Changeset 33444

Show
Ignore:
Timestamp:
29.08.2019 16:57:08 (3 weeks ago)
Author:
cpb16
Message:

//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?

Location:
other-projects/is-sheet-music-encore/trunk/image-identification-dev-02
Files:
3 modified

Legend:

Unmodified
Added
Removed
  • other-projects/is-sheet-music-encore/trunk/image-identification-dev-02/.idea/workspace.xml

    r33439 r33444  
    1515        <entry file="file://$PROJECT_DIR$/image-identification-development/src/Main.java"> 
    1616          <provider selected="true" editor-type-id="text-editor"> 
    17             <state relative-caret-position="874"> 
    18               <caret line="116" column="48" selection-start-line="116" selection-start-column="48" selection-end-line="116" selection-end-column="48" /> 
     17            <state relative-caret-position="3154"> 
     18              <caret line="820" column="49" selection-start-line="820" selection-start-column="49" selection-end-line="820" selection-end-column="49" /> 
    1919              <folding> 
    2020                <element signature="imports" expanded="true" /> 
     
    4040        <entry file="file://$PROJECT_DIR$/image-identification-development/src/MainMorph.java"> 
    4141          <provider selected="true" editor-type-id="text-editor"> 
    42             <state relative-caret-position="266"> 
    43               <caret line="407" column="55" selection-start-line="407" selection-start-column="55" selection-end-line="407" selection-end-column="55" /> 
     42            <state relative-caret-position="221"> 
     43              <caret line="182" column="12" selection-start-line="182" selection-start-column="12" selection-end-line="182" selection-end-column="12" /> 
    4444              <folding> 
    4545                <element signature="imports" expanded="true" /> 
    46                 <element signature="class#StartAndEndPoint#0;class#MainMorph#0" /> 
    47                 <element signature="method#toBufferedImage#0;class#MainMorph#0" /> 
    48                 <element signature="e#11164#13670#1" /> 
    49                 <element signature="e#13754#15793#1" /> 
    50                 <element signature="e#15861#18508#1" /> 
    51                 <element signature="e#21594#25229#1" /> 
     46                <element signature="e#7379#7795#1" /> 
     47                <element signature="e#7580#7900#1" /> 
     48                <element signature="e#11581#14087#1" /> 
     49                <element signature="e#14171#16210#1" /> 
     50                <element signature="e#16278#18925#1" /> 
     51                <element signature="e#19007#24734#1" /> 
     52                <element signature="e#24817#28826#1" /> 
     53                <element signature="e#28892#30082#1" /> 
     54                <element signature="e#30149#34144#1" /> 
     55                <element signature="e#34814#34826#0" expanded="true" /> 
    5256              </folding> 
    5357            </state> 
     
    5862        <entry file="file://$PROJECT_DIR$/../image-identification-terminal/javaClassifierComparison.java"> 
    5963          <provider selected="true" editor-type-id="text-editor"> 
    60             <state relative-caret-position="4332"> 
     64            <state relative-caret-position="4598"> 
    6165              <caret line="356" selection-start-line="356" selection-end-line="356" /> 
    6266              <folding> 
     
    111115      <foldersAlwaysOnTop value="true" /> 
    112116    </navigator> 
    113     <panes> 
    114       <pane id="ProjectPane" /> 
    115       <pane id="PackagesPane" /> 
    116       <pane id="Scope" /> 
    117     </panes> 
     117    <panes /> 
    118118  </component> 
    119119  <component name="PropertiesComponent"> 
     
    167167  <component name="ToolWindowManager"> 
    168168    <frame x="67" y="25" width="1613" height="1025" extended-state="6" /> 
    169     <editor active="true" /> 
    170169    <layout> 
    171170      <window_info content_ui="combo" id="Project" order="0" weight="0.19783024" /> 
     
    175174      <window_info id="Favorites" order="4" side_tool="true" /> 
    176175      <window_info anchor="bottom" id="Message" order="0" /> 
    177       <window_info anchor="bottom" id="Find" order="1" /> 
    178       <window_info active="true" anchor="bottom" id="Run" order="2" visible="true" weight="0.2494432" /> 
    179       <window_info anchor="bottom" id="Debug" order="3" weight="0.4" /> 
     176      <window_info anchor="bottom" id="Find" order="1" weight="0.32962137" /> 
     177      <window_info anchor="bottom" id="Run" order="2" weight="0.2494432" /> 
     178      <window_info anchor="bottom" id="Debug" order="3" weight="0.3997773" /> 
    180179      <window_info anchor="bottom" id="Cvs" order="4" weight="0.25" /> 
    181180      <window_info anchor="bottom" id="Inspection" order="5" weight="0.4" /> 
     
    223222    <entry file="file://$PROJECT_DIR$/image-identification-development/src/Main.java"> 
    224223      <provider selected="true" editor-type-id="text-editor"> 
    225         <state relative-caret-position="874"> 
    226           <caret line="116" column="48" selection-start-line="116" selection-start-column="48" selection-end-line="116" selection-end-column="48" /> 
     224        <state relative-caret-position="3154"> 
     225          <caret line="820" column="49" selection-start-line="820" selection-start-column="49" selection-end-line="820" selection-end-column="49" /> 
    227226          <folding> 
    228227            <element signature="imports" expanded="true" /> 
     
    246245    <entry file="file://$PROJECT_DIR$/../image-identification-terminal/javaClassifierComparison.java"> 
    247246      <provider selected="true" editor-type-id="text-editor"> 
    248         <state relative-caret-position="4332"> 
     247        <state relative-caret-position="4598"> 
    249248          <caret line="356" selection-start-line="356" selection-end-line="356" /> 
    250249          <folding> 
     
    263262    <entry file="file://$PROJECT_DIR$/image-identification-development/src/MainMorph.java"> 
    264263      <provider selected="true" editor-type-id="text-editor"> 
    265         <state relative-caret-position="266"> 
    266           <caret line="407" column="55" selection-start-line="407" selection-start-column="55" selection-end-line="407" selection-end-column="55" /> 
     264        <state relative-caret-position="221"> 
     265          <caret line="182" column="12" selection-start-line="182" selection-start-column="12" selection-end-line="182" selection-end-column="12" /> 
    267266          <folding> 
    268267            <element signature="imports" expanded="true" /> 
    269             <element signature="class#StartAndEndPoint#0;class#MainMorph#0" /> 
    270             <element signature="method#toBufferedImage#0;class#MainMorph#0" /> 
    271             <element signature="e#11164#13670#1" /> 
    272             <element signature="e#13754#15793#1" /> 
    273             <element signature="e#15861#18508#1" /> 
    274             <element signature="e#21594#25229#1" /> 
     268            <element signature="e#7379#7795#1" /> 
     269            <element signature="e#7580#7900#1" /> 
     270            <element signature="e#11581#14087#1" /> 
     271            <element signature="e#14171#16210#1" /> 
     272            <element signature="e#16278#18925#1" /> 
     273            <element signature="e#19007#24734#1" /> 
     274            <element signature="e#24817#28826#1" /> 
     275            <element signature="e#28892#30082#1" /> 
     276            <element signature="e#30149#34144#1" /> 
     277            <element signature="e#34814#34826#0" expanded="true" /> 
    275278          </folding> 
    276279        </state> 
  • other-projects/is-sheet-music-encore/trunk/image-identification-dev-02/image-identification-development/src/MainMorph.java

    r33439 r33444  
    6363import org.opencv.imgcodecs.Imgcodecs; 
    6464import org.opencv.imgproc.Imgproc; 
    65 import org.opencv.imgproc.Moments; 
    66 import org.opencv.osgi.OpenCVNativeLoader; 
    67 import org.opencv.photo.Photo; 
    68  
     65 
     66import static org.opencv.core.Core.FILLED; 
    6967import static org.opencv.core.CvType.CV_8UC3; 
    7068import static org.opencv.highgui.HighGui.imshow; 
    7169import static org.opencv.imgcodecs.Imgcodecs.imwrite; 
    72 import java.awt.image.BufferedImage; 
    73 import java.awt.image.DataBufferByte; 
     70 
    7471import java.io.File; 
    7572import java.util.ArrayList; 
    76 import java.util.Collection; 
    77 import java.util.Collections; 
    78 import java.util.Comparator; 
    79 import javax.imageio.ImageIO; 
    8073 
    8174//REFERENCES: 
     
    9689//http://androiderstuffs.blogspot.com/2016/06/detecting-rectangle-using-opencv-java.html 
    9790//https://stackoverflow.com/questions/23327502/opencv-how-to-draw-minarearect-in-java 
     91//https://stackoverflow.com/questions/30056910/opencv-java-modify-pixel-values 
    9892 
    9993 
     
    115109 
    116110public class MainMorph { 
     111    //CODE VERSIONS 
     112    static int CODE_VERSION  = 8; 
     113    static int IMAGE_VERSION = 3; 
    117114    //GLOBAL_CONSTANTS 
    118115 
     
    122119 
    123120    // 
    124     static class StartAndEndPoint { 
    125         //PRIVATES 
    126         private Point _p1; 
    127         private Point _p2; 
    128         //CONSTRUCTOR 
    129         public StartAndEndPoint(Point p1, Point p2){ 
    130             _p1 = p1; 
    131             _p2 = p2; 
    132         } 
    133         //GETTERS 
    134         public Point getP1(){ 
    135             return _p1; 
    136         } 
    137         public Point getP2(){ 
    138             return  _p2; 
    139         } 
    140         //SETTERS 
    141         public void setP1(Point p1){ 
    142             _p1 = p1; 
    143         } 
    144         public void setP2(Point p2){ 
    145             _p2 = p2; 
    146         } 
    147  
    148         //ToString 
    149         public  String toString(){ 
    150             return "Start: " + _p1 + " End: " + _p2; 
    151         } 
    152  
    153     } 
    154     private static  BufferedImage toBufferedImage(Mat mat){ 
    155         //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    156         //MOSTLY COPY PASTE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    157         //https://riptutorial.com/opencv/example/21963/converting-an-mat-object-to-an-bufferedimage-object 
    158         try{ 
    159             int type = BufferedImage.TYPE_3BYTE_BGR; 
    160             int bufferSize = mat.channels() * mat.cols() * mat.rows(); 
    161             byte[] b = new byte[bufferSize]; 
    162             //get all the pixels 
    163             mat.get(0, 0, b); 
    164             BufferedImage image = new BufferedImage(mat.cols(), mat.rows(), type); 
    165             final byte[] targetPixels = ((DataBufferByte) image.getRaster().getDataBuffer()).getData(); 
    166             System.arraycopy(b, 0, targetPixels, 0, b.length); 
    167             return image; 
    168         } 
    169         catch(Exception e){ 
    170             System.err.println(e); 
    171         } 
    172         return null; 
    173     } 
    174  
    175     private static void showWaitDestroy(String winname, Mat img) { 
     121 
     122    private static void imageViewer(String winName, Mat img) { 
    176123        try { 
    177             HighGui.namedWindow(winname, HighGui.WINDOW_AUTOSIZE); 
    178             imshow(winname, img); 
    179              HighGui.resizeWindow(winname, 1000, 1000); 
    180             HighGui.moveWindow(winname, 500, 0); 
    181             HighGui.waitKey(0); 
    182  
    183             HighGui.destroyWindow(winname); 
     124            //Internal display - Overview - Will Distort High Res images 
     125            if(IMAGE_VERSION == 1) { 
     126                HighGui.namedWindow(winName, HighGui.WINDOW_NORMAL); 
     127                HighGui.resizeWindow(winName, 1000, 1000); 
     128                imshow(winName, img); 
     129 
     130                HighGui.moveWindow(winName, 500, 0); 
     131                HighGui.waitKey(0); 
     132 
     133                HighGui.destroyWindow(winName); 
     134            } 
     135            //Internal display - Segmented - Will _NOT_ Distort High Res images 
     136            if(IMAGE_VERSION == 2) { 
     137                HighGui.namedWindow(winName, HighGui.WINDOW_AUTOSIZE); 
     138                HighGui.resizeWindow(winName, 1000, 1000); 
     139                imshow(winName, img); 
     140                HighGui.moveWindow(winName, 500, 0); 
     141                HighGui.waitKey(0); 
     142 
     143                HighGui.destroyWindow(winName); 
     144            } 
     145            //External display - Save Images for manual viewing 
     146            if(IMAGE_VERSION == 3) { 
     147                //save file (testing purposes) 
     148                imwrite(winName+".jpg", img); 
     149            } 
    184150        } 
    185151        catch (Exception e){ 
     
    189155    //MAIN 
    190156    public static void main(String[] args) { 
    191  
    192157        System.loadLibrary(Core.NATIVE_LIBRARY_NAME); 
    193  
    194158        try { 
    195  
    196             ArrayList<StartAndEndPoint> pointArrayList = new ArrayList<>(); 
    197  
    198159            //Variables 
    199             int codeVersion = 4; 
    200             System.out.println("Running code version: " + codeVersion); 
     160            System.out.println("Running code version: " + CODE_VERSION); 
    201161            Mat edgesDetected = new Mat(); 
    202162            Mat mid = new Mat(); 
     
    218178            //String default_file =hiresDirectory+"BK/NotSheetMusic/aeu.ark+=13960=t2q53nq6w-6.png"; 
    219179            //String default_file =hiresDirectory+"BK/NotSheetMusic/aeu.ark+=13960=t9z03w65z-4.png"; 
    220             String default_file =hiresDirectory+"MU/NotSheetMusic/aeu.ark+=13960=t0dv28v9r-1.png"; 
     180            //String default_file =hiresDirectory+"MU/NotSheetMusic/aeu.ark+=13960=t0dv28v9r-1.png"; 
     181            //String default_file =hiresDirectory+"MU/SheetMusic/emu.010001066823-9.png"; 
     182            //String default_file =hiresDirectory+"MU/NotSheetMusic/mdp.39015096363935-1.png"; 
     183            String default_file =hiresDirectory+"MU/SheetMusic/coo.31924062612282-9.png"; 
    221184 
    222185            //System.out.println(default_file); 
     
    236199            // Load an image 
    237200            Mat original1 = Imgcodecs.imread(filename, Imgcodecs.IMREAD_GRAYSCALE); 
     201            System.out.println("Width: " + original1.width() + " Height: " + original1.height()); 
    238202            Mat original = original1.clone(); 
    239203             
     
    251215 
    252216            //dynamic morphology?? 
    253             if(codeVersion == 1) { 
     217            if(CODE_VERSION == 1) { 
    254218                int hori = original.width(); 
    255219                int vert = original.height(); 
     
    261225 
    262226                Mat test = original.clone(); 
    263                 showWaitDestroy("Original", test); 
     227                imageViewer("Original", test); 
    264228 
    265229                System.out.println("hori: " + hori + '\t' + "vert: " + vert); 
     
    268232                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX, (sizeY/100))); 
    269233                Imgproc.erode(test,test,kernelErode); 
    270                 showWaitDestroy("01 Erode", test); 
     234                imageViewer("01 Erode", test); 
    271235 
    272236                Mat kernelDialate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX,(sizeY/10))); 
    273237                Imgproc.dilate(test, test, kernelDialate); 
    274                 showWaitDestroy("02 Dialate", test); 
     238                imageViewer("02 Dialate", test); 
    275239 
    276240                Mat kernelErodeAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size((sizeX/10),(sizeY/5))); 
    277241                Imgproc.erode(test,test,kernelErodeAgain); 
    278                 showWaitDestroy(" 03 Erode Again", test); 
     242                imageViewer(" 03 Erode Again", test); 
    279243 
    280244                Mat kernelClose = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size((sizeX/10)*3,(sizeY/10)*3)); 
    281245                Imgproc.morphologyEx(test,test,Imgproc.MORPH_CLOSE, kernelClose); 
    282                 showWaitDestroy("04 Close", test); 
     246                imageViewer("04 Close", test); 
    283247 
    284248                Imgproc.adaptiveThreshold(test, test,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV, 15, THRESHOLD_C); 
    285                 showWaitDestroy("05 Binarized", test); 
     249                imageViewer("05 Binarized", test); 
    286250 
    287251                Mat kernelOpen = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size((sizeX/10),(sizeY/20))); 
    288252                Imgproc.morphologyEx(test,test,Imgproc.MORPH_OPEN, kernelOpen); 
    289                 showWaitDestroy(" 06 Open", test); 
     253                imageViewer(" 06 Open", test); 
    290254 
    291255                Mat kernelDialateAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size((sizeX/5),(sizeY/100))); 
    292256                Imgproc.dilate(test, test, kernelDialateAgain); 
    293                 showWaitDestroy("07 Dialate", test); 
     257                imageViewer("07 Dialate", test); 
    294258 
    295259 
    296260                Mat kernelCloseAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size((sizeX/10),(sizeY/2))); 
    297261                Imgproc.morphologyEx(test,test,Imgproc.MORPH_CLOSE, kernelCloseAgain); 
    298                 showWaitDestroy(" 08 Close Again (Final)", test); 
     262                imageViewer(" 08 Close Again (Final)", test); 
    299263            } 
    300264            //Successful hardcode for morhpology 
    301             if (codeVersion == 2) { 
     265            if (CODE_VERSION == 2) { 
    302266 
    303267                //MAKE SURE BLACK & WHITE 
    304268                Mat test = original.clone(); 
    305                 showWaitDestroy("00 Binarized Original", test); 
     269                imageViewer("00 Binarized Original", test); 
    306270 
    307271                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(100,1)); 
    308272                Imgproc.erode(test,test,kernelErode); 
    309                 showWaitDestroy("01 Erode", test); 
     273                imageViewer("01 Erode", test); 
    310274 
    311275                Mat kernelDialate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(110,10)); 
    312276                Imgproc.dilate(test, test, kernelDialate); 
    313                 showWaitDestroy("02 Dialate", test); 
     277                imageViewer("02 Dialate", test); 
    314278 
    315279                Mat kernelErodeAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,20)); 
    316280                Imgproc.erode(test,test,kernelErodeAgain); 
    317                 showWaitDestroy(" 03 Erode Again", test); 
     281                imageViewer(" 03 Erode Again", test); 
    318282 
    319283                Mat kernelClose = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(35,20)); 
    320284                Imgproc.morphologyEx(test,test,Imgproc.MORPH_CLOSE, kernelClose); 
    321                 showWaitDestroy("04 Close", test); 
     285                imageViewer("04 Close", test); 
    322286 
    323287//                Imgproc.threshold(test,test, 127, 255, Imgproc.THRESH_BINARY); 
    324 //                showWaitDestroy("05 Binarized", test); 
     288//                imageViewer("05 Binarized", test); 
    325289 
    326290                Mat kernelOpen = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(4,4)); 
    327291                Imgproc.morphologyEx(test,test,Imgproc.MORPH_OPEN, kernelOpen); 
    328                 showWaitDestroy(" 06 Open", test); 
     292                imageViewer(" 06 Open", test); 
    329293 
    330294//                Mat kernelDialateAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(1,10)); 
    331295//                Imgproc.dilate(test, test, kernelDialateAgain); 
    332 //                showWaitDestroy("07 Dialate", test); 
     296//                imageViewer("07 Dialate", test); 
    333297 
    334298                //FIGURE OUT FLOOD FILL!! 
     
    338302                Mat kernelCloseAgain = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,50)); 
    339303                Imgproc.morphologyEx(test,test,Imgproc.MORPH_CLOSE, kernelCloseAgain); 
    340                 showWaitDestroy(" 08 Close Again (Final)", test); 
     304                imageViewer(" 08 Close Again (Final)", test); 
    341305 
    342306            } 
    343307            //Tutorial/Demo Code 
    344             if (codeVersion == 3) { 
     308            if (CODE_VERSION == 3) { 
    345309                Mat horizontal = original.clone(); 
    346310                Mat vertical = original.clone(); 
     
    353317                Imgproc.dilate(horizontal, horizontal, horizontalStructure); 
    354318                // Show extracted horizontal lines 
    355                 showWaitDestroy("horizontal", horizontal); 
     319                imageViewer("horizontal", horizontal); 
    356320                // Specify size on vertical axis 
    357321                int vertical_size = vertical.rows() / 30; 
     
    362326                Imgproc.dilate(vertical, vertical, verticalStructure); 
    363327                // Show extracted vertical lines 
    364                 showWaitDestroy("vertical", vertical); 
     328                imageViewer("vertical", vertical); 
    365329                // Inverse vertical image 
    366330                Core.bitwise_not(vertical, vertical); 
    367                 showWaitDestroy("vertical_bit", vertical); 
     331                imageViewer("vertical_bit", vertical); 
    368332                // Extract edges and smooth image according to the logic 
    369333                // 1. extract edges 
     
    375339                Mat edges = new Mat(); 
    376340                Imgproc.adaptiveThreshold(vertical, edges, 255, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, -2); 
    377                 showWaitDestroy("edges", edges); 
     341                imageViewer("edges", edges); 
    378342                // Step 2 
    379343                Mat kernel = Mat.ones(2, 2, CvType.CV_8UC1); 
    380344                Imgproc.dilate(edges, edges, kernel); 
    381                 showWaitDestroy("dilate", edges); 
     345                imageViewer("dilate", edges); 
    382346                // Step 3 
    383347                Mat smooth = new Mat(); 
     
    388352                smooth.copyTo(vertical, edges); 
    389353                // Show final result 
    390                 showWaitDestroy("smooth - final", vertical); 
     354                imageViewer("smooth - final", vertical); 
    391355                System.exit(0); 
    392356            } 
    393357            //Better morphology attempt - static 
    394             if(codeVersion ==4) { 
     358            if(CODE_VERSION ==4) { 
    395359 
    396360                //Display Original 
    397                 showWaitDestroy("original", original1); 
     361                imageViewer("original", original1); 
    398362 
    399363                Mat test = original.clone(); 
    400  
    401                 showWaitDestroy("00 Inverse Binarized Original", test); 
     364                Mat pre = original.clone(); 
     365                Mat dst = new Mat(); 
     366 
     367                imageViewer("00 Inverse Binarized Original", test); 
    402368 
    403369                //remove large items of no interest pre proc 
     
    411377                //denoize 
    412378                Mat denoize = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3,3)); 
    413                 Imgproc.morphologyEx(test,test, Imgproc.MORPH_OPEN, denoize); 
    414                 showWaitDestroy("Denoize", test); 
     379                Imgproc.morphologyEx(pre,pre, Imgproc.MORPH_OPEN, denoize); 
     380                imageViewer("Denoize - PRE", pre); 
    415381 
    416382                //close up gaps 
    417                 Mat gapcloser = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3,3)); 
    418                 Imgproc.morphologyEx(test,test,Imgproc.MORPH_CLOSE, gapcloser); 
    419                 showWaitDestroy("gap closer", test); 
    420  
    421                 Mat kernelRemoveLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5, 50)); 
    422                 Imgproc.erode(test,test, kernelRemoveLarge); 
    423                 showWaitDestroy("Remove Large", test); 
     383                Mat gapCloser = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5)); 
     384                Imgproc.morphologyEx(pre,pre,Imgproc.MORPH_CLOSE, gapCloser); 
     385                imageViewer("gap closer - PRE", pre); 
     386 
     387                Mat kernelHighlightLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10, 10)); 
     388                Imgproc.erode(pre,pre, kernelHighlightLarge); 
     389                imageViewer("Highlight Large - PRE", pre); 
     390 
     391                //change white pixels to red 
     392                ArrayList<MatOfPoint> contoursPre = new ArrayList<MatOfPoint>(); 
     393                Mat hierarchyPre = new Mat(); 
     394 
     395                //PARAMETERS: input image, output array of arrays, output array, contour retrieval mode, contour approximation method. 
     396                //(contours)  output array of arrays: Detected contours. Each contour is stored as a vector of points 
     397                //(hierarchy) output array:           Optional output vector, containing information about the image topology. 
     398                //https://docs.opencv.org/3.3.1/d3/dc0/group__imgproc__shape.html#ga17ed9f5d79ae97bd4c7cf18403e1689a 
     399 
     400                Imgproc.findContours(pre, contoursPre, hierarchyPre, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); 
     401 
     402                //Draw contours and record areas 
     403 
     404                Mat drawingPre = Mat.zeros(test.size(), CvType.CV_8UC3); 
     405                Mat mask = new Mat(drawingPre.size(), CV_8UC3,new Scalar(0)); 
     406                Scalar colorPre = new Scalar(255, 255, 255); 
     407                Imgproc.drawContours(mask, contoursPre, -1, new Scalar(255, 255, 255), FILLED); 
     408                Imgproc.fillPoly(drawingPre, contoursPre,colorPre); 
     409                imageViewer("DRAWINGPRE", drawingPre); 
     410 
     411 
     412                //FIIIIIIIIIIIIIIIIIIIIIIIIIIXXXXXXXXXXXX 
     413                //Remove from main Mat 
     414                Core.bitwise_not(mask,mask); 
     415                imageViewer("MASK", mask); 
     416                imageViewer("TEST", test); 
     417 
     418                drawingPre.copyTo(test, mask); 
     419                imageViewer("COMBINE", test); 
    424420 
    425421                //start staff line detection 
     
    427423                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,1)); 
    428424                Imgproc.erode(test,test,kernelErode); 
    429                 showWaitDestroy("01 Erode", test); 
     425                imageViewer("01 Erode plus pre", test); 
    430426 
    431427                Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(20,3)); 
    432428                Imgproc.dilate(test,test,kernelDilate); 
    433                 showWaitDestroy("02 Dilate", test); 
     429                imageViewer("02 Dilate", test); 
    434430 
    435431                Mat kernelOpening = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(4,4)); 
    436432                Imgproc.morphologyEx(test, test, Imgproc.MORPH_CLOSE, kernelOpening); 
    437                 showWaitDestroy("03 Open", test); 
     433                imageViewer("03 Open", test); 
    438434 
    439435                Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8,8)); 
    440436                Imgproc.erode(test,test,kernelErode02); 
    441                 showWaitDestroy("04 Erode (Final)", test); 
     437                imageViewer("04 Erode (Final)", test); 
    442438 
    443439 
     
    475471 
    476472                //Show in a window 
    477                 showWaitDestroy("Contours", drawing); 
     473                imageViewer("Contours", drawing); 
    478474            } 
    479475            //Better morphology attempt - dynamic 
    480             if(codeVersion ==5) { 
     476            if(CODE_VERSION ==5) { 
    481477                int hori = original.width(); 
    482478                int vert = original.height(); 
     
    494490                System.out.println(hori + " " + vert + " "  + sizeX1 + " " + sizeY1); 
    495491                //Display Original 
    496                 showWaitDestroy("original", original1); 
     492                imageViewer("original", original1); 
    497493 
    498494                Mat test = original.clone(); 
    499                 showWaitDestroy("00 Inverse Binarized Original", test); 
     495                imageViewer("00 Inverse Binarized Original", test); 
    500496 
    501497                //Remove very large and wide black spaces (8th of the page) 
    502498                //Mat kernelRemoveLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(hori/8, vert/8)); 
    503499                //Imgproc.erode(test,test, kernelRemoveLarge); 
    504                 //showWaitDestroy("Remove Large", test); 
     500                //imageViewer("Remove Large", test); 
    505501 
    506502                //Eliminate things that are not long and thin 
    507503                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX10,sizeY1)); //new Size(10,1)); 
    508504                Imgproc.erode(test,test,kernelErode); 
    509                 showWaitDestroy("01 Erode", test); 
     505                imageViewer("01 Erode", test); 
    510506 
    511507                Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX10*2,sizeY1*3)); //new Size(20,3)); 
    512508                Imgproc.dilate(test,test,kernelDilate); 
    513                 showWaitDestroy("02 Dilate", test); 
     509                imageViewer("02 Dilate", test); 
    514510 
    515511                Mat kernelClose = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX1*4,sizeY1*4)); //new Size(4,4)); 
    516512                Imgproc.morphologyEx(test, test, Imgproc.MORPH_CLOSE, kernelClose); 
    517                 showWaitDestroy("03 Open", test); 
     513                imageViewer("03 Open", test); 
    518514 
    519515                Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(sizeX1*8,sizeX1*8)); //new Size(8,8)); 
    520516                Imgproc.erode(test,test,kernelErode02); 
    521                 showWaitDestroy("04 Erode (Final)", test); 
     517                imageViewer("04 Erode (Final)", test); 
    522518 
    523519 
     
    554550 
    555551                //Show in a window 
    556                 showWaitDestroy("Contours", drawing); 
    557             } 
    558             //ADD PRE PROC 
     552                imageViewer("Contours", drawing); 
     553            } 
     554            //MASK UNDERSTANDING 
     555            if(CODE_VERSION ==6) { 
     556                String path ="/Scratch/cpb16/is-sheet-music-encore/hires-download-images/MU/NotSheetMusic/aeu.ark+=13960=t0dv28v9r-1.png"; 
     557                Mat mask = new Mat(); 
     558                Mat dst = new Mat(); 
     559                //Get source image and binerize 
     560                Mat src = Imgcodecs.imread(path, Imgcodecs.IMREAD_GRAYSCALE); 
     561                Imgproc.adaptiveThreshold(original1, src,255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C,Imgproc.THRESH_BINARY_INV, 15, THRESHOLD_C); 
     562                imageViewer("src", src); 
     563 
     564                //Find unwanted material, then invert it so mask removes not keeps. 
     565                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(100,1)); 
     566                Imgproc.erode(src,mask,kernelErode); 
     567                Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(110,10)); 
     568                Imgproc.dilate(mask, mask, kernelDilate); 
     569                Core.bitwise_not(mask,mask); 
     570                imageViewer("mask", mask); 
     571 
     572                //Copy source image to new Mat, with mask in use 
     573                src.copyTo(dst, mask); 
     574                imageViewer("dst", dst); 
     575 
     576 
     577 
     578 
     579            } 
     580            //Mask implementation 
     581            if(CODE_VERSION ==7) { 
     582 
     583                //Display Original 
     584                imageViewer("original", original1); 
     585 
     586                Mat src = original.clone(); 
     587                Mat test = original.clone(); 
     588                Mat mask = new Mat(); 
     589                Mat dst = new Mat(); 
     590 
     591                imageViewer("00 Inverse Binarized Original", src); 
     592 
     593                //denoize 
     594                Mat denoize = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(3,3)); 
     595                Imgproc.morphologyEx(src,mask, Imgproc.MORPH_OPEN, denoize); 
     596                imageViewer("01 Denoize - mask", mask); 
     597 
     598                //close up gaps 
     599                Mat gapCloser = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5)); 
     600                Imgproc.morphologyEx(mask,mask,Imgproc.MORPH_CLOSE, gapCloser); 
     601                imageViewer("02 gap closer - mask", mask); 
     602 
     603                //Isolate large items 
     604                Mat isolateLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8, 8)); 
     605                Imgproc.morphologyEx(mask,mask,Imgproc.MORPH_OPEN, isolateLarge); 
     606                imageViewer("03 Isolate Large - mask", mask); 
     607                Core.bitwise_not(mask,mask); 
     608 
     609                //Remove unwanted large items from image 
     610                src.copyTo(dst, mask); 
     611                imageViewer("04 Large Items Removed", dst); 
     612 
     613                //start staff line detection 
     614 
     615                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,1)); 
     616                Imgproc.erode(dst,test,kernelErode); 
     617                imageViewer("11 Erode plus pre", test); 
     618 
     619                Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(20,3)); 
     620                Imgproc.dilate(test,test,kernelDilate); 
     621                imageViewer("12 Dilate", test); 
     622 
     623                Mat kernelOpening = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(4,4)); 
     624                Imgproc.morphologyEx(test, test, Imgproc.MORPH_CLOSE, kernelOpening); 
     625                imageViewer("13 Open", test); 
     626 
     627                Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8,8)); 
     628                Imgproc.erode(test,test,kernelErode02); 
     629                imageViewer("14 Erode (Final)", test); 
     630 
     631 
     632                //DETECT OUTLINE AND FIND AREA OF THESE LINES. 
     633                ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>(); 
     634                Mat hierarchy = new Mat(); 
     635 
     636                //PARAMETERS: input image, output array of arrays, output array, contour retrieval mode, contour approximation method. 
     637                //(contours)  output array of arrays: Detected contours. Each contour is stored as a vector of points 
     638                //(hierarchy) output array:           Optional output vector, containing information about the image topology. 
     639                //https://docs.opencv.org/3.3.1/d3/dc0/group__imgproc__shape.html#ga17ed9f5d79ae97bd4c7cf18403e1689a 
     640 
     641                Imgproc.findContours(test, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); 
     642 
     643                //Draw contours and record areas 
     644                Mat drawing = Mat.zeros(test.size(), CvType.CV_8UC3); 
     645                int areaCounter = 0; 
     646 
     647 
     648                Imgproc.drawContours(drawing, contours, -1, new Scalar(0, 255, 0), FILLED); 
     649//                for (int i = 0; i < contours.size(); i++) { 
     650//                    Scalar color = new Scalar(0, i, i); 
     651//                    double area = Imgproc.contourArea(contours.get(i)); 
     652//                    Imgproc.drawContours(drawing, contours, i, color, FILLED); 
     653//                    System.out.println("AREA: " + area); 
     654// 
     655//                } 
     656                imageViewer("Contours found", drawing); 
     657 
     658                //Classifier Calculation 
     659                if(areaCounter >= THRESHOLD_AREA_COUNT){ 
     660                    System.out.println("THIS IS SHEET MUSIC"); 
     661                    System.out.println(areaCounter); 
     662                } 
     663 
     664 
     665            } 
     666            //Mask implementation - HIGH RES NUMBER MOD 
     667            if(CODE_VERSION ==8) { 
     668 
     669                //Display Original 
     670                imageViewer("original", original1); 
     671 
     672                Mat src = original.clone(); 
     673                Mat test = original.clone(); 
     674                Mat mask = new Mat(); 
     675                Mat dst = new Mat(); 
     676 
     677                imageViewer("00 Inverse Binarized Original", src); 
     678 
     679                //Close then Open 
     680 
     681//                Mat firstKernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,10)); 
     682//                Imgproc.morphologyEx(src, mask, Imgproc.MORPH_CLOSE, firstKernel); 
     683//                imageViewer("01 Closed - mask", mask); 
     684// 
     685//                Mat secondKernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,10)); 
     686//                Imgproc.morphologyEx(src,mask, Imgproc.MORPH_OPEN, secondKernel); 
     687//                imageViewer("02 Open - mask", mask); 
     688 
     689 
     690                //denoize 
     691                Mat denoize = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5)); 
     692                Imgproc.morphologyEx(src,mask, Imgproc.MORPH_OPEN, denoize); 
     693                imageViewer("01 Denoize - mask", mask); 
     694 
     695                //close up gaps 
     696                Mat gapCloser = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(5,5)); 
     697                Imgproc.morphologyEx(mask,mask,Imgproc.MORPH_CLOSE, gapCloser); 
     698                imageViewer("02 gap closer - mask", mask); 
     699 
     700                //Isolate large items 
     701                Mat isolateLarge = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(8, 8)); 
     702                Imgproc.morphologyEx(mask,mask,Imgproc.MORPH_OPEN, isolateLarge); 
     703                imageViewer("03 Isolate Large - mask", mask); 
     704                Core.bitwise_not(mask,mask); 
     705 
     706                //Remove unwanted large items from image 
     707                src.copyTo(dst, mask); 
     708                imageViewer("04 Large Items Removed", dst); 
     709 
     710                //start staff line detection 
     711 
     712                Mat kernelErode = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(15,2)); //10,2 
     713                Imgproc.erode(dst,test,kernelErode); 
     714                imageViewer("11 Erode plus pre", test); 
     715 
     716                Mat kernelDilate = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //20,3 
     717                Imgproc.dilate(test,test,kernelDilate); 
     718                imageViewer("12 Dilate", test); 
     719 
     720                Mat kernelOpening = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //4,4 
     721                Imgproc.morphologyEx(test, test, Imgproc.MORPH_CLOSE, kernelOpening); 
     722                imageViewer("13 Open", test); 
     723 
     724                Mat kernelErode02 = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(10,4)); //10,1 
     725                Imgproc.erode(test,test,kernelErode02); 
     726                imageViewer("14 Erode (Final)", test); 
     727 
     728 
     729                //DETECT OUTLINE AND FIND AREA OF THESE LINES. 
     730                ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>(); 
     731                Mat hierarchy = new Mat(); 
     732 
     733                //PARAMETERS: input image, output array of arrays, output array, contour retrieval mode, contour approximation method. 
     734                //(contours)  output array of arrays: Detected contours. Each contour is stored as a vector of points 
     735                //(hierarchy) output array:           Optional output vector, containing information about the image topology. 
     736                //https://docs.opencv.org/3.3.1/d3/dc0/group__imgproc__shape.html#ga17ed9f5d79ae97bd4c7cf18403e1689a 
     737 
     738                Imgproc.findContours(test, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); 
     739 
     740                //Draw contours and record areas 
     741                Mat drawing = Mat.zeros(test.size(), CvType.CV_8UC3); 
     742                int areaCounter = 0; 
     743 
     744                //Have created a preprocess to remove large objects. 
     745                //Need to now finalized Classifier, re try area detection. 
     746                //Paths to take - rectangle boxes around detected contours over threshold (area or perimeter) 
     747                //Just use area and periemter to determine if sheet music 
     748                //Discuss with david before weekend perhaps? 
     749 
     750                Imgproc.drawContours(drawing, contours, -1, new Scalar(0, 255, 0), 1); //USES LINE_8 
     751//                   for (int i = 0; i < contours.size(); i++) { 
     752//                    Scalar color = new Scalar(0, i, i); 
     753//                    double area = Imgproc.contourArea(contours.get(i)); 
     754//                    Imgproc.drawContours(drawing, contours, i, color, FILLED); 
     755//                    System.out.println("AREA: " + area); 
     756// 
     757//                } 
     758                imageViewer("Contours found", drawing); 
     759 
     760                //Classifier Calculation 
     761                if(areaCounter >= THRESHOLD_AREA_COUNT){ 
     762                    System.out.println("THIS IS SHEET MUSIC"); 
     763                    System.out.println(areaCounter); 
     764                } 
     765 
     766 
     767            } 
    559768 
    560769            //USE stuc element, to rule out large wide and long pieces of black and white.