Điều chỉnh theo tỷ lệ

Cần thiết: Hình ảnh được tải lên từ giao diện người dùng dưới dạng chuỗi Base64, cần điều chỉnh kích thước mà vẫn giữ nguyên tỷ lệ của hình ảnh.

Thực hiện mã: Sử dụng công cụ xử lý hình ảnh: Thumbnailator

    <dependency>
        <groupId>net.coobird</groupId>
        <artifactId>thumbnailator</artifactId>
        <version>0.4.8</version>
    </dependency>
  

Mã chính:

    import net.coobird.thumbnailator.Thumbnails;

    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.IOException;
    import java.math.RoundingMode;
    import java.text.DecimalFormat;
    import java.util.Base64;
    import java.util.Objects;

    public class ImgResizer {
        private static final String BASE64_PREFIX = "data:image/[^;]+;base64,";
        private static final String IMG_DATA = "";
        private static final String OUT_PATH = "/Users/user/Desktop/output.png";
        private static int targetH = 350;
        private static int targetW = 350;

        public static void main(String[] args) throws IOException {
            DecimalFormat fmt = new DecimalFormat("#.##");
            fmt.setRoundingMode(RoundingMode.FLOOR);
            String imgStr = IMG_DATA.replaceAll(BASE64_PREFIX, "");
            BufferedImage img = convertBase64ToImage(imgStr);
            if (Objects.isNull(img)) {
                System.err.println("Lỗi chuyển đổi base64 thành hình ảnh.");
                return;
            }
            int h = img.getHeight();
            int w = img.getWidth();
            double scaleH = Double.parseDouble(fmt.format((double) targetH / h));
            double scaleW = Double.parseDouble(fmt.format((double) targetW / w));
            System.out.printf("[Chiều cao hiện tại]: %d, [Chiều rộng hiện tại]: %d \n[Chiều cao mục tiêu]: %d, [Chiều rộng mục tiêu]: %d\n", h, w, targetH, targetW);
            double scale = Math.max(scaleH, scaleW);
            System.out.printf("[Tỷ lệ chiều cao]: %s, [Tỷ lệ chiều rộng]: %s, [Tỷ lệ cuối cùng]: %s \n", scaleH, scaleW, scale);
            BufferedImage resizedImg = Thumbnails.of(img).scale(scale).asBufferedImage();
            ImageIO.write(resizedImg, "png", new File(OUT_PATH));
        }

        public static BufferedImage convertBase64ToImage(String base64Data) {
            try {
                byte[] imgBytes = Base64.getDecoder().decode(base64Data);
                ByteArrayInputStream bis = new ByteArrayInputStream(imgBytes);
                BufferedImage img = ImageIO.read(bis);
                bis.close();
                return img;
            } catch (Exception e) {
                System.err.println(e);
            }
            return null;
        }
    }
  

Điều chỉnh không theo tỷ lệ

Sử dụng `BufferedImage` của JDK:

    public static String resizeNonProportional(final String base64Img, final int targetW, final int targetH) throws Exception {
        long startTime = System.currentTimeMillis();
        BufferedImage originalImg = convertBase64ToImage(base64Img);
        assert originalImg != null;
        BufferedImage resizedImg = resizeImage(originalImg, targetW, targetH);
        String resultBase64 = convertImageToBase64(resizedImg);
        System.out.printf("Resize hoàn tất trong %d ms.\n", System.currentTimeMillis() - startTime);
        return resultBase64;
    }
  

Phương thức liên quan:

    public static BufferedImage resizeImage(BufferedImage originalImg, int targetW, int targetH) throws IOException {
        if (originalImg.getWidth() == targetW && originalImg.getHeight() == targetH) {
            return originalImg;
        }
        Image scaledImg = originalImg.getScaledInstance(targetW, targetH, Image.SCALE_AREA_AVERAGING);
        BufferedImage outputImg = new BufferedImage(targetW, targetH, BufferedImage.TYPE_INT_ARGB);
        outputImg.getGraphics().drawImage(scaledImg, 0, 0, null);
        return outputImg;
    }

    public static BufferedImage convertBase64ToImage(String base64Data) {
        try {
            byte[] imgBytes = Base64.getDecoder().decode(base64Data);
            ByteArrayInputStream bis = new ByteArrayInputStream(imgBytes);
            BufferedImage img = ImageIO.read(bis);
            bis.close();
            return img;
        } catch (Exception e) {
            System.out.println("Lỗi convertBase64ToImage: " + e.getMessage());
        }
        return null;
    }

    public static String convertImageToBase64(BufferedImage img) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ImageIO.write(img, "png", baos);
            baos.close();
            byte[] imgBytes = baos.toByteArray();
            return Base64.getEncoder().encodeToString(imgBytes);
        } catch (Exception e) {
            System.out.println("Lỗi convertImageToBase64: " + e.getMessage());
        }
        return null;
    }