Examples of RandomIter


Examples of javax.media.jai.iterator.RandomIter

/* 614 */       int tpad = this.interp.getTopPadding();
/* 615 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 617 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 622 */     if (this.extender != null) {
/* 623 */       int minX = src.getMinX();
/* 624 */       int maxX = src.getMaxX();
/* 625 */       int minY = src.getMinY();
/* 626 */       int maxY = src.getMaxY();
/* 627 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 631 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 635 */       minX = src.getMinX() + lpad;
/* 636 */       maxX = src.getMaxX() - rpad;
/* 637 */       minY = src.getMinY() + tpad;
/* 638 */       maxY = src.getMaxY() - bpad;
/* 639 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 642 */     int kwidth = this.interp.getWidth();
/* 643 */     int kheight = this.interp.getHeight();
/*     */
/* 645 */     int dstWidth = dst.getWidth();
/* 646 */     int dstHeight = dst.getHeight();
/* 647 */     int dstBands = dst.getNumBands();
/*     */
/* 649 */     int lineStride = dst.getScanlineStride();
/* 650 */     int pixelStride = dst.getPixelStride();
/* 651 */     int[] bandOffsets = dst.getBandOffsets();
/* 652 */     float[][] data = dst.getFloatDataArrays();
/*     */
/* 654 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 656 */     float[][] samples = new float[kheight][kwidth];
/*     */
/* 658 */     int lineOffset = 0;
/*     */
/* 660 */     float[] backgroundFloat = new float[dstBands];
/* 661 */     for (int i = 0; i < dstBands; i++) {
/* 662 */       backgroundFloat[i] = ((float)this.backgroundValues[i]);
/*     */     }
/* 664 */     for (int h = 0; h < dstHeight; h++) {
/* 665 */       int pixelOffset = lineOffset;
/* 666 */       lineOffset += lineStride;
/*     */
/* 668 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 670 */       int count = 0;
/* 671 */       for (int w = 0; w < dstWidth; w++) {
/* 672 */         float sx = warpData[(count++)];
/* 673 */         float sy = warpData[(count++)];
/*     */
/* 675 */         int xint = floor(sx);
/* 676 */         int yint = floor(sy);
/* 677 */         float xfrac = sx - xint;
/* 678 */         float yfrac = sy - yint;
/*     */
/* 680 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 683 */           if (this.setBackground) {
/* 684 */             for (int b = 0; b < dstBands; b++)
/* 685 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundFloat[b];
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 690 */           xint -= lpad;
/* 691 */           yint -= tpad;
/*     */
/* 693 */           for (int b = 0; b < dstBands; b++) {
/* 694 */             for (int j = 0; j < kheight; j++) {
/* 695 */               for (int i = 0; i < kwidth; i++) {
/* 696 */                 samples[j][i] = iter.getSampleFloat(xint + i, yint + j, b);
/*     */               }
/*     */
/*     */             }
/*     */
/* 701 */             data[b][(pixelOffset + bandOffsets[b])] = this.interp.interpolate(samples, xfrac, yfrac);
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/* 716 */       int tpad = this.interp.getTopPadding();
/* 717 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 719 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 724 */     if (this.extender != null) {
/* 725 */       int minX = src.getMinX();
/* 726 */       int maxX = src.getMaxX();
/* 727 */       int minY = src.getMinY();
/* 728 */       int maxY = src.getMaxY();
/* 729 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 733 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 737 */       minX = src.getMinX() + lpad;
/* 738 */       maxX = src.getMaxX() - rpad;
/* 739 */       minY = src.getMinY() + tpad;
/* 740 */       maxY = src.getMaxY() - bpad;
/* 741 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 744 */     int kwidth = this.interp.getWidth();
/* 745 */     int kheight = this.interp.getHeight();
/*     */
/* 747 */     int dstWidth = dst.getWidth();
/* 748 */     int dstHeight = dst.getHeight();
/* 749 */     int dstBands = dst.getNumBands();
/*     */
/* 751 */     int lineStride = dst.getScanlineStride();
/* 752 */     int pixelStride = dst.getPixelStride();
/* 753 */     int[] bandOffsets = dst.getBandOffsets();
/* 754 */     double[][] data = dst.getDoubleDataArrays();
/*     */
/* 756 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 758 */     double[][] samples = new double[kheight][kwidth];
/*     */
/* 760 */     int lineOffset = 0;
/*     */
/* 762 */     for (int h = 0; h < dstHeight; h++) {
/* 763 */       int pixelOffset = lineOffset;
/* 764 */       lineOffset += lineStride;
/*     */
/* 766 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 768 */       int count = 0;
/* 769 */       for (int w = 0; w < dstWidth; w++) {
/* 770 */         float sx = warpData[(count++)];
/* 771 */         float sy = warpData[(count++)];
/*     */
/* 773 */         int xint = floor(sx);
/* 774 */         int yint = floor(sy);
/* 775 */         float xfrac = sx - xint;
/* 776 */         float yfrac = sy - yint;
/*     */
/* 778 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 781 */           if (this.setBackground) {
/* 782 */             for (int b = 0; b < dstBands; b++)
/* 783 */               data[b][(pixelOffset + bandOffsets[b])] = this.backgroundValues[b];
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 788 */           xint -= lpad;
/* 789 */           yint -= tpad;
/*     */
/* 791 */           for (int b = 0; b < dstBands; b++) {
/* 792 */             for (int j = 0; j < kheight; j++) {
/* 793 */               for (int i = 0; i < kwidth; i++) {
/* 794 */                 samples[j][i] = iter.getSampleDouble(xint + i, yint + j, b);
/*     */               }
/*     */
/*     */             }
/*     */
/* 799 */             data[b][(pixelOffset + bandOffsets[b])] = this.interp.interpolate(samples, xfrac, yfrac);
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/* 140 */       int tpad = this.interp.getTopPadding();
/* 141 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 143 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 148 */     if (this.extender != null) {
/* 149 */       int minX = src.getMinX();
/* 150 */       int maxX = src.getMaxX();
/* 151 */       int minY = src.getMinY();
/* 152 */       int maxY = src.getMaxY();
/* 153 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 157 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 161 */       minX = src.getMinX() + lpad;
/* 162 */       maxX = src.getMaxX() - rpad;
/* 163 */       minY = src.getMinY() + tpad;
/* 164 */       maxY = src.getMaxY() - bpad;
/* 165 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 168 */     int kwidth = this.interp.getWidth();
/* 169 */     int kheight = this.interp.getHeight();
/*     */
/* 171 */     int dstWidth = dst.getWidth();
/* 172 */     int dstHeight = dst.getHeight();
/* 173 */     int dstBands = dst.getNumBands();
/*     */
/* 175 */     int lineStride = dst.getScanlineStride();
/* 176 */     int pixelStride = dst.getPixelStride();
/* 177 */     int[] bandOffsets = dst.getBandOffsets();
/* 178 */     byte[][] data = dst.getByteDataArrays();
/*     */
/* 180 */     int precH = 1 << this.interp.getSubsampleBitsH();
/* 181 */     int precV = 1 << this.interp.getSubsampleBitsV();
/*     */
/* 183 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 185 */     int[][] samples = new int[kheight][kwidth];
/*     */
/* 187 */     int lineOffset = 0;
/*     */
/* 189 */     byte[] backgroundByte = new byte[dstBands];
/* 190 */     for (int i = 0; i < dstBands; i++) {
/* 191 */       backgroundByte[i] = ((byte)(int)this.backgroundValues[i]);
/*     */     }
/* 193 */     if (this.ctable == null)
/* 194 */       for (int h = 0; h < dstHeight; h++) {
/* 195 */         int pixelOffset = lineOffset;
/* 196 */         lineOffset += lineStride;
/*     */
/* 198 */         this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 200 */         int count = 0;
/* 201 */         for (int w = 0; w < dstWidth; w++) {
/* 202 */           float sx = warpData[(count++)];
/* 203 */           float sy = warpData[(count++)];
/*     */
/* 205 */           int xint = floor(sx);
/* 206 */           int yint = floor(sy);
/* 207 */           int xfrac = (int)((sx - xint) * precH);
/* 208 */           int yfrac = (int)((sy - yint) * precV);
/*     */
/* 210 */           if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */           {
/* 213 */             if (this.setBackground) {
/* 214 */               for (int b = 0; b < dstBands; b++)
/* 215 */                 data[b][(pixelOffset + bandOffsets[b])] = backgroundByte[b];
/*     */             }
/*     */           }
/*     */           else
/*     */           {
/* 220 */             xint -= lpad;
/* 221 */             yint -= tpad;
/*     */
/* 223 */             for (int b = 0; b < dstBands; b++) {
/* 224 */               for (int j = 0; j < kheight; j++) {
/* 225 */                 for (int i = 0; i < kwidth; i++) {
/* 226 */                   samples[j][i] = (iter.getSample(xint + i, yint + j, b) & 0xFF);
/*     */                 }
/*     */
/*     */               }
/*     */
/* 231 */               data[b][(pixelOffset + bandOffsets[b])] = ImageUtil.clampByte(this.interp.interpolate(samples, xfrac, yfrac));
/*     */             }
/*     */
/*     */           }
/*     */
/* 237 */           pixelOffset += pixelStride;
/*     */         }
/*     */       }
/*     */     else
/* 241 */       for (int h = 0; h < dstHeight; h++) {
/* 242 */         int pixelOffset = lineOffset;
/* 243 */         lineOffset += lineStride;
/*     */
/* 245 */         this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 247 */         int count = 0;
/* 248 */         for (int w = 0; w < dstWidth; w++) {
/* 249 */           float sx = warpData[(count++)];
/* 250 */           float sy = warpData[(count++)];
/*     */
/* 252 */           int xint = floor(sx);
/* 253 */           int yint = floor(sy);
/* 254 */           int xfrac = (int)((sx - xint) * precH);
/* 255 */           int yfrac = (int)((sy - yint) * precV);
/*     */
/* 257 */           if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */           {
/* 260 */             if (this.setBackground) {
/* 261 */               for (int b = 0; b < dstBands; b++)
/* 262 */                 data[b][(pixelOffset + bandOffsets[b])] = backgroundByte[b];
/*     */             }
/*     */           }
/*     */           else
/*     */           {
/* 267 */             xint -= lpad;
/* 268 */             yint -= tpad;
/*     */
/* 270 */             for (int b = 0; b < dstBands; b++) {
/* 271 */               byte[] t = this.ctable[b];
/*     */
/* 273 */               for (int j = 0; j < kheight; j++) {
/* 274 */                 for (int i = 0; i < kwidth; i++) {
/* 275 */                   samples[j][i] = (t[(iter.getSample(xint + i, yint + j, 0) & 0xFF)] & 0xFF);
/*     */                 }
/*     */
/*     */               }
/*     */
/* 280 */               data[b][(pixelOffset + bandOffsets[b])] = ImageUtil.clampByte(this.interp.interpolate(samples, xfrac, yfrac));
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/* 297 */       int tpad = this.interp.getTopPadding();
/* 298 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 300 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 305 */     if (this.extender != null) {
/* 306 */       int minX = src.getMinX();
/* 307 */       int maxX = src.getMaxX();
/* 308 */       int minY = src.getMinY();
/* 309 */       int maxY = src.getMaxY();
/* 310 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 314 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 318 */       minX = src.getMinX() + lpad;
/* 319 */       maxX = src.getMaxX() - rpad;
/* 320 */       minY = src.getMinY() + tpad;
/* 321 */       maxY = src.getMaxY() - bpad;
/* 322 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 325 */     int kwidth = this.interp.getWidth();
/* 326 */     int kheight = this.interp.getHeight();
/*     */
/* 328 */     int dstWidth = dst.getWidth();
/* 329 */     int dstHeight = dst.getHeight();
/* 330 */     int dstBands = dst.getNumBands();
/*     */
/* 332 */     int lineStride = dst.getScanlineStride();
/* 333 */     int pixelStride = dst.getPixelStride();
/* 334 */     int[] bandOffsets = dst.getBandOffsets();
/* 335 */     short[][] data = dst.getShortDataArrays();
/*     */
/* 337 */     int precH = 1 << this.interp.getSubsampleBitsH();
/* 338 */     int precV = 1 << this.interp.getSubsampleBitsV();
/*     */
/* 340 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 342 */     int[][] samples = new int[kheight][kwidth];
/*     */
/* 344 */     int lineOffset = 0;
/*     */
/* 346 */     short[] backgroundUShort = new short[dstBands];
/* 347 */     for (int i = 0; i < dstBands; i++) {
/* 348 */       backgroundUShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 350 */     for (int h = 0; h < dstHeight; h++) {
/* 351 */       int pixelOffset = lineOffset;
/* 352 */       lineOffset += lineStride;
/*     */
/* 354 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 356 */       int count = 0;
/* 357 */       for (int w = 0; w < dstWidth; w++) {
/* 358 */         float sx = warpData[(count++)];
/* 359 */         float sy = warpData[(count++)];
/*     */
/* 361 */         int xint = floor(sx);
/* 362 */         int yint = floor(sy);
/* 363 */         int xfrac = (int)((sx - xint) * precH);
/* 364 */         int yfrac = (int)((sy - yint) * precV);
/*     */
/* 366 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 369 */           if (this.setBackground) {
/* 370 */             for (int b = 0; b < dstBands; b++)
/* 371 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundUShort[b];
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 376 */           xint -= lpad;
/* 377 */           yint -= tpad;
/*     */
/* 379 */           for (int b = 0; b < dstBands; b++) {
/* 380 */             for (int j = 0; j < kheight; j++) {
/* 381 */               for (int i = 0; i < kwidth; i++) {
/* 382 */                 samples[j][i] = (iter.getSample(xint + i, yint + j, b) & 0xFFFF);
/*     */               }
/*     */
/*     */             }
/*     */
/* 387 */             data[b][(pixelOffset + bandOffsets[b])] = ImageUtil.clampUShort(this.interp.interpolate(samples, xfrac, yfrac));
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/* 403 */       int tpad = this.interp.getTopPadding();
/* 404 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 406 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 411 */     if (this.extender != null) {
/* 412 */       int minX = src.getMinX();
/* 413 */       int maxX = src.getMaxX();
/* 414 */       int minY = src.getMinY();
/* 415 */       int maxY = src.getMaxY();
/* 416 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 420 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 424 */       minX = src.getMinX() + lpad;
/* 425 */       maxX = src.getMaxX() - rpad;
/* 426 */       minY = src.getMinY() + tpad;
/* 427 */       maxY = src.getMaxY() - bpad;
/* 428 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 431 */     int kwidth = this.interp.getWidth();
/* 432 */     int kheight = this.interp.getHeight();
/*     */
/* 434 */     int dstWidth = dst.getWidth();
/* 435 */     int dstHeight = dst.getHeight();
/* 436 */     int dstBands = dst.getNumBands();
/*     */
/* 438 */     int lineStride = dst.getScanlineStride();
/* 439 */     int pixelStride = dst.getPixelStride();
/* 440 */     int[] bandOffsets = dst.getBandOffsets();
/* 441 */     short[][] data = dst.getShortDataArrays();
/*     */
/* 443 */     int precH = 1 << this.interp.getSubsampleBitsH();
/* 444 */     int precV = 1 << this.interp.getSubsampleBitsV();
/*     */
/* 446 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 448 */     int[][] samples = new int[kheight][kwidth];
/*     */
/* 450 */     int lineOffset = 0;
/*     */
/* 452 */     short[] backgroundShort = new short[dstBands];
/* 453 */     for (int i = 0; i < dstBands; i++) {
/* 454 */       backgroundShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 456 */     for (int h = 0; h < dstHeight; h++) {
/* 457 */       int pixelOffset = lineOffset;
/* 458 */       lineOffset += lineStride;
/*     */
/* 460 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 462 */       int count = 0;
/* 463 */       for (int w = 0; w < dstWidth; w++) {
/* 464 */         float sx = warpData[(count++)];
/* 465 */         float sy = warpData[(count++)];
/*     */
/* 467 */         int xint = floor(sx);
/* 468 */         int yint = floor(sy);
/* 469 */         int xfrac = (int)((sx - xint) * precH);
/* 470 */         int yfrac = (int)((sy - yint) * precV);
/*     */
/* 472 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 475 */           if (this.setBackground) {
/* 476 */             for (int b = 0; b < dstBands; b++)
/* 477 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundShort[b];
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 482 */           xint -= lpad;
/* 483 */           yint -= tpad;
/*     */
/* 485 */           for (int b = 0; b < dstBands; b++) {
/* 486 */             for (int j = 0; j < kheight; j++) {
/* 487 */               for (int i = 0; i < kwidth; i++) {
/* 488 */                 samples[j][i] = iter.getSample(xint + i, yint + j, b);
/*     */               }
/*     */
/*     */             }
/*     */
/* 493 */             data[b][(pixelOffset + bandOffsets[b])] = ImageUtil.clampShort(this.interp.interpolate(samples, xfrac, yfrac));
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/* 509 */       int tpad = this.interp.getTopPadding();
/* 510 */       bpad = this.interp.getBottomPadding();
/*     */     } else {
/* 512 */       lpad = rpad = tpad = bpad = 0;
/*     */     }
/*     */     RandomIter iter;
/*     */     int minX;
/*     */     int maxX;
/*     */     int minY;
/*     */     int maxY;
/*     */     RandomIter iter;
/* 517 */     if (this.extender != null) {
/* 518 */       int minX = src.getMinX();
/* 519 */       int maxX = src.getMaxX();
/* 520 */       int minY = src.getMinY();
/* 521 */       int maxY = src.getMaxY();
/* 522 */       Rectangle bounds = new Rectangle(src.getMinX() - lpad, src.getMinY() - tpad, src.getWidth() + lpad + rpad, src.getHeight() + tpad + bpad);
/*     */
/* 526 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 530 */       minX = src.getMinX() + lpad;
/* 531 */       maxX = src.getMaxX() - rpad;
/* 532 */       minY = src.getMinY() + tpad;
/* 533 */       maxY = src.getMaxY() - bpad;
/* 534 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 537 */     int kwidth = this.interp.getWidth();
/* 538 */     int kheight = this.interp.getHeight();
/*     */
/* 540 */     int dstWidth = dst.getWidth();
/* 541 */     int dstHeight = dst.getHeight();
/* 542 */     int dstBands = dst.getNumBands();
/*     */
/* 544 */     int lineStride = dst.getScanlineStride();
/* 545 */     int pixelStride = dst.getPixelStride();
/* 546 */     int[] bandOffsets = dst.getBandOffsets();
/* 547 */     int[][] data = dst.getIntDataArrays();
/*     */
/* 549 */     int precH = 1 << this.interp.getSubsampleBitsH();
/* 550 */     int precV = 1 << this.interp.getSubsampleBitsV();
/*     */
/* 552 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 554 */     int[][] samples = new int[kheight][kwidth];
/*     */
/* 556 */     int lineOffset = 0;
/*     */
/* 558 */     int[] backgroundInt = new int[dstBands];
/* 559 */     for (int i = 0; i < dstBands; i++) {
/* 560 */       backgroundInt[i] = ((int)this.backgroundValues[i]);
/*     */     }
/* 562 */     for (int h = 0; h < dstHeight; h++) {
/* 563 */       int pixelOffset = lineOffset;
/* 564 */       lineOffset += lineStride;
/*     */
/* 566 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 568 */       int count = 0;
/* 569 */       for (int w = 0; w < dstWidth; w++) {
/* 570 */         float sx = warpData[(count++)];
/* 571 */         float sy = warpData[(count++)];
/*     */
/* 573 */         int xint = floor(sx);
/* 574 */         int yint = floor(sy);
/* 575 */         int xfrac = (int)((sx - xint) * precH);
/* 576 */         int yfrac = (int)((sy - yint) * precV);
/*     */
/* 578 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 581 */           if (this.setBackground) {
/* 582 */             for (int b = 0; b < dstBands; b++)
/* 583 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundInt[b];
/*     */           }
/*     */         }
/*     */         else
/*     */         {
/* 588 */           xint -= lpad;
/* 589 */           yint -= tpad;
/*     */
/* 591 */           for (int b = 0; b < dstBands; b++) {
/* 592 */             for (int j = 0; j < kheight; j++) {
/* 593 */               for (int i = 0; i < kwidth; i++) {
/* 594 */                 samples[j][i] = iter.getSample(xint + i, yint + j, b);
/*     */               }
/*     */
/*     */             }
/*     */
/* 599 */             data[b][(pixelOffset + bandOffsets[b])] = this.interp.interpolate(samples, xfrac, yfrac);
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/*     */     }
/*     */   }
/*     */
/*     */   private void computeRectByte(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 136 */     if (this.extender != null) {
/* 137 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */
/* 140 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 144 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 147 */     int minX = src.getMinX();
/* 148 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */
/* 150 */     int minY = src.getMinY();
/* 151 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */
/* 154 */     int dstWidth = dst.getWidth();
/* 155 */     int dstHeight = dst.getHeight();
/* 156 */     int dstBands = dst.getNumBands();
/*     */
/* 158 */     int lineStride = dst.getScanlineStride();
/* 159 */     int pixelStride = dst.getPixelStride();
/* 160 */     int[] bandOffsets = dst.getBandOffsets();
/* 161 */     byte[][] data = dst.getByteDataArrays();
/*     */
/* 163 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 165 */     int lineOffset = 0;
/*     */
/* 167 */     byte[] backgroundByte = new byte[dstBands];
/* 168 */     for (int i = 0; i < dstBands; i++) {
/* 169 */       backgroundByte[i] = ((byte)(int)this.backgroundValues[i]);
/*     */     }
/* 171 */     if (this.ctable == null)
/* 172 */       for (int h = 0; h < dstHeight; h++) {
/* 173 */         int pixelOffset = lineOffset;
/* 174 */         lineOffset += lineStride;
/*     */
/* 176 */         this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 178 */         int count = 0;
/* 179 */         for (int w = 0; w < dstWidth; w++) {
/* 180 */           float sx = warpData[(count++)];
/* 181 */           float sy = warpData[(count++)];
/*     */
/* 183 */           int xint = floor(sx);
/* 184 */           int yint = floor(sy);
/* 185 */           float xfrac = sx - xint;
/* 186 */           float yfrac = sy - yint;
/*     */
/* 188 */           if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */           {
/* 191 */             if (this.setBackground) {
/* 192 */               for (int b = 0; b < dstBands; b++) {
/* 193 */                 data[b][(pixelOffset + bandOffsets[b])] = backgroundByte[b];
/*     */               }
/*     */             }
/*     */           }
/*     */           else {
/* 198 */             for (int b = 0; b < dstBands; b++) {
/* 199 */               int s00 = iter.getSample(xint, yint, b) & 0xFF;
/* 200 */               int s01 = iter.getSample(xint + 1, yint, b) & 0xFF;
/* 201 */               int s10 = iter.getSample(xint, yint + 1, b) & 0xFF;
/* 202 */               int s11 = iter.getSample(xint + 1, yint + 1, b) & 0xFF;
/*     */
/* 204 */               float s0 = (s01 - s00) * xfrac + s00;
/* 205 */               float s1 = (s11 - s10) * xfrac + s10;
/* 206 */               float s = (s1 - s0) * yfrac + s0;
/*     */
/* 208 */               data[b][(pixelOffset + bandOffsets[b])] = ((byte)(int)s);
/*     */             }
/*     */           }
/*     */
/* 212 */           pixelOffset += pixelStride;
/*     */         }
/*     */       }
/*     */     else
/* 216 */       for (int h = 0; h < dstHeight; h++) {
/* 217 */         int pixelOffset = lineOffset;
/* 218 */         lineOffset += lineStride;
/*     */
/* 220 */         this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 222 */         int count = 0;
/* 223 */         for (int w = 0; w < dstWidth; w++) {
/* 224 */           float sx = warpData[(count++)];
/* 225 */           float sy = warpData[(count++)];
/*     */
/* 227 */           int xint = floor(sx);
/* 228 */           int yint = floor(sy);
/* 229 */           float xfrac = sx - xint;
/* 230 */           float yfrac = sy - yint;
/*     */
/* 232 */           if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */           {
/* 235 */             if (this.setBackground) {
/* 236 */               for (int b = 0; b < dstBands; b++) {
/* 237 */                 data[b][(pixelOffset + bandOffsets[b])] = backgroundByte[b];
/*     */               }
/*     */             }
/*     */           }
/*     */           else {
/* 242 */             for (int b = 0; b < dstBands; b++) {
/* 243 */               byte[] t = this.ctable[b];
/*     */
/* 245 */               int s00 = t[(iter.getSample(xint, yint, 0) & 0xFF)] & 0xFF;
/*     */
/* 247 */               int s01 = t[(iter.getSample(xint + 1, yint, 0) & 0xFF)] & 0xFF;
/*     */
/* 249 */               int s10 = t[(iter.getSample(xint, yint + 1, 0) & 0xFF)] & 0xFF;
/*     */
/* 251 */               int s11 = t[(iter.getSample(xint + 1, yint + 1, 0) & 0xFF)] & 0xFF;
/*     */
/* 254 */               float s0 = (s01 - s00) * xfrac + s00;
/* 255 */               float s1 = (s11 - s10) * xfrac + s10;
/* 256 */               float s = (s1 - s0) * yfrac + s0;
/*     */
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/*     */       }
/*     */   }
/*     */
/*     */   private void computeRectUShort(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 270 */     if (this.extender != null) {
/* 271 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */
/* 274 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 278 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 281 */     int minX = src.getMinX();
/* 282 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */
/* 284 */     int minY = src.getMinY();
/* 285 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */
/* 288 */     int dstWidth = dst.getWidth();
/* 289 */     int dstHeight = dst.getHeight();
/* 290 */     int dstBands = dst.getNumBands();
/*     */
/* 292 */     int lineStride = dst.getScanlineStride();
/* 293 */     int pixelStride = dst.getPixelStride();
/* 294 */     int[] bandOffsets = dst.getBandOffsets();
/* 295 */     short[][] data = dst.getShortDataArrays();
/*     */
/* 297 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 299 */     int lineOffset = 0;
/*     */
/* 301 */     short[] backgroundUShort = new short[dstBands];
/* 302 */     for (int i = 0; i < dstBands; i++) {
/* 303 */       backgroundUShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 305 */     for (int h = 0; h < dstHeight; h++) {
/* 306 */       int pixelOffset = lineOffset;
/* 307 */       lineOffset += lineStride;
/*     */
/* 309 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 311 */       int count = 0;
/* 312 */       for (int w = 0; w < dstWidth; w++) {
/* 313 */         float sx = warpData[(count++)];
/* 314 */         float sy = warpData[(count++)];
/*     */
/* 316 */         int xint = floor(sx);
/* 317 */         int yint = floor(sy);
/* 318 */         float xfrac = sx - xint;
/* 319 */         float yfrac = sy - yint;
/*     */
/* 321 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 324 */           if (this.setBackground) {
/* 325 */             for (int b = 0; b < dstBands; b++) {
/* 326 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundUShort[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 331 */           for (int b = 0; b < dstBands; b++) {
/* 332 */             int s00 = iter.getSample(xint, yint, b) & 0xFFFF;
/* 333 */             int s01 = iter.getSample(xint + 1, yint, b) & 0xFFFF;
/* 334 */             int s10 = iter.getSample(xint, yint + 1, b) & 0xFFFF;
/* 335 */             int s11 = iter.getSample(xint + 1, yint + 1, b) & 0xFFFF;
/*     */
/* 337 */             float s0 = (s01 - s00) * xfrac + s00;
/* 338 */             float s1 = (s11 - s10) * xfrac + s10;
/* 339 */             float s = (s1 - s0) * yfrac + s0;
/*     */
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/*     */     }
/*     */   }
/*     */
/*     */   private void computeRectShort(PlanarImage src, RasterAccessor dst)
/*     */   {
/*     */     RandomIter iter;
/*     */     RandomIter iter;
/* 352 */     if (this.extender != null) {
/* 353 */       Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(), src.getWidth() + 1, src.getHeight() + 1);
/*     */
/* 356 */       iter = RandomIterFactory.create(src.getExtendedData(bounds, this.extender), bounds);
/*     */     }
/*     */     else
/*     */     {
/* 360 */       iter = RandomIterFactory.create(src, src.getBounds());
/*     */     }
/*     */
/* 363 */     int minX = src.getMinX();
/* 364 */     int maxX = src.getMaxX() - (this.extender != null ? 0 : 1);
/*     */
/* 366 */     int minY = src.getMinY();
/* 367 */     int maxY = src.getMaxY() - (this.extender != null ? 0 : 1);
/*     */
/* 370 */     int dstWidth = dst.getWidth();
/* 371 */     int dstHeight = dst.getHeight();
/* 372 */     int dstBands = dst.getNumBands();
/*     */
/* 374 */     int lineStride = dst.getScanlineStride();
/* 375 */     int pixelStride = dst.getPixelStride();
/* 376 */     int[] bandOffsets = dst.getBandOffsets();
/* 377 */     short[][] data = dst.getShortDataArrays();
/*     */
/* 379 */     float[] warpData = new float[2 * dstWidth];
/*     */
/* 381 */     int lineOffset = 0;
/*     */
/* 383 */     short[] backgroundShort = new short[dstBands];
/* 384 */     for (int i = 0; i < dstBands; i++) {
/* 385 */       backgroundShort[i] = ((short)(int)this.backgroundValues[i]);
/*     */     }
/* 387 */     for (int h = 0; h < dstHeight; h++) {
/* 388 */       int pixelOffset = lineOffset;
/* 389 */       lineOffset += lineStride;
/*     */
/* 391 */       this.warp.warpRect(dst.getX(), dst.getY() + h, dstWidth, 1, warpData);
/*     */
/* 393 */       int count = 0;
/* 394 */       for (int w = 0; w < dstWidth; w++) {
/* 395 */         float sx = warpData[(count++)];
/* 396 */         float sy = warpData[(count++)];
/*     */
/* 398 */         int xint = floor(sx);
/* 399 */         int yint = floor(sy);
/* 400 */         float xfrac = sx - xint;
/* 401 */         float yfrac = sy - yint;
/*     */
/* 403 */         if ((xint < minX) || (xint >= maxX) || (yint < minY) || (yint >= maxY))
/*     */         {
/* 406 */           if (this.setBackground) {
/* 407 */             for (int b = 0; b < dstBands; b++) {
/* 408 */               data[b][(pixelOffset + bandOffsets[b])] = backgroundShort[b];
/*     */             }
/*     */           }
/*     */         }
/*     */         else {
/* 413 */           for (int b = 0; b < dstBands; b++) {
/* 414 */             int s00 = iter.getSample(xint, yint, b);
/* 415 */             int s01 = iter.getSample(xint + 1, yint, b);
/* 416 */             int s10 = iter.getSample(xint, yint + 1, b);
/* 417 */             int s11 = iter.getSample(xint + 1, yint + 1, b);
/*     */
/* 419 */             float s0 = (s01 - s00) * xfrac + s00;
/* 420 */             float s1 = (s11 - s10) * xfrac + s10;
/* 421 */             float s = (s1 - s0) * yfrac + s0;
/*     */
View Full Code Here

Examples of javax.media.jai.iterator.RandomIter

/*     */     }
/*     */   }
/*     */
/*     */   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
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
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.