Examples of javax.media.jai.PixelAccessor

javax.media.jai.PixelAccessor
This is a utility class that may be used to access the pixel data stored in a RenderedImage's Rasters, as well as performing pixel-to-color data translation based on the image's SampleModel and ColorModel. It also provides several static methods to determine information about the image data.
This class is intended to help classes that need to access the pixel and/or color data of a RenderedImage, such as an OpImage, in an optimized fashion. Most of the variables defined in this class are public so that other classes may use them directly. However, the variables are also declared final so that other classes can not modify their values.
In general, the pixel data of a RenderedImage may be obtained by calling the getPixels() method. By definition, the pixel data of an image are the data described by the image's SampleModel and stored in the image's Rasters. No consideration of any kind is given to the image's ColorModel. If no error is found, the pixel data are returned in the primitive arrays of the type specified by the caller in an unpacked format, along with access information. Therefore, the specified data type must be one of the valid types defined in DataBuffer and large enough (in bit depth) to hold the pixel data of the image.
The pixel data of a binary image may be obtained in a packed format by calling the getPackedPixels() method. It returns the data in a packed byte array, with 8 pixels packed into 1 byte. The format of the data in the array is similar to the format described by the MultiPixelPackedSampleModel, where the end of each scanline is padded to the end of the byte if necessary. Note that this method returns a valid result only if and only if the image is a single-band bit image, that is, each pixel has only 1 sample with a sample size of 1 bit.
Two corresponding "set" methods are also provided for setting the computed pixel data back into the Raster's DataBuffer: setPixels() for unpacked data, and setPackedPixels() for packed data. It is very important that the caller uses the correct "set" method that matches the "get" method used to obtain the data, or errors will occur.
The color/alpha data of the RenderedImage may be obtained by calling the getComponents() method which returns the unnormalized data in the ColorSpace specified in the ColorModel, or the getComponentsRGB() method which returns the data scaled from 0 to 255 in the default sRGB ColorSpace. These methods retrieve the pixel data from the Raster, and perform the pixel-to-color translation. Therefore, in order for these two methods to return a valid result, the image must have a valid ColorModel.
Similarly, two "set" methods may be used to perform the color-to-pixel translation, and set the pixel data back to the Raster's DataBuffer. Again, it is important that the "get" and "set" methods are matched up correctly.
In addition, several static methods are included in this class for the convenience of OpImage developers, who may use them to help determine the appropriate destination SampleModel type. @since JAI 1.1

/*     */         }
/*     */     }
/*     */ 
/*     */     private void constructTree(Raster source) {
/* 219 */       if (!OctTreeOpImage.this.isInitialized) {
/* 220 */         OctTreeOpImage.this.srcPA = new PixelAccessor(OctTreeOpImage.this.getSourceImage(0));
/* 221 */         OctTreeOpImage.this.srcSampleType = (OctTreeOpImage.this.srcPA.sampleType == -1 ? 0 : OctTreeOpImage.this.srcPA.sampleType);
/*     */ 
/* 223 */         OctTreeOpImage.this.isInitialized = true;
/*     */       }
/*     */

View Full Code Here

/*     */ 
/* 222 */     short thresholdS = (short)(int)Math.ceil(this.threshold);
/*     */ 
/* 228 */     Rectangle srcRect = mapDestRect(destRect, 0);
/*     */ 
/* 230 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 231 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 232 */     int offset = pid.offset;
/* 233 */     PixelAccessor srcPa = new PixelAccessor(source.getSampleModel(), null);
/*     */ 
/* 235 */     UnpackedImageData srcImD = srcPa.getPixels(source, srcRect, 2, false);
/* 236 */     int srcOffset = srcImD.bandOffsets[0];
/* 237 */     short[] srcData = ((short[][])(short[][])srcImD.data)[0];
/* 238 */     int pixelStride = srcImD.pixelStride;
/*     */ 
/* 240 */     int ind0 = pid.bitOffset;

View Full Code Here

/*     */ 
/* 269 */     int thresholdI = (int)Math.ceil(this.threshold);
/*     */ 
/* 275 */     Rectangle srcRect = mapDestRect(destRect, 0);
/*     */ 
/* 277 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 278 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 279 */     int offset = pid.offset;
/* 280 */     PixelAccessor srcPa = new PixelAccessor(source.getSampleModel(), null);
/*     */ 
/* 282 */     UnpackedImageData srcImD = srcPa.getPixels(source, srcRect, 1, false);
/* 283 */     int srcOffset = srcImD.bandOffsets[0];
/* 284 */     short[] srcData = ((short[][])(short[][])srcImD.data)[0];
/* 285 */     int pixelStride = srcImD.pixelStride;
/*     */ 
/* 287 */     int ind0 = pid.bitOffset;

View Full Code Here

/*     */ 
/* 318 */     int thresholdI = (int)Math.ceil(this.threshold);
/*     */ 
/* 324 */     Rectangle srcRect = mapDestRect(destRect, 0);
/*     */ 
/* 326 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 327 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 328 */     int offset = pid.offset;
/* 329 */     PixelAccessor srcPa = new PixelAccessor(source.getSampleModel(), null);
/*     */ 
/* 331 */     UnpackedImageData srcImD = srcPa.getPixels(source, srcRect, 3, false);
/* 332 */     int srcOffset = srcImD.bandOffsets[0];
/* 333 */     int[] srcData = ((int[][])(int[][])srcImD.data)[0];
/* 334 */     int pixelStride = srcImD.pixelStride;
/*     */ 
/* 336 */     int ind0 = pid.bitOffset;

View Full Code Here

/*     */ 
/*     */   private void floatLoop(Raster source, WritableRaster dest, Rectangle destRect)
/*     */   {
/* 356 */     Rectangle srcRect = mapDestRect(destRect, 0);
/*     */ 
/* 358 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 359 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 360 */     int offset = pid.offset;
/* 361 */     PixelAccessor srcPa = new PixelAccessor(source.getSampleModel(), null);
/*     */ 
/* 363 */     UnpackedImageData srcImD = srcPa.getPixels(source, srcRect, 4, false);
/* 364 */     int srcOffset = srcImD.bandOffsets[0];
/* 365 */     float[] srcData = ((float[][])(float[][])srcImD.data)[0];
/* 366 */     int pixelStride = srcImD.pixelStride;
/*     */ 
/* 368 */     int ind0 = pid.bitOffset;

View Full Code Here

/*     */ 
/*     */   private void doubleLoop(Raster source, WritableRaster dest, Rectangle destRect)
/*     */   {
/* 387 */     Rectangle srcRect = mapDestRect(destRect, 0);
/*     */ 
/* 389 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 390 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 391 */     int offset = pid.offset;
/* 392 */     PixelAccessor srcPa = new PixelAccessor(source.getSampleModel(), null);
/*     */ 
/* 394 */     UnpackedImageData srcImD = srcPa.getPixels(source, srcRect, 5, false);
/* 395 */     int srcOffset = srcImD.bandOffsets[0];
/* 396 */     double[] srcData = ((double[][])(double[][])srcImD.data)[0];
/* 397 */     int pixelStride = srcImD.pixelStride;
/*     */ 
/* 399 */     int ind0 = pid.bitOffset;

View Full Code Here

/*     */   }
/*     */ 
/*     */   private void setTo1(Raster dest, Rectangle destRect)
/*     */   {
/* 416 */     initBitsOn();
/* 417 */     PixelAccessor pa = new PixelAccessor(dest.getSampleModel(), null);
/* 418 */     PackedImageData pid = pa.getPackedPixels(dest, destRect, true, false);
/* 419 */     int offset = pid.offset;
/*     */ 
/* 421 */     for (int h = 0; h < destRect.height; h++) {
/* 422 */       int ind0 = pid.bitOffset;
/* 423 */       int indE = ind0 + destRect.width - 1;
/* 424 */       if (indE < 8)
/*     */       {
/* 426 */         pid.data[offset] = ((byte)(pid.data[offset] | bitsOn[indE]));
/*     */       }
/*     */       else {
/* 429 */         pid.data[offset] = ((byte)(pid.data[offset] | bitsOn[7]));
/*     */ 
/* 431 */         for (int b = offset + 1; b <= offset + (indE - 7) / 8; b++) {
/* 432 */           pid.data[b] = -1;
/*     */         }
/*     */ 
/* 436 */         int remBits = indE % 8;
/* 437 */         if (remBits % 8 != 7) {
/* 438 */           indE = offset + indE / 8;
/* 439 */           pid.data[indE] = ((byte)(pid.data[indE] | bitsOn[remBits]));
/*     */         }
/*     */       }
/* 442 */       offset += pid.lineStride;
/*     */     }
/* 444 */     pa.setPackedPixels(pid);
/*     */   }

View Full Code Here

        // Bands associated with each sources
        int[] snbands = new int[nSrcs];
        // PixelAccessor array for each source
        PixelAccessor[] pas = new PixelAccessor[nSrcs];
        for (int i = 0; i < nSrcs; i++) {
            pas[i] = new PixelAccessor(sources[i].getSampleModel(), colorModels[i]);


            if (colorModels[i] instanceof IndexColorModel) {
                snbands[i] = colorModels[i].getNumComponents();
            } else {
                snbands[i] = sources[i].getNumBands();
            }
        }


        // Destination bands
        int dnbands = dest.getNumBands();
        // Destination data type
        int destType = dest.getTransferType();
        // PixelAccessor associated with the destination raster
        PixelAccessor d = new PixelAccessor(dest.getSampleModel(), null);


        UnpackedImageData dimd = d.getPixels(dest, destRect, destType, true);


        // Destination tile initial position
        final int minX = destRect.x;
        final int minY = destRect.y;


        // Destination data values
        byte[][] dstdata = (byte[][]) dimd.data;


        // ONLY VALID DATA
        if (caseA) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;
                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    byte[] dstdatabandb = dstdata[db];
                    byte[][] srcdata = (byte[][]) simd.data;
                    byte[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];


                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                            dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                        }
                    }
                }
            }
            // ONLY ROI
        } else if (caseB) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                byte[] dstdatabandb = dstdata[dbidx];
                                byte[][] srcdata = (byte[][]) simd.data;
                                byte[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }
                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                        + simd.bandOffsets[sb]];
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                byte[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataByte;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
            // ONLY NODATA
        } else if (caseC) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                // Source data
                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                // Source and Destination parameters
                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    // Source and destination data array
                    byte[] dstdatabandb = dstdata[db];
                    byte[][] srcdata = (byte[][]) simd.data;
                    byte[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];
                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {
                            // No Data control
                            if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                dstdatabandb[dstpos] = destNoDataByte;
                            } else {
                                dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                            }
                        }
                    }
                }
            }
            // NODATA AND ROI
        } else {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                byte[] dstdatabandb = dstdata[dbidx];
                                byte[][] srcdata = (byte[][]) simd.data;
                                byte[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }


                                // No Data control
                                if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataByte;
                                } else {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                            + simd.bandOffsets[sb]];
                                }
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                byte[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataByte;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
        }
        d.setPixels(dimd);
    }

View Full Code Here

        PixelAccessor[] pas = new PixelAccessor[nSrcs];


        boolean isUshort = getSampleModel().getDataType() == DataBuffer.TYPE_USHORT;


        for (int i = 0; i < nSrcs; i++) {
            pas[i] = new PixelAccessor(sources[i].getSampleModel(), colorModels[i]);


            if (colorModels[i] instanceof IndexColorModel) {
                snbands[i] = colorModels[i].getNumComponents();
            } else {
                snbands[i] = sources[i].getNumBands();
            }
        }


        // Destination bands
        int dnbands = dest.getNumBands();
        // Destination data type
        int destType = dest.getTransferType();
        // PixelAccessor associated with the destination raster
        PixelAccessor d = new PixelAccessor(dest.getSampleModel(), null);


        UnpackedImageData dimd = d.getPixels(dest, destRect, destType, true);


        // Destination data values
        short[][] dstdata = (short[][]) dimd.data;


        // ONLY VALID DATA
        if (caseA) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;
                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    short[] dstdatabandb = dstdata[db];
                    short[][] srcdata = (short[][]) simd.data;
                    short[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];


                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                            dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                        }
                    }
                }
            }
            // ONLY ROI
        } else if (caseB) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                short[] dstdatabandb = dstdata[dbidx];
                                short[][] srcdata = (short[][]) simd.data;
                                short[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }
                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                        + simd.bandOffsets[sb]];
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                short[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataShort;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
            // ONLY NODATA
        } else if (caseC) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                // Source data
                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                // Source and Destination parameters
                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    // Source and destination data array
                    short[] dstdatabandb = dstdata[db];
                    short[][] srcdata = (short[][]) simd.data;
                    short[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];
                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {
                            // No Data control
                            if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                dstdatabandb[dstpos] = destNoDataShort;
                            } else {
                                dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                            }
                        }
                    }
                }
            }
            // NODATA AND ROI
        } else {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                short[] dstdatabandb = dstdata[dbidx];
                                short[][] srcdata = (short[][]) simd.data;
                                short[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }


                                // No Data control
                                if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataShort;
                                } else {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                            + simd.bandOffsets[sb]];
                                }
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                short[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataShort;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
        }
        d.setPixels(dimd);
    }

View Full Code Here

        int[] snbands = new int[nSrcs];
        // PixelAccessor array for each source
        PixelAccessor[] pas = new PixelAccessor[nSrcs];


        for (int i = 0; i < nSrcs; i++) {
            pas[i] = new PixelAccessor(sources[i].getSampleModel(), colorModels[i]);


            if (colorModels[i] instanceof IndexColorModel) {
                snbands[i] = colorModels[i].getNumComponents();
            } else {
                snbands[i] = sources[i].getNumBands();
            }
        }


        // Destination bands
        int dnbands = dest.getNumBands();
        // Destination data type
        int destType = dest.getTransferType();
        // PixelAccessor associated with the destination raster
        PixelAccessor d = new PixelAccessor(dest.getSampleModel(), null);


        UnpackedImageData dimd = d.getPixels(dest, destRect, destType, true);
        // Destination data values
        int[][] dstdata = (int[][]) dimd.data;


        // ONLY VALID DATA
        if (caseA) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;
                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    int[] dstdatabandb = dstdata[db];
                    int[][] srcdata = (int[][]) simd.data;
                    int[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];


                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                            dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                        }
                    }
                }
            }
            // ONLY ROI
        } else if (caseB) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                int[] dstdatabandb = dstdata[dbidx];
                                int[][] srcdata = (int[][]) simd.data;
                                int[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }
                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                        + simd.bandOffsets[sb]];
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                int[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataInt;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
            // ONLY NODATA
        } else if (caseC) {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                // Source data
                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                // Source and Destination parameters
                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                // Cycle on each source bands
                for (int sb = 0; sb < snbands[sindex]; sb++, db++) {
                    if (db >= dnbands) {
                        // exceeding destNumBands; should not have happened
                        break;
                    }


                    // Source and destination data array
                    int[] dstdatabandb = dstdata[db];
                    int[][] srcdata = (int[][]) simd.data;
                    int[] srcdatabandsb = srcdata[sb];
                    int srcstart = simd.bandOffsets[sb];
                    int dststart = dimd.bandOffsets[db];
                    // Cycle on the y-axis
                    for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                        // Cycle on the x-axis
                        for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {
                            // No Data control
                            if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                dstdatabandb[dstpos] = destNoDataInt;
                            } else {
                                dstdatabandb[dstpos] = srcdatabandsb[srcpos];
                            }
                        }
                    }
                }
            }
            // NODATA AND ROI
        } else {
            // Cycle on all the sources
            for (int sindex = 0, db = 0; sindex < nSrcs; sindex++) {


                UnpackedImageData simd = colorModels[sindex] instanceof IndexColorModel ? pas[sindex]
                        .getComponents(sources[sindex], destRect, sources[sindex].getSampleModel()
                                .getTransferType()) : pas[sindex].getPixels(sources[sindex],
                        destRect, sources[sindex].getSampleModel().getTransferType(), false);


                int srcPixelStride = simd.pixelStride;
                int srcLineStride = simd.lineStride;
                int dstPixelStride = dimd.pixelStride;
                int dstLineStride = dimd.lineStride;
                int dRectWidth = destRect.width;


                int srcstart = 0;
                int dststart = 0;


                // Cycle on the y-axis
                for (int y = 0; y < destRect.height; y++, srcstart += srcLineStride, dststart += dstLineStride) {
                    // Cycle on the x-axis
                    for (int i = 0, srcpos = srcstart, dstpos = dststart; i < dRectWidth; i++, srcpos += srcPixelStride, dstpos += dstPixelStride) {


                        // ROI Check
                        if (roi.contains(i + minX, y + minY)) {
                            // Cycle on each source bands
                            for (int sb = 0; sb < snbands[sindex]; sb++) {
                                int dbidx = db + sb;
                                int[] dstdatabandb = dstdata[dbidx];
                                int[][] srcdata = (int[][]) simd.data;
                                int[] srcdatabandsb = srcdata[sb];


                                if (db >= dnbands) {
                                    // exceeding destNumBands; should not have happened
                                    break;
                                }


                                // No Data control
                                if (noData[sindex].contains(srcdatabandsb[srcpos])) {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataInt;
                                } else {
                                    dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = srcdatabandsb[srcpos
                                            + simd.bandOffsets[sb]];
                                }
                            }
                        } else {
                            for (int sb = 0; sb < snbands[sindex]; sb++) {


                                int dbidx = db + sb;
                                int[] dstdatabandb = dstdata[dbidx];


                                dstdatabandb[dstpos + dimd.bandOffsets[dbidx]] = destNoDataInt;
                            }
                        }
                    }
                }
                db += snbands[sindex];
            }
        }
        d.setPixels(dimd);
    }

View Full Code Here

0 1 2 3 4 5

TOP

Related Classes of javax.media.jai.PixelAccessor

com.sun.media.jai.codecimpl.util.ImageUtil

com.sun.media.jai.opimage.BandMergeOpImage

com.sun.media.jai.opimage.BinarizeOpImage

com.sun.media.jai.opimage.ColorQuantizerOpImage

com.sun.media.jai.opimage.DilateBinaryOpImage

com.sun.media.jai.opimage.ErodeBinaryOpImage

com.sun.media.jai.opimage.ExtremaOpImage

com.sun.media.jai.opimage.MeanOpImage

com.sun.media.jai.opimage.MedianCutOpImage

com.sun.media.jai.opimage.OctTreeOpImage$Cube

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.