Examples of com.lightcrafts.mediax.jai.iterator.RandomIter

Package com.lightcrafts.mediax.jai.iterator

Examples of com.lightcrafts.mediax.jai.iterator.RandomIter

com.lightcrafts.mediax.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

        } else {
            lpad = rpad = tpad = bpad = 0;
        }


        int minX, maxX, minY, maxY;
        RandomIter iter;
        if(extender != null) {
            minX = src.getMinX();
            maxX = src.getMaxX();
            minY = src.getMinY();
            maxY = src.getMaxY();
            Rectangle bounds = new Rectangle(src.getMinX() - lpad,
                                             src.getMinY() - tpad,
                                             src.getWidth() + lpad + rpad,
                                             src.getHeight() + tpad + bpad);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int kwidth = interp.getWidth();
        int kheight = interp.getHeight();


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        float[][] data = dst.getFloatDataArrays();


        float[] warpData = new float[2 * dstWidth];


        float[][] samples = new float[kheight][kwidth];


        int lineOffset = 0;


        float[] backgroundFloat = new float[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundFloat[i] = (float)backgroundValues[i];


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1, warpData);


            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundFloat[b];
                        }
                    }
                } else {
                    xint -= lpad;
                    yint -= tpad;


                    for (int b = 0; b < dstBands; b++) {
                        for (int j = 0; j < kheight; j++) {
                            for (int i = 0; i < kwidth; i++) {
                                samples[j][i] = iter.getSampleFloat(
                                    xint+i, yint+j, b);
                            }
                        }


                        data[b][pixelOffset+bandOffsets[b]] =

View Full Code Here

        } else {
            lpad = rpad = tpad = bpad = 0;
        }


        int minX, maxX, minY, maxY;
        RandomIter iter;
        if(extender != null) {
            minX = src.getMinX();
            maxX = src.getMaxX();
            minY = src.getMinY();
            maxY = src.getMaxY();
            Rectangle bounds = new Rectangle(src.getMinX() - lpad,
                                             src.getMinY() - tpad,
                                             src.getWidth() + lpad + rpad,
                                             src.getHeight() + tpad + bpad);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int kwidth = interp.getWidth();
        int kheight = interp.getHeight();


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        double[][] data = dst.getDoubleDataArrays();


        float[] warpData = new float[2 * dstWidth];


        double[][] samples = new double[kheight][kwidth];


        int lineOffset = 0;


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1, warpData);


            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundValues[b];
                        }
                    }
                } else {
                    xint -= lpad;
                    yint -= tpad;


                    for (int b = 0; b < dstBands; b++) {
                        for (int j = 0; j < kheight; j++) {
                            for (int i = 0; i < kwidth; i++) {
                                samples[j][i] = iter.getSampleDouble(
                                    xint+i, yint+j, b);
                            }
                        }


                        data[b][pixelOffset+bandOffsets[b]] =

View Full Code Here

        Rectangle rect = source.getBounds();


        if (roi != null)
            rect = roi.getBounds();


        RandomIter iterator = RandomIterFactory.create(source, rect);


        int samplefac = xPeriod * yPeriod;
        int startX = rect.x / xPeriod;
        int startY = rect.y / yPeriod;
        int offsetX = rect.x % xPeriod;
        int offsetY = rect.y % yPeriod;
        int pixelsPerLine = (rect.width - 1) / xPeriod + 1;
        int numSamples =
            pixelsPerLine * ((rect.height - 1) / yPeriod + 1);


        if (numSamples < minpicturebytes)
            samplefac = 1;


        alphadec = 30 + ((samplefac - 1) / 3);
        int pix = 0;


        int delta = numSamples / ncycles;
        int alpha = initalpha;
        int radius = initradius;


        int rad = radius >> radiusbiasshift;
        if (rad <= 1)
            rad = 0;
        for (int i = 0; i < rad; i++)
            radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));


        int step;
        if (numSamples < minpicturebytes)
            step = 3;
        else if ((numSamples % prime1) != 0)
            step = 3 * prime1;
        else {
            if ((numSamples % prime2) != 0)
                step = 3 * prime2;
            else {
                if ((numSamples % prime3) != 0)
                    step = 3 * prime3;
                else
                    step = 3 * prime4;
            }
        }


        int[] pixel = new int[3];


        for (int i = 0; i < numSamples;) {
            int y = (pix / pixelsPerLine + startY) * yPeriod + offsetY;
            int x = (pix % pixelsPerLine + startX) * xPeriod + offsetX;


            try {
            iterator.getPixel(x, y, pixel);
            } catch (Exception e) {
                continue;
            }


            int b = pixel[2] << netbiasshift;

View Full Code Here

            d.copyDataToRaster();
        }
    }


    private void computeRectByte(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        byte[][] data = dst.getByteDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


  byte[] backgroundByte = new byte[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundByte[i] = (byte)backgroundValues[i];


        if (ctable == null) {  // source does not have IndexColorModel
            for (int h = 0; h < dstHeight; h++) {
                int pixelOffset = lineOffset;
                lineOffset += lineStride;


                warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                              warpData);
                int count = 0;
                for (int w = 0; w < dstWidth; w++) {
                    float sx = warpData[count++];
                    float sy = warpData[count++];


                    int xint = floor(sx);
                    int yint = floor(sy);
                    float xfrac = sx - xint;
                    float yfrac = sy - yint;


                    if (xint < minX || xint >= maxX ||
                        yint < minY || yint >= maxY) {
                        /* Fill with a background color. */
                        if (setBackground) {
                            for (int b = 0; b < dstBands; b++) {
                                data[b][pixelOffset+bandOffsets[b]] =
                                    backgroundByte[b];
                            }
                        }
                    } else {
                        for (int b = 0; b < dstBands; b++) {
                            int s00 = iter.getSample(xint, yint, b) & 0xFF;
                            int s01 = iter.getSample(xint+1, yint, b) & 0xFF;
                            int s10 = iter.getSample(xint, yint+1, b) & 0xFF;
                            int s11 = iter.getSample(xint+1, yint+1, b) & 0xFF;


                            float s0 = (s01 - s00) * xfrac + s00;
                            float s1 = (s11 - s10) * xfrac + s10;
                            float s = (s1 - s0) * yfrac + s0;


                            data[b][pixelOffset+bandOffsets[b]] = (byte)s;
                        }
                    }


                    pixelOffset += pixelStride;
                }
            }
        } else {  // source has IndexColorModel
            for (int h = 0; h < dstHeight; h++) {
                int pixelOffset = lineOffset;
                lineOffset += lineStride;


                warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                              warpData);
                int count = 0;
                for (int w = 0; w < dstWidth; w++) {
                    float sx = warpData[count++];
                    float sy = warpData[count++];


                    int xint = floor(sx);
                    int yint = floor(sy);
                    float xfrac = sx - xint;
                    float yfrac = sy - yint;


                    if (xint < minX || xint >= maxX ||
                        yint < minY || yint >= maxY) {
                        /* Fill with a background color. */
                        if (setBackground) {
                            for (int b = 0; b < dstBands; b++) {
                                data[b][pixelOffset+bandOffsets[b]] =
                                    backgroundByte[b];
                            }
                        }
                    } else {
                        for (int b = 0; b < dstBands; b++) {
                            byte[] t = ctable[b];


                            int s00 = t[iter.getSample(xint, yint, 0) &
                                                       0xFF] & 0xFF;
                            int s01 = t[iter.getSample(xint+1, yint, 0) &
                                                       0xFF] & 0xFF;
                            int s10 = t[iter.getSample(xint, yint+1, 0) &
                                                       0xFF] & 0xFF;
                            int s11 = t[iter.getSample(xint+1, yint+1, 0) &
                                                       0xFF] & 0xFF;


                            float s0 = (s01 - s00) * xfrac + s00;
                            float s1 = (s11 - s10) * xfrac + s10;
                            float s = (s1 - s0) * yfrac + s0;

View Full Code Here

            }
        }
    }


    private void computeRectUShort(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        short[][] data = dst.getShortDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


  short[] backgroundUShort = new short[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundUShort[i] = (short)backgroundValues[i];


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                          warpData);
            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundUShort[b];
                        }
                    }
                } else {
                    for (int b = 0; b < dstBands; b++) {
                        int s00 = iter.getSample(xint, yint, b) & 0xFFFF;
                        int s01 = iter.getSample(xint+1, yint, b) & 0xFFFF;
                        int s10 = iter.getSample(xint, yint+1, b) & 0xFFFF;
                        int s11 = iter.getSample(xint+1, yint+1, b) & 0xFFFF;


                        float s0 = (s01 - s00) * xfrac + s00;
                        float s1 = (s11 - s10) * xfrac + s10;
                        float s = (s1 - s0) * yfrac + s0;

View Full Code Here

            }
        }
    }


    private void computeRectShort(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        short[][] data = dst.getShortDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


        short[] backgroundShort = new short[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundShort[i] = (short)backgroundValues[i];


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                          warpData);
            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundShort[b];
                        }
                    }
                } else {
                    for (int b = 0; b < dstBands; b++) {
                        int s00 = iter.getSample(xint, yint, b);
                        int s01 = iter.getSample(xint+1, yint, b);
                        int s10 = iter.getSample(xint, yint+1, b);
                        int s11 = iter.getSample(xint+1, yint+1, b);


                        float s0 = (s01 - s00) * xfrac + s00;
                        float s1 = (s11 - s10) * xfrac + s10;
                        float s = (s1 - s0) * yfrac + s0;

View Full Code Here

            }
        }
    }


    private void computeRectInt(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        int[][] data = dst.getIntDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


  int[] backgroundInt = new int[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundInt[i] = (int)backgroundValues[i];


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                          warpData);
            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundInt[b];
                        }
                    }
                } else {
                    for (int b = 0; b < dstBands; b++) {
                        int s00 = iter.getSample(xint, yint, b);
                        int s01 = iter.getSample(xint+1, yint, b);
                        int s10 = iter.getSample(xint, yint+1, b);
                        int s11 = iter.getSample(xint+1, yint+1, b);


                        float s0 = (s01 - s00) * xfrac + s00;
                        float s1 = (s11 - s10) * xfrac + s10;
                        float s = (s1 - s0) * yfrac + s0;

View Full Code Here

            }
        }
    }


    private void computeRectFloat(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        float[][] data = dst.getFloatDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


  float[] backgroundFloat = new float[dstBands];
  for (int i = 0; i < dstBands; i++)
      backgroundFloat[i] = (float)backgroundValues[i];


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                          warpData);
            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundFloat[b];
                        }
                    }
                } else {
                    for (int b = 0; b < dstBands; b++) {
                        float s00 = iter.getSampleFloat(xint, yint, b);
                        float s01 = iter.getSampleFloat(xint+1, yint, b);
                        float s10 = iter.getSampleFloat(xint, yint+1, b);
                        float s11 = iter.getSampleFloat(xint+1, yint+1, b);


                        float s0 = (s01 - s00) * xfrac + s00;
                        float s1 = (s11 - s10) * xfrac + s10;
                        float s = (s1 - s0) * yfrac + s0;

View Full Code Here

            }
        }
    }


    private void computeRectDouble(PlanarImage src, RasterAccessor dst) {
        RandomIter iter;
        if(extender != null) {
            Rectangle bounds = new Rectangle(src.getMinX(), src.getMinY(),
                                             src.getWidth() + 1,
                                             src.getHeight() + 1);
            iter = RandomIterFactory.create(src.getExtendedData(bounds,
                                                                extender),
                                            bounds);
        } else {
            iter = RandomIterFactory.create(src, src.getBounds());
        }


        int minX = src.getMinX();
        int maxX = src.getMaxX() -
            (extender != null ? 0 : 1); // Right padding
        int minY = src.getMinY();
        int maxY = src.getMaxY() -
            (extender != null ? 0 : 1); // Bottom padding


        int dstWidth = dst.getWidth();
        int dstHeight = dst.getHeight();
        int dstBands = dst.getNumBands();


        int lineStride = dst.getScanlineStride();
        int pixelStride = dst.getPixelStride();
        int[] bandOffsets = dst.getBandOffsets();
        double[][] data = dst.getDoubleDataArrays();


        float[] warpData = new float[2 * dstWidth];


        int lineOffset = 0;


        for (int h = 0; h < dstHeight; h++) {
            int pixelOffset = lineOffset;
            lineOffset += lineStride;


            warp.warpRect(dst.getX(), dst.getY()+h, dstWidth, 1,
                          warpData);
            int count = 0;
            for (int w = 0; w < dstWidth; w++) {
                float sx = warpData[count++];
                float sy = warpData[count++];


                int xint = floor(sx);
                int yint = floor(sy);
                float xfrac = sx - xint;
                float yfrac = sy - yint;


                if (xint < minX || xint >= maxX ||
                    yint < minY || yint >= maxY) {
                    /* Fill with a background color. */
                    if (setBackground) {
                        for (int b = 0; b < dstBands; b++) {
                            data[b][pixelOffset+bandOffsets[b]] =
                                backgroundValues[b];
                        }
                    }
                } else {
                    for (int b = 0; b < dstBands; b++) {
                        double s00 = iter.getSampleDouble(xint, yint, b);
                        double s01 = iter.getSampleDouble(xint+1, yint, b);
                        double s10 = iter.getSampleDouble(xint, yint+1, b);
                        double s11 = iter.getSampleDouble(xint+1, yint+1, b);


                        double s0 = (s01 - s00) * xfrac + s00;
                        double s1 = (s11 - s10) * xfrac + s10;
                        double s = (s1 - s0) * yfrac + s0;

View Full Code Here

0 1

TOP

Related Classes of com.lightcrafts.mediax.jai.iterator.RandomIter

com.lightcrafts.media.jai.opimage.NeuQuantOpImage

com.lightcrafts.media.jai.opimage.WarpBilinearOpImage

com.lightcrafts.media.jai.opimage.WarpGeneralOpImage

com.lightcrafts.media.jai.opimage.WarpNearestOpImage

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.