Changeset 7875 for trunk


Ignore:
Timestamp:
01/27/12 19:47:49 (8 years ago)
Author:
aivar
Message:

Continued refactoring. Fitted image working better now.

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

Legend:

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

    r7811 r7875  
    4747         
    4848        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    49         globalFitParams.setFitAlgorithm(FitAlgorithm.RLD_LMA); 
     49        globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
    5050        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
    5151        globalFitParams.setXInc(xInc); 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/FitInfo.java

    r7867 r7875  
    55package imagej.slim.fitting; 
    66 
     7import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     8import loci.curvefitter.ICurveFitter.FitFunction; 
     9import loci.curvefitter.ICurveFitter.FitRegion; 
     10import loci.curvefitter.ICurveFitter.NoiseModel; 
     11 
    712/** 
    813 * 
     
    1015 */ 
    1116public class FitInfo { 
    12      
    13     public static enum FitRegion { 
    14         SUMMED, ROI, POINT, EACH 
    15     } 
    16  
    17     public static enum FitAlgorithm { 
    18        JAOLHO, SLIMCURVE_RLD, SLIMCURVE_LMA, SLIMCURVE_RLD_LMA 
    19     } 
    20  
    21     public static enum FitFunction { 
    22         SINGLE_EXPONENTIAL, DOUBLE_EXPONENTIAL, TRIPLE_EXPONENTIAL, STRETCHED_EXPONENTIAL 
    23     } 
    24  
    25     public static enum NoiseModel { 
    26         GAUSSIAN_FIT, POISSON_FIT, POISSON_DATA, MAXIMUM_LIKELIHOOD 
    27     } 
    28      
     17    private volatile boolean _cancel = false; 
    2918    private int _channel; 
    3019    private FitRegion _region; 
     
    3726    private int _startDecay; 
    3827    private int _stopDecay; 
     28    private double _xInc; 
    3929    private int _threshold; //TODO this s/b accounted for by IInputImage 
    4030    private double _chiSquareTarget; 
     
    6555 
    6656    /** 
     57     * Gets whether to cancel current fit. 
     58     *  
     59     * @return  
     60     */ 
     61    public boolean getCancel() { 
     62        return _cancel; 
     63    } 
     64 
     65    /** 
     66     * Sets whether to cancel current fit. 
     67     *  
     68     * @param cancel  
     69     */ 
     70    public void setCancel(boolean cancel) { 
     71        _cancel = cancel; 
     72    } 
     73 
     74    /** 
    6775     * Gets current channel 
    6876     *  
     
    242250    public void setStopDecay(int bin) { 
    243251        _stopDecay = bin; 
     252    } 
     253 
     254    /** 
     255     * Gets x increment for each bin. 
     256     *  
     257     * @return  
     258     */ 
     259    public double getXInc() { 
     260        return _xInc; 
     261    } 
     262 
     263    /** 
     264     * Gets prompt or instrument response function. 
     265     * @return  
     266     */ 
     267    public double[] getPrompt() { 
     268        return _prompt; 
     269    } 
     270     
     271    /** 
     272     * Sets prompt or instrument response function. 
     273     *  
     274     * @param prompt  
     275     */ 
     276    public void setPrompt(double[] prompt) { 
     277        _prompt = prompt; 
     278    } 
     279 
     280    /** 
     281     * Gets start of prompt. 
     282     *  
     283     * @return  
     284     */ 
     285    public int getStartPrompt() { 
     286        return _startPrompt; 
     287    } 
     288     
     289    /** 
     290     * Sets start of prompt. 
     291     *  
     292     * @param startPrompt  
     293     */ 
     294    public void setStartPrompt(int startPrompt) { 
     295        _startPrompt = startPrompt; 
     296    } 
     297     
     298    /** 
     299     * Gets end of prompt. 
     300     *  
     301     * @return  
     302     */ 
     303    public int getStopPrompt() { 
     304        return _stopPrompt; 
     305    } 
     306 
     307    /** 
     308     * Sets start of prompt. 
     309     *  
     310     * @param stopPrompt  
     311     */ 
     312    public void setStopPrompt(int stopPrompt) { 
     313        _stopPrompt = stopPrompt; 
     314    } 
     315 
     316    /** 
     317     * Sets x increment for each bin. 
     318     *  
     319     * @param xInc  
     320     */ 
     321    public void setXInc(double xInc) { 
     322        _xInc = xInc; 
    244323    } 
    245324 
     
    416495            case STRETCHED_EXPONENTIAL: 
    417496                components = 1; 
     497                break; 
    418498            case DOUBLE_EXPONENTIAL: 
    419499                components = 2; 
     500                break; 
    420501            case TRIPLE_EXPONENTIAL: 
    421502                components = 3; 
     503                break; 
    422504        } 
    423505        return components; 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/callable/FittingEngineCallable.java

    r7842 r7875  
    4545 
    4646/** 
    47  * This class brings together everything needed to fit one pixel. 
     47 * This class brings together everything needed to fit one pixel.  It is a  
     48 * Callable, meant to be called from multiple threads. 
    4849 * 
    4950 * @author Aivar Grislis 
     
    5455    private ILocalFitParams _localParams; 
    5556    private IFitResults _result; 
    56  
     57     
    5758    @Override 
    5859    public void setup(final ICurveFitter curveFitter, 
     
    7778        curveFitData.setYCount(_localParams.getY()); 
    7879        curveFitData.setSig(_localParams.getSig()); 
    79         curveFitData.setParams(_localParams.getParams()); 
    80         curveFitData.setYFitted(_localParams.getYFitted()); //TODO awkward and kludgey!  How is this a local parameter?  It actually winds up in results. 
     80        curveFitData.setParams(_localParams.getParams().clone()); // params is overwritten 
     81        curveFitData.setYFitted(_localParams.getYFitted()); 
    8182        ICurveFitData[] curveFitDataArray = new ICurveFitData[] { curveFitData }; 
    8283 
     
    8788        _result.setParams(curveFitData.getParams()); 
    8889        _result.setYFitted(curveFitData.getYFitted()); 
    89  
     90  
    9091        return _result; 
    91     } 
     92    }    
    9293} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/AbstractBaseColorizedImage.java

    r7865 r7875  
    111111 
    112112        if (null != minMaxLUT) { 
    113             System.out.println("Internal redisplay " + minMaxLUT[0] + " " + minMaxLUT[1]); 
    114113            //TODO horrible kludge here!!!  But why on earth would these be zero? 
    115114            //TODO #2 wound up enabling this again, otherwise you don't get any images except current image 
     
    118117            } 
    119118        } 
    120         else System.out.println("min max null"); 
    121          
    122         System.out.println("RECALC " + numInvalid(_values)); 
    123119    } 
    124120 
     
    128124     */ 
    129125    public void redisplay() { 
    130         System.out.println("public redisplay"); 
    131126        double[] minMaxLUT = _histogramData.getMinMaxLUT(); 
    132127        redisplay(minMaxLUT); 
     
    139134        minMaxLUT = PaletteFix.adjustMinMax(minMaxLUT[0], minMaxLUT[1]); 
    140135        _image.setMinAndMax(minMaxLUT[0], minMaxLUT[1]); 
    141         System.out.println("SETTING MIN AND MAX LUT TO " + minMaxLUT[0] + " " + minMaxLUT[1]); 
    142136        _imagePlus.setProcessor(_image.duplicate()); 
    143137    } 
    144      
    145     private int numInvalid(double[][] values) { 
    146         int count = 0; 
    147         int num = 0; 
    148         for (int y = 0; y < values[0].length; ++y) { 
    149             for (int x = 0; x < values.length; ++x) { 
    150                 if (Double.isNaN(values[x][y])) { 
    151                     ++num; 
    152                 } 
    153                 ++count; 
    154             } 
    155         } 
    156         System.out.println("checked " + count + " pixels,  found invalid " + num); 
    157         return num; 
    158     }    
     138 
    159139     
    160140    /** 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramData.java

    r7865 r7875  
    200200        minLUT = maxLUT = 0.0; 
    201201        minView = maxView = 0.0; 
    202         if (_displayChannels || _combineChannels) { 
     202        if (1 < _channel.length && (_displayChannels || _combineChannels)) { 
    203203            minData = Double.MAX_VALUE; 
    204204            maxData = Double.MIN_VALUE; 
     
    243243 
    244244        if (null != _listener) { 
    245             System.out.println("tell listener " + _minView + " " + _maxView + "," + _minLUT + " " + _maxLUT); 
    246245            _listener.minMaxChanged(_minView, _maxView, _minLUT, _maxLUT); 
    247246        } 
     
    260259            bin[i] = 0; 
    261260        } 
    262         System.out.println("bin[3] is " + bin[3] + " bin[33] " + bin[33]); 
    263         System.out.println("_minView is " + _minView + " max " + _maxView); 
    264         System.out.println("_minLUT is " + _minLUT + " maxLUT " + _maxLUT); 
    265261         
    266262        if (_displayChannels) { 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramTool.java

    r7861 r7875  
    215215        public void minMaxChanged(double minView, double maxView, 
    216216                double minLUT, double maxLUT) { 
    217             System.out.println("CHANGED " + minView + " " + maxView + ", " + minLUT + " " + maxLUT); 
    218217            changed(minView, maxView, minLUT, maxLUT); 
    219218        } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ChunkyPixel.java

    r7866 r7875  
    4949    final int _width; 
    5050    final int _height; 
    51     final int[] _location; 
     51    int[] _location; 
    5252 
    5353    @Deprecated 
     
    5858        _height = height; 
    5959        _location = null; 
    60     } 
    61  
    62     public ChunkyPixel(int[] location, int width, int height) { 
    63         _location = location; 
    64         _width = width; 
    65         _height = height; 
    66         _x = _location[0]; 
    67         _y = _location[1]; //TODO just transitioning from x,y to location[] 
    6860    } 
    6961 
     
    8375        return _height; 
    8476    } 
     77     
     78    public void setLocation(int[] location) { 
     79        location[0] = _x; 
     80        location[1] = _y; 
     81        _location = location; 
     82    } 
    8583 
    8684    public int[] getLocation() { 
    87         if (null == _location) { 
    88             return new int[] { _x, _y }; 
    89         } 
    9085        return _location; 
    9186    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ChunkyPixelTableImpl.java

    r7668 r7875  
    4848   static final int HEIGHT = 16; 
    4949   static final ChunkyPixel[] m_table = { 
     50        
    5051       // divide 16x16 square into 4 8x8 parts 
    51         new ChunkyPixel( 0,  0, 16, 16), // draw 16x16 at (0,0) 
    52         new ChunkyPixel( 8,  0,  8, 16), // draw 8x16 at (8,0) 
    53         new ChunkyPixel( 0,  8, 16,  8), // draw 16x8 at (0,8) 
    54         new ChunkyPixel( 8,  8,  8,  8), // draw 8x8 at (8,8) 
    55  
    56         // divide 4 8z8 parts into 16 4x4 parts 
    57         new ChunkyPixel( 4,  0,  4,  8), // draw 4x8 at (4,0) 
    58         new ChunkyPixel(12,  0,  4,  8), // draw 4x8 at (12,0) 
    59         new ChunkyPixel( 4,  8,  4,  8), // draw 4x8 at (4,8) 
    60         new ChunkyPixel(12,  8,  4,  8), // draw 4x8 at (12,8) 
    61  
    62         new ChunkyPixel( 0,  4,  8,  4), // draw 8x4 at (0,4) 
    63         new ChunkyPixel( 8,  4,  8,  4), // draw 8x4 at (8,4) 
    64         new ChunkyPixel( 0, 12,  8,  4), // draw 8x4 at (0,12) 
    65         new ChunkyPixel( 8, 12,  8,  4), // draw 8x4 at (8,12) 
    66  
    67         new ChunkyPixel( 4,  4,  4,  4), // draw 4x4 at (4,4) 
    68         new ChunkyPixel(12,  4,  4,  4), // draw 4x4 at (12,4) 
    69         new ChunkyPixel( 4, 12,  4,  4), // draw 4x4 at (4,12) 
    70         new ChunkyPixel(12, 12,  4,  4), // draw 4x4 at (12,12) 
    71  
    72         // divide 16 4x4 parts into 64 2x2 parts 
    73         new ChunkyPixel( 2,  0,  2,  4), // draw 2x4 at (2,0) 
    74         new ChunkyPixel( 6,  0,  2,  4), // draw 2x4 at (6,0) 
    75         new ChunkyPixel(10,  0,  2,  4), // draw 2x4 at (10,0) 
    76         new ChunkyPixel(14,  0,  2,  4), // draw 2x4 at (14,0) 
    77  
    78         new ChunkyPixel( 2,  4,  2,  4), // draw 2x4 at (2,4) 
    79         new ChunkyPixel( 6,  4,  2,  4), // draw 2x4 at (6,4) 
    80         new ChunkyPixel(10,  4,  2,  4), // draw 2x4 at (10,4) 
    81         new ChunkyPixel(14,  4,  2,  4), // draw 2x4 at (14,4) 
    82  
    83         new ChunkyPixel( 2,  8,  2,  4), // draw 2x4 at (2,8) 
    84         new ChunkyPixel( 6,  8,  2,  4), // draw 2x4 at (6,8) 
    85         new ChunkyPixel(10,  8,  2,  4), // draw 2x4 at (10,8) 
    86         new ChunkyPixel(14,  8,  2,  4), // draw 2x4 at (14,8) 
    87  
    88         new ChunkyPixel( 2, 12,  2,  4), // draw 2x4 at (2,12) 
    89         new ChunkyPixel( 6, 12,  2,  4), // draw 2x4 at (6,12) 
    90         new ChunkyPixel(10, 12,  2,  4), // draw 2x4 at (10,12) 
    91         new ChunkyPixel(14, 12,  2,  4), // draw 2x4 at (14,12) 
    92  
    93         new ChunkyPixel( 0,  2,  4,  2), // draw 4x2 at (0,2) 
    94         new ChunkyPixel( 4,  2,  4,  2), // draw 4x2 at (4,2) 
    95         new ChunkyPixel( 8,  2,  4,  2), // draw 4x2 at (8,2) 
    96         new ChunkyPixel(12,  2,  4,  2), // draw 4x2 at (12,2) 
    97  
    98         new ChunkyPixel( 0,  6,  4,  2), // draw 4x2 at (0,6) 
    99         new ChunkyPixel( 4,  6,  4,  2), // draw 4x2 at (4,6) 
    100         new ChunkyPixel( 8,  6,  4,  2), // draw 4x2 at (8,6) 
    101         new ChunkyPixel(12,  6,  4,  2), // draw 4x2 at (12,6) 
    102  
    103         new ChunkyPixel( 0, 10,  4,  2), // draw 4x2 at (0,10) 
    104         new ChunkyPixel( 4, 10,  4,  2), // draw 4x2 at (4,10) 
    105         new ChunkyPixel( 8, 10,  4,  2), // draw 4x2 at (8,10) 
    106         new ChunkyPixel(12, 10,  4,  2), // draw 4x2 at (12,10) 
    107  
    108         new ChunkyPixel( 0, 14,  4,  2), // draw 4x2 at (0,14) 
    109         new ChunkyPixel( 4, 14,  4,  2), // draw 4x2 at (4,14) 
    110         new ChunkyPixel( 8, 14,  4,  2), // draw 4x2 at (8,14) 
    111         new ChunkyPixel(12, 14,  4,  2), // draw 4x2 at (12,14) 
    112  
    113         new ChunkyPixel( 2,  2,  2,  2), // draw 2x2 at (2,2) 
    114         new ChunkyPixel( 6,  2,  2,  2), // draw 2x2 at (6,2) 
    115         new ChunkyPixel(10,  2,  2,  2), // draw 2x2 at (10,2) 
    116         new ChunkyPixel(14,  2,  2,  2), // draw 2x2 at (14,2) 
    117  
    118         new ChunkyPixel( 2,  6,  2,  2), // draw 2x2 at (2,6) 
    119         new ChunkyPixel( 6,  6,  2,  2), // draw 2x2 at (6,6) 
    120         new ChunkyPixel(10,  6,  2,  2), // draw 2x2 at (10,6) 
    121         new ChunkyPixel(14,  6,  2,  2), // draw 2x2 at (14,6) 
    122  
    123         new ChunkyPixel( 2,  10,  2,  2), // draw 2x2 at (2,10) 
    124         new ChunkyPixel( 6,  10,  2,  2), // draw 2x2 at (6,10) 
    125         new ChunkyPixel(10,  10,  2,  2), // draw 2x2 at (10,10) 
    126         new ChunkyPixel(14,  10,  2,  2), // draw 2x2 at (14,10) 
    127  
    128         new ChunkyPixel( 2,  14,  2,  2), // draw 2x2 at (2,14) 
    129         new ChunkyPixel( 6,  14,  2,  2), // draw 2x2 at (6,14) 
    130         new ChunkyPixel(10,  14,  2,  2), // draw 2x2 at (10,14) 
    131         new ChunkyPixel(14,  14,  2,  2), // draw 2x2 at (14,14) 
    132  
    133         // divide 64 2x2 parts into 256 1x1 parts 
    134         new ChunkyPixel( 1,  0,  1,  2), // draw 1x2 at (*,0) 
    135         new ChunkyPixel( 3,  0,  1,  2), 
    136         new ChunkyPixel( 5,  0,  1,  2), 
    137         new ChunkyPixel( 7,  0,  1,  2), 
    138         new ChunkyPixel( 9,  0,  1,  2), 
    139         new ChunkyPixel(11,  0,  1,  2), 
    140         new ChunkyPixel(13,  0,  1,  2), 
    141         new ChunkyPixel(15,  0,  1,  2), 
    142  
    143         new ChunkyPixel( 1,  2,  1,  2), // draw 1x2 at (*,2) 
    144         new ChunkyPixel( 3,  2,  1,  2), 
    145         new ChunkyPixel( 5,  2,  1,  2), 
    146         new ChunkyPixel( 7,  2,  1,  2), 
    147         new ChunkyPixel( 9,  2,  1,  2), 
    148         new ChunkyPixel(11,  2,  1,  2), 
    149         new ChunkyPixel(13,  2,  1,  2), 
    150         new ChunkyPixel(15,  2,  1,  2), 
    151  
    152         new ChunkyPixel( 1,  4,  1,  2), // draw 1x2 at (*,4) 
    153         new ChunkyPixel( 3,  4,  1,  2), 
    154         new ChunkyPixel( 5,  4,  1,  2), 
    155         new ChunkyPixel( 7,  4,  1,  2), 
    156         new ChunkyPixel( 9,  4,  1,  2), 
    157         new ChunkyPixel(11,  4,  1,  2), 
    158         new ChunkyPixel(13,  4,  1,  2), 
    159         new ChunkyPixel(15,  4,  1,  2), 
    160  
    161         new ChunkyPixel( 1,  6,  1,  2), // draw 1x2 at (*,6) 
    162         new ChunkyPixel( 3,  6,  1,  2), 
    163         new ChunkyPixel( 5,  6,  1,  2), 
    164         new ChunkyPixel( 7,  6,  1,  2), 
    165         new ChunkyPixel( 9,  6,  1,  2), 
    166         new ChunkyPixel(11,  6,  1,  2), 
    167         new ChunkyPixel(13,  6,  1,  2), 
    168         new ChunkyPixel(15,  6,  1,  2), 
    169  
    170  
    171         new ChunkyPixel( 1,  8,  1,  2), // draw 1x2 at (*,8) 
    172         new ChunkyPixel( 3,  8,  1,  2), 
    173         new ChunkyPixel( 5,  8,  1,  2), 
    174         new ChunkyPixel( 7,  8,  1,  2), 
    175         new ChunkyPixel( 9,  8,  1,  2), 
    176         new ChunkyPixel(11,  8,  1,  2), 
    177         new ChunkyPixel(13,  8,  1,  2), 
    178         new ChunkyPixel(15,  8,  1,  2), 
    179  
    180         new ChunkyPixel( 1, 10,  1,  2), // draw 1x2 at (*,10) 
    181         new ChunkyPixel( 3, 10,  1,  2), 
    182         new ChunkyPixel( 5, 10,  1,  2), 
    183         new ChunkyPixel( 7, 10,  1,  2), 
    184         new ChunkyPixel( 9, 10,  1,  2), 
    185         new ChunkyPixel(11, 10,  1,  2), 
    186         new ChunkyPixel(13, 10,  1,  2), 
    187         new ChunkyPixel(15, 10,  1,  2), 
    188  
    189  
    190         new ChunkyPixel( 1, 12,  1,  2), // draw 1x2 at (*,12) 
    191         new ChunkyPixel( 3, 12,  1,  2), 
    192         new ChunkyPixel( 5, 12,  1,  2), 
    193         new ChunkyPixel( 7, 12,  1,  2), 
    194         new ChunkyPixel( 9, 12,  1,  2), 
    195         new ChunkyPixel(11, 12,  1,  2), 
    196         new ChunkyPixel(13, 12,  1,  2), 
    197         new ChunkyPixel(15, 12,  1,  2), 
    198  
    199         new ChunkyPixel( 1, 14,  1,  2), // draw 1x2 at (*,14) 
    200         new ChunkyPixel( 3, 14,  1,  2), 
    201         new ChunkyPixel( 5, 14,  1,  2), 
    202         new ChunkyPixel( 7, 14,  1,  2), 
    203         new ChunkyPixel( 9, 14,  1,  2), 
    204         new ChunkyPixel(11, 14,  1,  2), 
    205         new ChunkyPixel(13, 14,  1,  2), 
    206         new ChunkyPixel(15, 14,  1,  2), 
    207  
    208         new ChunkyPixel( 0,  1,  2,  1), // draw 2x1 at (*,1) 
    209         new ChunkyPixel( 2,  1,  2,  1), 
    210         new ChunkyPixel( 4,  1,  2,  1), 
    211         new ChunkyPixel( 6,  1,  2,  1), 
    212         new ChunkyPixel( 8,  1,  2,  1), 
    213         new ChunkyPixel(10,  1,  2,  1), 
    214         new ChunkyPixel(12,  1,  2,  1), 
    215         new ChunkyPixel(14,  1,  2,  1), 
    216  
    217         new ChunkyPixel( 0,  3,  2,  1), // draw 2x1 at (*,3) 
    218         new ChunkyPixel( 2,  3,  2,  1), 
    219         new ChunkyPixel( 4,  3,  2,  1), 
    220         new ChunkyPixel( 6,  3,  2,  1), 
    221         new ChunkyPixel( 8,  3,  2,  1), 
    222         new ChunkyPixel(10,  3,  2,  1), 
    223         new ChunkyPixel(12,  3,  2,  1), 
    224         new ChunkyPixel(14,  3,  2,  1), 
    225  
    226         new ChunkyPixel( 0,  5,  2,  1), // draw 2x1 at (*,5) 
    227         new ChunkyPixel( 2,  5,  2,  1), 
    228         new ChunkyPixel( 4,  5,  2,  1), 
    229         new ChunkyPixel( 6,  5,  2,  1), 
    230         new ChunkyPixel( 8,  5,  2,  1), 
    231         new ChunkyPixel(10,  5,  2,  1), 
    232         new ChunkyPixel(12,  5,  2,  1), 
    233         new ChunkyPixel(14,  5,  2,  1), 
    234  
    235         new ChunkyPixel( 0,  7,  2,  1), // draw 2x1 at (*,7) 
    236         new ChunkyPixel( 2,  7,  2,  1), 
    237         new ChunkyPixel( 4,  7,  2,  1), 
    238         new ChunkyPixel( 6,  7,  2,  1), 
    239         new ChunkyPixel( 8,  7,  2,  1), 
    240         new ChunkyPixel(10,  7,  2,  1), 
    241         new ChunkyPixel(12,  7,  2,  1), 
    242         new ChunkyPixel(14,  7,  2,  1), 
    243  
    244         new ChunkyPixel( 0,  9,  2,  1), // draw 2x1 at (*,9) 
    245         new ChunkyPixel( 2,  9,  2,  1), 
    246         new ChunkyPixel( 4,  9,  2,  1), 
    247         new ChunkyPixel( 6,  9,  2,  1), 
    248         new ChunkyPixel( 8,  9,  2,  1), 
    249         new ChunkyPixel(10,  9,  2,  1), 
    250         new ChunkyPixel(12,  9,  2,  1), 
    251         new ChunkyPixel(14,  9,  2,  1), 
    252  
    253         new ChunkyPixel( 0, 11,  2,  1), // draw 2x1 at (*,11) 
    254         new ChunkyPixel( 2, 11,  2,  1), 
    255         new ChunkyPixel( 4, 11,  2,  1), 
    256         new ChunkyPixel( 6, 11,  2,  1), 
    257         new ChunkyPixel( 8, 11,  2,  1), 
    258         new ChunkyPixel(10, 11,  2,  1), 
    259         new ChunkyPixel(12, 11,  2,  1), 
    260         new ChunkyPixel(14, 11,  2,  1), 
    261  
    262         new ChunkyPixel( 0, 13,  2,  1), // draw 2x1 at (*,13) 
    263         new ChunkyPixel( 2, 13,  2,  1), 
    264         new ChunkyPixel( 4, 13,  2,  1), 
    265         new ChunkyPixel( 6, 13,  2,  1), 
    266         new ChunkyPixel( 8, 13,  2,  1), 
    267         new ChunkyPixel(10, 13,  2,  1), 
    268         new ChunkyPixel(12, 13,  2,  1), 
    269         new ChunkyPixel(14, 13,  2,  1), 
    270  
    271         new ChunkyPixel( 0, 15,  2,  1), // draw 2x1 at (*,15) 
    272         new ChunkyPixel( 2, 15,  2,  1), 
    273         new ChunkyPixel( 4, 15,  2,  1), 
    274         new ChunkyPixel( 6, 15,  2,  1), 
    275         new ChunkyPixel( 8, 15,  2,  1), 
    276         new ChunkyPixel(10, 15,  2,  1), 
    277         new ChunkyPixel(12, 15,  2,  1), 
    278         new ChunkyPixel(14, 15,  2,  1), 
    279  
    280         new ChunkyPixel( 1,  1,  1,  1), // draw 1x1 at (*,1) 
     52        
     53        new ChunkyPixel( 0,  0, 16, 16), // means: at (0, 0), draw 16x16 
     54        new ChunkyPixel( 8,  0,  8, 16), 
     55        new ChunkyPixel( 0,  8,  8,  8), 
     56        new ChunkyPixel( 8,  8,  8,  8), 
     57 
     58        // further divide 4 8z8 parts into 16 4x4 parts 
     59         
     60        new ChunkyPixel( 4,  0,  4,  8), // divide 8x8 at (0, 0) 
     61        new ChunkyPixel( 0,  4,  4,  4), 
     62        new ChunkyPixel( 4,  4,  4,  4), 
     63         
     64        new ChunkyPixel(12,  0,  4,  8), // divide 8x8 at (8, 0) 
     65        new ChunkyPixel( 8,  4,  4,  4), 
     66        new ChunkyPixel(12,  4,  4,  4), 
     67         
     68        new ChunkyPixel( 4,  8,  4,  8), // divide 8x8 at (0, 8) 
     69        new ChunkyPixel( 0, 12,  4,  4), 
     70        new ChunkyPixel( 4, 12,  4,  4), 
     71         
     72        new ChunkyPixel(12,  8,  4,  8), // divide 8x8 at (8, 8) 
     73        new ChunkyPixel( 8, 12,  4,  4), 
     74        new ChunkyPixel(12, 12,  4,  4), 
     75         
     76        // further divide 16 4x4 parts into 64 2x2 parts 
     77         
     78        new ChunkyPixel( 2,  0,  2,  4), // divide 4x4 at (0, 0) 
     79        new ChunkyPixel( 0,  2,  2,  2),         
     80        new ChunkyPixel( 2,  2,  2,  2),  
     81         
     82        new ChunkyPixel( 6,  0,  2,  4), // divide 4x4 at (4, 0) 
     83        new ChunkyPixel( 4,  2,  2,  2), 
     84        new ChunkyPixel( 6,  2,  2,  2), 
     85         
     86        new ChunkyPixel(10,  0,  2,  4), // divide 4x4 at (8, 0) 
     87        new ChunkyPixel( 8,  2,  2,  2),           
     88        new ChunkyPixel(10,  2,  2,  2), 
     89         
     90        new ChunkyPixel(14,  0,  2,  4), // divide 4x4 at (12, 0)      
     91        new ChunkyPixel(12,  2,  2,  2),         
     92        new ChunkyPixel(14,  2,  2,  2), 
     93         
     94        new ChunkyPixel( 2,  4,  2,  4), // divide 4x4 at (0, 4) 
     95        new ChunkyPixel( 0,  6,  2,  2),         
     96        new ChunkyPixel( 2,  6,  2,  2),  
     97         
     98        new ChunkyPixel( 6,  4,  2,  4), // divide 4x4 at (4, 4) 
     99        new ChunkyPixel( 4,  6,  2,  2), 
     100        new ChunkyPixel( 6,  6,  2,  2), 
     101         
     102        new ChunkyPixel(10,  4,  2,  4), // divide 4x4 at (8, 4) 
     103        new ChunkyPixel( 8,  6,  2,  2),           
     104        new ChunkyPixel(10,  6,  2,  2), 
     105         
     106        new ChunkyPixel(14,  4,  2,  4), // divide 4x4 at (12, 4)      
     107        new ChunkyPixel(12,  6,  2,  2),         
     108        new ChunkyPixel(14,  6,  2,  2), 
     109        
     110        new ChunkyPixel( 2,  8,  2,  4), // divide 4x4 at (0, 8) 
     111        new ChunkyPixel( 0, 10,  2,  2),         
     112        new ChunkyPixel( 2, 10,  2,  2),  
     113         
     114        new ChunkyPixel( 6,  8,  2,  4), // divide 4x4 at (4, 8) 
     115        new ChunkyPixel( 4, 10,  2,  2), 
     116        new ChunkyPixel( 6, 10,  2,  2), 
     117         
     118        new ChunkyPixel(10,  8,  2,  4), // divide 4x4 at (8, 8) 
     119        new ChunkyPixel( 8, 10,  2,  2),           
     120        new ChunkyPixel(10, 10,  2,  2), 
     121         
     122        new ChunkyPixel(14,  8,  2,  4), // divide 4x4 at (12, 8)      
     123        new ChunkyPixel(12, 10,  2,  2),         
     124        new ChunkyPixel(14, 10,  2,  2), 
     125 
     126        new ChunkyPixel( 2, 12,  2,  4), // divide 4x4 at (0, 12) 
     127        new ChunkyPixel( 0, 14,  2,  2),         
     128        new ChunkyPixel( 2, 14,  2,  2),  
     129         
     130        new ChunkyPixel( 6, 12,  2,  4), // divide 4x4 at (4, 12) 
     131        new ChunkyPixel( 4, 14,  2,  2), 
     132        new ChunkyPixel( 6, 14,  2,  2), 
     133         
     134        new ChunkyPixel(10, 12,  2,  4), // divide 4x4 at (8, 12) 
     135        new ChunkyPixel( 8, 14,  2,  2),           
     136        new ChunkyPixel(10, 14,  2,  2), 
     137         
     138        new ChunkyPixel(14, 12,  2,  4), // divide 4x4 at (12, 12)      
     139        new ChunkyPixel(12, 14,  2,  2),         
     140        new ChunkyPixel(14, 14,  2,  2), 
     141                 
     142        // further divide 64 2x2 parts into 256 1x1 parts 
     143 
     144        new ChunkyPixel( 1,  0,  1,  2), // divide 2x2 at (0, 0) 
     145        new ChunkyPixel( 0,  1,  1,  1), 
     146        new ChunkyPixel( 1,  1,  1,  1), 
     147         
     148        new ChunkyPixel( 3,  0,  1,  2), // divide 2x2 at (2, 0) 
     149        new ChunkyPixel( 2,  1,  1,  1), 
    281150        new ChunkyPixel( 3,  1,  1,  1), 
     151         
     152        new ChunkyPixel( 5,  0,  1,  2), // divide 2x2 at (4, 0) 
     153        new ChunkyPixel( 4,  1,  1,  1), 
    282154        new ChunkyPixel( 5,  1,  1,  1), 
     155         
     156        new ChunkyPixel( 7,  0,  1,  2), // divide 2x2 at (6, 0) 
     157        new ChunkyPixel( 6,  1,  1,  1), 
    283158        new ChunkyPixel( 7,  1,  1,  1), 
     159         
     160        new ChunkyPixel( 9,  0,  1,  2), // divide 2x2 at (8, 0) 
     161        new ChunkyPixel( 8,  1,  1,  1), 
    284162        new ChunkyPixel( 9,  1,  1,  1), 
     163         
     164        new ChunkyPixel(11,  0,  1,  2), // divide 2x2 at (10, 0) 
     165        new ChunkyPixel(10,  1,  1,  1), 
    285166        new ChunkyPixel(11,  1,  1,  1), 
     167         
     168        new ChunkyPixel(13,  0,  1,  2), // divide 2x2 at (12, 0) 
     169        new ChunkyPixel(12,  1,  1,  1), 
    286170        new ChunkyPixel(13,  1,  1,  1), 
     171         
     172        new ChunkyPixel(15,  0,  1,  2), // divide 2x2 at (14, 0) 
     173        new ChunkyPixel(14,  1,  1,  1), 
    287174        new ChunkyPixel(15,  1,  1,  1), 
    288  
    289         new ChunkyPixel( 1,  3,  1,  1), // draw 1x1 at (*,3) 
     175         
     176 
     177        new ChunkyPixel( 1,  2,  1,  2), // divide 2x2 at (0, 2) 
     178        new ChunkyPixel( 0,  3,  1,  1), 
     179        new ChunkyPixel( 1,  3,  1,  1), 
     180         
     181        new ChunkyPixel( 3,  2,  1,  2), // divide 2x2 at (2, 2) 
     182        new ChunkyPixel( 2,  3,  1,  1), 
    290183        new ChunkyPixel( 3,  3,  1,  1), 
     184         
     185        new ChunkyPixel( 5,  2,  1,  2), // divide 2x2 at (4, 2) 
     186        new ChunkyPixel( 4,  3,  1,  1), 
    291187        new ChunkyPixel( 5,  3,  1,  1), 
     188         
     189        new ChunkyPixel( 7,  2,  1,  2), // divide 2x2 at (6, 2) 
     190        new ChunkyPixel( 6,  3,  1,  1), 
    292191        new ChunkyPixel( 7,  3,  1,  1), 
     192         
     193        new ChunkyPixel( 9,  2,  1,  2), // divide 2x2 at (8, 2) 
     194        new ChunkyPixel( 8,  3,  1,  1), 
    293195        new ChunkyPixel( 9,  3,  1,  1), 
     196         
     197        new ChunkyPixel(11,  2,  1,  2), // divide 2x2 at (10, 2) 
     198        new ChunkyPixel(10,  3,  1,  1), 
    294199        new ChunkyPixel(11,  3,  1,  1), 
     200         
     201        new ChunkyPixel(13,  2,  1,  2), // divide 2x2 at (12, 2) 
     202        new ChunkyPixel(12,  3,  1,  1), 
    295203        new ChunkyPixel(13,  3,  1,  1), 
     204         
     205        new ChunkyPixel(15,  2,  1,  2), // divide 2x2 at (14, 2) 
     206        new ChunkyPixel(14,  3,  1,  1), 
    296207        new ChunkyPixel(15,  3,  1,  1), 
    297  
    298         new ChunkyPixel( 1,  5,  1,  1), // draw 1x1 at (*,5) 
     208         
     209         
     210        new ChunkyPixel( 1,  4,  1,  2), // divide 2x2 at (0, 4) 
     211        new ChunkyPixel( 0,  5,  1,  1), 
     212        new ChunkyPixel( 1,  5,  1,  1), 
     213         
     214        new ChunkyPixel( 3,  4,  1,  2), // divide 2x2 at (2, 4) 
     215        new ChunkyPixel( 2,  5,  1,  1), 
    299216        new ChunkyPixel( 3,  5,  1,  1), 
     217         
     218        new ChunkyPixel( 5,  4,  1,  2), // divide 2x2 at (4, 4) 
     219        new ChunkyPixel( 4,  5,  1,  1), 
    300220        new ChunkyPixel( 5,  5,  1,  1), 
     221         
     222        new ChunkyPixel( 7,  4,  1,  2), // divide 2x2 at (6, 4) 
     223        new ChunkyPixel( 6,  5,  1,  1), 
    301224        new ChunkyPixel( 7,  5,  1,  1), 
     225         
     226        new ChunkyPixel( 9,  4,  1,  2), // divide 2x2 at (8, 4) 
     227        new ChunkyPixel( 8,  5,  1,  1), 
    302228        new ChunkyPixel( 9,  5,  1,  1), 
     229         
     230        new ChunkyPixel(11,  4,  1,  2), // divide 2x2 at (10, 4) 
     231        new ChunkyPixel(10,  5,  1,  1), 
    303232        new ChunkyPixel(11,  5,  1,  1), 
     233         
     234        new ChunkyPixel(13,  4,  1,  2), // divide 2x2 at (12, 4) 
     235        new ChunkyPixel(12,  5,  1,  1), 
    304236        new ChunkyPixel(13,  5,  1,  1), 
     237         
     238        new ChunkyPixel(15,  4,  1,  2), // divide 2x2 at (14, 4) 
     239        new ChunkyPixel(14,  5,  1,  1), 
    305240        new ChunkyPixel(15,  5,  1,  1), 
    306  
    307         new ChunkyPixel( 1,  7,  1,  1), // draw 1x1 at (*,7) 
     241         
     242                 
     243        new ChunkyPixel( 1,  6,  1,  2), // divide 2x2 at (0, 6) 
     244        new ChunkyPixel( 0,  7,  1,  1), 
     245        new ChunkyPixel( 1,  7,  1,  1), 
     246         
     247        new ChunkyPixel( 3,  6,  1,  2), // divide 2x2 at (2, 6) 
     248        new ChunkyPixel( 2,  7,  1,  1), 
    308249        new ChunkyPixel( 3,  7,  1,  1), 
     250         
     251        new ChunkyPixel( 5,  6,  1,  2), // divide 2x2 at (4, 6) 
     252        new ChunkyPixel( 4,  7,  1,  1), 
    309253        new ChunkyPixel( 5,  7,  1,  1), 
     254         
     255        new ChunkyPixel( 7,  6,  1,  2), // divide 2x2 at (6, 6) 
     256        new ChunkyPixel( 6,  7,  1,  1), 
    310257        new ChunkyPixel( 7,  7,  1,  1), 
     258         
     259        new ChunkyPixel( 9,  6,  1,  2), // divide 2x2 at (8, 6) 
     260        new ChunkyPixel( 8,  7,  1,  1), 
    311261        new ChunkyPixel( 9,  7,  1,  1), 
     262         
     263        new ChunkyPixel(11,  6,  1,  2), // divide 2x2 at (10, 6) 
     264        new ChunkyPixel(10,  7,  1,  1), 
    312265        new ChunkyPixel(11,  7,  1,  1), 
     266         
     267        new ChunkyPixel(13,  6,  1,  2), // divide 2x2 at (12, 6) 
     268        new ChunkyPixel(12,  7,  1,  1), 
    313269        new ChunkyPixel(13,  7,  1,  1), 
     270         
     271        new ChunkyPixel(15,  6,  1,  2), // divide 2x2 at (14, 6) 
     272        new ChunkyPixel(14,  7,  1,  1), 
    314273        new ChunkyPixel(15,  7,  1,  1), 
    315  
    316         new ChunkyPixel( 1,  9,  1,  1), // draw 1x1 at (*,9) 
     274         
     275                 
     276        new ChunkyPixel( 1,  8,  1,  2), // divide 2x2 at (0, 8) 
     277        new ChunkyPixel( 0,  9,  1,  1), 
     278        new ChunkyPixel( 1,  9,  1,  1), 
     279         
     280        new ChunkyPixel( 3,  8,  1,  2), // divide 2x2 at (2, 8) 
     281        new ChunkyPixel( 2,  9,  1,  1), 
    317282        new ChunkyPixel( 3,  9,  1,  1), 
     283         
     284        new ChunkyPixel( 5,  8,  1,  2), // divide 2x2 at (4, 8) 
     285        new ChunkyPixel( 4,  9,  1,  1), 
    318286        new ChunkyPixel( 5,  9,  1,  1), 
     287         
     288        new ChunkyPixel( 7,  8,  1,  2), // divide 2x2 at (6, 8) 
     289        new ChunkyPixel( 6,  9,  1,  1), 
    319290        new ChunkyPixel( 7,  9,  1,  1), 
     291         
     292        new ChunkyPixel( 9,  8,  1,  2), // divide 2x2 at (8, 8) 
     293        new ChunkyPixel( 8,  9,  1,  1), 
    320294        new ChunkyPixel( 9,  9,  1,  1), 
     295         
     296        new ChunkyPixel(11,  8,  1,  2), // divide 2x2 at (10, 8) 
     297        new ChunkyPixel(10,  9,  1,  1), 
    321298        new ChunkyPixel(11,  9,  1,  1), 
     299         
     300        new ChunkyPixel(13,  8,  1,  2), // divide 2x2 at (12, 8) 
     301        new ChunkyPixel(12,  9,  1,  1), 
    322302        new ChunkyPixel(13,  9,  1,  1), 
     303         
     304        new ChunkyPixel(15,  8,  1,  2), // divide 2x2 at (14, 8) 
     305        new ChunkyPixel(14,  9,  1,  1), 
    323306        new ChunkyPixel(15,  9,  1,  1), 
    324  
    325         new ChunkyPixel( 1, 11,  1,  1), // draw 1x1 at (*,11) 
     307         
     308              
     309        new ChunkyPixel( 1, 10,  1,  2), // divide 2x2 at (0, 10) 
     310        new ChunkyPixel( 0, 11,  1,  1), 
     311        new ChunkyPixel( 1, 11,  1,  1), 
     312         
     313        new ChunkyPixel( 3, 10,  1,  2), // divide 2x2 at (2, 10) 
     314        new ChunkyPixel( 2, 11,  1,  1), 
    326315        new ChunkyPixel( 3, 11,  1,  1), 
     316         
     317        new ChunkyPixel( 5, 10,  1,  2), // divide 2x2 at (4, 10) 
     318        new ChunkyPixel( 4, 11,  1,  1), 
    327319        new ChunkyPixel( 5, 11,  1,  1), 
     320         
     321        new ChunkyPixel( 7, 10,  1,  2), // divide 2x2 at (6, 10) 
     322        new ChunkyPixel( 6, 11,  1,  1), 
    328323        new ChunkyPixel( 7, 11,  1,  1), 
     324         
     325        new ChunkyPixel( 9, 10,  1,  2), // divide 2x2 at (8, 10) 
     326        new ChunkyPixel( 8, 11,  1,  1), 
    329327        new ChunkyPixel( 9, 11,  1,  1), 
     328         
     329        new ChunkyPixel(11, 10,  1,  2), // divide 2x2 at (10, 10) 
     330        new ChunkyPixel(10, 11,  1,  1), 
    330331        new ChunkyPixel(11, 11,  1,  1), 
     332         
     333        new ChunkyPixel(13, 10,  1,  2), // divide 2x2 at (12, 10) 
     334        new ChunkyPixel(12, 11,  1,  1), 
    331335        new ChunkyPixel(13, 11,  1,  1), 
     336         
     337        new ChunkyPixel(15, 10,  1,  2), // divide 2x2 at (14, 10) 
     338        new ChunkyPixel(14, 11,  1,  1), 
    332339        new ChunkyPixel(15, 11,  1,  1), 
    333  
    334         new ChunkyPixel( 1, 13,  1,  1), // draw 1x1 at (*,13) 
     340         
     341                         
     342        new ChunkyPixel( 1, 12,  1,  2), // divide 2x2 at (0, 12) 
     343        new ChunkyPixel( 0, 13,  1,  1), 
     344        new ChunkyPixel( 1, 13,  1,  1), 
     345         
     346        new ChunkyPixel( 3, 12,  1,  2), // divide 2x2 at (2, 12) 
     347        new ChunkyPixel( 2, 13,  1,  1), 
    335348        new ChunkyPixel( 3, 13,  1,  1), 
     349         
     350        new ChunkyPixel( 5, 12,  1,  2), // divide 2x2 at (4, 12) 
     351        new ChunkyPixel( 4, 13,  1,  1), 
    336352        new ChunkyPixel( 5, 13,  1,  1), 
     353         
     354        new ChunkyPixel( 7, 12,  1,  2), // divide 2x2 at (6, 12) 
     355        new ChunkyPixel( 6, 13,  1,  1), 
    337356        new ChunkyPixel( 7, 13,  1,  1), 
     357         
     358        new ChunkyPixel( 9, 12,  1,  2), // divide 2x2 at (8, 12) 
     359        new ChunkyPixel( 8, 13,  1,  1), 
    338360        new ChunkyPixel( 9, 13,  1,  1), 
     361         
     362        new ChunkyPixel(11, 12,  1,  2), // divide 2x2 at (10, 12) 
     363        new ChunkyPixel(10, 13,  1,  1), 
    339364        new ChunkyPixel(11, 13,  1,  1), 
     365         
     366        new ChunkyPixel(13, 12,  1,  2), // divide 2x2 at (12, 12) 
     367        new ChunkyPixel(12, 13,  1,  1), 
    340368        new ChunkyPixel(13, 13,  1,  1), 
     369         
     370        new ChunkyPixel(15, 12,  1,  2), // divide 2x2 at (14, 12) 
     371        new ChunkyPixel(14, 13,  1,  1), 
    341372        new ChunkyPixel(15, 13,  1,  1), 
    342  
    343         new ChunkyPixel( 1, 15,  1,  1), // draw 1x1 at (*,15) 
     373         
     374                         
     375        new ChunkyPixel( 1, 14,  1,  2), // divide 2x2 at (0, 14) 
     376        new ChunkyPixel( 0, 15,  1,  1), 
     377        new ChunkyPixel( 1, 15,  1,  1), 
     378         
     379        new ChunkyPixel( 3, 14,  1,  2), // divide 2x2 at (2, 14) 
     380        new ChunkyPixel( 2, 15,  1,  1), 
    344381        new ChunkyPixel( 3, 15,  1,  1), 
     382         
     383        new ChunkyPixel( 5, 14,  1,  2), // divide 2x2 at (4, 14) 
     384        new ChunkyPixel( 4, 15,  1,  1), 
    345385        new ChunkyPixel( 5, 15,  1,  1), 
     386         
     387        new ChunkyPixel( 7, 14,  1,  2), // divide 2x2 at (6, 14) 
     388        new ChunkyPixel( 6, 15,  1,  1), 
    346389        new ChunkyPixel( 7, 15,  1,  1), 
     390         
     391        new ChunkyPixel( 9, 14,  1,  2), // divide 2x2 at (8, 14) 
     392        new ChunkyPixel( 8, 15,  1,  1), 
    347393        new ChunkyPixel( 9, 15,  1,  1), 
     394         
     395        new ChunkyPixel(11, 14,  1,  2), // divide 2x2 at (10, 14) 
     396        new ChunkyPixel(10, 15,  1,  1), 
    348397        new ChunkyPixel(11, 15,  1,  1), 
     398         
     399        new ChunkyPixel(13, 14,  1,  2), // divide 2x2 at (12, 14) 
     400        new ChunkyPixel(12, 15,  1,  1), 
    349401        new ChunkyPixel(13, 15,  1,  1), 
     402         
     403        new ChunkyPixel(15, 14,  1,  2), // divide 2x2 at (14, 14) 
     404        new ChunkyPixel(14, 15,  1,  1), 
    350405        new ChunkyPixel(15, 15,  1,  1) 
    351406   }; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/CursorHelper.java

    r7811 r7875  
    3838import loci.curvefitter.ICurveFitData; 
    3939import loci.curvefitter.ICurveFitter; 
     40import loci.curvefitter.ICurveFitter.FitAlgorithm; 
    4041import loci.curvefitter.SLIMCurveFitter; 
    4142 
     
    287288 
    288289            SLIMCurveFitter curveFitter = new SLIMCurveFitter(); 
    289             curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD_LMA); 
     290            curveFitter.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
    290291            curveFitter.setXInc(xInc); 
    291292            curveFitter.setFree(free); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/DecayImageWrapper.java

    r7867 r7875  
    2626    private int _height; 
    2727    private int _channels; 
     28    private int _channelIndex; 
    2829    private int _bins; 
     30    private int _binIndex; 
    2931    private LocalizableByDimCursor<T> _cursor; 
    3032     
    31     public DecayImageWrapper(Image<T> image) { 
     33    public DecayImageWrapper(Image<T> image, int width, int height, 
     34            int channels, int channelIndex, int bins, int binIndex) { 
    3235        _image = image; 
    33         int[] dimensions = image.getDimensions(); 
    34         //TODO this is a hack to handle IJ1 images 
    35         if (3 == dimensions.length) { 
    36             _width    = dimensions[0]; 
    37             _height   = dimensions[1]; 
    38             _channels = 1; 
    39             _bins     = dimensions[2]; 
    40         } 
    41         else if (4 == dimensions.length) { 
    42             _width    = dimensions[0]; 
    43             _height   = dimensions[1]; 
    44             _channels = dimensions[2]; 
    45             _bins     = dimensions[3]; 
    46         } 
    47         else throw new UnsupportedOperationException 
    48                 ("Image dimensions " + dimensions.length + " not supported."); 
     36        _width = width; 
     37        _height = height; 
     38        _channels = channels; 
     39        _channelIndex = channelIndex; 
     40        _bins = bins; 
     41        _binIndex = binIndex; 
     42 
     43        _cursor = image.createLocalizableByDimCursor(); 
    4944    } 
    5045     
     
    10499    public double[] getPixel(int x, int y, int channel) { 
    105100        double[] decay = new double[_bins]; 
    106         int[] location = new int[] { x, y, channel, 0 }; 
     101        int[] location; 
     102         
     103        if (_channels > 1) { 
     104            location = new int[] { x, y, 0, 0 }; 
     105            location[_channelIndex] = channel; 
     106        } 
     107        else { 
     108            location = new int[] { x, y, 0 }; 
     109        } 
     110 
    107111        for (int i = 0; i < _bins; ++i) { 
    108             location[3] = i; 
     112            location[_binIndex] = i; 
    109113            _cursor.moveTo(location); 
    110114            decay[i] = _cursor.getType().getRealFloat(); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/OutputImageWrapper.java

    r7866 r7875  
    2525    private int _channels; 
    2626    private int _parameters; 
     27    private int _parameterIndex; 
    2728    private LocalizableByDimCursor<DoubleType> _cursor; 
    28      
    29     public OutputImageWrapper(Image<DoubleType> image) { 
    30         _image = image; 
    31         int[] dimensions = image.getDimensions(); 
    32         if (dimensions.length >= 4) { 
    33             _width = dimensions[0]; 
    34             _height = dimensions[1]; 
    35             _channels = dimensions[2]; 
    36             _parameters = dimensions[3]; 
    37             _cursor = _image.createLocalizableByDimCursor(); 
    38         } 
    39     } 
    40      
     29 
     30    //TODO s/b OutputImageWrapper(int[] dimensions) 
     31    //TODO is this a wrapper any more, if it creates the wrapped thing 
    4132    public OutputImageWrapper(int width, int height, int channels, int parameters) { 
    42         Image<DoubleType> _image = null; 
     33         
     34        System.out.println("creating output width height channels params " + width + " " + height + " " + channels + " " + parameters); 
     35         
     36         
    4337        _width = width; 
    4438        _height = height; 
     
    4943        if (1 == width) ++width; 
    5044        if (1 == height) ++height; 
    51         if (1 == channels) ++channels; 
    5245         
    53         int[] dimensions = { width, height, channels, parameters }; 
     46        int[] dimensions; 
     47        if (1 == channels) { 
     48            dimensions = new int[] { width, height, parameters }; 
     49            _parameterIndex = 2; 
     50        } 
     51        else { 
     52            dimensions = new int[] { width, height, channels, parameters }; 
     53            _parameterIndex = 3; 
     54        } 
    5455        _image = new ImageFactory<DoubleType> 
    5556                (new DoubleType(), 
    5657                 new PlanarContainerFactory()).createImage(dimensions, "Fitted"); 
    5758         
    58         // initialize image 
     59        // fill image with NaNs 
    5960        Cursor<DoubleType> cursor = _image.createCursor(); 
    6061        while (cursor.hasNext()) { 
     
    120121    public double[] getPixel(int[] location) { 
    121122        double[] parameters = new double[_parameters]; 
    122         int parameterIndex = location.length - 1; 
    123123        for (int i = 0; i < _parameters; ++i) { 
    124             location[parameterIndex] = i; 
     124            location[_parameterIndex] = i; 
    125125            _cursor.moveTo(location); 
    126126            parameters[i] = _cursor.getType().getRealFloat(); 
     
    130130 
    131131    public void setPixel(int[] location, double[] value) { 
    132         int parameterIndex = location.length - 1; 
    133132        for (int i = 0; i < _parameters; ++i) { 
    134             location[parameterIndex] = i; 
     133            location[_parameterIndex] = i; 
    135134            _cursor.moveTo(location); 
    136135            _cursor.getType().set(value[i]); 
     
    149148    public double[] getPixel(int x, int y, int channel) { 
    150149        double[] parameters = new double[_parameters]; 
    151         int[] location = new int[] { x, y, channel, 0 }; 
     150        int[] location; 
     151        if (_channels > 1) { 
     152            location = new int[] { x, y, channel, 0 }; 
     153        } 
     154        else { 
     155            location = new int[] { x, y, 0 }; 
     156        } 
    152157        for (int i = 0; i < _parameters; ++i) { 
    153             location[3] = i; 
     158            location[_parameterIndex] = i; 
    154159            _cursor.moveTo(location); 
    155160            parameters[i] = _cursor.getType().getRealFloat(); 
     
    168173    @Override 
    169174    public void setPixel(int x, int y, int channel, double[] parameters) { 
    170         int[] location = new int[] { x, y, channel, 0 }; 
     175        int[] location; 
     176        if (_channels > 1) { 
     177            location = new int[] { x, y, channel, 0 }; 
     178        } 
     179        else { 
     180            location = new int[] { x, y, 0 }; 
     181        } 
    171182        for (int i = 0; i < _parameters; ++i) { 
    172             location[3] = i; 
     183            location[_parameterIndex] = i; 
    173184            _cursor.moveTo(location); 
    174185            _cursor.getType().set(parameters[i]); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7867 r7875  
    3939import ij.gui.GenericDialog; 
    4040import ij.gui.Roi; 
     41import ij.io.OpenDialog; 
    4142import ij.plugin.frame.RoiManager; 
    4243import ij.process.ColorProcessor; 
     
    9697import imagej.slim.fitting.images.ColorizedImageFitter; 
    9798import imagej.slim.fitting.images.ColorizedImageFitter.ColorizedImageType; 
    98 import imagej.slim.fitting.FitInfo.FitAlgorithm; 
    99 import imagej.slim.fitting.FitInfo.FitFunction; 
    100 import imagej.slim.fitting.FitInfo.FitRegion; 
    101 import imagej.slim.fitting.FitInfo.NoiseModel; 
     99import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     100import loci.curvefitter.ICurveFitter.FitFunction; 
     101import loci.curvefitter.ICurveFitter.FitRegion; 
     102import loci.curvefitter.ICurveFitter.NoiseModel; 
    102103 
    103104 
     
    127128 
    128129    // this affects how many pixels we process at once 
    129     private static final int PIXEL_COUNT = 128; //32;//16; 
     130    private static final int PIXEL_COUNT = 128; 
    130131 
    131132    // Unicode special characters 
     
    151152 
    152153    private static final String FILE_KEY = "file"; 
     154    private static final String PATH_KEY = "path"; 
    153155    private String m_file; 
     156    private String m_path; 
    154157 
    155158    IFormatReader m_reader; 
     
    165168    private boolean m_hasChannels; 
    166169    private int m_channels; 
     170    private int m_channelIndex; 
    167171    private int m_width; 
    168172    private int m_height; 
    169173    private int[] m_cLengths; 
    170     private int m_timeBins; 
    171     private int m_lifetimeIndex; 
    172     private int m_spectraIndex; 
     174    private int m_bins; 
     175    private int m_binIndex; 
    173176 
    174177    private boolean m_little; 
     
    206209    private int m_threshold; 
    207210    private float m_chiSqTarget; 
     211     
     212    private FitInfo m_fitInfo; 
    208213 
    209214    private int m_debug = 0; 
     
    236241        boolean success = false; 
    237242        if (showFileDialog(getFileFromPreferences())) { 
    238             m_image = loadImage(m_file); 
     243            m_image = loadImage(m_path, m_file); 
    239244            if (null == m_image) { 
    240245                System.out.println("image is null"); 
    241246            } 
    242247            if (getImageInfo(m_image)) { 
    243                 saveFileInPreferences(m_file); 
     248                savePathAndFileInPreferences(m_path, m_file); 
    244249                success = true; 
    245250            } 
     
    267272        uiPanel.setX(0); 
    268273        uiPanel.setY(0); 
    269         uiPanel.setStart(m_timeBins / 2, false); //TODO hokey 
    270         uiPanel.setStop(m_timeBins - 1, false); 
     274        uiPanel.setStart(m_bins / 2, false); //TODO hokey 
     275        uiPanel.setStop(m_bins - 1, false); 
    271276        uiPanel.setThreshold(100); 
    272277        uiPanel.setChiSquareTarget(1.5); 
     
    290295                public void cancelFit() { 
    291296                    m_cancel = true; 
     297                    if (null != m_fitInfo) { 
     298                        m_fitInfo.setCancel(true); 
     299                    } 
    292300                } 
    293301                 
     
    333341                    int x = uiPanel.getX(); 
    334342                    int y = uiPanel.getY(); 
    335                     float[] values = new float[m_timeBins]; 
    336                     for (int b = 0; b < m_timeBins; ++b) { 
     343                    float[] values = new float[m_bins]; 
     344                    for (int b = 0; b < m_bins; ++b) { 
    337345                        values[b] = (float) getData(m_cursor, channel, x, y, b); 
    338346                    } 
     
    422430    private void updateDecayCursors(IUserInterfacePanel uiPanel) { 
    423431        // sum selected channel 
    424         double[] decay = new double[m_timeBins]; 
     432        double[] decay = new double[m_bins]; 
    425433        for (int i = 0; i < decay.length; ++i) { 
    426434            decay[i] = 0.0; 
     
    428436        for (int y = 0; y < m_height; ++y) { 
    429437            for (int x = 0; x < m_width; ++x) { 
    430                 for (int b = 0; b < m_timeBins; ++b) { 
     438                for (int b = 0; b < m_bins; ++b) { 
    431439                    decay[b] += getData(m_cursor, m_channel, x, y, b); 
    432440                } 
     
    451459                channel = m_grayScaleImage.getChannel(); 
    452460            } 
    453             double[] decay = new double[m_timeBins]; 
     461            double[] decay = new double[m_bins]; 
    454462            for (int i = 0; i < decay.length; ++i) { 
    455463                decay[i] = 0.0; 
     
    457465            for (int y = 0; y < m_height; ++y) { 
    458466                for (int x = 0; x < m_width; ++x) { 
    459                     for (int b = 0; b < m_timeBins; ++b) { 
     467                    for (int b = 0; b < m_bins; ++b) { 
    460468                        decay[b] += getData(m_cursor, channel, x, y, b); 
    461469                    } 
     
    502510     * @return 
    503511     */ 
    504     private boolean showFileDialog(String defaultFile) { 
    505         //TODO shouldn't UI be in separate class? 
    506         //TODO need to include fiji-lib.jar in repository: 
    507         //GenericDialogPlus dialog = new GenericDialogPlus("Load Data"); 
    508         GenericDialog dialog = new GenericDialog("Load Data"); 
    509         //TODO works with GenericDialogPlus, dialog.addFileField("File:", defaultFile, 24); 
    510         dialog.addStringField("File", defaultFile); 
    511         dialog.showDialog(); 
    512         if (dialog.wasCanceled()) { 
    513             return false; 
    514         } 
    515         m_file = dialog.getNextString(); 
     512    private boolean showFileDialog(String[] defaultPathAndFile) { 
     513        OpenDialog dialog = new OpenDialog("Load Data", m_path, m_file); 
     514        //if (dialog.wasCanceled()) return false; 
     515        m_path = dialog.getDirectory(); 
     516        m_file = dialog.getFileName(); 
     517        System.out.println("directory is " + dialog.getDirectory()); 
     518        System.out.println("file is " + dialog.getFileName()); 
    516519        return true; 
    517520    } 
    518521 
    519     private Image<T> loadImage(String file) { 
     522    private Image<T> loadImage(String path, String file) { 
    520523        boolean threwException = false; 
    521524        ImageOpener imageOpener = new ImageOpener(); 
    522525        Image<T> image = null; 
    523526        try { 
    524             image = imageOpener.openImage(file); 
    525         } 
    526         catch (java.io.IOException e) { } 
    527         catch (loci.formats.FormatException e) { 
     527            image = imageOpener.openImage(path + file); 
     528        } 
     529        //catch (java.io.IOException e) { } 
     530        //catch (loci.formats.FormatException e) { 
     531        catch (Exception e) { 
    528532            System.out.println("Exception message: " + e.getMessage()); 
    529533            threwException = true; 
     
    540544            dimensions = image.getDimensions(); 
    541545            System.out.println("dimensions size is " + dimensions.length); 
     546            for (int i : dimensions) { 
     547                System.out.print("" + i + " "); 
     548            } 
     549            System.out.println(); 
    542550        } 
    543551        catch (NullPointerException e) { 
     
    554562        if (dimensions.length > 3) { 
    555563            m_hasChannels = true; 
    556             m_channels = dimensions[3]; 
     564            m_channelIndex = 3; 
     565            m_channels = dimensions[m_channelIndex]; 
    557566        } 
    558567        System.out.println("corrected to " + m_channels); 
    559         m_timeBins = ImageUtils.getDimSize(image, FormatTools.LIFETIME); 
    560         System.out.println("width " + m_width + " height " + m_height + " timeBins " + m_timeBins + " channels " + m_channels); 
     568        m_bins = ImageUtils.getDimSize(image, FormatTools.LIFETIME); 
     569        m_binIndex = 2; 
     570        System.out.println("width " + m_width + " height " + m_height + " timeBins " + m_bins + " channels " + m_channels); 
    561571        m_cursor = image.createLocalizableByDimCursor(); 
    562572        /* 
     
    622632 
    623633    /** 
    624      * Restores file name from Java Preferences. 
     634     * Restores path and file name from Java Preferences. 
    625635     * 
    626      * @return file name String 
    627      */ 
    628     private String getFileFromPreferences() { 
     636     * @return String array with path and file name 
     637     */ 
     638    private String[] getFileFromPreferences() { 
    629639       Preferences prefs = Preferences.userNodeForPackage(this.getClass()); 
    630        return prefs.get(FILE_KEY, ""); 
     640       String path = prefs.get(PATH_KEY, ""); 
     641       String file = prefs.get(FILE_KEY, ""); 
     642        
     643       System.out.println("path " + path + " file " + file); 
     644       return new String[] { prefs.get(PATH_KEY, ""), prefs.get(FILE_KEY, "") }; 
    631645    } 
    632646 
    633647    /** 
    634      * Saves the file name to Java Preferences. 
     648     * Saves the path and file names to Java Preferences. 
    635649     * 
     650     * @param path 
    636651     * @param file 
    637652     */ 
    638     private void saveFileInPreferences(String file) { 
     653    private void savePathAndFileInPreferences(String path, String file) { 
    639654        Preferences prefs = Preferences.userNodeForPackage(this.getClass()); 
     655        prefs.put(PATH_KEY, path); 
    640656        prefs.put(FILE_KEY, file); 
    641657    } 
     
    668684            } 
    669685        } 
     686        System.out.println("fitted iage is " + fittedImage); 
    670687        if (null != fittedImage) { 
     688            System.out.println("not null"); 
    671689            for (String analysis : uiPanel.getAnalysisList()) { 
     690                System.out.println("analsysis " + analysis); 
    672691                m_analysis.doAnalysis(analysis, fittedImage, uiPanel.getRegion(), uiPanel.getFunction()); //TODO get from uiPanel or get from global?  re-evaluate approach here 
    673692            } 
     
    698717        return fitInfo; 
    699718    } 
    700      
    701     private IFittedImage wrapOutputImage() { 
    702         IFittedImage returnValue = null; //TODO 
    703         return returnValue; 
    704     } 
    705  
     719 
     720    /** 
     721     * Fits all the pixels in the image.  Gets fit settings from the UI panel 
     722     * and various globals. 
     723     *  
     724     * @param uiPanel 
     725     * @return  
     726     */ 
    706727    private Image<DoubleType> fitImage(IUserInterfacePanel uiPanel) { 
    707728        // get fit settings from the UI panel 
    708729        FitInfo fitInfo = getFitInfo(m_grayScaleImage, uiPanel); 
     730        fitInfo.setXInc(m_timeRange); 
     731        if (null != m_excitationPanel) { 
     732            fitInfo.setPrompt(m_excitationPanel.getValues(1)); 
     733            fitInfo.setStartPrompt(0); 
     734            fitInfo.setStopPrompt(100); 
     735        } 
     736        m_fitInfo = fitInfo; 
    709737         
    710738        // set up images 
    711         IDecayImage decayImage = new DecayImageWrapper(m_image); 
     739        IDecayImage decayImage = new DecayImageWrapper(m_image, m_width, m_height, m_channels, m_channelIndex, m_bins, m_binIndex); 
    712740        IFittedImage previousImage = null; 
    713         IFittedImage newImage = wrapOutputImage(); 
    714          
    715         // get the fitting engine to use 
     741        int width = decayImage.getWidth(); 
     742        int height = decayImage.getHeight(); 
     743        int channels = 1; 
     744        if (fitInfo.getFitAllChannels()) { 
     745            channels = decayImage.getChannels(); 
     746        } 
     747        int parameters = fitInfo.getParameterCount(); 
     748        IFittedImage newImage = new OutputImageWrapper(width, height, channels, parameters); 
     749         
     750        // create a fitting engine to use 
    716751        IFittingEngine fittingEngine = Configuration.getInstance().getFittingEngine(); 
     752        ICurveFitter curveFitter = getCurveFitter(uiPanel); //TODO ARG shouldn't all UI panel info go into FitInfo??? 
     753        fittingEngine.setCurveFitter(curveFitter); 
     754         
    717755        return fitImage(fittingEngine, fitInfo, decayImage, previousImage, newImage); 
    718756 
     
    751789        // handle optionally producing colorized images during the fit 
    752790        ColorizedImageFitter imageColorizer = null; 
    753         String outputs = null; //TODO fitInfo.getFittedImages(); 
     791        String outputs = fitInfo.getFittedImages(); 
    754792        if (null != outputs) { 
    755793            int components = fitInfo.getComponents(); 
     
    757795            ColorizedImageParser parser = new ColorizedImageParser(outputs, components, stretched); 
    758796            ColorizedImageType[] outputImages = parser.getColorizedImages(); 
     797            imageColorizer = new ColorizedImageFitter(); 
    759798            imageColorizer.setUpFit(outputImages, dimension, components); 
    760799            imageColorizer.beginFit(); 
    761800        } 
    762801   
     802        // set up global, image-wide fit parameters 
     803        //TODO revisit all of these 
     804        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     805        globalFitParams.setFitAlgorithm(fitInfo.getAlgorithm()); 
     806        globalFitParams.setFitFunction(fitInfo.getFunction()); 
     807        globalFitParams.setNoiseModel(fitInfo.getNoiseModel()); 
     808        globalFitParams.setStartDecay(fitInfo.getStartDecay()); 
     809        globalFitParams.setStopDecay(fitInfo.getStopDecay()); 
     810        globalFitParams.setXInc(fitInfo.getXInc()); 
     811        globalFitParams.setPrompt(fitInfo.getPrompt()); 
     812        globalFitParams.setStartPrompt(fitInfo.getStartPrompt()); 
     813        globalFitParams.setStopPrompt(fitInfo.getStopPrompt()); 
     814        globalFitParams.setChiSquareTarget(fitInfo.getChiSquareTarget()); 
     815        globalFitParams.setFree(fitInfo.getFree()); //TODO translateFree(uiPanel.getFunction(), uiPanel.getFree()));; 
     816      
    763817        // initialize class used for 'chunky pixel' effect 
    764818        IChunkyPixelTable chunkyPixelTable = new ChunkyPixelTableImpl(); 
    765819         
    766         // set up global, image-wide fit parameters 
    767         IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    768        ///TODO globalFitParams.setFitAlgorithm(fitInfo.getAlgorithm()); 
    769        ///TODO  globalFitParams.setFitFunction(fitInfo.getFunction()); 
    770         globalFitParams.setFree(fitInfo.getFree()); //TODO translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
    771        ///TODO globalFitParams.setNoiseModel(fitInfo.getNoiseModel()); 
    772         globalFitParams.setChiSquareTarget(fitInfo.getChiSquareTarget()); 
    773         globalFitParams.setXInc(m_timeRange); //TODO NO NO NO 
    774         globalFitParams.setPrompt(null); 
    775         if (null != m_excitationPanel) { 
    776             globalFitParams.setPrompt(m_excitationPanel.getValues(1)); //TODO NO NO AGAIN no globals in this method! 
    777         } 
    778       
    779820        List<ChunkyPixel> pixelList = new ArrayList<ChunkyPixel>();        
    780821        List<ILocalFitParams> localFitParamsList = new ArrayList<ILocalFitParams>(); 
     
    786827                    new ChunkyPixelEffectIterator(chunkyPixelTable, width, height); 
    787828             
    788             while (!m_cancel && pixelIterator.hasNext()) { //TODO pass in a class that does the cancel notification 
     829            while (!fitInfo.getCancel() && pixelIterator.hasNext()) { 
    789830                IJ.showProgress(++pixelCount, totalPixelCount); 
    790831                ChunkyPixel pixel = pixelIterator.next(); 
     
    795836                    // set up local, pixel fit parameters 
    796837                    ILocalFitParams localFitParams = new LocalFitParams(); 
     838                    localFitParams.setY(decayImage.getPixel(x, y, c)); 
     839                    double[] decay = decayImage.getPixel(x, y, c); 
     840                    localFitParams.setSig(null); 
     841                    localFitParams.setFitStart(fitInfo.getStartDecay()); 
     842                    localFitParams.setFitStop(fitInfo.getStopDecay()); 
     843                    localFitParams.setParams(fitInfo.getParameters()); 
     844                    double[] yFitted = new double[1024]; //TODO ARG s/b based on bins 
     845                    localFitParams.setYFitted(yFitted); 
    797846                     
     847                    pixel.setLocation(new int[] { x, y, c });                    
    798848                    pixelList.add(pixel); 
    799849                    localFitParamsList.add(localFitParams); 
     
    810860                    } 
    811861                } 
    812                  
    813  
    814  
    815                 /* 
    816                  
    817                 if (wantFitted(m_channel, pixel.getX(), pixel.getY())) { 
    818                     curveFitData = new CurveFitData(); 
    819                     curveFitData.setChannel(m_channel); 
    820                     curveFitData.setX(pixel.getX()); 
    821                     curveFitData.setY(pixel.getY()); 
    822                     curveFitData.setParams( 
    823                         useFittedParams ? 
    824                             getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
    825                                 params.clone()); 
    826                     yCount = new double[m_timeBins]; 
    827                     for (int b = 0; b < m_timeBins; ++b) { 
    828                         yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
    829                     } 
    830                     curveFitData.setYCount(yCount); 
    831                     yFitted = new double[m_timeBins]; 
    832                     curveFitData.setYFitted(yFitted); 
    833                     curveFitDataList.add(curveFitData); 
    834                     pixelList.add(pixel); 
    835  
    836                     // process the pixels 
    837                     if (++pixelsToProcessCount >= PIXEL_COUNT) { 
    838                         ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    839                         ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
    840                         processPixelsXYZ(data, pixels, imageFitter); 
    841                         curveFitDataList.clear(); 
    842                         pixelList.clear(); 
    843                         pixelsToProcessCount = 0; 
    844                     } 
    845                 } 
    846                  */ 
    847             } 
    848         } 
    849          
    850         //TODO REENABLE THIS BECAUSE YOU"RE LOSING SOME PIXELS HERE: 
    851          
    852  /*       if (m_cancel) { 
     862            } 
     863        } 
     864         
     865        if (fitInfo.getCancel()) { 
    853866            IJ.showProgress(0, 0); 
    854867            cancelImageFit(); 
    855             imageFitter.cancelFit(); 
     868            if (null != imageColorizer) { 
     869                imageColorizer.cancelFit(); 
     870            } 
    856871            return null; 
    857872        } 
    858873        else { 
    859874            if (pixelsToProcessCount > 0) { 
    860                 ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    861                 ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
    862                 processPixelsXYZ(data, pixels, imageFitter); 
    863             } 
    864             imageFitter.endFit(); 
    865         }   */ 
    866          
    867         return null; 
     875                System.out.println("finishing up " + pixelsToProcessCount + " pixels"); 
     876                ChunkyPixel[] pixelArray = pixelList.toArray(new ChunkyPixel[0]); 
     877                ILocalFitParams[] localFitParamsArray = localFitParamsList.toArray(new ILocalFitParams[0]); 
     878                processPixels(fittingEngine, pixelArray, globalFitParams, localFitParamsArray, imageColorizer, newImage); 
     879            } 
     880            if (null != imageColorizer) { 
     881                imageColorizer.endFit(); 
     882            } 
     883        } 
     884 
     885        return newImage.getImage(); 
    868886    } 
    869887 
     
    888906            IFittedImage fittedImage) { 
    889907 
    890         //TODO use Lists or just arrays? 
     908        //TODO use Lists or just arrays? This just converts from array to List. 
    891909        List<ILocalFitParams> localFitParamsList = new ArrayList<ILocalFitParams>(); 
    892910        for (ILocalFitParams lFP : localFitParams) { 
    893911            localFitParamsList.add(lFP); 
    894912        } 
    895  
     913         
    896914        List<IFitResults> resultsList = 
    897915                fittingEngine.fit(globalFitParams, localFitParamsList); 
     
    901919            ChunkyPixel p = pixels[i]; 
    902920            if (null != imageColorizer) { 
    903                 imageColorizer.updatePixel(p.getLocation(), result.getParams()); 
    904             } 
    905             fittedImage.setPixel(p.getLocation(), result.getParams()); 
     921                int[] location = p.getLocation(); 
     922                double[] results = result.getParams(); 
     923                imageColorizer.updatePixel(location, results); 
     924            } 
     925            fittedImage.setPixel(p.getLocation(), result.getParams()); //TODO ARG for a multichannel fit, location needs channel also; should ChunkyPixel keep track? 
    906926        } 
    907927 
     
    928948            curveFitData = new CurveFitData(); 
    929949            curveFitData.setParams(params.clone()); //TODO NO NO NO s/b either from UI or fitted point or fitted whole image 
    930             yCount = new double[m_timeBins]; 
    931             for (int b = 0; b < m_timeBins; ++b) { 
     950            yCount = new double[m_bins]; 
     951            for (int b = 0; b < m_bins; ++b) { 
    932952                yCount[b] = 0.0; 
    933953            } 
     
    940960            for (int y = 0; y < m_height; ++y) { 
    941961                for (int x = 0; x < m_width; ++x) { 
    942                     for (int b = 0; b < m_timeBins; ++b) { 
     962                    for (int b = 0; b < m_bins; ++b) { 
    943963                        double count = getData(m_cursor, m_channel, x, y, b); 
    944964                        yCount[b] += count; 
     
    949969            } 
    950970            curveFitData.setYCount(yCount); 
    951             yFitted = new double[m_timeBins]; 
     971            yFitted = new double[m_bins]; 
    952972            curveFitData.setYFitted(yFitted); 
    953973 
     
    10071027                curveFitData = new CurveFitData(); 
    10081028                curveFitData.setParams(params.clone()); 
    1009                 yCount = new double[m_timeBins]; 
    1010                 for (int b = 0; b < m_timeBins; ++b) { 
     1029                yCount = new double[m_bins]; 
     1030                for (int b = 0; b < m_bins; ++b) { 
    10111031                    yCount[b] = 0.0; 
    10121032                } 
     
    10171037                        if (roi.contains(bounds.x + x, bounds.y + y)) { 
    10181038                            ++pixels; 
    1019                             for (int b = 0; b < m_timeBins; ++b) { 
     1039                            for (int b = 0; b < m_bins; ++b) { 
    10201040                                yCount[b] += getData(m_cursor, channel, x, y, b); 
    10211041                            } 
     
    10241044                } 
    10251045                curveFitData.setYCount(yCount); 
    1026                 yFitted = new double[m_timeBins]; 
     1046                yFitted = new double[m_bins]; 
    10271047                curveFitData.setYFitted(yFitted); 
    10281048 
     
    11351155            curveFitData = new CurveFitData(); 
    11361156            curveFitData.setParams(params.clone()); //TODO NO NO NO s/b either from UI or fitted point or fitted whole image 
    1137             yCount = new double[m_timeBins]; 
    1138             for (int b = 0; b < m_timeBins; ++b) { 
     1157            yCount = new double[m_bins]; 
     1158            for (int b = 0; b < m_bins; ++b) { 
    11391159                yCount[b] = getData(m_cursor, channel, x, y, b); 
    11401160            } 
    11411161            curveFitData.setYCount(yCount); 
    1142             yFitted = new double[m_timeBins]; 
     1162            yFitted = new double[m_bins]; 
    11431163            curveFitData.setYFitted(yFitted); 
    11441164 
     
    12061226    //  = gives you fitted images and a histogram tool 
    12071227 
    1208     private Image<DoubleType> fitImages(IUserInterfacePanel uiPanel) { 
     1228    private Image<DoubleType> fitImagesDEFUNCT(IUserInterfacePanel uiPanel) { 
    12091229         
    12101230         
     
    12881308         
    12891309        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1290         globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); ///uiPanel.getAlgorithm()); //loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1291         globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); //uiPanel.getFunction()); 
     1310        globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); ///uiPanel.getAlgorithm()); //loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
     1311        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); //uiPanel.getFunction()); 
    12921312        globalFitParams.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
    1293         globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); //uiPanel.getNoiseModel()); 
     1313        globalFitParams.setNoiseModel(NoiseModel.MAXIMUM_LIKELIHOOD); //uiPanel.getNoiseModel()); 
    12941314        globalFitParams.setChiSquareTarget(uiPanel.getChiSquareTarget()); 
    12951315        ///globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     
    13221342                        getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
    13231343                            params.clone()); 
    1324                 yCount = new double[m_timeBins]; 
    1325                 for (int b = 0; b < m_timeBins; ++b) { 
     1344                yCount = new double[m_bins]; 
     1345                for (int b = 0; b < m_bins; ++b) { 
    13261346                    yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
    13271347                } 
    13281348                curveFitData.setYCount(yCount); 
    1329                 yFitted = new double[m_timeBins]; 
     1349                yFitted = new double[m_bins]; 
    13301350                curveFitData.setYFitted(yFitted); 
    13311351                curveFitDataList.add(curveFitData); 
     
    13721392     * are updated at the end of this function. 
    13731393     */ 
    1374     private void processPixels(ICurveFitData[] data, ChunkyPixel[] pixels, ColorizedImageFitter imageFitter) { 
     1394    private void processPixelsDEFUNCT(ICurveFitData[] data, ChunkyPixel[] pixels, ColorizedImageFitter imageFitter) { 
    13751395        if (null == _fittingEngine) { 
    13761396            _fittingEngine = Configuration.getInstance().getFittingEngine(); 
     
    13801400 
    13811401        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1382         globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1383         globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
    1384         globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); 
     1402        globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1403        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
     1404        globalFitParams.setNoiseModel(NoiseModel.MAXIMUM_LIKELIHOOD); 
    13851405        globalFitParams.setXInc(m_timeRange); 
    13861406        globalFitParams.setPrompt(null); 
     
    14251445    //  = gives you fitted images and a histogram tool 
    14261446     
    1427     private Image<DoubleType> fitEachPixelLatest(IUserInterfacePanel uiPanel) { 
     1447    private Image<DoubleType> fitEachPixelLatestDEFUNCT(IUserInterfacePanel uiPanel) { 
    14281448         
    14291449        // we need to generate the following for fitEachPixel nowadays: 
     
    14421462    } 
    14431463 
    1444     private Image<DoubleType> fitAllPixels(IUserInterfacePanel uiPanel) { 
     1464    private Image<DoubleType> fitAllPixelsDEFUNCT(IUserInterfacePanel uiPanel) { 
    14451465        long start = System.nanoTime(); 
    14461466        int pixelCount = 0; 
     
    15171537                        getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
    15181538                            params.clone()); 
    1519                 yCount = new double[m_timeBins]; 
    1520                 for (int b = 0; b < m_timeBins; ++b) { 
     1539                yCount = new double[m_bins]; 
     1540                for (int b = 0; b < m_bins; ++b) { 
    15211541                    yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
    15221542                } 
    15231543                curveFitData.setYCount(yCount); 
    1524                 yFitted = new double[m_timeBins]; 
     1544                yFitted = new double[m_bins]; 
    15251545                curveFitData.setYFitted(yFitted); 
    15261546                curveFitDataList.add(curveFitData); 
     
    15701590   
    15711591    // copied 1/12 to modify into "processPixels" above: 
    1572     private void processPixelsXYZhuhuh(ICurveFitData[] data, ChunkyPixel[] pixels, ColorizedImageFitter imageFitter) { 
     1592    private void processPixelsXYZhuhuhDEFUNCT(ICurveFitData[] data, ChunkyPixel[] pixels, ColorizedImageFitter imageFitter) { 
    15731593        if (null == _fittingEngine) { 
    15741594            _fittingEngine = Configuration.getInstance().getFittingEngine(); 
     
    15781598 
    15791599        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1580         globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1581         globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
    1582         globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); 
     1600        globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1601        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
     1602        globalFitParams.setNoiseModel(NoiseModel.MAXIMUM_LIKELIHOOD); 
    15831603        globalFitParams.setXInc(m_timeRange); 
    15841604        globalFitParams.setPrompt(null); 
     
    16221642     * are updated at the end of this function. 
    16231643     */ 
     1644    // THis is only called from defunct image fitters. 
    16241645    private void processPixelsXYZ(ICurveFitData[] data, ChunkyPixel[] pixels, ColorizedImageFitter imageFitter) { 
    16251646        if (null == _fittingEngine) { 
     
    16301651 
    16311652        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1632         globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1633         globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
    1634         globalFitParams.setNoiseModel(loci.curvefitter.ICurveFitter.NoiseModel.MAXIMUM_LIKELIHOOD); 
     1653        globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1654        globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
     1655        globalFitParams.setNoiseModel(NoiseModel.MAXIMUM_LIKELIHOOD); 
    16351656        globalFitParams.setXInc(m_timeRange); 
    16361657        globalFitParams.setPrompt(null); 
     
    16781699     */ 
    16791700    //TODO this is the old version 
    1680     private Image<DoubleType> fitEachPixelX(IUserInterfacePanel uiPanel) { 
     1701    private Image<DoubleType> fitEachPixelXDEFUNCT(IUserInterfacePanel uiPanel) { 
    16811702        long start = System.nanoTime(); 
    16821703        int pixelCount = 0; 
     
    17391760                                getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
    17401761                                params.clone()); 
    1741                     yCount = new double[m_timeBins]; 
    1742                     for (int b = 0; b < m_timeBins; ++b) { 
     1762                    yCount = new double[m_bins]; 
     1763                    for (int b = 0; b < m_bins; ++b) { 
    17431764                        yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
    17441765                    } 
    17451766                    curveFitData.setYCount(yCount); 
    1746                     yFitted = new double[m_timeBins]; 
     1767                    yFitted = new double[m_bins]; 
    17471768                    curveFitData.setYFitted(yFitted); 
    17481769                    curveFitDataList.add(curveFitData); 
     
    17731794                             
    17741795                            IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1775                             globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1776                             globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1796                            globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1797                            globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
    17771798                            globalFitParams.setXInc(m_timeRange); 
    17781799                            globalFitParams.setPrompt(null); 
     
    18401861                             
    18411862                            IGlobalFitParams globalFitParams = new GlobalFitParams(); 
    1842                             globalFitParams.setFitAlgorithm(loci.curvefitter.ICurveFitter.FitAlgorithm.RLD_LMA); 
    1843                             globalFitParams.setFitFunction(loci.curvefitter.ICurveFitter.FitFunction.SINGLE_EXPONENTIAL); 
     1863                            globalFitParams.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1864                            globalFitParams.setFitFunction(FitFunction.SINGLE_EXPONENTIAL); 
    18441865                            globalFitParams.setXInc(m_timeRange); 
    18451866                            globalFitParams.setPrompt(null); 
     
    19011922                                 getFittedParams(resultsCursor, channel, x, y, m_fittedParameterCount) : 
    19021923                                 params.clone()); 
    1903                          yCount = new double[m_timeBins]; 
    1904                          for (int b = 0; b < m_timeBins; ++b) { 
     1924                         yCount = new double[m_bins]; 
     1925                         for (int b = 0; b < m_bins; ++b) { 
    19051926                             yCount[b] = getData(pixelCursor, channel, x, y, b); //binnedData[channel][y][x][b]; 
    19061927                         } 
    19071928                         curveFitData.setYCount(yCount); 
    1908                          yFitted = new double[m_timeBins]; 
     1929                         yFitted = new double[m_bins]; 
    19091930                         curveFitData.setYFitted(yFitted); 
    19101931                         curveFitDataList.add(curveFitData); 
     
    23552376            case SLIMCURVE_RLD: 
    23562377                curveFitter = new SLIMCurveFitter(); 
    2357                 curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD); 
     2378                curveFitter.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD); 
    23582379                break; 
    23592380            case SLIMCURVE_LMA: 
    23602381                curveFitter = new SLIMCurveFitter(); 
    2361                 curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.LMA); 
     2382                curveFitter.setFitAlgorithm(FitAlgorithm.SLIMCURVE_LMA); 
    23622383                break; 
    23632384            case SLIMCURVE_RLD_LMA: 
    23642385                curveFitter = new SLIMCurveFitter(); 
    2365                 curveFitter.setFitAlgorithm(ICurveFitter.FitAlgorithm.RLD_LMA); 
     2386                curveFitter.setFitAlgorithm(FitAlgorithm.SLIMCURVE_RLD_LMA); 
    23662387                break; 
    23672388        } 
     
    23692390        switch (uiPanel.getFunction()) { 
    23702391            case SINGLE_EXPONENTIAL: 
    2371                 fitFunction = ICurveFitter.FitFunction.SINGLE_EXPONENTIAL; 
     2392                fitFunction = FitFunction.SINGLE_EXPONENTIAL; 
    23722393                break; 
    23732394            case DOUBLE_EXPONENTIAL: 
    2374                 fitFunction = ICurveFitter.FitFunction.DOUBLE_EXPONENTIAL; 
     2395                fitFunction = FitFunction.DOUBLE_EXPONENTIAL; 
    23752396                break; 
    23762397            case TRIPLE_EXPONENTIAL: 
    2377                 fitFunction = ICurveFitter.FitFunction.TRIPLE_EXPONENTIAL; 
     2398                fitFunction = FitFunction.TRIPLE_EXPONENTIAL; 
    23782399                break; 
    23792400            case STRETCHED_EXPONENTIAL: 
    2380                 fitFunction = ICurveFitter.FitFunction.STRETCHED_EXPONENTIAL; 
     2401                fitFunction = FitFunction.STRETCHED_EXPONENTIAL; 
    23812402                break; 
    23822403        } 
    23832404        curveFitter.setFitFunction(fitFunction); 
     2405        curveFitter.setNoiseModel(uiPanel.getNoiseModel()); 
    23842406        curveFitter.setXInc(m_timeRange); 
    23852407        curveFitter.setFree(translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     
    24462468    private void showDecayGraph(final String title, final IUserInterfacePanel uiPanel, final double irf[], final ICurveFitData data) { 
    24472469        loci.slim.refactor.ui.charts.IDecayGraph decayGraph = loci.slim.refactor.ui.charts.DecayGraph.getInstance(); 
    2448         JFrame frame = decayGraph.init(uiPanel.getFrame(), m_timeBins, m_timeRange); 
     2470        JFrame frame = decayGraph.init(uiPanel.getFrame(), m_bins, m_timeRange); 
    24492471        decayGraph.setTitle(title); 
    24502472        int start = uiPanel.getStart(); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/ISLIMAnalyzer.java

    r7864 r7875  
    3535package loci.slim.analysis; 
    3636 
    37 import imagej.slim.fitting.FitInfo.FitFunction; 
    38 import imagej.slim.fitting.FitInfo.FitRegion; 
     37import loci.curvefitter.ICurveFitter.FitFunction; 
     38import loci.curvefitter.ICurveFitter.FitRegion; 
    3939 
    4040import mpicbg.imglib.image.Image; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/SLIMAnalysis.java

    r7864 r7875  
    4141import java.util.List; 
    4242 
    43 import imagej.slim.fitting.FitInfo.FitFunction; 
    44 import imagej.slim.fitting.FitInfo.FitRegion; 
     43import loci.curvefitter.ICurveFitter.FitFunction; 
     44import loci.curvefitter.ICurveFitter.FitRegion; 
    4545 
    4646import mpicbg.imglib.image.Image; 
     
    5151 
    5252/** 
    53  * TODO 
     53 * This class runs post-fit analysis on the fitted image. 
    5454 * 
    5555 * <dl><dt><b>Source code:</b></dt> 
     
    6060 */ 
    6161public class SLIMAnalysis { 
    62     IndexItem<SLIMAnalyzer, ISLIMAnalyzer> m_plugins[]; 
    63     String m_names[]; 
     62    IndexItem<SLIMAnalyzer, ISLIMAnalyzer> _plugins[]; 
     63    String _names[]; 
    6464 
     65    /** 
     66     * Constructor, gets list of potential analysis plugins. 
     67     *  
     68     */ 
    6569    public SLIMAnalysis() { 
    6670        // get list of plugins and their names 
     
    7478            names.add(item.annotation().name()); 
    7579        } 
    76         m_plugins = plugins.toArray(new IndexItem[0]); 
    77         m_names = names.toArray(new String[0]); 
     80        _plugins = plugins.toArray(new IndexItem[0]); 
     81        _names = names.toArray(new String[0]); 
    7882    } 
    7983 
     84    /** 
     85     * Returns list of potential analysis plugin names. 
     86     *  
     87     * @return  
     88     */ 
    8089    public String[] getChoices() { 
    81         return m_names; 
     90        return _names; 
    8291    } 
    8392 
     93    /** 
     94     * Does image analysis. 
     95     *  
     96     * @param name 
     97     * @param image 
     98     * @param region 
     99     * @param function  
     100     */ 
    84101    public void doAnalysis(String name, Image<DoubleType> image, FitRegion region, FitFunction function) { 
     102         
     103        // find selected plugin 
    85104        IndexItem<SLIMAnalyzer, ISLIMAnalyzer> selectedPlugin = null; 
    86         for (int i = 0; i < m_names.length; ++i) { 
    87             if (name.equals(m_names[i])) { 
    88                 selectedPlugin = m_plugins[i]; 
     105        for (int i = 0; i < _names.length; ++i) { 
     106            if (name.equals(_names[i])) { 
     107                selectedPlugin = _plugins[i]; 
    89108            } 
    90109        } 
     
    105124            } 
    106125        } 
    107         else { 
    108             // default behavior 
    109             System.out.println("Default behavior"); 
    110         } 
    111126    } 
    112127} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/plugins/Display.java

    r7864 r7875  
    5252import loci.slim.colorizer.FiveColorColorize; 
    5353import loci.slim.colorizer.IColorize; 
    54 import imagej.slim.fitting.FitInfo.FitFunction; 
    55 import imagej.slim.fitting.FitInfo.FitRegion; 
     54import loci.curvefitter.ICurveFitter.FitFunction; 
     55import loci.curvefitter.ICurveFitter.FitRegion; 
    5656 
    5757import mpicbg.imglib.cursor.LocalizableByDimCursor; 
     
    223223        // look at image dimensions 
    224224        int dimensions[] = image.getDimensions(); 
     225        if (4 != dimensions.length) { 
     226            System.out.println("Display.analyze can't handle " + dimensions.length + "-dimensional image."); 
     227            return; 
     228        } 
    225229        int width    = dimensions[X_INDEX]; 
    226230        int height   = dimensions[Y_INDEX]; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/plugins/ExportToText.java

    r7864 r7875  
    4949import loci.slim.analysis.ISLIMAnalyzer; 
    5050import loci.slim.analysis.SLIMAnalyzer; 
    51 import imagej.slim.fitting.FitInfo.FitFunction; 
    52 import imagej.slim.fitting.FitInfo.FitRegion; 
     51import loci.curvefitter.ICurveFitter.FitFunction; 
     52import loci.curvefitter.ICurveFitter.FitRegion; 
    5353 
    5454import mpicbg.imglib.cursor.LocalizableByDimCursor; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/plugins/VisADAnalysisPlugin.java

    r7864 r7875  
    3838import ij.ImagePlus; 
    3939 
    40 import imagej.slim.fitting.FitInfo.FitFunction; 
    41 import imagej.slim.fitting.FitInfo.FitRegion; 
     40import loci.curvefitter.ICurveFitter.FitFunction; 
     41import loci.curvefitter.ICurveFitter.FitRegion; 
    4242import loci.slim.analysis.ISLIMAnalyzer; 
    4343import loci.slim.analysis.SLIMAnalyzer; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanel.java

    r7864 r7875  
    3737import javax.swing.JFrame; 
    3838 
    39 import imagej.slim.fitting.FitInfo.FitAlgorithm; 
    40 import imagej.slim.fitting.FitInfo.FitFunction; 
    41 import imagej.slim.fitting.FitInfo.FitRegion; 
    42 import imagej.slim.fitting.FitInfo.NoiseModel; 
     39import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     40import loci.curvefitter.ICurveFitter.FitFunction; 
     41import loci.curvefitter.ICurveFitter.FitRegion; 
     42import loci.curvefitter.ICurveFitter.NoiseModel; 
    4343 
    4444/** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7864 r7875  
    6464import ij.gui.GenericDialog; 
    6565 
    66 import imagej.slim.fitting.FitInfo.FitAlgorithm; 
    67 import imagej.slim.fitting.FitInfo.FitFunction; 
    68 import imagej.slim.fitting.FitInfo.FitRegion; 
    69 import imagej.slim.fitting.FitInfo.NoiseModel; 
     66import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     67import loci.curvefitter.ICurveFitter.FitFunction; 
     68import loci.curvefitter.ICurveFitter.FitRegion; 
     69import loci.curvefitter.ICurveFitter.NoiseModel; 
    7070 
    7171/** 
Note: See TracChangeset for help on using the changeset viewer.