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/fitting
Files:
3 added
2 deleted
2 edited
2 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} 
Note: See TracChangeset for help on using the changeset viewer.