Changeset 7112


Ignore:
Timestamp:
10/22/10 22:56:46 (9 years ago)
Author:
aivar
Message:

Added main loop that does fits based on UI input. Gets and sets parameters in UI.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/maven/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7108 r7112  
    102102 * @author Aivar Grislis grislis at wisc.edu 
    103103 */ 
    104 public class SLIMProcessor <T extends RealType<T>> implements MouseListener { 
     104public class SLIMProcessor <T extends RealType<T>> { 
    105105    private static final String X = "X"; 
    106106    private static final String Y = "Y"; 
     
    124124    private static final Character SUB_3  = '\u2083'; 
    125125 
     126    private static final double[] DEFAULT_SINGLE_EXP_PARAMS = { 5000.0, 0.005, 0.5 }; 
     127    private static final double[] DEFAULT_DOUBLE_EXP_PARAMS = { 0.0 }; 
     128    private static final double[] DEFAULT_TRIPLE_EXP_PARAMS = { 0.0 }; 
     129 
    126130    private Object m_synchFit = new Object(); 
    127131    private volatile boolean m_quit; 
     
    201205        boolean success = false; 
    202206 
    203         if (newLoadData(image)) { 
    204             // create a grayscale image from the data 
    205             createGlobalGrayScale(); 
    206              
     207        if (newLoadData(image)) {             
    207208            // show the UI; do fits 
    208             final IUserInterfacePanel uiPanel = new UserInterfacePanel(true); 
     209            IUserInterfacePanel uiPanel = new UserInterfacePanel(false); // using lambda 
     210            uiPanel.setX(0); 
     211            uiPanel.setY(0); 
     212            uiPanel.setStart(0); 
     213            uiPanel.setStop(m_timeBins - 1); 
     214            uiPanel.setThreshold(100); 
     215            uiPanel.setFunctionParameters(0, DEFAULT_SINGLE_EXP_PARAMS); 
     216            //uiPanel.setFunctionParameters(1, DEFAULT_DOUBLE_EXP_PARAMS); 
     217            //uiPanel.setFunctionParameters(2, DEFAULT_TRIPLE_EXP_PARAMS); 
    209218            uiPanel.setListener( 
    210219                    new IUserInterfacePanelListener() { 
    211220                        public void doFit() { 
    212221                            m_cancel = false; 
    213                             getFitSettings(uiPanel); 
    214                             fitData(); 
    215                             uiPanel.reset(); 
     222                            m_fitInProgress = true; 
    216223                        } 
    217224 
     
    220227                        } 
    221228 
     229                        public void quit() { 
     230                            m_quit = true; 
     231                        } 
     232 
    222233                    } 
    223234                ); 
    224  
    225  
    226             while (!m_quit) { 
    227                 try { 
    228                     Thread.sleep(1000); 
    229                 } 
    230                 catch (InterruptedException e) { 
    231  
    232                 } 
    233             } 
     235            uiPanel.getFrame().setLocationRelativeTo(null); 
     236            uiPanel.getFrame().setVisible(true); 
     237 
     238            // create a grayscale image from the data 
     239            createGlobalGrayScale("TITLE", uiPanel); 
     240 
     241            // loops infinitely; waits for UI 
     242            doFits(uiPanel); 
    234243        } 
    235244 
     
    287296     */ 
    288297    public void process(String arg) { 
    289         //IUserInterfacePanel uiPanel = new UserInterfacePanel(true); 
    290         //JPanel panel = uiPanel.getPanel(); 
    291          
    292298        m_channel = 0; //TODO s/b a JSlider that controls current channel 
    293299         
     
    307313         
    308314        if (success) { 
     315            // show the UI; do fits 
     316            IUserInterfacePanel uiPanel = new UserInterfacePanel(false); // using lambda 
     317            uiPanel.setX(0); 
     318            uiPanel.setY(0); 
     319            uiPanel.setStart(0); 
     320            uiPanel.setStop(m_timeBins - 1); 
     321            uiPanel.setThreshold(100); 
     322            uiPanel.setFunctionParameters(0, DEFAULT_SINGLE_EXP_PARAMS); 
     323            //uiPanel.setFunctionParameters(1, DEFAULT_DOUBLE_EXP_PARAMS); 
     324           // uiPanel.setFunctionParameters(2, DEFAULT_TRIPLE_EXP_PARAMS); 
     325            uiPanel.setListener( 
     326                new IUserInterfacePanelListener() { 
     327                    public void doFit() { 
     328                        m_cancel = false; 
     329                        m_fitInProgress = true; 
     330                    } 
     331 
     332                    public void cancelFit() { 
     333                        m_cancel = true; 
     334                    } 
     335 
     336                    public void quit() { 
     337                        m_quit = true; 
     338                    } 
     339 
     340                } 
     341            ); 
     342            uiPanel.getFrame().setLocationRelativeTo(null); 
     343            uiPanel.getFrame().setVisible(true); 
     344 
    309345            // create a grayscale image from the data 
    310             createGlobalGrayScale(); 
    311  
    312             // show the UI; do fits 
    313             final IUserInterfacePanel uiPanel = new UserInterfacePanel(true); 
    314             uiPanel.setListener( 
    315                     new IUserInterfacePanelListener() { 
    316                         public void doFit() { 
    317                             m_cancel = false; 
    318                             getFitSettings(uiPanel); 
    319                             fitData(); 
    320                             uiPanel.reset(); 
    321                         } 
    322  
    323                         public void cancelFit() { 
    324                             m_cancel = true; 
    325                         } 
    326  
    327                     } 
    328                 ); 
    329  
    330             while (!m_quit) { 
     346            createGlobalGrayScale("TITLE", uiPanel); 
     347 
     348            // loops infinitely; waits for UI 
     349            doFits(uiPanel); 
     350        } 
     351    } 
     352 
     353    /** 
     354     * Loops until quitting time and handles fit requests. 
     355     * Fitting is driven by a button on the UI panel. 
     356     * 
     357     * @param uiPanel 
     358     */ 
     359    private void doFits(IUserInterfacePanel uiPanel) { 
     360        while (!m_quit) { 
     361            while (!m_fitInProgress) { 
    331362                try { 
    332363                    Thread.sleep(1000); 
    333364                } 
    334365                catch (InterruptedException e) { 
    335                      
    336                 } 
    337             } 
    338  
    339  
    340  
    341  
    342  
    343  
    344            /* while (true) { 
    345                 // ask what kind fo fit 
    346                 if (!showFitDialog()) { 
    347                     break; 
    348                 } 
    349                 // ask for fit parameters 
    350                 if (!showFitParamsDialog()) { 
    351                     break; 
    352                 } 
    353                 fitData(); 
    354             } */ 
     366 
     367                } 
     368                if (m_quit) { 
     369                    return; 
     370                } 
     371            } 
     372            // get settings of requested fit 
     373            getFitSettings(uiPanel); 
     374 
     375            fitData(uiPanel); //TODO currently also diddles with m_fitInProgress; uses synch block 
     376 
     377            m_fitInProgress = false; 
     378            uiPanel.reset(); 
    355379        } 
    356380    } 
     
    716740     * image for the data. 
    717741     * 
     742     * @param uiPanel associated UI panel 
    718743     * @return whether successful 
    719744     */ 
    720     private boolean createGlobalGrayScale() { 
     745    private boolean createGlobalGrayScale(String name, final IUserInterfacePanel uiPanel) { 
    721746        int[][] pixels = new int[m_width][m_height]; 
    722747 
     
    738763 
    739764        ImageProcessor imageProcessor = new ByteProcessor(m_width, m_height); 
    740         ImagePlus imagePlus = new ImagePlus("Global GrayScale", imageProcessor); 
     765        ImagePlus imagePlus = new ImagePlus(name + " GrayScale", imageProcessor); 
    741766        byte[] outPixels = (byte[]) imageProcessor.getPixels(); 
    742767        for (int x = 0; x < m_width; ++x) { 
     
    752777        ImageWindow imageWindow = imagePlus.getWindow(); 
    753778        m_grayscaleCanvas = imageWindow.getCanvas(); 
    754         m_grayscaleCanvas.addMouseListener(this); 
     779        m_grayscaleCanvas.addMouseListener( 
     780            new MouseListener() { 
     781                public void mousePressed(MouseEvent e) {} 
     782                public void mouseExited(MouseEvent e) {} 
     783                public void mouseClicked(MouseEvent e) {} 
     784                public void mouseEntered(MouseEvent e) {} 
     785  
     786                public void mouseReleased(MouseEvent e) { 
     787                    // just ignore clicks during a fit 
     788                    if (!m_fitInProgress) { 
     789                        uiPanel.setX(e.getX()); 
     790                        uiPanel.setY(e.getY()); 
     791                        fitPixel(uiPanel, e.getX(), e.getY()); 
     792                    } 
     793                } 
     794            } 
     795        ); 
    755796        return true; 
    756797    } 
     
    762803     * @return 
    763804     */ 
    764     private boolean showFitDialog() { 
     805    private boolean XshowFitDialog() { 
    765806        NonBlockingGenericDialog dialog = new NonBlockingGenericDialog("Fit Type"); 
    766807        dialog.addChoice( 
     
    820861     * @return 
    821862     */ 
    822     private boolean showFitParamsDialog() { 
     863    private boolean XshowFitParamsDialog() { 
    823864        GenericDialog dialog = new GenericDialog("Fit Params"); 
    824865        if (FitRegion.POINT == m_region) { 
     
    10011042    } 
    10021043 
    1003     /** 
    1004      * MouseListener handler for button press. 
    1005      * Ignored. 
    1006      * 
    1007      * @param e 
    1008      */ 
    1009     public void mousePressed(MouseEvent e) { 
    1010     } 
    1011      
    1012     /** 
    1013      * MouseListener handler for mouse exit. 
    1014      * Ignored. 
    1015      * 
    1016      * @param e 
    1017      */ 
    1018     public void mouseExited(MouseEvent e) { 
    1019     } 
    1020      
    1021     /** 
    1022      * MouseListener handler for button click. 
    1023      * Ignored. 
    1024      * 
    1025      * @param e 
    1026      */ 
    1027     public void mouseClicked(MouseEvent e) { 
    1028     } 
    1029      
    1030     /** 
    1031      * MouseListener handler for mouse enter. 
    1032      * Ignored. 
    1033      * 
    1034      * @param e 
    1035      */ 
    1036     public void mouseEntered(MouseEvent e) { 
    1037     } 
    1038  
    1039  
    1040     /** 
    1041      * MouseListener handler for button release. 
    1042      * Clicking on a pixel triggers a fit. 
    1043      * 
    1044      * @param e 
    1045      */ 
    1046     public void mouseReleased(MouseEvent e) { 
    1047         // just ignore clicks during a fit 
    1048         System.out.println("mouseReleased " + e); 
    1049         if (!m_fitInProgress) { 
    1050             System.out.println("fit " + e.getX() + " " + e.getY()); 
    1051             fitPixel(e.getX(), e.getY()); 
    1052         } 
    1053      } 
    1054      
    1055     private void fitData() { 
    1056         System.out.println("FIT DATA"); 
     1044    private void fitData(IUserInterfacePanel uiPanel) { 
    10571045        // only one fit at a time 
    10581046        synchronized (m_synchFit) { 
     
    10631051                case SUMMED: 
    10641052                    // sum all pixels 
    1065                     fitSummed(); 
     1053                    fitSummed(uiPanel); 
    10661054                    break; 
    10671055                case ROI: 
    10681056                    // fit summed ROIs 
    1069                     fitROIs(); 
     1057                    fitROIs(uiPanel); 
    10701058                    break; 
    10711059                case POINT: 
    10721060                    // fit single pixel 
    1073                     fitPixel(m_x, m_y); 
     1061                    fitPixel(uiPanel, m_x, m_y); 
    10741062                    break; 
    10751063                case EACH: 
    10761064                    // fit every pixel 
    1077                     fitEachPixel(); 
     1065                    fitEachPixel(uiPanel); 
    10781066                    break; 
    10791067            } 
    1080 System.out.println("m_fitInProgress goes false"); 
    10811068            m_fitInProgress = false; 
    10821069        } 
     
    10861073     * Sums all pixels and fits the result. 
    10871074     */ 
    1088     private void fitSummed() { 
    1089         double params[] = getParams(); 
     1075    private void fitSummed(IUserInterfacePanel uiPanel) { 
     1076        double params[] = uiPanel.getParameters(); 
    10901077         
    10911078        // build the data 
     
    11191106        // do the fit 
    11201107        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1121         doFit(dataArray); 
    1122          
    1123         //TODO display results for summed? 
    1124         IJ.showMessage("Summed " + dataArray[0].getParams()[0] + " " + dataArray[0].getParams()[1] + " " + dataArray[0].getParams()[2]); 
    1125  
    1126         showDecayGraph(dataArray); 
    1127         saveParams(dataArray); 
     1108        doFit(uiPanel, dataArray); 
     1109 
     1110        // show decay and update UI parameters 
     1111        showDecayGraph(uiPanel, dataArray); 
     1112        uiPanel.setParameters(dataArray[0].getParams()); 
     1113        uiPanel.setChiSquare(dataArray[0].getChiSquare()); 
    11281114    } 
    11291115 
     
    11311117     * Sums and fits each ROI. 
    11321118     */ 
    1133     private void fitROIs() { 
    1134         double params[] = getParams(); 
     1119    private void fitROIs(IUserInterfacePanel uiPanel) { 
     1120        double params[] = uiPanel.getParameters(); 
    11351121         
    11361122        // build the data 
     
    11681154        // do the fit 
    11691155        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1170         doFit(dataArray); 
     1156        doFit(uiPanel, dataArray); 
    11711157         
    1172         showDecayGraph(dataArray); 
     1158        showDecayGraph(uiPanel, dataArray); 
    11731159         
    11741160        // show colorized lifetimes 
     
    11771163        int i = 0; 
    11781164        for (Roi roi: getRois()) { 
    1179             IJ.showMessage("Roi " + i + " " + dataArray[i].getParams()[0] + " " + dataArray[i].getParams()[1] + " " + dataArray[i].getParams()[2]); 
    11801165            double lifetime = dataArray[i++].getParams()[1]; 
    11811166            imageProcessor.setColor(lifetimeColorMap(MAXIMUM_LIFETIME, lifetime)); 
     
    11911176        } 
    11921177        imagePlus.show();   
    1193          
    1194         saveParams(dataArray); 
     1178 
     1179        // update UI parameters 
     1180        uiPanel.setParameters(dataArray[0].getParams()); 
     1181        uiPanel.setChiSquare(dataArray[0].getChiSquare()); //TODO what is the validity here of just choosing the first ROI?  How do we report multiple ROIs? 
    11951182    } 
    11961183 
     
    12011188     * @param y 
    12021189     */ 
    1203     private void fitPixel(int x, int y) { 
    1204         double params[] = getParams(); 
     1190    private void fitPixel(IUserInterfacePanel uiPanel, int x, int y) { 
     1191        double params[] = uiPanel.getParameters(); 
    12051192         
    12061193        // build the data 
     
    12231210        // do the fit 
    12241211        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1225         doFit(dataArray); 
     1212        doFit(uiPanel, dataArray); 
    12261213         
    1227         showDecayGraph(dataArray); 
    1228          
    1229         //TODO display results for single point? 
    1230         IJ.showMessage("Point A " + dataArray[0].getParams()[0] + " " + LAMBDA + " " + dataArray[0].getParams()[1] + " b " + dataArray[0].getParams()[2]); 
    1231          
    1232         saveParams(dataArray); 
     1214        showDecayGraph(uiPanel, dataArray); 
     1215 
     1216        // update UI parameters 
     1217        uiPanel.setParameters(dataArray[0].getParams()); 
     1218        uiPanel.setChiSquare(dataArray[0].getChiSquare()); 
    12331219    } 
    12341220  
     
    12401226     * Results of the fit go to VisAD for analysis. 
    12411227     */ 
    1242     private void fitEachPixel() { 
     1228    private void fitEachPixel(IUserInterfacePanel uiPanel) { 
    12431229        long start = System.nanoTime(); 
    12441230         
    1245         double params[] = getParams(); 
     1231        double params[] = uiPanel.getParameters(); 
    12461232         
    12471233        // build the data 
     
    12841270 
    12851271                    if (++pixelsToProcessCount >= PIXEL_COUNT) { 
    1286                         processPixels(dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
     1272                        processPixels(uiPanel, dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    12871273                        curveFitDataList.clear(); 
    12881274                        pixelList.clear(); 
     
    12921278            } 
    12931279            if (!m_cancel && 0 < pixelsToProcessCount) { 
    1294                 processPixels(dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
     1280                processPixels(uiPanel, dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    12951281            } 
    12961282        } 
     
    13651351            return; 
    13661352        } 
    1367         doFit(dataArray); 
     1353        doFit(uiPanel, dataArray); 
    13681354        //TODO save results 
    13691355 
     
    13801366     * @param pixels parallel list of rectangles with which to draw the fitted pixel 
    13811367     */ 
    1382     void processPixels(DataColorizer dataColorizer, int height, ICurveFitData data[], ChunkyPixel pixels[]) { 
    1383         doFit(data); 
     1368    void processPixels(IUserInterfacePanel uiPanel, DataColorizer dataColorizer, int height, ICurveFitData data[], ChunkyPixel pixels[]) { 
     1369        doFit(uiPanel, data); 
    13841370        //TODO save results 
    13851371 
     
    13901376 
    13911377            //TODO debugging: 
    1392             if (lifetime > 2 * m_param[1]) { 
    1393                 System.out.println("BAD FIT??? x " + pixel.getX() + " y " + pixel.getY() + " fitted lifetime " + lifetime); 
    1394             } 
     1378            //if (lifetime > 2 * m_param[1]) { 
     1379            //    System.out.println("BAD FIT??? x " + pixel.getX() + " y " + pixel.getY() + " fitted lifetime " + lifetime); 
     1380            //} 
    13951381 
    13961382            //TODO BUG: 
     
    15451531 
    15461532    /* 
    1547      * Helper function for the fit.  Initializes params array. 
    1548      *  
    1549      * @return initialized params array 
    1550      */ 
    1551     private double[] getParams() { 
    1552         // build the params 
    1553         double params[] = null; 
    1554         switch (m_function) { 
    1555             case SINGLE_EXPONENTIAL: 
    1556                 params = new double[3]; 
    1557                 params[0] = m_param[0]; 
    1558                 params[1] = m_param[1]; 
    1559                 params[2] = m_param[2]; 
    1560                 break; 
    1561             case DOUBLE_EXPONENTIAL: 
    1562                 params = new double[5]; 
    1563                 params[0] = m_param[0]; 
    1564                 params[1] = m_param[1]; 
    1565                 params[2] = m_param[2]; 
    1566                 params[3] = m_param[3]; 
    1567                 params[4] = m_param[4]; 
    1568                 break; 
    1569             case TRIPLE_EXPONENTIAL: 
    1570                 params = new double[7]; 
    1571                 params[0] = m_param[0]; 
    1572                 params[1] = m_param[1]; 
    1573                 params[2] = m_param[2]; 
    1574                 params[3] = m_param[3]; 
    1575                 params[4] = m_param[4]; 
    1576                 params[5] = m_param[5]; 
    1577                 params[6] = m_param[6]; 
    1578                 break; 
    1579             case STRETCHED_EXPONENTIAL: 
    1580                 System.out.println("NOT IMPLEMENTED YET"); 
    1581                 break; 
    1582         } 
    1583         return params; 
    1584     } 
    1585   
    1586     /* 
    15871533     * Helper function for the fit.  Does the actual fit. 
    15881534     *  
     
    15901536     */ 
    15911537    //TODO s/b a mechanism to add these curve fit libraries? 
    1592     private void doFit(ICurveFitData dataArray[]) { 
     1538    private void doFit(IUserInterfacePanel uiPanel, ICurveFitData dataArray[]) { 
    15931539        // do the fit 
    15941540        ICurveFitter curveFitter = null; 
    1595         switch (m_algorithm) { 
     1541        switch (uiPanel.getAlgorithm()) { 
    15961542            case JAOLHO: 
    15971543                curveFitter = new JaolhoCurveFitter(); 
     
    16241570        curveFitter.setXInc(m_timeRange); 
    16251571        curveFitter.setFree(m_free); 
    1626         int startBin = m_startBin + (256 * m_startX); 
    1627         curveFitter.fitData(dataArray, startBin, m_stopBin);         
     1572        curveFitter.fitData(dataArray, m_startBin, m_stopBin); 
    16281573    } 
    16291574 
     
    16331578     * @param dataArray array of fitted data 
    16341579     */ 
    1635     private void showDecayGraph(ICurveFitData dataArray[]) { 
     1580    private void showDecayGraph(final IUserInterfacePanel uiPanel, ICurveFitData dataArray[]) { 
    16361581        if (0 < dataArray.length) { 
    1637             //TODO need to be able to examine any fitted pixel; for now just show the last fitted pixel. // first! 
     1582            //TODO need to be able to examine any fitted pixel; for now just show the first.  // was last 
    16381583            DecayGraph decayGraph = new DecayGraph(m_startBin, m_stopBin, m_timeBins, m_timeRange, dataArray[0]); //dataArray.length - 1]); 
    1639             decayGraph.setStartStopListener(new MyListener()); 
     1584            decayGraph.setStartStopListener( 
     1585                new IStartStopListener() { 
     1586                    public void setStartStop(int start, int stop) { 
     1587                        uiPanel.setStart(start); 
     1588                        uiPanel.setStop(stop); 
     1589                    } 
     1590                } 
     1591            ); 
    16401592            JFrame frame = decayGraph.getFrame(); 
     1593            frame.setLocationRelativeTo(uiPanel.getFrame()); 
    16411594            frame.setVisible(true); 
    1642         } 
    1643          
    1644     } 
    1645  
    1646     /* 
    1647      * Helper function for the fit.  Saves params array. 
    1648      *  
    1649      * @param dataArray array of fitted data 
    1650      */ 
    1651     //TODO params are saved to the UI now 
    1652     private void saveParams(ICurveFitData dataArray[]) { 
    1653         double params[] = null; 
    1654         if (0 < dataArray.length) { 
    1655             params = dataArray[0].getParams(); 
    1656             switch (m_function) { 
    1657                 case SINGLE_EXPONENTIAL: 
    1658                     m_param[0] = params[0]; 
    1659                     m_param[1] = params[1]; 
    1660                     m_param[2] = params[2]; 
    1661                     break; 
    1662                 case DOUBLE_EXPONENTIAL: 
    1663                     m_param[0] = params[0]; 
    1664                     m_param[1] = params[1]; 
    1665                     m_param[2] = params[2]; 
    1666                     m_param[3] = params[3]; 
    1667                     m_param[4] = params[4]; 
    1668                     break; 
    1669                 case TRIPLE_EXPONENTIAL: 
    1670                     m_param[0] = params[0]; 
    1671                     m_param[1] = params[1]; 
    1672                     m_param[2] = params[2]; 
    1673                     m_param[3] = params[3]; 
    1674                     m_param[4] = params[4]; 
    1675                     m_param[5] = params[5]; 
    1676                     m_param[6] = params[6]; 
    1677                     break; 
    1678                 case STRETCHED_EXPONENTIAL: 
    1679                     System.out.println("Not implemented yet"); 
    1680                     break; 
    1681             } 
    1682         } 
    1683     } 
    1684      
    1685     /** 
    1686      * This routine does the fit, once all settings have 
    1687      * been specified. 
    1688      * 
    1689      * Note that fitting each pixel is a special case, which is 
    1690      * handled by fitEachPixel.  This routine therefore only 
    1691      * handles fitting a single set of data from a single pixel 
    1692      * or summed from all the pixels.  It can also sum the data 
    1693      * and fit by ROI. 
    1694      */ 
    1695     private void fitDataXX() { 
    1696         if (m_region.EACH == m_region) { 
    1697             fitEachPixel(); 
    1698             return; 
    1699         } 
    1700  
    1701         // build the params 
    1702         double params[] = null; 
    1703          switch (m_function) { 
    1704             case SINGLE_EXPONENTIAL: 
    1705                 params = new double[3]; 
    1706                 params[0] = m_param[0]; 
    1707                 params[1] = m_param[1]; 
    1708                 params[2] = m_param[2]; 
    1709                 break; 
    1710             case DOUBLE_EXPONENTIAL: 
    1711                 params = new double[5]; 
    1712                 params[0] = m_param[0]; 
    1713                 params[1] = m_param[1]; 
    1714                 params[2] = m_param[2]; 
    1715                 params[3] = m_param[3]; 
    1716                 params[4] = m_param[4]; 
    1717                 break; 
    1718             case TRIPLE_EXPONENTIAL: 
    1719                 params = new double[7]; 
    1720                 params[0] = m_param[0]; 
    1721                 params[1] = m_param[1]; 
    1722                 params[2] = m_param[2]; 
    1723                 params[3] = m_param[3]; 
    1724                 params[4] = m_param[4]; 
    1725                 params[5] = m_param[5]; 
    1726                 params[6] = m_param[6]; 
    1727                 break; 
    1728             case STRETCHED_EXPONENTIAL: 
    1729                 break; 
    1730          } 
    1731  
    1732         // build the data 
    1733         ArrayList<ICurveFitData> curveFitDataList = new ArrayList<ICurveFitData>(); 
    1734         ICurveFitData curveFitData; 
    1735         double yCount[]; 
    1736         double yFitted[]; 
    1737         switch (m_region) { 
    1738             case SUMMED: 
    1739                 // sum up all the photons 
    1740                 curveFitData = new CurveFitData(); 
    1741                 curveFitData.setParams(params); 
    1742                 yCount = new double[m_timeBins]; 
    1743                 for (int b = 0; b < m_timeBins; ++b) { 
    1744                     yCount[b] = 0.0; 
    1745                 } 
    1746                 int photons = 0; 
    1747                 for (int y = 0; y < m_height; ++y) { 
    1748                     for (int x = 0; x < m_width; ++x) { 
    1749                         for (int b = 0; b < m_timeBins; ++b) { 
    1750                             yCount[b] += m_data[0][y][x][b]; 
    1751                             photons += m_data[0][y][x][b]; 
    1752                         } 
    1753                     } 
    1754                 } 
    1755                 System.out.println("SUMMED photons " + photons); 
    1756                 curveFitData.setYCount(yCount); 
    1757                 yFitted = new double[m_timeBins]; 
    1758                 curveFitData.setYFitted(yFitted); 
    1759                 curveFitDataList.add(curveFitData); 
    1760                 break; 
    1761             case ROI: 
    1762                 int roiNumber = 0; 
    1763                 for (Roi roi: getRois()) { 
    1764                     ++roiNumber; 
    1765                     curveFitData = new CurveFitData(); 
    1766                     curveFitData.setParams(params.clone()); 
    1767                     yCount = new double[m_timeBins]; 
    1768                     for (int b = 0; b < m_timeBins; ++b) { 
    1769                         yCount[b] = 0.0; 
    1770                     } 
    1771                     Rectangle bounds = roi.getBounds(); 
    1772                     for (int x = 0; x < bounds.width; ++x) { 
    1773                         for (int y = 0; y < bounds.height; ++y) { 
    1774                             if (roi.contains(bounds.x + x, bounds.y + y)) { 
    1775                                 System.out.println("roi " + roiNumber + " x " + x + " Y " + y); 
    1776                                 for (int b = 0; b < m_timeBins; ++b) { 
    1777                                     yCount[b] += m_data[0][y][x][b]; 
    1778                                 } 
    1779                             } 
    1780                         } 
    1781                     } 
    1782                     curveFitData.setYCount(yCount); 
    1783                     yFitted = new double[m_timeBins]; 
    1784                     curveFitData.setYFitted(yFitted); 
    1785                     curveFitDataList.add(curveFitData); 
    1786                 } 
    1787                 break; 
    1788             case POINT: 
    1789                 curveFitData = new CurveFitData(); 
    1790                 curveFitData.setParams(params); 
    1791                 yCount = new double[m_timeBins]; 
    1792                 for (int b = 0; b < m_timeBins; ++b) { 
    1793                     yCount[b] = m_data[0][m_height - m_y - 1][m_x][b]; 
    1794                 } 
    1795                 curveFitData.setYCount(yCount); 
    1796                 yFitted = new double[m_timeBins]; 
    1797                 curveFitData.setYFitted(yFitted); 
    1798                 curveFitDataList.add(curveFitData); 
    1799                 break; 
    1800             case EACH: //TODO this is handled in fitEachPixel below 
    1801                 Roi[] rois = getRois(); 
    1802                 if (0 < rois.length) { 
    1803                     for (Roi roi: rois) { 
    1804                         Rectangle bounds = roi.getBounds(); 
    1805                         for (int x = 0; x < bounds.width; ++x) { 
    1806                             for (int y = 0; y < bounds.height; ++y) { 
    1807                                 if (roi.contains(bounds.x + x, bounds.y + y)) { 
    1808                                     curveFitData = new CurveFitData(); 
    1809                                     curveFitData.setParams(params.clone()); //TODO if you don't clone here each pixel fit uses results of previous fit to start 
    1810                                     yCount = new double[m_timeBins]; 
    1811                                     for (int b = 0; b < m_timeBins; ++b) { 
    1812                                         yCount[b] = m_data[0][y][x][b]; 
    1813                                     } 
    1814                                     curveFitData.setYCount(yCount); 
    1815                                     yFitted = new double[m_timeBins]; 
    1816                                     curveFitData.setYFitted(yFitted); 
    1817                                     curveFitDataList.add(curveFitData); 
    1818                                 } 
    1819                             } 
    1820                         } 
    1821                     } 
    1822                 } 
    1823                 else { 
    1824                     for (int y = 0; y < m_height; ++y) { 
    1825                         for (int x = 0; x < m_width; ++x) { 
    1826                             curveFitData = new CurveFitData(); 
    1827                             curveFitData.setParams(params.clone()); //TODO if you don't clone here each pixel fit uses results of previous fit to start 
    1828                             yCount = new double[m_timeBins]; 
    1829                             for (int b = 0; b < m_timeBins; ++b) { 
    1830                                 yCount[b] = m_data[0][y][x][b]; 
    1831                             } 
    1832                             curveFitData.setYCount(yCount); 
    1833                             yFitted = new double[m_timeBins]; 
    1834                             curveFitData.setYFitted(yFitted); 
    1835                             curveFitDataList.add(curveFitData); 
    1836                         } 
    1837                     } 
    1838                 } 
    1839                 break; 
    1840         } 
    1841         ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1842  
    1843         // do the fit 
    1844         ICurveFitter curveFitter = null; 
    1845         switch (m_algorithm) { 
    1846             case JAOLHO: 
    1847                 curveFitter = new JaolhoCurveFitter(); 
    1848                 break; 
    1849            /* case AKUTAN: 
    1850                 curveFitter = new AkutanCurveFitter(); 
    1851                 break; */ 
    1852             case BARBER_RLD: 
    1853                 curveFitter = new GrayCurveFitter(0); 
    1854                 break; 
    1855             case BARBER_LMA: 
    1856                 curveFitter = new GrayCurveFitter(1); 
    1857                 break; 
    1858             case MARKWARDT: 
    1859                 curveFitter = new MarkwardtCurveFitter(); 
    1860                 break; 
    1861             case BARBER2_RLD: 
    1862                 curveFitter = new GrayNRCurveFitter(0); 
    1863                 break; 
    1864             case BARBER2_LMA: 
    1865                 curveFitter = new GrayNRCurveFitter(1); 
    1866                 break; 
    1867             case SLIMCURVE_RLD: 
    1868                 curveFitter = new SLIMCurveFitter(0); 
    1869                 break; 
    1870             case SLIMCURVE_LMA: 
    1871                 curveFitter = new SLIMCurveFitter(1); 
    1872                 break; 
    1873         } 
    1874         curveFitter.setXInc(m_timeRange); 
    1875         curveFitter.setFree(m_free); 
    1876         int startBin = m_startBin + (256 * m_startX); 
    1877         curveFitter.fitData(dataArray, startBin, m_stopBin); 
    1878  
    1879         if (0 < dataArray.length) { 
    1880             //TODO need to be able to examine any fitted pixel; for now just show the last fitted pixel. // first! 
    1881             DecayGraph decayGraph = new DecayGraph(m_startBin, m_stopBin, m_timeBins, curveFitter.getXInc(), dataArray[0]); //dataArray.length - 1]); 
    1882             decayGraph.setStartStopListener(new MyListener()); 
    1883             JFrame frame = decayGraph.getFrame(); 
    1884             frame.setVisible(true); 
    1885         } 
    1886  
    1887         switch (m_region) { 
    1888             case SUMMED: 
    1889                 //TODO display results for summed? 
    1890                 IJ.showMessage("Summed " + dataArray[0].getParams()[0] + " " + dataArray[0].getParams()[1] + " " + dataArray[0].getParams()[2]); 
    1891                 break; 
    1892             case ROI: { 
    1893                 // show colorized lifetimes 
    1894                 ImageProcessor imageProcessor = new ColorProcessor(m_width, m_height); 
    1895                 ImagePlus imagePlus = new ImagePlus("Fitted Lifetimes", imageProcessor); 
    1896  
    1897                 int i = 0; 
    1898                 for (Roi roi: getRois()) { 
    1899                     IJ.showMessage("Roi " + i + " " + dataArray[i].getParams()[0] + " " + dataArray[i].getParams()[1] + " " + dataArray[i].getParams()[2]); 
    1900                     double lifetime = dataArray[i++].getParams()[1]; 
    1901                     imageProcessor.setColor(lifetimeColorMap(MAXIMUM_LIFETIME, lifetime)); 
    1902  
    1903                     Rectangle bounds = roi.getBounds(); 
    1904                     for (int x = 0; x < bounds.width; ++x) { 
    1905                         for (int y = 0; y < bounds.height; ++y) { 
    1906                             if (roi.contains(bounds.x + x, bounds.y + y)) { 
    1907                                 imageProcessor.drawPixel(bounds.x + x, bounds.y + y); 
    1908                             } 
    1909                         } 
    1910                     } 
    1911                 } 
    1912                 imagePlus.show(); 
    1913                 break; } 
    1914             case POINT: 
    1915                 //TODO display results for single point? 
    1916                 IJ.showMessage("Point A " + dataArray[0].getParams()[0] + " " + LAMBDA + " " + dataArray[0].getParams()[1] + " b " + dataArray[0].getParams()[2]); 
    1917                 break; 
    1918             case EACH: //TODO DEFUNCT CODE this is handled in fitEachPixel below 
    1919                 //TODO new version uses "chunky pixel effect" drawing. 
    1920                 // show colorized lifetimes 
    1921                 ImageProcessor imageProcessor = new ColorProcessor(m_width, m_height); 
    1922                 ImagePlus imagePlus = new ImagePlus("Fitted Lambdas", imageProcessor); 
    1923  
    1924                 int i = 0; 
    1925                 Roi[] rois = getRois(); 
    1926                 if (0 < rois.length) { 
    1927                     for (Roi roi: rois) { 
    1928                         Rectangle bounds = roi.getBounds(); 
    1929                         for (int x = 0; x < bounds.width; ++x) { 
    1930                             for (int y = 0; y < bounds.height; ++y) { 
    1931                                 if (roi.contains(bounds.x + x,  bounds.y + y)) { 
    1932                                     double lambda = dataArray[i++].getParams()[1]; 
    1933                                     imageProcessor.setColor(lifetimeColorMap(MAXIMUM_LIFETIME, lambda)); 
    1934                                     imageProcessor.drawPixel(bounds.x + x, m_height - bounds.y - y - 1); 
    1935                                 } 
    1936                             } 
    1937                         } 
    1938  
    1939                     } 
    1940                 } 
    1941                 else { 
    1942                     for (int y = 0; y < m_height; ++y) { 
    1943                         for (int x = 0; x < m_width; ++x) { 
    1944                             double lambda = dataArray[i++].getParams()[1]; 
    1945                             imageProcessor.setColor(lifetimeColorMap(MAXIMUM_LIFETIME, lambda)); 
    1946                             imageProcessor.drawPixel(x, m_height - y - 1); 
    1947                         } 
    1948                     } 
    1949                 } 
    1950                 imagePlus.show(); 
    1951                 break; 
    1952         } 
    1953          
    1954         if (0 < dataArray.length) { 
    1955             params = dataArray[0].getParams(); 
    1956             switch (m_function) { 
    1957                 case SINGLE_EXPONENTIAL: 
    1958                     m_param[0] = params[0]; 
    1959                     m_param[1] = params[1]; 
    1960                     m_param[2]  = params[2]; 
    1961                     break; 
    1962                 case DOUBLE_EXPONENTIAL: 
    1963                     m_param[0] = params[0]; 
    1964                     m_param[1] = params[1]; 
    1965                     m_param[2] = params[2]; 
    1966                     m_param[3] = params[3]; 
    1967                     m_param[4] = params[4]; 
    1968                     break; 
    1969                 case TRIPLE_EXPONENTIAL: 
    1970                     m_param[0] = params[0]; 
    1971                     m_param[1] = params[1]; 
    1972                     m_param[2] = params[2]; 
    1973                     m_param[3] = params[3]; 
    1974                     m_param[4] = params[4]; 
    1975                     m_param[5] = params[5]; 
    1976                     m_param[6] = params[6]; 
    1977                     break; 
    1978                 case STRETCHED_EXPONENTIAL: 
    1979                     break; 
    1980             } 
    1981         } 
    1982     } 
    1983  
    1984     /** 
    1985      * Fits each & every pixel in the image that is 
    1986      * selected by fitThisPixel. 
    1987      * 
    1988      * Starts up a DataColorizer to show dynamically colorized 
    1989      * lifetimes. 
    1990      * 
    1991      * Uses a ChunkyPixelEffectIterator to decide which pixel to 
    1992      * fit next.  Batches up pixels and calls processPixels to 
    1993      * do the fit. 
    1994      */ 
    1995     private void fitEachPixelX() { 
    1996         long start = System.nanoTime(); 
    1997  
    1998         // build the params 
    1999         double params[] = null; 
    2000          switch (m_function) { 
    2001             case SINGLE_EXPONENTIAL: 
    2002                 params = new double[3]; 
    2003                 params[0] = m_param[0]; 
    2004                 params[1] = m_param[1]; 
    2005                 params[2] = m_param[2]; 
    2006                 break; 
    2007             case DOUBLE_EXPONENTIAL: 
    2008                 params = new double[5]; 
    2009                 params[0] = m_param[0]; 
    2010                 params[1] = m_param[1]; 
    2011                 params[2] = m_param[2]; 
    2012                 params[3] = m_param[3]; 
    2013                 params[4] = m_param[4]; 
    2014                 break; 
    2015             case TRIPLE_EXPONENTIAL: 
    2016                 params = new double[7]; 
    2017                 params[0] = m_param[0]; 
    2018                 params[1] = m_param[1]; 
    2019                 params[2] = m_param[2]; 
    2020                 params[3] = m_param[3]; 
    2021                 params[4] = m_param[4]; 
    2022                 params[5] = m_param[5]; 
    2023                 params[6] = m_param[6]; 
    2024                 break; 
    2025             case STRETCHED_EXPONENTIAL: 
    2026                 break; 
    2027         } 
    2028  
    2029         // show colorized lifetimes 
    2030         //ImageProcessor imageProcessor = new ColorProcessor(m_width, m_height); 
    2031         //ImagePlus imagePlus = new ImagePlus("Fitted Lifetimes", imageProcessor); 
    2032         //imagePlus.show(); 
    2033         DataColorizer dataColorizer = new DataColorizer(m_width, m_height, m_algorithm + " Fitted Lifetimes"); 
    2034  
    2035         // build the data 
    2036         ArrayList<ICurveFitData> curveFitDataList = new ArrayList<ICurveFitData>(); 
    2037         ArrayList<ChunkyPixel> pixelList = new ArrayList<ChunkyPixel>(); 
    2038         ICurveFitData curveFitData; 
    2039         double yCount[]; 
    2040         double yFitted[]; 
    2041  
    2042         ChunkyPixelEffectIterator pixelIterator = new ChunkyPixelEffectIterator(new ChunkyPixelTableImpl(), m_width, m_height); 
    2043  
    2044         int pixelCount = 0; 
    2045         int pixelsToProcessCount = 0; 
    2046  
    2047         while (pixelIterator.hasNext()) { 
    2048             ++pixelCount; 
    2049             IJ.showProgress(pixelCount, m_height * m_width); 
    2050             ChunkyPixel pixel = pixelIterator.next(); 
    2051             if (wantFitted(pixel.getX(), pixel.getY())) { 
    2052                 curveFitData = new CurveFitData(); 
    2053                 curveFitData.setParams(params.clone()); 
    2054                 yCount = new double[m_timeBins]; 
    2055                 for (int b = 0; b < m_timeBins; ++b) { 
    2056                     yCount[b] = m_data[0][pixel.getY()][pixel.getX()][b]; 
    2057                 } 
    2058                 curveFitData.setYCount(yCount); 
    2059                 yFitted = new double[m_timeBins]; 
    2060                 curveFitData.setYFitted(yFitted); 
    2061                 curveFitDataList.add(curveFitData); 
    2062                 pixelList.add(pixel); 
    2063  
    2064  
    2065                 if (++pixelsToProcessCount >= PIXEL_COUNT) { 
    2066                     //processPixels(imagePlus, imageProcessor, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    2067                     processPixels(dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    2068                     curveFitDataList.clear(); 
    2069                     pixelList.clear(); 
    2070                     pixelsToProcessCount = 0; 
    2071                 } 
    2072             } 
    2073         } 
    2074         if (0 < pixelsToProcessCount) { 
    2075             //processPixels(imagePlus, imageProcessor, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    2076             processPixels(dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    2077         } 
    2078         long elapsed = System.nanoTime() - start; 
    2079         System.out.println("nanoseconds " + elapsed); 
    2080     } 
    2081  
    2082     private class MyListener implements IStartStopListener { 
    2083      /** 
    2084      * Listens for changes to the start and stop indices of the fit. 
    2085      * 
    2086      * @param start index 
    2087      * @param stop index inclusive 
    2088      */ 
    2089        public void setStartStop(int start, int stop) { 
    2090            System.out.println("start " + start + " stop " + stop); 
    2091        } 
    2092     } 
    2093  
    2094    /* private class MyDialogListener implements DialogListener { 
    2095         public boolean dialogItemChanged(GenericDialog dialog, AWTEvent e) { 
    2096             boolean showNextDialog = false; 
    2097             System.out.println("dialogItemChanged"); 
    2098             if (null == e) { 
    2099                 showNextDialog = true; 
    2100             } 
    2101             else if (e instanceof ActionEvent) { 
    2102                 System.out.println("!>" + ((ActionEvent) e).getActionCommand() + "<"); 
    2103                 System.out.println("!OK button pressed"); 
    2104                 showNextDialog = true; 
    2105             } 
    2106             else { 
    2107                 System.out.println("!Event " + e); 
    2108                 System.out.println(dialog.getChoices().get(0)); 
    2109             } 
    2110             return true; 
    2111         } 
    2112     }*/ 
     1595        }         
     1596    } 
    21131597} 
Note: See TracChangeset for help on using the changeset viewer.