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/loci/slim
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • 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.