Changeset 7862 for trunk/projects


Ignore:
Timestamp:
01/03/12 18:02:24 (8 years ago)
Author:
aivar
Message:

Clean up image fitting code.

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

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/GlobalFitParams.java

    r7842 r7862  
    134134     
    135135    @Override 
     136    public int getStartPrompt() { 
     137        return _startPrompt; 
     138    } 
     139     
     140    @Override 
    136141    public void setStopPrompt(int stopPrompt) { 
    137142        _stopPrompt = stopPrompt; 
     143    } 
     144     
     145    @Override 
     146    public int getStopPrompt() { 
     147        return _stopPrompt; 
    138148    } 
    139149     
     
    144154     
    145155    @Override 
     156    public int getStartDecay() { 
     157        return _startDecay; 
     158    } 
     159     
     160    @Override 
    146161    public void setStopDecay(int stopDecay) { 
    147162        _stopDecay = stopDecay; 
    148163    } 
     164     
     165    @Override 
     166    public int getStopDecay() { 
     167        return _stopDecay; 
     168    } 
    149169} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/IGlobalFitParams.java

    r7842 r7862  
    7777    public void setStartPrompt(int startPrompt); 
    7878     
     79    public int getStartPrompt(); 
     80     
    7981    public void setStopPrompt(int stopPrompt); 
     82     
     83    public int getStopPrompt(); 
    8084     
    8185    public void setStartDecay(int startDecay); 
    8286     
     87    public int getStartDecay(); 
     88     
    8389    public void setStopDecay(int stopDecay); 
     90     
     91    public int getStopDecay(); 
    8492} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7842 r7862  
    662662                case EACH: 
    663663                    // fit every pixel 
    664                     fittedImage = fitEachPixel(uiPanel); 
     664                    fittedImage = fitEachPixelXYZ(uiPanel); 
    665665                    break; 
    666666            } 
     
    963963    } 
    964964     
    965     //TODO This is the new version and "fitEachPixelX" is the old: 
     965    //TODO This fitImages is the new version and "fitEachPixelXYZ" is the old: 
    966966    //TODO need to fit all channels 
    967967    //TODO need to be a selfcontained function call 
    968968    //  = gives you fitted images and a histogram tool 
    969969 
    970     private Image<DoubleType> fitEachPixel(IUserInterfacePanel uiPanel) { 
     970    private Image<DoubleType> fitImages(IUserInterfacePanel uiPanel) { 
     971         
     972         
     973         
     974        // loop over all channels 
     975        int startChannel; 
     976        int stopChannel; 
     977        if (m_fitAllChannels) { 
     978            startChannel = 0; 
     979            stopChannel = m_channels; 
     980        } 
     981        else { 
     982            startChannel = m_channel; 
     983            stopChannel = m_channel + 1; 
     984        } 
     985        for (int channel = startChannel; channel < stopChannel; ++channel) { 
     986             
     987        } 
     988         
    971989        long start = System.nanoTime(); 
    972990        int pixelCount = 0; 
     
    976994        Image<T> workImage = m_image; 
    977995        if (!SLIMBinning.NONE.equals(uiPanel.getBinning())) { 
    978             workImage = m_binning.doBinning(uiPanel.getBinning(),  m_image); 
     996            workImage = m_binning.doBinning(uiPanel.getBinning(), m_image); 
    979997        } 
    980998        LocalizableByDimCursor<T> pixelCursor = workImage.createLocalizableByDimCursor(); 
     
    10291047        OutputImage[] outputImages = parser.getOutputImages(); 
    10301048        imageFitter.setUpFit(outputImages, new int[] { m_width, m_height }, components); 
    1031         imageFitter.beginFit();        
     1049        imageFitter.beginFit(); 
     1050         
     1051        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     1052        globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); ///uiPanel.getAlgorithm()); //loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
     1053        globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); //uiPanel.getFunction()); 
     1054        globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     1055        globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); //uiPanel.getNoiseModel()); 
     1056        globalFitParams.setChiSquareTarget(uiPanel.getChiSquareTarget()); 
     1057        ///globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1058        ///globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); 
     1059        globalFitParams.setXInc(m_timeRange); 
     1060        globalFitParams.setPrompt(null); 
     1061        if (null != m_excitationPanel) { 
     1062            globalFitParams.setPrompt(m_excitationPanel.getValues(1)); 
     1063        } 
     1064        ////globalFitParams.setChiSquareTarget(data[0].getChiSquareTarget()); 
     1065 
     1066 
     1067        boolean[] free = { true, true, true }; 
     1068        globalFitParams.setFree(free); //TODO BAD! s/n/b hardcoded here 
     1069      //TODO KLUDGE  globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     1070         
     1071         
     1072         
    10321073 
    10331074        while (!m_cancel && pixelIterator.hasNext()) { 
     
    10571098                    ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    10581099                    ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
    1059                     processPixels(data, pixels, imageFitter); 
     1100                    processPixelsXYZ(data, pixels, imageFitter); 
    10601101                    curveFitDataList.clear(); 
    10611102                    pixelList.clear(); 
     
    10751116                ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    10761117                ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
    1077                 processPixels(data, pixels, imageFitter); 
     1118                processPixelsXYZ(data, pixels, imageFitter); 
    10781119            } 
    10791120            imageFitter.endFit(); 
     
    10871128        return null; 
    10881129    } 
    1089  
     1130     
     1131     
    10901132    /* 
    10911133     * Helper function that processes an array of pixels.  Histogram and images 
     
    10931135     */ 
    10941136    private void processPixels(ICurveFitData[] data, ChunkyPixel[] pixels, FLIMImageFitter imageFitter) { 
     1137        if (null == _fittingEngine) { 
     1138            _fittingEngine = Configuration.getInstance().getFittingEngine(); 
     1139            _fittingEngine.setThreads(Configuration.getInstance().getThreads()); 
     1140            _fittingEngine.setCurveFitter(Configuration.getInstance().getCurveFitter()); 
     1141        } 
     1142 
     1143        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     1144        globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
     1145        globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1146        globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); 
     1147        globalFitParams.setXInc(m_timeRange); 
     1148        globalFitParams.setPrompt(null); 
     1149        if (null != m_excitationPanel) { 
     1150            globalFitParams.setPrompt(m_excitationPanel.getValues(1)); 
     1151        } 
     1152        globalFitParams.setChiSquareTarget(data[0].getChiSquareTarget()); 
     1153 
     1154 
     1155        boolean[] free = { true, true, true }; 
     1156        globalFitParams.setFree(free); //TODO BAD! s/n/b hardcoded here 
     1157      //TODO KLUDGE  globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     1158 
     1159        List<ILocalFitParams> dataList = new ArrayList<ILocalFitParams>(); 
     1160 
     1161        for (ICurveFitData datum : data) { 
     1162            ILocalFitParams localFitParams = new LocalFitParams(); 
     1163            localFitParams.setY(datum.getYCount()); 
     1164            localFitParams.setSig(datum.getSig()); 
     1165            localFitParams.setParams(datum.getParams()); 
     1166            localFitParams.setFitStart(m_startBin); 
     1167            localFitParams.setFitStop(m_stopBin); 
     1168            localFitParams.setYFitted(datum.getYFitted()); 
     1169            dataList.add(localFitParams); 
     1170        } 
     1171 
     1172        List<IFitResults> results = _fittingEngine.fit(globalFitParams, dataList); 
     1173 
     1174        for (int i = 0; i < results.size(); ++i) { 
     1175            IFitResults result = results.get(i); 
     1176            ChunkyPixel p = pixels[i]; 
     1177            int[] location = { p.getX(), p.getY() }; 
     1178            imageFitter.updatePixel(location, result.getParams()); 
     1179        } 
     1180 
     1181        imageFitter.recalcHistogram(); 
     1182    } 
     1183     
     1184    //TODO This XYZ is the new version and "fitEachPixelX" is the old: 
     1185    //TODO need to fit all channels 
     1186    //TODO need to be a selfcontained function call 
     1187    //  = gives you fitted images and a histogram tool 
     1188 
     1189    private Image<DoubleType> fitEachPixelXYZ(IUserInterfacePanel uiPanel) { 
     1190        long start = System.nanoTime(); 
     1191        int pixelCount = 0; 
     1192        int totalPixelCount = totalPixelCount(m_width, m_height, m_channels, m_fitAllChannels); 
     1193        int pixelsToProcessCount = 0; 
     1194 
     1195        Image<T> workImage = m_image; 
     1196        if (!SLIMBinning.NONE.equals(uiPanel.getBinning())) { 
     1197            workImage = m_binning.doBinning(uiPanel.getBinning(),  m_image); 
     1198        } 
     1199        LocalizableByDimCursor<T> pixelCursor = workImage.createLocalizableByDimCursor(); 
     1200 
     1201        ICurveFitter curveFitter = getCurveFitter(uiPanel); //TODO where is this used? 
     1202        double params[] = uiPanel.getParameters(); 
     1203 
     1204        boolean useFittedParams; 
     1205        LocalizableByDimCursor<DoubleType> resultsCursor = null; 
     1206        if (null == m_fittedImage || uiPanel.getParameterCount() != m_fittedParameterCount) { 
     1207            // can't use previous results 
     1208            useFittedParams = false; 
     1209            m_fittedParameterCount = uiPanel.getParameterCount(); 
     1210            m_fittedImage = makeImage(m_channels, m_width, m_height, m_fittedParameterCount); 
     1211        } 
     1212        else { 
     1213            // ask UI whether to use previous results 
     1214            useFittedParams = uiPanel.refineFit(); 
     1215        } 
     1216        resultsCursor = m_fittedImage.createLocalizableByDimCursor(); 
     1217         
     1218        // build the data 
     1219        ArrayList<ICurveFitData> curveFitDataList = new ArrayList<ICurveFitData>(); 
     1220        ArrayList<ChunkyPixel> pixelList = new ArrayList<ChunkyPixel>(); 
     1221        ICurveFitData curveFitData; 
     1222        double yCount[]; 
     1223        double yFitted[]; 
     1224 
     1225        ChunkyPixelEffectIterator pixelIterator = new ChunkyPixelEffectIterator(new ChunkyPixelTableImpl(), m_width, m_height); 
     1226         
     1227        //TODO new style code starts only here: 
     1228        FLIMImageFitter imageFitter = new FLIMImageFitter(); 
     1229        int components = 0; 
     1230        boolean stretched = false; 
     1231        switch (uiPanel.getFunction()) { 
     1232            case SINGLE_EXPONENTIAL: 
     1233                components = 1; 
     1234                break; 
     1235            case DOUBLE_EXPONENTIAL: 
     1236                components = 2; 
     1237                break; 
     1238            case TRIPLE_EXPONENTIAL: 
     1239                components = 3; 
     1240                break; 
     1241            case STRETCHED_EXPONENTIAL: 
     1242                stretched = true; 
     1243                break; 
     1244        } 
     1245        String outputs = uiPanel.getFittedImages(); 
     1246        OutputImageParser parser = new OutputImageParser(outputs, components, stretched); 
     1247         
     1248        OutputImage[] outputImages = parser.getOutputImages(); 
     1249        imageFitter.setUpFit(outputImages, new int[] { m_width, m_height }, components); 
     1250        imageFitter.beginFit();        
     1251 
     1252        while (!m_cancel && pixelIterator.hasNext()) { 
     1253            IJ.showProgress(++pixelCount, totalPixelCount); 
     1254            ChunkyPixel pixel = pixelIterator.next(); 
     1255            if (wantFitted(m_channel, pixel.getX(), pixel.getY())) { 
     1256                curveFitData = new CurveFitData(); 
     1257                curveFitData.setChannel(m_channel); 
     1258                curveFitData.setX(pixel.getX()); 
     1259                curveFitData.setY(pixel.getY()); 
     1260                curveFitData.setParams( 
     1261                    useFittedParams ? 
     1262                        getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
     1263                            params.clone()); 
     1264                yCount = new double[m_timeBins]; 
     1265                for (int b = 0; b < m_timeBins; ++b) { 
     1266                    yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
     1267                } 
     1268                curveFitData.setYCount(yCount); 
     1269                yFitted = new double[m_timeBins]; 
     1270                curveFitData.setYFitted(yFitted); 
     1271                curveFitDataList.add(curveFitData); 
     1272                pixelList.add(pixel); 
     1273 
     1274                // process the pixels 
     1275                if (++pixelsToProcessCount >= PIXEL_COUNT) { 
     1276                    ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1277                    ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
     1278                    processPixelsXYZ(data, pixels, imageFitter); 
     1279                    curveFitDataList.clear(); 
     1280                    pixelList.clear(); 
     1281                    pixelsToProcessCount = 0; 
     1282                } 
     1283            } 
     1284        } 
     1285         
     1286        if (m_cancel) { 
     1287            IJ.showProgress(0, 0); 
     1288            cancelImageFit(); 
     1289            imageFitter.cancelFit(); 
     1290            return null; 
     1291        } 
     1292        else { 
     1293            if (pixelsToProcessCount > 0) { 
     1294                ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     1295                ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
     1296                processPixelsXYZ(data, pixels, imageFitter); 
     1297            } 
     1298            imageFitter.endFit(); 
     1299        } 
     1300 
     1301         
     1302        //TODO so the results are not getting saved to an Imglib Image 
     1303        //TODO this technique of building an array of ICurveFitData, then breaking that down into 
     1304        // IGlobalFitParams and ILocalFitParams seems over-complicated 
     1305         
     1306        return null; 
     1307    } 
     1308 
     1309    /* 
     1310     * Helper function that processes an array of pixels.  Histogram and images 
     1311     * are updated at the end of this function. 
     1312     */ 
     1313    private void processPixelsXYZ(ICurveFitData[] data, ChunkyPixel[] pixels, FLIMImageFitter imageFitter) { 
    10951314        if (null == _fittingEngine) { 
    10961315            _fittingEngine = Configuration.getInstance().getFittingEngine(); 
Note: See TracChangeset for help on using the changeset viewer.