Changeset 7811


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
Files:
11 edited
3 moved

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/Test.java

    r7805 r7811  
    1111import imagej.slim.fitting.params.ILocalFitParams; 
    1212import imagej.slim.fitting.config.Configuration; 
     13 
     14import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     15import loci.curvefitter.ICurveFitter.FitFunction; 
    1316 
    1417import java.util.ArrayList; 
     
    2528        _fittingEngine = Configuration.getInstance().getFittingEngine(); 
    2629        _fittingEngine.setThreads(Configuration.getInstance().getThreads()); 
    27         IGlobalFitParams params = new GlobalFitParams(); 
     30        _fittingEngine.setCurveFitter(Configuration.getInstance().getCurveFitter()); 
     31         
     32        double[] y = new double[]{ 
     33          0,3,1,2,2,0,0,0,1,1,0,0,1,1,0,1,0,2,2,1,1,1,1,1,0,1,2,1,0,0,1,0,2,3,2,0,0, 
     34          0,0,1,0,2,0,2,0,0,0,2,0,0,2,3,2,3,4,3,7,12,3,5,3,7,10,1,7,3,6,8,1,10,6,4,6, 
     35          7,6,4,7,4,3,4,3,0,2,3,1,4,2,3,5,1,3,6,5,7,4,3,4,6,6,5,3,3,5,5,4,1,3,4,4,5, 
     36          5,3,4,3,2,2,4,3,3,2,4,1,3,3,4,4,2,6,0,1,0,6,3,3,4,3,3,4,1,3,0,2,1,1,2,1,1, 
     37          0,3,2,1,1,2,1,3,1,1,3,1,1,0,2,1,1,3,0,3,1,1,2,0,1,3,0,2,0,1,4,1,1,3,0,3,1, 
     38          3,2,4,1,1,0,3,1,2,0,1,1,0,2,1,4,2,0,2,0,2,0,2,0,2,0,0,1,2,0,0,1,0,1,1,2,2, 
     39          1,3,3,1,1,1,2,0,0,0,4,2,1,1,2,3,4,1,4,1,2,1,2,2,0,2,0,1,0,1,1,0,1,1,1 }; 
     40        double[] yFitted = new double[y.length]; 
     41        double xInc = 0.0390625; 
     42        int fitStart = 40; 
     43        int fitStop = 210; 
     44        int nData = y.length; 
     45        double[] sig = null; // new double[] { 1.0 }; 
     46        double[] params = new double[] { 0.0, 0.5, 100.0, 0.5 }; 
     47         
     48        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     49        globalFitParams.setFitAlgorithm(FitAlgorithm.RLD_LMA); 
     50        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
     51        globalFitParams.setXInc(xInc); 
     52        globalFitParams.setPrompt(null); 
     53        globalFitParams.setChiSquareTarget(0.0); 
     54        //TODO globalFitParams.setStartPrompt/setStopPrompt/setStartDecay/setStopDecay 
     55         
     56        System.out.println(" x inc is " + globalFitParams.getXInc()); 
     57         
     58        ILocalFitParams localFitParams = new LocalFitParams(); 
     59        localFitParams.setY(y); 
     60        localFitParams.setSig(sig); 
     61        localFitParams.setParams(params); 
     62        localFitParams.setFitStart(fitStart); 
     63        localFitParams.setFitStop(fitStop); 
     64        localFitParams.setYFitted(yFitted); //TODO ARG kludgey 
     65         
     66        /*IGlobalFitParams params = new GlobalFitParams(); 
    2867        List<ILocalFitParams> dataList = new ArrayList<ILocalFitParams>(); 
    2968        for (int i = 0; i < 128*128; ++i) { 
    3069            ILocalFitParams data = new LocalFitParams(); 
    31             data.setId(i); 
     70            //data.setId(i); 
    3271            dataList.add(data); 
    33         } 
     72        }*/ 
     73        List<ILocalFitParams> dataList = new ArrayList<ILocalFitParams>(); 
     74        dataList.add(localFitParams); 
    3475        long time = System.currentTimeMillis(); 
    35         _fittingEngine.fit(params, dataList); 
     76        _fittingEngine.fit(globalFitParams, dataList); 
    3677        System.out.println("DONE " + ((float) (System.currentTimeMillis() - time)/1000) + " secs"); 
    3778        _fittingEngine.shutdown(); 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/callable/FittingEngineCallable.java

    r7807 r7811  
    11// 
    2 // SLIMCurveCallable.java 
     2// FittingEngineCallable.java 
    33// 
    44 
     
    3535package imagej.slim.fitting.callable; 
    3636 
    37 import imagej.slim.fitting.params.LocalFitResult; 
     37import imagej.slim.fitting.params.FitResults; 
    3838import imagej.slim.fitting.params.ILocalFitParams; 
    3939import imagej.slim.fitting.params.IGlobalFitParams; 
    40 import imagej.slim.fitting.params.ILocalFitResults; 
    41 import java.util.Random; 
     40import imagej.slim.fitting.params.IFitResults; 
     41 
    4242import loci.curvefitter.CurveFitData; 
    43 import loci.curvefitter.GrayCurveFitter; 
    44 import loci.curvefitter.GrayNRCurveFitter; 
    4543import loci.curvefitter.ICurveFitData; 
    4644import loci.curvefitter.ICurveFitter; 
    47 import loci.curvefitter.JaolhoCurveFitter; 
    48 import loci.curvefitter.MarkwardtCurveFitter; 
    49 import loci.curvefitter.SLIMCurveFitter; 
    5045 
    5146/** 
     47 * This class brings together everything needed to fit one pixel. 
    5248 * 
    5349 * @author Aivar Grislis 
    5450 */ 
    55 public class SLIMCurveCallable implements IFittingEngineCallable { 
     51public class FittingEngineCallable implements IFittingEngineCallable { 
    5652    private ICurveFitter _curveFitter; 
    5753    private IGlobalFitParams _globalParams; 
    5854    private ILocalFitParams _localParams; 
    59     private ILocalFitResults _result; 
     55    private IFitResults _result; 
    6056 
    6157    @Override 
     
    6965  
    7066    @Override 
    71     public ILocalFitResults call() { 
    72         System.out.println(">>> " + _localParams.getId() + "-" + Thread.currentThread().getName()); 
    73         _result = new LocalFitResult(); 
    74         _result.setId(_localParams.getId()); 
    75   
    76         if (true) { 
    77             int waitTime = (new Random()).nextInt(10); 
    78             try { 
    79                 Thread.sleep(waitTime); 
    80             } 
    81             catch (InterruptedException e) { 
     67    public IFitResults call() { 
     68        _curveFitter.setFitAlgorithm(_globalParams.getFitAlgorithm()); 
     69        _curveFitter.setFitFunction(_globalParams.getFitFunction()); 
     70        _curveFitter.setInstrumentResponse(_globalParams.getPrompt()); 
     71        _curveFitter.setXInc(_globalParams.getXInc()); 
     72        _curveFitter.setFree(_globalParams.getFree()); 
     73        
     74        ICurveFitData curveFitData = new CurveFitData();  
     75        curveFitData.setChiSquareTarget(_globalParams.getChiSquareTarget()); 
     76        curveFitData.setYCount(_localParams.getY()); 
     77        curveFitData.setSig(_localParams.getSig()); 
     78        curveFitData.setParams(_localParams.getParams()); 
     79        curveFitData.setYFitted(_localParams.getYFitted()); //TODO awkward and kludgey!  How is this a local parameter?  It actually winds up in results. 
     80        ICurveFitData[] curveFitDataArray = new ICurveFitData[] { curveFitData }; 
    8281 
    83             } 
    84         } 
    85          
    86         System.out.println("<<< " + _localParams.getId() + "-" + Thread.currentThread().getName()); 
     82        _curveFitter.fitData(curveFitDataArray, _localParams.getFitStart(), _localParams.getFitStop()); 
     83 
     84        _result = new FitResults(); 
     85        _result.setChiSquare(curveFitData.getChiSquare()); 
     86        _result.setParams(curveFitData.getParams()); 
     87        _result.setYFitted(curveFitData.getYFitted()); 
     88 
    8789        return _result; 
    8890    } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/callable/IFittingEngineCallable.java

    r7807 r7811  
    3737import imagej.slim.fitting.params.ILocalFitParams; 
    3838import imagej.slim.fitting.params.IGlobalFitParams; 
    39 import imagej.slim.fitting.params.ILocalFitResults; 
     39import imagej.slim.fitting.params.IFitResults; 
    4040import loci.curvefitter.ICurveFitter; 
    4141 
     
    4646 * @author Aivar Grislis 
    4747 */ 
    48 public interface IFittingEngineCallable extends Callable<ILocalFitResults> { 
     48public interface IFittingEngineCallable extends Callable<IFitResults> { 
    4949     
    5050    public void setup(ICurveFitter curveFitter, 
    5151            IGlobalFitParams params, ILocalFitParams data); 
    5252     
    53     public ILocalFitResults call(); 
     53    public IFitResults call(); 
    5454} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/config/Configuration.java

    r7805 r7811  
    3636 
    3737import imagej.slim.fitting.callable.IFittingEngineCallable; 
    38 import imagej.slim.fitting.callable.SLIMCurveCallable; 
     38import imagej.slim.fitting.callable.FittingEngineCallable; 
    3939import imagej.slim.fitting.cursor.LameCursorEstimator; 
    4040import imagej.slim.fitting.cursor.ICursorEstimator; 
     
    4242import imagej.slim.fitting.engine.ThreadedFittingEngine; 
    4343 
     44import loci.curvefitter.ICurveFitter; 
     45import loci.curvefitter.SLIMCurveFitter; 
     46 
    4447/** 
    4548 * Handles configuration specific to the SLIM Plugin. 
     49 *  
     50 * A singleton so only one configuration per SLIM Plugin. 
    4651 *  
    4752 * @author Aivar Grislis 
     
    5156    private int _threads = 8; 
    5257    private IFittingEngine _fittingEngine; 
     58    private ICurveFitter _curveFitter; 
    5359    private ICursorEstimator _cursorEstimator; 
    5460 
    5561    /** 
    56      * Private constructor for Singleton pattern. 
     62     * Private constructor for singleton pattern. 
    5763     */ 
    5864    private Configuration() { 
     
    7783    } 
    7884     
     85    public synchronized ICurveFitter getCurveFitter() { 
     86        if (null == _curveFitter) { 
     87            _curveFitter = new SLIMCurveFitter(); 
     88        } 
     89        return _curveFitter; 
     90    } 
     91     
    7992    public synchronized ICursorEstimator getCursorEstimator() { 
    8093        if (null == _cursorEstimator) { 
     
    8598     
    8699    public IFittingEngineCallable newFittingEngineCallable() { 
    87         return new SLIMCurveCallable(); 
     100        return new FittingEngineCallable(); 
    88101    } 
    89102     
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/engine/IFittingEngine.java

    r7805 r7811  
    3737import imagej.slim.fitting.params.ILocalFitParams; 
    3838import imagej.slim.fitting.params.IGlobalFitParams; 
    39 import imagej.slim.fitting.params.ILocalFitResults; 
     39import imagej.slim.fitting.params.IFitResults; 
     40 
    4041import java.util.List; 
     42 
     43import loci.curvefitter.ICurveFitter; 
    4144 
    4245/** 
     
    4649 */ 
    4750public interface IFittingEngine { 
    48     public ILocalFitResults fit(IGlobalFitParams params, ILocalFitParams data); 
    49     public List<ILocalFitResults> fit(IGlobalFitParams params, List<ILocalFitParams> dataList); 
     51    public void shutdown(); 
    5052    public void setThreads(int threads); 
    51     public void shutdown(); 
     53    public void setCurveFitter(ICurveFitter curveFitter); 
     54    public IFitResults fit(IGlobalFitParams params, ILocalFitParams data); 
     55    public List<IFitResults> fit(IGlobalFitParams params, List<ILocalFitParams> dataList); 
    5256} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/engine/ThreadedFittingEngine.java

    r7807 r7811  
    3737import imagej.slim.fitting.params.ILocalFitParams; 
    3838import imagej.slim.fitting.params.IGlobalFitParams; 
    39 import imagej.slim.fitting.params.ILocalFitResults; 
     39import imagej.slim.fitting.params.IFitResults; 
    4040import imagej.slim.fitting.callable.IFittingEngineCallable; 
    4141import imagej.slim.fitting.config.Configuration; 
     42 
     43import loci.curvefitter.ICurveFitter; 
     44 
    4245import java.util.ArrayList; 
    4346import java.util.List; 
     
    5356    private static int THREADS = 4; 
    5457    private int _threads = THREADS; 
    55     private ThreadPool<ILocalFitResults> _threadPool; 
     58    private ThreadPool<IFitResults> _threadPool; 
     59    private ICurveFitter _curveFitter; 
    5660     
    5761    public ThreadedFittingEngine() { 
    58         _threadPool = new ThreadPool<ILocalFitResults>(); 
     62        _threadPool = new ThreadPool<IFitResults>(); 
    5963    } 
    6064  
     
    7478        _threadPool.setThreads(threads); 
    7579    } 
    76  
     80     
     81    /** 
     82     * Sets curve fitter to use. 
     83     *  
     84     * @param curve fitter  
     85     */ 
     86    public synchronized void setCurveFitter(ICurveFitter curveFitter) { 
     87        _curveFitter = curveFitter; 
     88    } 
     89     
    7790    /** 
    7891     * Fits a single pixel with given parameters. 
     
    8497     * @return results 
    8598     */ 
    86     public synchronized ILocalFitResults fit 
     99    public synchronized IFitResults fit 
    87100            (final IGlobalFitParams params, final ILocalFitParams data) { 
    88101        IFittingEngineCallable callable 
    89102                = Configuration.getInstance().newFittingEngineCallable(); 
    90         callable.setup(null, params, data); //TODO ARG pass in an ICurveFitter 
     103        callable.setup(_curveFitter, params, data); 
    91104        return callable.call(); 
    92105    } 
     
    99112     * @return results one or more pixels results 
    100113     */ 
    101     public synchronized List<ILocalFitResults> fit 
     114    public synchronized List<IFitResults> fit 
    102115            (final IGlobalFitParams params, final List<ILocalFitParams> dataList) { 
    103116         
     
    108121            IFittingEngineCallable callable 
    109122                    = Configuration.getInstance().newFittingEngineCallable(); 
    110             callable.setup(null, params, data); //TODO ARG pass in an ICurveFitter 
     123            callable.setup(_curveFitter, params, data); 
    111124            callableList.add(callable); 
    112125        } 
    113126         
    114         List<ILocalFitResults> resultList = _threadPool.process(callableList); 
     127        List<IFitResults> resultList = _threadPool.process(callableList); 
    115128        return resultList; 
    116129    } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/FitResults.java

    r7805 r7811  
    4040 * @author Aivar Grislis 
    4141 */ 
    42 public class LocalFitResult implements ILocalFitResults { 
    43     private int _id; 
     42public class FitResults implements IFitResults { 
     43    double _chiSquare; 
     44    double[] _params; 
     45    double[] _yFitted; 
    4446     
    45     public void setId(int id) { 
    46         _id = id; 
     47    public void setChiSquare(double chiSquare) { 
     48        _chiSquare = chiSquare; 
    4749    } 
    4850     
    49     public int getId() { 
    50         return _id; 
     51    public double getChiSquare() { 
     52        return _chiSquare; 
     53    } 
     54     
     55    public void setParams(double[] params) { 
     56        _params = params; 
     57    } 
     58     
     59    public double[] getParams() { 
     60        return _params; 
     61    } 
     62     
     63    public void setYFitted(double[] yFitted) { 
     64        _yFitted = yFitted; 
     65    } 
     66     
     67    public double[] getYFitted() { 
     68        return _yFitted; 
    5169    } 
    5270} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/GlobalFitParams.java

    r7806 r7811  
    3535package imagej.slim.fitting.params; 
    3636 
     37import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     38import loci.curvefitter.ICurveFitter.FitFunction; 
     39 
    3740/** 
    3841 * This contains the global fitting parameters, i.e. those valid for the whole 
     
    4245 */ 
    4346public class GlobalFitParams implements IGlobalFitParams { 
     47    private FitAlgorithm _fitAlgorithm; 
     48    private FitFunction _fitFunction; 
     49    private double _xInc; 
    4450    private double[] _prompt; 
    45     int _startPrompt; 
    46     int _stopPrompt; 
    47     int _startDecay; 
    48     int _stopDecay; 
     51    private double _chiSquareTarget; 
     52    private boolean[] _free; 
     53    private int _startPrompt; 
     54    private int _stopPrompt; 
     55    private int _startDecay; 
     56    private int _stopDecay; 
     57  
     58    @Override 
     59    public void setFitAlgorithm(FitAlgorithm fitAlgorithm) { 
     60        _fitAlgorithm = fitAlgorithm; 
     61    } 
    4962     
     63    @Override 
     64    public FitAlgorithm getFitAlgorithm() { 
     65        return _fitAlgorithm; 
     66    } 
     67     
     68    @Override 
     69    public void setFitFunction(FitFunction fitFunction) { 
     70        _fitFunction = fitFunction; 
     71    } 
     72     
     73    @Override 
     74    public FitFunction getFitFunction() { 
     75        return _fitFunction; 
     76    } 
     77     
     78    @Override 
     79    public void setXInc(double xInc) { 
     80        _xInc = xInc; 
     81    } 
     82     
     83    @Override 
     84    public double getXInc() { 
     85        return _xInc; 
     86    } 
     87     
     88    @Override 
    5089    public void setPrompt(double[] prompt) { 
    5190        _prompt = prompt; 
    5291    } 
    5392     
     93    @Override 
    5494    public double[] getPrompt() { 
    5595        return _prompt; 
    5696    } 
    5797     
     98    @Override 
     99    public void setChiSquareTarget(double chiSquareTarget) { 
     100        _chiSquareTarget = chiSquareTarget; 
     101    } 
     102     
     103    @Override 
     104    public double getChiSquareTarget() { 
     105        return _chiSquareTarget; 
     106    } 
     107     
     108    @Override 
     109    public void setFree(boolean[] free) { 
     110        _free = free; 
     111    } 
     112     
     113    @Override 
     114    public boolean[] getFree() { 
     115        return _free; 
     116    } 
     117     
     118    @Override 
    58119    public void setStartPrompt(int startPrompt) { 
    59120        _startPrompt = startPrompt; 
    60121    } 
    61122     
     123    @Override 
    62124    public void setStopPrompt(int stopPrompt) { 
    63125        _stopPrompt = stopPrompt; 
    64126    } 
    65127     
     128    @Override 
    66129    public void setStartDecay(int startDecay) { 
    67130        _startDecay = startDecay; 
    68131    } 
    69132     
     133    @Override 
    70134    public void setStopDecay(int stopDecay) { 
    71135        _stopDecay = stopDecay; 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/IFitResults.java

    r7805 r7811  
    4040 * @author Aivar Grislis 
    4141 */ 
    42 public interface ILocalFitResults { 
    43     public void setId(int id); 
     42public interface IFitResults { 
    4443     
    45     public int getId();    
     44    public void setChiSquare(double chiSquare); 
     45     
     46    public double getChiSquare(); 
     47     
     48    public void setParams(double[] params); 
     49     
     50    public double[] getParams(); 
     51     
     52    public void setYFitted(double[] yFitted); 
     53     
     54    public double[] getYFitted(); 
    4655} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/IGlobalFitParams.java

    r7806 r7811  
    3535package imagej.slim.fitting.params; 
    3636 
     37import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     38import loci.curvefitter.ICurveFitter.FitFunction; 
     39 
    3740/** 
    3841 * Interface for container for the global fitting parameters, i.e. those valid 
     
    4346public interface IGlobalFitParams { 
    4447     
     48    public void setFitAlgorithm(FitAlgorithm fitAlgorithm); 
     49     
     50    public FitAlgorithm getFitAlgorithm(); 
     51     
     52    public void setFitFunction(FitFunction fitFunction); 
     53     
     54    public FitFunction getFitFunction(); 
     55     
     56    public void setXInc(double xInc); 
     57     
     58    public double getXInc(); 
     59     
    4560    public void setPrompt(double[] prompt); 
    4661     
    47     public double[] getPrompt();    
     62    public double[] getPrompt(); 
     63     
     64    public void setChiSquareTarget(double chiSquareTarget); 
     65     
     66    public double getChiSquareTarget(); 
     67     
     68    public void setFree(boolean[] free); 
     69     
     70    public boolean[] getFree(); 
     71     
     72    public void setStartPrompt(int startPrompt); 
     73     
     74    public void setStopPrompt(int stopPrompt); 
     75     
     76    public void setStartDecay(int startDecay); 
     77     
     78    public void setStopDecay(int stopDecay); 
    4879} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/ILocalFitParams.java

    r7805 r7811  
    4343public interface ILocalFitParams { 
    4444     
    45     public void setId(int id); 
     45    public void setY(double[] y); 
    4646     
    47     public int getId();     
     47    public double[] getY(); 
     48     
     49    public void setSig(double[] sig); 
     50     
     51    public double[] getSig(); 
     52     
     53    public void setFitStart(int fitStart); 
     54     
     55    public int getFitStart(); 
     56     
     57    public void setFitStop(int fitStop); 
     58     
     59    public int getFitStop(); 
     60     
     61    public void setParams(double[] params); 
     62     
     63    public double[] getParams(); 
     64     
     65    public void setYFitted(double[] yFitted); //TODO ARG not really a fit param 
     66     
     67    public double[] getYFitted(); //TODO ARG not really a fit param 
    4868} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/params/LocalFitParams.java

    r7805 r7811  
    4242 */ 
    4343public class LocalFitParams implements ILocalFitParams { 
    44     private int _id; 
     44    private double[] _y; 
     45    private double[] _sig; 
     46    private int _fitStart; 
     47    private int _fitStop; 
     48    private double[] _params; 
     49    private double[] _yFitted; 
    4550     
    46     public void setId(int id) { 
    47         _id = id; 
     51    @Override 
     52    public void setY(double[] y) { 
     53        _y = y; 
    4854    } 
    4955     
    50     public int getId() { 
    51         return _id; 
     56    @Override 
     57    public double[] getY() { 
     58        return _y; 
     59    } 
     60  
     61    @Override 
     62    public void setSig(double[] sig) { 
     63        _sig = sig; 
     64    } 
     65 
     66    @Override 
     67    public double[] getSig() { 
     68        return _sig; 
     69    } 
     70     
     71    @Override 
     72    public void setFitStart(int fitStart) { 
     73        _fitStart = fitStart; 
     74    } 
     75     
     76    @Override 
     77    public int getFitStart() { 
     78        return _fitStart; 
     79    } 
     80     
     81    @Override 
     82    public void setFitStop(int fitStop) { 
     83        _fitStop = fitStop; 
     84    } 
     85     
     86    @Override 
     87    public int getFitStop() { 
     88        return _fitStop; 
     89    } 
     90     
     91    @Override 
     92    public void setParams(double[] params) { 
     93        _params = params; 
     94    } 
     95     
     96    @Override 
     97    public double[] getParams() { 
     98        return _params; 
     99    } 
     100     
     101    @Override 
     102    public void setYFitted(double[] yFitted) { 
     103        _yFitted = yFitted; 
     104    } 
     105     
     106    @Override 
     107    public double[] getYFitted() { 
     108        return _yFitted; 
    52109    } 
    53110} 
  • 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.