为什么android中使用的修复java代码在计算梯度法时出错

这是我正在编写的代码。我在android studio平台上使用了一个java代码来插入图像，其中inpaint意味着在不影响背景的情况下删除图像中的选定区域。我编辑了其他行，使它们没有错误。只有一个错误仍然存在，即CalculateGraient方法中，甚至在开始时的GradientCalculator数据类型gc中。请帮忙

import android.graphics.Bitmap;
import android.graphics.Color;

/*     */ import java.io.PrintStream;
/*     */ import java.util.Vector;
/*     */ 
/*     */ public class ImageInpaint
/*     */ {
/*     */   Bitmap origImg;
/*     */   Bitmap fillImg;
/*     */   Bitmap img;
/*     */   int iw;
/*     */   int ih;
/*     */   int[] pixels;
/*     */   int[][] pixelmap;
/*     */   int[][] fillPixelmap;
/*     */   int[][] sourceRegion;
/*     */   int[][] initialSourceRegion;
/*     */   double[][] fillRegion;
/*     */   double[][] gradientX;
/*     */   double[][] gradientY;
/*     */   double[][] confidence;
/*     */   double[][] data;
/*  57 */   double omega = 0.7D;
/*  58 */   double Alpha = 0.2D;
/*  59 */   double Beta = 0.8D;
/*     */   int maxX;
/*     */   int maxY;
/*     */   int minX;
/*     */   int minY;
/*  64 */   int continuousCol = 0;
/*  65 */   int continuousRow = 0;
/*     */   GradientCalculator gc;
/*  67 */   public Boolean halt = Boolean.valueOf(false);
/*  68 */   public Boolean completed = Boolean.valueOf(false);
/*  69 */   final int diamX = 50;
/*  70 */   final int diamY = 30;
/*     */   private int pixelPosX;
/*     */   private int pixelPosY;
/*  73 */   int i,w = 3;
/*  74 */   double[][] con = { { 1.0D, 1.0D, 1.0D }, { 1.0D, -8.0D, 1.0D }, { 1.0D, 1.0D, 1.0D } };

/*     */   
/*     */   public void init(Bitmap a_origImg, Bitmap a_fillImg, Boolean quickInpaint)
/*     */   {
/*  93 */     this.halt = Boolean.valueOf(false);
/*     */
/* 145 */     initialize_confidence_term();
/* 146 */     initialize_data_term();
/*     */     
/* 148 */     this.fillRegion = new double[this.ih][this.iw];
/* 149 */     this.sourceRegion = new int[this.ih][this.iw];
/* 150 */     this.initialSourceRegion = new int[this.ih][this.iw];
/*     */     
/*     */ 
/*     */ 
/*     */ 
/* 155 */     this.minX = this.iw;
/* 156 */     this.minY = this.ih;
/* 157 */     this.maxX = (this.maxY = 0);
/*     */     
/*     */ 
/* 160 */     this.continuousRow = (this.continuousCol = 0);
/* 161 */     for (int i = 0; i < this.ih; i++)
/*     */     {
/* 162 */       int countrow = 0;
/* 163 */       for (int j = 0; j < this.iw; j++)
/*     */       {
/* 164 */         int pixel = this.fillPixelmap[i][j];
/* 165 */         int r = 0xFF & pixel >> 16;
/* 166 */         int g = 0xFF & pixel >> 8;
/* 167 */         int b = 0xFF & pixel;
/* 172 */         if ((r == 0) && (g == 255) && (b == 0))
/*     */         {
/* 173 */           countrow++;
/* 174 */           this.fillRegion[i][j] = 1.0D;
/* 175 */           this.sourceRegion[i][j] = 0;
/* 176 */           this.initialSourceRegion[i][j] = 0;
/* 177 */           if (j < this.minX) {
/* 178 */             this.minX = j;
/*     */           }
/* 180 */           if (i < this.minY) {
/* 181 */             this.minY = i;
/*     */           }
/* 183 */           if (j > this.maxX) {
/* 184 */             this.maxX = j;
/*     */           }
/* 186 */           if (i > this.maxY) {
/* 187 */             this.maxY = i;
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 190 */           if (countrow > this.continuousRow) {
/* 191 */             this.continuousRow = countrow;
/*     */           }
/* 193 */           countrow = 0;
/* 194 */           this.fillRegion[i][j] = 0.0D;
/* 195 */           this.sourceRegion[i][j] = 1;
/* 196 */           this.initialSourceRegion[i][j] = 1;
/*     */         }
/*     */       }
/*     */     }
/* 201 */     for (int i = 0; i < this.iw; i++)
/*     */     {
/* 202 */       int countcol = 0;
/* 203 */       for (int j = 0; j < this.ih; j++)
/*     */       {
/* 204 */         int pixel = this.fillPixelmap[j][i];
/* 205 */         int r = 0xFF & pixel >> 16;
/* 206 */         int g = 0xFF & pixel >> 8;
/* 207 */         int b = 0xFF & pixel;
/* 211 */         if ((r == 0) && (g == 255) && (b == 0))
/*     */         {
/* 212 */           countcol++;
/*     */         }
/*     */         else
/*     */         {
/* 214 */           if (countcol > this.continuousCol) {
/* 215 */             this.continuousCol = countcol;
/*     */           }
/* 217 */           countcol = 0;
/*     */         }
/*     */       }
/*     */     }
/* 225 */     Boolean flag = Boolean.valueOf(true);
/*     */     
/* 227 */     double[][] temp = new double[this.ih][this.iw];
/* 228 */     double[][] sourceGradX = new double[this.ih][this.iw];
/* 229 */     double[][] sourceGradY = new double[this.ih][this.iw];
/*     */     
/* 231 */     Vector dR = new Vector();
/* 232 */     Vector Nx = new Vector();
/* 233 */     Vector Ny = new Vector();
/* 239 */     while (flag.booleanValue())
/*     */     {
/* 244 */       temp = conv2(this.fillRegion, this.con);
/*     */       
/*     */ 
/*     */ 
/*     */ 
/* 249 */       this.gc.calculateGradient(this.sourceRegion, this.ih, this.iw);
/* 250 */       sourceGradX = this.gc.gradientX;
/* 251 */       sourceGradY = this.gc.gradientY;
/*     */       
/* 253 */       dR.clear();
/* 254 */       Nx.clear();
/* 255 */       Ny.clear();
/* 260 */       for (i = 0; i < temp[0].length; i++) {
/* 261 */         for (int j = 0; j < temp.length; j++) {
/* 262 */           if (temp[j][i] > 0.0D)
/*     */           {
/* 263 */             dR.add(Integer.valueOf(i * temp.length + j));
/* 264 */             Nx.add(Double.valueOf(sourceGradX[j][i]));
/* 265 */             Ny.add(Double.valueOf(sourceGradY[j][i]));
/*     */           }
/*     */         }
/*     */       }
/* 270 */       double[][] N = normr(Nx, Ny);
/*     */       
/* 272 */       Vector q = new Vector();
/* 273 */       double count = 0.0D;
/* 278 */       for (int i = 0; i < dR.size(); i++)
/*     */       {
/* 279 */         int[][] Hp = getpatch(this.pixelmap, ((Integer)dR.get(i)).intValue());
/* 280 */         for (int j = 0; j < Hp.length; j++) {
/* 281 */           for (int k = 0; k < Hp[0].length; k++)
/*     */           {
/* 282 */             int col = Hp[j][k] / this.ih;
/* 283 */             int row = Hp[j][k] % this.ih;
/* 284 */             if (this.fillRegion[row][col] == 0.0D)
/*     */             {
/* 285 */               count += this.confidence[row][col];
/* 286 */               q.add(Integer.valueOf(Hp[j][k]));
/*     */             }
/*     */           }
/*     */         }
/* 291 */         int col = ((Integer)dR.get(i)).intValue() / this.ih;
/* 292 */         int row = ((Integer)dR.get(i)).intValue() % this.ih;
/* 293 */         this.confidence[row][col] = (count / (Hp.length * Hp[0].length));
/* 294 */         count = 0.0D;
/*     */       }
/* 297 */       double maxPriority = 0.0D;
/* 298 */       int maxPriorityIndex = -1;
/* 303 */       for (int i = 0; i < dR.size(); i++)
/*     */       {
/* 304 */         int col = ((Integer)dR.get(i)).intValue() / this.ih;
/* 305 */         int row = ((Integer)dR.get(i)).intValue() % this.ih;
/*     */         
/*     */ 
/*     */ 
/*     */ 
/* 310 */         this.data[row][col] = (Math.abs(this.gradientX[row][col] * N[i][0] + this.gradientY[row][col] * N[i][1]) + 0.001D);
/*     */         
/*     */ 
/*     */ 
/*     */ 
/* 315 */         double Rcp = (1.0D - this.omega) * this.confidence[row][col] + this.omega;
/*     */         
/* 317 */         double tempPriority = this.Alpha * Rcp + this.Beta * this.data[row][col];
/* 322 */         if (tempPriority >= maxPriority)
/*     */         {
/* 323 */           maxPriority = tempPriority;
/* 324 */           maxPriorityIndex = i;
/*     */         }
/*     */       }
/* 328 */       if (maxPriorityIndex == -1) {
/*     */         break;
/*     */       }
/* 336 */       int[][] Hp = getpatch(this.pixelmap, ((Integer)dR.get(maxPriorityIndex)).intValue());
/* 337 */       double[][] toFill = new double[Hp.length][Hp[0].length];
/* 338 */       double[][] toFillTrans = new double[Hp[0].length][Hp.length];
/* 343 */       for (int i = 0; i < Hp.length; i++) {
/* 344 */         for (int j = 0; j < Hp[0].length; j++)
/*     */         {
/* 345 */           int col = Hp[i][j] / this.ih;
/* 346 */           int row = Hp[i][j] % this.ih;
/* 347 */           toFill[i][j] = this.fillRegion[row][col];
/* 348 */           toFillTrans[j][i] = this.fillRegion[row][col];
/*     */         }
/*     */       }
/* 352 */       this.pixelPosX = (((Integer)dR.get(maxPriorityIndex)).intValue() / this.ih);
/* 353 */       this.pixelPosY = (((Integer)dR.get(maxPriorityIndex)).intValue() % this.ih);
/*     */       
/*     */ 
/*     */ 
/*     */ 
/* 358 */       int[] best = bestExemplar(Hp, toFillTrans, this.initialSourceRegion, quickInpaint);
/*     */       
/* 360 */       int nRows = best[3] - best[2] + 1;
/* 361 */       int nCols = best[1] - best[0] + 1;
/*     */       
/*     */ 
/*     */ 
/*     */ 
/* 366 */       int[][] X = new int[nRows][nCols];
/* 367 */       int[][] Y = new int[nRows][nCols];
/* 368 */       int[][] Hq = new int[nRows][nCols];
/* 369 */       for (int i = 0; i < nRows; i++) {
/* 370 */         for (int j = 0; j < nCols; j++)
/*     */         {
/* 371 */           X[i][j] = (best[0] + j);
/* 372 */           Y[i][j] = (best[2] + i);
/* 373 */           X[i][j] += Y[i][j] * this.ih;
/*     */         }
/*     */       }
/* 377 */       int p = ((Integer)dR.get(maxPriorityIndex)).intValue();
/* 382 */       for (int i = 0; i < toFill.length; i++) {
/* 383 */         for (int j = 0; j < toFill[0].length; j++) {
/* 384 */           if (toFill[i][j] != 0.0D)
/*     */           {
/* 385 */             toFill[i][j] = 1.0D;
/* 386 */             int col = Hp[i][j] / this.ih;
/* 387 */             int row = Hp[i][j] % this.ih;
/*     */             
/* 389 */             int col1 = Hq[i][j] / this.ih;
/* 390 */             int row1 = Hq[i][j] % this.ih;
/*     */             
/* 392 */             this.fillRegion[row][col] = 0.0D;
/* 393 */             this.sourceRegion[row][col] = 1;
/*     */             
/*     */ 
/* 396 */             this.confidence[row][col] = this.confidence[(p % this.ih)][(p / this.ih)];
/* 397 */             this.gradientX[row][col] = this.gradientX[row1][col1];
/* 398 */             this.gradientY[row][col] = this.gradientY[row1][col1];
/* 399 */             this.pixelmap[row][col] = this.pixelmap[row1][col1];
/*     */             
/*     */ 
/*     */ 
/*     */ 
/* 404 */             int[] color = new int[3];
/* 405 */             color[0] = (0xFF & this.pixelmap[row1][col1] >> 16);
/* 406 */             color[1] = (0xFF & this.pixelmap[row1][col1] >> 8);
/* 407 */             color[2] = (0xFF & this.pixelmap[row1][col1]);
                      int rgb= Color.rgb(color[0],color[1],color[2]);
/* 408 */             this.origImg.setPixel(col, row, rgb);
/*     */           }
/*     */         }
/*     */       }
/* 413 */       if (this.halt.booleanValue()) {
/*     */         break;
/*     */       }
/* 415 */       Thread.yield();
/*     */       
/*     */ 
/*     */ 
/*     */ 
/* 420 */       flag = Boolean.valueOf(false);
/* 421 */       for (int i = 0; i < this.fillRegion.length; i++)
/*     */       {
/* 422 */         for (int j = 0; j < this.fillRegion[0].length; j++) {
/* 423 */           if (this.fillRegion[i][j] == 1.0D)
/*     */           {
/* 424 */             flag = Boolean.valueOf(true);
/* 425 */             break;
/*     */           }
/*     */         }
/* 428 */         if (flag.booleanValue()) {
/*     */           break;
/*     */         }
/*     */       }
/* 431 */       if (this.halt.booleanValue()) {
/*     */         break;
/*     */       }
/*     */     }
/* 437 */     this.gc = null;
/* 438 */     if (!this.halt.booleanValue()) {
/* 439 */       this.completed = Boolean.valueOf(true);
/*     */     } else {
/* 441 */       this.completed = Boolean.valueOf(false);
/*     */     }
/* 443 */     this.origImg.updateStats(this.origImg);
/* 444 */     Thread.yield();
/*     */   }
/*     */   
/*     */   void initialize_confidence_term()
/*     */   {
/* 452 */     this.confidence = new double[this.ih][this.iw];
/* 453 */     for (int i = 0; i < this.ih; i++) {
/* 454 */       for (int j = 0; j < this.iw; j++)
/*     */       {
/* 455 */         int p = this.pixelmap[i][j];
/* 456 */         int r = 0xFF & p >> 16;
/* 457 */         int g = 0xFF & p >> 8;
/* 458 */         int b = 0xFF & p;
/* 459 */         if ((r == 0) && (g == 255) && (b == 0)) {
/* 460 */           this.confidence[i][j] = 0.0D;
/*     */         } else {
/* 462 */           this.confidence[i][j] = 1.0D;
/*     */         }
/*     */       }
/*     */     }
/*     */   }
/*     */   
/*     */   void initialize_data_term()
/*     */   {
/* 473 */     this.data = new double[this.ih][this.iw];
/* 474 */     for (int i = 0; i < this.ih; i++) {
/* 475 */       for (int j = 0; j < this.iw; j++) {
/* 476 */         this.data[i][j] = -0.1D;
/*     */       }
/*     */     }
/*     */   }
/*     */   
/*     */   double[][] conv2(double[][] a, double[][] b)
/*     */   {
/* 489 */     int ra = a.length;
/* 490 */     int ca = a[0].length;
/* 491 */     int rb = b.length;
/* 492 */     int cb = b[0].length;
/*     */     
/*     */ 
/* 495 */     double[][] c = new double[ra + rb - 1][ca + cb - 1];
/* 496 */     for (int i = 0; i < rb; i++) {
/* 497 */       for (int j = 0; j < cb; j++)
/*     */       {
/* 498 */         int r1 = i;
/* 499 */         int r2 = r1 + ra - 1;
/* 500 */         int c1 = j;
/* 501 */         int c2 = c1 + ca - 1;
/* 502 */         for (int k = r1; k < r2; k++) {
/* 503 */           for (int l = c1; l < c2; l++) {
/* 504 */             c[k][l] += b[i][j] * a[(k - r1 + 1)][(l - c1 + 1)];
/*     */           }
/*     */         }
/*     */       }
/*     */     }
/* 510 */     double[][] out = new double[ra][ca];
/*     */     
/* 512 */     int r1 = rb / 2;
/* 513 */     int r2 = r1 + ra - 1;
/* 514 */     int c1 = cb / 2;
/* 515 */     int c2 = c1 + ca - 1;
/* 516 */     for (int i = r1; i < r2; i++) {
/* 517 */       for (int j = c1; j < c2; j++) {
/* 518 */         out[(i - r1 + 1)][(j - c1 + 1)] = c[i][j];
/*     */       }
/*     */     }
/* 521 */     return out;
/*     */   }
/*     */   
/*     */   double[][] normr(Vector X, Vector Y)
/*     */   {
/* 533 */     double[][] normalized = new double[X.size()][2];
/* 534 */     for (int i = 0; i < X.size(); i++)
/*     */     {
/* 535 */       double temp1 = ((Double)X.get(i)).doubleValue();
/* 536 */       double temp2 = ((Double)Y.get(i)).doubleValue();
/*     */       
/* 538 */       temp1 *= temp1;
/* 539 */       temp2 *= temp2;
/*     */       double temp3;
/* 543 */       if (temp1 + temp2 == 0.0D)
/*     */       {
/* 544 */         temp3 = 0.0D;
/*     */       }
/*     */       else
/*     */       {
/* 546 */         temp3 = 1.0D / (temp1 + temp2);
/* 547 */         temp3 = Math.sqrt(temp3);
/*     */       }
/* 550 */       normalized[i][0] = (temp3 * ((Double)X.get(i)).doubleValue());
/* 551 */       normalized[i][1] = (temp3 * ((Double)Y.get(i)).doubleValue());
/*     */     }
/* 554 */     return normalized;
/*     */   }
/*     */   
/*     */   int[][] getpatch(int[][] pixelmap, int p)
/*     */   {
/* 570 */     p -= 1;
/* 571 */     int y = p / this.ih;
/* 572 */     p %= this.ih;
/* 573 */     int x = p + 1;
/*     */     
/* 575 */     int temp1 = Math.max(x - this.w, 0);
/* 576 */     int temp2 = Math.min(x + this.w, this.ih - 1);
/* 577 */     int temp3 = Math.max(y - this.w, 0);
/* 578 */     int temp4 = Math.min(y + this.w, this.iw - 1);
/*     */     
/*     */ 
/*     */ 
/* 582 */     int[][] N = new int[temp4 - temp3 + 1][temp2 - temp1 + 1];
/* 584 */     for (int i = 0; i < temp4 - temp3 + 1; i++) {
/* 585 */       for (int j = 0; j < temp2 - temp1 + 1; j++) {
/* 588 */         N[i][j] = (temp1 + j + (temp3 + i) * this.ih);
/*     */       }
/*     */     }
/* 591 */     return N;
/*     */   }
/*     */   
/*     */   int[] bestExemplar(int[][] Hp, double[][] toFill, int[][] sourceRegion, Boolean quickInpaint)
/*     */   {
/* 606 */     int[][] Ip = new int[toFill.length][toFill[0].length];
/* 607 */     for (int i = 0; i < toFill[0].length; i++) {
/* 608 */       for (int j = 0; j < toFill.length; j++)
/*     */       {
/* 609 */         int col = Hp[i][j] / this.ih;
/* 610 */         int row = Hp[i][j] % this.ih;
/* 611 */         Ip[j][i] = this.pixelmap[row][col];
/*     */       }
/*     */     }
/* 615 */     int[][] rIp = new int[Ip.length][Ip[0].length];
/* 616 */     int[][] gIp = new int[Ip.length][Ip[0].length];
/* 617 */     int[][] bIp = new int[Ip.length][Ip[0].length];
/* 619 */     for (int i = 0; i < Ip.length; i++) {
/* 620 */       for (int j = 0; j < Ip[0].length; j++)
/*     */       {
/* 624 */         rIp[i][j] = (0xFF & Ip[i][j] >> 16);
/* 625 */         gIp[i][j] = (0xFF & Ip[i][j] >> 8);
/* 626 */         bIp[i][j] = (0xFF & Ip[i][j]);
/*     */       }
/*     */     }
/* 635 */     int m = Ip.length;
/* 636 */     int n = Ip[0].length;
/*     */     int nn;
/*     */     int mm;
/*     */     int startX;
/*     */     int startY;
/*     */     int endX;
              int endY;
/* 637 */     if (quickInpaint.booleanValue())
/*     */     {
/* 639 */       startX = Math.max(0, this.pixelPosX - n / 2 - this.continuousRow - 25);
/* 640 */       startY = Math.max(0, this.pixelPosY - m / 2 - this.continuousCol - 15);
/* 641 */       endX = Math.min(this.pixelmap[0].length - 1, this.pixelPosX + n / 2 + this.continuousRow + 25);
/* 642 */       endY = Math.min(this.pixelmap.length - 1, this.pixelPosY + m / 2 + this.continuousCol + 15);
/* 643 */       mm = endY - startY + 1;
/* 644 */       nn = endX - startX + 1;
/*     */     }
/*     */     else
/*     */     {
/* 646 */       mm = this.pixelmap.length;
/* 647 */       nn = this.pixelmap[0].length;
/* 648 */       startX = 0;
/* 649 */       startY = 0;
/* 650 */       endX = endY = 0;
/*     */     }
/* 653 */     double patchErr = 0.0D;double err = 0.0D;double bestErr = 1.0E+020D;double bestPatchErr1 = 1.0E+020D;
/* 654 */     int[] best = { 0, 0, 0, 0 };
/* 655 */     Boolean skipPatchFlag = Boolean.valueOf(false);
/*     */     
/*     */ 
/* 658 */     int N = startX + nn - n + 1;int M = startY + mm - m + 1;
/* 659 */     for (int j = startX; j < N; j++)
/*     */     {
/* 660 */       int J = j + n - 1;
/* 661 */       for (int i = startY; i < M; i++)
/*     */       {
/* 662 */         int I = i + m - 1;
/*     */         
/* 664 */         skipPatchFlag = Boolean.valueOf(false);
/*     */         
/* 666 */         double meanR = 0.0D;
/* 667 */         double meanG = 0.0D;
/* 668 */         double meanB = 0.0D;
/*     */         
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/* 674 */         int jj = j;
/* 674 */         for (int jj2 = 0; jj <= J; jj2++)
/*     */         {
/* 675 */           int ii = i;
/* 675 */           for (int ii2 = 0; ii <= I; ii2++)
/*     */           {
/* 680 */             if (sourceRegion[ii][jj] != 1)
/*     */             {
/* 681 */               skipPatchFlag = Boolean.valueOf(true);
/* 682 */               break;
/*     */             }
/* 684 */             if (toFill[ii2][jj2] == 0.0D)
/*     */             {
/* 685 */               int rImage = 0xFF & this.pixelmap[ii][jj] >> 16;
/* 686 */               int gImage = 0xFF & this.pixelmap[ii][jj] >> 8;
/* 687 */               int bImage = 0xFF & this.pixelmap[ii][jj];
/*     */               
/*     */ 
/*     */ 
/*     */ 
/* 692 */               err = rImage - rIp[ii2][jj2];patchErr += err * err;
/* 693 */               err = gImage - gIp[ii2][jj2];patchErr += err * err;
/* 694 */               err = bImage - bIp[ii2][jj2];patchErr += err * err;
/*     */               
/*     */ 
/*     */ 
/* 698 */               meanR += rImage;
/* 699 */               meanG += gImage;
/* 700 */               meanB += bImage;
/*     */             }
/* 675 */             ii++;
/*     */           }
/* 703 */           if (skipPatchFlag.booleanValue()) {
/*     */             break;
/*     */           }
/* 674 */           jj++;
/*     */         }
/* 711 */         if ((!skipPatchFlag.booleanValue()) && (patchErr < bestErr))
/*     */         {
/* 712 */           bestErr = patchErr;
/* 713 */           best[0] = i;best[1] = I;
/* 714 */           best[2] = j;best[3] = J;
/*     */           
/*     */ 
/*     */ 
/*     */ 
/* 719 */           double patchErr1 = 0.0D;
/* 720 */           jj = j;
/* 720 */           for (int jj2 = 0; jj <= J; jj2++)
/*     */           {
/* 721 */             int ii = i;
/* 721 */             for (int ii2 = 0; ii <= I; ii2++)
/*     */             {
/* 722 */               if (toFill[ii2][jj2] == 1.0D)
/*     */               {
/* 723 */                 int rImage = 0xFF & this.pixelmap[ii][jj] >> 16;
/* 724 */                 int gImage = 0xFF & this.pixelmap[ii][jj] >> 8;
/* 725 */                 int bImage = 0xFF & this.pixelmap[ii][jj];
/*     */                 
/* 727 */                 err = rImage - meanR;patchErr1 += err * err;
/* 728 */                 err = gImage - meanG;patchErr1 += err * err;
/* 729 */                 err = bImage - meanB;patchErr1 += err * err;
/*     */               }
/* 721 */               ii++;
/*     */             }
/* 720 */             jj++;
/*     */           }
/* 733 */           bestPatchErr1 = patchErr1;
/*     */         }
/* 734 */         else if ((!skipPatchFlag.booleanValue()) && (patchErr == bestErr))
/*     */         {
/* 740 */           double patchErr1 = 0.0D;
/* 741 */           jj = j;
/* 741 */           for (int jj2 = 0; jj <= J; jj2++)
/*     */           {
/* 742 */             int ii = i;
/* 742 */             for (int ii2 = 0; ii <= I; ii2++)
/*     */             {
/* 743 */               if (toFill[ii2][jj2] == 1.0D)
/*     */               {
/* 744 */                 int rImage = 0xFF & this.pixelmap[ii][jj] >> 16;
/* 745 */                 int gImage = 0xFF & this.pixelmap[ii][jj] >> 8;
/* 746 */                 int bImage = 0xFF & this.pixelmap[ii][jj];
/*     */                 
/* 748 */                 err = rImage - meanR;patchErr1 += err * err;
/* 749 */                 err = gImage - meanG;patchErr1 += err * err;
/* 750 */                 err = bImage - meanB;patchErr1 += err * err;
/*     */               }
/* 742 */               ii++;
/*     */             }
/* 741 */             jj++;
/*     */           }
/* 758 */           if (bestPatchErr1 > patchErr1)
/*     */           {
/* 759 */             best[0] = i;best[1] = I;
/* 760 */             best[2] = j;best[3] = J;
/* 761 */             bestPatchErr1 = patchErr1;
/*     */           }
/*     */         }
/* 765 */         patchErr = 0.0D;
/*     */       }
/*     */     }
/* 769 */     if ((best[0] == 0) && (best[1] == 0) && (best[2] == 0) && (best[3] == 0)) {
/* 770 */       return bestExemplar(Hp, toFill, sourceRegion, Boolean.valueOf(false));
/*     */     }
/* 772 */     return best;
/*     */   }
/*     */ }

---

只有一个错误仍然存在，即CalculateGraient方法中，甚至在开始时的GradientCalculator数据类型gc中。。。该错误是？无法解析方法CalculateGradent[][]int int int，无法解析符号gradientX和Gradienty因此您声明了GradientCalculator对象，但我看不到导入some.package.GradientCalculator；或者在代码中使用私有类GradientCalculator{…}。那么java如何知道GradientCalculator是什么呢？是的，我正在使用import-inpaintutils.GradientCalculator语句；但这也显示了错误，并在android studio中变红。所以它没有意识到这一点。什么应该是正确的进口！你有解决办法吗？