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

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;
//import java.util.ArrayList;
//import java.util.Collections.*;
import java.util.*;
import java.lang.*;
import java.io.*;

//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{
    //GLOBALS Constants
    static int CLASSIFIER_HOUGHLINESP_MIN   = 10;
    static int CLASSIFIER_HOUGHLINESP_MAX   = 65;
    static int HOUGHLINEP_THRESHOLD         = 10;
    static int STANDARD_DEVIATION_THRESHOLD = 6;
    static int MINLINECOUNT                 = 40;
    static int MAXLINEGAP                   = 4;
    static double SLOPEGRADIENT             = 0.02;
    static double CLUSTER_DISTANCE_MAX      = 40;
    static double CLUSTER_DISTANCE_MIN      = 2;
    
    static class StartAndEndPoint {
        //PRIVATES
        private Point _p1;
        private Point _p2;
        //CONSTRUCTOR
        public StartAndEndPoint(Point p1, Point p2){
            _p1 = p1;
            _p2 = p2;}
        //GETTERS
        public Point getP1(){return _p1;}
        public Point getP2(){return  _p2;}
        //SETTERS
        public void setP1(Point p1){_p1 = p1;}
        public void setP2(Point p2){_p2 = p2;}
        //ToString
        public  String toString(){
            return "Start: " + _p1 + " End: " + _p2;
        }
    }
    
    public static void main(String[] args) {    
        try {
            if (args.length != 3) {
            System.out.println("Usage: imageClassifier <inputFilename> <classifierType> <outputFilename>");
            }
            else {
                ArrayList result_refined = null;
                Boolean result = null;
                String result_cluster = "";
                String imageFilename = args[0];
                String classifierType = args[1];
                String outputFilename = args[2];
                //Prep Writing output to disc
                File log = new File(outputFilename);
                FileWriter fileWriter = new FileWriter(log, true);
                BufferedWriter bw = new BufferedWriter(fileWriter);         
                //Execute classifierType defined from arguement
                
                //Split output by tab for processing in next java program
                //imageFilename = 1, result = 3, classifierType = 4
                switch(classifierType){
                case "houghlinesP":
                    result = setup_HoughLinesP(imageFilename); //true or false
                    bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + result + '\t' + classifierType + '\n');
                    break;
                case "houghlinesP-refined":
                    result_refined = setup_HoughLinesP_refined(imageFilename);
                    bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + result_refined.get(0) + '\t' + "Number of lines:" + '\t' + result_refined.get(1) + '\t' + classifierType + '\n');
                    break;
                case "cluster-detection":
                    //result_cluster = setup_Cluster(imageFilename);
                    //bw.write(result_cluster);
                    break;
                default:
                    System.out.println("unknown algorithm");
                    break;
                }           

                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 edgesExtra = 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 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 ArrayList setup_HoughLinesP_refined(String filename){
    System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    Boolean isSheetMusic = null;
    ArrayList returnArray = new ArrayList();
    try{
        //Variables
        int horizontalLineCount =0;
        Mat edgesDetected = new Mat();
        Mat edgesDetectedRGB = new Mat();
        Mat edgesExtra = new Mat();
        Mat edgesDetectedRGBProb;
        // Load an image
        Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
        // Edge detection
        Imgproc.adaptiveThreshold(original, edgesDetected,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV,15, 2);
        //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/8;
        Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 720, HOUGHLINEP_THRESHOLD, minLineLength, MAXLINEGAP);
        // 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<SLOPEGRADIENT) {
                //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), 1, Imgproc.LINE_AA, 0); SINCE NOT SAVING IMAGES OR COUNTING PIXELS
                horizontalLineCount++;
            }
        }
        
        //Convert MAT into a BufferedImage
        //BufferedImage toBeClassifiedImg = toBufferedImage(edgesDetectedRGB); SINCE NOT SAVING IMAGES OR COUNTING PIXELS
        //Calculate if its sheet music or not
        isSheetMusic = classifier_HoughLinesP_refined(horizontalLineCount);  
        returnArray.add(isSheetMusic);
        returnArray.add(horizontalLineCount);
            
    }
    catch(Exception e){
            System.err.println(e);
        }
        return returnArray;
 }
    private static boolean classifier_HoughLinesP_refined(int lineCount){
        if(lineCount>MINLINECOUNT){
            return true;
        }
        else{
            return false;
        }
    }

//    private static String setup_Cluster(String filename){
//      //NEED TO ADD IMAGE PROC, BEFORE THIS PART BELOW (ANALYSIS OF RESULTS)
//        String returnString = "";
//        //ArrayList lineClusterResult = ClassifierLineClusterPt(linePointsArray, clustersFoundRGB);
//        if(ClassifierLineCount(lineCount) == true){
//            returnString = "LineCount classifier Successful: " +   '\t' +"LinesFound: " + lineCount;
//            return returnString;
//        }
//        else if(lineClusterResult.get(0).toString() == "true"){
//            returnString = "LineCluster classifier Successful: " + '\t' + "LinesFound: " + lineCount + '\t' + "ClustersFound: " + lineClusterResult.get(1);
//            return returnString;
//        }
//        return returnString;
//    }

 //******************
 //INTERNAL FUNCTIONS
 //******************

    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;
    }
    private static ArrayList ClassifierLineClusterPt(ArrayList<StartAndEndPoint> linePointsArray, Mat clustersFoundRGB){
        /*
        ADDITION:
        This will check for a cluster of lines that are close together.
        1. Go through the list of Y positions(start point) in parsed array.
            If, there is a small distance between them,
                then, add to closeLineArray.

        Have all Y positions that are close to each other now.
        Need to find the lines that are clustered together.

        Now check if there are four of these are close to each other.
        2.  Go through list of closeLine.
                Get first four lines, traversing down a step each iteration {0,1,2,3} -> {1,2,3,4} -> {2,3,4,5}
                If, those 4 lines are close together,
                    Then, add them to a new array that holds Line Cluster Values.
                    Go to line 4 positions down since, as do not want duplicates.

        3.
        */
        ArrayList returnArray = new ArrayList();
        ArrayList<StartAndEndPoint> closeLinePts = new ArrayList();
        ArrayList<StartAndEndPoint[]> clusterPtArray = new ArrayList();
        int clusterCount = 0;
        try {
            if(linePointsArray.size()> 1) {
                /*
                //Display input array TESTING PURPOSES
                for (int i = 0; i < linePointsArray.size(); i++) {
                    System.out.println(linePointsArray.get(i).toString());
                }
                */
                //1. Check if y points are close together
                //go thru list and compare values against each other
                for (int i = 0; i < linePointsArray.size(); i++){
                    //System.out.println("i: "+ linePointsArray.get(i).getP1().y);
                    for (int j = 0; j < linePointsArray.size(); j++) {
                        //System.out.println("j: "+ linePointsArray.get(j).getP1().y);
                        //Check if difference is less than 4 and the values are not duplicates.
                        if(Math.abs(linePointsArray.get(j).getP1().y - linePointsArray.get(i).getP1().y) < 5){
                            if(linePointsArray.get(j).getP1().y != linePointsArray.get(i).getP1().y){
                                closeLinePts.add(linePointsArray.get(i));
                            }
                        }
                    }
                }

                //2. Now check if there are four of these are close to each other.
                //Go through all of the items in this list and check if four of them are close together
                //Check first four items, traverse down a step {0,1,2,3} -> {1,2,3,4} -> {2,3,4,5}
                //If 4 items are close together,
                //Then add them to a new array that holds Line Cluster Values.
                //Go down 4 positions down since, as do not want duplicates.

                //Now have an array of at least four lines that are close together.
                //Sort array and remove duplicates
                Collections.sort(closeLinePts, new Comparator<StartAndEndPoint>() {
                    @Override
                    public int compare(StartAndEndPoint p1, StartAndEndPoint p2) {
                        return (int)(p1.getP1().y - p2.getP1().y);
                    }
                });
                closeLinePts = removeDuplicates(closeLinePts);
                //DISPLAYING AS EXCEPTED! WOO!
                /*for (StartAndEndPoint pt : closeLinePts) {
                    System.out.println("CloseLinePTs: " + pt.getP1().y);
                }*/


                if(closeLinePts.size() >= 4) {
                    //FOR every item in array of CloseLines
                    for(int i= 0; i < closeLinePts.size(); i++){
                        //If last comparator is at end of array.
                        if(i + 4 >= closeLinePts.size()){
                            break;
                        }
                        else{
                            //Add 4 values of CloseLinePt Array to a tempArray
                            StartAndEndPoint[] tempPtArray = new StartAndEndPoint[4];
                            tempPtArray[0] = closeLinePts.get(i);
                            tempPtArray[1] = closeLinePts.get(i + 1);
                            tempPtArray[2] = closeLinePts.get(i + 2);
                            tempPtArray[3] = closeLinePts.get(i + 3);

                            //Check standard deviation between these 4 values.
                            //If it SD is less than 5 then it is considered to be a cluster of lines.
                            if(ClusterCheck(tempPtArray)){
                                //System.out.println("tempArray PT: "+tempPtArray[0] + " , " + tempPtArray[1] + " , " + tempPtArray[2] + " , " + tempPtArray[3]);
                                //Store array
                                clusterPtArray.add(tempPtArray);
                                //If I + 4 is less than the size of the array then increment by 4
                                //Go down +4 positions in closeLineYPos array
                                if((i + 4 < closeLinePts.size())){
                                    //System.out.println("IF, i = " + i + " -> "+ (i+4) + ", CloseLineYpos size= " + closeLineYPos.size());
                                    i = i+4;
                                }
                                else{
                                    //break
                                    Thread.sleep(2000);
                                    //System.out.println("End of closeLinePts -> break , i = " + i+ " closeLineYpos size= " + closeLinePts.size());
                                    break;
                                }
                            }
                        }
                    }
                }

                //System.out.println("Cluster Coordinates: ");
                //for(StartAndEndPoint[] items : clusterPtArray){
                //    for(int i = 0; i <clusterPtArray.size(); i++){
                //        System.out.println("ITEMS: "+ items);
                //    }
                //}

                //Setup Drawing clusters found.
                //For every pt given the input array
                for(StartAndEndPoint pt : linePointsArray){
                    //Go through every the Arrays in the clusterArray(clustered lines)
                    for(int i =0; i < clusterPtArray.size(); i++){
                        //Go through every item in the array
                        for(StartAndEndPoint item : clusterPtArray.get(i)) {
                            //Check if the curr item is equal to current pt
                            if (item.getP1().y == pt.getP1().y){
                                //calculate a different colour for each line
                                //Draw a line
                                Imgproc.line(clustersFoundRGB, pt.getP1(), pt.getP2(), new Scalar(0, 255, 0), 1, Imgproc.LINE_4, 0);
                            }
                        }
                    }
                }

                clusterCount = clusterPtArray.size();
                //SETUP RETURN ARRAY
                if(clusterCount >= 1){
                    returnArray.add(true);
                    returnArray.add(clusterCount);
                    returnArray.add(clustersFoundRGB);
                }
                else{
                    returnArray.add(false);
                    returnArray.add(clusterCount);
                    returnArray.add(clustersFoundRGB);
                }
            }
        }
        catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return returnArray;
    }
    private static boolean ClusterCheck(StartAndEndPoint parseArray[]){
        try {
            //System.out.println("LENGTH: " + parseArray.length);
            //MAKE THREE COMPARISONS
            //After clusters have been found.
            //Check if  their x positions intersect
            //Logic being
            //(L1.S < L2.E && L1.S > L2.S)
            //or
            //(L2.S < L1.E && L2.S > L1.S)
            //Variance is using Start of line point.
            //USING VARIANTS
            double variance = VarianceCalc(parseArray);
            Boolean consistent = false;
            if (variance <= CLUSTER_DISTANCE_MAX && variance > CLUSTER_DISTANCE_MIN) {

                for (int i = 0; i < parseArray.length - 1; i++) {
                    //System.out.println(i);
                    double l1_S = parseArray[i].getP1().x;
                    double l1_E = parseArray[i].getP2().x;
                    double l2_S = parseArray[i + 1].getP1().x;
                    double l2_E = parseArray[i + 1].getP2().x;

                    //Check which starts after
                    if (l1_S >= l2_S) {
                        //baseLineStart is l1_S (call with lineComparison)
                        consistent = lineComparison(l1_S, l2_S, l2_E);
                    } else if (l2_S > l1_S) {
                        //baseLineStart is l2_S (call with lineComparison)
                        consistent = lineComparison(l2_S, l1_S, l1_E);
                    } else {
                        System.err.println("An error, comparing l1_S and l2_S, has occurred");
                    }

                    //Check if false was returned;
                    if (consistent == false) {
                        /*System.out.print(" X positions of two lines did not overlap each other:" + '\t');
                        System.out.print("l1_S: " + l1_S + '\t');
                        System.out.print("l1_E: " + l1_E + '\t');
                        System.out.print("l2_S: " + l2_S + '\t');
                        System.out.print("l2_E: " + l2_E);
                        System.out.println(" ");*/
                        return false;
                    }
                }
                //Have been through for loop, maintaining consistent being true.
                //Have also meet the variance MIN and MAX requirement. Therefore it is a cluster
                return true;
            }
            //System.out.println("Did not meet Cluster Distance Min and Max requirements, Variance = " + variance);
            return false;
        }
        catch (Exception e){
            System.err.println("           "+e.getMessage());
            return false;
        }
    }
    private static double VarianceCalc(StartAndEndPoint parseArray[]){
        double sum =0;
        double temp =0;
        double mean, variance;
        int size = parseArray.length;
        //Calculate sum of array
        for(int i =0; i < parseArray.length; i++){
            sum += parseArray[i].getP1().y;
        }
        //Calculate mean of array
        mean = sum/parseArray.length;
        //Calculate variants
        for(int i =0; i < size; i++){
            temp += Math.pow((parseArray[i].getP1().y-mean),2);
        }
        variance = Math.abs(temp/(size -1));
        //System.out.println("VARIANCE: " + variance);
        return variance;
    }
    private static boolean lineComparison(double baseLineS, double compareLineS, double compareLineE ){
        //System.out.print("Comparing baseLineS: " + baseLineS + " with compareLineE: " + compareLineE + " and compareLineS: " + compareLineS);
        if(baseLineS < compareLineE && baseLineS > compareLineS){
            return true;
        }
        return false;
    }
    private static <T> ArrayList<T> removeDuplicates(ArrayList<T> list) {
        //DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED
        // Function to remove duplicates from an ArrayList
        // Create a new ArrayList
        ArrayList<T> newList = new ArrayList();
        // Traverse through the first list
        for (T element : list) {
            // If this element is not present in newList
            // then add it
            if (!newList.contains(element)) {
                newList.add(element);
            }
        }
        // return the new list
        return newList;
        //DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED//DIRECTLY COPIED
    }
    /*private static boolean LineCountOrCluster(int lineCount, ArrayList<StartAndEndPoint> linePointsArray, Mat clustersFoundRGB){
        ArrayList lineClusterResult = ClassifierLineClusterPt(linePointsArray, clustersFoundRGB);


        //String test = ClassifierLineClusterPt(linePointsArray, clustersFoundRGB).get(0).toString();
        if(ClassifierLineCount(lineCount) == true){
            System.out.println("LineCount classifier Successful: " +   '\t' +"LinesFound: " + lineCount);
            return true;
        }
        else if(lineClusterResult.get(0).toString() == "true"){
            System.out.println("LineCluster classifier Successful: " + '\t' + "LinesFound: " + lineCount + '\t' + "ClustersFound: " + lineClusterResult.get(1));

            return  false;
        }
        return false;
    }*/
 
}