如何使用Java对JPG图像进行像素化处理？

Question

我正在尝试使用Java 6对JPEG图像进行像素化处理，但进展不顺。这需要使用Java而不是像Photoshop这样的图像处理程序，并且输出的效果需要看起来像老式像素画 - 就像这样： 有人可以帮我吗？

- Adam Feoras

---

ImageIO可以帮助您加载和保存图像tutorial，除此之外它只是像素操作。 - BevynQ

Answer 1

使用 java.awt.image (javadoc) 和 javax.imageio (javadoc) API，您可以轻松地循环遍历图像的像素并自己进行像素化。

以下是示例代码。您至少需要这些导入： javax.imageio.ImageIO、java.awt.image.BufferedImage、java.awt.image.Raster、java.awt.image.WritableRaster 和 java.io.File。

例如：

// How big should the pixelations be?
final int PIX_SIZE = 10;

// Read the file as an Image
img = ImageIO.read(new File("image.jpg"));

// Get the raster data (array of pixels)
Raster src = img.getData();

// Create an identically-sized output raster
WritableRaster dest = src.createCompatibleWritableRaster();

// Loop through every PIX_SIZE pixels, in both x and y directions
for(int y = 0; y < src.getHeight(); y += PIX_SIZE) {
    for(int x = 0; x < src.getWidth(); x += PIX_SIZE) {

        // Copy the pixel
        double[] pixel = new double[3];
        pixel = src.getPixel(x, y, pixel);

        // "Paste" the pixel onto the surrounding PIX_SIZE by PIX_SIZE neighbors
        // Also make sure that our loop never goes outside the bounds of the image
        for(int yd = y; (yd < y + PIX_SIZE) && (yd < dest.getHeight()); yd++) {
            for(int xd = x; (xd < x + PIX_SIZE) && (xd < dest.getWidth()); xd++) {
                dest.setPixel(xd, yd, pixel);
            }
        }
    }
}

// Save the raster back to the Image
img.setData(dest);

// Write the new file
ImageIO.write(img, "jpg", new File("image-pixelated.jpg"));

编辑：我认为我应该提一下——根据我所知，double[] pixel仅仅是 RGB 颜色值。例如，当我转储一个像素时，它看起来像 {204.0, 197.0, 189.0}，是一种浅棕色。

- bchociej

Answer 2

为了完善@bchociej的答案，我在像素中使用由PIX_SIZE定义的区域的主要颜色。这不是一个完美的解决方案，但它比以前更好一些。以下是一个示例： 原图： 旧算法： 新算法：

代码示例

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.*;
import java.util.List;

public final class ImageUtil {

    public static BufferedImage pixelate(BufferedImage imageToPixelate, int pixelSize) {
        BufferedImage pixelateImage = new BufferedImage(
            imageToPixelate.getWidth(),
            imageToPixelate.getHeight(),
            imageToPixelate.getType());

        for (int y = 0; y < imageToPixelate.getHeight(); y += pixelSize) {
            for (int x = 0; x < imageToPixelate.getWidth(); x += pixelSize) {
                BufferedImage croppedImage = getCroppedImage(imageToPixelate, x, y, pixelSize, pixelSize);
                Color dominantColor = getDominantColor(croppedImage);
                for (int yd = y; (yd < y + pixelSize) && (yd < pixelateImage.getHeight()); yd++) {
                    for (int xd = x; (xd < x + pixelSize) && (xd < pixelateImage.getWidth()); xd++) {
                        pixelateImage.setRGB(xd, yd, dominantColor.getRGB());
                    }
                }
            }
        }

        return pixelateImage;
    }

    public static BufferedImage getCroppedImage(BufferedImage image, int startx, int starty, int width, int height) {
        if (startx < 0) startx = 0;
        if (starty < 0) starty = 0;
        if (startx > image.getWidth()) startx = image.getWidth();
        if (starty > image.getHeight()) starty = image.getHeight();
        if (startx + width > image.getWidth()) width = image.getWidth() - startx;
        if (starty + height > image.getHeight()) height = image.getHeight() - starty;
        return image.getSubimage(startx, starty, width, height);
    }

    public static Color getDominantColor(BufferedImage image) {
        Map<Integer, Integer> colorCounter = new HashMap<>(100);
        for (int x = 0; x < image.getWidth(); x++) {
            for (int y = 0; y < image.getHeight(); y++) {
                int currentRGB = image.getRGB(x, y);
                int count = colorCounter.getOrDefault(currentRGB, 0);
                colorCounter.put(currentRGB, count + 1);
            }
        }
        return getDominantColor(colorCounter);
    }

    private static Color getDominantColor(Map<Integer, Integer> colorCounter) {
        int dominantRGB = colorCounter.entrySet().stream()
            .max((entry1, entry2) -> entry1.getValue() > entry2.getValue() ? 1 : -1)
            .get()
            .getKey();
        return new Color(dominantRGB);
    }
}

如何使用它

img = ImageIO.read(new File("image.jpg"));
BufferedImage imagePixelated = ImageUtil.pixelate(img, PIX_SIZE);
ImageIO.write(imagePixelated, "jpg", new File("image-pixelated.jpg"));

- Thibaut Mottet

Answer 3

我手头没有代码，但如果你可以将图像的大小调整为原始大小的四分之一，然后将其重新采样到原始大小，那应该就可以了。大多数图像库都可以做到这一点。

- Matt Wolfe

Answer 4

我修改了Thibaut Mottet的答案中的dominantColor函数，所以它现在不返回最常见的颜色，而是返回该像素中RGB的平均值。
原始：

之后：

虽然不是很优化，但你能明白我的意思。

public static Color getDominantColor(BufferedImage image) {
    int sumR = 0, sumB = 0, sumG = 0, int sum2 = 0;
    int color = 0;
    for (int x = 0; x < image.getWidth(); x++) {
        for (int y = 0; y < image.getHeight(); y++) {
            color = image.getRGB(x, y);
            Color c = new Color(color);
            sumR += c.getRed();
            sumB += c.getBlue();
            sumG += c.getGreen();
            sum2++;
        }
    }
    return new Color(sumR/sum2, sumG/sum2, sumB/sum2);

- Ceilvia C

Answer 5

搜索“Close Pixelate”项目，这可能是你需要的。

- Alex

---

看起来很完美，只是它是用JavaScript写的；我需要Java。 - Adam Feoras

Answer 6

对于 @thibaut-mottet 的答案进行改进，因为在 'getDominantColor' 方法中我遇到了编译器错误（'entry1' 和 'entry2' 未定义）。

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class ImageUtil {

    public static BufferedImage pixelate(BufferedImage imageToPixelate, int pixelSize) {
        BufferedImage pixelateImage = new BufferedImage(
            imageToPixelate.getWidth(),
            imageToPixelate.getHeight(),
            imageToPixelate.getType());

        for (int y = 0; y < imageToPixelate.getHeight(); y += pixelSize) {
            for (int x = 0; x < imageToPixelate.getWidth(); x += pixelSize) {
                BufferedImage croppedImage = getCroppedImage(imageToPixelate, x, y, pixelSize, pixelSize);
                Color dominantColor = getDominantColor(croppedImage);
                for (int yd = y; (yd < y + pixelSize) && (yd < pixelateImage.getHeight()); yd++) {
                    for (int xd = x; (xd < x + pixelSize) && (xd < pixelateImage.getWidth()); xd++) {
                        pixelateImage.setRGB(xd, yd, dominantColor.getRGB());
                    }
                }
            }
        }

        return pixelateImage;
    }

    public static BufferedImage getCroppedImage(BufferedImage image, int startx, int starty, int width, int height) {
        if (startx < 0) startx = 0;
        if (starty < 0) starty = 0;
        if (startx > image.getWidth()) startx = image.getWidth();
        if (starty > image.getHeight()) starty = image.getHeight();
        if (startx + width > image.getWidth()) width = image.getWidth() - startx;
        if (starty + height > image.getHeight()) height = image.getHeight() - starty;
        return image.getSubimage(startx, starty, width, height);
    }

    public static Color getDominantColor(BufferedImage image) {
        Map<Integer, Integer> colorCounter = new HashMap<>(100);
        for (int x = 0; x < image.getWidth(); x++) {
            for (int y = 0; y < image.getHeight(); y++) {
                int currentRGB = image.getRGB(x, y);
                int count = colorCounter.getOrDefault(currentRGB, 0);
                colorCounter.put(currentRGB, count + 1);
            }
        }
        return getDominantColor(colorCounter);
    }

    @SuppressWarnings("unchecked")
    private static Color getDominantColor(Map<Integer, Integer> colorCounter) {
        int dominantRGB = colorCounter.entrySet().stream()
            .max(new EntryComparator())
            .get()
            .getKey();
        return new Color(dominantRGB);
    }
}

@SuppressWarnings("rawtypes")
class EntryComparator implements Comparator {

    @SuppressWarnings("unchecked")
    @Override
    public int compare(Object o1, Object o2) {
        Entry<Integer, Integer> entry1 = (Map.Entry<Integer, Integer>) o1;
        Entry<Integer, Integer> entry2 = (Map.Entry<Integer, Integer>) o2;
        return (entry1.getValue() > entry2.getValue() ? 1 : -1);
    }
}

使用方式完全相同：

img = ImageIO.read(new File("image.jpg"));
BufferedImage imagePixelated = ImageUtil.pixelate(img, PIX_SIZE);
ImageIO.write(imagePixelated, "jpg", new File("image-pixelated.jpg"));

- ricardo.scholz