Examples of javax.media.jai.iterator.RandomIter

javax.media.jai.iterator.RandomIter
An iterator that allows random read-only access to any sample within its bounding rectangle. This flexibility will generally exact a corresponding price in speed and setup overhead.
The iterator is initialized with a particular rectangle as its bounds, which it is illegal to exceed. This initialization takes place in a factory method and is not a part of the iterator interface itself.
The getSample(), getSampleFloat(), and getSampleDouble() methods are provided to allow read-only access to the source data. The getPixel() methods allow retrieval of all bands simultaneously.
An instance of RandomIter may be obtained by means of the RandomIterFactory.create() method, which returns an opaque object implementing this interface. @see WritableRandomIter @see RandomIterFactory

/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectInt(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 434 */     if (this.extender != null) {
/* 435 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */ 
/* 438 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 442 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */ 
/* 445 */     int minX = src.getMinX();
/* 446 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */ 
/* 448 */     int minY = src.getMinY();
/* 449 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */ 
/* 452 */     int dstWidth = dst.getWidth();
/* 453 */     int dstHeight = dst.getHeight();
/* 454 */     int dstBands = dst.getNumBands();
/*     */ 
/* 456 */     int lineStride = dst.getScanlineStride();
/* 457 */     int pixelStride = dst.getPixelStride();
/* 458 */     int[] bandOffsets = dst.getBandOffsets();
/* 459 */     int[][] data = dst.getIntDataArrays();
/*     */ 
/* 461 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 463 */     int lineOffset = 0;
/*     */ 
/* 465 */     int[] backgroundInt = new int[dstBands];
/* 466 */     for (int i = 0; i < dstBands; i++) {
/* 467 */       backgroundInt[i] = ((int)this.backgroundValues[i]);
/*     */     }
/* 469 */     for (int h = 0; h < dstHeight; h++) {
/* 470 */       int pixelOffset = lineOffset;
/* 471 */       lineOffset += lineStride;
/*     */ 
/* 473 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 475 */       int count = 0;
/* 476 */       for (int w = 0; w < dstWidth; w++) {
/* 477 */         float sx = warpData[(count++)];
/* 478 */         float sy = warpData[(count++)];
/*     */ 
/* 480 */         int xint = floor(sx);
/* 481 */         int yint = floor(sy);
/* 482 */         float xfrac = sx - xint;
/* 483 */         float yfrac = sy - yint;
/*     */ 
/* 485 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 488 */           if (this.setBackground) {
/* 489 */             for (int b = 0; b < dstBands; b++) {
/* 490 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundInt[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 495 */           for (int b = 0; b < dstBands; b++) {
/* 496 */             int s00 = iter.getSample(xint, yint, b);
/* 497 */             int s01 = iter.getSample(xint + 1, yint, b);
/* 498 */             int s10 = iter.getSample(xint, yint + 1, b);
/* 499 */             int s11 = iter.getSample(xint + 1, yint + 1, b);
/*     */ 
/* 501 */             float s0 = (s01 - s00) * xfrac + s00;
/* 502 */             float s1 = (s11 - s10) * xfrac + s10;
/* 503 */             float s = (s1 - s0) * yfrac + s0;
/*     */

View Full Code Here

/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectFloat(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 516 */     if (this.extender != null) {
/* 517 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */ 
/* 520 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 524 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */ 
/* 527 */     int minX = src.getMinX();
/* 528 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */ 
/* 530 */     int minY = src.getMinY();
/* 531 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */ 
/* 534 */     int dstWidth = dst.getWidth();
/* 535 */     int dstHeight = dst.getHeight();
/* 536 */     int dstBands = dst.getNumBands();
/*     */ 
/* 538 */     int lineStride = dst.getScanlineStride();
/* 539 */     int pixelStride = dst.getPixelStride();
/* 540 */     int[] bandOffsets = dst.getBandOffsets();
/* 541 */     float[][] data = dst.getFloatDataArrays();
/*     */ 
/* 543 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 545 */     int lineOffset = 0;
/*     */ 
/* 547 */     float[] backgroundFloat = new float[dstBands];
/* 548 */     for (int i = 0; i < dstBands; i++) {
/* 549 */       backgroundFloat[i] = ((float)this.backgroundValues[i]);
/*     */     }
/* 551 */     for (int h = 0; h < dstHeight; h++) {
/* 552 */       int pixelOffset = lineOffset;
/* 553 */       lineOffset += lineStride;
/*     */ 
/* 555 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 557 */       int count = 0;
/* 558 */       for (int w = 0; w < dstWidth; w++) {
/* 559 */         float sx = warpData[(count++)];
/* 560 */         float sy = warpData[(count++)];
/*     */ 
/* 562 */         int xint = floor(sx);
/* 563 */         int yint = floor(sy);
/* 564 */         float xfrac = sx - xint;
/* 565 */         float yfrac = sy - yint;
/*     */ 
/* 567 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 570 */           if (this.setBackground) {
/* 571 */             for (int b = 0; b < dstBands; b++) {
/* 572 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundFloat[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 577 */           for (int b = 0; b < dstBands; b++) {
/* 578 */             float s00 = iter.getSampleFloat(xint, yint, b);
/* 579 */             float s01 = iter.getSampleFloat(xint + 1, yint, b);
/* 580 */             float s10 = iter.getSampleFloat(xint, yint + 1, b);
/* 581 */             float s11 = iter.getSampleFloat(xint + 1, yint + 1, b);
/*     */ 
/* 583 */             float s0 = (s01 - s00) * xfrac + s00;
/* 584 */             float s1 = (s11 - s10) * xfrac + s10;
/* 585 */             float s = (s1 - s0) * yfrac + s0;
/*     */

View Full Code Here

/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectDouble(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 598 */     if (this.extender != null) {
/* 599 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */ 
/* 602 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 606 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */ 
/* 609 */     int minX = src.getMinX();
/* 610 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */ 
/* 612 */     int minY = src.getMinY();
/* 613 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */ 
/* 616 */     int dstWidth = dst.getWidth();
/* 617 */     int dstHeight = dst.getHeight();
/* 618 */     int dstBands = dst.getNumBands();
/*     */ 
/* 620 */     int lineStride = dst.getScanlineStride();
/* 621 */     int pixelStride = dst.getPixelStride();
/* 622 */     int[] bandOffsets = dst.getBandOffsets();
/* 623 */     double[][] data = dst.getDoubleDataArrays();
/*     */ 
/* 625 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 627 */     int lineOffset = 0;
/*     */ 
/* 629 */     for (int h = 0; h < dstHeight; h++) {
/* 630 */       int pixelOffset = lineOffset;
/* 631 */       lineOffset += lineStride;
/*     */ 
/* 633 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 635 */       int count = 0;
/* 636 */       for (int w = 0; w < dstWidth; w++) {
/* 637 */         float sx = warpData[(count++)];
/* 638 */         float sy = warpData[(count++)];
/*     */ 
/* 640 */         int xint = floor(sx);
/* 641 */         int yint = floor(sy);
/* 642 */         float xfrac = sx - xint;
/* 643 */         float yfrac = sy - yint;
/*     */ 
/* 645 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 648 */           if (this.setBackground) {
/* 649 */             for (int b = 0; b < dstBands; b++) {
/* 650 */               data[b][(pixelOffset + bandOffsets[b])] = this.backgroundValues[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 655 */           for (int b = 0; b < dstBands; b++) {
/* 656 */             double s00 = iter.getSampleDouble(xint, yint, b);
/* 657 */             double s01 = iter.getSampleDouble(xint + 1, yint, b);
/* 658 */             double s10 = iter.getSampleDouble(xint, yint + 1, b);
/* 659 */             double s11 = iter.getSampleDouble(xint + 1, yint + 1, b);
/*     */ 
/* 661 */             double s0 = (s01 - s00) * xfrac + s00;
/* 662 */             double s1 = (s11 - s10) * xfrac + s10;
/* 663 */             double s = (s1 - s0) * yfrac + s0;
/*     */

View Full Code Here

/* 170 */     Rectangle rect = source.getBounds();
/*     */ 
/* 172 */     if (this.roi != null) {
/* 173 */       rect = this.roi.getBounds();
/*     */     }
/* 175 */     RandomIter iterator = RandomIterFactory.create(source, rect);
/*     */ 
/* 177 */     int samplefac = this.xPeriod * this.yPeriod;
/* 178 */     int startX = rect.x / this.xPeriod;
/* 179 */     int startY = rect.y / this.yPeriod;
/* 180 */     int offsetX = rect.x % this.xPeriod;
/* 181 */     int offsetY = rect.y % this.yPeriod;
/* 182 */     int pixelsPerLine = (rect.width - 1) / this.xPeriod + 1;
/* 183 */     int numSamples = pixelsPerLine * ((rect.height - 1) / this.yPeriod + 1);
/*     */ 
/* 186 */     if (numSamples < 1509) {
/* 187 */       samplefac = 1;
/*     */     }
/* 189 */     this.alphadec = (30 + (samplefac - 1) / 3);
/* 190 */     int pix = 0;
/*     */ 
/* 192 */     int delta = numSamples / this.ncycles;
/* 193 */     int alpha = 1024;
/* 194 */     int radius = this.initradius;
/*     */ 
/* 196 */     int rad = radius >> 6;
/* 197 */     if (rad <= 1)
/* 198 */       rad = 0;
/* 199 */     for (int i = 0; i < rad; i++)
/* 200 */       this.radpower[i] = (alpha * ((rad * rad - i * i) * 256 / (rad * rad)));
/*     */     int step;
/*     */     int step;
/* 203 */     if (numSamples < 1509) {
/* 204 */       step = 3;
/*     */     }
/*     */     else
/*     */     {
/*     */       int step;
/* 205 */       if (numSamples % 499 != 0) {
/* 206 */         step = 1497;
/*     */       }
/*     */       else
/*     */       {
/*     */         int step;
/* 208 */         if (numSamples % 491 != 0) {
/* 209 */           step = 1473;
/*     */         }
/*     */         else
/*     */         {
/*     */           int step;
/* 211 */           if (numSamples % 487 != 0)
/* 212 */             step = 1461;
/*     */           else
/* 214 */             step = 1509;
/*     */         }
/*     */       }
/*     */     }
/* 218 */     int[] pixel = new int[3];
/*     */ 
/* 220 */     for (int i = 0; i < numSamples; ) {
/* 221 */       int y = (pix / pixelsPerLine + startY) * this.yPeriod + offsetY;
/* 222 */       int x = (pix % pixelsPerLine + startX) * this.xPeriod + offsetX;
/*     */       try
/*     */       {
/* 225 */         iterator.getPixel(x, y, pixel); } catch (Exception e) {
/*     */       }
/* 227 */       continue;
/*     */ 
/* 230 */       int b = pixel[2] << 4;
/* 231 */       int g = pixel[1] << 4;

View Full Code Here

/* 129 */       d.copyDataToRaster();
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectByte(PlanarImage src, RasterAccessor dst) {
/* 134 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 136 */     int minX = src.getMinX();
/* 137 */     int maxX = src.getMaxX();
/* 138 */     int minY = src.getMinY();
/* 139 */     int maxY = src.getMaxY();
/*     */ 
/* 141 */     int dstWidth = dst.getWidth();
/* 142 */     int dstHeight = dst.getHeight();
/* 143 */     int dstBands = dst.getNumBands();
/*     */ 
/* 145 */     int lineStride = dst.getScanlineStride();
/* 146 */     int pixelStride = dst.getPixelStride();
/* 147 */     int[] bandOffsets = dst.getBandOffsets();
/* 148 */     byte[][] data = dst.getByteDataArrays();
/*     */ 
/* 150 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 152 */     int lineOffset = 0;
/*     */ 
/* 154 */     byte[] backgroundByte = new byte[dstBands];
/* 155 */     for (int i = 0; i < dstBands; i++) {
/* 156 */       backgroundByte[i] = ((byte)(int)this.backgroundValues[i]);
/*     */     }
/* 158 */     for (int h = 0; h < dstHeight; h++) {
/* 159 */       int pixelOffset = lineOffset;
/* 160 */       lineOffset += lineStride;
/*     */ 
/* 162 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 164 */       int count = 0;
/* 165 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 172 */         int sx = round(warpData[(count++)]);
/* 173 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 175 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 177 */           if (this.setBackground) {
/* 178 */             for (int b = 0; b < dstBands; b++) {
/* 179 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundByte[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 184 */           for (int b = 0; b < dstBands; b++) {
/* 185 */             data[b][(pixelOffset + bandOffsets[b])] = ((byte)(iter.getSample(sx, sy, b) & 0xFF));
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 190 */         pixelOffset += pixelStride;

View Full Code Here

/*     */       }
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectUShort(PlanarImage src, RasterAccessor dst) {
/* 196 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 198 */     int minX = src.getMinX();
/* 199 */     int maxX = src.getMaxX();
/* 200 */     int minY = src.getMinY();
/* 201 */     int maxY = src.getMaxY();
/*     */ 
/* 203 */     int dstWidth = dst.getWidth();
/* 204 */     int dstHeight = dst.getHeight();
/* 205 */     int dstBands = dst.getNumBands();
/*     */ 
/* 207 */     int lineStride = dst.getScanlineStride();
/* 208 */     int pixelStride = dst.getPixelStride();
/* 209 */     int[] bandOffsets = dst.getBandOffsets();
/* 210 */     short[][] data = dst.getShortDataArrays();
/*     */ 
/* 212 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 214 */     int lineOffset = 0;
/*     */ 
/* 216 */     short[] backgroundUShort = new short[dstBands];
/* 217 */     for (int i = 0; i < dstBands; i++) {
/* 218 */       backgroundUShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 220 */     for (int h = 0; h < dstHeight; h++) {
/* 221 */       int pixelOffset = lineOffset;
/* 222 */       lineOffset += lineStride;
/*     */ 
/* 224 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 226 */       int count = 0;
/* 227 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 234 */         int sx = round(warpData[(count++)]);
/* 235 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 237 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 239 */           if (this.setBackground) {
/* 240 */             for (int b = 0; b < dstBands; b++) {
/* 241 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundUShort[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 246 */           for (int b = 0; b < dstBands; b++) {
/* 247 */             data[b][(pixelOffset + bandOffsets[b])] = ((short)(iter.getSample(sx, sy, b) & 0xFFFF));
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 252 */         pixelOffset += pixelStride;

View Full Code Here

/*     */       }
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectShort(PlanarImage src, RasterAccessor dst) {
/* 258 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 260 */     int minX = src.getMinX();
/* 261 */     int maxX = src.getMaxX();
/* 262 */     int minY = src.getMinY();
/* 263 */     int maxY = src.getMaxY();
/*     */ 
/* 265 */     int dstWidth = dst.getWidth();
/* 266 */     int dstHeight = dst.getHeight();
/* 267 */     int dstBands = dst.getNumBands();
/*     */ 
/* 269 */     int lineStride = dst.getScanlineStride();
/* 270 */     int pixelStride = dst.getPixelStride();
/* 271 */     int[] bandOffsets = dst.getBandOffsets();
/* 272 */     short[][] data = dst.getShortDataArrays();
/*     */ 
/* 274 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 276 */     int lineOffset = 0;
/*     */ 
/* 278 */     short[] backgroundShort = new short[dstBands];
/* 279 */     for (int i = 0; i < dstBands; i++) {
/* 280 */       backgroundShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 282 */     for (int h = 0; h < dstHeight; h++) {
/* 283 */       int pixelOffset = lineOffset;
/* 284 */       lineOffset += lineStride;
/*     */ 
/* 286 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 288 */       int count = 0;
/* 289 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 296 */         int sx = round(warpData[(count++)]);
/* 297 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 299 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 301 */           if (this.setBackground) {
/* 302 */             for (int b = 0; b < dstBands; b++) {
/* 303 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundShort[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 308 */           for (int b = 0; b < dstBands; b++) {
/* 309 */             data[b][(pixelOffset + bandOffsets[b])] = ((short)iter.getSample(sx, sy, b));
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 314 */         pixelOffset += pixelStride;

View Full Code Here

/*     */       }
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectInt(PlanarImage src, RasterAccessor dst) {
/* 320 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 322 */     int minX = src.getMinX();
/* 323 */     int maxX = src.getMaxX();
/* 324 */     int minY = src.getMinY();
/* 325 */     int maxY = src.getMaxY();
/*     */ 
/* 327 */     int dstWidth = dst.getWidth();
/* 328 */     int dstHeight = dst.getHeight();
/* 329 */     int dstBands = dst.getNumBands();
/*     */ 
/* 331 */     int lineStride = dst.getScanlineStride();
/* 332 */     int pixelStride = dst.getPixelStride();
/* 333 */     int[] bandOffsets = dst.getBandOffsets();
/* 334 */     int[][] data = dst.getIntDataArrays();
/*     */ 
/* 336 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 338 */     int lineOffset = 0;
/*     */ 
/* 340 */     int[] backgroundInt = new int[dstBands];
/* 341 */     for (int i = 0; i < dstBands; i++) {
/* 342 */       backgroundInt[i] = ((int)this.backgroundValues[i]);
/*     */     }
/* 344 */     for (int h = 0; h < dstHeight; h++) {
/* 345 */       int pixelOffset = lineOffset;
/* 346 */       lineOffset += lineStride;
/*     */ 
/* 348 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 350 */       int count = 0;
/* 351 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 358 */         int sx = round(warpData[(count++)]);
/* 359 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 361 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 363 */           if (this.setBackground) {
/* 364 */             for (int b = 0; b < dstBands; b++) {
/* 365 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundInt[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 370 */           for (int b = 0; b < dstBands; b++) {
/* 371 */             data[b][(pixelOffset + bandOffsets[b])] = iter.getSample(sx, sy, b);
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 376 */         pixelOffset += pixelStride;

View Full Code Here

/*     */       }
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectFloat(PlanarImage src, RasterAccessor dst) {
/* 382 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 384 */     int minX = src.getMinX();
/* 385 */     int maxX = src.getMaxX();
/* 386 */     int minY = src.getMinY();
/* 387 */     int maxY = src.getMaxY();
/*     */ 
/* 389 */     int dstWidth = dst.getWidth();
/* 390 */     int dstHeight = dst.getHeight();
/* 391 */     int dstBands = dst.getNumBands();
/*     */ 
/* 393 */     int lineStride = dst.getScanlineStride();
/* 394 */     int pixelStride = dst.getPixelStride();
/* 395 */     int[] bandOffsets = dst.getBandOffsets();
/* 396 */     float[][] data = dst.getFloatDataArrays();
/*     */ 
/* 398 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 400 */     int lineOffset = 0;
/*     */ 
/* 402 */     float[] backgroundFloat = new float[dstBands];
/* 403 */     for (int i = 0; i < dstBands; i++) {
/* 404 */       backgroundFloat[i] = ((float)this.backgroundValues[i]);
/*     */     }
/* 406 */     for (int h = 0; h < dstHeight; h++) {
/* 407 */       int pixelOffset = lineOffset;
/* 408 */       lineOffset += lineStride;
/*     */ 
/* 410 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 412 */       int count = 0;
/* 413 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 420 */         int sx = round(warpData[(count++)]);
/* 421 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 423 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 425 */           if (this.setBackground) {
/* 426 */             for (int b = 0; b < dstBands; b++) {
/* 427 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundFloat[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 432 */           for (int b = 0; b < dstBands; b++) {
/* 433 */             data[b][(pixelOffset + bandOffsets[b])] = iter.getSampleFloat(sx, sy, b);
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 438 */         pixelOffset += pixelStride;

View Full Code Here

/*     */       }
/*     */     }
/*     */   }
/*     */ 
/*     */   private void computeRectDouble(PlanarImage src, RasterAccessor dst) {
/* 444 */     RandomIter iter = RandomIterFactory.create(src, src.getBounds());
/*     */ 
/* 446 */     int minX = src.getMinX();
/* 447 */     int maxX = src.getMaxX();
/* 448 */     int minY = src.getMinY();
/* 449 */     int maxY = src.getMaxY();
/*     */ 
/* 451 */     int dstWidth = dst.getWidth();
/* 452 */     int dstHeight = dst.getHeight();
/* 453 */     int dstBands = dst.getNumBands();
/*     */ 
/* 455 */     int lineStride = dst.getScanlineStride();
/* 456 */     int pixelStride = dst.getPixelStride();
/* 457 */     int[] bandOffsets = dst.getBandOffsets();
/* 458 */     double[][] data = dst.getDoubleDataArrays();
/*     */ 
/* 460 */     float[] warpData = new float[2 * dstWidth];
/*     */ 
/* 462 */     int lineOffset = 0;
/*     */ 
/* 464 */     for (int h = 0; h < dstHeight; h++) {
/* 465 */       int pixelOffset = lineOffset;
/* 466 */       lineOffset += lineStride;
/*     */ 
/* 468 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */ 
/* 470 */       int count = 0;
/* 471 */       for (int w = 0; w < dstWidth; w++)
/*     */       {
/* 478 */         int sx = round(warpData[(count++)]);
/* 479 */         int sy = round(warpData[(count++)]);
/*     */ 
/* 481 */         if ((sx < minX) || (sx >= maxX) || (sy < minY) || (sy >= maxY))
/*     */         {
/* 483 */           if (this.setBackground) {
/* 484 */             for (int b = 0; b < dstBands; b++) {
/* 485 */               data[b][(pixelOffset + bandOffsets[b])] = this.backgroundValues[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 490 */           for (int b = 0; b < dstBands; b++) {
/* 491 */             data[b][(pixelOffset + bandOffsets[b])] = iter.getSampleDouble(sx, sy, b);
/*     */           }
/*     */ 
/*     */         }
/*     */ 
/* 496 */         pixelOffset += pixelStride;

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of javax.media.jai.iterator.RandomIter

com.sun.media.jai.opimage.NeuQuantOpImage

com.sun.media.jai.opimage.WarpBilinearOpImage

com.sun.media.jai.opimage.WarpGeneralOpImage

com.sun.media.jai.opimage.WarpNearestOpImage

org.geoserver.wcs.responses.NetCDFOutputManager

org.geoserver.wps.gs.GridCoverage2DRIA

org.geotools.coverage.processing.operation.GridCoverage2DRIA

org.geotools.gce.grassraster.core.CompressesRasterWriter

org.geotools.gce.imagemosaic.processing.ArtifactsFilterOpImage

org.geotools.image.test.ImageComparator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.