Ignore:
Timestamp:
12/09/11 18:51:19 (8 years ago)
Author:
aivar
Message:

FLIMImageFitter is coming along

Location:
trunk/projects/slim-plugin/src/main/java/imagej/slim
Files:
3 added
2 deleted
3 edited
3 moved

Legend:

Unmodified
Added
Removed

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/AbstractBaseFittedImage.java

    r7828 r7829  
    66package imagej.slim.fitting; 
    77 
     8import ij.process.MyFloatProcessor; //TODO IJ hack; update to IJ2 ImgLib 
     9 
    810import imagej.slim.histogram.HistogramData; 
     11import imagej.slim.histogram.HistogramDataChannel; 
    912 
    1013/** 
    … …  
    1417abstract public class AbstractBaseFittedImage implements IFittedImage { 
    1518    private String _title; 
     19    private double _values[][]; 
    1620    private HistogramData _histogramData; 
     21    private MyFloatProcessor _image; 
    1722     
    18     public void setTitle(String title) { 
     23    public AbstractBaseFittedImage(String title, int[] dimension) { 
    1924        _title = title; 
     25        int x = dimension[0]; 
     26        int y = dimension[1]; 
     27        _values = new double[x][y]; 
     28        HistogramDataChannel histogramDataChannel = new HistogramDataChannel(_values); 
     29        HistogramDataChannel[] histogramDataChannels = new HistogramDataChannel[] { histogramDataChannel }; 
     30        _histogramData = new HistogramData(title, histogramDataChannels); 
     31        _image = new MyFloatProcessor(x, y); 
    2032    } 
    21      
     33 
     34    /** 
     35     * Gets the title of the fitted image. 
     36     *  
     37     * @return  
     38     */ 
    2239    public String getTitle() { 
    2340        return _title; 
    2441    } 
    25  
    26     /** 
    27      * Sets the histogram data object associated with this fitted image. 
    28      * 
    29      * @param histogramData 
    30      */ 
    31     public void setHistogramData(HistogramData histogramData) { 
    32         _histogramData = histogramData; 
    33     } 
    34  
     42     
    3543    /** 
    3644     * Gets the associated histogram data object. 
    … …  
    4553     */ 
    4654    public void beginFit() { 
     55        // clear the 2D slice 
     56        clear(_values); 
    4757 
    4858    } 
    … …  
    5161     */ 
    5262    public void endFit() { 
    53  
    54     } 
    55  
    56     /** 
    57      * Updates the fitted parameters for a pixel. 
    58      * 
    59      * @param location 
    60      * @param parameters 
    61      */ 
    62     abstract public void updatePixel(int[] location, double[] parameters); 
    63  
    64     /** 
    65      * Updates the fitted parameters for a pixel.  The pixel is drawn 
    66      * outsized at first. 
    67      * 
    68      * @param location 
    69      * @param dimension 
    70      * @param parameters 
    71      */ 
    72     abstract public void updateChunkyPixel(int[] location, int[] dimension, double[] parameters); 
    73  
    74     private void updatePixel(int[] location, double value) { 
    75     } 
    76  
    77     private void updateChunkyPixel(int location[], double value) { 
    7863 
    7964    } 
    … …  
    8772        // etc. 
    8873    } 
     74     
     75    /** 
     76     * Updates the fitted parameters for a pixel. 
     77     * 
     78     * @param location 
     79     * @param parameters 
     80     */ 
     81    public void updatePixel(int[] location, double[] parameters) { 
     82        double value = getValue(parameters); 
     83        int x = location[0]; 
     84        int y = location[1]; 
     85        _values[x][y] = value; 
     86        _image.setValue(value); 
     87        _image.drawPixel(x, y); 
     88    } 
     89 
     90    /** 
     91     * Updates the fitted parameters for a pixel.  The pixel is drawn 
     92     * outsized at first. 
     93     * 
     94     * @param location 
     95     * @param dimension 
     96     * @param parameters 
     97     */ 
     98    public void updateChunkyPixel 
     99            (int[] location, int[] dimension, double[] parameters) 
     100    { 
     101        //TODO for now, draw w/o chunkiness: 
     102        updatePixel(location, parameters); 
     103    } 
     104         
     105    /** 
     106     * Given the array of fitted parameters, get the value for this image. 
     107     *  
     108     * @param parameters 
     109     * @return  
     110     */ 
     111    abstract public double getValue(double[] parameters);  
     112 
     113    private void clear(double[][] values) { 
     114        for (int y = 0; y < values[0].length; ++y) { 
     115            for (int x = 0; x < values.length; ++x) { 
     116                values[x][y] = Double.NaN; 
     117            } 
     118        } 
     119    } 
    89120} 

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/FLIMFittedImageFactory.java

    r7825 r7829  
    55package imagej.slim.fitting; 
    66 
    7 import imagej.slim.fitting.ImageFitter.OutputImage; 
     7import imagej.slim.fitting.FLIMImageFitter.OutputImage; 
    88 
    99/** 
    … …  
    1111 * @author aivar 
    1212 */ 
    13 public class OutputImageFactory { 
    14     private static OutputImageFactory INSTANCE = null; 
     13public class FLIMFittedImageFactory { 
     14    private static FLIMFittedImageFactory INSTANCE = null; 
    1515     
    16     private OutputImageFactory() {  
     16    private FLIMFittedImageFactory() {  
    1717    } 
    1818     
    19     public static synchronized OutputImageFactory getInstance() { 
     19    public static synchronized FLIMFittedImageFactory getInstance() { 
    2020        if (null == INSTANCE) { 
    21             INSTANCE = new OutputImageFactory(); 
     21            INSTANCE = new FLIMFittedImageFactory(); 
    2222        } 
    2323        return INSTANCE; 
    2424    } 
    2525     
    26     public IOutputImage createImage(OutputImage outputImage) { 
     26    public IFittedImage createImage(OutputImage outputImage, int[] dimension, int components) { 
     27        IFittedImage fittedImage = null; 
    2728        switch (outputImage) { 
    28             case A: 
    29             case T: 
    3029            case A1: 
     30                fittedImage = new FittedImage("A1", dimension, FLIMImageFitter.A1_INDEX); 
     31                break; 
    3132            case T1: 
     33                fittedImage = new FittedImage("T1", dimension, FLIMImageFitter.T1_INDEX); 
     34                break; 
    3235            case A2: 
     36                fittedImage = new FittedImage("A2", dimension, FLIMImageFitter.A2_INDEX); 
     37                break; 
    3338            case T2: 
     39                fittedImage = new FittedImage("T2", dimension, FLIMImageFitter.T2_INDEX); 
     40                break; 
     41            case A3: 
     42                fittedImage = new FittedImage("A3", dimension, FLIMImageFitter.A2_INDEX); 
     43                break; 
     44            case T3: 
     45                fittedImage = new FittedImage("T3", dimension, FLIMImageFitter.T2_INDEX); 
     46                break; 
    3447            case H: 
     48                fittedImage = new FittedImage("H", dimension, FLIMImageFitter.H_INDEX); 
     49                break; 
    3550            case Z: 
    36             case F0: 
     51                fittedImage = new FittedImage("Z", dimension, FLIMImageFitter.Z_INDEX); 
     52                break; 
     53            case CHISQ: 
     54                fittedImage = new FittedImage("ChiSquare", dimension, FLIMImageFitter.CHISQ_INDEX); 
     55                break; 
    3756            case F1: 
     57                fittedImage = new FractionalIntensityImage("F1", dimension, 0, components); 
     58                break; 
     59            case F2: 
     60                fittedImage = new FractionalIntensityImage("F2", dimension, 1, components); 
     61                break; 
     62            case F3: 
     63                fittedImage = new FractionalIntensityImage("F3", dimension, 2, components); 
     64                break; 
     65            case f1: 
     66                fittedImage = new FractionalContributionImage("f1", dimension, 0, components); 
     67                break; 
     68            case f2: 
     69                fittedImage = new FractionalContributionImage("f2", dimension, 1, components); 
     70                break; 
     71            case f3: 
     72                fittedImage = new FractionalContributionImage("f3", dimension, 2, components); 
     73                break; 
    3874        } 
    3975        return null; 

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/FLIMImageFitter.java

    r7825 r7829  
    44 */ 
    55package imagej.slim.fitting; 
     6 
     7import java.util.ArrayList; 
     8import java.util.List; 
    69 
    710import imagej.slim.fitting.engine.IFittingEngine; 
    … …  
    1215 * @author aivar 
    1316 */ 
    14 public class ImageFitter { 
    15     public enum OutputImage { A, T, A1, T1, A2, T2, A3, T3, H, Z, CHISQ, F0, F1 }; 
     17public class FLIMImageFitter { 
     18    public enum OutputImage { A1, T1, A2, T2, A3, T3, H, Z, CHISQ, F1, F2, F3, f1, f2, f3 }; 
     19    public static final int A1_INDEX    = 2; 
     20    public static final int T1_INDEX    = 3; 
     21    public static final int A2_INDEX    = 4; 
     22    public static final int T2_INDEX    = 5; 
     23    public static final int A3_INDEX    = 6; 
     24    public static final int T3_INDEX    = 7; 
     25    public static final int H_INDEX     = 4; 
     26    public static final int Z_INDEX     = 1; 
     27    public static final int CHISQ_INDEX = 0; 
     28    private List<IFittedImage> _fittedImages; 
    1629    private IFittingEngine _fittingEngine; 
    1730     
    18     public ImageFitter() { 
     31    public FLIMImageFitter() { 
     32        _fittedImages = new ArrayList<IFittedImage>(); 
     33        //TODO s/b configurable which fitting engine to use: 
    1934        _fittingEngine = new ThreadedFittingEngine(); 
    2035    } 
    2136     
    22     public void fit(OutputImage[] images) { 
    23          
     37    public void setUpFit(OutputImage[] images, int[] dimension, int components) { 
     38        _fittedImages.clear(); 
     39        for (OutputImage image : images) { 
     40            IFittedImage fittedImage = FLIMFittedImageFactory.getInstance().createImage(image, dimension, components); 
     41            _fittedImages.add(fittedImage); 
     42        }  
    2443    } 
     44     
     45    /** 
     46     * Begins a fit. 
     47     */ 
     48    public void beginFit() { 
     49        for (IFittedImage fittedImage : _fittedImages) { 
     50            fittedImage.beginFit(); 
     51        } 
     52    } 
     53 
     54    /** 
     55     * Ends a fit. 
     56     */ 
     57    public void endFit() { 
     58        for (IFittedImage fittedImage : _fittedImages) { 
     59            fittedImage.beginFit(); 
     60        } 
     61 
     62    } 
     63 
     64    /** 
     65     * Updates the fitted parameters for a pixel. 
     66     *  
     67     * @param location 
     68     * @param parameters 
     69     */ 
     70    public void updatePixel(int[] location, double[] parameters) { 
     71        for (IFittedImage fittedImage : _fittedImages) { 
     72            fittedImage.updatePixel(location, parameters); 
     73        } 
     74    } 
     75 
     76    /** 
     77     * Updates the fitted parameters for a pixel.  The pixel is drawn 
     78     * outsized at first. 
     79     *  
     80     * @param location 
     81     * @param dimension 
     82     * @param parameters 
     83     */ 
     84    public void updateChunkyPixel(int[] location, int[] dimension, double[] parameters) { 
     85        for (IFittedImage fittedImage : _fittedImages) { 
     86            fittedImage.updateChunkyPixel(location, dimension, parameters); 
     87        } 
     88    } 
     89    /** 
     90     * Recalculates the image histogram and resets the palette.  Called  
     91     * periodically during the fit. 
     92     */ 
     93    public void recalcHistogram() {     
     94        for (IFittedImage fittedImage : _fittedImages) { 
     95            fittedImage.recalcHistogram(); 
     96        } 
     97    }     
     98 
    2599} 

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/IFittedImage.java

    r7828 r7829  
    1313 */ 
    1414public interface IFittedImage { 
    15  
    16     /** 
    17      * Sets the histogram data object associated with this fitted image. 
    18      * 
    19      * @param histogramData 
    20      */ 
    21     public void setHistogramData(HistogramData histogramData); 
    2215 
    2316    /** 
    … …  
    6053     */ 
    6154    public void recalcHistogram(); 
     55 
     56    /** 
     57     * Given the array of fitted parameters, get the value for this image. 
     58     *  
     59     * @param parameters 
     60     * @return  
     61     */ 
     62    public double getValue(double[] parameters); 
    6263} 

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramData.java

    r7825 r7829  
    1212 */ 
    1313public class HistogramData { 
    14     private HistogramChannelData[] _channel; 
    1514    private String _title; 
     15    private HistogramDataChannel[] _channel; 
    1616    private int _channelIndex; 
    1717    private boolean _auto; 
    1818    private boolean _combine; 
    1919    private boolean _showAll; 
    20     private float _minView; 
    21     private float _maxView; 
    22     private float _minLUT; 
    23     private float _maxLUT; 
     20    private double _minView; 
     21    private double _maxView; 
     22    private double _minLUT; 
     23    private double _maxLUT; 
    2424 
    2525    /** 
    … …  
    2828     * @param channel  
    2929     */ 
    30     public HistogramData(HistogramChannelData[] channel, String title) { 
     30    public HistogramData(String title, HistogramDataChannel[] channel) { 
     31        _title = title; 
    3132        _channel = channel; 
    32         _title = title; 
    3333        _channelIndex = 0; 
    3434        _minView = _maxView = 0.0f; 
    … …  
    105105     * @return  
    106106     */ 
    107     public float[] getMinMaxView() { 
    108         return new float[] { _minView, _maxView }; 
     107    public double[] getMinMaxView() { 
     108        return new double[] { _minView, _maxView }; 
    109109    } 
    110110 
    … …  
    114114     * @return  
    115115     */ 
    116     public float[] getMinMaxLUT() { 
    117         return new float[] { _minLUT, _maxLUT }; 
     116    public double[] getMinMaxLUT() { 
     117        return new double[] { _minLUT, _maxLUT }; 
    118118    } 
    119119 
    … …  
    125125    //TODO s/b setting both view and lut min/max if automatic, o'wise no change 
    126126    //TODO who is calling this???? 
    127     public float[] getMinMax() { 
    128         float[] minMax = null; 
     127    public double[] getMinMax() { 
     128        double[] minMax = null; 
    129129         
    130130        if (_auto) { 
    131131            if (_combine) { 
    132                 float min = Float.MAX_VALUE; 
    133                 float max = Float.MIN_VALUE; 
     132                double min = Double.MAX_VALUE; 
     133                double max = Double.MIN_VALUE; 
    134134                 
    135135                // calculate actual minimum and maximum for all channels 
    … …  
    143143                    } 
    144144                } 
    145                 minMax = new float[] { min, max };   
     145                minMax = new double[] { min, max };   
    146146            } 
    147147            else { 

  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramDataChannel.java

    r7825 r7829  
    1111 * @author aivar 
    1212 */ 
    13 public class HistogramChannelData { 
    14     private float[][] _values; 
    15     private float _actualMin; 
    16     private float _actualMax; 
     13public class HistogramDataChannel { 
     14    private double[][] _values; 
     15    private double _actualMin; 
     16    private double _actualMax; 
    1717 
    1818    /** 
    … …  
    2121     * @param values  
    2222     */ 
    23     public HistogramChannelData(float[][] values) { 
     23    public HistogramDataChannel(double[][] values) { 
    2424        _values = values; 
    2525        _actualMin = _actualMax = 0.0f; 
    … …  
    3232     * @return array of { min, max } 
    3333     */ 
    34     public float[] resetActualMinMax() { 
    35         _actualMin = Float.MAX_VALUE; 
    36         _actualMax = Float.MIN_VALUE; 
     34    public double[] resetActualMinMax() { 
     35        _actualMin = Double.MAX_VALUE; 
     36        _actualMax = Double.MIN_VALUE; 
    3737        for (int i = 0; i < _values.length; ++i) { 
    3838            for (int j = 0; j < _values[0].length; ++j) { 
    39                 if (_values[i][j] != Float.NaN) { 
     39                if (_values[i][j] != Double.NaN) { 
    4040                    if (_values[i][j] < _actualMin) { 
    4141                        _actualMin = _values[i][j]; 
    … …  
    5050    } 
    5151     
    52     public float[] getActualMinMax() { 
    53         return new float[] { _actualMin, _actualMax }; 
     52    public double[] getActualMinMax() { 
     53        return new double[] { _actualMin, _actualMax }; 
    5454    } 
    5555     
    … …  
    6363     * @return histogram array with counts per bin 
    6464     */ 
    65     public int[] binValues(int bins, float nominalMin, float nominalMax) { 
     65    public int[] binValues(int bins, double nominalMin, double nominalMax) { 
    6666        int[] results = new int[bins]; 
    6767        for (int i = 0; i < bins; ++i) { 
    6868            results[i] = 0; 
    6969        } 
    70         float binWidth = bins / (nominalMax - nominalMin); 
     70        double binWidth = bins / (nominalMax - nominalMin); 
    7171        for (int i = 0; i < _values.length; ++i) { 
    7272            for (int j = 0; j < _values[0].length; ++j) { 
    73                 float value = _values[i][j]; 
     73                double value = _values[i][j]; 
    7474                if (value >= nominalMin && value <= nominalMax) { 
    7575                    // assign each value to a bin 
Note: See TracChangeset for help on using the changeset viewer.