gray-scale image to matrix and matrix to gray-scale image

Question

I am trying to get 2D matrix from gray-scale image and modify it, then return back to the gray-scale image.

But when try to convert the image to a matrix, the pixels return with black values.

How can I find a solution for this problem?

You can find the images below the code

Java code:

public class MyImageProcessing {
    private SampleModel sampleModel;
    public int[][] compute(File file)
{
try 
{
    BufferedImage img= ImageIO.read(file);
    Raster raster=img.getData();
    sampleModel = raster.getSampleModel();
    int w=raster.getWidth(),h=raster.getHeight();
    int pixels[][]=new int[w][h];
    for (int x=0;x<w;x++)
    {
        for(int y=0;y<h;y++)
        {
            pixels[x][y]=raster.getSample(x,y,0);
        }
    }

    return pixels;

}
catch (Exception e)
{
    e.printStackTrace();
}
return null;
}


    public void getImage(int pixels[][])
{
     int w=pixels.length;
     int h=pixels[0].length;
      WritableRaster raster= Raster.createWritableRaster(sampleModel, new Point(0,0));
     for(int i=0;i<w;i++)
     {
         for(int j=0;j<h;j++)
         {
             raster.setSample(i,j,0,pixels[i][j]);
         }
     }
BufferedImage image=new BufferedImage(w,h,BufferedImage.TYPE_BYTE_GRAY);
image.setData(raster);
File output=new File("C:\\Users\\salam\\Pictures\\3.png");
try {
    ImageIO.write(image,"png",output);
}
catch (Exception e)
{
    e.printStackTrace();
}
}

}

Original image:

Image retrieved from matrix:

Answer 1

Try this code out.

If it is not what you need then perhaps what you could take away from my post is that code should always be neat, readable, properly indented, and commented, all of which adds to the understandability of the program.

Note: Your image returns practically the same black and white image when converted to grayscale, because your image is black and white much like a binary image.

I can also suggest OpenCV (https://opencv.org/) which is under a BSD licence, it's simple, powerful, and available for Java - although I remember it being a PITA when installing it on Ubuntu 16.04.

import java.io.File;
import java.io.IOException;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;

/**
 * This class converts images to grayscale color.
 */

public class GrayscaleConverter {

/**
 * Creates a new grayscaled BufferedImage object from the given source image
 * by averaging each pixels RGB value.
 * 
 * @param inputImageAbsPath the absolute path of the image file, including its name and extension.
 * @return a BufferedImage object.
 */
private BufferedImage compute(String inputImageAbsPath) {
    
    System.out.println("... Converting source image to gray scale.");
    
    BufferedImage img = null; // image file

    // Read the source image or throw an exception
    try {
        img = ImageIO.read(new File(inputImageAbsPath));
    } catch(Exception e) {
        e.printStackTrace();
    }

    // Get the image width and height dimensions
    int width = img.getWidth();
    int height = img.getHeight();

    // Convert to grayscale by looping over pixels, beginning at top-most left coordinate (0,0)
    for (int y = 0; y < height; y++) { // y = rows
        for (int x = 0; x < width; x++) { // x = columns
    
            // Get the pixel value at this (x,y) coordinate
            int p = img.getRGB(x,y);
    
            // Extract the alpha, R, G, B values from pixel p
            int a = (p>>24) & 0xff; // Shift bits and unsign
            int r = (p>>16) & 0xff;
            int g = (p>>8) & 0xff;
            int b = p & 0xff;
    
            // Calculate average color (grayscale it)
            int avg = (r+g+b)/3;
    
            // Replace RGB value with avg
            p = (a<<24) | (avg<<16) | (avg<<8) | avg;
            img.setRGB(x, y, p);
        }
    }
    return img;
}

/**
 * Saves the converted grayscale image. This method builds the save path from the provided file name,
 * file extension, and absolute path of the folder that you want to save the image in.
 * 
 * @param path the absolute path of the folder that you would like to save the image inside.
 * @param imageName the name you would like to save the image with.
 * @param imageFileType the image file extension, without the dot (.) preceding the image file type.
 * @param image the BufferedImage object returned from the compute method.
 */
private void saveImage(String path, String imageName, String imageFileType, BufferedImage image) {
    
    // Save or throw exception
    try {
        System.out.println("... Saving grayscale image to "
                + path.concat("\\").concat(imageName).concat(".").concat(imageFileType)); // save path displayed to user
        
        ImageIO.write(image,
                    imageFileType,
                    new File(path.concat("\\").concat(imageName).concat(".").concat(imageFileType)));
        
    } catch(Exception e) {
        e.printStackTrace();
    }
    System.out.println("... Image saved.");
}


// Driver
public static void main(String args[]) throws IOException {
    
    /*
     * Tested for .png and .jpg files. Both worked successfully.
     */
    
    // Test
    System.out.println("Testing GrayscaleConverter.\n");
    
    String input = "*source images absolute file path including name and extension*";
    String outputPath = "*absolute path to folder where you will save grayscale image in*";
    String outputFileName = "*save image with this name*";
    String outputFileType = "*save image with this file extension (no dot (.) e.g. png or jpg)*";
    
    GrayscaleConverter gsc = new GrayscaleConverter();
    BufferedImage convertedImage = gsc.compute(input);
    gsc.saveImage(outputPath, outputFileName, outputFileType, convertedImage );
    
    System.out.println("\nTest complete.");
}

}

Your supplied input image:

Your output image:

Another sample input image:

Another sample output image:

I tested my program with both .png and .jpg image files and it worked. Good luck.