Changeset 4277


Ignore:
Timestamp:
08/01/08 12:38:56 (12 years ago)
Author:
curtis
Message:

Fix package statements and tweak formatting.

Location:
trunk/loci/apps/flow
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/loci/apps/flow/Detector.java

    r4267 r4277  
    3131*/ 
    3232 
     33package loci.apps.flow; 
    3334 
    3435import ij.*; 
     
    3940 
    4041public class Detector { 
    41          
    4242 
    4343        private static IndexColorModel theCM = makeCM(); 
     
    4848 
    4949                for(int ii=0 ; ii<256 ; ii++) 
    50                 r[ii] = g[ii] = b[ii] = (byte)ii;                
    51                  
     50                r[ii] = g[ii] = b[ii] = (byte)ii; 
     51 
    5252                return new IndexColorModel(8, 256, r,g,b); 
    5353    } 
     
    5757        private int intensityThreshold = 30; 
    5858        private int areaThreshold = 100; 
    59          
     59 
    6060        private int numRegions; 
    6161        private int[][] floodArray; 
    62          
     62 
    6363        private byte[] imageData; 
    64          
     64 
    6565        public void setIntensityThreshold(int t) { intensityThreshold = t; } 
    6666        public void setAreaThreshold(int t) { areaThreshold = t; } 
     
    7070                impParticles.hide(); 
    7171        } 
    72          
     72 
    7373        public static void main(String[] args) { 
    7474                Detector d = new Detector(512, 30, 100); 
    7575                Detector.impParticles = new ImagePlus("Particles", new ByteProcessor(d.size,d.size)); 
    76                  
    77  
    78                  
     76 
    7977                Detector.imp3 = IJ.openImage("particles.tiff"); 
    8078                Detector.imp3.show(); 
    8179                IJ.run("Despeckle"); 
    8280                //IJ.run("Haar wavelet filter", "k1=3 k2=3 k3=3 std=1.6"); 
    83                  
    84                  
    85                  
     81 
    8682                d.findParticles((ByteProcessor) Detector.imp3.getProcessor()); 
    8783                d.crunchArray(); 
    8884                displayImage(d.floodArray); 
    8985        } 
    90          
     86 
    9187        public Detector(int s, int intensT, int areaT) { 
    9288                size = s; 
     
    9490                areaThreshold = areaT; 
    9591        } 
    96          
     92 
    9793        public Vector<Particle> crunchArray() { 
    98                  
     94 
    9995                Vector<Particle> retval = new Vector<Particle>(); 
    10096                int[] area = new int[numRegions], totalIntensity = new int[numRegions]; 
     
    106102                        } 
    107103                } 
    108                  
     104 
    109105                boolean[] edgeParticle = new boolean[numRegions]; 
    110106                for (int i=0; i<size; i++) { 
     
    114110                        if (floodArray[i][size-1] > 1) edgeParticle[floodArray[i][size-1]-2] = true; 
    115111                } 
    116                  
    117                  
     112 
    118113                for (int i=0; i<numRegions; i++) { 
    119114                        if (area[i] < areaThreshold || edgeParticle[i]) continue; 
     
    137132                //Heuristic 1 
    138133                for (int i=0; i<50; i++) markPixels(floodArray); 
    139                  
     134 
    140135                // Find the particle regions. 
    141136                numRegions = fillParticles(floodArray); 
    142137        } 
    143          
     138 
    144139        public static void displayImage(int[][] arr) { 
    145140                byte[] particleArray = new byte[arr.length*arr[0].length]; 
     
    152147                impParticles.show(); 
    153148        } 
    154          
     149 
    155150        private int fillParticles(int[][] floodArray) { 
    156151                int num = 2; 
     
    173168                } 
    174169        } 
    175          
     170 
    176171        private void markPixels(int[][] arr) { 
    177172                int m=size-1; 
     
    188183                                        if (i<m &&        arr[i+1][j]  ==1) {bottom++;} 
    189184                                        if (i<m && j<m && arr[i+1][j+1]==1) {bottom++; right++;} 
    190                                          
     185 
    191186                                        int binTop = top>0 ? 1 : 0; 
    192187                                        int binBottom = bottom>0 ? 1 : 0; 
     
    203198                array[i][j] = num; 
    204199                int m=size-1; 
    205                  
     200 
    206201                int iter=j-1, left=j, right=j; 
    207202                while (iter>0 && array[i][iter]==1) { 
     
    214209                } 
    215210                right=iter; 
    216                  
     211 
    217212                if (left<0) left=0; 
    218213                if (right>m) right=m; 
    219                  
     214 
    220215                for (int k=left; k<=right; k++) { 
    221216                        if (i>1 && array[i-1][k] == 1) heuristicFloodFill(array, i-1, k, num); 
  • trunk/loci/apps/flow/JVMLinkFlowCytometry.java

    r4267 r4277  
    3131*/ 
    3232 
     33package loci.apps.flow; 
    3334 
    3435// TODO: make sure the pixels/micron thing is consistent 
     
    6263        int begin; 
    6364        int end; 
    64          
     65 
    6566        public Slice(int n) { 
    6667                num = n; 
     
    7576} 
    7677 
    77  
    7878public class JVMLinkFlowCytometry { 
    79          
     79 
    8080        private static final int MIN_INTENSITY = 0; 
    8181        private static final int MAX_INTENSITY = 255; 
    82          
     82 
    8383        private static final int INTENSITY_AXIS = 0; 
    8484        private static final int AREA_AXIS = 1; 
    85          
     85 
    8686        private static final int PIXELS = 0; 
    8787        private static final int MICRONS = 1; 
     
    9393        private static ColorModel theCM; 
    9494        private static Detector d; 
    95          
     95 
    9696        public static int nSlices; 
    9797        private static int nParticles; 
     
    103103        private static Vector<Double> diameterValues; 
    104104        private static Vector<Integer> cellFrameV = new Vector<Integer>(); 
    105          
     105 
    106106        private static Vector<Particle> particles; 
    107107        private static Vector<Slice> slices; 
     
    121121        private static double maxArea, minArea, maxIntensity, minIntensity; 
    122122        private static ScalarMap xMap, yMap; 
    123          
     123 
    124124        private static double pixelMicronSquared; 
    125          
     125 
    126126        private static int resolutionWidth = 0; 
    127127        private static int resolutionHeight = 0; 
     
    129129        private static int intensityThreshold=30, areaThresholdInPixels=100, areaUnit=0; 
    130130        private static boolean showParticles=false; 
    131          
     131 
    132132        private static Vector<Integer> sliceBegin, sliceEnd; 
    133133        // sliceBegin[i] is the minimum identifier of all particles on slice i 
    134134        // sliceEnd[i] is the maximum identifier of all particles on slice i 
    135          
     135 
    136136        // For XML metadata 
    137137        private static String s_Name, s_Experiment, s_Params, s_Date; 
     
    141141                ij.getBounds(); 
    142142        } 
    143          
     143 
    144144        public static void incrementSlices() { 
    145145                nSlices++; 
     
    172172                stack = new ImageStack(resolutionWidth, resolutionHeight, theCM); 
    173173                imp.show(); 
    174                  
     174 
    175175                Detector.createImageHolder(resolutionWidth, resolutionHeight); 
    176                  
     176 
    177177                imp.unlock(); 
    178                 maxArea=Double.MIN_VALUE;  
    179                 minArea=Double.MAX_VALUE;  
     178                maxArea=Double.MIN_VALUE; 
     179                minArea=Double.MAX_VALUE; 
    180180                maxIntensity = Double.MIN_VALUE; 
    181181                minIntensity = Double.MAX_VALUE; 
    182182                nSlices = 0; 
    183183                nParticles = 0; 
    184                  
     184 
    185185                pixelMicronSquared = pixelsPerMicron*pixelsPerMicron; 
    186186                pixelMicronSquared = 0.149*0.149; 
    187                  
     187 
    188188                particles = new Vector<Particle>(); 
    189189                slices = new Vector<Slice>(); 
    190                  
     190 
    191191                sliceBegin = new Vector<Integer>(); 
    192192                sliceEnd = new Vector<Integer>(); 
     
    194194                intensityValues = new Vector<Double>(); 
    195195                diameterValues = new Vector<Double>(); 
    196                  
     196 
    197197                XAxisValues = intensityValues; 
    198198                YAxisValues = areaValues; 
     
    210210                ImageWindow stackwin = ((ImageWindow) imp.getWindow()); 
    211211                scroll = (Scrollbar) stackwin.getComponent(1); 
    212                  
     212 
    213213                imp.setSlice(nSlices); 
    214214                //intensityValues.add(0.0); 
     
    221221                diameter = RealType.getRealType("Diameter"); 
    222222 
    223                 try {                    
     223                try { 
    224224                        // Display initialization 
    225225                        //RealTupleType point = new RealTupleType(area, intensity); 
    226226 
    227                          
    228227                        display = new DisplayImplJ2D("Graph Display"); 
    229228                        data_ref = new DataReferenceImpl("data_ref"); 
     
    286285                } catch (VisADException e) {IJ.log("VisAD Exception in init: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
    287286        } 
    288          
     287 
    289288        public static void setAxes(int x, int y) { 
    290289                // 0 - Intensity 
     
    292291                // 2 - Diameter 
    293292                xAxis = x; yAxis = y; 
    294                                  
     293 
    295294                switch(xAxis) { 
    296295                case 0: 
     
    307306                        break; 
    308307                } 
    309                  
     308 
    310309                switch(yAxis) { 
    311310                case 0: 
     
    332331                        display.addMap(xMap); 
    333332                        display.addMap(yMap); 
    334                          
     333 
    335334                } catch (RemoteException e) { e.printStackTrace(); } 
    336335                  catch (VisADException  e) { e.printStackTrace(); } 
     
    338337 
    339338        // Setters 
    340          
     339 
    341340        public static void setResolution(int width, int height) { 
    342341                resolutionWidth = width; 
    343342                resolutionHeight = height; 
    344343        } 
    345          
     344 
    346345        public static void setXAxis(int option) { xAxis = option; } 
    347346        public static void setYAxis(int option) { yAxis = option; } 
     
    354353        public static void setMaxY(int val) { maxY = val; } 
    355354        public static void setIntensityThreshold(int val) { intensityThreshold = val; } 
    356         public static void setAreaThreshold(int val) {  
     355        public static void setAreaThreshold(int val) { 
    357356                if (areaUnit == PIXELS) { 
    358357                        areaThresholdInPixels = val; 
    359358                } 
    360359                else if (areaUnit == MICRONS) { 
    361                         areaThresholdInPixels = (int) Math.round(val*pixelMicronSquared);                        
     360                        areaThresholdInPixels = (int) Math.round(val*pixelMicronSquared); 
    362361                } 
    363362        } 
     
    373372                        newestProcessFrame(i+1); 
    374373                } 
    375                 updateGraph();           
    376         } 
    377          
     374                updateGraph(); 
     375        } 
     376 
    378377        public static void saveDataWithXML() throws FormatException, IOException { 
    379378                ImageWriter iw = new ImageWriter(); 
    380379                MetadataStore metadataStore = MetadataTools.createOMEXMLMetadata(); 
    381380                metadataStore.createRoot(); 
    382                  
     381 
    383382                metadataStore.setPixelsSizeX(new Integer(resolutionWidth), 0, 0); 
    384383                metadataStore.setPixelsSizeY(new Integer(resolutionHeight), 0, 0); 
     
    391390                metadataStore.setExperimenterFirstName(s_Name, 0); 
    392391 
    393                  
    394392                MetadataRetrieve metadataObject = (MetadataRetrieve) metadataStore; 
    395393                iw.setMetadataRetrieve(metadataObject); 
     
    402400                // setImageCreationDate, setImageName on MetadataStore 
    403401                iw.setId("testImage.ome.tiff"); 
    404                  
     402 
    405403                System.out.println(stack.getSize()); 
    406404                for (int i=1; i<=stack.getSize(); i++) { 
     
    414412                newestProcessFrame(nSlices-2); 
    415413        } 
    416          
     414 
    417415        public static void newestProcessFrame(int sliceNum) { 
    418416                sliceNum = sliceNum+2; 
     
    431429                        thisSlice.end = nParticles+thisParticles.size()-1; 
    432430                } 
    433                  
     431 
    434432                for (int i=0; i<thisParticles.size(); i++) { 
    435433                        Particle thisParticle = thisParticles.get(i); 
     
    438436                        thisParticle.setPixelsPerMicron(pixelMicronSquared); 
    439437                        particles.add(thisParticle); 
    440                  
     438 
    441439                        //thisParticle.print(); 
    442                          
     440 
    443441                        int thisArea = thisParticle.getMicronArea(); 
    444442                        int thisIntensity = thisParticle.getIntensity(); 
     
    448446                        if (thisIntensity < minIntensity) minIntensity = thisIntensity; 
    449447                } 
    450                  
     448 
    451449                slices.add(thisSlice); 
    452450        } 
    453          
     451 
    454452        public static void newProcessFrame() { 
    455453                imp.unlock(); 
     
    476474                System.out.println("just added to vectors: "+totalArea+ " "+totalIntensity/totalArea); 
    477475        } 
    478          
     476 
    479477        public static void processFrame() { 
    480478                incrementSlices(); 
     
    495493                areaValues.add(totalArea); 
    496494                intensityValues.add(totalIntensity); 
    497                 cellFrameV.add(nSlices);  
    498                  
     495                cellFrameV.add(nSlices); 
     496 
    499497                sliceBegin.ensureCapacity(2*nSlices); 
    500498                sliceEnd.ensureCapacity(2*nSlices); 
     
    504502                for (int i=0; i<sliceBegin.size(); i++) System.out.println(sliceBegin.get(i)); 
    505503        } 
    506          
     504 
    507505        private static double getMinX() { 
    508506                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    509                  
     507 
    510508                if (minX !=0) return minX; 
    511509                else { 
    512510                        switch(xAxis) { 
    513511                                case AREA_AXIS: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    514                                 case INTENSITY_AXIS: return MIN_INTENSITY;  
     512                                case INTENSITY_AXIS: return MIN_INTENSITY; 
    515513                                default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    516514                        } 
    517515                } 
    518516        } 
    519          
     517 
    520518        private static double getMaxX() { 
    521519                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     
    533531        private static double getMinY() { 
    534532                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    535                  
     533 
    536534                if (minY !=0) return minY; 
    537535                else { 
    538536                        switch(yAxis) { 
    539537                                case AREA_AXIS: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    540                                 case INTENSITY_AXIS: return MIN_INTENSITY;  
     538                                case INTENSITY_AXIS: return MIN_INTENSITY; 
    541539                                default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    542540                        } 
    543541                } 
    544542        } 
    545          
     543 
    546544        private static double getMaxY() { 
    547545                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     
    588586                        } 
    589587                } 
    590                  
     588 
    591589                //System.out.println("beginIndex:"+beginIndex+" endIndex:"+endIndex+" numParticles:"+numParticles); 
    592                  
     590 
    593591                if (numParticles == 0) return null; 
    594592 
    595593                xArray = new double[numParticles]; 
    596594                yArray = new double[numParticles]; 
    597                  
    598595 
    599596                for (int i=beginIndex; i<=endIndex; i++) { 
     
    608605                } 
    609606                //for (int i=beginIndex; i<=endIndex; i++) System.out.println("Now plotting "+Double.toString(xArray[i-beginIndex]) + " " + Double.toString(yArray[i-beginIndex])); 
    610                  
     607 
    611608                List1DDoubleSet xSet; 
    612609                FlatField ff=null; 
     
    620617                return ff; 
    621618        } 
    622          
     619 
    623620        public static FlatField newGetData(int slice, boolean cumulative, RealType x, FunctionType fn) { 
    624621                //slice is NOT zero-indexed. 
     
    675672        } 
    676673 
    677          
    678674        public static void saveValues() throws IOException { 
    679675                BufferedWriter bw = new BufferedWriter(new FileWriter("values"+s_Date.substring(0,9))); 
     
    687683                } 
    688684        } 
    689          
     685 
    690686        public static void showParticles(boolean val) { 
    691687                showParticles = val; 
     
    693689                else Detector.impParticles.hide(); 
    694690        } 
    695          
     691 
    696692        public static void processFile(String filename) throws IOException { 
    697693                ImagePlus imp = IJ.openImage(filename); 
    698694                ImageStack stack = imp.getStack(); 
    699695                int size = imp.getWidth(); 
    700                  
     696 
    701697                double PixelsPerMicron = Double.valueOf(IJ.getString("Please enter the pixels/micron value for this analysis", "0.1")); 
    702698                pixelMicronSquared = PixelsPerMicron*PixelsPerMicron; 
    703                  
     699 
    704700                init(size, size, 1); 
    705701                showParticles(true); 
     
    711707                        updateGraph(); 
    712708                } 
    713                  
     709 
    714710                BufferedWriter bw = new BufferedWriter(new FileWriter(filename+".values")); 
    715711                bw.write("Area (micron^2)\t\t(pixel^2)\t\tIntensity\t\tFrame"); bw.newLine(); bw.newLine(); 
     
    728724                } 
    729725        } 
    730          
     726 
    731727        private static String flattenVector(Vector<Double> v) { 
    732728                String retval = ""; 
     
    735731                } 
    736732                return retval; 
    737         }        
     733        } 
    738734} 
  • trunk/loci/apps/flow/Particle.java

    r4267 r4277  
    44 
    55/* 
    6 Particle class to store information for each detected particle while  
     6Particle class to store information for each detected particle while 
    77running flow cytometry. 
    88Copyright (c) 2008 Hidayath Ansari and Curtis Rueden. All rights reserved. 
     
    3131*/ 
    3232 
     33package loci.apps.flow; 
    3334 
    3435public class Particle { 
     
    3940        private int sliceNum; 
    4041        private double pixelMicronSquared; 
    41                  
     42 
    4243        public Particle(int a, int i) { 
    4344                pixelArea = a; 
    4445                totalIntensity = i; 
    4546        } 
    46          
     47 
    4748        public void setPixelsPerMicron(double ppm) { 
    4849                pixelMicronSquared = ppm; 
    4950                micronArea = (int) Math.round(pixelArea/pixelMicronSquared); 
    5051        } 
    51          
     52 
    5253        public void print() { 
    5354                System.out.println("Particle "+num+" on slice "+sliceNum+" with area (in pixels) "+pixelArea+" and total intensity "+totalIntensity); 
     
    8384 
    8485        public int getMeanIntensity() { 
    85                 if (pixelArea==0) return 0;  
     86                if (pixelArea==0) return 0; 
    8687                else return totalIntensity/micronArea; 
    87         }        
     88        } 
    8889} 
Note: See TracChangeset for help on using the changeset viewer.