Java Application per ridimensionamento immagine in proporzione

DOMANDA:

Come posso ridimensionare un'immagine rispettando le sue proporzioni?

RISPOSTA:

Di seguito una breve guida per creare una piccola Java Application che visualizza un'immagine ridimensionata rispettando le sue proporzioni. 
L'applicazione inoltre salva l'immagine su disco attraverso il metodo saveImage().

Il codice utilizza il metodo getScaledDimension() riportato su StackOverflow.

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class ImageResizeProportionally {

 public static void main(String[] args) {

  String path_immagine = "C:\\mia_immagine.jpg";

  BufferedImage srcImage;
  try {
   srcImage = ImageIO.read(new File(path_immagine));

   BufferedImage scaledImage = getScaledImage(srcImage);

   showImage(scaledImage);
 
   saveImage(scaledImage);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 // Ridimensionamento 100x118
 private static BufferedImage getScaledImage(BufferedImage originalImage) {

  int MAX_IMG_WIDTH = 110;
  int MAX_IMG_HEIGHT = 118;

  int width = originalImage.getWidth();
  int height = originalImage.getHeight();

  Dimension originalDimension = new Dimension(originalImage.getWidth(),
    originalImage.getHeight());
  Dimension boundaryDimension = new Dimension(MAX_IMG_WIDTH,
    MAX_IMG_HEIGHT);
  Dimension scalingDimension = getScaledDimension(originalDimension,
    boundaryDimension);

  width = (int) scalingDimension.getWidth();
  height = (int) scalingDimension.getHeight();

  BufferedImage resizedImage = new BufferedImage(width, height,
    originalImage.getType());
  Graphics2D g = resizedImage.createGraphics();

  g.drawImage(originalImage, 0, 0, width, height, null);

  return resizedImage;

 }

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 = original_width;
    int new_height = original_height;

    // Controllo se e' necessario eseguire lo scaling
    if (original_width > bound_width) {
        //scaling della larghezza in base alla larghezza massima
        new_width = bound_width;
        //eseguo lo scaling dell'altezza per mantenere le proporzioni
        new_height = (new_width * original_height) / original_width;
    }

    // Dopo aver calcolato la nuova altezza, controllo se è ancora fuori limite
    if (new_height > bound_height) {
        
        new_height = bound_height;
        //rieseguo lo scaling per mantenere le proporzioni
        new_width = (new_height * original_width) / original_height;
    }

    return new Dimension(new_width, new_height);
}

 /**
  * Visualizzazione dell'immagine ridimensionata in un JFrame
  */
 private static void showImage(BufferedImage image) {

  JFrame editorFrame = new JFrame("Immagine ridimensionata");
  editorFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

  ImageIcon imageIcon = new ImageIcon(image);

  JLabel jLabel = new JLabel();
  jLabel.setIcon(imageIcon);

  editorFrame.getContentPane().add(jLabel, BorderLayout.CENTER);

  editorFrame.pack();
  editorFrame.setLocationRelativeTo(null);
  editorFrame.setVisible(true);

 }

 private static void saveImage(BufferedImage scaledImage) throws FileNotFoundException, IOException {
  FileOutputStream file = new FileOutputStream("C:\\mia_immmagine_ridimensionata.jpg");
  ImageIO.write(scaledImage, "jpg", file);
  file.close();
 }
}

L'output sarà una finestra Java che mostrerà l'immagine ridimensionata e, grazie al metodo saveImage(), in C: avremo una copia in scala dell'originale mia_immagine.jpg.