Changeset 33340 for other-projects/is-sheet-music-encore/trunk/image-identification-terminal/javaImageClassifier.java

Timestamp:

2019-07-22T16:46:33+12:00 (5 years ago)

Author:

cpb16

Message:

transferred backup of low res images. Classifiers work as expected. Updated javaAccuracyCalculator, now calculates overall rating correctly. Created gen-50-XX-ValidIDList.txt for the 10% high-res downloads. Done by selecting first 50 of each gen-500-XX-Valid.... .txt. Downloading high-res images after this backup

File:

• other-projects/is-sheet-music-encore/trunk/image-identification-terminal/javaImageClassifier.java (modified) (10 diffs)

other-projects/is-sheet-music-encore/trunk/image-identification-terminal/javaImageClassifier.java

@@ -7 +7 @@
 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferByte;
-import java.io.File;
-import java.io.BufferedWriter;
-import java.io.FileWriter;
+//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.logging.Logger;
+//import java.util.ArrayList;
+//import java.util.Collections.*;
+import java.util.*;
+import java.lang.*;
+import java.io.*;
 
 //REFERENCES:
@@ -28 +32 @@
 //False =classifierType + 0 + Filename + Status
 public class javaImageClassifier{
-    //Constants
-
+    //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 double MAXLINEGAP                = 4;
+    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 {
@@ -45 +71 @@
                 ArrayList result_refined = null;
                 Boolean result = null;
+                String result_cluster = "";
                 String imageFilename = args[0];
                 String classifierType = args[1];
@@ -65 +92 @@
                     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");
@@ -84 +115 @@
  //CLASSIFIER FUNCTIONS
  //******************
-    private static Boolean setup_HoughLinesP(String filename){
+    private static boolean setup_HoughLinesP(String filename){
     System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
     Boolean isSheetMusic = null;
@@ -118 +149 @@
         return isSheetMusic;
  }
- 
-     private static ArrayList setup_HoughLinesP_refined(String filename){
+    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;
@@ -134 +196 @@
         Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
         // Edge detection
-        //Imgproc.Canny(original, edgesDetected, 50, 200, 3, false);
         Imgproc.adaptiveThreshold(original, edgesDetected,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV,15, 2);
-        //Imgproc.blur(edgesExtra, edgesDetected, new Size(3,1));
-        //Imgproc.medianBlur(edgesExtra, edgesDetected, 3);
-        
-        
         //Copy edges to the images that will display the results in BGR
         Imgproc.cvtColor(edgesDetected, edgesDetectedRGB, Imgproc.COLOR_GRAY2BGR);
@@ -145 +202 @@
         Mat linesP = new Mat(); // will hold the results of the detection
         double minLineLength = edgesDetectedRGB.size().width/8;
-        //Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 180, 10, minLineLength, MAXLINEGAP);// runs the actual detection
-        Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 720, HOUGHLINEP_THRESHOLD, minLineLength, MAXLINEGAP); //TESTING
+        Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 720, HOUGHLINEP_THRESHOLD, minLineLength, MAXLINEGAP);
         // Draw the lines
         
@@ -179 +235 @@
         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 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 boolean classifier_HoughLinesP_refined(int lineCount){
-        if(lineCount>MINLINECOUNT){
-            return true;
-        }
-        else{
-            return false;
-        }
-    }
-    
-        private static  BufferedImage toBufferedImage(Mat mat){
+
+    private static  BufferedImage toBufferedImage(Mat mat){
         //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -245 +283 @@
         }
         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;
+    }*/
+ 
 }