Java JAI.KEY_IMAGE_LAYOUT屬性代碼示例

private PlanarImage makeTiledImage(PlanarImage img, int tileWidth, int tileHeight) {
    ImageLayout tileLayout = new ImageLayout(img);
    tileLayout.setTileWidth(tileWidth);
    tileLayout.setTileHeight(tileHeight);
    tileLayout.setSampleModel(img.getColorModel().createCompatibleSampleModel(tileWidth,tileHeight));
    tileLayout.setColorModel(img.getColorModel());
    RenderingHints tileHints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, tileLayout);
    ParameterBlock pb = new ParameterBlock();
    pb.addSource(img);
    PlanarImage pi = JAI.create("format", pb, tileHints);
    pi.getWidth();
    return pi;
}
 

private MultiLevelImage createProjectedImage(final GeoCoding sourceGeoCoding, final MultiLevelImage sourceImage,
                                             MultiLevelModel sourceModel, final Band targetBand, final Interpolation resampling,
                                             MultiLevelModel targetModel, Reproject reprojection) {
    final CoordinateReferenceSystem sourceModelCrs = Product.findModelCRS(sourceGeoCoding);
    final CoordinateReferenceSystem targetModelCrs = Product.findModelCRS(targetBand.getGeoCoding());
    final AffineTransform sourceImageToMapTransform = Product.findImageToModelTransform(sourceGeoCoding);
    final AffineTransform targetImageToMapTransform = Product.findImageToModelTransform(targetBand.getGeoCoding());

    return new DefaultMultiLevelImage(new AbstractMultiLevelSource(targetModel) {

        @Override
        public RenderedImage createImage(int targetLevel) {
            final double targetScale = targetModel.getScale(targetLevel);
            final int sourceLevel = sourceImage.getModel().getLevel(targetScale);
            RenderedImage leveledSourceImage = sourceImage.getImage(sourceLevel);

            final Rectangle sourceBounds = new Rectangle(leveledSourceImage.getMinX(),
                    leveledSourceImage.getMinY(),
                    leveledSourceImage.getWidth(),
                    leveledSourceImage.getHeight());

            // the following transformation maps the source level image to level zero and then to the model,
            // which either is a map or an image CRS
            final AffineTransform i2mSource = sourceModel.getImageToModelTransform(sourceLevel);
            i2mSource.concatenate(sourceModel.getModelToImageTransform(0));
            i2mSource.concatenate(sourceImageToMapTransform);
            ImageGeometry sourceGeometry = new ImageGeometry(sourceBounds,
                    sourceModelCrs,
                    i2mSource);

            ImageLayout imageLayout = ImageManager.createSingleBandedImageLayout(
                    ImageManager.getDataBufferType(targetBand.getDataType()),
                    targetBand.getRasterWidth(),
                    targetBand.getRasterHeight(),
                    targetProduct.getPreferredTileSize(),
                    ResolutionLevel.create(getModel(), targetLevel));
            Rectangle targetBounds = new Rectangle(imageLayout.getMinX(null), imageLayout.getMinY(null),
                    imageLayout.getWidth(null), imageLayout.getHeight(null));

            // the following transformation maps the target level image to level zero and then to the model,
            // which always is a map
            final AffineTransform i2mTarget = getModel().getImageToModelTransform(targetLevel);
            i2mTarget.concatenate(getModel().getModelToImageTransform(0));
            i2mTarget.concatenate(targetImageToMapTransform);

            ImageGeometry targetGeometry = new ImageGeometry(targetBounds,
                    targetModelCrs,
                    i2mTarget);
            Hints hints = new Hints(JAI.KEY_IMAGE_LAYOUT, imageLayout);
            hints.put(Hints.LENIENT_DATUM_SHIFT, Boolean.TRUE);

            Dimension tileSize = ImageManager.getPreferredTileSize(targetProduct);
            try {
                return reprojection.reproject(leveledSourceImage, sourceGeometry, targetGeometry,
                        targetBand.getNoDataValue(), resampling, hints, targetLevel,
                        tileSize);
            } catch (FactoryException | TransformException e) {
                Debug.trace(e);
                throw new RuntimeException(e);
            }
        }
    });
}
 

private byte[] getROIData(ROI roi, Rectangle rectIMG) {
    byte[] dataROI;
    PlanarImage roiIMG = roi.getAsImage();
    Rectangle rectROI = roiIMG.getBounds();
    // Forcing to component colormodel in order to avoid packed bits
    ImageWorker w = new ImageWorker();
    w.setImage(roiIMG);
    w.forceComponentColorModel();
    RenderedImage img = w.getRenderedImage();
    //
    BufferedImage test = new BufferedImage(rectIMG.width, rectIMG.height,
            BufferedImage.TYPE_BYTE_GRAY);
    ImageLayout2 layout = new ImageLayout2(test);
    layout.setMinX(img.getMinX());
    layout.setMinY(img.getMinY());
    layout.setWidth(img.getWidth());
    layout.setHeight(img.getHeight());
    // Lookup
    byte[] lut = new byte[256];
    lut[255] = 1;
    lut[1] = 1;
    LookupTableJAI table = new LookupTableJAI(lut);
    RenderingHints hints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
    RenderedOp transformed = LookupDescriptor.create(img, table, hints);

    Graphics2D gc2d = null;
    // Translation parameters in order to position the ROI data correctly in the Raster Space
    int trX = -rectIMG.x + rectROI.x - rectIMG.x;
    int trY = -rectIMG.y + rectROI.y - rectIMG.y;
    try {
        gc2d = test.createGraphics();
        gc2d.drawRenderedImage(transformed,
                AffineTransform.getTranslateInstance(trX, trY));
    } finally {
        gc2d.dispose();
    }
    Rectangle testRect = new Rectangle(rectIMG.width, rectIMG.height);
    DataBufferByte dbRoi = (DataBufferByte) test.getData(testRect).getDataBuffer();
    dataROI = dbRoi.getData();
    // BufferedImage is stored in memory so the planarImage chain before can be disposed
    ImageUtilities.disposePlanarImageChain(transformed);
    // Flush of the BufferedImage
    test.flush();

    return dataROI;
}
 

/**
 * Defines RenderingHints for JAI create operations (otherwise JAI will use defaultTileSize tiling)
 *
 * @param image
 * @return
 */
public static RenderingHints getRenderingHints(PlanarImage image) {
    ImageLayout layout = new ImageLayout(image.getMinX(), image.getMinY(), image.getWidth(), image.getHeight(), image.getTileGridXOffset(), image.getTileGridYOffset(), image.getTileWidth(), image.getTileHeight(), image.getSampleModel(), image.getColorModel());
    RenderingHints renderingHints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
    return renderingHints;
}