How to use

Kernel

in

java.awt.image

public RenderedImage render(Diagram diagram, BufferedImage image,  RenderingOptions options){
  RenderedImage renderedImage = image;
  Graphics2D g2 = image.createGraphics();
    antialiasSetting = RenderingHints.VALUE_ANTIALIAS_ON;
  g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialiasSetting);
  g2.setColor(Color.white);
  g2.fillRect(0, 0, image.getWidth()+10, image.getHeight()+10);
      for (int k = 0; k < blurRadius2; k++)
        elements[k] = weight;
      Kernel myKernel = new Kernel(blurRadius, blurRadius, elements);
        new ConvolveOp(myKernel, ConvolveOp.EDGE_NO_OP, null);
          image.getType());
      simpleBlur.filter(image, (BufferedImage) destination);

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
BufferedImage buffer = GraphicsManager.gc.createCompatibleImage(this.getWidth(), this.getHeight(), Transparency.TRANSLUCENT);
Graphics2D gb = buffer.createGraphics();
gb.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  g2.setPaint(new GradientPaint(0, -buttonHeight, Color.darkGray, 0, buttonHeight, buttonColor, false));
  g2.fillRoundRect(INSET, INSET, buttonWidth, buttonHeight, arc, arc);
  g2.setColor(Color.darkGray);
  ConvolveOp blurOp = new ConvolveOp(new Kernel(3, 3, BLUR));
  BufferedImage blurredImage = blurOp.filter(buffer, null);

final BufferedImage REFLECTION_IMAGE = new BufferedImage(SOURCE_IMAGE.getWidth(), SOURCE_IMAGE.getHeight(), BufferedImage.TYPE_INT_ARGB);
final BufferedImage BLURED_REFLECTION_IMAGE = new BufferedImage(SOURCE_IMAGE.getWidth(), SOURCE_IMAGE.getHeight(), BufferedImage.TYPE_INT_ARGB);
final Graphics2D G2 = REFLECTION_IMAGE.createGraphics();
G2.translate(0, SOURCE_IMAGE.getHeight());
G2.scale(1, -1);
G2.drawRenderedImage(SOURCE_IMAGE, null);
G2.setComposite(java.awt.AlphaComposite.getInstance(java.awt.AlphaComposite.DST_IN));
G2.setPaint(new java.awt.GradientPaint(0, SOURCE_IMAGE.getHeight() * FADE_OUT_HEIGHT, new Color(0.0f, 0.0f, 0.0f, 0.0f), 0, SOURCE_IMAGE.getHeight(), new Color(0.0f, 0.0f, 0.0f, OPACITY)));
  0.0625f
};
final java.awt.image.Kernel KERNEL = new java.awt.image.Kernel(3, 3, data);
final java.awt.image.ConvolveOp CONVOLE = new java.awt.image.ConvolveOp(KERNEL, java.awt.image.ConvolveOp.EDGE_NO_OP, null);
CONVOLE.filter(REFLECTION_IMAGE, BLURED_REFLECTION_IMAGE);

ColorModel srcCM = src.getColorModel();
ColorModel dstCM;
BufferedImage origDst = dst;
  src = icm.convertToIntDiscrete(src.getRaster(), false);
  srcCM = src.getColorModel();
Kernel gaussianBlur1 = new Kernel(matrix.length, 1, matrix);
Kernel gaussianBlur2 = new Kernel(1, matrix.length, matrix);
ConvolveOp gaussianOp1 = new ConvolveOp(gaussianBlur1, ConvolveOp.EDGE_NO_OP, null);
ConvolveOp gaussianOp2 = new ConvolveOp(gaussianBlur2, ConvolveOp.EDGE_NO_OP, null);
BufferedImage tempImage = new BufferedImage(src.getWidth(),
  tempImage = gaussianOp1.filter(nextSource, tempImage);
  dst = gaussianOp2.filter(tempImage, dst);
  java.awt.Graphics2D g = origDst.createGraphics();
try {
  g.drawImage(dst, 0, 0, null);
} finally {
  g.dispose();

BufferedImage bufferedImage = new BufferedImage(temp.getWidth(null), temp.getHeight(null),
  BufferedImage.TYPE_INT_RGB);
Graphics2D g1 = bufferedImage.createGraphics();
g1.setColor(Color.white);
g1.fillRect(0, 0, temp.getWidth(null), temp.getHeight(null));
g1.drawImage(temp, 0, 0, null);
g1.dispose();
float[] softenArray = { 0, softenFactor, 0, softenFactor, 1 - (softenFactor * 4), softenFactor, 0,
    softenFactor, 0 };
Kernel kernel = new Kernel(3, 3, softenArray);
ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
bufferedImage = cOp.filter(bufferedImage, null);
Graphics2D g = bufferedImage.createGraphics();

Graphics2D gBlurred = (Graphics2D) blurred.getGraphics();
gBlurred.setFont(graphics.getFont());
gBlurred.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
    RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
gBlurred.setColor(SubstanceColorUtilities
    .getNegativeColor(foregroundColor));
ConvolveOp convolve = new ConvolveOp(new Kernel(3, 3, new float[] {
    .02f, .05f, .02f, .05f, .02f, .05f, .02f, .05f, .02f }),
    ConvolveOp.EDGE_NO_OP, null);
gBlurred.drawString(text, xOffset, yOffset - 1);
blurred = convolve.filter(blurred, null);
graphics.setComposite(LafWidgetUtilities.getAlphaComposite(c,

public static BufferedImage differenceOfGaussians(BufferedImage image) {
  BufferedImage img1 = getGrayscaleImage(image);
  BufferedImage img2 = getGrayscaleImage(image);
  ConvolveOp gaussian1 = new ConvolveOp(new Kernel(5, 5, ImageUtils.makeGaussianKernel(5, 1.0f)));
  ConvolveOp gaussian2 = new ConvolveOp(new Kernel(5, 5, ImageUtils.makeGaussianKernel(5, 2.0f)));
  img1 = gaussian1.filter(img1, null);
  img2 = gaussian2.filter(img2, null);
  WritableRaster r1 = img1.getRaster();
  WritableRaster r2 = img2.getRaster();
  int[] tmp1 = new int[3];
  int[] tmp2 = new int[3];
  for (int x = 0; x < img1.getWidth(); x++) {
    for (int y = 0; y < img1.getHeight(); y++) {
      r1.getPixel(x, y, tmp1);
      r2.getPixel(x, y, tmp2);
      tmp1[0] = Math.abs(tmp1[0] - tmp2[0]);
      // System.out.println("tmp1 = " + tmp1[0]);
      if (tmp1[0] > 5) tmp1[0] = 0;
      else tmp1[0] = 255;
      r1.setPixel(x, y, tmp1);
    }
  }
  return img1;
}

if (buffer == null || buffer.getWidth() != getComponent().getWidth() ||
    buffer.getHeight() != getComponent().getHeight()) {
  buffer =
      new BufferedImage(getComponent().getWidth(),
      getComponent().getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = buffer.createGraphics();
g2.setComposite(AlphaComposite.Clear);
g2.setPaint(new Color(0.f, 0.f, 0.f, 0.f));
g2.fillRect(0, 0, buffer.getWidth(), buffer.getHeight());
  value, value, value
};
ConvolveOp vBlurOp = new ConvolveOp(new Kernel(3, 3, BLUR));
  buffer = vBlurOp.filter(buffer, null);
g2 = img.createGraphics();

  case EDGE_REFLECT:
  case EDGE_WRAP:
    original = addBorder(pOriginal, pKernel.getWidth() / 2, pKernel.getHeight() / 2, pEdgeOperation);
    break;
  default:
ConvolveOp convolve = new ConvolveOp(pKernel, pEdgeOperation, null);
if (original.getType() == BufferedImage.TYPE_3BYTE_BGR) {
  result = createBuffered(
      pOriginal.getWidth(), pOriginal.getHeight(),
      pOriginal.getType(), pOriginal.getColorModel().getTransparency()
  );
BufferedImage image = convolve.filter(original, result);
  image = image.getSubimage(
      pKernel.getWidth() / 2, pKernel.getHeight() / 2, pOriginal.getWidth(), pOriginal.getHeight()
  );

  || buffer.getWidth() != getWidth()
  || buffer.getHeight() != getHeight()) {
buffer = new BufferedImage(getWidth(), getHeight(),
    BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = buffer.createGraphics();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
    RenderingHints.VALUE_ANTIALIAS_ON);
  };
  ConvolveOp vBlurOp = new ConvolveOp(new Kernel(3, 3, BLUR));
  g2.dispose();
  buffer = vBlurOp.filter(buffer, null);
  g2 = buffer.createGraphics();
  g2.drawImage(notifier, null, getWidth() - notifier.getWidth(),
      0 + getInsets().top);

  textImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
  dropShadowImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D textImageG = textImage.createGraphics();
textImageG.setComposite(AlphaComposite.Clear);
textImageG.fillRect(0, 0, w, h);
textImageG.setComposite(AlphaComposite.SrcOver);
textImageG.setColor(TEXT_BLUR_COLOR);
paintText(textImageG, w, h);
    kernelData[i] = blurFactor;
  blur = new ConvolveOp(new Kernel(kw, kh, kernelData));
blurryImageG.drawImage(textImage, blur, SHIFT_X, SHIFT_Y);

RoundRectangle2D rect = new RoundRectangle2D.Double (0, 0, rectWidth, rectWidth, cornerSize, cornerSize);
int imageWidth = rectWidth + shadowSize * 2;
BufferedImage image = new BufferedImage (imageWidth, imageWidth, BufferedImage.TYPE_INT_ARGB);
Graphics2D buffer = (Graphics2D) image.getGraphics ();
buffer.setRenderingHint (RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
buffer.setRenderingHint (RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
buffer.setRenderingHint (RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
buffer.setRenderingHint (RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
buffer.setColor (new Color (0.0f, 0.0f, 0.0f, shadowOpacity));
  blurKernel[i] = blurry;
ConvolveOp blur = new ConvolveOp (new Kernel (shadowSize, shadowSize, blurKernel));
BufferedImage targetImage = new BufferedImage (imageWidth, imageWidth, BufferedImage.TYPE_INT_ARGB);
((Graphics2D) targetImage.getGraphics ()).drawImage (image, blur, -(shadowSize / 2), -(shadowSize / 2));

final Kernel horizontalKernel = new Kernel(kernel.length, 1, kernel);
final Kernel verticalKernel = new Kernel(1, kernel.length, kernel);
  final int blurredWidth = useOriginalImageAsDestination ? image.getWidth() : image.getWidth() + 4 * filterRadius;
  final int blurredHeight = useOriginalImageAsDestination ? image.getHeight() : image.getHeight() + 4 * filterRadius;
  final Graphics2D graphics0 = img0.createGraphics();
  graphics0.drawImage(image, null, useOriginalImageAsDestination ? 0 : 2 * filterRadius, useOriginalImageAsDestination ? 0 : 2 * filterRadius);
  graphics0.dispose();
  final Graphics2D graphics1 = img1.createGraphics();
  graphics1.drawImage(img0, new ConvolveOp(horizontalKernel, ConvolveOp.EDGE_NO_OP, null), 0, 0);
  graphics1.dispose();
  BufferedImage destination = useOriginalImageAsDestination ? image : new BufferedImage(blurredWidth, blurredHeight, BufferedImage.TYPE_INT_ARGB);
  final Graphics2D destGraphics = destination.createGraphics();
  destGraphics.drawImage(img1, new ConvolveOp(verticalKernel, ConvolveOp.EDGE_NO_OP, null), 0, 0);
  destGraphics.dispose();

int imageWidth = rectWidth + shadowSize * 2;
BufferedImage image = GraphicsUtilities.createCompatibleTranslucentImage(imageWidth, imageWidth);
Graphics2D buffer = (Graphics2D)image.getGraphics();
  buffer.setPaint(new Color(shadowColor.getRed(), shadowColor.getGreen(),
      shadowColor.getBlue(), (int)(shadowOpacity * 255)));
  buffer.translate(shadowSize, shadowSize);
  buffer.fill(rect);
} finally {
  buffer.dispose();
  blurKernel[i] = blurry;
ConvolveOp blur = new ConvolveOp(new Kernel(shadowSize, shadowSize, blurKernel));
BufferedImage targetImage = GraphicsUtilities.createCompatibleTranslucentImage(imageWidth, imageWidth);
((Graphics2D)targetImage.getGraphics()).drawImage(image, blur, -(shadowSize/2), -(shadowSize/2));
images.put(Position.TOP, getSubImage(targetImage, x, y, w, h));
image.flush();
CACHE.put(shadowSize + (shadowColor.hashCode() * .3) + (shadowOpacity * .12), images); //TODO do a real hash

BufferedImage bufferedImage =  new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
Graphics2D g2D = bufferedImage.createGraphics();
g2D.drawImage(awtImage, 0, 0, null);
};
BufferedImageOp op = new ConvolveOp( new Kernel(3, 3, blurKernel));
bufferedImage = op.filter(bufferedImage, null);
bufferedImage = op.filter(bufferedImage, null);
g2D = bufferedImage.createGraphics();
g2D.setColor(new Color(0x3300FF));
Font font = new Font("Sans", Font.BOLD, 60);
g2D.setFont(font);
g2D.drawString("ImageJ", 20, 220); 

/**
 *
 * @param sourceImage
 * @param amount recommended amount is between 1 and 10
 * @return
 */
public BufferedImage sharpen(BufferedImage sourceImage, int amount) {
  BufferedImage resultImage =  new BufferedImage(sourceImage.getWidth(), sourceImage.getHeight(), sourceImage.getType());
  float sharpenAmmount = amount * 0.2f;
  float[] data = new float[]{
      0.0f, -sharpenAmmount, 0.0f,
      -sharpenAmmount, 4f * sharpenAmmount + 1f, -sharpenAmmount,
      0.0f, -sharpenAmmount, 0.0f
  };
  Kernel kernel = new Kernel(3, 3, data);
  BufferedImageOp bufferedImageOp = new ConvolveOp(kernel);
  bufferedImageOp.filter(sourceImage, resultImage);
  return resultImage;
}

try {
 BufferedImage im = ImageIO.read(new File("map.png"));
 cop = new ConvolveOp(new Kernel(3, 3, new float[] { 0f, 1f / 5f, 0f, 1f / 5f, 1f / 5f, 1f / 5f, 0f, 1f / 5f, 0f }),
  ConvolveOp.EDGE_NO_OP, null);
Dimension dim = new Dimension((int) (im.getWidth() * scale), (int) (im.getHeight() * scale));
nim = new BufferedImage(dim.width, dim.height, BufferedImage.TYPE_INT_RGB);
Graphics2D g = (Graphics2D) nim.getGraphics();
g.scale(scale, scale);
g.drawImage(im, cop, 0, 0);
g.dispose();
return nim;

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
BufferedImage buffer = GraphicsManager.gc.createCompatibleImage(this.getWidth(), this.getHeight(), Transparency.TRANSLUCENT);
Graphics2D gb = buffer.createGraphics();
gb.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Color topColoring = backgroundColor.darker().darker().darker();
Color bottomColoring = backgroundColor.brighter().brighter().brighter();
gb.setPaint(new GradientPaint(0, INSET, topColoring, 0, buttonHeight, bottomColoring, false));
ConvolveOp blurOp = new ConvolveOp(new Kernel(3, 3, BLUR));
BufferedImage blurredImage = blurOp.filter(buffer, null);

    || renderBuffer.getWidth() != getWidth()
    || renderBuffer.getHeight() != getHeight();
  Graphics2D g2Buffer = renderBuffer.createGraphics();
  g2Buffer.dispose();
  };
  ConvolveOp vBlurOp = new ConvolveOp(new Kernel(3, 3, BLUR));
  renderBuffer = vBlurOp.filter(renderBuffer, null);
g2.drawImage(renderBuffer, 0, 0, null);

private float getComplexity(BufferedImage img) {
  //Uses its own resizing method to remove color in the same step
  BufferedImage sml = new BufferedImage(SIZE, SIZE, BufferedImage.TYPE_BYTE_GRAY);
  sml.getGraphics().drawImage(img, 0, 0, SIZE, SIZE, null);
  float ret = 0;
  int w = sml.getWidth();
  int h = sml.getHeight();
  Kernel laplace = new Kernel(3, 3, new float[]{1, 1, 1, 1, -8, 1, 1, 1, 1});
  ConvolveOp filter = new ConvolveOp(laplace);
  BufferedImage dest = filter.createCompatibleDestImage(sml, null);
  filter.filter(sml, dest);
  WritableRaster data = dest.getRaster();
  int[] pixels = data.getPixels(0, 0, w, h, new int[w * h]);
  int sum = 0;
  for (int i = 0; i < w; i++) {
    for (int j = 0; j < h; j++) {
      int temp = pixels[i + j * w];
      sum += temp;
    }
  }
  ret = (float) sum / (w * h * 256);
  if (ret < 0.01) {
    ret = 1;
  }
  return ret;
}