Changeset 7887 for trunk


Ignore:
Timestamp:
02/08/12 19:08:00 (8 years ago)
Author:
aivar
Message:

SLIM Plugin: Got multiple channel fitting working.

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

Legend:

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

    r7875 r7887  
    44 */ 
    55package imagej.slim.fitting; 
     6 
     7import java.awt.image.IndexColorModel; 
    68 
    79import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     
    2224    private NoiseModel _noiseModel; 
    2325    private String _fittedImages; 
     26    private IndexColorModel _indexColorModel; 
    2427    private String[] _analysisList; 
    2528    private boolean _fitAllChannels; 
     
    178181    public void setFittedImages(String fittedImages) { 
    179182        _fittedImages = fittedImages; 
     183    } 
     184     
     185    /** 
     186     * Returns color model for fitted images. 
     187     *  
     188     * @return 
     189     */ 
     190    public IndexColorModel getIndexColorModel() { 
     191        return _indexColorModel; 
     192    } 
     193 
     194    /** 
     195     * Sets color model for fitted images. 
     196     *  
     197     * @param indexColorModel  
     198     */ 
     199    public void setIndexColorModel(IndexColorModel indexColorModel) { 
     200        _indexColorModel = indexColorModel; 
    180201    } 
    181202 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/IDecayImage.java

    r7867 r7887  
    5050     * @return  
    5151     */ 
    52     public boolean fitThisPixel(int x, int y, int channel); 
     52    public boolean fitThisPixel(int[] location); 
    5353    
    5454    /** 
     
    6060     * @return  
    6161     */ 
    62     public double[] getPixel(int x, int y, int channel); 
     62    public double[] getPixel(int[] location); 
    6363 
    6464    /** 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/IFittedImage.java

    r7866 r7887  
    6262     * @param value 
    6363     */ 
    64     public void setPixel(int[] location, double[] value); 
    65  
    66     /** 
    67      * Gets fitted pixel value. 
    68      * 
    69      * @param x 
    70      * @param y 
    71      * @param channel 
    72      * @return 
    73      */ 
    74     public double[] getPixel(int x, int y, int channel); 
    75  
    76     /** 
    77      * Puts fitted pixel value. 
    78      *  
    79      * @param x 
    80      * @param y 
    81      * @param channel 
    82      * @param value 
    83      */ 
    84     public void setPixel(int x, int y, int channel, double[] value); 
    85      
     64    public void setPixel(int[] location, double[] value);    
    8665 
    8766    /** 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/AbstractBaseColorizedImage.java

    r7879 r7887  
    99import java.awt.event.FocusListener; 
    1010import java.awt.image.IndexColorModel; 
     11import java.util.ArrayList; 
     12import java.util.List; 
    1113 
    1214import ij.ImagePlus; 
     15import ij.ImageStack; 
    1316import ij.process.FloatProcessor; 
    1417 
     
    1720import imagej.slim.histogram.HistogramTool; 
    1821import imagej.slim.histogram.PaletteFix; 
     22 
     23import loci.slim.MyStackWindow; 
    1924 
    2025/** 
     
    2328 */ 
    2429abstract public class AbstractBaseColorizedImage implements IColorizedImage { 
     30    private static final int UNKNOWN_CHANNEL = -1; 
    2531    private String _title; 
     32    private int _width; 
     33    private int _height; 
     34    private int _channels; 
     35    private int _channel; 
     36    private ImageStack _imageStack; 
     37    private ImagePlus _imagePlus; 
     38    private MyStackWindow _stackWindow; 
    2639    private double _values[][]; 
     40    private HistogramDataChannel[] _histogramDataChannels; 
    2741    private HistogramData _histogramData; 
    28     private FloatProcessor _image; 
    29     private ImagePlus _imagePlus; 
    30      
    31     public AbstractBaseColorizedImage(String title, int[] dimension) { 
     42    private FloatProcessor _imageProcessor; 
     43     
     44    public AbstractBaseColorizedImage(String title, int[] dimension, 
     45            IndexColorModel indexColorModel) { 
    3246        _title = title; 
    33         int x = dimension[0]; 
    34         int y = dimension[1]; 
    35         _values = new double[x][y]; 
    36         //TODO need to handle multiple channels: 
    37         // _values c/b slice being drawn only; refer to Image for other slices; this scheme would fall apart if Image is colorized grayscale like SPCImage, 
    38         // so better to keep _values around for each channel 
    39         HistogramDataChannel histogramDataChannel = new HistogramDataChannel(_values); 
    40         HistogramDataChannel[] histogramDataChannels = new HistogramDataChannel[] { histogramDataChannel }; 
    41         _histogramData = new HistogramData(this, title, histogramDataChannels); 
    42         _image = new FloatProcessor(x, y); 
    43         _image.setColorModel(imagej.slim.histogram.HistogramTool.getIndexColorModel()); 
    44         // fill the image with a value that will be out of LUT range and paint black. 
    45         _image.setValue(Float.NaN); 
    46         _image.fill(); 
    47         _imagePlus = new ImagePlus(title, _image); 
    48         _imagePlus.show(); 
    49         _imagePlus.getWindow().addFocusListener(new FocusListener() { 
     47        _width = dimension[0]; 
     48        _height = dimension[1]; 
     49        _channels = dimension[2]; 
     50        _channel = UNKNOWN_CHANNEL; 
     51         
     52        // building an image stack 
     53        _imageStack = new ImageStack(_width, _height); 
     54         
     55        // building a list of HistogramDataChannels 
     56        List<HistogramDataChannel> list = new ArrayList<HistogramDataChannel>(); 
     57         
     58        for (int c = 0; c < _channels; ++c) { 
     59            // build the actual displayed image 
     60            FloatProcessor imageProcessor = new FloatProcessor(_width, _height); 
     61            imageProcessor.setColorModel(indexColorModel); 
     62             
     63            // fill the image with a value that will be out of LUT range and 
     64            // paint black 
     65            imageProcessor.setValue(Float.NaN); 
     66            imageProcessor.fill(); 
     67             
     68            _imageStack.addSlice("" + c, imageProcessor); 
     69             
     70            // build the histogram data 
     71            _values = new double[_width][_height]; 
     72            clear(_values); 
     73            HistogramDataChannel histogramDataChannel = new HistogramDataChannel(_values); 
     74            list.add(histogramDataChannel);            
     75        } 
     76         
     77        _imagePlus = new ImagePlus(title, _imageStack); 
     78        _stackWindow = new MyStackWindow(_imagePlus); 
     79        _stackWindow.setVisible(true); 
     80        _stackWindow.addFocusListener(new FocusListener() { 
    5081            public void focusGained(FocusEvent e) { 
    5182                HistogramTool.getInstance().setHistogramData(_histogramData); 
     
    5485            public void focusLost(FocusEvent e) { } 
    5586        });   
     87         
     88        _histogramDataChannels 
     89                = list.toArray(new HistogramDataChannel[0]); 
     90        _histogramData = new HistogramData(this, title, _histogramDataChannels);  
    5691    } 
    5792 
     
    71106     */    
    72107    public void setColorModel(IndexColorModel colorModel) { 
    73         _image.setColorModel(colorModel); 
     108        _imageProcessor.setColorModel(colorModel); 
    74109    }     
    75110     
     
    86121     */ 
    87122    public void beginFit() { 
    88         // clear the 2D slice 
    89         clear(_values); 
    90     } 
     123    } 
     124     
    91125    /** 
    92126     * Ends a fit. 
     
    129163    private void redisplay(double[] minMaxLUT) { 
    130164        minMaxLUT = PaletteFix.adjustMinMax(minMaxLUT[0], minMaxLUT[1]); 
    131         System.out.println("***** REDISPLAY 256-COLOR SPECS ***** " + minMaxLUT[0] + " " + minMaxLUT[1]); 
    132         _image.setMinAndMax(minMaxLUT[0], minMaxLUT[1]); 
    133         _imagePlus.setProcessor(_image.duplicate()); 
     165        _imageProcessor.setMinAndMax(minMaxLUT[0], minMaxLUT[1]); 
     166        _imagePlus.setProcessor(_imageProcessor.duplicate()); //TODO ARG OUCH!  This ImagePlus holds an ImageStack - maybe update(ImageProcessor ip) Updates this stack so its attributes such as min max calibration table and color model, are the same as 'ip' 
    134167    } 
    135168 
     
    142175     */ 
    143176    public void updatePixel(int[] location, double[] parameters) { 
     177        // compute our displayable value from params 
    144178        double value = getValue(parameters); 
    145         int x = location[0]; 
    146         int y = location[1]; 
     179         
     180        int x       = location[0]; 
     181        int y       = location[1]; 
     182        int channel = location[2]; 
     183        System.out.println("updatePixel(" + x + " " + y + " " + channel + " prev channel is " + _channel); 
     184         
     185        if (_channel != channel) { 
     186            _channel = channel; 
     187            _stackWindow.showSlice(channel + 1); 
     188            _values = _histogramDataChannels[channel].getValues(); 
     189             
     190            System.out.println("values is " + _values + " " + _values.hashCode()); 
     191             
     192            _imageProcessor = (FloatProcessor) _imageStack.getProcessor(channel + 1); 
     193            System.out.println("ImageProc for " + channel + " is " + _imageProcessor.toString() + " hash " + _imageProcessor.hashCode()); 
     194        } 
     195         
    147196        _values[x][y] = value; 
    148         _image.setValue(value); 
    149         _image.drawPixel(x, y); 
     197        _imageProcessor.setValue(value); 
     198        _imageProcessor.drawPixel(x, y); 
    150199    } 
    151200 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/ColorizedImage.java

    r7865 r7887  
    44 */ 
    55package imagej.slim.fitting.images; 
     6 
     7import java.awt.image.IndexColorModel; 
    68 
    79import imagej.slim.fitting.images.AbstractBaseColorizedImage; 
     
    2224     * @param parameterIndex 
    2325     */ 
    24     public ColorizedImage(String title, int[] dimension, int parameterIndex) { 
    25         super(title, dimension); 
     26    public ColorizedImage(String title, int[] dimension, 
     27            IndexColorModel indexColorModel, int parameterIndex) { 
     28        super(title, dimension, indexColorModel); 
    2629        _parameterIndex = parameterIndex; 
    2730    } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/ColorizedImageFactory.java

    r7865 r7887  
    44 */ 
    55package imagej.slim.fitting.images; 
     6 
     7import java.awt.image.IndexColorModel; 
    68 
    79import imagej.slim.fitting.images.IColorizedImage; 
     
    2830    } 
    2931     
    30     public IColorizedImage createImage(ColorizedImageType outputImage, int[] dimension, int components) { 
     32    public IColorizedImage createImage(ColorizedImageType outputImage, 
     33            int[] dimension, IndexColorModel indexColorModel, int components) { 
    3134        IColorizedImage fittedImage = null; 
    3235        String title; 
     
    3437            case A1: 
    3538                title = (1 == components) ? "A" : "A1"; 
    36                 fittedImage = new ColorizedImage(title, dimension, ColorizedImageFitter.A1_INDEX); 
     39                fittedImage = new ColorizedImage(title, dimension, 
     40                        indexColorModel, ColorizedImageFitter.A1_INDEX); 
    3741                break; 
    3842            case T1: 
    3943                title = (1 == components) ? "T" : "T1"; 
    40                 fittedImage = new ColorizedImage(title, dimension, ColorizedImageFitter.T1_INDEX); 
     44                fittedImage = new ColorizedImage(title, dimension, 
     45                        indexColorModel, ColorizedImageFitter.T1_INDEX); 
    4146                break; 
    4247            case A2: 
    43                 fittedImage = new ColorizedImage("A2", dimension, ColorizedImageFitter.A2_INDEX); 
     48                fittedImage = new ColorizedImage("A2", dimension, 
     49                        indexColorModel, ColorizedImageFitter.A2_INDEX); 
    4450                break; 
    4551            case T2: 
    46                 fittedImage = new ColorizedImage("T2", dimension, ColorizedImageFitter.T2_INDEX); 
     52                fittedImage = new ColorizedImage("T2", dimension, 
     53                        indexColorModel, ColorizedImageFitter.T2_INDEX); 
    4754                break; 
    4855            case A3: 
    49                 fittedImage = new ColorizedImage("A3", dimension, ColorizedImageFitter.A2_INDEX); 
     56                fittedImage = new ColorizedImage("A3", dimension, 
     57                        indexColorModel, ColorizedImageFitter.A2_INDEX); 
    5058                break; 
    5159            case T3: 
    52                 fittedImage = new ColorizedImage("T3", dimension, ColorizedImageFitter.T2_INDEX); 
     60                fittedImage = new ColorizedImage("T3", dimension, 
     61                        indexColorModel, ColorizedImageFitter.T2_INDEX); 
    5362                break; 
    5463            case H: 
    55                 fittedImage = new ColorizedImage("H", dimension, ColorizedImageFitter.H_INDEX); 
     64                fittedImage = new ColorizedImage("H", dimension, 
     65                        indexColorModel, ColorizedImageFitter.H_INDEX); 
    5666                break; 
    5767            case Z: 
    58                 fittedImage = new ColorizedImage("Z", dimension, ColorizedImageFitter.Z_INDEX); 
     68                fittedImage = new ColorizedImage("Z", dimension, 
     69                        indexColorModel, ColorizedImageFitter.Z_INDEX); 
    5970                break; 
    6071            case CHISQ: 
    61                 fittedImage = new ColorizedImage("ChiSquare", dimension, ColorizedImageFitter.CHISQ_INDEX); 
     72                fittedImage = new ColorizedImage("ChiSquare", dimension, 
     73                        indexColorModel, ColorizedImageFitter.CHISQ_INDEX); 
    6274                break; 
    6375            case F1: 
    64                 fittedImage = new FractionalIntensityImage("F1", dimension, 0, components); 
     76                fittedImage = new FractionalIntensityImage("F1", dimension, 
     77                        indexColorModel, 0, components); 
    6578                break; 
    6679            case F2: 
    67                 fittedImage = new FractionalIntensityImage("F2", dimension, 1, components); 
     80                fittedImage = new FractionalIntensityImage("F2", dimension, 
     81                        indexColorModel, 1, components); 
    6882                break; 
    6983            case F3: 
    70                 fittedImage = new FractionalIntensityImage("F3", dimension, 2, components); 
     84                fittedImage = new FractionalIntensityImage("F3", dimension, 
     85                        indexColorModel, 2, components); 
    7186                break; 
    7287            case f1: 
    73                 fittedImage = new FractionalContributionImage("f1", dimension, 0, components); 
     88                fittedImage = new FractionalContributionImage("f1", dimension, 
     89                        indexColorModel, 0, components); 
    7490                break; 
    7591            case f2: 
    76                 fittedImage = new FractionalContributionImage("f2", dimension, 1, components); 
     92                fittedImage = new FractionalContributionImage("f2", dimension, 
     93                        indexColorModel, 1, components); 
    7794                break; 
    7895            case f3: 
    79                 fittedImage = new FractionalContributionImage("f3", dimension, 2, components); 
     96                fittedImage = new FractionalContributionImage("f3", dimension, 
     97                        indexColorModel, 2, components); 
    8098                break; 
    8199        } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/ColorizedImageFitter.java

    r7865 r7887  
    55package imagej.slim.fitting.images; 
    66 
     7import java.awt.image.IndexColorModel; 
    78import java.util.ArrayList; 
    89import java.util.List; 
     
    3132    } 
    3233     
    33     public void setUpFit(ColorizedImageType[] images, int[] dimension, int components) { 
     34    public void setUpFit(ColorizedImageType[] images, int[] dimension, 
     35            IndexColorModel indexColorModel, int components) { 
    3436        _fittedImages.clear(); 
    3537        for (ColorizedImageType image : images) { 
    36             IColorizedImage fittedImage = ColorizedImageFactory.getInstance().createImage(image, dimension, components); 
     38            IColorizedImage fittedImage = 
     39                    ColorizedImageFactory.getInstance().createImage 
     40                            (image, dimension, indexColorModel, components); 
    3741            _fittedImages.add(fittedImage); 
    3842        } 
     
    4145        int lastIndex = images.length - 1; 
    4246        if (lastIndex >= 0) { 
    43             HistogramTool.getInstance().setHistogramData(_fittedImages.get(lastIndex).getHistogramData()); 
     47            HistogramTool.getInstance().setHistogramData 
     48                    (_fittedImages.get(lastIndex).getHistogramData()); 
    4449        } 
    4550    } 
     
    5055    public void beginFit() { 
    5156        for (IColorizedImage fittedImage : _fittedImages) { 
    52             //fittedImage.setColorModel(HistogramTool.getLUT()); //TODO getIndexColorModel()); //TODO all the same really as far as I can tell, i.e. broken 
    5357            fittedImage.beginFit(); 
    5458        } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/FractionalContributionImage.java

    r7865 r7887  
    44 */ 
    55package imagej.slim.fitting.images; 
     6 
     7import java.awt.image.IndexColorModel; 
    68 
    79import imagej.slim.fitting.images.AbstractBaseColorizedImage; 
     
    2830     * @param components  
    2931     */ 
    30     public FractionalContributionImage(String title, int[] dimension, int component, int components) { 
    31         super(title, dimension); 
     32    public FractionalContributionImage(String title, int[] dimension, 
     33            IndexColorModel indexColorModel, int component, int components) { 
     34        super(title, dimension, indexColorModel); 
    3235        _component = component; 
    3336        _components = components; 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/images/FractionalIntensityImage.java

    r7865 r7887  
    44 */ 
    55package imagej.slim.fitting.images; 
     6 
     7import java.awt.image.IndexColorModel; 
    68 
    79import imagej.slim.fitting.images.AbstractBaseColorizedImage; 
     
    2830     * @param components  
    2931     */ 
    30     public FractionalIntensityImage(String title, int[] dimension, int component, int components) { 
    31         super(title, dimension); 
     32    public FractionalIntensityImage(String title, int[] dimension, 
     33            IndexColorModel indexColorModel, int component, int components) { 
     34        super(title, dimension, indexColorModel); 
    3235        _component = component; 
    3336        _components = components; 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramData.java

    r7879 r7887  
    6161        _listener = listener; 
    6262    } 
    63      
     63      
    6464    /** 
    6565     * Gets a descriptive title to display on histogram UI for this data. 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramDataChannel.java

    r7845 r7887  
    3030    public HistogramDataChannel(double[][] values) { 
    3131        _values = values; 
     32    } 
     33 
     34    /** 
     35     * Gets the values array. 
     36     *  
     37     * @return  
     38     */ 
     39    public double[][] getValues() { 
     40        return _values; 
    3241    } 
    3342 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/UIPanel.java

    r7879 r7887  
    121121            } 
    122122        ); 
    123         if (hasChannels) { 
     123        /** 
     124         * IJ1 uses the same LUT for the entire stack.  It might be possible for 
     125         * the histogram tool to set the appropriate LUT for the current channel 
     126         * but there is no listener or event for the histogram tool to know when 
     127         * the channel changes. 
     128         *  
     129         * Perhaps this can change with IJ2. 
     130         *  
     131         * ARG 2/8/12 
     132         */ 
     133        if (false && hasChannels) { 
    124134            add(_combineChannelsCheckBox); 
    125135        } 
     
    137147            } 
    138148        ); 
    139         if (hasChannels) { 
     149        /** 
     150         * Now that we're down to one extra checkbox for channels, lets always 
     151         * display it.  (See above.) 
     152         *  
     153         * ARG 2/8/12 
     154         */ 
     155        if (true || hasChannels) { 
    140156            add(_displayChannelsCheckBox); 
    141157        } 
     
    176192     */ 
    177193    public void dragMinMaxLUT(double min, double max) { 
    178         System.out.println("UIPanel.dragMinMaxLUT " + min + " " + max); 
     194//        System.out.println("UIPanel.dragMinMaxLUT " + min + " " + max); 
    179195        showMinMaxLUT(min, max); 
    180196    } 
     
    187203     */ 
    188204    public void setMinMaxLUT(double min, double max) { 
    189         System.out.println("UIPanel.setMinMaxLUT " + min + " " + max); 
     205//        System.out.println("UIPanel.setMinMaxLUT " + min + " " + max); 
    190206        showMinMaxLUT(min, max); 
    191207        //TODO anything else?  if not combine these two methods 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ChunkyPixel.java

    r7875 r7887  
    4949    final int _width; 
    5050    final int _height; 
    51     int[] _location; 
     51    int[] _inputLocation; 
     52    int[] _outputLocation; 
    5253 
    5354    @Deprecated 
     
    5758        _width = width; 
    5859        _height = height; 
    59         _location = null; 
     60        _inputLocation = null; 
     61        _outputLocation = null; 
    6062    } 
    6163 
     
    7678    } 
    7779     
    78     public void setLocation(int[] location) { 
    79         location[0] = _x; 
    80         location[1] = _y; 
    81         _location = location; 
     80    public void setInputLocation(int[] location) { 
     81        _inputLocation = location; 
    8282    } 
    8383 
    84     public int[] getLocation() { 
    85         return _location; 
     84    public int[] getInputLocation() { 
     85        return _inputLocation; 
     86    } 
     87     
     88    public void setOutputLocation(int[] location) { 
     89        _outputLocation = location; 
     90    } 
     91     
     92    public int[] getOutputLocation() { 
     93        return _outputLocation; 
    8694    } 
    8795} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ChunkyPixelEffectIterator.java

    r7668 r7887  
    4848 */ 
    4949public class ChunkyPixelEffectIterator implements Iterator { 
    50     int m_width; 
    51     int m_height; 
    52     int m_index; 
    53     int m_x; 
    54     int m_y; 
    55     IChunkyPixelTable m_table; 
    56     ChunkyPixel m_chunkyPixel; 
     50    IChunkyPixelTable _table; 
     51    int _width; 
     52    int _height; 
     53    int _index; 
     54    int _x; 
     55    int _y; 
     56    ChunkyPixel _chunkyPixel; 
    5757 
    5858    public ChunkyPixelEffectIterator(IChunkyPixelTable table, int width, int height) { 
    59         m_table = table; 
    60         m_width = width; 
    61         m_height = height; 
     59        _table = table; 
     60        _width = width; 
     61        _height = height; 
    6262 
    6363        // initialize 
    64         m_index = 0; 
    65         m_x = 0; 
    66         m_y = 0; 
     64        _index = 0; 
     65        _x = 0; 
     66        _y = 0; 
    6767 
    6868        // get first chunky pixel 
    69         m_chunkyPixel = getNextChunkyPixel(); 
     69        _chunkyPixel = getNextChunkyPixel(); 
    7070    } 
    7171 
    7272    public boolean hasNext() { 
    73         return m_chunkyPixel != null; 
     73        return _chunkyPixel != null; 
    7474    } 
    7575 
    7676    public ChunkyPixel next() { 
    77         ChunkyPixel chunkyPixel = m_chunkyPixel; 
    78         m_chunkyPixel = getNextChunkyPixel(); 
     77        ChunkyPixel chunkyPixel = _chunkyPixel; 
     78        _chunkyPixel = getNextChunkyPixel(); 
    7979        return chunkyPixel; 
    8080    } 
     
    8686    ChunkyPixel getNextChunkyPixel() { 
    8787        // get the relative chunky pixel from the table 
    88         ChunkyPixel relChunkyPixel = m_table.getChunkyPixel(m_index); 
     88        ChunkyPixel relChunkyPixel = _table.getChunkyPixel(_index); 
    8989 
    90         if (m_x + relChunkyPixel.getX() >= m_width) { 
     90        if (_x + relChunkyPixel.getX() >= _width) { 
    9191            // start next row 
    92             m_x = 0; 
    93             m_y += m_table.getHeight(); 
     92            _x = 0; 
     93            _y += _table.getHeight(); 
    9494 
    95             if (m_y + relChunkyPixel.getY() >= m_height) { 
     95            if (_y + relChunkyPixel.getY() >= _height) { 
    9696                // use next table entry, are we done? 
    97                 if (++m_index >= m_table.size()) { 
     97                if (++_index >= _table.size()) { 
    9898                    return null; 
    9999                } 
    100100 
    101101                // start from the top 
    102                 m_y = 0; 
     102                _y = 0; 
    103103 
    104104                // update relative chunky pixel 
    105                 relChunkyPixel = m_table.getChunkyPixel(m_index); 
     105                relChunkyPixel = _table.getChunkyPixel(_index); 
    106106            } 
    107107        } 
    108108         
    109109        // convert relative to absolute 
    110         int x = m_x + relChunkyPixel.getX(); 
    111         int y = m_y + relChunkyPixel.getY(); 
     110        int x = _x + relChunkyPixel.getX(); 
     111        int y = _y + relChunkyPixel.getY(); 
    112112        ChunkyPixel absChunkyPixel = new ChunkyPixel(x, y, 
    113                 Math.min(relChunkyPixel.getWidth(), m_width - x), 
    114                 Math.min(relChunkyPixel.getHeight(), m_height - y)); 
     113                Math.min(relChunkyPixel.getWidth(), _width - x), 
     114                Math.min(relChunkyPixel.getHeight(), _height - y)); 
    115115 
    116116        // set up for next call 
    117         m_x += m_table.getWidth(); 
     117        _x += _table.getWidth(); 
    118118 
    119119        return absChunkyPixel; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/DecayImageWrapper.java

    r7875 r7887  
    2626    private int _height; 
    2727    private int _channels; 
    28     private int _channelIndex; 
    2928    private int _bins; 
    3029    private int _binIndex; 
     
    3231     
    3332    public DecayImageWrapper(Image<T> image, int width, int height, 
    34             int channels, int channelIndex, int bins, int binIndex) { 
    35         _image = image; 
    36         _width = width; 
    37         _height = height; 
     33            int channels, int bins, int binIndex) { 
     34        _image    = image; 
     35        _width    = width; 
     36        _height   = height; 
    3837        _channels = channels; 
    39         _channelIndex = channelIndex; 
    40         _bins = bins; 
     38        _bins     = bins; 
    4139        _binIndex = binIndex; 
    4240 
     
    8482     
    8583    @Override 
    86     public boolean fitThisPixel(int x, int y, int channel) { 
     84    public boolean fitThisPixel(int[] location) { 
    8785        return true; //TODO FOR NOW ONLY!! 
    8886    } 
     
    9189     * Gets input pixel decay curve. 
    9290     *  
    93      * @param x 
    94      * @param y 
    95      * @param channel 
     91     * @param location 
    9692     * @return  
    9793     */ 
    9894    @Override 
    99     public double[] getPixel(int x, int y, int channel) { 
     95    public double[] getPixel(int[] location) { 
    10096        double[] decay = new double[_bins]; 
    101         int[] location; 
    10297         
    103         if (_channels > 1) { 
    104             location = new int[] { x, y, 0, 0 }; 
    105             location[_channelIndex] = channel; 
     98        // add bins to location 
     99        int[] innerLocation = new int[location.length + 1]; 
     100        for (int i = 0; i < _binIndex; ++i) { 
     101            innerLocation[i] = location[i]; 
    106102        } 
    107         else { 
    108             location = new int[] { x, y, 0 }; 
     103        for (int i = _binIndex; i < location.length; ++i) { 
     104            innerLocation[i + 1] = location[i]; 
    109105        } 
    110106 
    111107        for (int i = 0; i < _bins; ++i) { 
    112             location[_binIndex] = i; 
    113             _cursor.moveTo(location); 
     108            innerLocation[_binIndex] = i; 
     109            _cursor.moveTo(innerLocation); 
    114110            decay[i] = _cursor.getType().getRealFloat(); 
    115111        } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/GrayScaleImage.java

    r7741 r7887  
    9090        LocalizableByDimCursor cursor = image.createLocalizableByDimCursor(); 
    9191        double[][] pixels = new double[m_width][m_height]; 
    92         byte[] outPixels = new byte[m_width * m_height]; 
    9392        int[] position = (channels > 1) ? new int[4] : new int[3]; 
    9493 
     
    9796                position[3] = c; 
    9897            } 
     98            byte[] outPixels = new byte[m_width * m_height]; 
    9999 
    100100            // sum photon counts 
     
    111111                        pixels[x][y] += ((ComplexType) cursor.getType()).getRealDouble(); 
    112112                    } 
     113                    // keep track of maximum 
    113114                    if (pixels[x][y] > maxPixel) { 
    114115                        maxPixel = pixels[x][y]; 
     
    123124                } 
    124125            } 
    125             //TODO random noise to ensure different channels do have different images: 
    126             //java.util.Random randomizer = new java.util.Random(); 
    127             //for (int i = 0; i < 1000; ++i) { 
    128             //    int noise = randomizer.nextInt(255); 
    129             //    int x = randomizer.nextInt(m_width); 
    130             //    int y = randomizer.nextInt(m_height); 
    131             //    outPixels[y * m_width + x] = (byte) noise; 
    132             //} 
    133126 
    134127            // add a slice 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/OutputImageWrapper.java

    r7875 r7887  
    2727    private int _parameterIndex; 
    2828    private LocalizableByDimCursor<DoubleType> _cursor; 
     29    private int[] _location; 
    2930 
    30     //TODO s/b OutputImageWrapper(int[] dimensions) 
    31     //TODO is this a wrapper any more, if it creates the wrapped thing 
    32     public OutputImageWrapper(int width, int height, int channels, int parameters) { 
    33          
    34         System.out.println("creating output width height channels params " + width + " " + height + " " + channels + " " + parameters); 
    35          
    36          
     31    /** 
     32     * Creates a wrapper for an output image (and the image itself). 
     33     *  
     34     * @param width 
     35     * @param height 
     36     * @param channels 
     37     * @param parameters  
     38     */ 
     39    public OutputImageWrapper(int width, int height, int channels, int parameters) {   
    3740        _width = width; 
    3841        _height = height; 
    3942        _channels = channels; 
    4043        _parameters = parameters; 
     44         
     45        int[] dimensions = new int[] { width, height, channels, parameters }; 
     46        _parameterIndex = 3; 
     47        _location = new int[dimensions.length]; 
    4148 
    42         // avoid a problem with ImgLib: 
    43         if (1 == width) ++width; 
    44         if (1 == height) ++height; 
    45          
    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         } 
    5549        _image = new ImageFactory<DoubleType> 
    5650                (new DoubleType(), 
     
    109103    @Override 
    110104    public int[] getDimension() { 
    111         int[] dimension = null; 
    112         if (_channels > 1) { 
    113             dimension = new int[] { _width, _height, _channels, _parameters }; 
    114         } 
    115         else { 
    116             dimension = new int[] { _width, _height, _parameters }; 
    117         } 
     105        int[] dimension = new int[] { _width, _height, _channels, _parameters }; 
    118106        return dimension; 
    119107    } 
    120108 
     109    @Override 
    121110    public double[] getPixel(int[] location) { 
     111        for (int i = 0; i < location.length; ++i) { 
     112            _location[i] = location[i]; 
     113        } 
    122114        double[] parameters = new double[_parameters]; 
    123115        for (int i = 0; i < _parameters; ++i) { 
    124             location[_parameterIndex] = i; 
    125             _cursor.moveTo(location); 
     116            _location[_parameterIndex] = i; 
     117            _cursor.moveTo(_location); 
    126118            parameters[i] = _cursor.getType().getRealFloat(); 
    127119        } 
     
    129121    } 
    130122 
     123    @Override 
    131124    public void setPixel(int[] location, double[] value) { 
    132         for (int i = 0; i < _parameters; ++i) { 
    133             location[_parameterIndex] = i; 
    134             _cursor.moveTo(location); 
    135             _cursor.getType().set(value[i]); 
    136         } 
    137     } 
    138  
    139     /** 
    140      * Gets fitted pixel value. 
    141      *  
    142      * @param x 
    143      * @param y 
    144      * @param channel 
    145      * @return 
    146      */ 
    147     @Override 
    148     public double[] getPixel(int x, int y, int channel) { 
    149         double[] parameters = new double[_parameters]; 
    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 }; 
     125        for (int i = 0; i < location.length; ++i) { 
     126            _location[i] = location[i]; 
    156127        } 
    157128        for (int i = 0; i < _parameters; ++i) { 
    158             location[_parameterIndex] = i; 
    159             _cursor.moveTo(location); 
    160             parameters[i] = _cursor.getType().getRealFloat(); 
    161         } 
    162         return parameters; 
    163     } 
    164  
    165     /** 
    166      * Puts fitted pixel value. 
    167      *  
    168      * @param x 
    169      * @param y 
    170      * @param channel 
    171      * @param pixel  
    172      */ 
    173     @Override 
    174     public void setPixel(int x, int y, int channel, double[] parameters) { 
    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         } 
    182         for (int i = 0; i < _parameters; ++i) { 
    183             location[_parameterIndex] = i; 
    184             _cursor.moveTo(location); 
    185             _cursor.getType().set(parameters[i]); 
     129            _location[_parameterIndex] = i; 
     130            _cursor.moveTo(_location); 
     131            _cursor.getType().set(value[i]); 
    186132        } 
    187133    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7875 r7887  
    9797import imagej.slim.fitting.images.ColorizedImageFitter; 
    9898import imagej.slim.fitting.images.ColorizedImageFitter.ColorizedImageType; 
     99import imagej.slim.histogram.HistogramTool; 
     100 
    99101import loci.curvefitter.ICurveFitter.FitAlgorithm; 
    100102import loci.curvefitter.ICurveFitter.FitFunction; 
     
    734736            fitInfo.setStopPrompt(100); 
    735737        } 
     738        fitInfo.setIndexColorModel(HistogramTool.getIndexColorModel()); 
    736739        m_fitInfo = fitInfo; 
    737740         
    738741        // set up images 
    739         IDecayImage decayImage = new DecayImageWrapper(m_image, m_width, m_height, m_channels, m_channelIndex, m_bins, m_binIndex); 
     742        IDecayImage decayImage = new DecayImageWrapper(m_image, m_width, m_height, m_channels, m_bins, m_binIndex); 
    740743        IFittedImage previousImage = null; 
    741744        int width = decayImage.getWidth(); 
     
    775778  
    776779        // get commonly-used items in local variables 
    777         int width = /*new*/decayImage.getWidth(); 
    778         int height = /*new*/decayImage.getHeight(); 
    779         int channels = /*new*/decayImage.getChannels(); 
    780         int[] dimension = new int[] { width, height, channels }; 
     780        int width = decayImage.getWidth(); 
     781        int height = decayImage.getHeight(); 
     782        int channels = decayImage.getChannels(); 
     783        int bins = decayImage.getBins(); 
    781784        int channel = fitInfo.getChannel(); 
    782785        boolean fitAllChannels = fitInfo.getFitAllChannels(); 
     
    788791  
    789792        // handle optionally producing colorized images during the fit 
     793        int colorizedChannels = 1; 
     794        if (fitAllChannels) { 
     795            colorizedChannels = channels; 
     796        } 
     797        int[] dimension = new int[] { width, height, colorizedChannels }; 
    790798        ColorizedImageFitter imageColorizer = null; 
    791799        String outputs = fitInfo.getFittedImages(); 
     
    796804            ColorizedImageType[] outputImages = parser.getColorizedImages(); 
    797805            imageColorizer = new ColorizedImageFitter(); 
    798             imageColorizer.setUpFit(outputImages, dimension, components); 
     806            imageColorizer.setUpFit(outputImages, dimension, 
     807                    fitInfo.getIndexColorModel(), components); 
    799808            imageColorizer.beginFit(); 
    800809        } 
     
    830839                IJ.showProgress(++pixelCount, totalPixelCount); 
    831840                ChunkyPixel pixel = pixelIterator.next(); 
    832                  
     841 
     842                // compute full location information 
    833843                int x = pixel.getX(); 
    834844                int y = pixel.getY(); 
    835                 if (decayImage.fitThisPixel(x, y, c)) { 
     845                int[] inputLocation = new int[] { x, y, c }; 
     846                int[] outputLocation = new int[] { x, y, fitAllChannels ? c : 0 }; 
     847 
     848                double[] decay = decayImage.getPixel(inputLocation); 
     849                // fit this pixel? 
     850                if (null != decay) { 
    836851                    // set up local, pixel fit parameters 
    837852                    ILocalFitParams localFitParams = new LocalFitParams(); 
    838                     localFitParams.setY(decayImage.getPixel(x, y, c)); 
    839                     double[] decay = decayImage.getPixel(x, y, c); 
     853                    localFitParams.setY(decay); 
    840854                    localFitParams.setSig(null); 
    841855                    localFitParams.setFitStart(fitInfo.getStartDecay()); 
    842856                    localFitParams.setFitStop(fitInfo.getStopDecay()); 
    843857                    localFitParams.setParams(fitInfo.getParameters()); 
    844                     double[] yFitted = new double[1024]; //TODO ARG s/b based on bins 
     858                    double[] yFitted = new double[bins]; 
    845859                    localFitParams.setYFitted(yFitted); 
    846860                     
    847                     pixel.setLocation(new int[] { x, y, c });                    
     861                    pixel.setInputLocation(inputLocation); 
     862                    pixel.setOutputLocation(outputLocation); 
    848863                    pixelList.add(pixel); 
    849864                    localFitParamsList.add(localFitParams); 
     
    918933            IFitResults result = resultsList.get(i); 
    919934            ChunkyPixel p = pixels[i]; 
     935            int[] location = p.getOutputLocation(); 
     936            double[] results = result.getParams(); 
     937            // if producing colorized images, feed this pixel to colorizer 
    920938            if (null != imageColorizer) { 
    921                 int[] location = p.getLocation(); 
    922                 double[] results = result.getParams(); 
    923939                imageColorizer.updatePixel(location, results); 
    924940            } 
    925             fittedImage.setPixel(p.getLocation(), result.getParams()); //TODO ARG for a multichannel fit, location needs channel also; should ChunkyPixel keep track? 
     941            fittedImage.setPixel(location, results); 
    926942        } 
    927943 
     
    13041320         
    13051321        ColorizedImageType[] outputImages = parser.getColorizedImages(); 
    1306         imageFitter.setUpFit(outputImages, new int[] { m_width, m_height }, components); 
     1322        imageFitter.setUpFit(outputImages, new int[] { m_width, m_height }, null, components); 
    13071323        imageFitter.beginFit(); 
    13081324         
     
    15221538         
    15231539        ColorizedImageType[] colorizedImages = parser.getColorizedImages(); 
    1524         imageFitter.setUpFit(colorizedImages, new int[] { m_width, m_height }, components); 
     1540        imageFitter.setUpFit(colorizedImages, new int[] { m_width, m_height }, null, components); 
    15251541        imageFitter.beginFit();        
    15261542 
Note: See TracChangeset for help on using the changeset viewer.