Ignore:
Timestamp:
12/09/11 04:15:57 (8 years ago)
Author:
avivekan
Message:

Flow update. still testing...

File:
1 edited

Legend:

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

    r7668 r7827  
    1111Redistribution and use in source and binary forms, with or without 
    1212modification, are permitted provided that the following conditions are met: 
    13     * Redistributions of source code must retain the above copyright 
     13 * Redistributions of source code must retain the above copyright 
    1414      notice, this list of conditions and the following disclaimer. 
    15     * Redistributions in binary form must reproduce the above copyright 
     15 * Redistributions in binary form must reproduce the above copyright 
    1616      notice, this list of conditions and the following disclaimer in the 
    1717      documentation and/or other materials provided with the distribution. 
    18     * Neither the name of the UW-Madison LOCI nor the 
     18 * Neither the name of the UW-Madison LOCI nor the 
    1919      names of its contributors may be used to endorse or promote products 
    2020      derived from this software without specific prior written permission. 
     
    3131ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
    3232POSSIBILITY OF SUCH DAMAGE. 
    33 */ 
     33 */ 
    3434 
    3535package loci.apps.flow; 
     
    4242import ij.measure.ResultsTable; 
    4343import ij.plugin.filter.Analyzer; 
     44import ij.plugin.frame.RoiManager; 
    4445import ij.process.ByteProcessor; 
    4546import ij.process.ImageProcessor; 
    46  
    4747import java.awt.BorderLayout; 
    4848import java.awt.Scrollbar; 
     
    9999 */ 
    100100class Slice { 
    101   int num; 
    102   boolean hasParticles; 
    103   int begin; 
    104   int end; 
    105  
    106   public Slice(int n) { 
    107     num = n; 
    108     hasParticles = false; 
    109   } 
    110  
    111   public void print() { 
    112     if (hasParticles) { 
    113       System.out.println("Slice "+num+" begins with particle "+ 
    114         begin+" and ends at "+end); 
    115     } 
    116     else System.out.println("Slice "+num+" has no particles"); 
    117   } 
     101        int num; 
     102        boolean hasParticles; 
     103        int begin; 
     104        int end; 
     105 
     106        public Slice(int n) { 
     107                num = n; 
     108                hasParticles = false; 
     109        } 
     110 
     111        public void print() { 
     112                if (hasParticles) { 
     113                        System.out.println("Slice "+num+" begins with particle "+ 
     114                                        begin+" and ends at "+end); 
     115                } 
     116                else System.out.println("Slice "+num+" has no particles"); 
     117        } 
    118118} 
    119119 
    120120public class FlowCytometry { 
    121121 
    122   /** Debugging flag. */ 
    123   protected static boolean debug = true; 
    124  
    125   private static final int MIN_INTENSITY = 0; 
    126   private static final int MAX_INTENSITY = 255; 
    127  
    128   private static final int INTENSITY_AXIS = 0; 
    129   private static final int AREA_AXIS = 1; 
    130  
    131   private static final int PIXELS = 0; 
    132   private static final int MICRONS = 1; 
    133  
    134   private static ImageJ ij; 
    135   private static ImagePlus imp; 
    136   private static ImageStack stack; 
    137   private static ByteProcessor bp; 
    138   private static ColorModel theCM; 
    139   private static Detector d; 
    140  
    141   public static int nSlices; 
    142   private static int nParticles; 
    143   private static JFrame frame; 
    144   private static JCheckBox CBcumulative; 
    145   private static boolean cumulative; 
    146   private static Vector<Double> areaValues; 
    147   private static Vector<Double> intensityValues; 
    148   private static Vector<Double> diameterValues; 
    149   private static Vector<Integer> cellFrameV = new Vector<Integer>(); 
    150  
    151   private static Vector<Particle> particles; 
    152   private static Vector<Slice> slices; 
    153  
    154   //These are pointers to vectors containing actual values 
    155   //to axes as specified in WiscScan. 
    156   private static Vector<Double> XAxisValues; 
    157   private static Vector<Double> YAxisValues; 
    158   private static int xAxis, yAxis; 
    159  
    160   private static RealType area, intensity, diameter, xType, yType; 
    161   private static FunctionType fn; 
    162   private static DataReferenceImpl data_ref; 
    163   private static Scrollbar scroll; 
    164   private static DisplayImpl display; 
    165   private static ResultsTable rt; 
    166   private static double maxArea, minArea, maxIntensity, minIntensity; 
    167   private static ScalarMap xMap, yMap; 
    168  
    169   private static double pixelMicronSquared; 
    170  
    171   private static int resolutionWidth = 0; 
    172   private static int resolutionHeight = 0; 
    173   private static int minX=0, maxX=0, minY=0, maxY=0; 
    174   private static int intensityThreshold=30; 
    175   private static int areaThresholdInPixels=100; 
    176   private static int areaUnit=0; 
    177   private static boolean showParticles=false; 
    178   private static boolean b_logY = false; 
    179   private static Vector<Particle> lastFrameParticles; 
    180  
    181   private static Vector<Integer> sliceBegin, sliceEnd; 
    182   // sliceBegin[i] is the minimum identifier of all particles on slice i 
    183   // sliceEnd[i] is the maximum identifier of all particles on slice i 
    184  
    185   // For XML metadata 
    186   private static String s_Name, s_Experiment, s_Params, s_Date; 
    187  
    188   public static void startImageJ() { 
    189     ij = new ImageJ(); 
    190     ij.getBounds(); 
    191   } 
    192  
    193   public static void incrementSlices() { 
    194     nSlices++; 
    195   } 
    196  
    197   public static void showImage(int width, int height, byte[] imageData) { 
    198     //bp = new ByteProcessor(width,height,imageData, 
    199     //  ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
    200     bp = new ByteProcessor(width,height,imageData, theCM); 
    201     bp.createImage(); 
    202     stack.addSlice("Slice "+nSlices, bp); 
    203     imp.setStack("Islet images", stack); 
    204     imp.setSlice(stack.getSize()); 
    205     imp.show(); 
    206  
    207     if (nSlices == 1) { 
    208       stack.deleteSlice(1); 
    209     } 
    210     else if (nSlices == 2) { 
    211       ImageWindow stackwin = imp.getWindow(); 
    212       scroll = (Scrollbar) stackwin.getComponent(1); 
    213  
    214       AdjustmentListener l = new AdjustmentListener() { 
    215         @SuppressWarnings("synthetic-access") 
    216         @Override 
    217         public void adjustmentValueChanged(AdjustmentEvent arg0) { 
    218           try { 
    219             int slideNum = 
    220               ((Scrollbar) imp.getWindow().getComponent(1)).getValue(); 
    221             //for the detected particles window 
    222             if (showParticles) { 
    223               d = new Detector(resolutionWidth, 
    224                 intensityThreshold, areaThresholdInPixels); 
    225               d.findParticles(stack.getProcessor(slideNum)); 
    226               d.crunchArray(); 
    227               Detector.displayImage(d.getFloodArray()); 
    228             } 
    229  
    230             //for the graph 
    231             //IJ.log("This is slide "+slideNum+ 
    232             //  " and particle numbers on this slide go from "+ 
    233             //  sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
    234             //IJ.log(Integer.toString(((Scrollbar) 
    235             //  Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
    236             FlowCytometry.data_ref.setData( 
    237               newestGetData(slideNum, cumulative, intensity, fn)); 
    238             FlowCytometry.display.reDisplayAll(); 
    239             //Intensity_.this.data_ref.setData( 
    240             //  getData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
    241           } 
    242           catch (RemoteException e) { 
    243             // ignore exceptions 
    244           } 
    245           catch (VisADException e) { 
    246             // ignore exceptions 
    247           } 
    248         } 
    249       }; 
    250       scroll.addAdjustmentListener(l); 
    251     } 
    252   } 
    253  
    254   public static void initVars() { 
    255     maxArea=Double.MIN_VALUE; 
    256     minArea=Double.MAX_VALUE; 
    257     maxIntensity = Double.MIN_VALUE; 
    258     minIntensity = Double.MAX_VALUE; 
    259     nSlices = 0; 
    260     nParticles = 0; 
    261  
    262     particles = new Vector<Particle>(); 
    263     slices = new Vector<Slice>(); 
    264  
    265     sliceBegin = new Vector<Integer>(); 
    266     sliceEnd = new Vector<Integer>(); 
    267     areaValues = new Vector<Double>(); 
    268     intensityValues = new Vector<Double>(); 
    269     diameterValues = new Vector<Double>(); 
    270  
    271     XAxisValues = intensityValues; 
    272     YAxisValues = areaValues; 
    273  
    274     area = RealType.getRealType("Area"); 
    275     intensity = RealType.getRealType("Intensity"); 
    276     diameter = RealType.getRealType("Diameter"); 
    277   } 
    278  
    279   public static void init(int width, int height, double pixelsPerMicron) { 
    280     setResolution(width, height); 
    281     s_Date = new java.text.SimpleDateFormat("MM.dd.yyyy hh:mm:ss").format( 
    282       new java.util.Date()); 
    283  
    284     byte[] r = new byte[256]; 
    285     byte[] g = new byte[256]; 
    286     byte[] b = new byte[256]; 
    287  
    288     for(int ii=0 ; ii<256 ; ii++) 
    289     r[ii] = g[ii] = b[ii] = (byte)ii; 
    290  
    291     theCM = new IndexColorModel(8, 256, r,g,b); 
    292     imp = new ImagePlus("Islet images", 
    293       new ByteProcessor(resolutionWidth,resolutionHeight)); 
    294     stack = new ImageStack(resolutionWidth, resolutionHeight, theCM); 
    295     imp.show(); 
    296  
    297     Detector.createImageHolder(resolutionWidth, resolutionHeight); 
    298  
    299     imp.unlock(); 
    300  
    301     initVars(); 
    302  
    303     pixelMicronSquared = 0.149*0.149; 
    304     if (pixelsPerMicron > 0) { 
    305       pixelMicronSquared = pixelsPerMicron*pixelsPerMicron; 
    306     } 
    307  
    308     byte[] dummyData = new byte[resolutionWidth*resolutionHeight]; 
    309     bp = new ByteProcessor(resolutionWidth,resolutionHeight,dummyData, theCM); 
    310     bp.createImage(); 
    311     stack.addSlice("Slice "+nSlices, bp); 
    312     imp.setStack("Islet images", stack); 
    313  
    314     imp.setSlice(1); 
    315  
    316     try { 
    317       // Display initialization 
    318  
    319       display = new DisplayImplJ2D("Graph Display"); 
    320       data_ref = new DataReferenceImpl("data_ref"); 
    321       data_ref.setData(null); 
    322       display.addReference(data_ref); 
    323       display.getGraphicsModeControl().setScaleEnable(true); 
    324       display.getGraphicsModeControl().setPointSize(3); 
    325       setAxes(0,1); 
    326  
    327       frame = new JFrame("Graph Window"); 
    328       frame.setLayout(new BorderLayout()); 
    329  
    330       CBcumulative = new JCheckBox("Cumulative"); 
    331       CBcumulative.setMnemonic(KeyEvent.VK_G); 
    332       JPanel bottomPanel = new JPanel(); 
    333       bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS)); 
    334       bottomPanel.add(CBcumulative); 
    335  
    336       frame.getContentPane().add(display.getComponent(), BorderLayout.CENTER); 
    337       frame.getContentPane().add(bottomPanel, BorderLayout.SOUTH); 
    338  
    339       ItemListener CBitemListener = new ItemListener() { 
    340         @SuppressWarnings("synthetic-access") 
    341         @Override 
    342         public void itemStateChanged(ItemEvent itemEvent) { 
    343           cumulative = itemEvent.getStateChange() == ItemEvent.SELECTED; 
    344           try { 
    345             FlowCytometry.data_ref.setData(newestGetData( 
    346               imp.getCurrentSlice(), cumulative, intensity, fn)); 
    347             FlowCytometry.display.reDisplayAll(); 
    348           } 
    349           catch (RemoteException e) { 
    350             // ignore exceptions 
    351           } 
    352           catch (VisADException e) { 
    353             // ignore exceptions 
    354           } 
    355         } 
    356       }; 
    357       CBcumulative.addItemListener(CBitemListener); 
    358  
    359       imp.setSlice(1); 
    360       frame.setSize(600, 600); 
    361       frame.setVisible(true); 
    362     } 
    363     catch (VisADException e) { 
    364       IJ.log("VisAD Exception in init: "+e.getMessage()); 
    365     } 
    366     catch (RemoteException re) { 
    367       IJ.log("Remote Exception: "+re.getMessage()); 
    368     } 
    369   } 
    370  
    371   public static void setAxes(int x, int y) { 
    372     // 0 - Intensity 
    373     // 1 - Area 
    374     // 2 - Diameter 
    375     xAxis = x; yAxis = y; 
    376  
    377     switch(xAxis) { 
    378       case 0: 
    379         xType = intensity; 
    380         XAxisValues = intensityValues; 
    381         break; 
    382       case 1: 
    383         xType = area; 
    384         XAxisValues = areaValues; 
    385         break; 
    386       case 2: 
    387         xType = diameter; 
    388         XAxisValues = diameterValues; 
    389         break; 
    390     } 
    391  
    392     switch(yAxis) { 
    393       case 0: 
    394         yType = intensity; 
    395         YAxisValues = intensityValues; 
    396         break; 
    397       case 1: 
    398         yType = area; 
    399         YAxisValues = areaValues; 
    400         break; 
    401       case 2: 
    402         yType = diameter; 
    403         YAxisValues = diameterValues; 
    404         break; 
    405     } 
    406     try { 
    407       xMap = new ScalarMap(xType, Display.XAxis); 
    408       yMap = new ScalarMap(yType, Display.YAxis); 
    409       xMap.setRange(getMinX(), getMaxX()); 
    410       yMap.setRange(getMinY(), getMaxY()); 
    411  
    412       fn = new FunctionType(xType, yType); 
    413       display.clearMaps(); 
    414       display.addMap(xMap); 
    415       display.addMap(yMap); 
    416  
    417     } 
    418     catch (RemoteException e) { e.printStackTrace(); } 
    419     catch (VisADException e) { e.printStackTrace(); } 
    420   } 
    421  
    422   // Setters 
    423  
    424   public static void setResolution(int width, int height) { 
    425     resolutionWidth = width; 
    426     resolutionHeight = height; 
    427   } 
    428  
    429   public static void setXAxis(int option) { xAxis = option; } 
    430   public static void setYAxis(int option) { yAxis = option; } 
    431   public static void setName(String name) { s_Name = name; } 
    432   public static void setExperiment(String exp) { s_Experiment = exp; } 
    433   public static void setParams(String params) { s_Params = params; } 
    434   public static void setMinX(int val) { minX = val; } 
    435   public static void setMaxX(int val) { maxX = val; } 
    436   public static void setMinY(int val) { minY = val; } 
    437   public static void setMaxY(int val) { maxY = val; } 
    438   public static void setIntensityThreshold(int val) { 
    439     intensityThreshold = val; 
    440   } 
    441   public static void setAreaThreshold(int val) { 
    442     if (areaUnit == PIXELS) { 
    443       areaThresholdInPixels = val; 
    444     } 
    445     else if (areaUnit == MICRONS) { 
    446       areaThresholdInPixels = (int) Math.round(val*pixelMicronSquared); 
    447     } 
    448   } 
    449   public static void setAreaUnits(int val) { areaUnit = val; } 
    450   public static void setPixelMicronSquared(double val) { 
    451     pixelMicronSquared = val*val; 
    452   } 
    453   public static void reprocessAll() { 
    454     particles = new Vector<Particle>(); 
    455     slices = new Vector<Slice>(); 
    456     nParticles = 0; 
    457     nSlices = 0; 
    458     for (int i=0; i<stack.getSize(); i++) { 
    459       incrementSlices(); 
    460       newestProcessFrame(i+1); 
    461     } 
    462     updateGraph(); 
    463   } 
    464  
    465   public static void saveDataWithXML() throws FormatException, IOException { 
    466     ImageWriter iw = new ImageWriter(); 
    467  
    468     OMEXMLService service = null; 
    469     OMEXMLMetadata omexmlMeta = null; 
    470  
    471     Exception exc = null; 
    472     try { 
    473       ServiceFactory factory = new ServiceFactory(); 
    474       service = factory.getInstance(OMEXMLService.class); 
    475       omexmlMeta = service.createOMEXMLMetadata(); 
    476     } 
    477     catch (DependencyException e) { 
    478       throw new FormatException("Could not create OMEXMLMetadataStore", exc); 
    479     } 
    480     catch (ServiceException e) { 
    481       throw new FormatException("Could not create OMEXMLMetadataStore", exc); 
    482     } 
    483  
    484     omexmlMeta.createRoot(); 
    485  
    486     omexmlMeta.setPixelsSizeX(new PositiveInteger(resolutionWidth), 0); 
    487     omexmlMeta.setPixelsSizeY(new PositiveInteger(resolutionHeight), 0); 
    488     omexmlMeta.setPixelsSizeZ(new PositiveInteger(1), 0); 
    489     omexmlMeta.setPixelsSizeC(new PositiveInteger(1), 0); 
    490     omexmlMeta.setPixelsSizeT(new PositiveInteger(stack.getSize()), 0); 
    491     try { 
    492       omexmlMeta.setPixelsType(PixelType.fromString("uint8"), 0); 
    493     } 
    494     catch (EnumerationException e) { 
    495       throw new FormatException(e); 
    496     } 
    497     omexmlMeta.setPixelsBinDataBigEndian(Boolean.FALSE, 0, 0); 
    498     try { 
    499       omexmlMeta.setPixelsDimensionOrder(DimensionOrder.fromString("XYTZC"), 0); 
    500     } 
    501     catch (EnumerationException e) { 
    502       throw new FormatException(e); 
    503     } 
    504     omexmlMeta.setExperimenterFirstName(s_Name, 0); 
    505  
    506     iw.setMetadataRetrieve(omexmlMeta); 
    507     service.populateOriginalMetadata(omexmlMeta, "Experiment", s_Experiment); 
    508     service.populateOriginalMetadata(omexmlMeta, "Parameters", s_Params); 
    509     service.populateOriginalMetadata(omexmlMeta, "Date", s_Date); 
    510     service.populateOriginalMetadata(omexmlMeta, 
    511       "AreaValues", flattenVector(areaValues)); 
    512     service.populateOriginalMetadata(omexmlMeta, 
    513       "IntensityValues", flattenVector(intensityValues)); 
    514  
    515     // setImageCreationDate, setImageName on OME-XML metadata 
    516     iw.setId("testImage.ome.tiff"); 
    517  
    518     System.out.println(stack.getSize()); 
    519     for (int i=1; i<=stack.getSize(); i++) { 
    520       byte[] byteArray = (byte[]) stack.getProcessor(i).getPixels(); 
    521       iw.saveBytes(i - 1, byteArray); 
    522     } 
    523     iw.close(); 
    524   } 
    525  
    526   public static void newestProcessFrame() { 
    527     newestProcessFrame(nSlices); 
    528   } 
    529  
    530   public static void newestProcessFrame(int sliceNum) { 
    531     imp.unlock(); 
    532     d = new Detector(resolutionWidth, 
    533       intensityThreshold, areaThresholdInPixels); 
    534     d.findParticles(stack.getProcessor(sliceNum)); 
    535     lastFrameParticles = d.crunchArray(); 
    536     if (showParticles) { 
    537       System.out.println("Processing slice "+sliceNum); 
    538       Detector.displayImage(d.getFloodArray()); 
    539     } 
    540     Slice thisSlice = new Slice(nSlices); 
    541     if (lastFrameParticles.size() > 0) { 
    542       thisSlice.hasParticles = true; 
    543       thisSlice.begin = nParticles; 
    544       thisSlice.end = nParticles + lastFrameParticles.size() - 1; 
    545     } 
    546  
    547     for (int i = 0; i < lastFrameParticles.size(); i++) { 
    548       Particle thisParticle = lastFrameParticles.get(i); 
    549       thisParticle.setNum(nParticles++); 
    550       thisParticle.setSliceNum(nSlices); 
    551       thisParticle.setPixelsPerMicron(pixelMicronSquared); 
    552       addParticle(thisParticle); 
    553  
    554       //thisParticle.print(); 
    555  
    556       int thisArea = thisParticle.getMicronArea(); 
    557       int thisIntensity = thisParticle.getIntensity(); 
    558       if (thisArea > maxArea) maxArea = thisArea; 
    559       if (thisArea < minArea) minArea = thisArea; 
    560       if (thisIntensity > maxIntensity) maxIntensity = thisIntensity; 
    561       if (thisIntensity < minIntensity) minIntensity = thisIntensity; 
    562     } 
    563  
    564     slices.add(thisSlice); 
    565     System.out.println("Particles size is "+particles.size()); 
    566     //for (int i=0; i<particles.size(); i++) particles.get(i).print(); 
    567   } 
    568  
    569   public static int[] getParticleMicronAreas() { 
    570     int[] micronAreas = new int[lastFrameParticles.size()]; 
    571     for (int i = 0; i < micronAreas.length; i++) { 
    572       micronAreas[i] = lastFrameParticles.get(i).getMicronArea(); 
    573     } 
    574     return micronAreas; 
    575   } 
    576  
    577   private static boolean addParticle(Particle particle) { 
    578     int particleIndex = particles.size()-1; 
    579     if (particles.size() == 0) { 
    580       particles.add(particle); 
    581       return false; 
    582     } 
    583     int lastSliceNum = nSlices-1; 
    584     boolean duplicate = false; 
    585     Particle lastParticle = particles.get(particleIndex); 
    586     while (lastParticle.getSliceNum() == lastSliceNum) { 
    587       duplicate = isSameParticle(particle, lastParticle); 
    588       if (duplicate) { 
    589         lastParticle.deactivate(); 
    590         debug("Duplicate particle detected"); 
    591         break; 
    592       } 
    593       if (particleIndex == 0) break; 
    594       lastParticle = particles.get(--particleIndex); 
    595     } 
    596     particles.add(particle); 
    597     return duplicate; 
    598   } 
    599  
    600   private static boolean isSameParticle(Particle oldP, Particle newP) { 
    601     int nMatches = 0; 
    602     double tolerance = 0.1; 
    603     if (newP.getPixelArea() < (1+tolerance)*oldP.getPixelArea() && 
    604       newP.getPixelArea() > (1-tolerance)*oldP.getPixelArea()) 
    605     { 
    606       nMatches++; 
    607     } 
    608     if (newP.getMeanIntensity() < (1+tolerance)*oldP.getMeanIntensity() && 
    609       newP.getMeanIntensity() > (1-tolerance)*oldP.getMeanIntensity()) 
    610     { 
    611       nMatches++; 
    612     } 
    613     if (newP.getCentroidY() < (1+tolerance)*oldP.getCentroidY() && 
    614       newP.getCentroidY() > (1-tolerance)*oldP.getCentroidY()) 
    615     { 
    616       nMatches++; 
    617     } 
    618     if (newP.getSizeY() < (1+tolerance)*oldP.getSizeY() && 
    619       newP.getSizeY() > (1-tolerance)*oldP.getSizeY()) 
    620     { 
    621       nMatches++; 
    622     } 
    623     if (newP.getCentroidX() < (1+tolerance)*oldP.getCentroidX() && 
    624       newP.getCentroidX() > (1-tolerance)*oldP.getCentroidX()) 
    625     { 
    626       nMatches++; 
    627     } 
    628     if (newP.getSizeX() < (1+tolerance)*oldP.getSizeX() && 
    629       newP.getSizeX() > (1-tolerance)*oldP.getSizeX()) 
    630     { 
    631       nMatches++; 
    632     } 
    633  
    634     //Do something with the x-position and flow rate here. 
    635  
    636     return nMatches > 2; 
    637   } 
    638  
    639   public static void newProcessFrame() { 
    640     imp.unlock(); 
    641     ImageProcessor ip = stack.getProcessor(imp.getCurrentSlice()); 
    642     double totalArea=0, totalIntensity=0; 
    643     for (int i=0; i<resolutionWidth; i++) { 
    644       for (int j=0; j<resolutionHeight; j++) { 
    645         int value = ip.getPixel(i, j); 
    646         if (value >= intensityThreshold) { 
    647           totalArea++; 
    648           totalIntensity += value; 
    649         } 
    650       } 
    651     } 
    652     IJ.log("Area: "+totalArea); 
    653     IJ.log("Intensity: "+totalIntensity); 
    654     if (totalArea > maxArea) maxArea = totalArea; 
    655     if (totalArea < minArea) minArea = totalArea; 
    656     if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
    657     if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
    658     areaValues.add(totalArea); 
    659     if (totalArea != 0) intensityValues.add(totalIntensity/totalArea); 
    660     else intensityValues.add(0.0); 
    661     System.out.println("just added to vectors: "+ 
    662       totalArea+ " "+totalIntensity/totalArea); 
    663   } 
    664  
    665   public static void processFrame() { 
    666     incrementSlices(); 
    667     imp.unlock(); 
    668     bp.setThreshold(25, 255, 1); 
    669     IJ.run("Analyze Particles...", 
    670       "size=0-Infinity circularity=0.00-1.00 show=Nothing display clear"); 
    671     rt = Analyzer.getResultsTable(); 
    672     double totalArea=0, totalIntensity=0; 
    673     for (int j=0; j<rt.getCounter(); j++) { 
    674       double jArea = rt.getValue("Area", j); 
    675       totalArea += jArea; 
    676       totalIntensity += (rt.getValue("Mean", j))*jArea; 
    677     } 
    678     if (totalArea > maxArea) maxArea = totalArea; 
    679     if (totalArea < minArea) minArea = totalArea; 
    680     if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
    681     if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
    682     areaValues.add(totalArea); 
    683     intensityValues.add(totalIntensity); 
    684     cellFrameV.add(nSlices); 
    685  
    686     sliceBegin.ensureCapacity(2*nSlices); 
    687     sliceEnd.ensureCapacity(2*nSlices); 
    688     sliceBegin.add(nSlices); 
    689     sliceEnd.add(nSlices); 
    690     System.out.println("############: sliceBegin looks like "); 
    691     for (int i=0; i<sliceBegin.size(); i++) { 
    692       System.out.println(sliceBegin.get(i)); 
    693     } 
    694   } 
    695  
    696   private static double getMinX() { 
    697     double areaRange = (maxArea - minArea);///pixelMicronSquared; 
    698  
    699     if (minX !=0) return minX; 
    700     switch (xAxis) { 
    701       case AREA_AXIS: 
    702         return (minArea - 0.05*areaRange); 
    703       case INTENSITY_AXIS: 
    704         return MIN_INTENSITY; 
    705       default: 
    706         return (minArea - 0.05*areaRange); 
    707     } 
    708   } 
    709  
    710   private static double getMaxX() { 
    711     double areaRange = (maxArea - minArea);///pixelMicronSquared; 
    712  
    713     if (maxX !=0) return maxX; 
    714     switch (xAxis) { 
    715       case AREA_AXIS: 
    716         return (maxArea+0.05*areaRange); 
    717       case INTENSITY_AXIS: 
    718         return MAX_INTENSITY; 
    719       default: 
    720         return (maxArea+0.05*areaRange); 
    721     } 
    722   } 
    723  
    724   private static double getMinY() { 
    725     double areaRange = (maxArea - minArea);///pixelMicronSquared; 
    726     double retval; 
    727  
    728     if (minY !=0) return minY; 
    729     switch(yAxis) { 
    730       case AREA_AXIS: 
    731         retval = (minArea - 0.05*areaRange); 
    732         break; 
    733       case INTENSITY_AXIS: 
    734         retval = MIN_INTENSITY; 
    735         break; 
    736       default: 
    737         retval = (minArea - 0.05*areaRange); 
    738         break; 
    739     } 
    740  
    741     if (b_logY) { 
    742       if (retval < 0) { 
    743         debug("getMinY() returning 0 (in log case)"); 
    744         return 0; 
    745       } 
    746       return Math.log(retval); 
    747     } 
    748     return retval; 
    749   } 
    750  
    751   private static double getMaxY() { 
    752     double areaRange = (maxArea - minArea);///pixelMicronSquared; 
    753     double retval; 
    754  
    755     if (maxY !=0) return maxY; 
    756     switch (yAxis) { 
    757       case AREA_AXIS: 
    758         retval = (maxArea+0.05*areaRange); 
    759         break; 
    760       case INTENSITY_AXIS: 
    761         retval = MAX_INTENSITY; 
    762         break; 
    763       default: 
    764         retval = (maxArea+0.05*areaRange); 
    765         break; 
    766     } 
    767  
    768     if (b_logY) { 
    769       if (retval < 0) return 0; 
    770       return Math.log(retval); 
    771     } 
    772     return retval; 
    773   } 
    774  
    775   //public static void oldupdateGraph() { 
    776   //  //1.55^2 from the pixels/micron value: 
    777   //  double areaRange = (maxArea - minArea)/pixelMicronSquared; 
    778   //  try { 
    779   //    areaMap.setRange(minArea/pixelMicronSquared - 0.05*areaRange, 
    780   //      maxArea/pixelMicronSquared+0.05*areaRange); 
    781   //    data_ref.setData(newGetData(nSlices, true, intensity, fn)); 
    782   //    display.addReference(data_ref); 
    783   //  } 
    784   //  catch (VisADException e) { 
    785   //    IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
    786   //  } 
    787   //  catch (RemoteException re) { 
    788   //    IJ.log("Remote Exception: "+re.getMessage()); 
    789   //  } 
    790   //} 
    791  
    792   public static void updateGraph() { 
    793     try { 
    794       xMap.setRange(getMinX(), getMaxX()); 
    795       yMap.setRange(getMinY(), getMaxY()); 
    796       data_ref.setData(newestGetData(nSlices, true, xType, fn)); 
    797       //display.addReference(data_ref); 
    798       display.reDisplayAll(); // Replacing above line with this 
    799     } 
    800     catch (VisADException e) { 
    801       IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
    802     } 
    803     catch (RemoteException re) { 
    804       IJ.log("Remote Exception: "+re.getMessage()); 
    805     } 
    806   } 
    807  
    808   public static FlatField newestGetData(int slice, boolean cumul, 
    809     RealType x, FunctionType funcType) 
    810   { 
    811     //slice is NOT zero-indexed. 
    812     double[] xArray, yArray; 
    813     int beginSlice=0, endSlice=slice-1; 
    814     if (!cumul) beginSlice = slice-1; 
    815     int beginIndex = Integer.MAX_VALUE; 
    816     int endIndex = Integer.MIN_VALUE; 
    817     int numParticles=0; 
    818     for (int i=beginSlice; i<=endSlice; i++) { 
    819       if (slices.get(i).hasParticles) { 
    820         if (slices.get(i).begin < beginIndex) beginIndex = slices.get(i).begin; 
    821         if (slices.get(i).end > endIndex) endIndex = slices.get(i).end; 
    822         numParticles += (slices.get(i).end - slices.get(i).begin + 1); 
    823       } 
    824     } 
    825  
    826     //System.out.println("beginIndex:"+beginIndex+ 
    827     //  " endIndex:"+endIndex+" numParticles:"+numParticles); 
    828  
    829     if (numParticles == 0) return null; 
    830  
    831     double minXGraph = getMinX(), maxXGraph = getMaxX(); 
    832     double minYGraph = getMinY(), maxYGraph = getMaxY(); 
    833  
    834     double[] newxArray = new double[numParticles]; 
    835     double[] newyArray = new double[numParticles]; 
    836     int arrayindex = 0; 
    837  
    838     for (int i=beginIndex; i<=endIndex; i++) { 
    839       if (particles.get(i).getStatus()) { 
    840         boolean xActive = true, yActive = true; 
    841         double xValue=0, yValue=0; 
    842         switch(xAxis) { 
    843           case INTENSITY_AXIS: 
    844             xValue = particles.get(i).getMeanIntensity(); 
    845             if (xValue < minXGraph || xValue > maxXGraph) xActive = false; 
    846             break; 
    847           case AREA_AXIS: 
    848             xValue = particles.get(i).getMicronArea(); 
    849             if (xValue < minXGraph || xValue > maxXGraph) xActive = false; 
    850             break; 
    851         } 
    852         switch(yAxis) { 
    853           case INTENSITY_AXIS: 
    854             yValue = particles.get(i).getMeanIntensity(); 
    855             yValue = (b_logY ? Math.log(yValue) : yValue); 
    856             if (yValue < minYGraph || yValue > maxYGraph) yActive = false; 
    857             break; 
    858           case AREA_AXIS: 
    859             yValue = particles.get(i).getMicronArea(); 
    860             yValue = (b_logY ? Math.log(yValue) : yValue); 
    861             if (yValue < minYGraph || yValue > maxYGraph) yActive = false; 
    862             break; 
    863         } 
    864         if (xActive && yActive) { 
    865           newxArray[arrayindex] = xValue; 
    866           newyArray[arrayindex] = yValue; 
    867           arrayindex++; 
    868         } 
    869       } 
    870     } 
    871  
    872     xArray = new double[arrayindex]; 
    873     yArray = new double[arrayindex]; 
    874     for (int i=0; i<arrayindex; i++) { 
    875       xArray[i] = newxArray[i]; 
    876       yArray[i] = newyArray[i]; 
    877     } 
    878  
    879     /* Old code 
     122        /** Debugging flag. */ 
     123        protected static boolean debug = true; 
     124 
     125        private static final int MIN_INTENSITY = 0; 
     126        private static final int MAX_INTENSITY = 255; 
     127 
     128        private static final int INTENSITY_AXIS = 0; 
     129        private static final int AREA_AXIS = 1; 
     130 
     131        private static final int PIXELS = 0; 
     132        private static final int MICRONS = 1; 
     133 
     134        private static ImageJ ij; 
     135        private static ImagePlus imp; 
     136        private static ImageStack stack; 
     137        private static ByteProcessor bp; 
     138        private static ColorModel theCM; 
     139        private static Detector d; 
     140 
     141        public static int nSlices; 
     142        private static int nParticles; 
     143        private static JFrame frame; 
     144        private static JCheckBox CBcumulative; 
     145        private static boolean cumulative; 
     146        private static Vector<Double> areaValues; 
     147        private static Vector<Double> intensityValues; 
     148        private static Vector<Double> diameterValues; 
     149        private static Vector<Integer> cellFrameV = new Vector<Integer>(); 
     150 
     151        private static Vector<Particle> particles; 
     152        private static Vector<Slice> slices; 
     153 
     154        //These are pointers to vectors containing actual values 
     155        //to axes as specified in WiscScan. 
     156        private static Vector<Double> XAxisValues; 
     157        private static Vector<Double> YAxisValues; 
     158        private static int xAxis, yAxis; 
     159 
     160        private static RealType area, intensity, diameter, xType, yType; 
     161        private static FunctionType fn; 
     162        private static DataReferenceImpl data_ref; 
     163        private static Scrollbar scroll; 
     164        private static DisplayImpl display; 
     165        private static ResultsTable rt; 
     166        private static double maxArea, minArea, maxIntensity, minIntensity; 
     167        private static ScalarMap xMap, yMap; 
     168 
     169        private static double pixelMicronSquared; 
     170 
     171        private static int resolutionWidth = 0; 
     172        private static int resolutionHeight = 0; 
     173        private static int minX=0, maxX=0, minY=0, maxY=0; 
     174        private static int intensityThreshold=30; 
     175        private static int areaThresholdInPixels=100; 
     176        private static int areaUnit=0; 
     177        private static boolean showParticles=false; 
     178        private static boolean b_logY = false; 
     179        private static Vector<Particle> lastFrameParticles; 
     180 
     181        private static Vector<Integer> sliceBegin, sliceEnd; 
     182        // sliceBegin[i] is the minimum identifier of all particles on slice i 
     183        // sliceEnd[i] is the maximum identifier of all particles on slice i 
     184 
     185        // For XML metadata 
     186        private static String s_Name, s_Experiment, s_Params, s_Date; 
     187 
     188        public static void startImageJ() { 
     189                ij = new ImageJ(); 
     190                ij.getBounds(); 
     191        } 
     192 
     193        public static void incrementSlices() { 
     194                nSlices++; 
     195        } 
     196         
     197        //ajeet 
     198        public static int[] getBFParticleAreas(){ 
     199                IJ.runPlugIn("My_Plugin", null); 
     200 
     201                RoiManager rm = RoiManager.getInstance(); 
     202                int lenghtOfRoiTable =rm.getRoisAsArray().length; 
     203                int[] retVal = new int[lenghtOfRoiTable]; 
     204 
     205                for (int i = 0; i < lenghtOfRoiTable; i++){ 
     206                        retVal[i] = Integer.parseInt(IJ.runMacro("getResults(\"Area\", i)", null)); 
     207                } 
     208 
     209                return retVal; 
     210        } 
     211         
     212        /* 
     213        public static void showImageForBrightfield(int width, int height, byte[] imageData) { 
     214                //bp = new ByteProcessor(width,height,imageData, 
     215                //  ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
     216                bp2 = new ByteProcessor(width,height,imageData, theCM); 
     217                bp2.createImage(); 
     218                stack2.addSlice("Slice2 "+nSlices2, bp2); 
     219                imp2.setStack("Islet images 2", stack2); 
     220                imp2.setSlice(stack2.getSize()); 
     221                imp2.show(); 
     222 
     223                if (nSlices2 == 1) { 
     224                        stack2.deleteSlice(1); 
     225                } 
     226                else if (nSlices2 == 2) { 
     227                        ImageWindow stackwin = imp2.getWindow(); 
     228                        scroll2 = (Scrollbar) stackwin.getComponent(1); 
     229 
     230                        AdjustmentListener l = new AdjustmentListener() { 
     231                                @SuppressWarnings("synthetic-access") 
     232                                @Override 
     233                                public void adjustmentValueChanged(AdjustmentEvent arg0) { 
     234                                        try { 
     235                                                int slideNum = 
     236                                                                ((Scrollbar) imp2.getWindow().getComponent(1)).getValue(); 
     237                                                //for the detected particles window 
     238                                                if (showParticles2) { 
     239                                                        d2 = new Detector(resolutionWidth, 
     240                                                                        intensityThreshold, areaThresholdInPixels); 
     241                                                        d2.findParticles(stack2.getProcessor(slideNum)); 
     242                                                        d2.crunchArray(); 
     243                                                        Detector.displayImage(d2.getFloodArray()); 
     244                                                } 
     245 
     246                                                //for the graph 
     247                                                //IJ.log("This is slide "+slideNum+ 
     248                                                //  " and particle numbers on this slide go from "+ 
     249                                                //  sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
     250                                                //IJ.log(Integer.toString(((Scrollbar) 
     251                                                //  Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
     252                                                FlowCytometry.data_ref.setData( 
     253                                                                newestGetData(slideNum, cumulative, intensity, fn)); 
     254                                                FlowCytometry.display.reDisplayAll(); 
     255                                                //Intensity_.this.data_ref.setData( 
     256                                                //  getData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
     257                                        } 
     258                                        catch (RemoteException e) { 
     259                                                // ignore exceptions 
     260                                        } 
     261                                        catch (VisADException e) { 
     262                                                // ignore exceptions 
     263                                        } 
     264                                } 
     265                        }; 
     266                        scroll2.addAdjustmentListener(l); 
     267                } 
     268        } 
     269*/ 
     270        public static void showImage(int width, int height, byte[] imageData) { 
     271                //bp = new ByteProcessor(width,height,imageData, 
     272                //  ImageTools.makeColorModel(1, DataBuffer.TYPE_BYTE)); 
     273                bp = new ByteProcessor(width,height,imageData, theCM); 
     274                bp.createImage(); 
     275                stack.addSlice("Slice "+nSlices, bp); 
     276                imp.setStack("Islet images", stack); 
     277                imp.setSlice(stack.getSize()); 
     278                imp.show(); 
     279 
     280                if (nSlices == 1) { 
     281                        stack.deleteSlice(1); 
     282                } 
     283                else if (nSlices == 2) { 
     284                        ImageWindow stackwin = imp.getWindow(); 
     285                        scroll = (Scrollbar) stackwin.getComponent(1); 
     286 
     287                        AdjustmentListener l = new AdjustmentListener() { 
     288                                @SuppressWarnings("synthetic-access") 
     289                                @Override 
     290                                public void adjustmentValueChanged(AdjustmentEvent arg0) { 
     291                                        try { 
     292                                                int slideNum = 
     293                                                                ((Scrollbar) imp.getWindow().getComponent(1)).getValue(); 
     294                                                //for the detected particles window 
     295                                                if (showParticles) { 
     296                                                        d = new Detector(resolutionWidth, 
     297                                                                        intensityThreshold, areaThresholdInPixels); 
     298                                                        d.findParticles(stack.getProcessor(slideNum)); 
     299                                                        d.crunchArray(); 
     300                                                        Detector.displayImage(d.getFloodArray()); 
     301                                                } 
     302 
     303                                                //for the graph 
     304                                                //IJ.log("This is slide "+slideNum+ 
     305                                                //  " and particle numbers on this slide go from "+ 
     306                                                //  sliceBegin[slideNum]+" to "+sliceEnd[slideNum]); 
     307                                                //IJ.log(Integer.toString(((Scrollbar) 
     308                                                //  Intensity_.this.imp.getWindow().getComponent(1)).getValue())); 
     309                                                FlowCytometry.data_ref.setData( 
     310                                                                newestGetData(slideNum, cumulative, intensity, fn)); 
     311                                                FlowCytometry.display.reDisplayAll(); 
     312                                                //Intensity_.this.data_ref.setData( 
     313                                                //  getData(imp.getCurrentSlice(), cumulative, intensity, fn)); 
     314                                        } 
     315                                        catch (RemoteException e) { 
     316                                                // ignore exceptions 
     317                                        } 
     318                                        catch (VisADException e) { 
     319                                                // ignore exceptions 
     320                                        } 
     321                                } 
     322                        }; 
     323                        scroll.addAdjustmentListener(l); 
     324                } 
     325        } 
     326 
     327        public static void initVars() { 
     328                maxArea=Double.MIN_VALUE; 
     329                minArea=Double.MAX_VALUE; 
     330                maxIntensity = Double.MIN_VALUE; 
     331                minIntensity = Double.MAX_VALUE; 
     332                nSlices = 0; 
     333                nParticles = 0; 
     334 
     335                particles = new Vector<Particle>(); 
     336                slices = new Vector<Slice>(); 
     337 
     338                sliceBegin = new Vector<Integer>(); 
     339                sliceEnd = new Vector<Integer>(); 
     340                areaValues = new Vector<Double>(); 
     341                intensityValues = new Vector<Double>(); 
     342                diameterValues = new Vector<Double>(); 
     343 
     344                XAxisValues = intensityValues; 
     345                YAxisValues = areaValues; 
     346 
     347                area = RealType.getRealType("Area"); 
     348                intensity = RealType.getRealType("Intensity"); 
     349                diameter = RealType.getRealType("Diameter"); 
     350        } 
     351 
     352        public static void init(int width, int height, double pixelsPerMicron) { 
     353                setResolution(width, height); 
     354                s_Date = new java.text.SimpleDateFormat("MM.dd.yyyy hh:mm:ss").format( 
     355                                new java.util.Date()); 
     356 
     357                byte[] r = new byte[256]; 
     358                byte[] g = new byte[256]; 
     359                byte[] b = new byte[256]; 
     360 
     361                for(int ii=0 ; ii<256 ; ii++) 
     362                        r[ii] = g[ii] = b[ii] = (byte)ii; 
     363 
     364                theCM = new IndexColorModel(8, 256, r,g,b); 
     365                imp = new ImagePlus("Islet images", 
     366                                new ByteProcessor(resolutionWidth,resolutionHeight)); 
     367                stack = new ImageStack(resolutionWidth, resolutionHeight, theCM); 
     368                imp.show(); 
     369 
     370                Detector.createImageHolder(resolutionWidth, resolutionHeight); 
     371 
     372                imp.unlock(); 
     373 
     374                initVars(); 
     375 
     376                pixelMicronSquared = 0.149*0.149; 
     377                if (pixelsPerMicron > 0) { 
     378                        pixelMicronSquared = pixelsPerMicron*pixelsPerMicron; 
     379                } 
     380 
     381                byte[] dummyData = new byte[resolutionWidth*resolutionHeight]; 
     382                bp = new ByteProcessor(resolutionWidth,resolutionHeight,dummyData, theCM); 
     383                bp.createImage(); 
     384                stack.addSlice("Slice "+nSlices, bp); 
     385                imp.setStack("Islet images", stack); 
     386 
     387                imp.setSlice(1); 
     388 
     389                try { 
     390                        // Display initialization 
     391 
     392                        display = new DisplayImplJ2D("Graph Display"); 
     393                        data_ref = new DataReferenceImpl("data_ref"); 
     394                        data_ref.setData(null); 
     395                        display.addReference(data_ref); 
     396                        display.getGraphicsModeControl().setScaleEnable(true); 
     397                        display.getGraphicsModeControl().setPointSize(3); 
     398                        setAxes(0,1); 
     399 
     400                        frame = new JFrame("Graph Window"); 
     401                        frame.setLayout(new BorderLayout()); 
     402 
     403                        CBcumulative = new JCheckBox("Cumulative"); 
     404                        CBcumulative.setMnemonic(KeyEvent.VK_G); 
     405                        JPanel bottomPanel = new JPanel(); 
     406                        bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.LINE_AXIS)); 
     407                        bottomPanel.add(CBcumulative); 
     408 
     409                        frame.getContentPane().add(display.getComponent(), BorderLayout.CENTER); 
     410                        frame.getContentPane().add(bottomPanel, BorderLayout.SOUTH); 
     411 
     412                        ItemListener CBitemListener = new ItemListener() { 
     413                                @SuppressWarnings("synthetic-access") 
     414                                @Override 
     415                                public void itemStateChanged(ItemEvent itemEvent) { 
     416                                        cumulative = itemEvent.getStateChange() == ItemEvent.SELECTED; 
     417                                        try { 
     418                                                FlowCytometry.data_ref.setData(newestGetData( 
     419                                                                imp.getCurrentSlice(), cumulative, intensity, fn)); 
     420                                                FlowCytometry.display.reDisplayAll(); 
     421                                        } 
     422                                        catch (RemoteException e) { 
     423                                                // ignore exceptions 
     424                                        } 
     425                                        catch (VisADException e) { 
     426                                                // ignore exceptions 
     427                                        } 
     428                                } 
     429                        }; 
     430                        CBcumulative.addItemListener(CBitemListener); 
     431 
     432                        imp.setSlice(1); 
     433                        frame.setSize(600, 600); 
     434                        frame.setVisible(true); 
     435                } 
     436                catch (VisADException e) { 
     437                        IJ.log("VisAD Exception in init: "+e.getMessage()); 
     438                } 
     439                catch (RemoteException re) { 
     440                        IJ.log("Remote Exception: "+re.getMessage()); 
     441                } 
     442        } 
     443 
     444        public static void setAxes(int x, int y) { 
     445                // 0 - Intensity 
     446                // 1 - Area 
     447                // 2 - Diameter 
     448                xAxis = x; yAxis = y; 
     449 
     450                switch(xAxis) { 
     451                case 0: 
     452                        xType = intensity; 
     453                        XAxisValues = intensityValues; 
     454                        break; 
     455                case 1: 
     456                        xType = area; 
     457                        XAxisValues = areaValues; 
     458                        break; 
     459                case 2: 
     460                        xType = diameter; 
     461                        XAxisValues = diameterValues; 
     462                        break; 
     463                } 
     464 
     465                switch(yAxis) { 
     466                case 0: 
     467                        yType = intensity; 
     468                        YAxisValues = intensityValues; 
     469                        break; 
     470                case 1: 
     471                        yType = area; 
     472                        YAxisValues = areaValues; 
     473                        break; 
     474                case 2: 
     475                        yType = diameter; 
     476                        YAxisValues = diameterValues; 
     477                        break; 
     478                } 
     479                try { 
     480                        xMap = new ScalarMap(xType, Display.XAxis); 
     481                        yMap = new ScalarMap(yType, Display.YAxis); 
     482                        xMap.setRange(getMinX(), getMaxX()); 
     483                        yMap.setRange(getMinY(), getMaxY()); 
     484 
     485                        fn = new FunctionType(xType, yType); 
     486                        display.clearMaps(); 
     487                        display.addMap(xMap); 
     488                        display.addMap(yMap); 
     489 
     490                } 
     491                catch (RemoteException e) { e.printStackTrace(); } 
     492                catch (VisADException e) { e.printStackTrace(); } 
     493        } 
     494 
     495        // Setters 
     496 
     497        public static void setResolution(int width, int height) { 
     498                resolutionWidth = width; 
     499                resolutionHeight = height; 
     500        } 
     501 
     502        public static void setXAxis(int option) { xAxis = option; } 
     503        public static void setYAxis(int option) { yAxis = option; } 
     504        public static void setName(String name) { s_Name = name; } 
     505        public static void setExperiment(String exp) { s_Experiment = exp; } 
     506        public static void setParams(String params) { s_Params = params; } 
     507        public static void setMinX(int val) { minX = val; } 
     508        public static void setMaxX(int val) { maxX = val; } 
     509        public static void setMinY(int val) { minY = val; } 
     510        public static void setMaxY(int val) { maxY = val; } 
     511        public static void setIntensityThreshold(int val) { 
     512                intensityThreshold = val; 
     513        } 
     514        public static void setAreaThreshold(int val) { 
     515                if (areaUnit == PIXELS) { 
     516                        areaThresholdInPixels = val; 
     517                } 
     518                else if (areaUnit == MICRONS) { 
     519                        areaThresholdInPixels = (int) Math.round(val*pixelMicronSquared); 
     520                } 
     521        } 
     522        public static void setAreaUnits(int val) { areaUnit = val; } 
     523        public static void setPixelMicronSquared(double val) { 
     524                pixelMicronSquared = val*val; 
     525        } 
     526        public static void reprocessAll() { 
     527                particles = new Vector<Particle>(); 
     528                slices = new Vector<Slice>(); 
     529                nParticles = 0; 
     530                nSlices = 0; 
     531                for (int i=0; i<stack.getSize(); i++) { 
     532                        incrementSlices(); 
     533                        newestProcessFrame(i+1); 
     534                } 
     535                updateGraph(); 
     536        } 
     537 
     538        public static void saveDataWithXML() throws FormatException, IOException { 
     539                ImageWriter iw = new ImageWriter(); 
     540 
     541                OMEXMLService service = null; 
     542                OMEXMLMetadata omexmlMeta = null; 
     543 
     544                Exception exc = null; 
     545                try { 
     546                        ServiceFactory factory = new ServiceFactory(); 
     547                        service = factory.getInstance(OMEXMLService.class); 
     548                        omexmlMeta = service.createOMEXMLMetadata(); 
     549                } 
     550                catch (DependencyException e) { 
     551                        throw new FormatException("Could not create OMEXMLMetadataStore", exc); 
     552                } 
     553                catch (ServiceException e) { 
     554                        throw new FormatException("Could not create OMEXMLMetadataStore", exc); 
     555                } 
     556 
     557                omexmlMeta.createRoot(); 
     558 
     559                omexmlMeta.setPixelsSizeX(new PositiveInteger(resolutionWidth), 0); 
     560                omexmlMeta.setPixelsSizeY(new PositiveInteger(resolutionHeight), 0); 
     561                omexmlMeta.setPixelsSizeZ(new PositiveInteger(1), 0); 
     562                omexmlMeta.setPixelsSizeC(new PositiveInteger(1), 0); 
     563                omexmlMeta.setPixelsSizeT(new PositiveInteger(stack.getSize()), 0); 
     564                try { 
     565                        omexmlMeta.setPixelsType(PixelType.fromString("uint8"), 0); 
     566                } 
     567                catch (EnumerationException e) { 
     568                        throw new FormatException(e); 
     569                } 
     570                omexmlMeta.setPixelsBinDataBigEndian(Boolean.FALSE, 0, 0); 
     571                try { 
     572                        omexmlMeta.setPixelsDimensionOrder(DimensionOrder.fromString("XYTZC"), 0); 
     573                } 
     574                catch (EnumerationException e) { 
     575                        throw new FormatException(e); 
     576                } 
     577                omexmlMeta.setExperimenterFirstName(s_Name, 0); 
     578 
     579                iw.setMetadataRetrieve(omexmlMeta); 
     580                service.populateOriginalMetadata(omexmlMeta, "Experiment", s_Experiment); 
     581                service.populateOriginalMetadata(omexmlMeta, "Parameters", s_Params); 
     582                service.populateOriginalMetadata(omexmlMeta, "Date", s_Date); 
     583                service.populateOriginalMetadata(omexmlMeta, 
     584                                "AreaValues", flattenVector(areaValues)); 
     585                service.populateOriginalMetadata(omexmlMeta, 
     586                                "IntensityValues", flattenVector(intensityValues)); 
     587 
     588                // setImageCreationDate, setImageName on OME-XML metadata 
     589                iw.setId("testImage.ome.tiff"); 
     590 
     591                System.out.println(stack.getSize()); 
     592                for (int i=1; i<=stack.getSize(); i++) { 
     593                        byte[] byteArray = (byte[]) stack.getProcessor(i).getPixels(); 
     594                        iw.saveBytes(i - 1, byteArray); 
     595                } 
     596                iw.close(); 
     597        } 
     598 
     599        public static void newestProcessFrame() { 
     600                newestProcessFrame(nSlices); 
     601        } 
     602 
     603        public static void newestProcessFrame(int sliceNum) { 
     604                imp.unlock(); 
     605                d = new Detector(resolutionWidth, 
     606                                intensityThreshold, areaThresholdInPixels); 
     607                d.findParticles(stack.getProcessor(sliceNum)); 
     608                lastFrameParticles = d.crunchArray(); 
     609                if (showParticles) { 
     610                        System.out.println("Processing slice "+sliceNum); 
     611                        Detector.displayImage(d.getFloodArray()); 
     612                } 
     613                Slice thisSlice = new Slice(nSlices); 
     614                if (lastFrameParticles.size() > 0) { 
     615                        thisSlice.hasParticles = true; 
     616                        thisSlice.begin = nParticles; 
     617                        thisSlice.end = nParticles + lastFrameParticles.size() - 1; 
     618                } 
     619 
     620                for (int i = 0; i < lastFrameParticles.size(); i++) { 
     621                        Particle thisParticle = lastFrameParticles.get(i); 
     622                        thisParticle.setNum(nParticles++); 
     623                        thisParticle.setSliceNum(nSlices); 
     624                        thisParticle.setPixelsPerMicron(pixelMicronSquared); 
     625                        addParticle(thisParticle); 
     626 
     627                        //thisParticle.print(); 
     628 
     629                        int thisArea = thisParticle.getMicronArea(); 
     630                        int thisIntensity = thisParticle.getIntensity(); 
     631                        if (thisArea > maxArea) maxArea = thisArea; 
     632                        if (thisArea < minArea) minArea = thisArea; 
     633                        if (thisIntensity > maxIntensity) maxIntensity = thisIntensity; 
     634                        if (thisIntensity < minIntensity) minIntensity = thisIntensity; 
     635                } 
     636 
     637                slices.add(thisSlice); 
     638                System.out.println("Particles size is "+particles.size()); 
     639                //for (int i=0; i<particles.size(); i++) particles.get(i).print(); 
     640        } 
     641 
     642        public static int[] getParticleMicronAreas() { 
     643                int[] micronAreas = new int[lastFrameParticles.size()]; 
     644                for (int i = 0; i < micronAreas.length; i++) { 
     645                        micronAreas[i] = lastFrameParticles.get(i).getMicronArea(); 
     646                } 
     647                return micronAreas; 
     648        } 
     649 
     650        //ajeet 
     651        public static int[] getBrightfieldMicronAreas(){ 
     652                //TO DO get particle areas in brightfield and return 
     653                //area of those areas in microns 
     654 
     655                return null; 
     656        } 
     657 
     658        private static boolean addParticle(Particle particle) { 
     659                int particleIndex = particles.size()-1; 
     660                if (particles.size() == 0) { 
     661                        particles.add(particle); 
     662                        return false; 
     663                } 
     664                int lastSliceNum = nSlices-1; 
     665                boolean duplicate = false; 
     666                Particle lastParticle = particles.get(particleIndex); 
     667                while (lastParticle.getSliceNum() == lastSliceNum) { 
     668                        duplicate = isSameParticle(particle, lastParticle); 
     669                        if (duplicate) { 
     670                                lastParticle.deactivate(); 
     671                                debug("Duplicate particle detected"); 
     672                                break; 
     673                        } 
     674                        if (particleIndex == 0) break; 
     675                        lastParticle = particles.get(--particleIndex); 
     676                } 
     677                particles.add(particle); 
     678                return duplicate; 
     679        } 
     680 
     681        private static boolean isSameParticle(Particle oldP, Particle newP) { 
     682                int nMatches = 0; 
     683                double tolerance = 0.1; 
     684                if (newP.getPixelArea() < (1+tolerance)*oldP.getPixelArea() && 
     685                                newP.getPixelArea() > (1-tolerance)*oldP.getPixelArea()) 
     686                { 
     687                        nMatches++; 
     688                } 
     689                if (newP.getMeanIntensity() < (1+tolerance)*oldP.getMeanIntensity() && 
     690                                newP.getMeanIntensity() > (1-tolerance)*oldP.getMeanIntensity()) 
     691                { 
     692                        nMatches++; 
     693                } 
     694                if (newP.getCentroidY() < (1+tolerance)*oldP.getCentroidY() && 
     695                                newP.getCentroidY() > (1-tolerance)*oldP.getCentroidY()) 
     696                { 
     697                        nMatches++; 
     698                } 
     699                if (newP.getSizeY() < (1+tolerance)*oldP.getSizeY() && 
     700                                newP.getSizeY() > (1-tolerance)*oldP.getSizeY()) 
     701                { 
     702                        nMatches++; 
     703                } 
     704                if (newP.getCentroidX() < (1+tolerance)*oldP.getCentroidX() && 
     705                                newP.getCentroidX() > (1-tolerance)*oldP.getCentroidX()) 
     706                { 
     707                        nMatches++; 
     708                } 
     709                if (newP.getSizeX() < (1+tolerance)*oldP.getSizeX() && 
     710                                newP.getSizeX() > (1-tolerance)*oldP.getSizeX()) 
     711                { 
     712                        nMatches++; 
     713                } 
     714 
     715                //Do something with the x-position and flow rate here. 
     716 
     717                return nMatches > 2; 
     718        } 
     719 
     720        public static void newProcessFrame() { 
     721                imp.unlock(); 
     722                ImageProcessor ip = stack.getProcessor(imp.getCurrentSlice()); 
     723                double totalArea=0, totalIntensity=0; 
     724                for (int i=0; i<resolutionWidth; i++) { 
     725                        for (int j=0; j<resolutionHeight; j++) { 
     726                                int value = ip.getPixel(i, j); 
     727                                if (value >= intensityThreshold) { 
     728                                        totalArea++; 
     729                                        totalIntensity += value; 
     730                                } 
     731                        } 
     732                } 
     733                IJ.log("Area: "+totalArea); 
     734                IJ.log("Intensity: "+totalIntensity); 
     735                if (totalArea > maxArea) maxArea = totalArea; 
     736                if (totalArea < minArea) minArea = totalArea; 
     737                if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
     738                if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
     739                areaValues.add(totalArea); 
     740                if (totalArea != 0) intensityValues.add(totalIntensity/totalArea); 
     741                else intensityValues.add(0.0); 
     742                System.out.println("just added to vectors: "+ 
     743                                totalArea+ " "+totalIntensity/totalArea); 
     744        } 
     745 
     746        public static void processFrame() { 
     747                incrementSlices(); 
     748                imp.unlock(); 
     749                bp.setThreshold(25, 255, 1); 
     750                IJ.run("Analyze Particles...", 
     751                                "size=0-Infinity circularity=0.00-1.00 show=Nothing display clear"); 
     752                rt = Analyzer.getResultsTable(); 
     753                double totalArea=0, totalIntensity=0; 
     754                for (int j=0; j<rt.getCounter(); j++) { 
     755                        double jArea = rt.getValue("Area", j); 
     756                        totalArea += jArea; 
     757                        totalIntensity += (rt.getValue("Mean", j))*jArea; 
     758                } 
     759                if (totalArea > maxArea) maxArea = totalArea; 
     760                if (totalArea < minArea) minArea = totalArea; 
     761                if (totalIntensity > maxIntensity) maxIntensity = totalIntensity; 
     762                if (totalIntensity < minIntensity) minIntensity = totalIntensity; 
     763                areaValues.add(totalArea); 
     764                intensityValues.add(totalIntensity); 
     765                cellFrameV.add(nSlices); 
     766 
     767                sliceBegin.ensureCapacity(2*nSlices); 
     768                sliceEnd.ensureCapacity(2*nSlices); 
     769                sliceBegin.add(nSlices); 
     770                sliceEnd.add(nSlices); 
     771                System.out.println("############: sliceBegin looks like "); 
     772                for (int i=0; i<sliceBegin.size(); i++) { 
     773                        System.out.println(sliceBegin.get(i)); 
     774                } 
     775        } 
     776 
     777        private static double getMinX() { 
     778                double areaRange = (maxArea - minArea);///pixelMicronSquared; 
     779 
     780                if (minX !=0) return minX; 
     781                switch (xAxis) { 
     782                case AREA_AXIS: 
     783                        return (minArea - 0.05*areaRange); 
     784                case INTENSITY_AXIS: 
     785                        return MIN_INTENSITY; 
     786                default: 
     787                        return (minArea - 0.05*areaRange); 
     788                } 
     789        } 
     790 
     791        private static double getMaxX() { 
     792                double areaRange = (maxArea - minArea);///pixelMicronSquared; 
     793 
     794                if (maxX !=0) return maxX; 
     795                switch (xAxis) { 
     796                case AREA_AXIS: 
     797                        return (maxArea+0.05*areaRange); 
     798                case INTENSITY_AXIS: 
     799                        return MAX_INTENSITY; 
     800                default: 
     801                        return (maxArea+0.05*areaRange); 
     802                } 
     803        } 
     804 
     805        private static double getMinY() { 
     806                double areaRange = (maxArea - minArea);///pixelMicronSquared; 
     807                double retval; 
     808 
     809                if (minY !=0) return minY; 
     810                switch(yAxis) { 
     811                case AREA_AXIS: 
     812                        retval = (minArea - 0.05*areaRange); 
     813                        break; 
     814                case INTENSITY_AXIS: 
     815                        retval = MIN_INTENSITY; 
     816                        break; 
     817                default: 
     818                        retval = (minArea - 0.05*areaRange); 
     819                        break; 
     820                } 
     821 
     822                if (b_logY) { 
     823                        if (retval < 0) { 
     824                                debug("getMinY() returning 0 (in log case)"); 
     825                                return 0; 
     826                        } 
     827                        return Math.log(retval); 
     828                } 
     829                return retval; 
     830        } 
     831 
     832        private static double getMaxY() { 
     833                double areaRange = (maxArea - minArea);///pixelMicronSquared; 
     834                double retval; 
     835 
     836                if (maxY !=0) return maxY; 
     837                switch (yAxis) { 
     838                case AREA_AXIS: 
     839                        retval = (maxArea+0.05*areaRange); 
     840                        break; 
     841                case INTENSITY_AXIS: 
     842                        retval = MAX_INTENSITY; 
     843                        break; 
     844                default: 
     845                        retval = (maxArea+0.05*areaRange); 
     846                        break; 
     847                } 
     848 
     849                if (b_logY) { 
     850                        if (retval < 0) return 0; 
     851                        return Math.log(retval); 
     852                } 
     853                return retval; 
     854        } 
     855 
     856        //public static void oldupdateGraph() { 
     857        //  //1.55^2 from the pixels/micron value: 
     858        //  double areaRange = (maxArea - minArea)/pixelMicronSquared; 
     859        //  try { 
     860        //    areaMap.setRange(minArea/pixelMicronSquared - 0.05*areaRange, 
     861        //      maxArea/pixelMicronSquared+0.05*areaRange); 
     862        //    data_ref.setData(newGetData(nSlices, true, intensity, fn)); 
     863        //    display.addReference(data_ref); 
     864        //  } 
     865        //  catch (VisADException e) { 
     866        //    IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
     867        //  } 
     868        //  catch (RemoteException re) { 
     869        //    IJ.log("Remote Exception: "+re.getMessage()); 
     870        //  } 
     871        //} 
     872 
     873        public static void updateGraph() { 
     874                try { 
     875                        xMap.setRange(getMinX(), getMaxX()); 
     876                        yMap.setRange(getMinY(), getMaxY()); 
     877                        data_ref.setData(newestGetData(nSlices, true, xType, fn)); 
     878                        //display.addReference(data_ref); 
     879                        display.reDisplayAll(); // Replacing above line with this 
     880                } 
     881                catch (VisADException e) { 
     882                        IJ.log("VisAD Exception in updateGraph: "+e.getMessage()); 
     883                } 
     884                catch (RemoteException re) { 
     885                        IJ.log("Remote Exception: "+re.getMessage()); 
     886                } 
     887        } 
     888 
     889        public static FlatField newestGetData(int slice, boolean cumul, 
     890                        RealType x, FunctionType funcType) 
     891        { 
     892                //slice is NOT zero-indexed. 
     893                double[] xArray, yArray; 
     894                int beginSlice=0, endSlice=slice-1; 
     895                if (!cumul) beginSlice = slice-1; 
     896                int beginIndex = Integer.MAX_VALUE; 
     897                int endIndex = Integer.MIN_VALUE; 
     898                int numParticles=0; 
     899                for (int i=beginSlice; i<=endSlice; i++) { 
     900                        if (slices.get(i).hasParticles) { 
     901                                if (slices.get(i).begin < beginIndex) beginIndex = slices.get(i).begin; 
     902                                if (slices.get(i).end > endIndex) endIndex = slices.get(i).end; 
     903                                numParticles += (slices.get(i).end - slices.get(i).begin + 1); 
     904                        } 
     905                } 
     906 
     907                //System.out.println("beginIndex:"+beginIndex+ 
     908                //  " endIndex:"+endIndex+" numParticles:"+numParticles); 
     909 
     910                if (numParticles == 0) return null; 
     911 
     912                double minXGraph = getMinX(), maxXGraph = getMaxX(); 
     913                double minYGraph = getMinY(), maxYGraph = getMaxY(); 
     914 
     915                double[] newxArray = new double[numParticles]; 
     916                double[] newyArray = new double[numParticles]; 
     917                int arrayindex = 0; 
     918 
     919                for (int i=beginIndex; i<=endIndex; i++) { 
     920                        if (particles.get(i).getStatus()) { 
     921                                boolean xActive = true, yActive = true; 
     922                                double xValue=0, yValue=0; 
     923                                switch(xAxis) { 
     924                                case INTENSITY_AXIS: 
     925                                        xValue = particles.get(i).getMeanIntensity(); 
     926                                        if (xValue < minXGraph || xValue > maxXGraph) xActive = false; 
     927                                        break; 
     928                                case AREA_AXIS: 
     929                                        xValue = particles.get(i).getMicronArea(); 
     930                                        if (xValue < minXGraph || xValue > maxXGraph) xActive = false; 
     931                                        break; 
     932                                } 
     933                                switch(yAxis) { 
     934                                case INTENSITY_AXIS: 
     935                                        yValue = particles.get(i).getMeanIntensity(); 
     936                                        yValue = (b_logY ? Math.log(yValue) : yValue); 
     937                                        if (yValue < minYGraph || yValue > maxYGraph) yActive = false; 
     938                                        break; 
     939                                case AREA_AXIS: 
     940                                        yValue = particles.get(i).getMicronArea(); 
     941                                        yValue = (b_logY ? Math.log(yValue) : yValue); 
     942                                        if (yValue < minYGraph || yValue > maxYGraph) yActive = false; 
     943                                        break; 
     944                                } 
     945                                if (xActive && yActive) { 
     946                                        newxArray[arrayindex] = xValue; 
     947                                        newyArray[arrayindex] = yValue; 
     948                                        arrayindex++; 
     949                                } 
     950                        } 
     951                } 
     952 
     953                xArray = new double[arrayindex]; 
     954                yArray = new double[arrayindex]; 
     955                for (int i=0; i<arrayindex; i++) { 
     956                        xArray[i] = newxArray[i]; 
     957                        yArray[i] = newyArray[i]; 
     958                } 
     959 
     960                /* Old code 
    880961    xArray = new double[numParticles]; 
    881962    yArray = new double[numParticles]; 
     
    899980      } 
    900981    } 
    901     */ 
    902     //for (int i=0; i<xArray.length; i++) { 
    903     //  debug("Now plotting "+Double.toString(xArray[i]) + 
    904     //    " " + Double.toString(yArray[i])); 
    905     //} 
    906  
    907     List1DDoubleSet xSet; 
    908     FlatField ff=null; 
    909     if (xArray.length > 0) try { 
    910       xSet = new List1DDoubleSet(xArray, x, null, null); 
    911       ff = new FlatField(funcType, xSet); 
    912       double[][] ff_vals = new double[1][xArray.length]; 
    913       ff_vals[0] = yArray; 
    914       ff.setSamples(ff_vals); 
    915     } 
    916     catch (VisADException e) { 
    917       IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
    918     } 
    919     catch (RemoteException re) { 
    920       IJ.log("Remote Exception: "+re.getMessage()); 
    921     } 
    922     return ff; 
    923   } 
    924  
    925   public static FlatField newGetData(int slice, 
    926     boolean cumul, RealType x, FunctionType funcType) 
    927   { 
    928     //slice is NOT zero-indexed. 
    929     double[] xArray, yArray; 
    930     int beginIndex=0, endIndex; 
    931     if (!cumul) beginIndex = slice-1; 
    932     endIndex = slice-1; 
    933     xArray = new double[endIndex - beginIndex + 1]; 
    934     yArray = new double[endIndex - beginIndex + 1]; 
    935     for (int i=beginIndex; i<=endIndex; i++) { 
    936       //intensityValues.get(i); 
    937       xArray[i-beginIndex] = XAxisValues.get(i); 
    938       //areaValues.get(i)/pixelMicronSquared; 
    939       yArray[i-beginIndex] = YAxisValues.get(i); 
    940     } 
    941     System.out.println("Plotting for slices between indices "+ 
    942       beginIndex+ " and "+endIndex); 
    943     //printVector(XAxisValues); 
    944     //System.out.println("--"); 
    945     //printVector(YAxisValues); 
    946     for (int i=beginIndex; i<=endIndex; i++) { 
    947       IJ.log("Now plotting "+Double.toString(xArray[i-beginIndex]) + 
    948         " " + Double.toString(yArray[i-beginIndex])); 
    949     } 
    950     List1DDoubleSet xSet; 
    951     FlatField ff=null; 
    952     if (endIndex >= beginIndex) try { 
    953       xSet = new List1DDoubleSet(xArray, x, null, null); 
    954       ff = new FlatField(funcType, xSet); 
    955       double[][] ff_vals = new double[1][xArray.length]; 
    956       ff_vals[0] = yArray; 
    957       ff.setSamples(ff_vals); 
    958     } 
    959     catch (VisADException e) { 
    960       IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
    961     } 
    962     catch (RemoteException re) { 
    963       IJ.log("Remote Exception: "+re.getMessage()); 
    964     } 
    965     return ff; 
    966   } 
    967  
    968   public static FlatField getData(int slice, 
    969     boolean cumul, RealType x, FunctionType funcType) 
    970   { 
    971     double[] xArray, yArray; 
    972     int beginIndex=0, endIndex; 
    973     if (!cumul) beginIndex = sliceBegin.get(slice); 
    974     endIndex = sliceEnd.get(slice); 
    975     xArray = new double[endIndex - beginIndex + 1]; 
    976     yArray = new double[endIndex - beginIndex + 1]; 
    977     IJ.log("In getData, begin and end indices are "+ 
    978       beginIndex+ " and "+endIndex); 
    979     for (int i=beginIndex; i<=endIndex; i++) { 
    980       //IJ.log("Assigning values in the x and y arrays"); 
    981       xArray[i-beginIndex] = intensityValues.elementAt(i); 
    982       yArray[i-beginIndex] = areaValues.elementAt(i); 
    983     } 
    984     IJ.log("Done assigning"); 
    985     for (int i=beginIndex; i<=endIndex; i++) { 
    986       IJ.log(Double.toString(xArray[i-beginIndex]) + 
    987         " " + Double.toString(yArray[i-beginIndex])); 
    988     } 
    989     List1DDoubleSet intensitySet; 
    990     FlatField ff=null; 
    991     if (endIndex >= beginIndex) { 
    992       try { 
    993         intensitySet = new List1DDoubleSet(xArray, x, null, null); 
    994         ff = new FlatField(funcType, intensitySet); 
    995         double[][] ff_vals = new double[1][xArray.length]; 
    996         ff_vals[0] = yArray; 
    997         ff.setSamples(ff_vals); 
    998       } 
    999       catch (VisADException e) {IJ.log("VisAD Exception: "+e.getMessage());} 
    1000       catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
    1001     } 
    1002     return ff; 
    1003   } 
    1004  
    1005   public static void saveValues() throws IOException { 
    1006     saveValues("values"+s_Date.substring(0,9)); 
    1007   } 
    1008  
    1009   public static void saveValues(String filename) throws IOException { 
    1010     BufferedWriter bw = new BufferedWriter(new FileWriter(filename)); 
    1011     bw.write("Area (micron^2)\t\t(pixel^2)\t\tIntensity\t\tFrame\t\tLast"); 
    1012     bw.newLine(); 
    1013     bw.newLine(); 
    1014     System.out.println("Particles size is "+particles.size()); 
    1015     for (Particle p : particles) { 
    1016       bw.write(p.getMicronArea()+"\t\t"+ 
    1017         p.getPixelArea()+"\t\t"+ 
    1018         p.getMeanIntensity()+"\t\t"+ 
    1019         p.getSliceNum()+"\t\t"+ 
    1020         // NB: The same particle across multiple timepoints will be labeled 
    1021         // with Last=no until the final position of that particle, which will 
    1022         // be labeled Last=yes. 
    1023         (p.getStatus() ? "no" : "yes")); 
    1024       bw.newLine(); 
    1025     } 
    1026     bw.flush(); 
    1027     bw.close(); 
    1028   } 
    1029  
    1030   public static void showParticles(boolean val) { 
    1031     showParticles = val; 
    1032     if (val) Detector.impParticles.show(); 
    1033     else Detector.impParticles.hide(); 
    1034   } 
    1035  
    1036   public static void processFile(String filename) throws IOException { 
    1037     ImagePlus imagePlus = IJ.openImage(filename); 
    1038     ImageStack imageStack = imagePlus.getStack(); // TODO: handle exception 
    1039     int size = imagePlus.getWidth(); 
    1040  
    1041     double PixelsPerMicron = Double.valueOf(IJ.getString( 
    1042       "Please enter the pixels/micron value for this analysis", "0.1")); 
    1043     pixelMicronSquared = PixelsPerMicron*PixelsPerMicron; 
    1044  
    1045     // Close the other open windows 
    1046     if (frame != null) frame.dispose(); 
    1047     imagePlus.close(); 
    1048  
    1049     init(size, size, PixelsPerMicron); 
    1050     showParticles(true); 
    1051     for (int i=1; i<=imageStack.getSize(); i++) { 
    1052       byte[] imageData = (byte[]) imageStack.getPixels(i); 
    1053       incrementSlices(); 
    1054       showImage(size, size, imageData); 
    1055       newestProcessFrame(i); 
    1056       updateGraph(); 
    1057     } 
    1058  
    1059     saveValues(filename+".values"); 
    1060   } 
    1061  
    1062   public static void printVector(Vector<Double> v) { 
    1063     for (int i=0; i<v.size(); i++) { 
    1064       double dtemp = v.get(i); 
    1065       System.out.println(dtemp); 
    1066     } 
    1067   } 
    1068  
    1069   private static String flattenVector(Vector<Double> v) { 
    1070     String retval = ""; 
    1071     for (int i=0; i<v.size(); i++) { 
    1072       retval += v.get(i)+"\n"; 
    1073     } 
    1074     return retval; 
    1075   } 
    1076  
    1077   public static void main(String[] args) throws IOException { 
    1078     String filename = ""; 
    1079     if (args.length > 0) filename = args[0]; 
    1080     else { 
    1081       String wd = System.getProperty("user.dir"); 
    1082       JFileChooser fc = new JFileChooser(wd); 
    1083       int rc = fc.showDialog(null, "Select Data File"); 
    1084       if (rc == JFileChooser.APPROVE_OPTION) { 
    1085         File file = fc.getSelectedFile(); 
    1086         filename = file.getAbsolutePath(); 
    1087       } 
    1088       else { 
    1089         System.out.println("File chooser cancel button clicked"); 
    1090         return; 
    1091       } 
    1092     } 
    1093     intensityThreshold = Integer.valueOf(IJ.getString( 
    1094       "Please enter the intensity threshold for this analysis", "30")); 
    1095     areaThresholdInPixels = Integer.valueOf(IJ.getString( 
    1096       "Please enter the area threshold in pixels", "100")); 
    1097     processFile(filename); 
    1098     System.out.println("Done. Press Ctrl-C to exit"); 
    1099   } 
    1100  
    1101   private static void debug(String msg) { 
    1102     if (debug) System.out.println("FlowCytometry: " + msg); 
    1103   } 
    1104  
    1105   public static void setLogY(boolean b_logy) { 
    1106     b_logY = b_logy; 
    1107   } 
    1108  
    1109   public static void closeAllWindows() { 
    1110     ij.quit(); 
    1111     frame.dispose(); 
    1112   } 
     982                */ 
     983                //for (int i=0; i<xArray.length; i++) { 
     984                //  debug("Now plotting "+Double.toString(xArray[i]) + 
     985                //    " " + Double.toString(yArray[i])); 
     986                //} 
     987 
     988                List1DDoubleSet xSet; 
     989                FlatField ff=null; 
     990                if (xArray.length > 0) try { 
     991                        xSet = new List1DDoubleSet(xArray, x, null, null); 
     992                        ff = new FlatField(funcType, xSet); 
     993                        double[][] ff_vals = new double[1][xArray.length]; 
     994                        ff_vals[0] = yArray; 
     995                        ff.setSamples(ff_vals); 
     996                } 
     997                catch (VisADException e) { 
     998                        IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
     999                } 
     1000                catch (RemoteException re) { 
     1001                        IJ.log("Remote Exception: "+re.getMessage()); 
     1002                } 
     1003                return ff; 
     1004        } 
     1005 
     1006        public static FlatField newGetData(int slice, 
     1007                        boolean cumul, RealType x, FunctionType funcType) 
     1008        { 
     1009                //slice is NOT zero-indexed. 
     1010                double[] xArray, yArray; 
     1011                int beginIndex=0, endIndex; 
     1012                if (!cumul) beginIndex = slice-1; 
     1013                endIndex = slice-1; 
     1014                xArray = new double[endIndex - beginIndex + 1]; 
     1015                yArray = new double[endIndex - beginIndex + 1]; 
     1016                for (int i=beginIndex; i<=endIndex; i++) { 
     1017                        //intensityValues.get(i); 
     1018                        xArray[i-beginIndex] = XAxisValues.get(i); 
     1019                        //areaValues.get(i)/pixelMicronSquared; 
     1020                        yArray[i-beginIndex] = YAxisValues.get(i); 
     1021                } 
     1022                System.out.println("Plotting for slices between indices "+ 
     1023                                beginIndex+ " and "+endIndex); 
     1024                //printVector(XAxisValues); 
     1025                //System.out.println("--"); 
     1026                //printVector(YAxisValues); 
     1027                for (int i=beginIndex; i<=endIndex; i++) { 
     1028                        IJ.log("Now plotting "+Double.toString(xArray[i-beginIndex]) + 
     1029                                        " " + Double.toString(yArray[i-beginIndex])); 
     1030                } 
     1031                List1DDoubleSet xSet; 
     1032                FlatField ff=null; 
     1033                if (endIndex >= beginIndex) try { 
     1034                        xSet = new List1DDoubleSet(xArray, x, null, null); 
     1035                        ff = new FlatField(funcType, xSet); 
     1036                        double[][] ff_vals = new double[1][xArray.length]; 
     1037                        ff_vals[0] = yArray; 
     1038                        ff.setSamples(ff_vals); 
     1039                } 
     1040                catch (VisADException e) { 
     1041                        IJ.log("VisAD Exception in newGetData: "+e.getMessage()); 
     1042                } 
     1043                catch (RemoteException re) { 
     1044                        IJ.log("Remote Exception: "+re.getMessage()); 
     1045                } 
     1046                return ff; 
     1047        } 
     1048 
     1049        public static FlatField getData(int slice, 
     1050                        boolean cumul, RealType x, FunctionType funcType) 
     1051        { 
     1052                double[] xArray, yArray; 
     1053                int beginIndex=0, endIndex; 
     1054                if (!cumul) beginIndex = sliceBegin.get(slice); 
     1055                endIndex = sliceEnd.get(slice); 
     1056                xArray = new double[endIndex - beginIndex + 1]; 
     1057                yArray = new double[endIndex - beginIndex + 1]; 
     1058                IJ.log("In getData, begin and end indices are "+ 
     1059                                beginIndex+ " and "+endIndex); 
     1060                for (int i=beginIndex; i<=endIndex; i++) { 
     1061                        //IJ.log("Assigning values in the x and y arrays"); 
     1062                        xArray[i-beginIndex] = intensityValues.elementAt(i); 
     1063                        yArray[i-beginIndex] = areaValues.elementAt(i); 
     1064                } 
     1065                IJ.log("Done assigning"); 
     1066                for (int i=beginIndex; i<=endIndex; i++) { 
     1067                        IJ.log(Double.toString(xArray[i-beginIndex]) + 
     1068                                        " " + Double.toString(yArray[i-beginIndex])); 
     1069                } 
     1070                List1DDoubleSet intensitySet; 
     1071                FlatField ff=null; 
     1072                if (endIndex >= beginIndex) { 
     1073                        try { 
     1074                                intensitySet = new List1DDoubleSet(xArray, x, null, null); 
     1075                                ff = new FlatField(funcType, intensitySet); 
     1076                                double[][] ff_vals = new double[1][xArray.length]; 
     1077                                ff_vals[0] = yArray; 
     1078                                ff.setSamples(ff_vals); 
     1079                        } 
     1080                        catch (VisADException e) {IJ.log("VisAD Exception: "+e.getMessage());} 
     1081                        catch (RemoteException re) {IJ.log("Remote Exception: "+re.getMessage());} 
     1082                } 
     1083                return ff; 
     1084        } 
     1085 
     1086        public static void saveValues() throws IOException { 
     1087                saveValues("values"+s_Date.substring(0,9)); 
     1088        } 
     1089 
     1090        public static void saveValues(String filename) throws IOException { 
     1091                BufferedWriter bw = new BufferedWriter(new FileWriter(filename)); 
     1092                bw.write("Area (micron^2)\t\t(pixel^2)\t\tIntensity\t\tFrame\t\tLast"); 
     1093                bw.newLine(); 
     1094                bw.newLine(); 
     1095                System.out.println("Particles size is "+particles.size()); 
     1096                for (Particle p : particles) { 
     1097                        bw.write(p.getMicronArea()+"\t\t"+ 
     1098                                        p.getPixelArea()+"\t\t"+ 
     1099                                        p.getMeanIntensity()+"\t\t"+ 
     1100                                        p.getSliceNum()+"\t\t"+ 
     1101                                        // NB: The same particle across multiple timepoints will be labeled 
     1102                                        // with Last=no until the final position of that particle, which will 
     1103                                        // be labeled Last=yes. 
     1104                                        (p.getStatus() ? "no" : "yes")); 
     1105                        bw.newLine(); 
     1106                } 
     1107                bw.flush(); 
     1108                bw.close(); 
     1109        } 
     1110 
     1111        public static void showParticles(boolean val) { 
     1112                showParticles = val; 
     1113                if (val) Detector.impParticles.show(); 
     1114                else Detector.impParticles.hide(); 
     1115        } 
     1116 
     1117        public static void processFile(String filename) throws IOException { 
     1118                ImagePlus imagePlus = IJ.openImage(filename); 
     1119                ImageStack imageStack = imagePlus.getStack(); // TODO: handle exception 
     1120                int size = imagePlus.getWidth(); 
     1121 
     1122                double PixelsPerMicron = Double.valueOf(IJ.getString( 
     1123                                "Please enter the pixels/micron value for this analysis", "0.1")); 
     1124                pixelMicronSquared = PixelsPerMicron*PixelsPerMicron; 
     1125 
     1126                // Close the other open windows 
     1127                if (frame != null) frame.dispose(); 
     1128                imagePlus.close(); 
     1129 
     1130                init(size, size, PixelsPerMicron); 
     1131                showParticles(true); 
     1132                for (int i=1; i<=imageStack.getSize(); i++) { 
     1133                        byte[] imageData = (byte[]) imageStack.getPixels(i); 
     1134                        incrementSlices(); 
     1135                        showImage(size, size, imageData); 
     1136                        newestProcessFrame(i); 
     1137                        updateGraph(); 
     1138                } 
     1139 
     1140                saveValues(filename+".values"); 
     1141        } 
     1142 
     1143        public static void printVector(Vector<Double> v) { 
     1144                for (int i=0; i<v.size(); i++) { 
     1145                        double dtemp = v.get(i); 
     1146                        System.out.println(dtemp); 
     1147                } 
     1148        } 
     1149 
     1150        private static String flattenVector(Vector<Double> v) { 
     1151                String retval = ""; 
     1152                for (int i=0; i<v.size(); i++) { 
     1153                        retval += v.get(i)+"\n"; 
     1154                } 
     1155                return retval; 
     1156        } 
     1157 
     1158        public static void main(String[] args) throws IOException { 
     1159                String filename = ""; 
     1160                if (args.length > 0) filename = args[0]; 
     1161                else { 
     1162                        String wd = System.getProperty("user.dir"); 
     1163                        JFileChooser fc = new JFileChooser(wd); 
     1164                        int rc = fc.showDialog(null, "Select Data File"); 
     1165                        if (rc == JFileChooser.APPROVE_OPTION) { 
     1166                                File file = fc.getSelectedFile(); 
     1167                                filename = file.getAbsolutePath(); 
     1168                        } 
     1169                        else { 
     1170                                System.out.println("File chooser cancel button clicked"); 
     1171                                return; 
     1172                        } 
     1173                } 
     1174                intensityThreshold = Integer.valueOf(IJ.getString( 
     1175                                "Please enter the intensity threshold for this analysis", "30")); 
     1176                areaThresholdInPixels = Integer.valueOf(IJ.getString( 
     1177                                "Please enter the area threshold in pixels", "100")); 
     1178                processFile(filename); 
     1179                System.out.println("Done. Press Ctrl-C to exit"); 
     1180        } 
     1181 
     1182        private static void debug(String msg) { 
     1183                if (debug) System.out.println("FlowCytometry: " + msg); 
     1184        } 
     1185 
     1186        public static void setLogY(boolean b_logy) { 
     1187                b_logY = b_logy; 
     1188        } 
     1189 
     1190        public static void closeAllWindows() { 
     1191                ij.quit(); 
     1192                frame.dispose(); 
     1193        } 
    11131194 
    11141195} 
Note: See TracChangeset for help on using the changeset viewer.