How to use

createInstance

method

in

javax.media.jai.BorderExtender

  /**
   * Create a new instance of TransparencyFillOpImage in the rendered layer. This method satisfies
   * the implementation of RIF.
   *
   * @param paramBlock The source image and the dilation kernel.
   */
  public RenderedImage create(ParameterBlock paramBlock, RenderingHints renderHints) {
    // Get ImageLayout from renderHints if any.
    ImageLayout layout = RIFUtil.getImageLayoutHint(renderHints);

    // Get BorderExtender from renderHints if any.
    BorderExtender extender = RIFUtil.getBorderExtenderHint(renderHints);
    if (extender == null) {
      extender = BorderExtender.createInstance(BorderExtender.BORDER_COPY);
    }
    FillType type = TransparencyFillDescriptor.FILL_AVERAGE;
    Object param0 = paramBlock.getObjectParameter(0);
    if (param0 != null && param0 instanceof FillType) {
      type = (FillType) param0;
    }
    RenderedImage source = paramBlock.getRenderedSource(0);
    return new TransparencyFillOpImage(source, extender, type, renderHints, layout);
  }
}

new RenderingHints(
    JAI.KEY_BORDER_EXTENDER,
    BorderExtender.createInstance(BorderExtender.BORDER_COPY)));

  this.borderExtender = BorderExtender.createInstance(DEFAULT_BORDER_EXTENDER_TYPE);
} else this.borderExtender = be;
if (index + 1 < interpolations.length) {

  public static RenderedImage blur(RenderedImage image, int radius) {
    int klen = Math.max(radius, 2);
    int ksize = klen * klen;
    float f = 1f / ksize;
    float[] kern = new float[ksize];
    for (int i = 0; i < ksize; i++)
      kern[i] = f;
    KernelJAI blur = new KernelJAI(klen, klen, kern);
    ParameterBlockJAI param = getParameterBlockJAIForImage(image, "Convolve");
    param.setParameter("kernel", blur);
    // hint with border extender
    RenderingHints hint = new RenderingHints(JAI.KEY_BORDER_EXTENDER, BorderExtender
        .createInstance(BorderExtender.BORDER_COPY));
    return JAI.create("Convolve", param, hint);
  }
}

protected PlanarImage scaleUnit(PlanarImage image) {
  final RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,
      BorderExtender.createInstance(BorderExtender.BORDER_ZERO));
  final ParameterBlockJAI pb = new ParameterBlockJAI("DivideByConst",
      RenderedRegistryMode.MODE_NAME);
  pb.setSource("source0", image);
  pb.setParameter("constants", new double[] { scaleArea });
  return JAI.create("DivideByConst", pb, hints);
}

hints.put(
    JAI.KEY_BORDER_EXTENDER,
    BorderExtender.createInstance(BorderExtender.BORDER_COPY));

private RenderedImage smoothImage(final RenderedImage rawImage) {
  final int slidingWindowWidth = windowWidth / blockWidth;
  final int slidingWindowHeight = windowHeight / blockHeight;
  final BorderExtender extender = BorderExtender.createInstance(BorderExtender.BORDER_REFLECT);
  final RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER, extender);
  final ParameterBlock pb = new ParameterBlock();
  pb.addSource(rawImage);
  pb.add(slidingWindowWidth);
  pb.add(slidingWindowHeight);
  pb.add(slidingWindowWidth / 2);
  pb.add(slidingWindowHeight / 2);
  return JAI.create("boxfilter", pb, hints);
}

private static RenderedOp createScaledImage(int targetWidth, int targetHeight, int sourceWidth, int sourceHeight,
                      int sourceSampling, ProductData data, Dimension tileSize) {
  int tempW = sourceWidth * sourceSampling + 1;
  int tempH = sourceHeight * sourceSampling + 1;
  float xScale = (float) tempW / (float) sourceWidth;
  float yScale = (float) tempH / (float) sourceHeight;
  RenderingHints renderingHints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,
                            BorderExtender.createInstance(BorderExtender.BORDER_COPY));
  RenderedImage srcImg = ImageUtils.createRenderedImage(sourceWidth, sourceHeight, data);
  ImageLayout imageLayout = new ImageLayout(0, 0, targetWidth, targetHeight,
      0, 0, tileSize.width, tileSize.height, null, null);
  renderingHints.put(JAI.KEY_IMAGE_LAYOUT, imageLayout);
  RenderedOp tempImg = ScaleDescriptor.create(srcImg, xScale, yScale,
                        -0.5f * sourceSampling + 1,
                        -0.5f * sourceSampling + 1,
                        Interpolation.getInstance(Interpolation.INTERP_BILINEAR),
                        renderingHints);
  return CropDescriptor.create(tempImg, 0f, 0f, (float) targetWidth, (float) targetHeight, null);
}

  @Override
  protected RenderedImage createImage(int level) {
    ImageManager imageManager = ImageManager.getInstance();
    RenderingHints rh = new RenderingHints(JAI.KEY_BORDER_EXTENDER, BorderExtender.createInstance(
        BorderExtenderCopy.BORDER_COPY));
    PlanarImage geophysicalImage = imageManager.getGeophysicalImage(getSource(), level);
    int dataBufferType = getDataType() == ProductData.TYPE_FLOAT64 ? DataBuffer.TYPE_DOUBLE : DataBuffer.TYPE_FLOAT;
    geophysicalImage = FormatDescriptor.create(geophysicalImage, dataBufferType, null);
    PlanarImage validMaskImage = imageManager.getValidMaskImage(getSource(), level);
    if (validMaskImage != null) {
      geophysicalImage = new FillConstantOpImage(geophysicalImage, validMaskImage, Float.NaN);
    }
    return createSourceLevelImage(geophysicalImage, level, rh);
  }
};

 @Override
 protected PlanarImage execute (PadBlackOp operation, final EditableImage image, PlanarImage planarImage)
  {
   ParameterBlock pb = new ParameterBlock();
   int width = planarImage.getData().getWidth();
   int height = planarImage.getData().getHeight();
   int padx = width;
   int pady = height;
   pb.addSource(planarImage);
   pb.add(padx);
   pb.add(padx);
   pb.add(pady);
   pb.add(pady);
   pb.add(BorderExtender.createInstance(BorderExtender.BORDER_ZERO));    
   planarImage = JAI.create("border", pb);    
   JAIUtils.logImage(log, ">>>> PadBlackOp returning", planarImage);
   
   return planarImage;
  }
}

 /*******************************************************************************
  *
  * @inheritDoc
  *
  ******************************************************************************/
 protected PlanarImage execute (PadBlackOp operation, final EditableImage image, PlanarImage planarImage)
  {
   ParameterBlock pb = new ParameterBlock();
   int width = planarImage.getData().getWidth();
   int height = planarImage.getData().getHeight();
   int padx = width;
   int pady = height;
   pb.addSource(planarImage);
   pb.add(padx);
   pb.add(padx);
   pb.add(pady);
   pb.add(pady);
   pb.add(BorderExtender.createInstance(BorderExtender.BORDER_ZERO));    
   planarImage = JAI.create("border", pb);    
   JAIUtils.logImage(logger, ">>>> PadBlackOp returning", planarImage);
   
   return planarImage;
  }
}

public static RenderedImage addBorder(RenderedImage inputImage, int left, int right, int top, int bottom) {
  ParameterBlock pb = new ParameterBlock();
  pb.addSource(inputImage);
  pb.add(left);
  pb.add(right);
  pb.add(top);
  pb.add(bottom);
  pb.add(BorderExtender.createInstance(BorderExtender.BORDER_ZERO));
  return JAI.create("border", pb);
}

public static BufferedImage addBorder(BufferedImage inputImage, int left, int right, int top, int bottom) {
  ParameterBlock pb = new ParameterBlock();
  pb.addSource(inputImage);
  pb.add(left);
  pb.add(right);
  pb.add(top);
  pb.add(bottom);
  pb.add(BorderExtender.createInstance(BorderExtender.BORDER_ZERO));
  return JAI.create("border", pb).getAsBufferedImage();
}

private void assertNoDataBleed(Interpolation interpolation, RenderedImage source, int expectedValue) {
  RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,BorderExtender.createInstance(BorderExtender.BORDER_COPY));
  RenderedImage scaled= ScaleDescriptor.create(source, 2f, 2f,
      0f, 0f, interpolation, null, null, RangeFactory.create(0, 0), null, hints);
  // make sure all pixels are solid like the input ones
  Raster raster = scaled.getData();
  for (int i = raster.getMinY(); i < raster.getMinY() + raster.getHeight(); i++) {
    for (int j = raster.getMinX(); j < raster.getMinX() + raster.getWidth(); j++) {
      int value = raster.getSample(j, i, 0);
      assertEquals("Unexpected value at " + i + ", " + j + ": " + value, expectedValue, value);
    }
  }
}

private void assertNoDataBleed(Interpolation interpolation, RenderedImage source, int expectedValue) {
  RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,BorderExtender.createInstance(BorderExtender.BORDER_COPY));
  RenderedImage scaled= Scale2Descriptor.create(source, 2d, 2d,
      0d, 0d, interpolation, null, null, RangeFactory.create(0, 0), null, hints);
  // make sure all pixels are solid like the input ones
  Raster raster = scaled.getData();
  for (int i = raster.getMinY(); i < raster.getMinY() + raster.getHeight(); i++) {
    for (int j = raster.getMinX(); j < raster.getMinX() + raster.getWidth(); j++) {
      int value = raster.getSample(j, i, 0);
      assertEquals("Unexpected value at " + i + ", " + j + ": " + value, expectedValue, value);
    }
  }
}

 @Override
 protected PlanarImage execute (PadPeriodicOp operation, final EditableImage image, PlanarImage planarImage)
  {
   int oldWidth = planarImage.getData().getWidth();
   int oldHeight = planarImage.getData().getHeight();
   int newWidth = JAIUtils.closestPower2Size(oldWidth);
   int newHeight = JAIUtils.closestPower2Size(oldHeight);
   int padx = (newWidth - oldWidth) / 2;
   int pady = (newHeight - oldHeight) / 2;
   log.debug(">>>> pad: {}, {}", padx, pady);
   ParameterBlock pb = new ParameterBlock();
   pb.addSource(planarImage);
   pb.add((float)padx);
   pb.add((float)pady);
   RenderedOp trans = JAI.create("translate", pb);
   pb = new ParameterBlock();
   pb.addSource(trans);
   pb.add(padx);
   pb.add(padx);
   pb.add(pady);
   pb.add(pady);
   pb.add(BorderExtender.createInstance(BorderExtender.BORDER_WRAP));
   planarImage = JAI.create("border", pb);
   
   JAIUtils.logImage(log, ">>>> PadPeriodicJAIOp returning", planarImage);
   
   return planarImage;
  }
}

/**
 * Build a 4x4 image with pixels having value as the sum of their coordinates, attaches
 * a ROI covering the 4 central pixels, and scales up by a factor of 2 with the given interpolation
 * @param dataType
 * @return
 */
protected RenderedImage buildImageWithROI(int dataType, Interpolation interpolation, boolean useROIAccessor, Range noData) {
  
  int width = 4;
  int height = 4;
  SampleModel sm = new ComponentSampleModel(dataType, width, height, 1, width, new int[] {0});
  TiledImage source =
      new TiledImage(0, 0, width, height, 0, 0, sm, PlanarImage.createColorModel(sm));
  for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
      source.setSample(x, y, 0, x + y);
    }
  }
  
  // build a ROI covering the center of the image and associate
  ROI roi = new ROIShape(new Rectangle(1, 1, 2, 2));
  RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,BorderExtender.createInstance(BorderExtender.BORDER_COPY));
  hints.put(JAI.KEY_IMAGE_LAYOUT, new ImageLayout(0, 0, width * 2, height * 2, 0, 0, width * 2, height * 2, null, null));
  return ScaleDescriptor.create(source, 2f, 2f, 0f, 0f, interpolation, roi, useROIAccessor, noData, new double[] {0}, hints);
}

  /**
   * Build a 4x4 image with pixels having value as the sum of their coordinates, attaches
   * a ROI covering the 4 central pixels, and scales up by a factor of 2 with the given interpolation
   * @param dataType
   * @return
   */
  protected RenderedImage buildImageWithROI(int dataType, Interpolation interpolation, boolean useROIAccessor, Range noData) {
    
    int width = 4;
    int height = 4;
    SampleModel sm = new ComponentSampleModel(dataType, width, height, 1, width, new int[] {0});
    TiledImage source =
        new TiledImage(0, 0, width, height, 0, 0, sm, PlanarImage.createColorModel(sm));
    for (int y = 0; y < height; y++) {
      for (int x = 0; x < width; x++) {
        source.setSample(x, y, 0, x + y);
      }
    }
    
    // build a ROI covering the center of the image and associate
    ROI roi = new ROIShape(new Rectangle(1, 1, 2, 2));
    RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,BorderExtender.createInstance(BorderExtender.BORDER_COPY));
    hints.put(JAI.KEY_IMAGE_LAYOUT, new ImageLayout(0, 0, width * 2, height * 2, 0, 0, width * 2, height * 2, null, null));
    return Scale2Descriptor.create(source, 2d, 2d, 0d, 0d, interpolation, roi, useROIAccessor, noData, new double[] {0}, hints);
  }
}

protected void assertInterpolateInHole(int dataType, Interpolation interpolation) {
  // build image with high ring at borders and almost nodata in the middle
  SampleModel sm = new ComponentSampleModel(dataType, 10, 10, 1, 10, new int[] {0});
  int width = 10;
  int height = 10;
  TiledImage source = new TiledImage(0, 0, 10, 10, 0, 0, sm, PlanarImage.createColorModel(sm));
  for (int y = 0; y < height; y++) {
    for (int x = 0; x < width; x++) {
      if(x == 0 || x == (width - 1) || y == 0 || y == (height - 1)) {
        source.setSample(x, y, 0, 255);
      } else {
        source.setSample(x, y, 0, 1);
      }
      
    }
  }
  RenderingHints hints = new RenderingHints(JAI.KEY_BORDER_EXTENDER,BorderExtender.createInstance(BorderExtender.BORDER_COPY));
  RenderedImage scaled= ScaleDescriptor.create(source, 2f, 2f,
      0f, 0f, interpolation, null, null, RangeFactory.create(0, 0), null, hints);
  // make sure none of the pixels became 0
  Raster raster = scaled.getData();
  for (int i = raster.getMinY(); i < raster.getMinY() + raster.getHeight(); i++) {
    for (int j = raster.getMinX(); j < raster.getMinX() + raster.getWidth(); j++) {
      int value = raster.getSample(j, i, 0);
      assertTrue("Expected valid value but found nodata", value > 0);
    }
  }
}

BorderExtender.createInstance(BorderExtender.BORDER_COPY));