Changeset 7972


Ignore:
Timestamp:
04/14/12 23:37:07 (7 years ago)
Author:
avivekan
Message:

going crazy with modifications...2 new methods created in Find_Particle_Areas.java to be called by FlowCyto.java...hopefully this works more efficiently than the last trial

Location:
trunk/projects/flow-cytometry/src/main/java/loci/apps/flow
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/projects/flow-cytometry/src/main/java/loci/apps/flow/Find_Particle_Areas.java

    r7971 r7972  
    77import ij.plugin.Duplicator; 
    88import ij.plugin.filter.PlugInFilter; 
    9 import ij.plugin.frame.RoiManager; 
    109import ij.process.ImageProcessor; 
    1110import ij.text.TextWindow; 
     
    2322        private Duplicator duplicator; 
    2423        private TextWindow twindow; 
     24         
    2525 
    2626        /** 
     
    6060                        gd.addNumericField ("Size_Minimum",  0, 0); 
    6161                        gd.addCheckbox("Exclude_Particles_on_Edge",true); 
    62                         gd.addCheckbox("Show summed areas",false); 
    63                         gd.addCheckbox("Run Plugin Over Entire Stack", false); 
    64  
     62                        gd.addCheckbox("Show_summed_areas",false); 
     63                        gd.addCheckbox("Run_Plugin_Over_Entire_Stack", false); 
     64                         
    6565                        gd.showDialog(); 
    6666                        if (gd.wasCanceled()) return; 
     
    7373                        doTheSum= gd.getNextBoolean(); 
    7474                        dofullStack = gd.getNextBoolean(); 
    75  
     75                         
    7676                        //begin core program 
    7777                        Interpreter.batchMode=true; 
    7878 
    79                         //check option for analyze full stack first, bypass other methods if so. 
     79                        //check option for analyze full stack, bypass other methods if so. 
    8080                        //uses original stacked image, not single image 
    8181                        if (dofullStack){ 
     
    9191                                        doTheSum(true); 
    9292 
    93                                 imp.flush(); 
    9493                                imp.close(); 
    9594                        } 
    96  
    97  
     95                        Interpreter.batchMode=false; 
     96                         
    9897                } catch(Exception e){ 
    9998                        IJ.showMessage("Error with plugin."); 
    10099                        e.printStackTrace(); 
     100                        Interpreter.batchMode=false; 
    101101                } 
    102102        } 
     
    225225                } 
    226226        } 
     227         
     228         
     229        public static float[] inWiscScanMode(ImagePlus imageToAnalyze, boolean isIntensity, boolean excludeOnEdge, double threshMin, int minSize){ 
     230                float[] summedPixelAreasArray;           
     231                try{ 
     232                        //if image is of intensity, do related calculations, else do brightfield calculations 
     233                        if(isIntensity){ 
     234                                imageToAnalyze.getProcessor().setThreshold(threshMin, 255, ImageProcessor.RED_LUT); 
     235                                IJ.run(imageToAnalyze, "Convert to Mask", null); 
     236 
     237                                if(excludeOnEdge) IJ.run(imageToAnalyze, "Analyze Particles...", "size="+minSize+"-Infinity circularity=0.00-1.00 show=Masks display exclude clear include add"); 
     238                                else IJ.run(imageToAnalyze, "Analyze Particles...", "size="+minSize+"-Infinity circularity=0.00-1.00 show=Masks display clear include add"); 
     239                        }                        
     240                        else{ 
     241                                IJ.run(imageToAnalyze, "Find Edges", null); 
     242                                IJ.run(imageToAnalyze, "Find Edges", null); 
     243 
     244                                IJ.run(imageToAnalyze, "Gaussian Blur...", "sigma=5"); 
     245 
     246                                IJ.runPlugIn(imageToAnalyze, "Auto Threshold", "method=Minimum white"); 
     247 
     248                                if(excludeOnEdge) IJ.run(imageToAnalyze, "Analyze Particles...", "size="+minSize+"-Infinity circularity=0.00-1.00 show=Masks display exclude clear include add"); 
     249                                else IJ.run(imageToAnalyze, "Analyze Particles...", "size="+minSize+"-Infinity circularity=0.00-1.00 show=Masks display clear include add"); 
     250                        }  
     251                         
     252                        //get the pixel areas for all particles in this image as array 
     253                        ResultsTable resTab = ResultsTable.getResultsTable(); 
     254                        if(resTab.getCounter()>0){ 
     255                                //get the values under the column "Area" 
     256                                return summedPixelAreasArray = resTab.getColumn(resTab.getColumnIndex("Area")); 
     257                        } 
     258                }catch(Exception e){ 
     259                        IJ.showMessage("Error with finding particles plugin"); 
     260                        IJ.log(e.getMessage()); 
     261                        //fall through 
     262                } 
     263                summedPixelAreasArray=new float[1]; 
     264                summedPixelAreasArray[0]=0; 
     265                Interpreter.batchMode=false; 
     266                return summedPixelAreasArray; 
     267 
     268                 
     269        } 
    227270 
    228271} 
  • trunk/projects/flow-cytometry/src/main/java/loci/apps/flow/FlowCyto.java

    r7971 r7972  
    1616import java.io.IOException; 
    1717 
     18 
    1819public class FlowCyto { 
    1920 
     
    2728        //      private static String s_Name, s_Experiment, s_Params, s_Date, tempImageName; 
    2829        private static double pixelMicronSquared; 
    29         private static RoiManager rman; 
    30         private static ResultsTable rtab; 
    3130        private static byte[] dummyData; 
    3231 
     
    5554 
    5655                try{ 
    57                         IJ.run("Close All"); 
     56                        //      IJ.run("Close All"); 
    5857                        WindowManager.closeAllWindows(); 
    5958                        imagej.quit(); 
     
    163162 
    164163        @SuppressWarnings("static-access") 
    165         public static void showImage(String mode, int width, int height, byte[] imageData) { 
     164        public static void showImage(int mode, int width, int height, byte[] imageData) { 
    166165                try{ 
    167166                        long initialTime = System.nanoTime(); 
    168167                        bp = new ByteProcessor(width,height,imageData, theCM); 
    169168                        bp.createImage(); 
    170                         mode = mode.toLowerCase(); 
    171                         if ("brightfield".equals(mode)) { 
     169 
     170                        //brightfield 
     171                        if (mode == 1) { 
    172172                                stackBF.addSlice("Slice "+nSlicesBF, bp); 
    173173                                impBF.setStack("Brightfield Images", stackBF); 
     
    177177                                nSlicesBF++; 
    178178                                //-----------------------FOR DEBUG PURPOSES--------------------// 
    179                                 IJ.log("brightfield image "+nSlicesBF+" displayed in "+ ((System.nanoTime() - initialTime)/1000) +"us"); 
     179                                IJ.log("brightfield image "+nSlicesBF+" displayed in "+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
    180180                                //-------------------------------------------------------------// 
    181181                        } 
    182                         else if ("intensity".equals(mode)) { 
     182 
     183                        //intensity 
     184                        else if (mode == 2) { 
    183185                                stackIN.addSlice("Slice "+nSlicesIN, bp); 
    184186                                impIN.setStack("Intensity Images", stackIN); 
     
    188190                                nSlicesIN++; 
    189191                                //-----------------------FOR DEBUG PURPOSES--------------------// 
    190                                 IJ.log("intensity image "+nSlicesIN+" displayed in "+ ((System.nanoTime() - initialTime)/1000) +"us"); 
     192                                IJ.log("intensity image "+nSlicesIN+" displayed in "+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
    191193                                //-------------------------------------------------------------// 
    192194                        } 
     195 
     196                        //default 
    193197                        else { 
    194198                                stack.addSlice("Slice "+nSlices, bp); 
     
    206210 
    207211        @SuppressWarnings("static-access") 
    208         public static float[] getParticleAreas(boolean isIntensityImage, boolean excludeOnEdge, double thresholdMin, int sizeMin){ 
     212        public static boolean foundParticle(boolean isIntensityImage, boolean excludeOnEdge, double thresholdMin, int sizeMin, float compareTOLow, float compareTOHigh){ 
     213 
     214                //-----------------------FOR DEBUG PURPOSES--------------------// 
    209215                long initialTime = System.nanoTime(); 
     216                IJ.log("Gating method started on slice "+nSlicesIN+" at \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     217                //-------------------------------------------------------------// 
     218 
     219                float[] summedPixelAreasArray; 
    210220                Interpreter.batchMode=true; 
    211221 
    212222                try{ 
    213  
    214223                        if(isIntensityImage){                            
    215224                                try{ 
    216                                         if(excludeOnEdge) IJ.run(impIN, "Find Particle Areas", "channel=Intensity threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+" exclude_particles_on_edge"); 
    217                                         else IJ.run(impIN, "Find Particle Areas", "channel=Intensity threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+""); 
    218                                         //-----------------------FOR DEBUG PURPOSES--------------------// 
    219                                         IJ.log("plugin finished on intensity image "+nSlicesIN+" in "+ ((System.nanoTime() - initialTime)/1000) +"us"); 
    220                                         //-------------------------------------------------------------// 
    221  
    222                                 }catch(Exception e){ 
    223                                         if(excludeOnEdge)IJ.run(imp, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+" exclude_particles_on_edge"); 
    224                                         else IJ.run(imp, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+""); 
     225                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(impIN, true, excludeOnEdge, thresholdMin, sizeMin); 
     226 
     227                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     228                                        IJ.log("plugin finished on intensity image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     229                                        //-------------------------------------------------------------// 
     230 
     231                                }catch(Exception e){  
     232                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(imp, true, excludeOnEdge, thresholdMin, sizeMin); 
     233 
     234                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     235                                        IJ.log("plugin finished on ISLET DEFAULT image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     236                                        //-------------------------------------------------------------// 
     237 
    225238                                } 
    226239                        } 
    227240                        else { 
    228241                                try{ 
    229                                         if(excludeOnEdge)IJ.run(impBF, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+" exclude_particles_on_edge"); 
    230                                         else IJ.run(impBF, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+""); 
    231                                         //-----------------------FOR DEBUG PURPOSES--------------------// 
    232                                         IJ.log("plugin finished on brightfield image "+nSlicesBF+" in "+ ((System.nanoTime() - initialTime)/1000) +"us"); 
     242                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(impBF, false, excludeOnEdge, thresholdMin, sizeMin); 
     243 
     244                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     245                                        IJ.log("plugin finished on brightfield image "+nSlicesBF+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
    233246                                        //-------------------------------------------------------------// 
    234247 
    235248                                }catch(Exception e){ 
    236                                         if(excludeOnEdge)IJ.run(imp, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+" exclude_particles_on_edge"); 
    237                                         else IJ.run(imp, "Find Particle Areas", "channel=Brightfield threshold_minimum="+thresholdMin+" size_minimum="+sizeMin+""); 
    238                                 } 
    239                         } 
    240  
    241                         rman = RoiManager.getInstance2(); 
    242                         if(rman.getCount()>0){ 
    243                                 rman.runCommand("Measure"); 
    244                                 rtab = ResultsTable.getResultsTable(); 
    245  
    246                                 float[] areasArray = rtab.getColumn(rtab.getColumnIndex("Area")); 
    247  
    248                                 if(areasArray!=null){ 
    249  
    250                 //                      rtab.reset(); 
    251                 //                      rman.runCommand("Deselect"); 
    252                 //                      rman.runCommand("Delete"); 
    253  
    254                                         //-----------------------FOR DEBUG PURPOSES--------------------// 
    255                                         IJ.log("particle areas calculated in "+ ((System.nanoTime() - initialTime)/1000) +"us"); 
    256                                         //-------------------------------------------------------------// 
    257  
    258                                         return areasArray; 
    259                                 } 
    260  
    261                                 rman.runCommand("Deselect"); 
    262                                 rman.runCommand("Delete");               
    263                         } 
     249                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(imp, false, excludeOnEdge, thresholdMin, sizeMin); 
     250 
     251                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     252                                        IJ.log("plugin finished on ISLET DEFAULT image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     253                                        //-------------------------------------------------------------// 
     254 
     255                                } 
     256                        } 
     257 
     258                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     259                        IJ.log("particle areas calculated in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     260                        //-------------------------------------------------------------// 
     261 
     262                        for(int i=0; i<summedPixelAreasArray.length;i++) 
     263                        { 
     264                                if(summedPixelAreasArray[i] >= compareTOLow && summedPixelAreasArray[i] <= compareTOHigh){ 
     265 
     266                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     267                                        IJ.log("gating boolean -TRUE- calculated in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     268                                        //-------------------------------------------------------------// 
     269                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     270                                        IJ.log("_"); 
     271                                        //-------------------------------------------------------------// 
     272 
     273                                        return true;                                     
     274                                } 
     275 
     276 
     277 
     278                        } 
     279 
     280                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     281                        IJ.log("gating boolean -FALSE- calculated in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     282                        //-------------------------------------------------------------// 
     283                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     284                        IJ.log("_"); 
     285                        //-------------------------------------------------------------// 
     286                        return false; 
    264287                }catch (Exception e){ 
    265                         //fall through 
    266                 } 
    267  
    268                 float[] defaultVal = new float[1]; 
    269                 Interpreter.batchMode=false; 
    270                 defaultVal[0]=0; 
    271                 return defaultVal; 
     288                        IJ.log("Problem in getting particle areas"); 
     289                        IJ.log(e.getMessage()); 
     290                } 
     291                return false; 
     292        } 
     293 
     294        @SuppressWarnings("static-access") 
     295        public static float getSumOfParticleAreas(boolean isIntensityImage, boolean excludeOnEdge, double thresholdMin, int sizeMin){ 
     296 
     297                //-----------------------FOR DEBUG PURPOSES--------------------// 
     298                long initialTime = System.nanoTime(); 
     299                IJ.log("Pixel areas summing method started on slice "+nSlicesIN+" at \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     300                //-------------------------------------------------------------// 
     301                float summedPixelAreas=0; 
     302                float[] summedPixelAreasArray; 
     303                Interpreter.batchMode=true; 
     304 
     305                try{ 
     306                        if(isIntensityImage){                            
     307                                try{ 
     308                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(impIN, true, excludeOnEdge, thresholdMin, sizeMin); 
     309 
     310                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     311                                        IJ.log("plugin finished on intensity image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     312                                        //-------------------------------------------------------------// 
     313 
     314                                }catch(Exception e){  
     315                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(imp, true, excludeOnEdge, thresholdMin, sizeMin); 
     316 
     317                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     318                                        IJ.log("plugin finished on ISLET DEFAULT image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     319                                        //-------------------------------------------------------------// 
     320 
     321                                } 
     322                        } 
     323                        else { 
     324                                try{ 
     325                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(impBF, false, excludeOnEdge, thresholdMin, sizeMin); 
     326 
     327                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     328                                        IJ.log("plugin finished on brightfield image "+nSlicesBF+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     329                                        //-------------------------------------------------------------// 
     330 
     331                                }catch(Exception e){ 
     332                                        summedPixelAreasArray=Find_Particle_Areas.inWiscScanMode(imp, false, excludeOnEdge, thresholdMin, sizeMin); 
     333 
     334                                        //-----------------------FOR DEBUG PURPOSES--------------------// 
     335                                        IJ.log("plugin finished on ISLET DEFAULT image "+nSlicesIN+" in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     336                                        //-------------------------------------------------------------// 
     337 
     338                                } 
     339                        } 
     340                         
     341                        for(int i=0; i<summedPixelAreasArray.length; i++){ 
     342                                summedPixelAreas+=summedPixelAreasArray[i]; 
     343                        }                        
     344                }catch (Exception e){ 
     345                        IJ.log("Problem in getting particle areas"); 
     346                        IJ.log(e.getMessage()); 
     347                } 
     348                 
     349                //-----------------------FOR DEBUG PURPOSES--------------------// 
     350                IJ.log("pixel areas sum calculated in \t \t \t"+ ((System.nanoTime() - initialTime)/1000000) +"ms"); 
     351                //-------------------------------------------------------------// 
     352                //-----------------------FOR DEBUG PURPOSES--------------------// 
     353                IJ.log("_"); 
     354                //-------------------------------------------------------------// 
     355                 
     356                return summedPixelAreas; 
    272357        } 
    273358 
Note: See TracChangeset for help on using the changeset viewer.