Changeset 4125


Ignore:
Timestamp:
06/21/08 04:12:19 (11 years ago)
Author:
curtis
Message:

Fix build errors and clean up loci.apps.flow package.

Location:
trunk
Files:
1 added
1 deleted
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/build.properties

    r4099 r4125  
    3434 
    3535# files requiring Java 1.5 (rather than Java 1.4) 
    36 java15.dirs = loci/formats/auto/** 
     36java15.dirs = loci/apps/flow/** \ 
     37              loci/formats/auto/** 
    3738 
    3839# files to avoid copying into the build source tree 
  • trunk/build.xml

    r4082 r4125  
    479479    <!-- By default, source files should compile under Java 1.4 --> 
    480480    <javac srcdir="." destdir="." debug="true" classpath="${ext.jars}" 
    481       deprecation="true" source="1.4" target="1.4"> 
    482       <include name="loci/**"/> 
    483       <exclude name="${java15.dirs}"/> 
    484     </javac> 
     481      deprecation="true" source="1.4" target="1.4" 
     482      includes="loci/**" excludes="${java15.dirs}"/> 
    485483    <!-- Source files requiring Java 1.5 --> 
    486484    <javac srcdir="." destdir="." debug="true" classpath="${ext.jars}" 
    487       deprecation="true" source="1.5" target="1.5"> 
    488       <include name="${java15.dirs}"/> 
    489     </javac> 
     485      deprecation="true" source="1.5" target="1.5" includes="${java15.dirs}"/> 
    490486  </target> 
    491487 
  • trunk/loci/apps/flow

    • Property svn:ignore set to
      *.class
  • trunk/loci/apps/flow/Detector.java

    r4120 r4125  
     1// 
     2// Detector.java 
     3// 
     4 
     5/* 
     6Server application for flow cytometry with WiscScan using JVMLink. 
     7Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     8 
     9Redistribution and use in source and binary forms, with or without 
     10modification, 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 
     20THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
     21EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     22WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
     23DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
     24DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     25(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
     26LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
     27ON 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 
     29SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30*/ 
     31 
     32package loci.apps.flow; 
     33 
    134import ij.*; 
    235import ij.process.*; 
     
    538import java.util.Vector; 
    639 
     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 */ 
    745public class Detector { 
    8          
    9  
    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]; 
    15  
    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     } 
    21  
    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; } 
    34  
    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                  
    44  
    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         } 
    82  
    83         public void findParticles(ImageProcessor ip) { 
    84  
    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]; 
    88  
    89                 IJ.run(new ImagePlus("temp", new ByteProcessor(size, size, newByteArray, theCM)), "Despeckle", ""); 
    90                 imageData = newByteArray; 
    91                 floodArray = new int[size][size]; 
    92                 markPixelsInitial(); 
    93  
    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         } 
    126  
    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         } 
    158  
    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         } 
    182  
    183         public int getNumRegions() { 
    184                 return numRegions; 
    185         } 
    186  
    187         public int[][] getFloodArray() { 
    188                 return floodArray; 
    189         } 
     46 
     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]; 
     52 
     53    for (int ii=0; ii<256; ii++) r[ii] = g[ii] = b[ii] = (byte) ii; 
     54 
     55    return new IndexColorModel(8, 256, r, g, b); 
     56  } 
     57 
     58  public static ImagePlus impParticles, imp3; 
     59 
     60  private int size = 512; 
     61  private int intensityThreshold = 30; 
     62  private int areaThreshold = 100; 
     63 
     64  private int numRegions; 
     65  private int[][] floodArray; 
     66 
     67  private byte[] imageData; 
     68 
     69  public void setIntensityThreshold(int t) { intensityThreshold = t; } 
     70  public void setAreaThreshold(int t) { areaThreshold = t; } 
     71 
     72  public static void createImageHolder(int x, int y) { 
     73    impParticles = new ImagePlus("Particles", new ByteProcessor(x, y)); 
     74    impParticles.hide(); 
     75  } 
     76 
     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)); 
     81 
     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"); 
     86 
     87    d.findParticles((ByteProcessor) Detector.imp3.getProcessor()); 
     88    d.crunchArray(); 
     89    displayImage(d.floodArray); 
     90  } 
     91 
     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 
    190235} 
  • trunk/loci/apps/flow/FCTest.java

    r4120 r4125  
     1// 
     2// FCTest.java 
     3// 
     4 
     5/* 
     6Server application for flow cytometry with WiscScan using JVMLink. 
     7Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     8 
     9Redistribution and use in source and binary forms, with or without 
     10modification, 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 
     20THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
     21EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     22WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
     23DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
     24DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     25(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
     26LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
     27ON 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 
     29SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30*/ 
     31 
     32package loci.apps.flow; 
     33 
    134import ij.*; 
    235 
     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 */ 
    341public class FCTest { 
    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         }        
     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 
    2565} 
  • trunk/loci/apps/flow/JVMLinkFlowCytometry.java

    r4120 r4125  
    44 
    55/* 
    6 JVMLink client/server architecture for communicating between Java and 
    7 non-Java programs using sockets. 
    8 Copyright (c) 2008 Hidayath Ansari and Curtis Rueden. All rights reserved. 
     6Server application for flow cytometry with WiscScan using JVMLink. 
     7Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
    98 
    109Redistribution and use in source and binary forms, with or without 
     
    3130*/ 
    3231 
     32package loci.apps.flow; 
     33 
    3334import ij.*; 
    3435import ij.gui.ImageWindow; 
     
    4546import java.io.IOException; 
    4647import java.rmi.RemoteException; 
     48import java.text.SimpleDateFormat; 
     49import java.util.Date; 
    4750import java.util.Vector; 
    4851 
     
    5457import loci.formats.meta.MetadataStore; 
    5558 
    56 class 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         } 
     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 */ 
     64public 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  } 
     580*/ 
     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  } 
    71804 
    72805} 
    73806 
    74  
    75 public class JVMLinkFlowCytometry { 
    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         } 
    548 */ 
    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 printVector(Vector<Double> v) { 
    678                 for (int i=0; i<v.size(); i++) { 
    679                         double dtemp = v.get(i); 
    680                         System.out.println(dtemp); 
    681                 } 
    682         } 
    683          
    684         private static String flattenVector(Vector<Double> v) { 
    685                 String retval = ""; 
    686                 for (int i=0; i<v.size(); i++) { 
    687                         retval += v.get(i)+"\n"; 
    688                 } 
    689                 return retval; 
    690         }        
    691 } 
    692  
    693  
    694807/* Old try catch block 
    695 try {                    
     808try { 
    696809// Display initialization 
    697810area = RealType.getRealType("Area"); 
     
    725838 
    726839ItemListener CBitemListener = new ItemListener() { 
    727         public void itemStateChanged(ItemEvent itemEvent) { 
    728                 if (itemEvent.getStateChange() == ItemEvent.SELECTED) cumulative = true; 
    729                 else cumulative = false; 
    730                 try { 
    731                         JVMLinkFlowCytometry.data_ref.setData(newGetData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
    732                         JVMLinkFlowCytometry.display.reDisplayAll(); 
    733                 } catch (RemoteException e) {} catch (VisADException e) {} 
    734         } 
     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  } 
    735851}; 
    736852CBcumulative.addItemListener(CBitemListener); 
    737853 
    738854AdjustmentListener l = new AdjustmentListener() { 
    739         public void adjustmentValueChanged(AdjustmentEvent arg0) { 
    740                 try { 
    741                         int slideNum = ((Scrollbar) imp.getWindow().getComponent(1)).getValue(); 
    742                         //IJ.log("This is slide "+slideNum+" and particle numbers on this slide go from "+sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
    743                         //IJ.log(Integer.toString(((Scrollbar) Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
    744                         JVMLinkFlowCytometry.data_ref.setData(newGetData(slideNum, cumulative, intensity, fn)); 
    745                         JVMLinkFlowCytometry.display.reDisplayAll(); 
    746                         //Intensity_.this.data_ref.setData(getData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
    747                 } catch (RemoteException e) {} catch (VisADException e) {} 
    748         } 
     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  } 
    749871}; 
    750872scroll.addAdjustmentListener(l); 
     
    753875frame.setSize(600, 600); 
    754876frame.setVisible(true); 
    755 } catch (VisADException e) {IJ.log("VisAD Exception in init: "+e.getMessage());} catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     877} 
     878catch (VisADException e) {IJ.log("VisAD Exception in init: "+e.getMessage());} 
     879catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
    756880*/ 
  • trunk/loci/apps/flow/JVMLinkXML.java

    r4120 r4125  
     1// 
     2// JVMLinkXML.java 
     3// 
     4 
     5/* 
     6Server application for flow cytometry with WiscScan using JVMLink. 
     7Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     8 
     9Redistribution and use in source and binary forms, with or without 
     10modification, 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 
     20THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
     21EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     22WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
     23DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
     24DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     25(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
     26LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
     27ON 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 
     29SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30*/ 
     31 
     32package loci.apps.flow; 
     33 
    134import loci.formats.*; 
    2 import loci.formats.meta.MetadataRetrieve; 
    335import loci.formats.meta.MetadataStore; 
    436 
     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 */ 
    542public 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          
     43 
     44  public static MetadataStore metadataStore; 
     45 
     46  public static void createOMEXMLMetadata() { 
     47    metadataStore = MetadataTools.createOMEXMLMetadata(); 
     48    metadataStore.createRoot(); 
     49  } 
    1650 
    1751} 
  • trunk/loci/apps/flow/Particle.java

    r4120 r4125  
     1// 
     2// Particle.java 
     3// 
    14 
     5/* 
     6Server application for flow cytometry with WiscScan using JVMLink. 
     7Copyright (c) 2008 Hidayath Ansari. All rights reserved. 
     8 
     9Redistribution and use in source and binary forms, with or without 
     10modification, 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 
     20THIS SOFTWARE IS PROVIDED BY THE UW-MADISON LOCI ``AS IS'' AND ANY 
     21EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
     22WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
     23DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY 
     24DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
     25(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
     26LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
     27ON 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 
     29SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     30*/ 
     31 
     32package loci.apps.flow; 
     33 
     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 */ 
    239public 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         } 
    1640 
    17         public int getNum() { 
    18                 return num; 
    19         } 
     41  int area; 
     42  int num; 
     43  int totalIntensity; 
     44  int sliceNum; 
    2045 
    21         public void setNum(int num) { 
    22                 this.num = num; 
    23         } 
     46  public Particle(int a, int i) { 
     47    area = a; 
     48    totalIntensity = i; 
     49  } 
    2450 
    25         public int getSliceNum() { 
    26                 return sliceNum; 
    27         } 
     51  public void print() { 
     52    System.out.println("Particle "+num+" on slice "+ 
     53      sliceNum+" with area "+area+" and total intensity "+totalIntensity); 
     54  } 
    2855 
    29         public void setSliceNum(int sliceNum) { 
    30                 this.sliceNum = sliceNum; 
    31         } 
     56  public int getNum() { 
     57    return num; 
     58  } 
    3259 
    33         public int getArea() { 
    34                 return area; 
    35         } 
     60  public void setNum(int num) { 
     61    this.num = num; 
     62  } 
    3663 
    37         public int getIntensity() { 
    38                 return totalIntensity; 
    39         } 
     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 
    4080} 
Note: See TracChangeset for help on using the changeset viewer.