根据邻居为像素分配颜色

Question

我已经把图像的所有黑色像素放在一个数组中，我想让它们得到它们左边邻居的颜色。我没有错误地运行代码，但结果并不是我所期望的。那些黑色条纹是从哪里来的？我以为它会全是红色的。

这是我的代码和结果。

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


public class ImageTest {
    public static BufferedImage Threshold(BufferedImage img) {

        int height = img.getHeight();
        int width = img.getWidth();
        BufferedImage finalImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

        int r = 0;
        int g = 0;
        int b = 0;
        List<Integer> blackpixels = new ArrayList<Integer>();



        for (int x = 0; x < width; x++) {
            try {

                for (int y = 0; y < height; y++) {

                    //Get RGB values of pixels
                    int rgb = img.getRGB(x, y); 
                    r = ImageTest.getRed(rgb);
                    g = ImageTest.getGreen(rgb);
                    b = ImageTest.getBlue(rgb);

                    int leftLoc = (x-1) + y*width;

                    if ((r < 5) && (g < 5) && (b < 5)) {
                        blackpixels.add(rgb);
                        Integer[] simpleArray = new Integer[ blackpixels.size() ];
                        System.out.print(simpleArray.length);

                        int pix = 0;

                        while(pix < simpleArray.length) {
                            r = leftLoc;
                            pix = pix +1;   
                        }


                    }

                    finalImage.setRGB(x,y,ImageTest.mixColor(r, g,b));  
                }

                }
            catch (Exception e) {
                    e.getMessage();
            }
    }
    return finalImage;

    }
    private static int mixColor(int red, int g, int b) {
        return red<<16|g<<8|b;
    }

    public static int getRed(int rgb) {
        return (rgb & 0x00ff0000)  >> 16;
    }

    public static int getGreen(int rgb) {
        return  (rgb & 0x0000ff00)  >> 8;
    }

    public static int getBlue(int rgb) {
        return (rgb & 0x000000ff)  >> 0;

    }
}

Answer 1

以下方法可能奏效。主要的变化是，它首先收集所有暗像素的位置，然后通过它们来分配它们左边邻居的颜色。

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

public class BlackRedImage
{
    public static BufferedImage Threshold( BufferedImage img )
    {
        int height = img.getHeight();
        int width = img.getWidth();
        BufferedImage finalImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

        List<Integer> blackpixels = new ArrayList<Integer>();

        for ( int x = 0; x < width; x++ )
        {
            for ( int y = 0; y < height; y++ )
            {
                int rgb = img.getRGB(x, y); // Get the pixel in question
                int r = BlackRedImage.getRed(rgb);
                int g = BlackRedImage.getGreen(rgb);
                int b = BlackRedImage.getBlue(rgb);

                if ( (r < 5) && (g < 5) && (b < 5) )
                { // record location of any "black" pixels found
                    blackpixels.add(x + (y * width));
                }

                finalImage.setRGB(x, y, rgb);
            }
        }

        // Now loop through all "black" pixels, setting them to the colour found to their left
        for ( int blackPixelLocation: blackpixels )
        {
            if ( blackPixelLocation % width == 0 )
            { // these pixels are on the left most edge, therefore they do not have a left neighbour!
                continue;
            }

            int y = blackPixelLocation / width;
            int x = blackPixelLocation - (width * y);

            int rgb = img.getRGB(x - 1, y); // Get the pixel to the left of the "black" pixel
            System.out.println("x = " + x + ", y = " + y + ", rgb = " + rgb);
            finalImage.setRGB(x, y, rgb);
        }
        return finalImage;
    }

    private static int mixColor( int red, int g, int b )
    {
        return red << 16 | g << 8 | b;
    }

    public static int getRed( int rgb )
    {
        return (rgb & 0x00ff0000) >> 16;
    }

    public static int getGreen( int rgb )
    {
        return (rgb & 0x0000ff00) >> 8;
    }

    public static int getBlue( int rgb )
    {
        return (rgb & 0x000000ff) >> 0;
    }
}

编辑：这里有一个更简单的版本（不收集黑色像素）

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

public class ColourMove
{
    public static BufferedImage Threshold( BufferedImage img )
    {
        int width = img.getWidth();
        int height = img.getHeight();
        BufferedImage finalImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);

        for ( int x = 1; x < width; x++ ) // Start at 1 as the left most edge doesn't have a left neighbour
        {
            for ( int y = 0; y < height; y++ )
            {
                Color colour = new Color(img.getRGB(x, y));
                int red = colour.getRed();
                int green = colour.getGreen();
                int blue = colour.getBlue();

                if ( (red < 5) && (green < 5) && (blue < 5) )
                { // Encountered a "black" pixel, now replace it with it's left neighbour
                    finalImage.setRGB(x, y, img.getRGB(x - 1, y));
                }
                else
                { // Non-black pixel
                    finalImage.setRGB(x, y, colour.getRGB());
                }
            }
        }
        return finalImage;
    }
}