Changeset 4169


Ignore:
Timestamp:
07/08/08 14:28:13 (12 years ago)
Author:
ansari
Message:

Updating flow app files

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

Legend:

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

    r4125 r4169  
    1 // 
    2 // Detector.java 
    3 // 
    4  
    5 /* 
    6 Server application for flow cytometry with WiscScan using JVMLink. 
    7 Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
    8  
    9 Redistribution and use in source and binary forms, with or without 
    10 modification, are permitted provided that the following conditions are met: 
    11   * Redistributions of source code must retain the above copyright 
    12     notice, this list of conditions and the following disclaimer. 
    13   * Redistributions in binary form must reproduce the above copyright 
    14     notice, this list of conditions and the following disclaimer in the 
    15     documentation and/or other materials provided with the distribution. 
    16   * Neither the name of the UW-Madison LOCI nor the names of its 
    17     contributors may be used to endorse or promote products derived from 
    18     this software without specific prior written permission. 
    19  
    20 THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
    21 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    22 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
    23 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    24 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
    25 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    26 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
    27 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    30 */ 
    31  
    32 package loci.apps.flow; 
    33  
    341import ij.*; 
    352import ij.process.*; 
     
    385import java.util.Vector; 
    396 
    40 /** 
    41  * <dl><dt><b>Source code:</b></dt> 
    42  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/apps/flow/Detector.java">Trac</a>, 
    43  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/apps/flow/Detector.java">SVN</a></dd></dl> 
    44  */ 
    457public class Detector { 
     8         
    469 
    47   private static IndexColorModel theCM = makeCM(); 
    48   private static IndexColorModel makeCM() { 
    49     byte[] r = new byte[256]; 
    50     byte[] g = new byte[256]; 
    51     byte[] b = new byte[256]; 
     10        private static IndexColorModel theCM = makeCM(); 
     11    private static IndexColorModel makeCM() { 
     12                byte[] r = new byte[256]; 
     13                byte[] g = new byte[256]; 
     14                byte[] b = new byte[256]; 
    5215 
    53     for (int ii=0; ii<256; ii++) r[ii] = g[ii] = b[ii] = (byte) ii; 
     16                for(int ii=0 ; ii<256 ; ii++) 
     17                r[ii] = g[ii] = b[ii] = (byte)ii;                
     18                 
     19                return new IndexColorModel(8, 256, r,g,b); 
     20    } 
    5421 
    55     return new IndexColorModel(8, 256, r, g, b); 
    56   } 
     22    public static ImagePlus impParticles, imp3; 
     23        private int size = 512; 
     24        private int intensityThreshold = 30; 
     25        private int areaThreshold = 100; 
     26         
     27        private int numRegions; 
     28        private int[][] floodArray; 
     29         
     30        private byte[] imageData; 
     31         
     32        public void setIntensityThreshold(int t) { intensityThreshold = t; } 
     33        public void setAreaThreshold(int t) { areaThreshold = t; } 
    5734 
    58   public static ImagePlus impParticles, imp3; 
     35        public static void createImageHolder(int x, int y) { 
     36                impParticles = new ImagePlus("Particles", new ByteProcessor(x, y)); 
     37                impParticles.hide(); 
     38        } 
     39         
     40        public static void main(String[] args) { 
     41                Detector d = new Detector(512, 30, 100); 
     42                Detector.impParticles = new ImagePlus("Particles", new ByteProcessor(d.size,d.size)); 
     43                 
    5944 
    60   private int size = 512; 
    61   private int intensityThreshold = 30; 
    62   private int areaThreshold = 100; 
     45                 
     46                Detector.imp3 = IJ.openImage("particles.tiff"); 
     47                Detector.imp3.show(); 
     48                IJ.run("Despeckle"); 
     49                //IJ.run("Haar wavelet filter", "k1=3 k2=3 k3=3 std=1.6"); 
     50                 
     51                 
     52                 
     53                d.findParticles((ByteProcessor) Detector.imp3.getProcessor()); 
     54                d.crunchArray(); 
     55                displayImage(d.floodArray); 
     56        } 
     57         
     58        public Detector(int s, int intensT, int areaT) { 
     59                size = s; 
     60                intensityThreshold = intensT; 
     61                areaThreshold = areaT; 
     62        } 
     63         
     64        public Vector<Particle> crunchArray() { 
     65                 
     66                Vector<Particle> retval = new Vector<Particle>(); 
     67                int[] area = new int[numRegions], totalIntensity = new int[numRegions]; 
     68                for (int i=0; i<size; i++) { 
     69                        for (int j=0; j<size; j++) { 
     70                                if (floodArray[i][j] < 2) continue; 
     71                                area[floodArray[i][j]-2]++; 
     72                                totalIntensity[floodArray[i][j]-2] += (imageData[i*size+j] & 0xff); 
     73                        } 
     74                } 
     75                for (int i=0; i<numRegions; i++) { 
     76                        if (area[i] < areaThreshold) continue; 
     77                        retval.add(new Particle(area[i], totalIntensity[i])); 
     78                        //System.out.println("Region "+i+": Area "+area[i]+"  Intensity "+totalIntensity[i]); 
     79                } 
     80                return retval; 
     81        } 
    6382 
    64   private int numRegions; 
    65   private int[][] floodArray; 
     83        public void findParticles(ImageProcessor ip) { 
    6684 
    67   private byte[] imageData; 
     85                byte[] oldByteArray = (byte[]) ip.getPixels(); 
     86                byte[] newByteArray = new byte[oldByteArray.length]; 
     87                for (int i=0; i<newByteArray.length; i++) newByteArray[i] = oldByteArray[i]; 
    6888 
    69   public void setIntensityThreshold(int t) { intensityThreshold = t; } 
    70   public void setAreaThreshold(int t) { areaThreshold = t; } 
     89                IJ.run(new ImagePlus("temp", new ByteProcessor(size, size, newByteArray, theCM)), "Despeckle", ""); 
     90                imageData = newByteArray; 
     91                floodArray = new int[size][size]; 
     92                markPixelsInitial(); 
    7193 
    72   public static void createImageHolder(int x, int y) { 
    73     impParticles = new ImagePlus("Particles", new ByteProcessor(x, y)); 
    74     impParticles.hide(); 
    75   } 
     94                //Heuristic 1 
     95                for (int i=0; i<50; i++) markPixels(floodArray); 
     96                 
     97                // Find the particle regions. 
     98                numRegions = fillParticles(floodArray); 
     99        } 
     100         
     101        public static void displayImage(int[][] arr) { 
     102                byte[] particleArray = new byte[arr.length*arr[0].length]; 
     103                for (int i=0; i<arr.length; i++) { 
     104                        for (int j=0; j<arr[0].length; j++) { 
     105                                if (arr[i][j] > 0) particleArray[i*arr[0].length+j] = new Integer(140).byteValue(); 
     106                        } 
     107                } 
     108                impParticles.setProcessor("particles", new ByteProcessor(arr.length, arr[0].length, particleArray, theCM)); 
     109                impParticles.show(); 
     110        } 
     111         
     112        private int fillParticles(int[][] floodArray) { 
     113                int num = 2; 
     114                for (int i=0; i<size; i++) { 
     115                        for (int j=0; j<size; j++) { 
     116                                if (floodArray[i][j]==0) continue; 
     117                                if (floodArray[i][j]==1) { 
     118                                        //System.out.println("Starting flood fill "+num+" at ("+i+", "+j+")"); 
     119                                        heuristicFloodFill(floodArray, i, j, num++); 
     120                                } 
     121                        } 
     122                } 
     123                System.out.println("Particles found: "+(num-2)); 
     124                return (num-2); 
     125        } 
    76126 
    77   public static void main(String[] args) { 
    78     Detector d = new Detector(512, 30, 100); 
    79     Detector.impParticles = new ImagePlus("Particles", 
    80       new ByteProcessor(d.size,d.size)); 
     127        private void markPixelsInitial() { 
     128                for (int i=0; i<imageData.length; i++) { 
     129                        if ((imageData[i] & 0xff) > intensityThreshold) floodArray[i/size][i%size] = 1; 
     130                } 
     131        } 
     132         
     133        private void markPixels(int[][] arr) { 
     134                int m=size-1; 
     135                for (int i=0; i<size; i++) { 
     136                        for (int j=0; j<size; j++) { 
     137                                if (arr[i][j]==0) { 
     138                                        int top=0, bottom=0, left=0, right=0; //Keeping counts in case we want to do something more sophisticated later. 
     139                                        if (i>1 && j>1 && arr[i-1][j-1]==1) {top++; left++;} 
     140                                        if (i>1 &&        arr[i-1][j]  ==1) {top++;} 
     141                                        if (i>1 && j<m && arr[i-1][j+1]==1) {top++; right++;} 
     142                                        if (       j>1 && arr[i][j-1]  ==1) {left++;} 
     143                                        if (       j<m && arr[i][j+1]  ==1) {right++;} 
     144                                        if (i<m && j>1 && arr[i+1][j-1]==1) {bottom++; left++;} 
     145                                        if (i<m &&        arr[i+1][j]  ==1) {bottom++;} 
     146                                        if (i<m && j<m && arr[i+1][j+1]==1) {bottom++; right++;} 
     147                                         
     148                                        int binTop = top>0 ? 1 : 0; 
     149                                        int binBottom = bottom>0 ? 1 : 0; 
     150                                        int binLeft = left>0 ? 1 : 0; 
     151                                        int binRight = right>0 ? 1 : 0; 
     152                                        if (binTop+binBottom+binLeft+binRight > 3) arr[i][j] = 1; 
     153                                        if (bottom+left+right>6) arr[i][j]=1; 
     154                                } 
     155                        } 
     156                } 
     157        } 
    81158 
    82     Detector.imp3 = IJ.openImage("particles.tiff"); 
    83     Detector.imp3.show(); 
    84     IJ.run("Despeckle"); 
    85     //IJ.run("Haar wavelet filter", "k1=3 k2=3 k3=3 std=1.6"); 
     159        private void heuristicFloodFill(int[][] array, int i, int j, int num) { 
     160                array[i][j] = num; 
     161                int m=size-1; 
     162                 
     163                int iter=j-1, left=j, right=j; 
     164                while (iter>0 && array[i][iter]==1) { 
     165                        array[i][iter--] = num; 
     166                } 
     167                left=iter; 
     168                iter=j+1; 
     169                while (iter<m && array[i][iter]==1) { 
     170                        array[i][iter++] = num; 
     171                } 
     172                right=iter; 
     173                 
     174                if (left<0) left=0; 
     175                if (right>m) right=m; 
     176                 
     177                for (int k=left; k<=right; k++) { 
     178                        if (i>1 && array[i-1][k] == 1) heuristicFloodFill(array, i-1, k, num); 
     179                        if (i<m && array[i+1][k] == 1) heuristicFloodFill(array, i+1, k, num); 
     180                } 
     181        } 
    86182 
    87     d.findParticles((ByteProcessor) Detector.imp3.getProcessor()); 
    88     d.crunchArray(); 
    89     displayImage(d.floodArray); 
    90   } 
     183        public int getNumRegions() { 
     184                return numRegions; 
     185        } 
    91186 
    92   public Detector(int s, int intensT, int areaT) { 
    93     size = s; 
    94     intensityThreshold = intensT; 
    95     areaThreshold = areaT; 
    96   } 
    97  
    98   public Vector<Particle> crunchArray() { 
    99  
    100     Vector<Particle> retval = new Vector<Particle>(); 
    101     int[] area = new int[numRegions], totalIntensity = new int[numRegions]; 
    102     for (int i=0; i<size; i++) { 
    103       for (int j=0; j<size; j++) { 
    104         if (floodArray[i][j] < 2) continue; 
    105         area[floodArray[i][j]-2]++; 
    106         totalIntensity[floodArray[i][j]-2] += (imageData[i*size+j] & 0xff); 
    107       } 
    108     } 
    109     for (int i=0; i<numRegions; i++) { 
    110       if (area[i] < areaThreshold) continue; 
    111       retval.add(new Particle(area[i], totalIntensity[i])); 
    112       //System.out.println("Region "+i+": Area "+area[i]+ 
    113       //  "  Intensity "+totalIntensity[i]); 
    114     } 
    115     return retval; 
    116   } 
    117  
    118   public void findParticles(ImageProcessor ip) { 
    119  
    120     byte[] oldByteArray = (byte[]) ip.getPixels(); 
    121     byte[] newByteArray = new byte[oldByteArray.length]; 
    122     for (int i=0; i<newByteArray.length; i++) newByteArray[i] = oldByteArray[i]; 
    123  
    124     ByteProcessor bp = new ByteProcessor(size, size, newByteArray, theCM); 
    125     IJ.run(new ImagePlus("temp", bp), "Despeckle", ""); 
    126     imageData = newByteArray; 
    127     floodArray = new int[size][size]; 
    128     markPixelsInitial(); 
    129  
    130     //Heuristic 1 
    131     for (int i=0; i<50; i++) markPixels(floodArray); 
    132  
    133     // Find the particle regions. 
    134     numRegions = fillParticles(floodArray); 
    135   } 
    136  
    137   public static void displayImage(int[][] arr) { 
    138     byte[] particleArray = new byte[arr.length*arr[0].length]; 
    139     for (int i=0; i<arr.length; i++) { 
    140       for (int j=0; j<arr[0].length; j++) { 
    141         if (arr[i][j] > 0) { 
    142           particleArray[i*arr[0].length+j] = new Integer(140).byteValue(); 
    143         } 
    144       } 
    145     } 
    146     ByteProcessor bp = new ByteProcessor(arr.length, 
    147       arr[0].length, particleArray, theCM); 
    148     impParticles.setProcessor("particles", bp); 
    149     impParticles.show(); 
    150   } 
    151  
    152   private int fillParticles(int[][] floodArray) { 
    153     int num = 2; 
    154     for (int i=0; i<size; i++) { 
    155       for (int j=0; j<size; j++) { 
    156         if (floodArray[i][j]==0) continue; 
    157         if (floodArray[i][j]==1) { 
    158           //System.out.println("Starting flood fill "+num+" at ("+i+", "+j+")"); 
    159           heuristicFloodFill(floodArray, i, j, num++); 
    160         } 
    161       } 
    162     } 
    163     System.out.println("Particles found: "+(num-2)); 
    164     return (num-2); 
    165   } 
    166  
    167   private void markPixelsInitial() { 
    168     for (int i=0; i<imageData.length; i++) { 
    169       if ((imageData[i] & 0xff) > intensityThreshold) { 
    170         floodArray[i/size][i%size] = 1; 
    171       } 
    172     } 
    173   } 
    174  
    175   private void markPixels(int[][] arr) { 
    176     int m=size-1; 
    177     for (int i=0; i<size; i++) { 
    178       for (int j=0; j<size; j++) { 
    179         if (arr[i][j]==0) { 
    180           // keep counts in case we want to do 
    181           // something more sophisticated later 
    182           int top=0, bottom=0, left=0, right=0; 
    183           if (i>1 && j>1 && arr[i-1][j-1]==1) {top++; left++;} 
    184           if (i>1 &&        arr[i-1][j]  ==1) {top++;} 
    185           if (i>1 && j<m && arr[i-1][j+1]==1) {top++; right++;} 
    186           if (       j>1 && arr[i][j-1]  ==1) {left++;} 
    187           if (       j<m && arr[i][j+1]  ==1) {right++;} 
    188           if (i<m && j>1 && arr[i+1][j-1]==1) {bottom++; left++;} 
    189           if (i<m &&        arr[i+1][j]  ==1) {bottom++;} 
    190           if (i<m && j<m && arr[i+1][j+1]==1) {bottom++; right++;} 
    191  
    192           int binTop = top>0 ? 1 : 0; 
    193           int binBottom = bottom>0 ? 1 : 0; 
    194           int binLeft = left>0 ? 1 : 0; 
    195           int binRight = right>0 ? 1 : 0; 
    196           if (binTop+binBottom+binLeft+binRight > 3) arr[i][j] = 1; 
    197           if (bottom+left+right>6) arr[i][j]=1; 
    198         } 
    199       } 
    200     } 
    201   } 
    202  
    203   private void heuristicFloodFill(int[][] array, int i, int j, int num) { 
    204     array[i][j] = num; 
    205     int m=size-1; 
    206  
    207     int iter=j-1, left=j, right=j; 
    208     while (iter>0 && array[i][iter]==1) { 
    209       array[i][iter--] = num; 
    210     } 
    211     left=iter; 
    212     iter=j+1; 
    213     while (iter<m && array[i][iter]==1) { 
    214       array[i][iter++] = num; 
    215     } 
    216     right=iter; 
    217  
    218     if (left<0) left=0; 
    219     if (right>m) right=m; 
    220  
    221     for (int k=left; k<=right; k++) { 
    222       if (i>1 && array[i-1][k] == 1) heuristicFloodFill(array, i-1, k, num); 
    223       if (i<m && array[i+1][k] == 1) heuristicFloodFill(array, i+1, k, num); 
    224     } 
    225   } 
    226  
    227   public int getNumRegions() { 
    228     return numRegions; 
    229   } 
    230  
    231   public int[][] getFloodArray() { 
    232     return floodArray; 
    233   } 
    234  
     187        public int[][] getFloodArray() { 
     188                return floodArray; 
     189        } 
    235190} 
  • trunk/loci/apps/flow/FCTest.java

    r4125 r4169  
    1 // 
    2 // FCTest.java 
    3 // 
    4  
    5 /* 
    6 Server application for flow cytometry with WiscScan using JVMLink. 
    7 Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
    8  
    9 Redistribution and use in source and binary forms, with or without 
    10 modification, are permitted provided that the following conditions are met: 
    11   * Redistributions of source code must retain the above copyright 
    12     notice, this list of conditions and the following disclaimer. 
    13   * Redistributions in binary form must reproduce the above copyright 
    14     notice, this list of conditions and the following disclaimer in the 
    15     documentation and/or other materials provided with the distribution. 
    16   * Neither the name of the UW-Madison LOCI nor the names of its 
    17     contributors may be used to endorse or promote products derived from 
    18     this software without specific prior written permission. 
    19  
    20 THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
    21 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    22 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
    23 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    24 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
    25 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    26 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
    27 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    30 */ 
    31  
    32 package loci.apps.flow; 
    33  
    341import ij.*; 
    352 
    36 /** 
    37  * <dl><dt><b>Source code:</b></dt> 
    38  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/apps/flow/FCTest.java">Trac</a>, 
    39  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/apps/flow/FCTest.java">SVN</a></dd></dl> 
    40  */ 
    413public class FCTest { 
    42  
    43   public static void main(String[] args) { 
    44     FCTest fc = new FCTest(); 
    45     fc.doStuff(); 
    46   } 
    47  
    48   public void doStuff() { 
    49     ImagePlus imp = IJ.openImage("particles.tiff"); 
    50     ImageStack stack = imp.getStack(); 
    51     int size = 512; 
    52  
    53     JVMLinkFlowCytometry.init(size, size, 1); 
    54     JVMLinkFlowCytometry.setIntensityThreshold(30); 
    55     JVMLinkFlowCytometry.showParticles(true); 
    56     for (int i=1; i<=stack.getSize(); i++) { 
    57       byte[] imageData = (byte[]) stack.getPixels(i); 
    58       JVMLinkFlowCytometry.incrementSlices(); 
    59       JVMLinkFlowCytometry.showImage(size, size, imageData); 
    60       JVMLinkFlowCytometry.newestProcessFrame(i); 
    61       JVMLinkFlowCytometry.updateGraph(); 
    62     } 
    63   } 
    64  
     4        public static void main(String[] args) { 
     5                FCTest fc = new FCTest(); 
     6                fc.doStuff(); 
     7        } 
     8         
     9        public void doStuff() { 
     10                ImagePlus imp = IJ.openImage("particles.tiff"); 
     11                ImageStack stack = imp.getStack(); 
     12                int size = 512;          
     13                 
     14                JVMLinkFlowCytometry.init(size, size, 1); 
     15                JVMLinkFlowCytometry.setIntensityThreshold(30); 
     16                JVMLinkFlowCytometry.showParticles(true); 
     17                for (int i=1; i<=stack.getSize(); i++) { 
     18                        byte[] imageData = (byte[]) stack.getPixels(i); 
     19                        JVMLinkFlowCytometry.incrementSlices(); 
     20                        JVMLinkFlowCytometry.showImage(size, size, imageData); 
     21                        JVMLinkFlowCytometry.newestProcessFrame(i); 
     22                        JVMLinkFlowCytometry.updateGraph(); 
     23                }                
     24        }        
    6525} 
  • trunk/loci/apps/flow/JVMLinkFlowCytometry.java

    r4125 r4169  
    44 
    55/* 
    6 Server application for flow cytometry with WiscScan using JVMLink. 
    7 Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     6JVMLink client/server architecture for communicating between Java and 
     7non-Java programs using sockets. 
     8Copyright (c) 2008 Hidayath Ansari and Curtis Rueden. All rights reserved. 
    89 
    910Redistribution and use in source and binary forms, with or without 
     
    3031*/ 
    3132 
    32 package loci.apps.flow; 
    33  
    3433import ij.*; 
    3534import ij.gui.ImageWindow; 
     
    4645import java.io.IOException; 
    4746import java.rmi.RemoteException; 
    48 import java.text.SimpleDateFormat; 
    49 import java.util.Date; 
    5047import java.util.Vector; 
    5148 
     
    5754import loci.formats.meta.MetadataStore; 
    5855 
    59 /** 
    60  * <dl><dt><b>Source code:</b></dt> 
    61  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/apps/flow/JVMLinkFlowCytometry.java">Trac</a>, 
    62  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/apps/flow/JVMLinkFlowCytometry.java">SVN</a></dd></dl> 
    63  */ 
     56class Slice { 
     57        int num; 
     58        boolean hasParticles; 
     59        int begin; 
     60        int end; 
     61         
     62        public Slice(int n) { 
     63                num = n; 
     64                hasParticles = false; 
     65        } 
     66 
     67        public void print() { 
     68                if (hasParticles) System.out.println("Slice "+num+" begins with particle "+begin+" and ends at "+end); 
     69                else System.out.println("Slice "+num+" has no particles"); 
     70        } 
     71 
     72} 
     73 
     74 
    6475public class JVMLinkFlowCytometry { 
    65  
    66   private static final int MIN_INTENSITY = 0; 
    67   private static final int MAX_INTENSITY = 255; 
    68  
    69   private static ImageJ ij; 
    70   private static ImagePlus imp; 
    71   private static ImageStack stack; 
    72   private static ByteProcessor bp; 
    73   private static ColorModel theCM; 
    74   private static Detector d; 
    75  
    76   public static int nSlices; 
    77   private static int nParticles; 
    78   private static JFrame frame; 
    79   private static JCheckBox CBcumulative; 
    80   private static boolean cumulative; 
    81   private static Vector<Double> areaValues; 
    82   private static Vector<Double> intensityValues; 
    83   private static Vector<Double> diameterValues; 
    84   private static Vector<Integer> cellFrameV = new Vector<Integer>(); 
    85  
    86   private static Vector<Particle> particles; 
    87   private static Vector<Slice> slices; 
    88  
    89   //These are pointers to vectors containing actual values 
    90   //to axes as specified in WiscScan. 
    91   private static Vector<Double> XAxisValues; 
    92   private static Vector<Double> YAxisValues; 
    93   private static int xAxis, yAxis; 
    94  
    95   private static RealType area, intensity, diameter, xType, yType; 
    96   private static FunctionType fn; 
    97   private static DataReferenceImpl data_ref; 
    98   private static Scrollbar scroll; 
    99   private static DisplayImpl display; 
    100   private static ResultsTable rt; 
    101   private static double maxArea, minArea, maxIntensity, minIntensity; 
    102   private static ScalarMap xMap, yMap; 
    103  
    104   private static double pixelMicronSquared; 
    105  
    106   private static int resolutionWidth = 0; 
    107   private static int resolutionHeight = 0; 
    108   private static int minX=0, maxX=0, minY=0, maxY=0; 
    109   private static int intensityThreshold=30, areaThreshold=100; 
    110   private static boolean showParticles=false; 
    111  
    112   private static Vector<Integer> sliceBegin, sliceEnd; 
    113   // sliceBegin[i] is the minimum identifier of all particles on slice i 
    114   // sliceEnd[i] is the maximum identifier of all particles on slice i 
    115  
    116   // For XML metadata 
    117   private static String s_Name, s_Experiment, s_Params, s_Date; 
    118  
    119   public static void startImageJ() { 
    120     ij = new ImageJ(); 
    121     ij.getBounds(); 
    122   } 
    123  
    124   public static void incrementSlices() { 
    125     nSlices++; 
    126   } 
    127  
    128   public static void showImage(int width, int height, byte[] imageData) { 
    129     //bp = new ByteProcessor(width, height, imageData, 
    130     //  ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
    131     bp = new ByteProcessor(width,height,imageData, theCM); 
    132     bp.createImage(); 
    133     stack.addSlice("Slice "+nSlices, bp); 
    134     imp.setStack("Islet images", stack); 
    135     imp.setSlice(nSlices); 
    136     imp.show(); 
    137   } 
    138  
    139   public static void init(int width, int height, double pixelsPerMicron) { 
    140     setResolution(width, height); 
    141     s_Date = new SimpleDateFormat("MM.dd.yyyy hh:mm:ss").format(new Date()); 
    142  
    143     byte[] r = new byte[256]; 
    144     byte[] g = new byte[256]; 
    145     byte[] b = new byte[256]; 
    146  
    147     for(int ii=0 ; ii<256 ; ii++) 
    148     r[ii] = g[ii] = b[ii] = (byte)ii; 
    149  
    150     theCM = new IndexColorModel(8, 256, r,g,b); 
    151     imp = new ImagePlus("Islet images", 
    152       new ByteProcessor(resolutionWidth, resolutionHeight)); 
    153     //stack = new ImageStack(512, 512, 
    154     //  ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
    155     stack = new ImageStack(resolutionWidth, resolutionHeight, theCM); 
    156     imp.show(); 
    157  
    158     Detector.createImageHolder(resolutionWidth, resolutionHeight); 
    159  
    160     imp.unlock(); 
    161     maxArea=Double.MIN_VALUE; 
    162     minArea=Double.MAX_VALUE; 
    163     maxIntensity = Double.MIN_VALUE; 
    164     minIntensity = Double.MAX_VALUE; 
    165     nSlices = 0; 
    166     nParticles = 0; 
    167  
    168     pixelMicronSquared = pixelsPerMicron*pixelsPerMicron; 
    169     pixelMicronSquared = 0.149*0.149; 
    170  
    171     particles = new Vector<Particle>(); 
    172     slices = new Vector<Slice>(); 
    173  
    174     sliceBegin = new Vector<Integer>(); 
    175     sliceEnd = new Vector<Integer>(); 
    176     areaValues = new Vector<Double>(); 
    177     intensityValues = new Vector<Double>(); 
    178     diameterValues = new Vector<Double>(); 
    179  
    180     XAxisValues = intensityValues; 
    181     YAxisValues = areaValues; 
    182  
    183     byte[] dummyData = new byte[resolutionWidth*resolutionHeight]; 
    184     bp = new ByteProcessor(resolutionWidth,resolutionHeight,dummyData, theCM); 
    185     bp.createImage(); 
    186     nSlices = 2; 
    187     stack.addSlice("Slice "+nSlices, bp); 
    188  
    189     // because newestProcessFrame indexes from non-blank slides 
    190     newestProcessFrame(-1); 
    191  
    192     stack.addSlice("Slice "+nSlices, bp); 
    193     newestProcessFrame(0); 
    194     imp.setStack("Islet images", stack); 
    195  
    196     ImageWindow stackwin = ((ImageWindow) imp.getWindow()); 
    197     scroll = (Scrollbar) stackwin.getComponent(1); 
    198  
    199     imp.setSlice(nSlices); 
    200     //intensityValues.add(0.0); 
    201     //areaValues.add(0.0); 
    202     //intensityValues.add(0.0); 
    203     //areaValues.add(0.0); 
    204  
    205     area = RealType.getRealType("Area"); 
    206     intensity = RealType.getRealType("Intensity"); 
    207     diameter = RealType.getRealType("Diameter"); 
    208  
    209     try { 
    210       // Display initialization 
    211       //RealTupleType point = new RealTupleType(area, intensity); 
    212  
    213       display = new DisplayImplJ2D("Graph Display"); 
    214       data_ref = new DataReferenceImpl("data_ref"); 
    215       data_ref.setData(null); 
    216       display.addReference(data_ref); 
    217       display.getGraphicsModeControl().setScaleEnable(true); 
    218       display.getGraphicsModeControl().setPointSize(3); 
    219       setAxes(0,1); 
    220  
    221       frame = new JFrame("Graph Window"); 
    222       frame.setLayout(new BorderLayout()); 
    223  
    224       CBcumulative = new JCheckBox("Cumulative"); 
    225       CBcumulative.setMnemonic(KeyEvent.VK_G); 
    226       JPanel bottomPanel = new JPanel(); 
    227       bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS)); 
    228       bottomPanel.add(CBcumulative); 
    229  
    230       frame.getContentPane().add(display.getComponent(), BorderLayout.CENTER); 
    231       frame.getContentPane().add(bottomPanel, BorderLayout.SOUTH); 
    232  
    233       ItemListener CBitemListener = new ItemListener() { 
    234         public void itemStateChanged(ItemEvent itemEvent) { 
    235           cumulative = itemEvent.getStateChange() == ItemEvent.SELECTED; 
    236           try { 
    237             JVMLinkFlowCytometry.data_ref.setData( 
    238               newestGetData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
    239             JVMLinkFlowCytometry.display.reDisplayAll(); 
    240           } 
    241           catch (RemoteException e) { } 
    242           catch (VisADException e) { } 
    243         } 
    244       }; 
    245       CBcumulative.addItemListener(CBitemListener); 
    246  
    247       AdjustmentListener l = new AdjustmentListener() { 
    248         public void adjustmentValueChanged(AdjustmentEvent arg0) { 
    249           try { 
    250             int slideNum = ((Scrollbar) 
    251               imp.getWindow().getComponent(1)).getValue(); 
    252             //for the detected particles window 
    253             if (showParticles) { 
    254               d = new Detector(resolutionWidth, 
    255                 intensityThreshold, areaThreshold); 
    256               d.findParticles(stack.getProcessor(slideNum)); 
    257               d.crunchArray(); 
    258               Detector.displayImage(d.getFloodArray()); 
    259             } 
    260  
    261             //for the graph 
    262             //IJ.log("This is slide "+slideNum+" and particle numbers " + 
    263             //  "on this slide go from "+sliceBegin[slideNum]+" to "+ 
    264             //  sliceEnd[slideNum]); 
    265             //IJ.log(Integer.toString(((Scrollbar) 
    266             //  Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
    267             JVMLinkFlowCytometry.data_ref.setData(newestGetData(slideNum, 
    268               cumulative, intensity, fn)); 
    269             JVMLinkFlowCytometry.display.reDisplayAll(); 
    270             //Intensity_.this.data_ref.setData(getData(imp.getCurrentSlice(), 
    271             //  cumulative, intensity, fn)); 
    272           } 
    273           catch (RemoteException e) { } 
    274           catch (VisADException e) { } 
    275         } 
    276       }; 
    277       scroll.addAdjustmentListener(l); 
    278  
    279       imp.setSlice(1); 
    280       frame.setSize(600, 600); 
    281       frame.setVisible(true); 
    282     } 
    283     catch (VisADException e) { 
    284       IJ.log("VisAD Exception in init: "+e.getMessage()); 
    285     } 
    286     catch (RemoteException re) { 
    287       IJ.log("Remote Exception: "+re.getMessage()); 
    288     } 
    289   } 
    290  
    291   public static void setAxes(int x, int y) { 
    292     // 0 - Intensity 
    293     // 1 - Area 
    294     // 2 - Diameter 
    295     xAxis = x; yAxis = y; 
    296  
    297     switch(xAxis) { 
    298     case 0: 
    299       xType = intensity; 
    300       XAxisValues = intensityValues; 
    301       break; 
    302     case 1: 
    303       xType = area; 
    304       XAxisValues = areaValues; 
    305       break; 
    306     case 2: 
    307       xType = diameter; 
    308       XAxisValues = diameterValues; 
    309       break; 
    310     } 
    311  
    312     switch(yAxis) { 
    313     case 0: 
    314       yType = intensity; 
    315       YAxisValues = intensityValues; 
    316       break; 
    317     case 1: 
    318       yType = area; 
    319       YAxisValues = areaValues; 
    320       break; 
    321     case 2: 
    322       yType = diameter; 
    323       YAxisValues = diameterValues; 
    324       break; 
    325     } 
    326     try { 
    327       xMap = new ScalarMap(xType, Display.XAxis); 
    328       yMap = new ScalarMap(yType, Display.YAxis); 
    329       xMap.setRange(getMinX(), getMaxX()); 
    330       yMap.setRange(getMinY(), getMaxY()); 
    331  
    332       fn = new FunctionType(xType, yType); 
    333       display.clearMaps(); 
    334       display.addMap(xMap); 
    335       display.addMap(yMap); 
    336  
    337     } 
    338     catch (RemoteException e) { e.printStackTrace(); } 
    339     catch (VisADException  e) { e.printStackTrace(); } 
    340   } 
    341  
    342   // Setters 
    343  
    344   public static void setResolution(int width, int height) { 
    345     resolutionWidth = width; 
    346     resolutionHeight = height; 
    347   } 
    348  
    349   public static void setXAxis(int option) { xAxis = option; } 
    350   public static void setYAxis(int option) { yAxis = option; } 
    351   public static void setName(String name) { s_Name = name; } 
    352   public static void setExperiment(String exp) { s_Experiment = exp; } 
    353   public static void setParams(String params) { s_Params = params; } 
    354   public static void setMinX(int val) { minX = val; } 
    355   public static void setMaxX(int val) { maxX = val; } 
    356   public static void setMinY(int val) { minY = val; } 
    357   public static void setMaxY(int val) { maxY = val; } 
    358   public static void setIntensityThreshold(int val) { 
    359     intensityThreshold = val; 
    360   } 
    361   public static void setAreaThreshold(int val) { areaThreshold = val; } 
    362   public static void setPixelMicronSquared(double val) { 
    363     pixelMicronSquared = val; 
    364   } 
    365   public static void reprocessAll() { 
    366     particles = new Vector<Particle>(); 
    367     slices = new Vector<Slice>(); 
    368     nParticles = 0; 
    369     nSlices = 0; 
    370     for (int i=0; i<stack.getSize(); i++) { 
    371       incrementSlices(); 
    372       newestProcessFrame(i+1); 
    373     } 
    374     updateGraph(); 
    375   } 
    376  
    377   public static void saveDataWithXML() throws FormatException, IOException { 
    378     ImageWriter iw = new ImageWriter(); 
    379     MetadataStore metadataStore = MetadataTools.createOMEXMLMetadata(); 
    380     metadataStore.createRoot(); 
    381  
    382     metadataStore.setPixelsSizeX(new Integer(resolutionWidth), 0, 0); 
    383     metadataStore.setPixelsSizeY(new Integer(resolutionHeight), 0, 0); 
    384     metadataStore.setPixelsSizeZ(new Integer(1), 0, 0); 
    385     metadataStore.setPixelsSizeC(new Integer(1), 0, 0); 
    386     metadataStore.setPixelsSizeT(new Integer(stack.getSize()), 0, 0); 
    387     metadataStore.setPixelsPixelType("Uint8", 0, 0); 
    388     metadataStore.setPixelsBigEndian(new Boolean(false), 0, 0); 
    389     metadataStore.setPixelsDimensionOrder("XYTZC", 0, 0); 
    390     metadataStore.setExperimenterFirstName(s_Name, 0); 
    391  
    392     MetadataRetrieve metadataObject = (MetadataRetrieve) metadataStore; 
    393     iw.setMetadataRetrieve(metadataObject); 
    394     MetadataTools.populateOriginalMetadata(metadataObject, 
    395       "Experiment", s_Experiment); 
    396     MetadataTools.populateOriginalMetadata(metadataObject, 
    397       "Parameters", s_Params); 
    398     MetadataTools.populateOriginalMetadata(metadataObject, "Date", s_Date); 
    399     MetadataTools.populateOriginalMetadata(metadataObject, 
    400       "AreaValues", flattenVector(areaValues)); 
    401     MetadataTools.populateOriginalMetadata(metadataObject, 
    402       "IntensityValues", flattenVector(intensityValues)); 
    403  
    404     // setImageCreationDate, setImageName on MetadataStore 
    405     iw.setId("testImage.ome.tiff"); 
    406  
    407     System.out.println(stack.getSize()); 
    408     for (int i=1; i<=stack.getSize(); i++) { 
    409       byte[] byteArray = (byte[]) stack.getProcessor(i).getPixels(); 
    410       iw.saveBytes(byteArray, i==stack.getSize()); 
    411     } 
    412     iw.close(); 
    413   } 
    414  
    415   public static void newestProcessFrame() { 
    416     newestProcessFrame(nSlices-2); 
    417   } 
    418  
    419   public static void newestProcessFrame(int sliceNum) { 
    420     sliceNum = sliceNum+2; 
    421     imp.unlock(); 
    422     d = new Detector(resolutionWidth, intensityThreshold, areaThreshold); 
    423     d.findParticles(stack.getProcessor(sliceNum)); 
    424     Vector<Particle> thisParticles = d.crunchArray(); 
    425     if (showParticles) { 
    426       System.out.println("processFrame for slice "+sliceNum); 
    427       Detector.displayImage(d.getFloodArray()); 
    428     } 
    429     Slice thisSlice = new Slice(nSlices); 
    430     if (thisParticles.size() > 0) { 
    431       thisSlice.hasParticles = true; 
    432       thisSlice.begin = nParticles; 
    433       thisSlice.end = nParticles+thisParticles.size()-1; 
    434     } 
    435  
    436     for (int i=0; i<thisParticles.size(); i++) { 
    437       Particle thisParticle = thisParticles.get(i); 
    438       thisParticle.setNum(nParticles++); 
    439       thisParticle.setSliceNum(nSlices); 
    440       particles.add(thisParticle); 
    441       //thisParticle.print(); 
    442  
    443       int thisArea = thisParticle.getArea(); 
    444       int thisIntensity = thisParticle.getIntensity(); 
    445       if (thisArea > maxArea) maxArea = thisArea; 
    446       if (thisArea < minArea) minArea = thisArea; 
    447       if (thisIntensity > maxIntensity) maxIntensity = thisIntensity; 
    448       if (thisIntensity < minIntensity) minIntensity = thisIntensity; 
    449     } 
    450  
    451     slices.add(thisSlice); 
    452   } 
    453  
    454   public static void newProcessFrame() { 
    455     imp.unlock(); 
    456     ImageProcessor ip = stack.getProcessor(imp.getCurrentSlice()); 
    457     double totalArea=0, totalIntensity=0; 
    458     for (int i=0; i<resolutionWidth; i++) { 
    459       for (int j=0; j<resolutionHeight; j++) { 
    460         int value = ip.getPixel(i, j); 
    461         if (value >= intensityThreshold) { 
    462           totalArea++; 
    463           totalIntensity += value; 
    464         } 
    465       } 
    466     } 
    467     IJ.log("Area: "+totalArea); 
    468     IJ.log("Intensity: "+totalIntensity); 
    469     if (totalArea > maxArea) maxArea = totalArea; 
    470     if (totalArea < minArea) minArea = totalArea; 
    471     if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
    472     if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
    473     areaValues.add(totalArea); 
    474     if (totalArea != 0) intensityValues.add(totalIntensity/totalArea); 
    475     else intensityValues.add(0.0); 
    476     System.out.println("just added to vectors: "+ 
    477       totalArea+" "+totalIntensity/totalArea); 
    478   } 
    479  
    480   public static void processFrame() { 
    481     incrementSlices(); 
    482     imp.unlock(); 
    483     bp.setThreshold(25, 255, 1); 
    484     IJ.run("Analyze Particles...", 
    485       "size=0-Infinity circularity=0.00-1.00 show=Nothing display clear"); 
    486     rt = Analyzer.getResultsTable(); 
    487     double totalArea=0, totalIntensity=0; 
    488     for (int j=0; j<rt.getCounter(); j++) { 
    489       double area = rt.getValue("Area", j); 
    490       totalArea += area; 
    491       totalIntensity += (rt.getValue("Mean", j))*area; 
    492     } 
    493     if (totalArea > maxArea) maxArea = totalArea; 
    494     if (totalArea < minArea) minArea = totalArea; 
    495     if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
    496     if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
    497     areaValues.add(totalArea); 
    498     intensityValues.add(totalIntensity); 
    499     cellFrameV.add(nSlices); 
    500  
    501     sliceBegin.ensureCapacity(2*nSlices); 
    502     sliceEnd.ensureCapacity(2*nSlices); 
    503     sliceBegin.add(nSlices); 
    504     sliceEnd.add(nSlices); 
    505     System.out.println("############: sliceBegin looks like "); 
    506     for (int i=0; i<sliceBegin.size(); i++) { 
    507       System.out.println(sliceBegin.get(i)); 
    508     } 
    509   } 
    510  
    511   private static double getMinX() { 
    512     double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    513  
    514     if (minX !=0) return minX; 
    515     else { 
    516       switch(xAxis) { 
    517         case 1: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    518         case 0: return MIN_INTENSITY; 
    519         default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    520       } 
    521     } 
    522   } 
    523  
    524   private static double getMaxX() { 
    525     double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    526  
    527     if (maxX !=0) return maxX; 
    528     else { 
    529       switch(xAxis) { 
    530         case 1: return (maxArea/pixelMicronSquared+0.05*areaRange); 
    531         case 0: return MAX_INTENSITY; 
    532         default: return (maxArea/pixelMicronSquared+0.05*areaRange); 
    533       } 
    534     } 
    535   } 
    536  
    537   private static double getMinY() { 
    538     double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    539  
    540     if (minY !=0) return minY; 
    541     else { 
    542       switch(yAxis) { 
    543         case 1: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    544         case 0: return MIN_INTENSITY; 
    545         default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
    546       } 
    547     } 
    548   } 
    549  
    550   private static double getMaxY() { 
    551     double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    552  
    553     if (maxY !=0) return maxY; 
    554     else { 
    555       switch(yAxis) { 
    556         case 1: return (maxArea/pixelMicronSquared+0.05*areaRange); 
    557         case 0: return MAX_INTENSITY; 
    558         default: return (maxArea/pixelMicronSquared+0.05*areaRange); 
    559       } 
    560     } 
    561   } 
    562  
    563 /* 
    564   public static void oldupdateGraph() { 
    565     //1.55^2 from the pixels/micron value. 
    566     double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    567     try { 
    568       areaMap.setRange(minArea/pixelMicronSquared - 0.05*areaRange, 
    569         maxArea/pixelMicronSquared+0.05*areaRange); 
    570       data_ref.setData(newGetData(nSlices, true, intensity, fn)); 
    571       display.addReference(data_ref); 
    572     } 
    573     catch (VisADException e) { 
    574       IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
    575     } 
    576     catch (RemoteException re) { 
    577       IJ.log("Remote Exception: "+re.getMessage()); 
    578     } 
    579   } 
     76         
     77        private static final int MIN_INTENSITY = 0; 
     78        private static final int MAX_INTENSITY = 255; 
     79 
     80        private static ImageJ ij; 
     81        private static ImagePlus imp; 
     82        private static ImageStack stack; 
     83        private static ByteProcessor bp; 
     84        private static ColorModel theCM; 
     85        private static Detector d; 
     86         
     87        public static int nSlices; 
     88        private static int nParticles; 
     89        private static JFrame frame; 
     90        private static JCheckBox CBcumulative; 
     91        private static boolean cumulative; 
     92        private static Vector<Double> areaValues; 
     93        private static Vector<Double> intensityValues; 
     94        private static Vector<Double> diameterValues; 
     95        private static Vector<Integer> cellFrameV = new Vector<Integer>(); 
     96         
     97        private static Vector<Particle> particles; 
     98        private static Vector<Slice> slices; 
     99 
     100        //These are pointers to vectors containing actual values 
     101        //to axes as specified in WiscScan. 
     102        private static Vector<Double> XAxisValues; 
     103        private static Vector<Double> YAxisValues; 
     104        private static int xAxis, yAxis; 
     105 
     106        private static RealType area, intensity, diameter, xType, yType; 
     107        private static FunctionType fn; 
     108        private static DataReferenceImpl data_ref; 
     109        private static Scrollbar scroll; 
     110        private static DisplayImpl display; 
     111        private static ResultsTable rt; 
     112        private static double maxArea, minArea, maxIntensity, minIntensity; 
     113        private static ScalarMap xMap, yMap; 
     114         
     115        private static double pixelMicronSquared; 
     116         
     117        private static int resolutionWidth = 0; 
     118        private static int resolutionHeight = 0; 
     119        private static int minX=0, maxX=0, minY=0, maxY=0; 
     120        private static int intensityThreshold=30, areaThreshold=100; 
     121        private static boolean showParticles=false; 
     122         
     123        private static Vector<Integer> sliceBegin, sliceEnd; 
     124        // sliceBegin[i] is the minimum identifier of all particles on slice i 
     125        // sliceEnd[i] is the maximum identifier of all particles on slice i 
     126         
     127        // For XML metadata 
     128        private static String s_Name, s_Experiment, s_Params, s_Date; 
     129 
     130        public static void startImageJ() { 
     131                ij = new ImageJ(); 
     132                ij.getBounds(); 
     133        } 
     134         
     135        public static void incrementSlices() { 
     136                nSlices++; 
     137        } 
     138 
     139        public static void showImage(int width, int height, byte[] imageData) { 
     140                //bp = new ByteProcessor(width,height,imageData, ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
     141                bp = new ByteProcessor(width,height,imageData, theCM); 
     142                bp.createImage(); 
     143                stack.addSlice("Slice "+nSlices, bp); 
     144                imp.setStack("Islet images", stack); 
     145                imp.setSlice(nSlices); 
     146                imp.show(); 
     147        } 
     148 
     149        public static void init(int width, int height, double pixelsPerMicron) { 
     150                setResolution(width, height); 
     151                s_Date = new java.text.SimpleDateFormat("MM.dd.yyyy hh:mm:ss").format(new java.util.Date()); 
     152 
     153                byte[] r = new byte[256]; 
     154                byte[] g = new byte[256]; 
     155                byte[] b = new byte[256]; 
     156 
     157                for(int ii=0 ; ii<256 ; ii++) 
     158                r[ii] = g[ii] = b[ii] = (byte)ii; 
     159 
     160                theCM = new IndexColorModel(8, 256, r,g,b); 
     161                imp = new ImagePlus("Islet images", new ByteProcessor(resolutionWidth,resolutionHeight)); 
     162//              stack = new ImageStack(512, 512, ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
     163                stack = new ImageStack(resolutionWidth, resolutionHeight, theCM); 
     164                imp.show(); 
     165                 
     166                Detector.createImageHolder(resolutionWidth, resolutionHeight); 
     167                 
     168                imp.unlock(); 
     169                maxArea=Double.MIN_VALUE;  
     170                minArea=Double.MAX_VALUE;  
     171                maxIntensity = Double.MIN_VALUE; 
     172                minIntensity = Double.MAX_VALUE; 
     173                nSlices = 0; 
     174                nParticles = 0; 
     175                 
     176                pixelMicronSquared = pixelsPerMicron*pixelsPerMicron; 
     177                pixelMicronSquared = 0.149*0.149; 
     178                 
     179                particles = new Vector<Particle>(); 
     180                slices = new Vector<Slice>(); 
     181                 
     182                sliceBegin = new Vector<Integer>(); 
     183                sliceEnd = new Vector<Integer>(); 
     184                areaValues = new Vector<Double>(); 
     185                intensityValues = new Vector<Double>(); 
     186                diameterValues = new Vector<Double>(); 
     187                 
     188                XAxisValues = intensityValues; 
     189                YAxisValues = areaValues; 
     190 
     191                byte[] dummyData = new byte[resolutionWidth*resolutionHeight]; 
     192                bp = new ByteProcessor(resolutionWidth,resolutionHeight,dummyData, theCM); 
     193                bp.createImage(); 
     194                nSlices = 2; 
     195                stack.addSlice("Slice "+nSlices, bp); 
     196                newestProcessFrame(-1); // because newestProcessFrame indexes from non-blank slides 
     197                stack.addSlice("Slice "+nSlices, bp); 
     198                newestProcessFrame(0); 
     199                imp.setStack("Islet images", stack); 
     200 
     201                ImageWindow stackwin = ((ImageWindow) imp.getWindow()); 
     202                scroll = (Scrollbar) stackwin.getComponent(1); 
     203                 
     204                imp.setSlice(nSlices); 
     205                //intensityValues.add(0.0); 
     206                //areaValues.add(0.0); 
     207                //intensityValues.add(0.0); 
     208                //areaValues.add(0.0); 
     209 
     210                area = RealType.getRealType("Area"); 
     211                intensity = RealType.getRealType("Intensity"); 
     212                diameter = RealType.getRealType("Diameter"); 
     213 
     214                try {                    
     215                        // Display initialization 
     216                        //RealTupleType point = new RealTupleType(area, intensity); 
     217 
     218                         
     219                        display = new DisplayImplJ2D("Graph Display"); 
     220                        data_ref = new DataReferenceImpl("data_ref"); 
     221                        data_ref.setData(null); 
     222                        display.addReference(data_ref); 
     223                        display.getGraphicsModeControl().setScaleEnable(true); 
     224                        display.getGraphicsModeControl().setPointSize(3); 
     225                        setAxes(0,1); 
     226 
     227                        frame = new JFrame("Graph Window"); 
     228                        frame.setLayout(new BorderLayout()); 
     229 
     230                        CBcumulative = new JCheckBox("Cumulative"); 
     231                        CBcumulative.setMnemonic(KeyEvent.VK_G); 
     232                        JPanel bottomPanel = new JPanel(); 
     233                        bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS)); 
     234                        bottomPanel.add(CBcumulative); 
     235 
     236                        frame.getContentPane().add(display.getComponent(), BorderLayout.CENTER); 
     237                        frame.getContentPane().add(bottomPanel, BorderLayout.SOUTH); 
     238 
     239                        ItemListener CBitemListener = new ItemListener() { 
     240                                public void itemStateChanged(ItemEvent itemEvent) { 
     241                                        if (itemEvent.getStateChange() == ItemEvent.SELECTED) cumulative = true; 
     242                                        else cumulative = false; 
     243                                        try { 
     244                                                JVMLinkFlowCytometry.data_ref.setData(newestGetData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
     245                                                JVMLinkFlowCytometry.display.reDisplayAll(); 
     246                                        } catch (RemoteException e) {} catch (VisADException e) {} 
     247                                } 
     248                        }; 
     249                        CBcumulative.addItemListener(CBitemListener); 
     250 
     251                        AdjustmentListener l = new AdjustmentListener() { 
     252                                public void adjustmentValueChanged(AdjustmentEvent arg0) { 
     253                                        try { 
     254                                                int slideNum = ((Scrollbar) imp.getWindow().getComponent(1)).getValue(); 
     255                                                //for the detected particles window 
     256                                                if (showParticles) { 
     257                                                        d = new Detector(resolutionWidth, intensityThreshold, areaThreshold); 
     258                                                        d.findParticles(stack.getProcessor(slideNum)); 
     259                                                        d.crunchArray(); 
     260                                                        Detector.displayImage(d.getFloodArray()); 
     261                                                } 
     262 
     263                                                //for the graph 
     264                                                //IJ.log("This is slide "+slideNum+" and particle numbers on this slide go from "+sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
     265                                                //IJ.log(Integer.toString(((Scrollbar) Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
     266                                                JVMLinkFlowCytometry.data_ref.setData(newestGetData(slideNum, cumulative, intensity, fn)); 
     267                                                JVMLinkFlowCytometry.display.reDisplayAll(); 
     268                                                //Intensity_.this.data_ref.setData(getData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
     269                                        } catch (RemoteException e) {} catch (VisADException e) {} 
     270                                } 
     271                        }; 
     272                        scroll.addAdjustmentListener(l); 
     273 
     274                        imp.setSlice(1); 
     275                        frame.setSize(600, 600); 
     276                        frame.setVisible(true); 
     277                } catch (VisADException e) {IJ.log("VisAD Exception in init: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     278        } 
     279         
     280        public static void setAxes(int x, int y) { 
     281                // 0 - Intensity 
     282                // 1 - Area 
     283                // 2 - Diameter 
     284                xAxis = x; yAxis = y; 
     285                                 
     286                switch(xAxis) { 
     287                case 0: 
     288                        xType = intensity; 
     289                        XAxisValues = intensityValues; 
     290                        break; 
     291                case 1: 
     292                        xType = area; 
     293                        XAxisValues = areaValues; 
     294                        break; 
     295                case 2: 
     296                        xType = diameter; 
     297                        XAxisValues = diameterValues; 
     298                        break; 
     299                } 
     300                 
     301                switch(yAxis) { 
     302                case 0: 
     303                        yType = intensity; 
     304                        YAxisValues = intensityValues; 
     305                        break; 
     306                case 1: 
     307                        yType = area; 
     308                        YAxisValues = areaValues; 
     309                        break; 
     310                case 2: 
     311                        yType = diameter; 
     312                        YAxisValues = diameterValues; 
     313                        break; 
     314                } 
     315                try { 
     316                        xMap = new ScalarMap(xType, Display.XAxis); 
     317                        yMap = new ScalarMap(yType, Display.YAxis); 
     318                        xMap.setRange(getMinX(), getMaxX()); 
     319                        yMap.setRange(getMinY(), getMaxY()); 
     320 
     321                        fn = new FunctionType(xType, yType); 
     322                        display.clearMaps(); 
     323                        display.addMap(xMap); 
     324                        display.addMap(yMap); 
     325                         
     326                } catch (RemoteException e) { e.printStackTrace(); } 
     327                  catch (VisADException  e) { e.printStackTrace(); } 
     328        } 
     329 
     330        // Setters 
     331         
     332        public static void setResolution(int width, int height) { 
     333                resolutionWidth = width; 
     334                resolutionHeight = height; 
     335        } 
     336         
     337        public static void setXAxis(int option) { xAxis = option; } 
     338        public static void setYAxis(int option) { yAxis = option; } 
     339        public static void setName(String name) { s_Name = name; } 
     340        public static void setExperiment(String exp) { s_Experiment = exp; } 
     341        public static void setParams(String params) { s_Params = params; } 
     342        public static void setMinX(int val) { minX = val; } 
     343        public static void setMaxX(int val) { maxX = val; } 
     344        public static void setMinY(int val) { minY = val; } 
     345        public static void setMaxY(int val) { maxY = val; } 
     346        public static void setIntensityThreshold(int val) { intensityThreshold = val; } 
     347        public static void setAreaThreshold(int val) { areaThreshold = val; } 
     348        public static void setPixelMicronSquared(double val) { pixelMicronSquared = val; } 
     349        public static void reprocessAll() { 
     350                particles = new Vector<Particle>(); 
     351                slices = new Vector<Slice>(); 
     352                nParticles = 0; 
     353                nSlices = 0; 
     354                for (int i=0; i<stack.getSize(); i++) { 
     355                        incrementSlices(); 
     356                        newestProcessFrame(i+1); 
     357                } 
     358                updateGraph();           
     359        } 
     360         
     361        public static void saveDataWithXML() throws FormatException, IOException { 
     362                ImageWriter iw = new ImageWriter(); 
     363                MetadataStore metadataStore = MetadataTools.createOMEXMLMetadata(); 
     364                metadataStore.createRoot(); 
     365                 
     366                metadataStore.setPixelsSizeX(new Integer(resolutionWidth), 0, 0); 
     367                metadataStore.setPixelsSizeY(new Integer(resolutionHeight), 0, 0); 
     368                metadataStore.setPixelsSizeZ(new Integer(1), 0, 0); 
     369                metadataStore.setPixelsSizeC(new Integer(1), 0, 0); 
     370                metadataStore.setPixelsSizeT(new Integer(stack.getSize()), 0, 0); 
     371                metadataStore.setPixelsPixelType("Uint8", 0, 0); 
     372                metadataStore.setPixelsBigEndian(new Boolean(false), 0, 0); 
     373                metadataStore.setPixelsDimensionOrder("XYTZC", 0, 0); 
     374                metadataStore.setExperimenterFirstName(s_Name, 0); 
     375 
     376                 
     377                MetadataRetrieve metadataObject = (MetadataRetrieve) metadataStore; 
     378                iw.setMetadataRetrieve(metadataObject); 
     379                MetadataTools.populateOriginalMetadata(metadataObject, "Experiment", s_Experiment); 
     380                MetadataTools.populateOriginalMetadata(metadataObject, "Parameters", s_Params); 
     381                MetadataTools.populateOriginalMetadata(metadataObject, "Date", s_Date); 
     382                MetadataTools.populateOriginalMetadata(metadataObject, "AreaValues", flattenVector(areaValues)); 
     383                MetadataTools.populateOriginalMetadata(metadataObject, "IntensityValues", flattenVector(intensityValues)); 
     384 
     385                // setImageCreationDate, setImageName on MetadataStore 
     386                iw.setId("testImage.ome.tiff"); 
     387                 
     388                System.out.println(stack.getSize()); 
     389                for (int i=1; i<=stack.getSize(); i++) { 
     390                        byte[] byteArray = (byte[]) stack.getProcessor(i).getPixels(); 
     391                        iw.saveBytes(byteArray, i==stack.getSize()); 
     392                } 
     393                iw.close(); 
     394        } 
     395 
     396        public static void newestProcessFrame() { 
     397                newestProcessFrame(nSlices-2); 
     398        } 
     399         
     400        public static void newestProcessFrame(int sliceNum) { 
     401                sliceNum = sliceNum+2; 
     402                imp.unlock(); 
     403                d = new Detector(resolutionWidth, intensityThreshold, areaThreshold); 
     404                d.findParticles(stack.getProcessor(sliceNum)); 
     405                Vector<Particle> thisParticles = d.crunchArray(); 
     406                if (showParticles) { 
     407                        System.out.println("processFrame for slice "+sliceNum); 
     408                        Detector.displayImage(d.getFloodArray()); 
     409                } 
     410                Slice thisSlice = new Slice(nSlices); 
     411                if (thisParticles.size() > 0) { 
     412                        thisSlice.hasParticles = true; 
     413                        thisSlice.begin = nParticles; 
     414                        thisSlice.end = nParticles+thisParticles.size()-1; 
     415                } 
     416                 
     417                for (int i=0; i<thisParticles.size(); i++) { 
     418                        Particle thisParticle = thisParticles.get(i); 
     419                        thisParticle.setNum(nParticles++); 
     420                        thisParticle.setSliceNum(nSlices); 
     421                        particles.add(thisParticle); 
     422                        //thisParticle.print(); 
     423                         
     424                        int thisArea = thisParticle.getArea(); 
     425                        int thisIntensity = thisParticle.getIntensity(); 
     426                        if (thisArea > maxArea) maxArea = thisArea; 
     427                        if (thisArea < minArea) minArea = thisArea; 
     428                        if (thisIntensity > maxIntensity) maxIntensity = thisIntensity; 
     429                        if (thisIntensity < minIntensity) minIntensity = thisIntensity; 
     430                } 
     431                 
     432                slices.add(thisSlice); 
     433        } 
     434         
     435        public static void newProcessFrame() { 
     436                imp.unlock(); 
     437                ImageProcessor ip = stack.getProcessor(imp.getCurrentSlice()); 
     438                double totalArea=0, totalIntensity=0; 
     439                for (int i=0; i<resolutionWidth; i++) { 
     440                        for (int j=0; j<resolutionHeight; j++) { 
     441                                int value = ip.getPixel(i, j); 
     442                                if (value >= intensityThreshold) { 
     443                                        totalArea++; 
     444                                        totalIntensity += value; 
     445                                } 
     446                        } 
     447                } 
     448                IJ.log("Area: "+totalArea); 
     449                IJ.log("Intensity: "+totalIntensity); 
     450                if (totalArea > maxArea) maxArea = totalArea; 
     451                if (totalArea < minArea) minArea = totalArea; 
     452                if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
     453                if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
     454                areaValues.add(totalArea); 
     455                if (totalArea != 0) intensityValues.add(totalIntensity/totalArea); 
     456                else intensityValues.add(0.0); 
     457                System.out.println("just added to vectors: "+totalArea+ " "+totalIntensity/totalArea); 
     458        } 
     459         
     460        public static void processFrame() { 
     461                incrementSlices(); 
     462                imp.unlock(); 
     463                bp.setThreshold(25, 255, 1); 
     464                IJ.run("Analyze Particles...", "size=0-Infinity circularity=0.00-1.00 show=Nothing display clear"); 
     465                rt = Analyzer.getResultsTable(); 
     466                double totalArea=0, totalIntensity=0; 
     467                for (int j=0; j<rt.getCounter(); j++) { 
     468                        double area = rt.getValue("Area", j); 
     469                        totalArea += area; 
     470                        totalIntensity += (rt.getValue("Mean", j))*area; 
     471                } 
     472                if (totalArea > maxArea) maxArea = totalArea; 
     473                if (totalArea < minArea) minArea = totalArea; 
     474                if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
     475                if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
     476                areaValues.add(totalArea); 
     477                intensityValues.add(totalIntensity); 
     478                cellFrameV.add(nSlices);  
     479                 
     480                sliceBegin.ensureCapacity(2*nSlices); 
     481                sliceEnd.ensureCapacity(2*nSlices); 
     482                sliceBegin.add(nSlices); 
     483                sliceEnd.add(nSlices); 
     484                System.out.println("############: sliceBegin looks like "); 
     485                for (int i=0; i<sliceBegin.size(); i++) System.out.println(sliceBegin.get(i)); 
     486        } 
     487         
     488        private static double getMinX() { 
     489                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     490                 
     491                if (minX !=0) return minX; 
     492                else { 
     493                        switch(xAxis) { 
     494                                case 1: return (minArea/pixelMicronSquared - 0.05*areaRange); 
     495                                case 0: return MIN_INTENSITY;  
     496                                default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
     497                        } 
     498                } 
     499        } 
     500         
     501        private static double getMaxX() { 
     502                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     503 
     504                if (maxX !=0) return maxX; 
     505                else { 
     506                        switch(xAxis) { 
     507                                case 1: return (maxArea/pixelMicronSquared+0.05*areaRange); 
     508                                case 0: return MAX_INTENSITY; 
     509                                default: return (maxArea/pixelMicronSquared+0.05*areaRange); 
     510                        } 
     511                } 
     512        } 
     513 
     514        private static double getMinY() { 
     515                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     516                 
     517                if (minY !=0) return minY; 
     518                else { 
     519                        switch(yAxis) { 
     520                                case 1: return (minArea/pixelMicronSquared - 0.05*areaRange); 
     521                                case 0: return MIN_INTENSITY;  
     522                                default: return (minArea/pixelMicronSquared - 0.05*areaRange); 
     523                        } 
     524                } 
     525        } 
     526         
     527        private static double getMaxY() { 
     528                double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     529 
     530                if (maxY !=0) return maxY; 
     531                else { 
     532                        switch(yAxis) { 
     533                                case 1: return (maxArea/pixelMicronSquared+0.05*areaRange); 
     534                                case 0: return MAX_INTENSITY; 
     535                                default: return (maxArea/pixelMicronSquared+0.05*areaRange); 
     536                        } 
     537                } 
     538        } 
     539 
     540/*      public static void oldupdateGraph() { 
     541                double areaRange = (maxArea - minArea)/pixelMicronSquared; //1.55^2 from the pixels/micron value. 
     542                try { 
     543                        areaMap.setRange(minArea/pixelMicronSquared - 0.05*areaRange, maxArea/pixelMicronSquared+0.05*areaRange); 
     544                        data_ref.setData(newGetData(nSlices, true, intensity, fn)); 
     545                        display.addReference(data_ref); 
     546                } catch (VisADException e) {IJ.log("VisAD Exception in updateGraph: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     547        } 
    580548*/ 
    581  
    582   public static void updateGraph() { 
    583     try { 
    584       xMap.setRange(getMinX(), getMaxX()); 
    585       yMap.setRange(getMinY(), getMaxY()); 
    586       data_ref.setData(newestGetData(nSlices, true, xType, fn)); 
    587       display.addReference(data_ref); 
    588     } 
    589     catch (VisADException e) { 
    590       IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
    591     } 
    592     catch (RemoteException re) { 
    593       IJ.log("Remote Exception: "+re.getMessage()); 
    594     } 
    595   } 
    596  
    597   public static FlatField newestGetData(int slice, 
    598     boolean cumulative, RealType x, FunctionType fn) 
    599   { 
    600     //slice is NOT zero-indexed. 
    601     double[] xArray, yArray; 
    602     int beginSlice=0, endSlice=slice-1; 
    603     if (!cumulative) beginSlice = slice-1; 
    604     int beginIndex = Integer.MAX_VALUE, 
    605       endIndex = Integer.MIN_VALUE, numParticles=0; 
    606     for (int i=beginSlice; i<=endSlice; i++) { 
    607       if (slices.get(i).hasParticles) { 
    608         if (slices.get(i).begin < beginIndex) beginIndex = slices.get(i).begin; 
    609         if (slices.get(i).end > endIndex) endIndex = slices.get(i).end; 
    610         numParticles += (slices.get(i).end - slices.get(i).begin + 1); 
    611       } 
    612     } 
    613  
    614     //System.out.println("beginIndex:"+beginIndex+ 
    615     //  " endIndex:"+endIndex+" numParticles:"+numParticles); 
    616  
    617     if (numParticles == 0) return null; 
    618  
    619     xArray = new double[numParticles]; 
    620     yArray = new double[numParticles]; 
    621  
    622     for (int i=beginIndex; i<=endIndex; i++) { 
    623       switch(xAxis) { 
    624         case 0: 
    625           xArray[i-beginIndex] = 
    626             particles.get(i).totalIntensity / particles.get(i).area; 
    627           break; 
    628         case 1: 
    629           xArray[i-beginIndex] = particles.get(i).area/pixelMicronSquared; 
    630           break; 
    631       } 
    632       switch(yAxis) { 
    633         case 0: 
    634           yArray[i-beginIndex] = 
    635             particles.get(i).totalIntensity / particles.get(i).area; 
    636           break; 
    637         case 1: 
    638           yArray[i-beginIndex] = particles.get(i).area/pixelMicronSquared; 
    639           break; 
    640       } 
    641     } 
    642     //for (int i=beginIndex; i<=endIndex; i++) { 
    643     //  System.out.println("Now plotting "+ 
    644     //    Double.toString(xArray[i-beginIndex]) + " " + 
    645     //    Double.toString(yArray[i-beginIndex])); 
    646     //} 
    647  
    648     List1DDoubleSet xSet; 
    649     FlatField ff=null; 
    650     if (endIndex >= beginIndex) try { 
    651       xSet = new List1DDoubleSet(xArray, x, null, null); 
    652       ff = new FlatField(fn, xSet); 
    653       double[][] ff_vals = new double[1][xArray.length]; 
    654       ff_vals[0] = yArray; 
    655       ff.setSamples(ff_vals); 
    656     } 
    657     catch (VisADException e) { 
    658       IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
    659     } 
    660     catch (RemoteException re) { 
    661       IJ.log("Remote Exception: "+re.getMessage()); 
    662     } 
    663     return ff; 
    664   } 
    665  
    666   public static FlatField newGetData(int slice, 
    667     boolean cumulative, RealType x, FunctionType fn) 
    668   { 
    669     //slice is NOT zero-indexed. 
    670     double[] xArray, yArray; 
    671     int beginIndex=0, endIndex; 
    672     if (!cumulative) beginIndex = slice-1; 
    673     endIndex = slice-1; 
    674     xArray = new double[endIndex - beginIndex + 1]; 
    675     yArray = new double[endIndex - beginIndex + 1]; 
    676     for (int i=beginIndex; i<=endIndex; i++) { 
    677       //intensityValues.get(i); 
    678       xArray[i-beginIndex] = XAxisValues.get(i); 
    679  
    680       //areaValues.get(i)/pixelMicronSquared; 
    681       yArray[i-beginIndex] = YAxisValues.get(i); 
    682     } 
    683     System.out.println("Plotting for slices between indices "+ 
    684       beginIndex+ " and "+endIndex); 
    685     //printVector(XAxisValues); 
    686     //System.out.println("--"); 
    687     //printVector(YAxisValues); 
    688     for (int i=beginIndex; i<=endIndex; i++) { 
    689       IJ.log("Now plotting "+Double.toString(xArray[i-beginIndex]) + 
    690         " " + Double.toString(yArray[i-beginIndex])); 
    691     } 
    692     List1DDoubleSet xSet; 
    693     FlatField ff=null; 
    694     if (endIndex >= beginIndex) try { 
    695       xSet = new List1DDoubleSet(xArray, x, null, null); 
    696       ff = new FlatField(fn, xSet); 
    697       double[][] ff_vals = new double[1][xArray.length]; 
    698       ff_vals[0] = yArray; 
    699       ff.setSamples(ff_vals); 
    700     } 
    701     catch (VisADException e) { 
    702       IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
    703     } 
    704     catch (RemoteException re) { 
    705       IJ.log("Remote Exception: "+re.getMessage()); 
    706     } 
    707     return ff; 
    708   } 
    709  
    710   public static FlatField getData(int slice, 
    711     boolean cumulative, RealType x, FunctionType fn) 
    712   { 
    713     double[] xArray, yArray; 
    714     int beginIndex=0, endIndex; 
    715     if (!cumulative) beginIndex = sliceBegin.get(slice); 
    716     endIndex = sliceEnd.get(slice); 
    717     xArray = new double[endIndex - beginIndex + 1]; 
    718     yArray = new double[endIndex - beginIndex + 1]; 
    719     IJ.log("In getData, begin and end indices are "+ 
    720       beginIndex+ " and "+endIndex); 
    721     for (int i=beginIndex; i<=endIndex; i++) { 
    722       //IJ.log("Assigning values in the x and y arrays"); 
    723       xArray[i-beginIndex] = intensityValues.elementAt(i); 
    724       yArray[i-beginIndex] = areaValues.elementAt(i); 
    725     } 
    726     IJ.log("Done assigning"); 
    727     for (int i=beginIndex; i<=endIndex; i++) { 
    728       IJ.log(Double.toString(xArray[i-beginIndex]) + " " + 
    729         Double.toString(yArray[i-beginIndex])); 
    730     } 
    731     List1DDoubleSet intensitySet; 
    732     FlatField ff=null; 
    733     if (endIndex >= beginIndex) try { 
    734       intensitySet = new List1DDoubleSet(xArray, x, null, null); 
    735       ff = new FlatField(fn, intensitySet); 
    736       double[][] ff_vals = new double[1][xArray.length]; 
    737       ff_vals[0] = yArray; 
    738       ff.setSamples(ff_vals); 
    739     } 
    740     catch (VisADException e) { 
    741       IJ.log("VisAD Exception: "+e.getMessage()); 
    742     } 
    743     catch (RemoteException re) { 
    744       IJ.log("Remote Exception: "+re.getMessage()); 
    745     } 
    746     return ff; 
    747   } 
    748  
    749   public static void saveValues() throws IOException { 
    750     BufferedWriter bw = new BufferedWriter( 
    751       new FileWriter("values"+s_Date.substring(0,9))); 
    752     bw.write("Area values: "); bw.newLine(); 
    753     for (int i=0; i<areaValues.size(); i++) { 
    754       bw.write(Double.toString(areaValues.get(i))); bw.newLine(); 
    755     } 
    756     bw.write("Intensity values: "); bw.newLine(); 
    757     for (int i=0; i<intensityValues.size(); i++) { 
    758       bw.write(Double.toString(intensityValues.get(i))); bw.newLine(); 
    759     } 
    760   } 
    761  
    762   public static void showParticles(boolean val) { 
    763     showParticles = val; 
    764     if (val) Detector.impParticles.show(); 
    765     else Detector.impParticles.hide(); 
    766   } 
    767  
    768   public static void printVector(Vector<Double> v) { 
    769     for (int i=0; i<v.size(); i++) { 
    770       double dtemp = v.get(i); 
    771       System.out.println(dtemp); 
    772     } 
    773   } 
    774  
    775   private static String flattenVector(Vector<Double> v) { 
    776     String retval = ""; 
    777     for (int i=0; i<v.size(); i++) { 
    778       retval += v.get(i)+"\n"; 
    779     } 
    780     return retval; 
    781   } 
    782  
    783   // -- Helper classes -- 
    784  
    785   private static class Slice { 
    786     int num; 
    787     boolean hasParticles; 
    788     int begin; 
    789     int end; 
    790  
    791     public Slice(int n) { 
    792       num = n; 
    793       hasParticles = false; 
    794     } 
    795  
    796     public void print() { 
    797       if (hasParticles) { 
    798         System.out.println("Slice "+num+" begins with particle "+ 
    799           begin+" and ends at "+end); 
    800       } 
    801       else System.out.println("Slice "+num+" has no particles"); 
    802     } 
    803   } 
    804  
     549        public static void updateGraph() { 
     550                try { 
     551                        xMap.setRange(getMinX(), getMaxX()); 
     552                        yMap.setRange(getMinY(), getMaxY()); 
     553                        data_ref.setData(newestGetData(nSlices, true, xType, fn)); 
     554                        display.addReference(data_ref); 
     555                } catch (VisADException e) {IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); } catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     556        } 
     557 
     558        public static FlatField newestGetData(int slice, boolean cumulative, RealType x, FunctionType fn) { 
     559                //slice is NOT zero-indexed. 
     560                double[] xArray, yArray; 
     561                int beginSlice=0, endSlice=slice-1; 
     562                if (!cumulative) beginSlice = slice-1; 
     563                int beginIndex = Integer.MAX_VALUE, endIndex = Integer.MIN_VALUE, numParticles=0; 
     564                for (int i=beginSlice; i<=endSlice; i++) { 
     565                        if (slices.get(i).hasParticles) { 
     566                                if (slices.get(i).begin < beginIndex) beginIndex = slices.get(i).begin; 
     567                                if (slices.get(i).end > endIndex) endIndex = slices.get(i).end; 
     568                                numParticles += (slices.get(i).end - slices.get(i).begin + 1); 
     569                        } 
     570                } 
     571                 
     572                //System.out.println("beginIndex:"+beginIndex+" endIndex:"+endIndex+" numParticles:"+numParticles); 
     573                 
     574                if (numParticles == 0) return null; 
     575 
     576                xArray = new double[numParticles]; 
     577                yArray = new double[numParticles]; 
     578                 
     579 
     580                for (int i=beginIndex; i<=endIndex; i++) { 
     581                        switch(xAxis) { 
     582                                case 0: xArray[i-beginIndex] = particles.get(i).totalIntensity/particles.get(i).area; break; 
     583                                case 1: xArray[i-beginIndex] = particles.get(i).area/pixelMicronSquared; break; 
     584                        } 
     585                        switch(yAxis) { 
     586                                case 0: yArray[i-beginIndex] = particles.get(i).totalIntensity/particles.get(i).area; break; 
     587                                case 1: yArray[i-beginIndex] = particles.get(i).area/pixelMicronSquared; break; 
     588                        } 
     589                } 
     590                //for (int i=beginIndex; i<=endIndex; i++) System.out.println("Now plotting "+Double.toString(xArray[i-beginIndex]) + " " + Double.toString(yArray[i-beginIndex])); 
     591                 
     592                List1DDoubleSet xSet; 
     593                FlatField ff=null; 
     594                if (endIndex >= beginIndex) try { 
     595                        xSet = new List1DDoubleSet(xArray, x, null, null); 
     596                        ff = new FlatField(fn, xSet); 
     597                        double[][] ff_vals = new double[1][xArray.length]; 
     598                        ff_vals[0] = yArray; 
     599                        ff.setSamples(ff_vals); 
     600                } catch (VisADException e) {IJ.log("VisAD Exception in newGetData: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     601                return ff; 
     602        } 
     603         
     604        public static FlatField newGetData(int slice, boolean cumulative, RealType x, FunctionType fn) { 
     605                //slice is NOT zero-indexed. 
     606                double[] xArray, yArray; 
     607                int beginIndex=0, endIndex; 
     608                if (!cumulative) beginIndex = slice-1; 
     609                endIndex = slice-1; 
     610                xArray = new double[endIndex - beginIndex + 1]; 
     611                yArray = new double[endIndex - beginIndex + 1]; 
     612                for (int i=beginIndex; i<=endIndex; i++) { 
     613                        xArray[i-beginIndex] = XAxisValues.get(i);//intensityValues.get(i); 
     614                        yArray[i-beginIndex] = YAxisValues.get(i);//areaValues.get(i)/pixelMicronSquared; 
     615                } 
     616                System.out.println("Plotting for slices between indices "+beginIndex+ " and "+endIndex); 
     617                //printVector(XAxisValues); System.out.println("--"); printVector(YAxisValues); 
     618                for (int i=beginIndex; i<=endIndex; i++) IJ.log("Now plotting "+Double.toString(xArray[i-beginIndex]) + " " + Double.toString(yArray[i-beginIndex])); 
     619                List1DDoubleSet xSet; 
     620                FlatField ff=null; 
     621                if (endIndex >= beginIndex) try { 
     622                        xSet = new List1DDoubleSet(xArray, x, null, null); 
     623                        ff = new FlatField(fn, xSet); 
     624                        double[][] ff_vals = new double[1][xArray.length]; 
     625                        ff_vals[0] = yArray; 
     626                        ff.setSamples(ff_vals); 
     627                } catch (VisADException e) {IJ.log("VisAD Exception in newGetData: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     628                return ff; 
     629        } 
     630 
     631        public static FlatField getData(int slice, boolean cumulative, RealType x, FunctionType fn) { 
     632                double[] xArray, yArray; 
     633                int beginIndex=0, endIndex; 
     634                if (!cumulative) beginIndex = sliceBegin.get(slice); 
     635                endIndex = sliceEnd.get(slice); 
     636                xArray = new double[endIndex - beginIndex + 1]; 
     637                yArray = new double[endIndex - beginIndex + 1]; 
     638                IJ.log("In getData, begin and end indices are "+beginIndex+ " and "+endIndex); 
     639                for (int i=beginIndex; i<=endIndex; i++) { 
     640                        //IJ.log("Assigning values in the x and y arrays"); 
     641                        xArray[i-beginIndex] = intensityValues.elementAt(i); 
     642                        yArray[i-beginIndex] = areaValues.elementAt(i); 
     643                } 
     644                IJ.log("Done assigning"); 
     645                for (int i=beginIndex; i<=endIndex; i++) IJ.log(Double.toString(xArray[i-beginIndex]) + " " + Double.toString(yArray[i-beginIndex])); 
     646                List1DDoubleSet intensitySet; 
     647                FlatField ff=null; 
     648                if (endIndex >= beginIndex) try { 
     649                        intensitySet = new List1DDoubleSet(xArray, x, null, null); 
     650                        ff = new FlatField(fn, intensitySet); 
     651                        double[][] ff_vals = new double[1][xArray.length]; 
     652                        ff_vals[0] = yArray; 
     653                        ff.setSamples(ff_vals); 
     654                } catch (VisADException e) {IJ.log("VisAD Exception: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     655                return ff; 
     656        } 
     657 
     658         
     659        public static void saveValues() throws IOException { 
     660                BufferedWriter bw = new BufferedWriter(new FileWriter("values"+s_Date.substring(0,9))); 
     661                bw.write("Area values: "); bw.newLine(); 
     662                for (int i=0; i<areaValues.size(); i++) { 
     663                        bw.write(Double.toString(areaValues.get(i))); bw.newLine(); 
     664                } 
     665                bw.write("Intensity values: "); bw.newLine(); 
     666                for (int i=0; i<intensityValues.size(); i++) { 
     667                        bw.write(Double.toString(intensityValues.get(i))); bw.newLine(); 
     668                } 
     669        } 
     670         
     671        public static void showParticles(boolean val) { 
     672                showParticles = val; 
     673                if (val) Detector.impParticles.show(); 
     674                else Detector.impParticles.hide(); 
     675        } 
     676         
     677        public static void processFile(String filename) throws IOException { 
     678                ImagePlus imp = IJ.openImage(filename); 
     679                ImageStack stack = imp.getStack(); 
     680                int size = imp.getWidth(); 
     681                 
     682                init(size, size, 1); 
     683                showParticles(true); 
     684                for (int i=1; i<=stack.getSize(); i++) { 
     685                        byte[] imageData = (byte[]) stack.getPixels(i); 
     686                        incrementSlices(); 
     687                        showImage(size, size, imageData); 
     688                        newestProcessFrame(i); 
     689                        updateGraph(); 
     690                } 
     691                 
     692                BufferedWriter bw = new BufferedWriter(new FileWriter(filename+".values")); 
     693                bw.write("Area\t\tIntensity"); bw.newLine(); bw.newLine(); 
     694                System.out.println("Particles size is "+particles.size()); 
     695                for (int i=0; i<particles.size(); i++) { 
     696                        bw.write(particles.get(i).getArea()+"\t\t"+particles.get(i).getMeanIntensity()); bw.newLine(); 
     697                } 
     698                bw.flush(); 
     699                bw.close(); 
     700        } 
     701 
     702        public static void printVector(Vector<Double> v) { 
     703                for (int i=0; i<v.size(); i++) { 
     704                        double dtemp = v.get(i); 
     705                        System.out.println(dtemp); 
     706                } 
     707        } 
     708         
     709        private static String flattenVector(Vector<Double> v) { 
     710                String retval = ""; 
     711                for (int i=0; i<v.size(); i++) { 
     712                        retval += v.get(i)+"\n"; 
     713                } 
     714                return retval; 
     715        }        
    805716} 
    806  
    807 /* Old try catch block 
    808 try { 
    809 // Display initialization 
    810 area = RealType.getRealType("Area"); 
    811 intensity = RealType.getRealType("Intensity"); 
    812 diameter = RealType.getRealType("Diameter"); 
    813 //RealTupleType point = new RealTupleType(area, intensity); 
    814 areaMap = new ScalarMap(area, Display.YAxis); 
    815 intensityMap = new ScalarMap(intensity, Display.XAxis); 
    816 intensityMap.setRange(0,255); 
    817  
    818 fn = new FunctionType(intensity, area); 
    819 display = new DisplayImplJ2D("Graph Display"); 
    820 display.addMap(intensityMap); 
    821 display.addMap(areaMap); 
    822 data_ref = new DataReferenceImpl("data_ref"); 
    823 data_ref.setData(null); 
    824 display.addReference(data_ref); 
    825 display.getGraphicsModeControl().setScaleEnable(true); 
    826 display.getGraphicsModeControl().setPointSize(3); 
    827 frame = new JFrame("Graph Window"); 
    828 frame.setLayout(new BorderLayout()); 
    829  
    830 CBcumulative = new JCheckBox("Cumulative"); 
    831 CBcumulative.setMnemonic(KeyEvent.VK_G); 
    832 JPanel bottomPanel = new JPanel(); 
    833 bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS)); 
    834 bottomPanel.add(CBcumulative); 
    835  
    836 frame.getContentPane().add(display.getComponent(), BorderLayout.CENTER); 
    837 frame.getContentPane().add(bottomPanel, BorderLayout.SOUTH); 
    838  
    839 ItemListener CBitemListener = new ItemListener() { 
    840   public void itemStateChanged(ItemEvent itemEvent) { 
    841     if (itemEvent.getStateChange() == ItemEvent.SELECTED) cumulative = true; 
    842     else cumulative = false; 
    843     try { 
    844       JVMLinkFlowCytometry.data_ref.setData(newGetData(imp.getCurrentSlice(), 
    845         cumulative, intensity, fn)); 
    846       JVMLinkFlowCytometry.display.reDisplayAll(); 
    847     } 
    848     catch (RemoteException e) { } 
    849     catch (VisADException e) { } 
    850   } 
    851 }; 
    852 CBcumulative.addItemListener(CBitemListener); 
    853  
    854 AdjustmentListener l = new AdjustmentListener() { 
    855   public void adjustmentValueChanged(AdjustmentEvent arg0) { 
    856     try { 
    857       int slideNum = ((Scrollbar) imp.getWindow().getComponent(1)).getValue(); 
    858       //IJ.log("This is slide "+slideNum+" and particle numbers on this " + 
    859       //  "slide go from "+sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
    860       //IJ.log(Integer.toString(((Scrollbar) 
    861       //  Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
    862       JVMLinkFlowCytometry.data_ref.setData(newGetData(slideNum, 
    863         cumulative, intensity, fn)); 
    864       JVMLinkFlowCytometry.display.reDisplayAll(); 
    865       //Intensity_.this.data_ref.setData(getData(imp.getCurrentSlice(), 
    866       //  cumulative, intensity, fn)); 
    867     } 
    868     catch (RemoteException e) { } 
    869     catch (VisADException e) { } 
    870   } 
    871 }; 
    872 scroll.addAdjustmentListener(l); 
    873  
    874 imp.setSlice(1); 
    875 frame.setSize(600, 600); 
    876 frame.setVisible(true); 
    877 } 
    878 catch (VisADException e) {IJ.log("VisAD Exception in init: "+e.getMessage());} 
    879 catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
    880 */ 
  • trunk/loci/apps/flow/JVMLinkXML.java

    r4125 r4169  
    1 // 
    2 // JVMLinkXML.java 
    3 // 
    4  
    5 /* 
    6 Server application for flow cytometry with WiscScan using JVMLink. 
    7 Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
    8  
    9 Redistribution and use in source and binary forms, with or without 
    10 modification, are permitted provided that the following conditions are met: 
    11   * Redistributions of source code must retain the above copyright 
    12     notice, this list of conditions and the following disclaimer. 
    13   * Redistributions in binary form must reproduce the above copyright 
    14     notice, this list of conditions and the following disclaimer in the 
    15     documentation and/or other materials provided with the distribution. 
    16   * Neither the name of the UW-Madison LOCI nor the names of its 
    17     contributors may be used to endorse or promote products derived from 
    18     this software without specific prior written permission. 
    19  
    20 THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
    21 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    22 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
    23 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    24 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
    25 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    26 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
    27 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    30 */ 
    31  
    32 package loci.apps.flow; 
    33  
    341import loci.formats.*; 
     2import loci.formats.meta.MetadataRetrieve; 
    353import loci.formats.meta.MetadataStore; 
    364 
    37 /** 
    38  * <dl><dt><b>Source code:</b></dt> 
    39  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/apps/flow/JVMLinkXML.java">Trac</a>, 
    40  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/apps/flow/JVMLinkXML.java">SVN</a></dd></dl> 
    41  */ 
    425public class JVMLinkXML { 
     6         
     7        public static MetadataStore metadataStore; 
     8         
     9         
     10        public static void createOMEXMLMetadata() { 
     11                metadataStore = MetadataTools.createOMEXMLMetadata(); 
     12                metadataStore.createRoot(); 
     13        } 
     14         
     15        public static void setDatasetRefID(String id) { 
     16                // Not sure what goes here. 
     17        } 
     18         
     19        public static void setDatasetName(String id) { 
     20                // Not sure what function to call here. 
     21        } 
     22         
     23        public static void setDatasetExperimenter(String id) { 
     24                // Not sure what function to call here. 
     25        } 
    4326 
    44   public static MetadataStore metadataStore; 
     27        public static void setDatasetGroup(String id) { 
     28                // Not sure what function to call here. 
     29        } 
    4530 
    46   public static void createOMEXMLMetadata() { 
    47     metadataStore = MetadataTools.createOMEXMLMetadata(); 
    48     metadataStore.createRoot(); 
    49   } 
     31        public static void setDatasetLocked(String id) { 
     32                // Not sure what function to call here. 
     33        } 
     34 
     35        public static void setProjectID(String id) { 
     36                // Not sure what function to call here. 
     37        } 
     38 
     39        public static void setProjectName(String id) { 
     40                // Not sure what function to call here. 
     41        } 
     42 
     43        public static void setProjectDescription(String id) { 
     44                // Not sure what function to call here. 
     45        } 
     46 
     47        public static void setProjectExperimenter(String id) { 
     48                // Not sure what function to call here. 
     49        } 
     50 
     51        public static void setProjectGroup(String id) { 
     52                // Not sure what function to call here. 
     53        } 
     54 
     55        public static void setImageID(String id) { 
     56                // Not sure what function to call here. 
     57        } 
     58         
     59        public static void setImageName(String id) { 
     60                // Not sure what function to call here. 
     61        } 
     62 
     63        public static void setImageCreationDate(String id) { 
     64                // Not sure what function to call here. 
     65        } 
     66 
     67        public static void setImageDescription(String id) { 
     68                // Not sure what function to call here. 
     69        } 
     70 
     71        public static void setImageExperimenter(String id) { 
     72                // Not sure what function to call here. 
     73        } 
     74 
     75        public static void setImageDefaultPixels(String id) { 
     76                // Not sure what function to call here. 
     77        } 
     78 
     79        public static void setAttributeKeyPair(String key, String value) { 
     80                MetadataTools.populateOriginalMetadata(metadataStore, key, value); 
     81        } 
     82 
    5083 
    5184} 
  • trunk/loci/apps/flow/Particle.java

    r4125 r4169  
    1 // 
    2 // Particle.java 
    3 // 
    41 
    5 /* 
    6 Server application for flow cytometry with WiscScan using JVMLink. 
    7 Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     2public class Particle { 
     3                int area; 
     4                int num; 
     5                int totalIntensity; 
     6                int sliceNum; 
     7                 
     8        public Particle(int a, int i) { 
     9                area = a; 
     10                totalIntensity = i; 
     11        } 
     12         
     13        public void print() { 
     14                System.out.println("Particle "+num+" on slice "+sliceNum+" with area "+area+" and total intensity "+totalIntensity); 
     15        } 
    816 
    9 Redistribution and use in source and binary forms, with or without 
    10 modification, are permitted provided that the following conditions are met: 
    11   * Redistributions of source code must retain the above copyright 
    12     notice, this list of conditions and the following disclaimer. 
    13   * Redistributions in binary form must reproduce the above copyright 
    14     notice, this list of conditions and the following disclaimer in the 
    15     documentation and/or other materials provided with the distribution. 
    16   * Neither the name of the UW-Madison LOCI nor the names of its 
    17     contributors may be used to endorse or promote products derived from 
    18     this software without specific prior written permission. 
     17        public int getNum() { 
     18                return num; 
     19        } 
    1920 
    20 THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
    21 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
    22 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
    23 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    24 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
    25 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
    26 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
    27 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
    28 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    30 */ 
     21        public void setNum(int num) { 
     22                this.num = num; 
     23        } 
    3124 
    32 package loci.apps.flow; 
     25        public int getSliceNum() { 
     26                return sliceNum; 
     27        } 
    3328 
    34 /** 
    35  * <dl><dt><b>Source code:</b></dt> 
    36  * <dd><a href="https://skyking.microscopy.wisc.edu/trac/java/browser/trunk/loci/apps/flow/Particle.java">Trac</a>, 
    37  * <a href="https://skyking.microscopy.wisc.edu/svn/java/trunk/loci/apps/flow/Particle.java">SVN</a></dd></dl> 
    38  */ 
    39 public class Particle { 
     29        public void setSliceNum(int sliceNum) { 
     30                this.sliceNum = sliceNum; 
     31        } 
    4032 
    41   int area; 
    42   int num; 
    43   int totalIntensity; 
    44   int sliceNum; 
     33        public int getArea() { 
     34                return area; 
     35        } 
    4536 
    46   public Particle(int a, int i) { 
    47     area = a; 
    48     totalIntensity = i; 
    49   } 
     37        public int getIntensity() { 
     38                return totalIntensity; 
     39        } 
    5040 
    51   public void print() { 
    52     System.out.println("Particle "+num+" on slice "+ 
    53       sliceNum+" with area "+area+" and total intensity "+totalIntensity); 
    54   } 
    55  
    56   public int getNum() { 
    57     return num; 
    58   } 
    59  
    60   public void setNum(int num) { 
    61     this.num = num; 
    62   } 
    63  
    64   public int getSliceNum() { 
    65     return sliceNum; 
    66   } 
    67  
    68   public void setSliceNum(int sliceNum) { 
    69     this.sliceNum = sliceNum; 
    70   } 
    71  
    72   public int getArea() { 
    73     return area; 
    74   } 
    75  
    76   public int getIntensity() { 
    77     return totalIntensity; 
    78   } 
    79  
     41        public int getMeanIntensity() { 
     42                if (area==0) return 0;  
     43                else return totalIntensity/area; 
     44        } 
    8045} 
Note: See TracChangeset for help on using the changeset viewer.