Java Tutorial/2D Graphics/Image
Содержание
- 1 A 3x3 kernel that blurs an image.
- 2 A 3x3 kernel that embosses an image.
- 3 A 3x3 kernel that sharpens an image.
- 4 A reflected image: effect makes an illusion as if the image was reflected in water
- 5 Blur our image: Blur means an unfocused image
- 6 Brighten the image by 30%
- 7 Calculation of the mean value of an image
- 8 Create a filter that can modify any of the RGB pixel values in an image.
- 9 Create a grayscale image with Java 2D tools
- 10 Creates PNG images of the specified color that fade from fully opaque to fully transparent
- 11 Darken the image by 10%
- 12 Determining If an Image Has Transparent Pixels
- 13 Draw an Icon object
- 14 Draw Image
- 15 Enlarging an image by pixel replication
- 16 Filtering the RGB Values in an Image
- 17 Flip an image
- 18 Flush an image
- 19 Get average of a set of images
- 20 Get the dimensions of the image; these will be non-negative
- 21 Getting the Color Model of an Image
- 22 Gray scale image operation
- 23 Load Image and scale it
- 24 Reading an Image or Icon from a File
- 25 Resize an image
- 26 Rotating a Drawn Image
- 27 Scaling a Drawn Image
- 28 Shearing a Drawn Image
- 29 Shrinking an image by skipping pixels
- 30 This filter removes all but the red values in an image
- 31 Translating a Drawn Image
- 32 Use PixelGrabber class to acquire pixel data from an Image object
- 33 Using mediatracker to pre-load images
A 3x3 kernel that blurs an image.
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; public class Main {
public static void main(String[] argv) throws Exception {
BufferedImage bufferedImage = new BufferedImage(200, 200,
BufferedImage.TYPE_BYTE_INDEXED);
Kernel kernel = new Kernel(3, 3, new float[] { 1f / 9f, 1f / 9f, 1f / 9f,
1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f });
BufferedImageOp op = new ConvolveOp(kernel);
bufferedImage = op.filter(bufferedImage, null);
}
}</source>
A 3x3 kernel that embosses an image.
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; public class Main {
public static void main(String[] argv) throws Exception {
BufferedImage bufferedImage = new BufferedImage(200, 200,
BufferedImage.TYPE_BYTE_INDEXED);
Kernel kernel = new Kernel(3, 3, new float[] { -2, 0, 0, 0, 1, 0, 0, 0, 2 });
BufferedImageOp op = new ConvolveOp(kernel);
bufferedImage = op.filter(bufferedImage, null);
}
}</source>
A 3x3 kernel that sharpens an image.
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; public class Main {
public static void main(String[] argv) throws Exception {
BufferedImage bufferedImage = new BufferedImage(200, 200,
BufferedImage.TYPE_BYTE_INDEXED);
Kernel kernel = new Kernel(3, 3, new float[] { -1, -1, -1, -1, 9, -1, -1,
-1, -1 });
BufferedImageOp op = new ConvolveOp(kernel);
bufferedImage = op.filter(bufferedImage, null);
}
}</source>
A reflected image: effect makes an illusion as if the image was reflected in water
<source lang="java">
import java.awt.AlphaComposite; import java.awt.Color; import java.awt.GradientPaint; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.image.BufferedImage; import java.io.File; import javax.imageio.ImageIO; import javax.swing.JComponent; import javax.swing.JFrame; public class ImageReflection extends JComponent {
public void paintComponent(Graphics g) {
try {
BufferedImage image = ImageIO.read(new File("yourImage.jpg"));
Graphics2D g2d = (Graphics2D) g;
int width = getWidth();
int height = getHeight();
int imageWidth = image.getWidth();
int imageHeight = image.getHeight();
int gap = 20;
float opacity = 0.4f;
float fadeHeight = 0.3f;
g2d.translate((width - imageWidth) / 2, height / 2 - imageHeight);
g2d.drawRenderedImage(image, null);
g2d.translate(0, 2 * imageHeight + gap);
g2d.scale(1, -1);
BufferedImage reflection = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB);
Graphics2D rg = reflection.createGraphics();
rg.drawRenderedImage(image, null);
rg.setComposite(AlphaComposite.getInstance(AlphaComposite.DST_IN));
rg.setPaint(new GradientPaint(0, imageHeight * fadeHeight, new Color(0.0f, 0.0f, 0.0f, 0.0f),
0, imageHeight, new Color(0.0f, 0.0f, 0.0f, opacity)));
rg.fillRect(0, 0, imageWidth, imageHeight);
rg.dispose();
g2d.drawRenderedImage(reflection, null);
} catch (Exception e) {
}
}
public static void main(String[] args) {
JFrame frame = new JFrame("Reflection");
ImageReflection r = new ImageReflection();
frame.add(r);
frame.setSize(300, 300);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}</source>
Blur our image: Blur means an unfocused image
<source lang="java">
import java.awt.Dimension; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; import javax.imageio.ImageIO; import javax.swing.JFrame; import javax.swing.JPanel; public class BlurredImage extends JPanel {
public void paint(Graphics g) {
try {
BufferedImage myImage = ImageIO.read(this.getClass().getResource("redrock.png"));
BufferedImage filteredImage = new BufferedImage(myImage.getWidth(null), myImage
.getHeight(null), BufferedImage.TYPE_BYTE_GRAY);
Graphics g1 = filteredImage.getGraphics();
g1.drawImage(myImage, 400, 200, null);
float[] blurKernel = { 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f, 1 / 9f };
BufferedImageOp blur = new ConvolveOp(new Kernel(3, 3, blurKernel));
myImage = blur.filter(myImage, null);
g1.dispose();
Graphics2D g2d = (Graphics2D) g;
g2d.drawImage(myImage, null, 3, 3);
} catch (Exception e) {
}
}
public static void main(String[] args) {
JFrame frame = new JFrame("Blurred Image");
frame.add(new BlurredImage());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400,400);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}</source>
Brighten the image by 30%
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.RescaleOp; public class Main {
public static void main(String[] argv) throws Exception {
BufferedImage bufferedImage = new BufferedImage(200, 200,
BufferedImage.TYPE_BYTE_INDEXED);
float scaleFactor = 1.3f;
RescaleOp op = new RescaleOp(scaleFactor, 0, null);
bufferedImage = op.filter(bufferedImage, null);
}
}</source>
Calculation of the mean value of an image
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.Raster; public class Main {
public static void main(String[] argv) throws Exception {
}
public static double meanValue(BufferedImage image) {
Raster raster = image.getRaster();
double sum = 0.0;
for (int y = 0; y < image.getHeight(); ++y){
for (int x = 0; x < image.getWidth(); ++x){
sum += raster.getSample(x, y, 0);
}
}
return sum / (image.getWidth() * image.getHeight());
}
}</source>
Create a filter that can modify any of the RGB pixel values in an image.
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; import java.awt.image.FilteredImageSource; import java.awt.image.ImageFilter; import java.awt.image.RGBImageFilter; import javax.swing.ImageIcon;
class GetRedFilter extends RGBImageFilter {
public GetRedFilter() {
canFilterIndexColorModel = true;
}
public int filterRGB(int x, int y, int rgb) {
if (x == -1) {
}
return rgb & 0xffff0000;
}
} public class Main {
public static void main(String[] argv) throws Exception {
Image image = new ImageIcon("image.gif").getImage();
ImageFilter filter = new GetRedFilter();
FilteredImageSource filteredSrc = new FilteredImageSource(image.getSource(), filter);
image = Toolkit.getDefaultToolkit().createImage(filteredSrc);
}
}</source>
Create a grayscale image with Java 2D tools
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.image.BufferedImage; import javax.swing.ImageIcon; import javax.swing.JFrame; import javax.swing.JPanel; public class GrayImage extends JPanel {
public GrayImage() {
}
public void paint(Graphics g) {
Image myImage = new ImageIcon("yourImage.png").getImage();
BufferedImage bufferedImage = new BufferedImage(myImage.getHeight(this), myImage.getWidth(this), BufferedImage.TYPE_BYTE_GRAY);
Graphics gi = bufferedImage.getGraphics();
gi.drawImage(myImage, 0, 0, null);
gi.dispose();
Graphics2D g2d = (Graphics2D) g;
g2d.drawImage(bufferedImage, null, 0, 0);
}
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.add(new GrayImage());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400,400);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}</source>
Creates PNG images of the specified color that fade from fully opaque to fully transparent
<source lang="java">
/*
* Copyright (c) 2004 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 3nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose, * including teaching and use in open-source projects. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book, * please visit http://www.davidflanagan.ru/javaexamples3. */
import java.io.*; import java.awt.*; import java.awt.image.*; /*
* This program creates PNG images of the specified color that fade from fully * opaque to fully transparent. Images of this sort are useful in web design * where they can be used as background images and combined with background * colors to produce two-color fades. (IE6 does not support PNG transparency). * * Images are produced in three sizes and with and 8 directions. The images are * written into the current directory and are given names of the form: * fade-to-color-speed-direction.png * * color: the color name specified on the command line speed: slow (1024px), * medium (512px), fast(256px) direction: a compass point: N, E, S, W, NE, SE, * SW, NW * * Invoke this program with a color name and three floating-point values * specifying the red, green, and blue components of the color. */
public class MakeFades {
// A fast fade is a small image, and a slow fade is a large image
public static final String[] sizeNames = { "fast", "medium", "slow" };
public static final int[] sizes = { 256, 512, 1024 };
// Direction names and coordinates
public static final String[] directionNames = { "N", "E", "S", "W", "NE", "SE", "SW", "NW" };
public static float[][] directions = { new float[] { 0f, 1f, 0f, 0f }, // North
new float[] { 0f, 0f, 1f, 0f }, // East
new float[] { 0f, 0f, 0f, 1f }, // South
new float[] { 1f, 0f, 0f, 0f }, // West
new float[] { 0f, 1f, 1f, 0f }, // Northeast
new float[] { 0f, 0f, 1f, 1f }, // Southeast
new float[] { 1f, 0f, 0f, 1f }, // Southwest
new float[] { 1f, 1f, 0f, 0f } // Northwest
};
public static void main(String[] args) throws IOException, NumberFormatException {
// Create from and to colors based on those arguments
Color from = Color.RED; // transparent
Color to = Color.BLACK; // opaque
// Loop through the sizes and directions, and create an image for each
for (int s = 0; s < sizes.length; s++) {
for (int d = 0; d < directions.length; d++) {
// This is the size of the image
int size = sizes[s];
// Create a GradientPaint for this direction and size
Paint paint = new GradientPaint(directions[d][0] * size, directions[d][1] * size, from,
directions[d][2] * size, directions[d][3] * size, to);
// Start with a blank image that supports transparency
BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
// Now use fill the image with our color gradient
Graphics2D g = image.createGraphics();
g.setPaint(paint);
g.fillRect(0, 0, size, size);
// This is the name of the file we"ll write the image to
File file = new File("fade-to-" + sizeNames[s] + "-" + directionNames[d]
+ ".png");
// Save the image in PNG format using the javax.imageio API
javax.imageio.ImageIO.write(image, "png", file);
// Show the user our progress by printing the filename
System.out.println(file);
}
}
}
}</source>
Darken the image by 10%
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.RescaleOp; public class Main {
public static void main(String[] argv) throws Exception {
BufferedImage bufferedImage = new BufferedImage(200, 200,
BufferedImage.TYPE_BYTE_INDEXED);
RescaleOp op = new RescaleOp(.9f, 0, null);
bufferedImage = op.filter(bufferedImage, null);
}
}</source>
Determining If an Image Has Transparent Pixels
<source lang="java">
import java.awt.Image; import java.awt.image.BufferedImage; import java.awt.image.ColorModel; import java.awt.image.PixelGrabber; import javax.swing.ImageIcon; public class Main {
public static void main(String[] argv) throws Exception {
Image image = new ImageIcon("a.png").getImage();
if (image instanceof BufferedImage) {
BufferedImage bimage = (BufferedImage) image;
System.out.println(bimage.getColorModel().hasAlpha());
}
PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
try {
pg.grabPixels();
} catch (InterruptedException e) {
}
ColorModel cm = pg.getColorModel();
System.out.println(cm.hasAlpha());
}
}</source>
Draw an Icon object
<source lang="java">
import java.awt.Graphics; import javax.swing.ImageIcon; import javax.swing.JComponent; import javax.swing.JFrame; public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
} class MyComponent extends JComponent {
public void paint(Graphics g) {
ImageIcon icon = new ImageIcon("a.png");
int x = 0;
int y = 100;
icon.paintIcon(this, g, x, y);
}
}</source>
Draw Image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Toolkit; import javax.swing.JComponent; import javax.swing.JFrame; class MyCanvas extends JComponent {
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Image img1 = Toolkit.getDefaultToolkit().getImage("yourFile.gif");
g2.drawImage(img1, 10, 10, this);
g2.finalize();
}
} public class Graphics2DDrawImage {
public static void main(String[] a) {
JFrame window = new JFrame();
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.setBounds(30, 30, 300, 300);
window.getContentPane().add(new MyCanvas());
window.setVisible(true);
}
}</source>
Enlarging an image by pixel replication
<source lang="java">
import java.awt.image.BufferedImage; public class Main {
public static void main(String[] argv) throws Exception {
}
public static BufferedImage enlarge(BufferedImage image, int n) {
int w = n * image.getWidth();
int h = n * image.getHeight();
BufferedImage enlargedImage = new BufferedImage(w, h, image.getType());
for (int y = 0; y < h; ++y){
for (int x = 0; x < w; ++x){
enlargedImage.setRGB(x, y, image.getRGB(x / n, y / n));
}
}
return enlargedImage;
}
}</source>
Filtering the RGB Values in an Image
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; import java.awt.image.FilteredImageSource; import java.awt.image.ImageFilter; import java.awt.image.RGBImageFilter; import javax.swing.ImageIcon;
class GetRedFilter extends RGBImageFilter {
public GetRedFilter() {
canFilterIndexColorModel = true;
}
public int filterRGB(int x, int y, int rgb) {
if (x == -1) {
}
return rgb & 0xffff0000;
}
} public class Main {
public static void main(String[] argv) throws Exception {
Image image = new ImageIcon("image.gif").getImage();
ImageFilter filter = new GetRedFilter();
FilteredImageSource filteredSrc = new FilteredImageSource(image.getSource(), filter);
image = Toolkit.getDefaultToolkit().createImage(filteredSrc);
}
}</source>
Flip an image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.geom.AffineTransform; import java.awt.image.AffineTransformOp; import java.awt.image.BufferedImage; import javax.swing.ImageIcon; import javax.swing.JFrame; import javax.swing.JPanel; public class ImageFlip extends JPanel {
public void paint(Graphics g) {
Image myImage = new ImageIcon("yourImage.jpg").getImage();
BufferedImage bufferedImage = new BufferedImage(myImage.getWidth(null), myImage.getHeight(null), BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = (Graphics2D) g;
Graphics gb = bufferedImage.getGraphics();
gb.drawImage(myImage, 0, 0, null);
gb.dispose();
AffineTransform tx = AffineTransform.getScaleInstance(-1, 1);
tx.translate(-myImage.getWidth(null), 0);
AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
bufferedImage = op.filter(bufferedImage, null);
g2d.drawImage(myImage, 10, 10, null);
g2d.drawImage(bufferedImage, null, 300, 10);
}
public static void main(String[] args) {
JFrame frame = new JFrame("Flip image");
frame.add(new ImageFlip());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(570, 230);
frame.setVisible(true);
}
}</source>
Flush an image
<source lang="java">
// This example is from the book _Java AWT Reference_ by John Zukowski. // Written by John Zukowski. Copyright (c) 1997 O"Reilly & Associates. // You may study, use, modify, and distribute this example for any purpose. // This example is provided WITHOUT WARRANTY either expressed or import java.awt.Event; import java.awt.Frame; import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit; public class flushMe extends Frame {
Image im;
flushMe() {
super("Flushing");
im = Toolkit.getDefaultToolkit().getImage("flush.gif");
setSize(175, 225);
}
public void paint(Graphics g) {
g.drawImage(im, 0, 0, 175, 225, this);
}
public boolean mouseDown(Event e, int x, int y) {
im.flush();
repaint();
return true;
}
public static void main(String[] args) {
Frame f = new flushMe();
f.setVisible(true);
}
}</source>
Get average of a set of images
<source lang="java">
import java.awt.image.BufferedImage; import java.awt.image.WritableRaster; public class Main {
static BufferedImage average(BufferedImage[] images) {
BufferedImage average = new BufferedImage(images[0].getWidth(), images[0].getHeight(),
BufferedImage.TYPE_BYTE_GRAY);
WritableRaster raster = average.getRaster().createCompatibleWritableRaster();
for (int k = 0; k < images[0].getHeight(); ++k) {
for (int j = 0; j < images[0].getWidth(); ++j) {
float sum = 0.0f;
for (int i = 0; i < images.length; ++i) {
sum = sum + images[i].getRaster().getSample(j, k, 0);
}
raster.setSample(j, k, 0, Math.round(sum / images.length));
}
}
average.setData(raster);
return average;
}
}</source>
Get the dimensions of the image; these will be non-negative
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; public class BasicDraw {
public static void main(String[] args) {
Image image = new ImageIcon("image.gif").getImage();
width = image.getWidth(null);
height = image.getHeight(null);
}
}</source>
Getting the Color Model of an Image
<source lang="java">
import java.awt.Image; import java.awt.image.BufferedImage; import java.awt.image.ColorModel; import java.awt.image.PixelGrabber; import javax.swing.ImageIcon; public class Main {
public static void main(String[] argv) throws Exception {
Image image = new ImageIcon("a.png").getImage();
if (image instanceof BufferedImage) {
BufferedImage bimage = (BufferedImage) image;
System.out.println(bimage.getColorModel().getNumColorComponents());
}
PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
try {
pg.grabPixels();
} catch (InterruptedException e) {
}
ColorModel cm = pg.getColorModel();
System.out.println(cm.getNumColorComponents());
}
}</source>
Gray scale image operation
<source lang="java">
/*
* Copyright (c) 2000 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.ru/javaexamples2. */
import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Toolkit; import java.awt.color.ColorSpace; import java.awt.geom.AffineTransform; import java.awt.image.AffineTransformOp; import java.awt.image.BufferedImage; import java.awt.image.BufferedImageOp; import java.awt.image.ByteLookupTable; import java.awt.image.ColorConvertOp; import java.awt.image.ConvolveOp; import java.awt.image.Kernel; import java.awt.image.LookupOp; import java.awt.image.RescaleOp; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.net.URL; import javax.swing.JFrame; import javax.swing.JPanel; /** A demonstration of various image processing filters */ public class ImageOps extends JPanel {
static final int WIDTH = 600, HEIGHT = 675; // Size of our example
public String getName() {
return "Image Processing";
}
public int getWidth() {
return WIDTH;
}
public int getHeight() {
return HEIGHT;
}
Image image;
/** This constructor loads the image we will manipulate */
public ImageOps() {
image = Toolkit.getDefaultToolkit().getImage("a.jpg");
}
// These arrays of bytes are used by the LookupImageOp image filters below
static byte[] brightenTable = new byte[256];
static byte[] thresholdTable = new byte[256];
static { // Initialize the arrays
for (int i = 0; i < 256; i++) {
brightenTable[i] = (byte) (Math.sqrt(i / 255.0) * 255);
thresholdTable[i] = (byte) ((i < 225) ? 0 : i);
}
}
// This AffineTransform is used by one of the image filters below
static AffineTransform mirrorTransform;
static { // Create and initialize the AffineTransform
mirrorTransform = AffineTransform.getTranslateInstance(127, 0);
mirrorTransform.scale(-1.0, 1.0); // flip horizontally
}
// These are the labels we"ll display for each of the filtered images
static String[] filterNames = new String[] { "Original", "Gray Scale", "Negative", "Brighten (linear)", "Brighten (sqrt)", "Threshold", "Blur", "Sharpen", "Edge Detect", "Mirror", "Rotate (center)", "Rotate (lower left)" };
// The following BufferedImageOp image filter objects perform
// different types of image processing operations.
static BufferedImageOp[] filters = new BufferedImageOp[] {
// 1) No filter here. We"ll display the original image
null,
// 2) Convert to Grayscale color space
new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null),
// 3) Image negative. Multiply each color value by -1.0 and add 255
new RescaleOp(-1.0f, 255f, null),
// 4) Brighten using a linear formula that increases all color
// values
new RescaleOp(1.25f, 0, null),
// 5) Brighten using the lookup table defined above
new LookupOp(new ByteLookupTable(0, brightenTable), null),
// 6) Threshold using the lookup table defined above
new LookupOp(new ByteLookupTable(0, thresholdTable), null),
// 7) Blur by "convolving" the image with a matrix
new ConvolveOp(new Kernel(3, 3, new float[] { .1111f, .1111f, .1111f, .1111f, .1111f, .1111f, .1111f, .1111f, .1111f, })),
// 8) Sharpen by using a different matrix
new ConvolveOp(new Kernel(3, 3, new float[] { 0.0f, -0.75f, 0.0f, -0.75f, 4.0f, -0.75f, 0.0f, -0.75f, 0.0f })),
// 9) Edge detect using yet another matrix
new ConvolveOp(new Kernel(3, 3, new float[] { 0.0f, -0.75f, 0.0f, -0.75f, 3.0f, -0.75f, 0.0f, -0.75f, 0.0f })),
// 10) Compute a mirror image using the transform defined above
new AffineTransformOp(mirrorTransform, AffineTransformOp.TYPE_BILINEAR),
// 11) Rotate the image 180 degrees about its center point
new AffineTransformOp(AffineTransform.getRotateInstance(Math.PI, 64, 95), AffineTransformOp.TYPE_NEAREST_NEIGHBOR),
// 12) Rotate the image 15 degrees about the bottom left
new AffineTransformOp(AffineTransform.getRotateInstance(Math.PI / 12, 0, 190), AffineTransformOp.TYPE_NEAREST_NEIGHBOR), };
/** Draw the example */
public void paint(Graphics g1) {
Graphics2D g = (Graphics2D) g1;
// Create a BufferedImage big enough to hold the Image loaded
// in the constructor. Then copy that image into the new
// BufferedImage object so that we can process it.
BufferedImage bimage = new BufferedImage(image.getWidth(this), image.getHeight(this), BufferedImage.TYPE_INT_RGB);
Graphics2D ig = bimage.createGraphics();
ig.drawImage(image, 0, 0, this); // copy the image
// Set some default graphics attributes
g.setFont(new Font("SansSerif", Font.BOLD, 12)); // 12pt bold text
g.setColor(Color.green); // Draw in green
g.translate(10, 10); // Set some margins
// Loop through the filters
for (int i = 0; i < filters.length; i++) {
// If the filter is null, draw the original image, otherwise,
// draw the image as processed by the filter
if (filters[i] == null)
g.drawImage(bimage, 0, 0, this);
else
g.drawImage(filters[i].filter(bimage, null), 0, 0, this);
g.drawString(filterNames[i], 0, 205); // Label the image
g.translate(137, 0); // Move over
if (i % 4 == 3)
g.translate(-137 * 4, 215); // Move down after 4
}
}
public static void main(String[] a) {
JFrame f = new JFrame();
f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
f.setContentPane(new ImageOps());
f.pack();
f.setVisible(true);
}
}</source>
Load Image and scale it
<source lang="java">
import java.awt.BorderLayout; import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.File; import javax.swing.JButton; import javax.swing.JFileChooser; import javax.swing.JFrame; import javax.swing.JPanel; public class ImageFileFilterImageScale extends JFrame implements ActionListener {
Image img;
JButton getPictureButton = new JButton("Get Picture");
public static void main(String[] args) {
new ImageFileFilterImageScale();
}
public ImageFileFilterImageScale() {
this.setSize(300, 300);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel picPanel = new PicturePanel();
this.add(picPanel, BorderLayout.CENTER);
JPanel buttonPanel = new JPanel();
getPictureButton.addActionListener(this);
buttonPanel.add(getPictureButton);
this.add(buttonPanel, BorderLayout.SOUTH);
this.setVisible(true);
}
public void actionPerformed(ActionEvent e) {
String file = getImageFile();
if (file != null) {
Toolkit kit = Toolkit.getDefaultToolkit();
img = kit.getImage(file);
img = img.getScaledInstance(300, -1, Image.SCALE_SMOOTH);
this.repaint();
}
}
private String getImageFile() {
JFileChooser fc = new JFileChooser();
fc.setFileFilter(new ImageFilter());
int result = fc.showOpenDialog(null);
File file = null;
if (result == JFileChooser.APPROVE_OPTION) {
file = fc.getSelectedFile();
return file.getPath();
} else
return null;
}
class PicturePanel extends JPanel {
public void paint(Graphics g) {
g.drawImage(img, 0, 0, this);
}
}
} class ImageFilter extends javax.swing.filechooser.FileFilter {
public boolean accept(File f) {
if (f.isDirectory())
return true;
String name = f.getName();
if (name.matches(".*((.jpg)|(.gif)|(.png))"))
return true;
else
return false;
}
public String getDescription() {
return "Image files (*.jpg, *.gif, *.png)";
}
}</source>
Reading an Image or Icon from a File
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; public class BasicDraw {
public static void main(String[] args) {
Image image = Toolkit.getDefaultToolkit().getImage("image.gif");
int width = image.getWidth(null);
int height = image.getHeight(null);
if (width >= 0) {
// The image has been fully loaded
} else {
// The image has not been fully loaded
}
}
}</source>
Resize an image
<source lang="java">
import java.awt.Graphics; import java.awt.Image; import java.awt.Toolkit; import javax.swing.JComponent; import javax.swing.JFrame; class MyCanvas extends JComponent {
public void paint(Graphics g) {
Image img1 = Toolkit.getDefaultToolkit().getImage("yourFile.gif");
int width = img1.getWidth(this);
int height = img1.getHeight(this);
int scale = 2;
int w = scale * width;
int h = scale * height;
// explicitly specify width (w) and height (h)
g.drawImage(img1, 10, 10, (int) w, (int) h, this);
}
} public class Graphics2DDrawScaleImage {
public static void main(String[] a) {
JFrame window = new JFrame();
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.setBounds(30, 30, 300, 300);
window.getContentPane().add(new MyCanvas());
window.setVisible(true);
}
}</source>
Rotating a Drawn Image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import javax.swing.ImageIcon; import javax.swing.JComponent; import javax.swing.JFrame; public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
} class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
AffineTransform tx = new AffineTransform();
double radians = -Math.PI / 4;
tx.rotate(radians);
g2d.setTransform(tx);
g2d.drawImage(new ImageIcon("a.png").getImage(), tx, this);
}
}</source>
Scaling a Drawn Image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import javax.swing.ImageIcon; import javax.swing.JComponent; import javax.swing.JFrame; public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
} class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
AffineTransform tx = new AffineTransform();
double scalex = .5;
double scaley = 1;
tx.scale(scalex, scaley);
g2d.setTransform(tx);
g2d.drawImage(new ImageIcon("a.png").getImage(), tx, this);
}
}</source>
Shearing a Drawn Image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import javax.swing.ImageIcon; import javax.swing.JComponent; import javax.swing.JFrame; public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
} class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
AffineTransform tx = new AffineTransform();
double shiftx = .1;
double shifty = .3;
tx.shear(shiftx, shifty);
g2d.setTransform(tx);
g2d.drawImage(new ImageIcon("a.png").getImage(), tx, this);
}
}</source>
Shrinking an image by skipping pixels
<source lang="java">
import java.awt.image.BufferedImage; public class Main {
static BufferedImage enlarge(BufferedImage image, int n) {
int w = image.getWidth() / n;
int h = image.getHeight() / n;
BufferedImage shrunkImage = new BufferedImage(w, h, image.getType());
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
shrunkImage.setRGB(x, y, image.getRGB(x * n, y * n));
return shrunkImage;
}
}</source>
This filter removes all but the red values in an image
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; import java.awt.image.FilteredImageSource; import java.awt.image.ImageFilter; import java.awt.image.RGBImageFilter; import javax.swing.ImageIcon;
class GetRedFilter extends RGBImageFilter {
public GetRedFilter() {
canFilterIndexColorModel = true;
}
public int filterRGB(int x, int y, int rgb) {
if (x == -1) {
}
return rgb & 0xffff0000;
}
} public class Main {
public static void main(String[] argv) throws Exception {
Image image = new ImageIcon("image.gif").getImage();
ImageFilter filter = new GetRedFilter();
FilteredImageSource filteredSrc = new FilteredImageSource(image.getSource(), filter);
image = Toolkit.getDefaultToolkit().createImage(filteredSrc);
}
}</source>
Translating a Drawn Image
<source lang="java">
import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.AffineTransform; import javax.swing.ImageIcon; import javax.swing.JComponent; import javax.swing.JFrame; public class BasicDraw {
public static void main(String[] args) {
new BasicDraw();
}
BasicDraw() {
JFrame frame = new JFrame();
frame.add(new MyComponent());
frame.setSize(300, 300);
frame.setVisible(true);
}
} class MyComponent extends JComponent {
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
AffineTransform tx = new AffineTransform();
double x = 50;
double y = 50;
tx.translate(x, y);
g2d.setTransform(tx);
g2d.drawImage(new ImageIcon("a.png").getImage(), tx, this);
}
}</source>
Use PixelGrabber class to acquire pixel data from an Image object
<source lang="java">
import java.awt.Image; import java.awt.Toolkit; import java.awt.image.PixelGrabber; public class Main {
static boolean isGreyscaleImage(PixelGrabber pg) {
return pg.getPixels() instanceof byte[];
}
public static void main(String args[]) throws Exception {
Image image = Toolkit.getDefaultToolkit().getImage("inFile.png");
PixelGrabber grabber = new PixelGrabber(image, 0, 0, -1, -1, false);
if (grabber.grabPixels()) {
int width = grabber.getWidth();
int height = grabber.getHeight();
if (isGreyscaleImage(grabber)) {
byte[] data = (byte[]) grabber.getPixels();
} else {
int[] data = (int[]) grabber.getPixels();
}
}
}
}</source>
Using mediatracker to pre-load images
<source lang="java">
import java.awt.BorderLayout; import java.awt.Graphics; import java.awt.Image; import java.awt.MediaTracker; import java.awt.Toolkit; import javax.swing.JFrame; import javax.swing.JPanel; public class Main extends JFrame {
Main() {
add(BorderLayout.CENTER, new ImagePanel());
setSize(800, 150);
}
public static void main(String[] args) {
Main jrframe = new Main();
jrframe.setVisible(true);
}
} class ImagePanel extends JPanel {
String images[] = { "i.png", "j.png" };
Image[] imgs = new Image[images.length];
ImagePanel() {
MediaTracker mt = new MediaTracker(this);
for (int i = 0; i < images.length; i++) {
imgs[i] = Toolkit.getDefaultToolkit().getImage(images[i]);
mt.addImage(imgs[i], i);
}
try {
mt.waitForAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
protected void paintComponent(Graphics g) {
super.paintComponent(g);
int x = 0;
int y = 0;
for (int i = 0; i < imgs.length; i++) {
g.drawImage(imgs[i], x, y, null);
x += imgs[i].getWidth(null);
}
}
}</source>
