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

Timestamp:

2019-08-26T16:44:52+12:00 (5 years ago)

Author:

cpb16

Message:

made progress with morphology. Need to have a better area dimension threshold setup

File:

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

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

@@ -34 +34 @@
 //False =classifierType + 0 + Filename + Status
 public class javaClassifierComparison {
+
+    //MAKE THIS A PROPERTIES FILE. THIS WILL BE SET AND CHECKED FROM OUTSIDE THE LOOP
     //GLOBALS Constants
     static int CLASSIFIER_HOUGHLINESP_MIN = 10;
@@ -41 +43 @@
     static int MINLINECOUNT = 40;
     static int MAXLINEGAP = 1;
-    static double THRESHOLD_C               = 4;
+    static double THRESHOLD_C = 4;
     static double SLOPEGRADIENT = 0.02;
     static double CLUSTER_DISTANCE_MAX = 40;
     static double CLUSTER_DISTANCE_MIN = 2;
+    //MORPHOLOGY
+    static double THRESHOLD_AREA_SIZE  = 1000;
+    static double THRESHOLD_AREA_COUNT = 4;
 
 
@@ -113 +118 @@
                 System.out.println("Usage: imageClassifier <inputFilename> <classifierType> <outputFilename>");
             } else {
-                Pair houghlinesPResult = new Pair();
+                Pair algorithmResult = new Pair();
 
                 Boolean result = null;
@@ -132 +137 @@
                     case "count":
                         enableLineClustering = false;
-                        houghlinesPResult = Algorithm_HoughLinesP(imageFilename, enableLineClustering);
-                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + houghlinesPResult.getBoolean() + '\t' + "Number of lines:" + '\t' + houghlinesPResult.getInteger() + '\t' + classifierType + '\n');
+                        algorithmResult = Algorithm_HoughLinesP_Single(imageFilename, enableLineClustering);
+                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + algorithmResult.getBoolean() + '\t' + "Number of lines:" + '\t' + algorithmResult.getInteger() + '\t' + classifierType + '\n');
                         break;
                     case "cluster":
                         enableLineClustering = true;
-                        houghlinesPResult = Algorithm_HoughLinesP(imageFilename, enableLineClustering);
-                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + houghlinesPResult.getBoolean() + '\t' + "Number of lines:" + '\t' + houghlinesPResult.getInteger() + '\t' + classifierType + '\n');
+                        algorithmResult = Algorithm_HoughLinesP_Single(imageFilename, enableLineClustering);
+                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + algorithmResult.getBoolean() + '\t' + "Number of lines:" + '\t' + algorithmResult.getInteger() + '\t' + classifierType + '\n');
+                        break;
+                    case "combo":
+                        algorithmResult = Algorithm_HoughLinesP_Combo(imageFilename);
+                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + algorithmResult.getBoolean() + '\t' + "Number of lines:" + '\t' + algorithmResult.getInteger() + '\t' + classifierType + '\n');
                         break;
                     case "morphology":
-                        //result_cluster = setup_Cluster(imageFilename);
-                        //bw.write(result_cluster);
+                        algorithmResult = Algorithm_Morphology(imageFilename);
+                        bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + algorithmResult.getBoolean() + '\t' + "Number of areas:" + '\t' + algorithmResult.getInteger() + '\t' + classifierType + '\n');
                         break;
                     default:
@@ -148 +157 @@
                         break;
                 }
-
                 bw.close();
             }
@@ -159 +167 @@
     //ALGORITHM FUNCTIONS
     //******************
-    private static Pair Algorithm_HoughLinesP(String filename, Boolean enableLineClusterDetection){
+    private static Pair Algorithm_HoughLinesP_Single(String filename, Boolean enableLineClusterDetection){
         System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
         Boolean isSheetMusic = null;
@@ -170 +178 @@
             Mat edgesExtra = new Mat();
             Mat edgesDetectedRGBProb;
-            ArrayList<StartAndEndPoint> pointArrayList = new ArrayList<>();
+            ArrayList<StartAndEndPoint> pointArrayList = new ArrayList<StartAndEndPoint>();
 
             //****************EXPLANATION**************************************************
@@ -204 +212 @@
                 returnVariables.setBoolean(isSheetMusic);
                 returnVariables.setInteger(horizontalLineCount);
+            }
+        }
+        catch(Exception e){
+            System.err.println(e);
+        }
+        return returnVariables;
+    }
+    private static Pair Algorithm_HoughLinesP_Combo(String filename){
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        Boolean isSheetMusic = null;
+        Pair returnVariables = new Pair();
+        try{
+            //Variables
+            int horizontalLineCount =0;
+            Mat edgesDetected = new Mat();
+            Mat edgesDetectedRGB = new Mat();
+            Mat edgesExtra = new Mat();
+            Mat edgesDetectedRGBProb;
+            ArrayList<StartAndEndPoint> pointArrayList = new ArrayList<StartAndEndPoint>();
+
+            //****************EXPLANATION**************************************************
+            //
+            //Load an image in greyscale
+            //Additional matrix to hold results of line detection
+            //Inversed Binarization of image
+            //Detect lines in image
+            //Go thru every line detected and check its gradient is less than SLOPEGRADIENT
+            //
+            //****************EXPLANATION**************************************************
+
+            Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+            Mat linesP = new Mat(); //will hold the results of the detection
+            Imgproc.adaptiveThreshold(original, edgesDetected,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV,15, THRESHOLD_C);
+            double minLineLength = edgesDetected.size().width/8;
+            Imgproc.HoughLinesP(edgesDetected, linesP, 1, Math.PI / 720, HOUGHLINEP_THRESHOLD, minLineLength, MAXLINEGAP);
+            for (int x = 0; x < linesP.rows(); x++) {
+                double[] l = linesP.get(x, 0);
+                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);
+                if(m<SLOPEGRADIENT) {
+                    horizontalLineCount++;
+                    pointArrayList.add(new StartAndEndPoint(p1, p2));
+                }
+            }
+
+            //Calculate if its sheet music or not
+            isSheetMusic = Classifier_LineCounter(horizontalLineCount);
+            if(isSheetMusic == true){
+                returnVariables.setBoolean(isSheetMusic);
+                returnVariables.setInteger(horizontalLineCount);
+            }
+            else if (isSheetMusic == false){
+                returnVariables = Classifier_ClusterDetection(pointArrayList);
+            }
+        }
+        catch(Exception e){
+            System.err.println(e);
+        }
+        return returnVariables;
+    }
+    private static Pair Algorithm_Morphology(String filename){
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        Boolean isSheetMusic = null;
+        Pair returnVariables = new Pair();
+        try{
+            //Variables
+            int areaCounter = 0;
+            Mat edgesDetectedRGB = new Mat();
+            Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+
+            ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
+            Mat hierarchy = new Mat();
+
+            //Thresholds
+            Imgproc.adaptiveThreshold(original, original,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV, 15, THRESHOLD_C);
+            Mat processed = original.clone();
+            //Morphological Processing
+            Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,1));
+            Imgproc.erode(processed,processed,kernelErode);
+
+            Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(20,3));
+            Imgproc.dilate(processed,processed,kernelDilate);
+
+            Mat kernelOpening = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(4,4));
+            Imgproc.morphologyEx(processed, processed, Imgproc.MORPH_CLOSE, kernelOpening);
+
+            Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8,8));
+            Imgproc.erode(processed,processed,kernelErode02);
+
+            //Detect contours
+            Imgproc.findContours(processed, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
+
+            //Record areas
+            for (int i = 0; i < contours.size(); i++) {
+                double area = Imgproc.contourArea(contours.get(i));
+                //Check if area detected meets threshold
+                if(area > THRESHOLD_AREA_SIZE) {
+                    areaCounter++;
+                    //System.out.println("AREA: " + area);
+                }
+            }
+            //Calculates if sheet music or not
+            if(areaCounter >= THRESHOLD_AREA_COUNT){
+                returnVariables.setBoolean(true);
+                returnVariables.setInteger(areaCounter);
             }
         }