Ignore:
Timestamp:
11/18/11 19:57:07 (8 years ago)
Author:
aivar
Message:

Got the new style fitting engine working. Bit of a hack; SLIMProcessor needs a lot of rework. Fit each pixel takes 75% of the time on my dual-core.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/loci/slim/CursorHelper.java

    r7795 r7811  
    3737import loci.curvefitter.CurveFitData; 
    3838import loci.curvefitter.ICurveFitData; 
     39import loci.curvefitter.ICurveFitter; 
    3940import loci.curvefitter.SLIMCurveFitter; 
    4041 
     
    285286            CurveFitData[] data = new CurveFitData[] { curveFitData }; 
    286287 
    287             SLIMCurveFitter curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.RLD_LMA); 
     288            SLIMCurveFitter curveFitter = new SLIMCurveFitter(); 
     289            curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD_LMA); 
    288290            curveFitter.setXInc(xInc); 
    289291            curveFitter.setFree(free); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7804 r7811  
    8181import mpicbg.imglib.type.numeric.real.DoubleType; 
    8282 
     83// Kludge in the new stuff: 
     84import imagej.slim.fitting.params.IGlobalFitParams; 
     85import imagej.slim.fitting.params.LocalFitParams; 
     86import imagej.slim.fitting.params.GlobalFitParams; 
     87import imagej.slim.fitting.engine.IFittingEngine; 
     88import imagej.slim.fitting.params.ILocalFitParams; 
     89import imagej.slim.fitting.params.IFitResults; 
     90import imagej.slim.fitting.config.Configuration; 
     91 
     92 
    8393 
    8494//TODO tidy up SLIMProcessor 
     
    95105 */ 
    96106public class SLIMProcessor <T extends RealType<T>> { 
     107    private static boolean OLD_STYLE = false; // fully krausened, from God's Country in WI 
     108     
     109    private imagej.slim.fitting.engine.IFittingEngine _fittingEngine; 
     110     
    97111    private static final String X = "X"; 
    98112    private static final String Y = "Y"; 
     
    10251039                    // process the pixels 
    10261040                    if (++pixelsToProcessCount >= PIXEL_COUNT) { 
    1027                         pixelsToProcessCount = 0; 
    1028                         ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    1029                         curveFitDataList.clear(); 
    1030                         curveFitter.fitData(data, m_startBin, m_stopBin); 
    1031                         setFittedParamsFromData(resultsCursor, data); 
    1032                         colorizePixels(dataColorizer, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
    1033                         pixelList.clear(); 
     1041                        if (OLD_STYLE) { 
     1042                            pixelsToProcessCount = 0; 
     1043                            ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1044                            curveFitDataList.clear(); 
     1045                            curveFitter.fitData(data, m_startBin, m_stopBin); 
     1046                            setFittedParamsFromData(resultsCursor, data); 
     1047                            colorizePixels(dataColorizer, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
     1048                            pixelList.clear(); 
     1049                        } 
     1050                        else { 
     1051                            pixelsToProcessCount = 0; 
     1052                            ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1053                            curveFitDataList.clear(); 
     1054                             
     1055                            if (null == _fittingEngine) { 
     1056                                _fittingEngine = Configuration.getInstance().getFittingEngine(); 
     1057                                _fittingEngine.setThreads(Configuration.getInstance().getThreads()); 
     1058                                _fittingEngine.setCurveFitter(Configuration.getInstance().getCurveFitter()); 
     1059                            } 
     1060                                                         
     1061                             
     1062                            IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     1063                            globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
     1064                            globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1065                            globalFitParams.setXInc(m_timeRange); 
     1066                            globalFitParams.setPrompt(null); 
     1067                            if (null != m_excitationPanel) { 
     1068                                globalFitParams.setPrompt(m_excitationPanel.getValues(1)); 
     1069                            } 
     1070                            globalFitParams.setChiSquareTarget(data[0].getChiSquareTarget()); 
     1071                            globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     1072                             
     1073                            java.util.List<ILocalFitParams> dataList = new ArrayList<ILocalFitParams>(); 
     1074                             
     1075                            for (ICurveFitData datum : data) { 
     1076                                ILocalFitParams localFitParams = new LocalFitParams(); 
     1077                                localFitParams.setY(datum.getYCount()); 
     1078                                localFitParams.setSig(datum.getSig()); 
     1079                                localFitParams.setParams(datum.getParams()); 
     1080                                localFitParams.setFitStart(m_startBin); 
     1081                                localFitParams.setFitStop(m_stopBin); 
     1082                                localFitParams.setYFitted(datum.getYFitted()); 
     1083                                dataList.add(localFitParams); 
     1084                            } 
     1085                             
     1086                            java.util.List<IFitResults> results = _fittingEngine.fit(globalFitParams, dataList); 
     1087                             
     1088                            double[] lifetimes = new double[pixelList.size()]; 
     1089                            for (int i = 0; i < pixelList.size(); ++i) { 
     1090                                lifetimes[i] = results.get(i).getParams()[3]; 
     1091                            } 
     1092 
     1093                           //TODO ARG setFittedParamsFromData(resultsCursor, data); 
     1094                            colorizePixelsII(dataColorizer, m_channel, lifetimes, pixelList.toArray(new ChunkyPixel[0])); 
     1095                            pixelList.clear(); 
     1096                             
     1097                            //TODO so the results are not getting saved to an Imglib Image 
     1098                            //TODO this technique of building an array of ICurveFitData, then breaking that down into 
     1099                            // IGlobalFitParams and ILocalFitParams 
     1100 
     1101                        } 
     1102 
    10341103                    } 
    10351104                } 
     
    10371106            // handle any leftover pixels 
    10381107            if (!m_cancel && pixelsToProcessCount > 0) { 
    1039                 pixelsToProcessCount = 0; 
    1040                 ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    1041                 curveFitDataList.clear(); 
    1042                 curveFitter.fitData(data, m_startBin, m_stopBin); 
    1043                 setFittedParamsFromData(resultsCursor, data); 
    1044                 colorizePixels(dataColorizer, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
     1108                if (OLD_STYLE) { 
     1109                    pixelsToProcessCount = 0; 
     1110                    ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1111                    curveFitDataList.clear(); 
     1112                    curveFitter.fitData(data, m_startBin, m_stopBin); 
     1113                    setFittedParamsFromData(resultsCursor, data); 
     1114                    colorizePixels(dataColorizer, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
     1115  
     1116                } 
     1117                else { 
     1118                            pixelsToProcessCount = 0; 
     1119                            ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1120                            curveFitDataList.clear(); 
     1121                             
     1122                            if (null == _fittingEngine) { 
     1123                                _fittingEngine = Configuration.getInstance().getFittingEngine(); 
     1124                                _fittingEngine.setThreads(Configuration.getInstance().getThreads()); 
     1125                                _fittingEngine.setCurveFitter(Configuration.getInstance().getCurveFitter()); 
     1126                            } 
     1127                                                         
     1128                             
     1129                            IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     1130                            globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
     1131                            globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1132                            globalFitParams.setXInc(m_timeRange); 
     1133                            globalFitParams.setPrompt(null); 
     1134                            if (null != m_excitationPanel) { 
     1135                                globalFitParams.setPrompt(m_excitationPanel.getValues(1)); 
     1136                            } 
     1137                            globalFitParams.setChiSquareTarget(data[0].getChiSquareTarget()); 
     1138                            globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     1139                             
     1140                            java.util.List<ILocalFitParams> dataList = new ArrayList<ILocalFitParams>(); 
     1141                             
     1142                            for (ICurveFitData datum : data) { 
     1143                                ILocalFitParams localFitParams = new LocalFitParams(); 
     1144                                localFitParams.setY(datum.getYCount()); 
     1145                                localFitParams.setSig(datum.getSig()); 
     1146                                localFitParams.setParams(datum.getParams()); 
     1147                                localFitParams.setFitStart(m_startBin); 
     1148                                localFitParams.setFitStop(m_stopBin); 
     1149                                localFitParams.setYFitted(datum.getYFitted()); 
     1150                                dataList.add(localFitParams); 
     1151                            } 
     1152                             
     1153                            java.util.List<IFitResults> results = _fittingEngine.fit(globalFitParams, dataList); 
     1154                             
     1155                            double[] lifetimes = new double[pixelList.size()]; 
     1156                            for (int i = 0; i < pixelList.size(); ++i) { 
     1157                                lifetimes[i] = results.get(i).getParams()[3]; 
     1158                            } 
     1159 
     1160                           //TODO ARG setFittedParamsFromData(resultsCursor, data); 
     1161                            colorizePixelsII(dataColorizer, m_channel, lifetimes, pixelList.toArray(new ChunkyPixel[0])); 
     1162 
     1163                } 
    10451164            } 
    10461165        } 
     
    12511370        } 
    12521371    } 
    1253  
     1372     
     1373    private void setFittedParamsFromDataII(LocalizableByDimCursor<DoubleType> cursor, ICurveFitData dataArray[]) { 
     1374        int x, y; 
     1375        double[] params; 
     1376        for (ICurveFitData data : dataArray) { 
     1377            setFittedParams(cursor, data.getChannel(), data.getX(), data.getY(), data.getParams()); 
     1378        } 
     1379    } 
     1380     
    12541381    private void setFittedParams(LocalizableByDimCursor<DoubleType> cursor, int channel, int x, int y, double[] params) { 
    12551382        int position[] = new int[4]; 
     
    13251452        dataColorizer.update(); 
    13261453    } 
    1327  
     1454     
     1455    void colorizePixelsII(DataColorizer dataColorizer, int channel, double[] lifetime, ChunkyPixel pixels[]) { 
     1456 
     1457        // draw as you go; 'chunky' pixels get smaller as the overall fit progresses 
     1458        for (int i = 0; i < pixels.length; ++i) { 
     1459            ChunkyPixel pixel = pixels[i]; 
     1460            //TODO tau is 3, 1 is C double lifetime = data[i].getParams()[1]; 
     1461 
     1462 
     1463            //TODO quick fix 
     1464            if (lifetime[i] < 0.0) { 
     1465                System.out.println("negative lifetime " + lifetime + " at " + pixel.getX() + " " + pixel.getY()); 
     1466                return; 
     1467            } 
     1468 
     1469            //TODO debugging: 
     1470            //if (lifetime > 2 * m_param[1]) { 
     1471            //    System.out.println("BAD FIT??? x " + pixel.getX() + " y " + pixel.getY() + " fitted lifetime " + lifetime); 
     1472            //} 
     1473 
     1474            //TODO BUG: 
     1475            // With the table as is, you can get 
     1476            //   x   y   w   h 
     1477            //   12  15  2   1 
     1478            //   14  15  2   1 
     1479            // all within the same drawing cycle. 
     1480            // So it looks like a 4x1 slice gets drawn (it 
     1481            // is composed of two adjacent 2x1 slices with 
     1482            // potentially two different colors). 
     1483            //if (pixel.getWidth() == 2) { 
     1484            //    System.out.println("x " + pixel.getX() + " y " + pixel.getY() + " w " + pixel.getWidth() + " h " + pixel.getHeight()); 
     1485            //} 
     1486            //System.out.println("w " + pixel.getWidth() + " h " + pixel.getHeight()); 
     1487            //System.out.println("lifetime is " + lifetime); 
     1488            //Color color = lifetimeColorMap(MAXIMUM_LIFETIME, lifetime); 
     1489            //imageProcessor.setColor(color); 
     1490            boolean firstTime = true; 
     1491            for (int x = pixel.getX(); x < pixel.getX() + pixel.getWidth(); ++x) { 
     1492                for (int y = pixel.getY(); y < pixel.getY() + pixel.getHeight(); ++y) { 
     1493                    if (wantFitted(channel, x, y)) { 
     1494                        dataColorizer.setData(firstTime, x, y , lifetime[i]); 
     1495                        firstTime = false; 
     1496                    } 
     1497                } 
     1498            } 
     1499        } 
     1500        dataColorizer.update(); 
     1501    } 
     1502     
    13281503    /** 
    13291504     * Checks criterion for whether this pixel needs to get fitted or drawn. 
     
    14701645                break; */ 
    14711646            case BARBER_RLD: 
    1472                 curveFitter = new GrayCurveFitter(0); 
     1647                curveFitter = new GrayCurveFitter(); 
     1648                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD); 
    14731649                break; 
    14741650            case BARBER_LMA: 
    1475                 curveFitter = new GrayCurveFitter(1); 
     1651                curveFitter = new GrayCurveFitter(); 
     1652                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.LMA); 
    14761653                break; 
    14771654            case MARKWARDT: 
     
    14791656                break; 
    14801657            case BARBER2_RLD: 
    1481                 curveFitter = new GrayNRCurveFitter(0); 
     1658                curveFitter = new GrayNRCurveFitter(); 
     1659                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD);         
    14821660                break; 
    14831661            case BARBER2_LMA: 
    1484                 curveFitter = new GrayNRCurveFitter(1); 
     1662                curveFitter = new GrayNRCurveFitter(); 
     1663                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD); 
    14851664                break; 
    14861665            case SLIMCURVE_RLD: 
    1487                 curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.RLD); 
     1666                curveFitter = new SLIMCurveFitter(); 
     1667                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD); 
    14881668                break; 
    14891669            case SLIMCURVE_LMA: 
    1490                 curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.LMA); 
     1670                curveFitter = new SLIMCurveFitter(); 
     1671                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.LMA); 
    14911672                break; 
    14921673            case SLIMCURVE_RLD_LMA: 
    1493                 curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.RLD_LMA); 
     1674                curveFitter = new SLIMCurveFitter(); 
     1675                curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD_LMA); 
    14941676                break; 
    14951677        } 
Note: See TracChangeset for help on using the changeset viewer.