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

Timestamp:

2019-08-30T18:03:01+12:00 (5 years ago)

Author:

cpb16

Message:

starting to implement terminal version of new morphology. need to fix. return bariables always returning null

File:

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

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

@@ -1 @@
-
 import org.opencv.core.*;
 import org.opencv.core.Point;
@@ -5 +4 @@
 import org.opencv.imgcodecs.Imgcodecs;
 import org.opencv.imgproc.Imgproc;
-import static org.opencv.imgcodecs.Imgcodecs.imwrite;
+import org.opencv.imgproc.Moments;
+//import org.opencv.core.Core.FILLED;
+//import org.opencv.imgcodecs.Imgcodecs.imwrite;
 import java.awt.image.BufferedImage;
 import java.awt.image.DataBufferByte;
@@ -200 +201 @@
                         break;
                     case "morphology":
-                        algorithmResult = Algorithm_Morphology(imageFilename);
+                        algorithmResult = Algorithm_MorphologyOLD(imageFilename);
                         bw.write("Filename:" + '\t' + imageFilename + '\t' + "Classified as:" + '\t' + algorithmResult.getBoolean() + '\t' + "Number of areas:" + '\t' + algorithmResult.getInteger() + '\t' + classifierType + '\n');
                         break;
@@ -324 +325 @@
         return returnVariables;
     }
-    private static Pair Algorithm_Morphology(String filename){
+    private static Pair Algorithm_MorphologyOLD(String filename){
+
         System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
         Boolean isSheetMusic = null;
@@ -365 +367 @@
                 }
             }
+
+
+
+
+
+
             //Calculates if sheet music or not
             if(areaCounter >= THRESHOLD_AREA_COUNT){
@@ -376 +384 @@
         return returnVariables;
     }
-
+    private static Pair Algorithm_Morphology(String filename){
+
+        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
+        Boolean isSheetMusic = null;
+        Pair returnVariables = new Pair();
+        try{
+            int FILLED = -1;
+            //Display Original
+            //imageViewer("original", original1);
+            Mat original = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE);
+            Mat test = original.clone();
+            //imageViewer("00 Inverse Binarized Original", test);
+
+
+            //************************************
+            //Large Object Removal
+            //************************************
+            Mat srcLOR = original.clone();
+            Mat maskLOR = new Mat();
+            Mat dstLOR = new Mat();
+
+            //denoize
+            Mat denoize = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5));
+            Imgproc.morphologyEx(srcLOR,maskLOR, Imgproc.MORPH_OPEN, denoize);
+            //imageViewer("01 Denoize - mask", maskLOR);
+
+            //close up gaps
+            Mat gapCloser = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5));
+            Imgproc.morphologyEx(maskLOR,maskLOR,Imgproc.MORPH_CLOSE, gapCloser);
+            //imageViewer("02 gap closer - mask", maskLOR);
+
+            //Isolate large items
+            Mat isolateLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8, 8));
+            Imgproc.morphologyEx(maskLOR,maskLOR,Imgproc.MORPH_OPEN, isolateLarge);
+            //imageViewer("03 Isolate Large - mask", maskLOR);
+
+            //Remove large items from image
+            Core.bitwise_not(maskLOR,maskLOR);
+            srcLOR.copyTo(dstLOR, maskLOR);
+            //imageViewer("04 Large Items Removed", dstLOR);
+
+            //****************************************
+            //Small object removal (SOR)
+            //****************************************
+
+            Mat srcSOR = dstLOR.clone();
+            Mat maskSOR = new Mat();
+            Mat dstSOR = new Mat();
+
+            Mat startSOR =Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(7,7));
+            Imgproc.morphologyEx(srcSOR,maskSOR, Imgproc.MORPH_OPEN, startSOR);
+            //imageViewer("11 show small - mask", maskSOR);
+
+            Mat highlightSmall = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(7,7));
+            Imgproc.dilate(maskSOR, maskSOR, highlightSmall);
+            //imageViewer("12 highlight small - mask", maskSOR);
+
+/*              Mat isolateSmall =Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,10));
+                Imgproc.morphologyEx(maskSOR,maskSOR,Imgproc.MORPH_CLOSE, isolateSmall);
+                imageViewer("13 isolate small - mask", maskSOR);
+*/
+
+            //Remove small items from image
+            Core.bitwise_not(maskSOR, maskSOR);
+            srcSOR.copyTo(dstSOR, maskSOR);
+            //imageViewer("14 Small Items Removed", dstSOR);
+
+
+            //****************************************
+            //start staff line detection
+            //****************************************
+
+            Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(15,2)); //10,2
+            Imgproc.erode(dstSOR,test,kernelErode);
+            //imageViewer("21 Erode plus pre", test);
+
+            Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //20,3
+            Imgproc.dilate(test,test,kernelDilate);
+            //imageViewer("22 Dilate", test);
+
+            Mat kernelClose = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //4,4
+            Imgproc.morphologyEx(test, test, Imgproc.MORPH_CLOSE, kernelClose);
+            //imageViewer("23 Close", test);
+
+
+            Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //10,1
+            Imgproc.erode(test,test,kernelErode02);
+            //imageViewer("24 Erode (Final)", test);
+
+            //********************************************************************************
+            //DETECT OUTLINE AND FIND AREA OF THESE LINES.
+            //********************************************************************************
+            ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>();
+            ArrayList<MatOfPoint> largeContours = new ArrayList<MatOfPoint>();
+            ArrayList<MatOfPoint> postContours = new ArrayList<MatOfPoint>();
+            Mat hierarchy = new Mat();
+
+            //PARAMETERS: input image, output array of arrays, output array, contour retrieval mode, contour approximation method.
+            //(contours)  output array of arrays: Detected contours. Each contour is stored as a vector of points
+            //(hierarchy) output array:           Optional output vector, containing information about the image topology.
+            //https://docs.opencv.org/3.3.1/d3/dc0/group__imgproc__shape.html#ga17ed9f5d79ae97bd4c7cf18403e1689a
+
+            Imgproc.findContours(test, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+            System.out.println(contours.size());
+            //Draw contours and record areas
+            Mat allContoursFound = Mat.zeros(test.size(), CvType.CV_8UC3);
+            Mat largeContoursFound = allContoursFound.clone() ;
+            Mat postContoursFound = allContoursFound.clone();
+            int areaCounter = 0;
+
+            //Have created a preprocess to remove large objects.
+            //Need to now finalized Classifier, re try area detection.
+            //Paths to take - rectangle boxes around detected contours over threshold (area or perimeter)
+            //Just use area and periemter to determine if sheet music
+            //Discuss with david before weekend perhaps?
+
+            Imgproc.drawContours(allContoursFound, contours, -1, new Scalar(0, 255, 0), 1); //USES LINE_8
+            for (int i = 0; i < contours.size(); i++) {
+                double area = Imgproc.contourArea(contours.get(i));
+                if(area > 100) {
+                    //System.out.println("AREA: " + area);
+                    Imgproc.drawContours(largeContoursFound, contours, i, new Scalar(255, 0, 0), FILLED);
+                    //create list of large coutours found
+                    largeContours.add(contours.get(i));
+                }
+            }
+            //imageViewer("80 All Contours found", allContoursFound);
+            //imageViewer("81 Large Contours Found", largeContoursFound);
+
+            //*****************************************************************
+            //Circles and centres on processed images
+            //*****************************************************************
+
+            //Init arrays
+            Mat circleOutput = allContoursFound.clone();
+            MatOfPoint2f[] contoursPoly  = new MatOfPoint2f[largeContours.size()];
+            Point[] centers = new Point[largeContours.size()];
+            float[][] radius = new float[largeContours.size()][1];
+
+            //Fill arrays
+            for (int i = 0; i < largeContours.size(); i++) {
+                contoursPoly[i] = new MatOfPoint2f();
+                Imgproc.approxPolyDP(new MatOfPoint2f(largeContours.get(i).toArray()), contoursPoly[i], 1, true);
+                centers[i] = new Point();
+                Imgproc.minEnclosingCircle(contoursPoly[i], centers[i], radius[i]);
+
+            }
+            //Draw circle for each large contour
+            for (int i = 0; i < largeContours.size(); i++) {
+                Imgproc.circle(circleOutput, centers[i], (int) radius[i][0],new Scalar(255, 0, 0), 1);
+            }
+            //imageViewer("82 Circles found", circleOutput);
+
+            //********************************************************************************
+            //Centroids - Everything must be to scale
+            //********************************************************************************
+
+            ArrayList<Moments> mu = new ArrayList<Moments>(largeContours.size());
+            Mat centreOutput = Mat.zeros(largeContoursFound.size(), CvType.CV_8UC3);
+            for (int i = 0; i < largeContours.size(); i++) {
+                mu.add(i, Imgproc.moments(largeContours.get(i), false));
+                Moments p = mu.get(i);
+                int x = (int) (p.get_m10() / p.get_m00());
+                int y = (int) (p.get_m01() / p.get_m00());
+                Imgproc.circle(centreOutput, new Point(x, y), 4, new Scalar(255, 255, 255), 30);
+            }
+            //imageViewer("83 Centres found", centreOutput);
+
+
+            //***********************************************
+            //PostProcessing - Morphology Classifier
+            //  Use dilation to "Connect the dots"
+            //  Testing showed the centroids were clustered together
+            //  Then use area or perimeter as a classifier filter
+            //***********************************************
+
+            Mat postDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(150,15));
+            Imgproc.dilate(centreOutput,centreOutput,postDilate);
+            //imageViewer("91 PostDilated", centreOutput);
+
+            Mat postClose = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //4,4
+            Imgproc.morphologyEx(centreOutput, centreOutput, Imgproc.MORPH_CLOSE, postClose);
+            //imageViewer("92 PostClose", centreOutput);
+
+            Mat postDenoize = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(100,100));
+            Imgproc.morphologyEx(centreOutput,centreOutput, Imgproc.MORPH_OPEN, postDenoize);
+            //imageViewer("93 PostDenoize", centreOutput);
+
+            //Mat postOutline = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(50,50));
+            //Imgproc.morphologyEx(centreOutput, centreOutput, Imgproc.MORPH_GRADIENT, postOutline);
+
+            //Find area
+            Mat centreOutputGrey = new Mat();
+            Imgproc.cvtColor(centreOutput, centreOutputGrey, Imgproc.COLOR_RGB2GRAY);
+            Imgproc.findContours(centreOutputGrey, postContours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
+
+            for (int i = 0; i < postContours.size(); i++) {
+                double area = Imgproc.contourArea(postContours.get(i));
+                if(area > THRESHOLD_AREA_SIZE) {
+                    System.out.println("POST AREA: " + area + "AREA COUNTER: " + areaCounter);
+                    //Imgproc.drawContours(postContoursFound, postContours, i, new Scalar(0, 255, 0), FILLED);
+                    areaCounter++;
+                }
+            }
+
+            //imageViewer("93 PostEND", postContoursFound);
+
+            //Calculates if sheet music or not
+            if(areaCounter >= THRESHOLD_AREA_COUNT){
+                returnVariables = new Pair(true, areaCounter);
+                //returnVariables.setBoolean(true);
+                //returnVariables.setInteger(areaCounter);
+                System.out.println("TEST RETURN VARIABLES: "+ returnVariables.toString());
+            }
+
+        }
+        catch(Exception e){
+            System.err.println(e);
+        }
+        return returnVariables;
+    }
     //******************
     //CLASSIFIER FUNCTIONS