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

        } 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();
            iter = getRandomIterator(src, lpad, rpad, tpad, bpad, extender);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = getRandomIterator(src);
        }


        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();
        short[][] data = dst.getShortDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
            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);
                int xfrac = (int) ((sx - xint) * precH);
                int yfrac = (int) ((sy - yint) * precV);


                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 {
                    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.getSample(xint + i, yint + j, b) & 0xFFFF;
                            }
                        }


                        data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampUShort(interp
                                .interpolate(samples, xfrac, yfrac));

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();
            iter = getRandomIterator(src, lpad, rpad, tpad, bpad, extender);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = getRandomIterator(src);
        }


        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();
        short[][] data = dst.getShortDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
            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);
                int xfrac = (int) ((sx - xint) * precH);
                int yfrac = (int) ((sy - yint) * precV);


                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 {
                    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.getSample(xint + i, yint + j, b);
                            }
                        }


                        data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampShort(interp
                                .interpolate(samples, xfrac, yfrac));

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();
            iter = getRandomIterator(src, lpad, rpad, tpad, bpad, extender);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = getRandomIterator(src);
        }


        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();
        int[][] data = dst.getIntDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
            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);
                int xfrac = (int) ((sx - xint) * precH);
                int yfrac = (int) ((sy - yint) * precV);


                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 {
                    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.getSample(xint + i, yint + j, b);
                            }
                        }


                        data[b][pixelOffset + bandOffsets[b]] = interp.interpolate(samples, xfrac,
                                yfrac);

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();
            iter = getRandomIterator(src, lpad, rpad, tpad, bpad, extender);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = getRandomIterator(src);
        }


        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);
            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]] = interp.interpolate(samples, xfrac,
                                yfrac);

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();
            iter = getRandomIterator(src, lpad, rpad, tpad, bpad, extender);
        } else {
            minX = src.getMinX() + lpad;
            maxX = src.getMaxX() - rpad;
            minY = src.getMinY() + tpad;
            maxY = src.getMaxY() - bpad;
            iter = getRandomIterator(src);
        }


        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);
            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]] = interp.interpolate(samples, xfrac,
                                yfrac);

View Full Code Here

        return getRandomIterator(src, 0, 1, 0, 1, extender);
    }


    private RandomIter getRandomIterator(final PlanarImage src, int leftPad, int rightPad,
            int topPad, int bottomPad, BorderExtender extender) {
        RandomIter iterSource;
        if (extender != null) {
            RenderedOp op = BorderDescriptor.create(src, leftPad, rightPad, topPad, bottomPad,
                    extender, GeoTools.getDefaultHints());
            iterSource = RandomIterFactory.create(op, op.getBounds());
        } else {

View Full Code Here

        MathTransform2D w2g = coverage.getGridGeometry()
                .getCRSToGrid2D(PixelOrientation.UPPER_LEFT);
        // Iterator on the FeatureCollection
        SimpleFeatureIterator it = collection.features();
        // Iterator on the input image
        RandomIter imageIterator = RandomIterFactory.create(coverage.getRenderedImage(), null);
        // Boolean indicating that the TargetCRS is not null
        boolean crsExists = targetCRS != null;
        // Cycle on the Collection
        try {
            while (it.hasNext()) {
                // Selection of the feature
                SimpleFeature ft = it.next();
                // If the scale factor is more than 1 then no comparison between the values is done due
                // to possible differences on the interpolation
                if (scaleFactor == null) {
                    // Selection of the associated point
                    Point point = (Point) ft.getDefaultGeometry();
                    Point rasterPoint = (Point) JTS.transform(point, w2g);
                    int x = (int) (rasterPoint.getX());
                    int y = (int) (rasterPoint.getY());
                    // Selection of the value for the single band for the selected position
                    int sampleIMG = imageIterator.getSample(x, y, 0);
                    int sampleColl = (Short) ft.getAttribute(bandName);
                    // Ensure the values are equal
                    Assert.assertEquals(sampleIMG, sampleColl);
                }
                // Check the hemisphere

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();
        byte[][] data = dst.getByteDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
                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);
                    int xfrac = (int) ((sx - xint) * precH);
                    int yfrac = (int) ((sy - yint) * precV);


                    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 {
                        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.getSample(xint + i, yint + j, b) & 0xFF;
                                }
                            }


                            data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampByte(interp
                                    .interpolate(samples, xfrac, yfrac));
                        }
                    }


                    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);
                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);
                    int xfrac = (int) ((sx - xint) * precH);
                    int yfrac = (int) ((sy - yint) * precV);


                    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 {
                        xint -= lpad;
                        yint -= tpad;


                        for (int b = 0; b < dstBands; b++) {
                            byte[] t = ctable[b];


                            for (int j = 0; j < kheight; j++) {
                                for (int i = 0; i < kwidth; i++) {
                                    samples[j][i] = t[iter.getSample(xint + i, yint + j, 0) & 0xFF] & 0xFF;
                                }
                            }


                            data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampByte(interp
                                    .interpolate(samples, xfrac, yfrac));

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();
        short[][] data = dst.getShortDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
            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);
                int xfrac = (int) ((sx - xint) * precH);
                int yfrac = (int) ((sy - yint) * precV);


                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 {
                    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.getSample(xint + i, yint + j, b) & 0xFFFF;
                            }
                        }


                        data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampUShort(interp
                                .interpolate(samples, xfrac, yfrac));

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();
        short[][] data = dst.getShortDataArrays();


        int precH = 1 << interp.getSubsampleBitsH();
        int precV = 1 << interp.getSubsampleBitsV();


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


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


        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);
            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);
                int xfrac = (int) ((sx - xint) * precH);
                int yfrac = (int) ((sy - yint) * precV);


                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 {
                    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.getSample(xint + i, yint + j, b);
                            }
                        }


                        data[b][pixelOffset + bandOffsets[b]] = ImageUtil.clampShort(interp
                                .interpolate(samples, xfrac, yfrac));

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.