source: other-projects/is-sheet-music-encore/trunk/image-identification-terminal/javaImageClassifier.java@ 33221

import org.opencv.core.*;
import org.opencv.core.Point;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
import static org.opencv.imgcodecs.Imgcodecs.imwrite;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.File;
import java.io.BufferedWriter;
import java.io.FileWriter;
import javax.imageio.ImageIO;
import java.util.logging.Logger;

//REFERENCES:
//https://docs.opencv.org/3.4.3/d9/db0/tutorial_hough_lines.
//https://stackoverflow.com/questions/43443309/count-red-pixel-in-a-given-image
//https://www.wikihow.com/Calculate-Percentage-in-Java
//https://riptutorial.com/opencv/example/21963/converting-an-mat-object-to-an-bufferedimage-object
//https://stackoverflow.com/questions/15758685/how-to-write-logs-in-text-file-when-using-java-util-logging-logger
//https://stackoverflow.com/questions/9961292/write-to-text-file-without-overwriting-in-java


//OUTPUT OF THIS JAVA PROGRAM FOUND IN log.txt
//Each image processed will have an output of
//True  =classifierType + 1 + Filename + Status 
//False =classifierType + 0 + Filename + Status
public class javaImageClassifier{
    //Constants
    static int CLASSIFIER_HOUGHLINESP_MIN = 5;
    static int CLASSIFIER_HOUGHLINESP_MAX = 40;

    public static void main(String[] args) {    
        try {
            if (args.length != 3) {
            System.out.println("Usage: imageClassifier <inputFilename> <classifierType> <outputFilename>");
            }
            else {
                Boolean result = null;
                String imageFilename = args[0];
                String classifierType = args[1];
                String outputFilename = args[2];            
                //Execute classifierType defined from arguement
                switch(classifierType){
                case "houghlinesP":
                    result = setup_HoughLinesP(imageFilename); //true or false
                    break;
                case "houghlinesP-refined":
                    result = setup_HoughLinesP_refined(imageFilename);
                    break;
                default:
                    System.out.println("unknown algorithm");
                    break;
                }           
                //Write output to disc
                File log = new File(outputFilename);
                FileWriter fileWriter = new FileWriter(log, true);
                BufferedWriter bw = new BufferedWriter(fileWriter);
                //Split output by tab for processing in next java program
                //imageFilename = 1, result = 3, classifierType = 4
                bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + result + '\t' + classifierType + '\n');
                bw.close();             
            }
        }
        catch(Exception e){
            System.err.println(e);
        }
    }  
    //Returns
    //True = 1 + Filename + Status
    //False= 0 + Filename + Status
    
 //******************
 //CLASSIFIER FUNCTIONS
 //******************
    private static Boolean setup_HoughLinesP(String filename){
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    Boolean isSheetMusic = null;
    try{
        //Variables
        Mat edgesDetected = new Mat();
        Mat edgesDetectedRGB = new Mat();
        Mat edgesDetectedRGBProb;
        // Load an image
        Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
        // Edge detection
        Imgproc.Canny(original, edgesDetected, 50, 200, 3, false);
        //Copy edges to the images that will display the results in BGR
        Imgproc.cvtColor(edgesDetected, edgesDetectedRGB, Imgproc.COLOR_GRAY2BGR);
        // Probabilistic Line Transform
        Mat linesP = new Mat(); // will hold the results of the detection
        Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 180, 50, 50, 10); // runs the actual detection
        // Draw the lines
        for (int x = 0; x < linesP.rows(); x++) {
            double[] l = linesP.get(x, 0);
            Imgproc.line(edgesDetectedRGB, new Point(l[0], l[1]), new Point(l[2], l[3]), new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0);
        }
        
        //Convert MAT into a BufferedImage
        BufferedImage toBeClassifiedImg = toBufferedImage(edgesDetectedRGB);
        //Calculate if its sheet music or not
        isSheetMusic = classifier_HoughLinesP(toBeClassifiedImg);               
    }
    catch(Exception e){
            System.err.println(e);
        }
        return isSheetMusic;
 }
 
     private static Boolean setup_HoughLinesP_refined(String filename){
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    Boolean isSheetMusic = null;
    try{
        //Variables
        Mat edgesDetected = new Mat();
        Mat edgesDetectedRGB = new Mat();
        Mat edgesDetectedRGBProb;
        // Load an image
        Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
        // Edge detection
        Imgproc.Canny(original, edgesDetected, 50, 200, 3, false);
        //Copy edges to the images that will display the results in BGR
        Imgproc.cvtColor(edgesDetected, edgesDetectedRGB, Imgproc.COLOR_GRAY2BGR);
        // Probabilistic Line Transform
        Mat linesP = new Mat(); // will hold the results of the detection
        double minLineLength = edgesDetectedRGB.size().width/4;
        //Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 180, 50, minLineLength, 10);// runs the actual detection
            Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 180, 10, minLineLength, 5);// remote testing
        // Draw the lines
        
        for (int x = 0; x < linesP.rows(); x++) {
            double[] l = linesP.get(x, 0);
            //New angles
            Point p1 = new Point(l[0], l[1]);
            Point p2 = new Point(l[2], l[3]);
            double m = Math.abs(p2.y - p1.y)/(p2.x - p1.x);
            //System.out.println(l[0]);
            //System.out.println(l[1]);
            //System.out.println(l[2]);
            //System.out.println(l[3]);
            if(m<0.1) {
                //System.out.println("m: " + m);
                Imgproc.line(edgesDetectedRGB, new Point(l[0], l[1]), new Point(l[2], l[3]), new Scalar(0, 0, 255), 3, Imgproc.LINE_AA, 0);
            }
        }
        
        //Convert MAT into a BufferedImage
        BufferedImage toBeClassifiedImg = toBufferedImage(edgesDetectedRGB);
        //Calculate if its sheet music or not
        isSheetMusic = classifier_HoughLinesP(toBeClassifiedImg);  

            
    }
    catch(Exception e){
            System.err.println(e);
        }
        return isSheetMusic;
 }
 
 //******************
 //INTERNAL FUNCTIONS
 //******************
    private static boolean classifier_HoughLinesP(BufferedImage img){
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    try {
        //Read file
        int x = img.getWidth();
        int y = img.getHeight();
        int pixelCount  = 0;
        int redCount    = 0;
        float percentage = 0;
        //Go Thru every pixel
        for(int i=0; i < y; i++){
            for(int j=0;j < x; j++){
                //Get value for current pixels RGB value
                int currPixelRGB = img.getRGB(j, i);
                //Check if pixel is red (hex value of red)
                if(currPixelRGB == 0xFFFF0000){
                    redCount++;
                }
                pixelCount++;
            }
        }
        //Calculate percentage of Red in image
        percentage = ((float)redCount/(float)pixelCount)*(float)100;
        //If more than %10 and less than %50 then its sheet music!
        if(percentage > CLASSIFIER_HOUGHLINESP_MIN && percentage < CLASSIFIER_HOUGHLINESP_MAX){
            return true;}
        }
        catch (Exception e) {
            System.err.println(e);
        }
        return false;
    }
        private static  BufferedImage toBufferedImage(Mat mat){
        //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //https://riptutorial.com/opencv/example/21963/converting-an-mat-object-to-an-bufferedimage-object
        try{
        
            int type = BufferedImage.TYPE_3BYTE_BGR;
            int bufferSize = mat.channels() * mat.cols() * mat.rows();
            byte[] b = new byte[bufferSize];
            //get all the pixels
            mat.get(0, 0, b);
            BufferedImage image = new BufferedImage(mat.cols(), mat.rows(), type);
            final byte[] targetPixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
            System.arraycopy(b, 0, targetPixels, 0, b.length);
            return image;
        }
        catch(Exception e){
            System.err.println(e);
        }
        return null;
    } 
}