is there is a possible way to convert this java code into matlab 2013

package inpaint;

import imageselection.Main; import inpaintutils.GradientCalculator;

import java.awt.Image; import java.awt.image.BufferedImage; import java.awt.image.PixelGrabber; import java.awt.image.WritableRaster; import java.util.Vector;

/** * Class to Inpaint the given Image. Call Function init with original image, fillImage and quickPaint as arguments * * @author Sapan & Pulkit */ public class ImageInpaint { BufferedImage origImg; // BufferedImage Object to represent updated image at every step Image fillImg; // Image Object to represent Image with target region marked BufferedImage img; // BufferedImage Object to represent original Image WritableRaster raster; // Raster to write to the image int iw, ih; // iw: Width of Image, ih: Height of Image int pixels[]; // Temporary array that will initially store the grabbed pixels int pixelmap[][]; // Matrix to store the pixels of original image int fillPixelmap[][]; // Matrix to store the pixels of image marked with target region int sourceRegion[][]; // Matrix to store Boolean values for Source Region (is updated after each iteration) int initialSourceRegion[][]; // Matrix to store Boolean values for Initial Source Region double fillRegion[][]; // Matrix to store Boolean values for Target Region double gradientX[][]; // Matrix to represent the perpendicular Gradient at each point in X direction double gradientY[][]; // Matrix to represent the perpendicular Gradient at each point in Y direction double confidence[][]; // Matrix that stores the Confidence values for each pixel double data[][]; // Matrix to store the data terms for each pixel GradientCalculator gc; // Object of GradientCalculator class used to calculate gradient double omega = 0.7; // Represents the omega used in confidence term double Alpha = 0.2; // Represents the multiplier for confidence term in calculating priority double Beta = 0.8; // Represents the multiplier for data term in calculating priority int maxX; // The maximum X coordinate of the target region int maxY; // The maximum Y coordinate of the target region int minX; // The minimum X coordinate of the target region int minY; // The minimum Y coordinate of the target region int continuousCol = 0; // The maximum number of continuous green pixels in one column int continuousRow = 0; // The maximum number of continuous green pixels in one row protected Main owner; // Object to the Main Class. Used in passing updates after every iteration public Boolean halt = false; // Used to stop inpainting. public Boolean completed = false; // Used to report when the inpainting is complete. final int diamX = 50; // Diameter (in X direction) of the Region to be searched for final int diamY = 30; // Diameter (in Y direction) of the Region to be searched for private int pixelPosX; // The X-coordinate of current pixel being processed private int pixelPosY; // The Y-coordinate of current pixel being processed int w = 3; // Patch size is 2*w + 1 double con[][] = new double[][] { { 1, 1, 1 }, { 1, -8, 1 }, { 1, 1, 1 } }; // Laplacian filter used in founding // boundary of target region

/** * Constructor for the ImageInpaint Class * * @param owner * Object to the Main class representing the owner of ImageInpaint object. */ public ImageInpaint(Main owner) { this.owner = owner; }

/** * Function to inpaint the given image. * * @param a_origImg * Original Image (without the target region marked) * @param a_fillImg * Image with the target region marked in green color * @param quickInpaint * Flag to specify whether quick painting is enabled or not */ @SuppressWarnings("unchecked") public void init(BufferedImage a_origImg, BufferedImage a_fillImg, Boolean quickInpaint) { halt = false; int i, j; try { origImg = a_origImg; img = a_origImg; fillImg = a_fillImg; raster = origImg.getRaster();

iw = img.getWidth(null); ih = img.getHeight(null);

/** * Grab the pixels of Original Image. */ pixels = new int[iw * ih]; PixelGrabber pg = new PixelGrabber(img, 0, 0, iw, ih, pixels, 0, iw); pg.grabPixels(); pixelmap = new int[ih][iw];

for (i = 0; i < ih; i++) { for (j = 0; j < iw; j++) { pixelmap[i][j] = pixels[i * iw + j]; } }

/** * Grab the pixels of Fill Image. */ PixelGrabber fillPg = new PixelGrabber(fillImg, 0, 0, iw, ih, pixels, 0, iw); fillPg.grabPixels(); fillPixelmap = new int[ih][iw];

for (i = 0; i < ih; i++) { for (j = 0; j < iw; j++) { fillPixelmap[i][j] = pixels[i * iw + j]; } }

} catch (InterruptedException e1) { javax.swing.JOptionPane.showMessageDialog(owner, "Error " + e1, "Error!!", javax.swing.JOptionPane.ERROR_MESSAGE); System.out.println("Error " + e1); }

/** * Create instance of GradientCalculator to calculate gradients. */ gc = new GradientCalculator(); gc.calculateGradientFromImage(pixelmap, ih, iw); // Calculate Perpendicular Gradient for original image. gradientX = gc.gradientX; gradientY = gc.gradientY;

initialize_confidence_term(); // Initialize the confidence term initialize_data_term(); // Initialize the data term

fillRegion = new double[ih][iw]; // Allocate Space for fillRegion sourceRegion = new int[ih][iw]; // Allocate Space for SourceRegion initialSourceRegion = new int[ih][iw]; // Allocate Space for initialSourceRegion

/** * Initialize minX, minY, maxX and maxY to find these coordinates */ minX = iw; minY = ih; maxX = maxY = 0;

int pixel, r, g, b, countrow, countcol; continuousRow = continuousCol = 0; for (i = 0; i < ih; i++) { countrow = 0; for (j = 0; j < iw; j++) { pixel = fillPixelmap[i][j]; r = 0xff & pixel >> 16; // Obtain the red Component g = 0xff & pixel >> 8; // Obtain the green Component b = 0xff & pixel; // Obtain the blue Component /** * If the color is green, mark it as fillRegion Otherwise mark it as SourceRegion. */ if (r == 0 && g == 255 && b == 0) { countrow++; // Increase the number of continuous green pixels fillRegion[i][j] = 1; sourceRegion[i][j] = 0; initialSourceRegion[i][j] = 0; if (j < minX) { minX = j; } if (i < minY) { minY = i; } if (j > maxX) { maxX = j; } if (i > maxY) { maxY = i; } } else { if (countrow > continuousRow) { continuousRow = countrow; } countrow = 0; fillRegion[i][j] = 0; sourceRegion[i][j] = 1; initialSourceRegion[i][j] = 1; } } }

for (i = 0; i < iw; ++i) { countcol = 0; for (j = 0; j < ih; ++j) { pixel = fillPixelmap[j][i]; r = 0xff & pixel >> 16; // Obtain the red Component g = 0xff & pixel >> 8; // Obtain the green Component b = 0xff & pixel; // Obtain the blue Component /** * If pixel is green, increase the countcol by 1. */ if (r == 0 && g == 255 && b == 0) { countcol++; // Increase the number of continuous green pixels } else { if (countcol > continuousCol) { continuousCol = countcol; } countcol = 0; } } }

// System.out.println("Col = " + continuousCol); // System.out.println("Col = " + continuousRow);

Boolean flag = true; // Flag to represent the completion of the inpainting process

double[][] temp = new double[ih][iw]; double[][] sourceGradX = new double[ih][iw]; double[][] sourceGradY = new double[ih][iw];

Vector dR = new Vector(); // Vector to store pixels of the boundary Vector Nx = new Vector(); // Vector to store corresponding gradient in X direction Vector Ny = new Vector(); // Vector to store corresponding gradient in Y direction

double count; // Temporary variable used in calculating confidence terms for patches double Rcp; // Temporary variable used in calculating confidence terms for patches double tempPriority; // Temporary variable used in calculating maximum priority

while (flag) {

/** * Filter the fillRegion with Laplacian Filter. Done to find the pixels on the boundary. */ temp = conv2(fillRegion, con);

/** * Find the gradient of Source Region. */ gc.calculateGradient(sourceRegion, ih, iw); sourceGradX = gc.gradientX; sourceGradY = gc.gradientY;

dR.clear(); Nx.clear(); Ny.clear();

/** * Add the coordinates of boundary pixels to dR and their gradients to Nx and Ny. */ for (i = 0; i < temp[0].length; i++) { for (j = 0; j < temp.length; j++) { if (temp[j][i] > 0) { dR.add(i * temp.length + j); Nx.add(sourceGradX[j][i]); Ny.add(sourceGradY[j][i]); } } }

double[][] N = normr(Nx, Ny); // Normalize Nx and Ny and store in N

Vector q = new Vector(); count = 0.0;

/** * Now calculate Confidence Terms for all the pixels in the boundary of target region. */ for (i = 0; i < dR.size(); i++) { int[][] Hp = getpatch(pixelmap, (Integer) dR.get(i)); for (j = 0; j < Hp.length; j++) { for (int k = 0; k < Hp[0].length; k++) { int col = Hp[j][k] / ih; int row = Hp[j][k] % ih; if (fillRegion[row][col] == 0) { count += confidence[row][col]; q.add(Hp[j][k]); } } }

int col = (Integer) dR.get(i) / ih; int row = (Integer) dR.get(i) % ih; confidence[row][col] = count / (Hp.length * Hp[0].length); count = 0; }

double maxPriority = 0.0; int maxPriorityIndex = -1; /** * After calculating confidence terms, now calculate data term and then find the patch with maximum * priority. This is done using the additive priority term. */ for (i = 0; i < dR.size(); i++) { int col = (Integer) dR.get(i) / ih; int row = (Integer) dR.get(i) % ih;

/** * Calculate Data term. +0.001 to prevent it from getting value Zero. */ data[row][col] = Math.abs(gradientX[row][col] * N[i][0] + gradientY[row][col] * N[i][1]) + 0.001;

/** * Elevated Confidence term. This prevents it from reaching Zero to soon. */ Rcp = (1 - omega) * confidence[row][col] + omega;

tempPriority = Alpha * Rcp + Beta * data[row][col]; // Calculate Priority using additive function

/** * find the patch with maximum priority */ if (tempPriority >= maxPriority) { maxPriority = tempPriority; maxPriorityIndex = i; } }

if (maxPriorityIndex == -1) { break; // If no patch is found, then inpainting is complete. }

/** * Obtain the patch with maximum priority. * * @Hp: Coordinates of patch with maximum priority * @toFill: Represents which pixels (from the patch) are to be filled * @toFillTrans: Transpose of ToFill matrix */ int[][] Hp = getpatch(pixelmap, (Integer) dR.get(maxPriorityIndex)); double[][] toFill = new double[Hp.length][Hp[0].length]; double[][] toFillTrans = new double[Hp[0].length][Hp.length];

/** * Calculate ToFill and ToFillTrans */ for (i = 0; i < Hp.length; i++) { for (j = 0; j < Hp[0].length; j++) { int col = Hp[i][j] / ih; int row = Hp[i][j] % ih; toFill[i][j] = fillRegion[row][col]; toFillTrans[j][i] = fillRegion[row][col]; } }

pixelPosX = (Integer) dR.get(maxPriorityIndex) / ih; pixelPosY = (Integer) dR.get(maxPriorityIndex) % ih; /** * Find the Best Exemplar. if quickInpaint is set, then only a small region of complete image is scanned. We * now get the starting and ending X and Y coordinates of the best Patch. */ int[] best = bestExemplar(Hp, toFillTrans, initialSourceRegion, quickInpaint);

int nRows = best[3] - best[2] + 1; int nCols = best[1] - best[0] + 1;

/** * Find the patch represented by best. */ int[][] X = new int[nRows][nCols]; int[][] Y = new int[nRows][nCols]; int[][] Hq = new int[nRows][nCols]; for (i = 0; i < nRows; i++) { for (j = 0; j < nCols; j++) { X[i][j] = best[0] + j; Y[i][j] = best[2] + i; Hq[i][j] = X[i][j] + Y[i][j] * ih; } }

int p = (Integer) dR.get(maxPriorityIndex);

/** * Update the image, data values and confidence values. */ for (i = 0; i < toFill.length; i++) { for (j = 0; j < toFill[0].length; j++) { if (toFill[i][j] != 0) { toFill[i][j] = 1; int col = Hp[i][j] / ih; int row = Hp[i][j] % ih;

int col1 = Hq[i][j] / ih; int row1 = Hq[i][j] % ih;

fillRegion[row][col] = 0; // Since the region is reconstructed, remove from fillRegion sourceRegion[row][col] = 1; // Since the region is reconstructed, add to SourceRegion

/** Propagate Confidence and Isophote Values */ confidence[row][col] = confidence[p % ih][p / ih]; gradientX[row][col] = gradientX[row1][col1]; gradientY[row][col] = gradientY[row1][col1]; pixelmap[row][col] = pixelmap[row1][col1];

/** * Update the image pixels */ int[] color = new int[3]; color[0] = 0xff & pixelmap[row1][col1] >> 16; color[1] = 0xff & pixelmap[row1][col1] >> 8; color[2] = 0xff & pixelmap[row1][col1]; raster.setPixel(col, row, color); } } }

if (halt) { break; } owner.updateStats(origImg); // Inform the owner about the updated image. Thread.yield();

/** * Find whether any other pixels are remaining to be inpainted. */ flag = false; for (i = 0; i < fillRegion.length; ++i) { for (j = 0; j < fillRegion[0].length; ++j) { if (fillRegion[i][j] == 1) { flag = true; break; } } if (flag) { break; // If none of the pixels are in target region, break } }

if (halt) { break; // Stop Inpainting if owner halts the process. } } /** * No need of gradient calculator now. Mark it as null to drop a hint to garbageCollector that it can now be * removed. */ gc = null; if (!halt) { completed = true; } else { completed = false; } owner.updateStats(origImg); // Inform the owner about the updates. Thread.yield(); }

/** * Initializes the confidence term to zero for pixels in target region and 1 for pixels in source region. */ void initialize_confidence_term() { confidence = new double[ih][iw]; for (int i = 0; i < ih; i++) { for (int j = 0; j < iw; j++) { int p = pixelmap[i][j]; int r = 0xff & p >> 16; int g = 0xff & p >> 8; int b = 0xff & p; if (r == 0 && g == 255 && b == 0) { confidence[i][j] = 0; } else { confidence[i][j] = 1; } } } }

/** * Initialize the data term. */ void initialize_data_term() { data = new double[ih][iw]; for (int i = 0; i < ih; i++) { for (int j = 0; j < iw; j++) { data[i][j] = -0.1; } } }

/** * Function to convolve the given matrix with another matrix * * @param a * Matrix to be convolved * @param b * Matrix to be convolved with * @return The result after convolution. */ double[][] conv2(double a[][], double b[][]) { int ra = a.length; int ca = a[0].length; int rb = b.length; int cb = b[0].length;

// do full convolution double c[][] = new double[ra + rb - 1][ca + cb - 1]; for (int i = 0; i < rb; i++) { for (int j = 0; j < cb; j++) { int r1 = i; int r2 = r1 + ra - 1; int c1 = j; int c2 = c1 + ca - 1; for (int k = r1; k < r2; k++) { for (int l = c1; l < c2; l++) { c[k][l] = c[k][l] + b[i][j] * a[k - r1 + 1][l - c1 + 1]; } } } }

double out[][] = new double[ra][ca]; // extract region of size(a) from c int r1 = rb / 2; int r2 = r1 + ra - 1; int c1 = cb / 2; int c2 = c1 + ca - 1; for (int i = r1; i < r2; i++) { for (int j = c1; j < c2; j++) { out[i - r1 + 1][j - c1 + 1] = c[i][j]; } } return out; }

/** * Function to normalize the given vectors and return them concatenated in one single matrix * * @param X * Vector 1 * @param Y * Vector 2 * @return The result after normalizing and then concatenating the two vectors. */ @SuppressWarnings("unchecked") double[][] normr(Vector X, Vector Y) { double normalized[][] = new double[X.size()][2]; for (int i = 0; i < X.size(); i++) { double temp1 = (Double) X.get(i); double temp2 = (Double) Y.get(i);

temp1 *= temp1; temp2 *= temp2;

double temp3;

if (temp1 + temp2 == 0) { temp3 = 0; } else { temp3 = 1 / (temp1 + temp2); temp3 = Math.sqrt(temp3); }

normalized[i][0] = temp3 * (Double) X.get(i); normalized[i][1] = temp3 * (Double) Y.get(i); }

return normalized; }

/** * Function that returns the patch around the given pixel. * * @param pixelmap * Matrix representing the pixelmap of the image. * @param p * Position of the pixel around which patch is to be calculated * @return a matrix that contains the coordinates of the pixels that form the patch. */ @SuppressWarnings("unchecked") int[][] getpatch(int[][] pixelmap, int p) {

int y; int x;

p = p - 1; y = p / ih;// + 1; p = p % ih; x = p + 1;

int temp1 = Math.max(x - w, 0); // Starting X coordinate int temp2 = Math.min(x + w, ih - 1); // Ending X coordinate int temp3 = Math.max(y - w, 0); // Starting Y Coordinate int temp4 = Math.min(y + w, iw - 1); // Ending Y Coordinate

// int[][] X = new int[temp4-temp3+1][temp2-temp1+1]; // int[][] Y = new int[temp4-temp3+1][temp2-temp1+1]; int[][] N = new int[temp4 - temp3 + 1][temp2 - temp1 + 1];

for (int i = 0; i < temp4 - temp3 + 1; i++) { for (int j = 0; j < temp2 - temp1 + 1; j++) { // X[i][j] = temp1 + j; // Y[i][j] = temp3 + i; N[i][j] = temp1 + j + (temp3 + i) * ih; } } return N; }

/** * Function that finds the best exemplar from the image that matches the patch given to the fucntion. By default, it * finds the complete image to look for the best exemplar. But if quickInpaint is set, it only looks for the patch * inside a region defined by minX, maxX, minY, maxY, diamX and diamY * * @param Hp * Patch for which the best exemplar is to be found * @param toFill * Pixels that are to be filled from the patch. * @param sourceRegion * the source region from where to look for the best exemplar * @param quickInpaint * Flag that represents whether or not to perform quick Inpainting. * @return Returns an integer array with four elements representing starting x coordinate, ending x coordinate, * starting y coordinate and ending y coordinate respectively. */ int[] bestExemplar(int[][] Hp, double[][] toFill, int[][] sourceRegion, Boolean quickInpaint) { int[][] Ip = new int[toFill.length][toFill[0].length]; for (int i = 0; i < toFill[0].length; i++) { for (int j = 0; j < toFill.length; j++) { int col = Hp[i][j] / ih; int row = Hp[i][j] % ih; Ip[j][i] = pixelmap[row][col]; // transpose } }

int[][] rIp = new int[Ip.length][Ip[0].length]; int[][] gIp = new int[Ip.length][Ip[0].length]; int[][] bIp = new int[Ip.length][Ip[0].length];

for (int i = 0; i < Ip.length; ++i) { for (int j = 0; j < Ip[0].length; ++j) { /** * Extract the RGB components of the image. */ rIp[i][j] = 0xff & Ip[i][j] >> 16; gIp[i][j] = 0xff & Ip[i][j] >> 8; bIp[i][j] = 0xff & Ip[i][j]; } }

int mm, nn; int startX; int startY; int endX; int endY; int m = Ip.length; int n = Ip[0].length; if (quickInpaint) {

startX = Math.max(0, pixelPosX - n / 2 - continuousRow - diamX / 2); // Set the start X coordinate above the // pixel's X-coordinate by some // amount startY = Math.max(0, pixelPosY - m / 2 - continuousCol - diamY / 2); // Set the start Y coordinate above the // pixel's Y-coordinate by some // amount endX = Math.min(pixelmap[0].length - 1, pixelPosX + n / 2 + continuousRow + diamX / 2); endY = Math.min(pixelmap.length - 1, pixelPosY + m / 2 + continuousCol + diamY / 2); mm = endY - startY + 1; nn = endX - startX + 1; } else { mm = pixelmap.length; nn = pixelmap[0].length; startX = 0; startY = 0; endX = endY = 0; } int i, j, ii, jj, ii2, jj2, M, N, I, J; double patchErr = 0.0, err = 0.0, bestErr = 99999999999999999999.0, bestPatchErr1 = 99999999999999999999.0; int[] best = { 0, 0, 0, 0 }; Boolean skipPatchFlag = false;

/** for each patch */ N = startX + nn - n + 1; M = startY + mm - m + 1; for (j = startX; j < N; j++) { J = j + n - 1; for (i = startY; i < M; i++) { I = i + m - 1;

skipPatchFlag = false;

double meanR = 0.0; double meanG = 0.0; double meanB = 0.0;

/** * Calculate patch error */ for (jj = j, jj2 = 0; jj <= J; jj++, jj2++) { for (ii = i, ii2 = 0; ii <= I; ii++, ii2++) {

/** * If any pixels does not belong to the source region, then skip the patch. */ if (sourceRegion[ii][jj] != 1) { skipPatchFlag = true; break; } if (toFill[ii2][jj2] == 0) { int rImage = 0xff & pixelmap[ii][jj] >> 16; int gImage = 0xff & pixelmap[ii][jj] >> 8; int bImage = 0xff & pixelmap[ii][jj];

/** * Calculate the mean square error for the patch. / err = rImage - rIp[ii2][jj2]; patchErr += err * err; err = gImage - gIp[ii2][jj2]; patchErr += err * err; err = bImage - bIp[ii2][jj2]; patchErr += err * err; /* * Calculate the mean of the color values. Used when we get two patches with same best * error. */ meanR += rImage; meanG += gImage; meanB += bImage; } } if (skipPatchFlag) { break; } }

/** * Update */ if (!skipPatchFlag && patchErr < bestErr) { bestErr = patchErr; best[0] = i; best[1] = I; best[2] = j; best[3] = J;

/** * Calculate the variance of the patch. */ double patchErr1 = 0.0; for (jj = j, jj2 = 0; jj J; jj++, jj2++) { for (ii = i, ii2 = 0; ii <= I; ii++, ii2++) { if (toFill[ii2][jj2] == 1) { int rImage = 0xff & pixelmap[ii][jj] > 16; int gImage = 0xff & pixelmap[ii][jj] >> 8; int bImage = 0xff & pixelmap[ii][jj];

err = rImage - meanR; patchErr1 += err * err; err = gImage - meanG; patchErr1 += err * err; err = bImage - meanB; patchErr1 += err * err; } } } bestPatchErr1 = patchErr1; // Update the variance of the best patch found so far. } else if (!skipPatchFlag && patchErr == bestErr) { /** * If the current patch has same error as the previous best patch we find the variance of this * patch. The patch with minimum variance is now selected as the best patch. */ double patchErr1 = 0.0; for (jj = j, jj2 = 0; jj J; jj++, jj2++) { for (ii = i, ii2 = 0; ii <= I; ii++, ii2++) { if (toFill[ii2][jj2] == 1) { int rImage = 0xff & pixelmap[ii][jj] > 16; int gImage = 0xff & pixelmap[ii][jj] >> 8; int bImage = 0xff & pixelmap[ii][jj];

err = rImage - meanR; patchErr1 += err * err; err = gImage - meanG; patchErr1 += err * err; err = bImage - meanB; patchErr1 += err * err; } } } /** * Select the new patch if it has lower variance. Otherwise discard. */ if (bestPatchErr1 > patchErr1) { best[0] = i; best[1] = I; best[2] = j; best[3] = J; bestPatchErr1 = patchErr1; } }

patchErr = 0.0; } }

if (best[0] == 0 && best[1] == 0 && best[2] == 0 && best[3] == 0) { return bestExemplar(Hp, toFill, sourceRegion, false); } return best; } }

Answer 1

[Image Analyst]

Yes. MATLAB is a lot like Java and C so it shouldn't be too hard as long as you have all the source code. Just start doing it. Good luck.