Assign color to a pixel based on its neighbors

Question

I've put all the black pixels of the image in an array and I want them to get the color of their left neighbor. I run the code without errors but the result is not really what I'm expecting. Where those black stripes comes form? I was expecting it to be all red.

Here's my code and results.

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

The following might work. The main change is that it first collects the locations of ALL dark pixels, then goes over them to assign the colour from their left neighbours.

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;
    }
}

EDIT: Here is a simpler version (doesn't collect the black pixels)

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;
    }
}