使用Java缩放大图像

Question

I have read through many related questions and other web resources for days, but I just can't find a solution.

1. I want to scale down very large images (eg 1300 x 27000 Pixel).
2. I cannot use a larger heap space for eclipse than 1024.
3. I rather don't want to use an external tool like JMagick since I want to export a single executable jar to run on other devices. Also from what I read I am not sure if even JMagick could do this scaling of very large images. Does anyone know?
4. Everything I tried so far results in "OutOfMemoryError: Java heap space" I trieg eg coobird.thumbnailator or awt.Graphics2D, ...

Performance and quality are not the most important factors. Mainly I just want to be sure, that all sizes of images can be scaled down without running out of heap space.

So, is there a way to scale images? may be in small chunks so that the full image doesn't need to be loaded? Or any other way to do this?

As a workaround it would also be sufficient if I could just make a thumbnail of a smaller part of the image. But I guess cropping an large image will have the same problems as if scaling a large image?

Thanks and cheers!

[EDIT:] With the Thumbnailator

        Thumbnails.of(new File(".../20150601161616.png"))
        .size(160, 160);

works for the particular picture, but

        Thumbnails.of(new File(".../20150601161616.png"))
        .size(160, 160)
        .toFile(new File(".../20150601161616_t.png"));

runs out of memory.

Answer 1

I've never had to do that; but I would suggest loading the image in tiled pieces, scaling them down, printing the scaled-down version on the new BufferedImage, and then loading the next tile over the first.

Psuedocode (parameters may also be a little out of order):

Image finalImage;
Graphics2D g2D = finalImage.createGraphics();
for each yTile:
    for each xTile:
        Image orig = getImage(path, x, y, xWidth, yWidth);
        g2D.drawImage(x * scaleFactor, y * scaleFactor, xWidth * scaleFactor, yWidth * scaleFactor, orig);
return orig;

Of course you could always do it the dreaded binary way; but this apparently addresses how to load only small chunks of an image: Draw part of image to screen (without loading all to memory)

It seems that there are already a large number of prebuilt utilities for loading only part of a file.

I apologize for the somewhat scattered nature of my answer; you actually have me curious about this now and I'll be researching it further tonight. I'll try and make note of what I run into here. Good luck!

Answer 2

With your hints and questions I was able to write a class that actually does what I want. It might not scale all sizes, but works for very large images. The performance is very bad (10-15 Sec for an 1300 x 27000 png), but it works for my purposes.

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import net.coobird.thumbnailator.Thumbnails;


public class ImageManager {
    private int tileHeight;
    private String pathSubImgs;

    /**
     * @param args
     */
    public static void main(String[] args) {
        int tileHeightL = 2000;
        String imageBasePath = "C:.../screenshots/";
        String subImgsFolderName = "subImgs/";
        String origImgName = "TestStep_319_20150601161652.png";
        String outImgName = origImgName+"scaled.png";

        ImageManager imgMngr = new ImageManager(tileHeightL,imageBasePath+subImgsFolderName);

        if(imgMngr.scaleDown(imageBasePath+origImgName, imageBasePath+outImgName))
            System.out.println("Scaled.");
        else
            System.out.println("Failed.");



    }

    /**
     * @param origImgPath
     * @param outImgPath
     * @param tileHeight
     * @param pathSubImgs
     */
    public ImageManager(int tileHeight,
            String pathSubImgs) {
        super();
        this.tileHeight = tileHeight;
        this.pathSubImgs = pathSubImgs;
    }

    private boolean scaleDown(String origImgPath, String outImgPath){
        try {
        BufferedImage image = ImageIO.read(new File(origImgPath));
        int origH = image.getHeight();
        int origW = image.getWidth();

        int tileRestHeight;
        int yTiles = (int) Math.ceil(origH/tileHeight);
        int tyleMod = origH%tileHeight;

        for(int tile = 0; tile <= yTiles ; tile++){
            if(tile == yTiles)
                tileRestHeight = tyleMod;
            else
                tileRestHeight = tileHeight;
            BufferedImage out = image.getSubimage(0, tile * tileHeight, origW, tileRestHeight);

                ImageIO.write(out, "png", new File(pathSubImgs + tile + ".png"));

            Thumbnails.of(new File(pathSubImgs + tile + ".png"))
            .size(400, 400)
            .toFile(new File(pathSubImgs + tile + ".png"));
        }

        image = ImageIO.read(new File(pathSubImgs + 0 + ".png"));
        BufferedImage img2;
        for(int tile = 1; tile <= yTiles ; tile++){
            if(tile == yTiles)
                tileRestHeight = tyleMod;
            else
                tileRestHeight = tileHeight;
            img2 = ImageIO.read(new File(pathSubImgs + tile + ".png"));
            image = joinBufferedImage(image, img2);
        }
        ImageIO.write(image, "png", new File(outImgPath));  
        return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }   
    }

    public static BufferedImage joinBufferedImage(BufferedImage img1,BufferedImage img2) {

        //do some calculate first
        int height = img1.getHeight()+img2.getHeight();
        int width = Math.max(img1.getWidth(),img2.getWidth());
        //create a new buffer and draw two image into the new image
        BufferedImage newImage = new BufferedImage(width,height, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2 = newImage.createGraphics();
        Color oldColor = g2.getColor();
        //fill background
        g2.setPaint(Color.WHITE);
        g2.fillRect(0, 0, width, height);
        //draw image
        g2.setColor(oldColor);
        g2.drawImage(img1, null, 0, 0);
        g2.drawImage(img2, null, 0, img1.getHeight());
        g2.dispose();
        return newImage;
    }
}