Develop Reference

How can I extend the width size in a PNG file?

I am currently working with PNG images and I'm little bit blocked because a task that not sure how to fix...
This is the scenario. I have a PNG file of 655x265 pixels with a barcode inside of it. What I need to do is 'extend' the width of the image just to include a blank zone on the left of the image, just like this:
The problem is that nothing happens with the image dimensions when I execute my code:
public static void main(String[] args)
{
try
{
String path = "C:\\Users\\xxx\\Desktop\\a.png";
BufferedImage image = ImageIO.read(new File(path));
resizeImage(path, image.getWidth() + 100, image.getHeight());
Graphics graphics = image.getGraphics();
graphics.setColor(Color.BLACK);
graphics.setFont(new Font("Verdana", Font.PLAIN, 40));
graphics.drawString("TTT", 5, 250);
graphics.dispose();
ImageIO.write(image, "png", new File(path));
System.out.println("Image created");
} catch (Exception e)
{
System.out.println(e.getMessage());
e.printStackTrace();
}
System.out.println("Fin");
}
public static void resizeImage(String path, int newHeight, int newWidth) throws IOException
{
File inputFile = new File(path);
BufferedImage inputImage = ImageIO.read(inputFile);
BufferedImage outputImage = new BufferedImage(newWidth, newHeight, inputImage.getType());
Graphics2D graphics = outputImage.createGraphics();
graphics.drawImage(inputImage, 0, 0, newWidth, newHeight, null);
graphics.dispose();
ImageIO.write(outputImage, "png", new File(path));
inputImage.flush();
outputImage.flush();
}
Do you know what I am doing wrong? Is one of my first times working with image files and probably I misunderstood something important...
Edit: Solution provides in the comments. Link

What you could do is let the method take a BufferedImage, resize it and return it:
public static BufferedImage resizeImage(BufferedImage inputImage, int newHeight, int newWidth){
BufferedImage outputImage = new BufferedImage(newWidth, newHeight, inputImage.getType());
Graphics2D graphics = outputImage.createGraphics();
graphics.drawImage(inputImage, 0, 0, newWidth, newHeight, null);
graphics.dispose();
outputImage.flush();
return outputImage;
}
Then continue working on the resized image in your surrounding method:
String path = "C:\\Users\\xxx\\Desktop\\a.png";
BufferedImage image = ImageIO.read(new File(path));
image = resizeImage(image, image.getWidth() + 100, image.getHeight()); // here you replace the image with the new, resized image from your method
Graphics graphics = image.getGraphics();
graphics.setColor(Color.BLACK);
....

How to save an Image from a JLabel

I am working to create a GUI that will save an Image drawn on a JLabel by a user. Here is the code that I have for my saveImage method. I can get the box to pop up so that I can select where to save the file, but no file is actually saved.
public void saveImage()
{
BufferedImage image = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics2D image2 = image.createGraphics();
image2.setBackground(Color.WHITE);
image2.clearRect(0, 0, this.getWidth(), this.getHeight());
this.paintAll(image2);
try
{
File output = new File("rectangle.png");
ImageIO.write(image, "Rectangles", output);
final JFileChooser fchooser = new JFileChooser(".");
int retvalue = fchooser.showSaveDialog(RectangleLabel.this);
if (retvalue == JFileChooser.APPROVE_OPTION)
{
fchooser.setSelectedFile(output);
File f = fchooser.getSelectedFile();
}
}
catch(IOException ie)
{
}
}

First, you need to create an image of the component...
BufferedImage img = new BufferedImage(label.getWidth(), label.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = img.createGraphics();
label.printAll(g2d);
g2d.dispose();
Then you need to save it...
ImageIO.write(img, "png", f);
Take a look at Writing/Saving an Image for more details

Resize image in Java without losing transparency

I want to resize an image (jpg, png, gif) without losing the transparency.
I want to save the resized version to the disk after resizing.
I googled a lot but I only found solutions that lose the transparency and fill the transparent space black...
I am looking for a snippet or a library that does the job :)

After resarch i found that you can resize buffer image only if you keep it as BufferedImage without convert it to ImageIcon
I solve the proplem like this:
public class NewJFrame extends javax.swing.JFrame {
/**
* Creates new form NewJFrame
*/
public NewJFrame() {
try {
initComponents();
BufferedImage c = ImageIO.read(new File("60_Personnel.png"));
JLabel lblMains = new JLabel( new ImageIcon(c));
this.add(lblMains); //add real size
this.add(new JLabel(new ImageIcon((resize(c, 150))))); //add converting image
this.pack();
this.setLocationRelativeTo(null);
this.setVisible(true);
} catch (IOException ex) {
Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex);
}
}
public static BufferedImage resize(Object img, int percent) {
BufferedImage buff = (BufferedImage) img;
return resize(buff, buff.getWidth() * percent / 100, buff.getWidth() * percent / 100);
}
public static BufferedImage resize(BufferedImage img, int newW, int newH) {
Image tmp = img.getScaledInstance(newW, newH, Image.SCALE_SMOOTH);
BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = dimg.createGraphics();
g2d.drawImage(tmp, 0, 0, null);
g2d.dispose();
return dimg;
}
}

This is how i solved my problem:
public static BufferedImage convertRGBAToIndexed(BufferedImage src) {
BufferedImage dest = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_BYTE_INDEXED);
Graphics g = dest.getGraphics();
g.setColor(new Color(231, 20, 189));
g.fillRect(0, 0, dest.getWidth(), dest.getHeight());
dest = makeTransparent(dest, 0, 0);
dest.createGraphics().drawImage(src, 0, 0, null);
return dest;
}
public static BufferedImage makeTransparent(BufferedImage image, int x, int y) {
ColorModel cm = image.getColorModel();
if (!(cm instanceof IndexColorModel))
return image; // sorry...
IndexColorModel icm = (IndexColorModel) cm;
WritableRaster raster = image.getRaster();
int pixel = raster.getSample(x, y, 0);
int size = icm.getMapSize();
byte[] reds = new byte[size];
byte[] greens = new byte[size];
byte[] blues = new byte[size];
icm.getReds(reds);
icm.getGreens(greens);
icm.getBlues(blues);
IndexColorModel icm2 = new IndexColorModel(8, size, reds, greens, blues, pixel);
return new BufferedImage(icm2, raster, image.isAlphaPremultiplied(), null);
}
public static Dimension getScaledDimension(Dimension imgSize, Dimension boundary) {
int original_width = imgSize.width;
int original_height = imgSize.height;
int bound_width = boundary.width;
int bound_height = boundary.height;
int new_width = 0;
int new_height = 0;
if (original_width > original_height) {
new_width = bound_width;
new_height = (new_width*original_height)/original_width;
} else {
new_height = bound_height;
new_width = (new_height*original_width)/original_height;
}
return new Dimension(new_width, new_height);
}
public static void resizeImage(File original_image, File resized_image, int IMG_SIZE) {
try {
BufferedImage originalImage = ImageIO.read(original_image);
String extension = Files.getFileExtension(original_image.getName());
int type = extension.equals("gif") || (originalImage.getType() == 0) ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
Dimension new_dim = getScaledDimension(new Dimension(originalImage.getWidth(), originalImage.getHeight()), new Dimension(IMG_SIZE,IMG_SIZE));
BufferedImage resizedImage = new BufferedImage((int) new_dim.getWidth(), (int) new_dim.getHeight(), type);
Graphics2D g = resizedImage.createGraphics();
g.drawImage(originalImage, 0, 0, (int) new_dim.getWidth(), (int) new_dim.getHeight(), null);
g.dispose();
if (!extension.equals("gif")) {
ImageIO.write(resizedImage, extension, resized_image);
} else {
// Gif Transparence workarround
ImageIO.write(convertRGBAToIndexed(resizedImage), "gif", resized_image);
}
} catch (IOException e) {
Utils.log("resizeImage", e.getMessage());
}
}

Change something like this:
public static BufferedImage resizeImage(BufferedImage originalImage, int targetWidth, int targetHeight) {
BufferedImage resizedImage = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_RGB);
Graphics2D graphics2D = resizedImage.createGraphics();
graphics2D.drawImage(originalImage, 0, 0, targetWidth, targetHeight, null);
graphics2D.dispose();
return resizedImage;
}
to this:
public static BufferedImage resizeImage(BufferedImage originalImage, int targetWidth, int targetHeight) {
BufferedImage resizedImage = new BufferedImage(targetWidth, targetHeight, BufferedImage.TYPE_INT_ARGB);
Graphics2D graphics2D = resizedImage.createGraphics();
graphics2D.drawImage(originalImage, 0, 0, targetWidth, targetHeight, null);
graphics2D.dispose();
return resizedImage;
}
you basically change "BufferedImage.TYPE_INT_RGB" to "BufferedImage.TYPE_INT_ARGB"

save resized image java

How do i save a resized image to a specific folder?
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
ImgChooser ic = new ImgChooser();
ImageIcon icon = new ImageIcon(me,"id pic");
Image img1 = icon.getImage();
Image img2 = img1.getScaledInstance(105, 105, 0);
icon.setImage(img2);
jLabel1.setIcon(icon);
}
This first code is where i get the image and resize it. Then i want the resized image to be saved in another folder. Thanks in advance

Use ImageIO.write(...) as others have already said (+1 to them), to add here is an example for you:
public static void main(String[] args) {
try {
BufferedImage originalImage = ImageIO.read(new File("c:\\test.jpg"));//change path to where file is located
int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
BufferedImage resizeImageJpg = resizeImage(originalImage, type, 100, 100);
ImageIO.write(resizeImageJpg, "jpg", new File("c:\\images\\testresized.jpg")); //change path where you want it saved
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
private static BufferedImage resizeImage(BufferedImage originalImage, int type, int IMG_WIDTH, int IMG_HEIGHT) {
BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, type);
Graphics2D g = resizedImage.createGraphics();
g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
g.dispose();
return resizedImage;
}
Reference:
http://www.mkyong.com/java/how-to-resize-an-image-in-java/

Try this...
Use ImageIO.write() method...
static boolean ImageIO.write(RenderedImage im, String formatName, File output) throws IOException
Eg:
try {
// retrieve image
BufferedImage bi = getMyImage();
File outputfile = new File("saved.png");
ImageIO.write(bi, "png", outputfile);
} catch (IOException e) {
...
}

First transform your image into a BufferedImage and then use ImageIO to save the image:
BufferedImage image = new BufferedImage(img2.getWidth(null), img2.getHeight(null), BufferedImage.TYPE_4BYTE_ABGR);
Graphics2D g2 = image.createGraphics();
g2.drawImage(img2, 0, 0, null);
g2.dispose();
ImageIO.write(image, formatName, outputFile);
Where the format name is a String like "jpg", "png" or "gif" and outputFile is the File to save the image to.
Also please note that if you are saving an image that doesn't support an alpha level (transparency) then the third parameter you pass to the BufferedImage constructor should be a 3 byte image like: BufferedImage.TYPE_3BYTE_BGR

changing the height and width of image

There is an image of width 450 pixels and height 450 pixels. I want to convert this image o 75 x 75 pixels. How can i do this ?

BufferedImage scaledImg = new BufferedImage(75, 75, BufferedImage.TYPE_INT_RGB);
scaledImg.createGraphics().drawImage(sourceImg, 0, 0, 75, 75, null);

From How to resize an image in Java?
public class ImageResize {
private static final int IMG_WIDTH = 75;
private static final int IMG_HEIGHT = 75;
public static void main(String [] args){
try{
BufferedImage originalImage = ImageIO.read(new File("c:\\image\\img1.jpg"));
int type = originalImage.getType() == 0? BufferedImage.TYPE_INT_ARGB : originalImage.getType();
BufferedImage resizeImageJpg = resizeImage(originalImage, type);
ImageIO.write(resizeImageJpg, "jpg", new File("c:\\image\\img1_jpg.jpg"));
BufferedImage resizeImagePng = resizeImage(originalImage, type);
ImageIO.write(resizeImagePng, "png", new File("c:\\image\\img1_png.jpg"));
BufferedImage resizeImageHintJpg = resizeImageWithHint(originalImage, type);
ImageIO.write(resizeImageHintJpg, "jpg", new File("c:\\image\\img1_hint_jpg.jpg"));
BufferedImage resizeImageHintPng = resizeImageWithHint(originalImage, type);
ImageIO.write(resizeImageHintPng, "png", new File("c:\\image\\img1_hint_png.jpg"));
}catch(IOException e){
System.out.println(e.getMessage());
}
}
private static BufferedImage resizeImage(BufferedImage originalImage, int type){
BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, type);
Graphics2D g = resizedImage.createGraphics();
g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
g.dispose();
return resizedImage;
}
private static BufferedImage resizeImageWithHint(BufferedImage originalImage, int type){
BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, type);
Graphics2D g = resizedImage.createGraphics();
g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
g.dispose();
g.setComposite(AlphaComposite.Src);
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
return resizedImage;
}
}