Changeset 7834 for trunk/projects


Ignore:
Timestamp:
12/14/11 18:08:35 (8 years ago)
Author:
aivar
Message:

Working on histogram

Location:
trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram
Files:
4 edited

Legend:

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

    r7833 r7834  
    133133                // calculate actual minimum and maximum for all channels 
    134134                for (int i = 0; i < _channel.length; ++i) { 
    135                     minMax = _channel[i].resetActualMinMax(); 
     135                    minMax = _channel[i].findMinMax(); 
    136136                    if (minMax[0] < min) { 
    137137                        min = minMax[0]; 
     
    145145            else { 
    146146                // calculate actual minimum and maximum for current channel 
    147                 minMax = _channel[_channelIndex].resetActualMinMax(); 
     147                minMax = _channel[_channelIndex].findMinMax(); 
    148148            } 
    149149            _minView = _minLUT = minMax[0]; 
     
    156156        // start new histogram bins            
    157157        int[] bin = new int[bins]; 
     158        for (int i = 0; i < bins; ++i) { 
     159            bin[i] = 0; 
     160        } 
    158161        System.out.println("bin[3] is " + bin[3] + " bin[33] " + bin[33]); 
    159162        System.out.println("_minView is " + _minView + " max " + _maxView); 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramDataChannel.java

    r7833 r7834  
    77/** 
    88 * This class shadows a channel in a stack for a displayed image.  If the image 
    9  * is not a stack there would be only one of these. 
     9 * has only two dimensions there would be only one of these per HistogramData. 
    1010 * 
    11  * @author aivar 
     11 * @author Aivar Grislis 
    1212 */ 
    1313public class HistogramDataChannel { 
    1414    private double[][] _values; 
    15     private double _actualMin; 
    16     private double _actualMax; 
     15    private double _min; 
     16    private double _max; 
     17    private double _minLUT; 
     18    private double _maxLUT; 
    1719 
    1820    /** 
    1921     * Constructor, takes the array of values. 
     22     *  
     23     * This class keeps a separate array of values, rather than just referring 
     24     * to the image values, for two reasons: 
     25     * 1) If the 'chunky pixel' effect is used to draw the image, histogram 
     26     * values will be temporarily incorrect until image is complete. 
     27     * 2) If the image shows colorized grayscale, a la SPCImage, the image values 
     28     * will be incorrect. 
    2029     *  
    2130     * @param values  
     
    2332    public HistogramDataChannel(double[][] values) { 
    2433        _values = values; 
    25         _actualMin = _actualMax = 0.0f; 
     34        _min = _max = 0.0f; 
     35    } 
     36 
     37    /** 
     38     * This class is also a container for minimum and maximum LUT values.  These 
     39     * only apply when the LUT is not autoranging and each channel has its own 
     40     * values. 
     41     *  
     42     * @return  
     43     */ 
     44    public double[] getMinMaxLUT() { 
     45        return new double[] { _minLUT, _maxLUT }; 
     46    } 
     47  
     48    /** 
     49     * Sets the minimum and maximum LUT values. 
     50     *  
     51     * @param min 
     52     * @param max  
     53     */ 
     54    public void setMinMaxLUT(double min, double max) { 
     55        _minLUT = min; 
     56        _maxLUT = max; 
    2657    } 
    2758 
     
    3263     * @return array of { min, max } 
    3364     */ 
    34     public double[] resetActualMinMax() { 
    35         _actualMin = Double.MAX_VALUE; 
    36         _actualMax = Double.MIN_VALUE; 
     65    public double[] findMinMax() { 
     66        _min = Double.MAX_VALUE; 
     67        _max = Double.MIN_VALUE; 
    3768        for (int i = 0; i < _values.length; ++i) { 
    3869            for (int j = 0; j < _values[0].length; ++j) { 
    3970                if (_values[i][j] != Double.NaN) { 
    40                     if (_values[i][j] < _actualMin) { 
    41                         _actualMin = _values[i][j]; 
     71                    if (_values[i][j] < _min) { 
     72                        _min = _values[i][j]; 
    4273                    } 
    43                     if (_values[i][j] > _actualMax) { 
    44                         _actualMax = _values[i][j]; 
     74                    if (_values[i][j] > _max) { 
     75                        _max = _values[i][j]; 
    4576                    } 
    4677                } 
    4778            } 
    4879        } 
    49         return new double[] { _actualMin, _actualMax }; 
     80        return new double[] { _min, _max }; 
    5081    } 
    5182     
     
    6495            results[i] = 0; 
    6596        } 
    66         double binWidth = bins / (nominalMax - nominalMin); 
     97        //TODOdouble binWidth = bins / (nominalMax - nominalMin); I think this might be losing the last bin //TODO no, still loses the last bin, on gpl1.sdt T1 
    6798        for (int i = 0; i < _values.length; ++i) { 
    6899            for (int j = 0; j < _values[0].length; ++j) { 
     
    70101                if (value >= nominalMin && value <= nominalMax) { 
    71102                    // assign each value to a bin 
    72                     int bin = (int)((value - nominalMin) * binWidth); 
     103                    int bin = (int)((value - nominalMin) * bins / (nominalMax - nominalMin)); //TODO binWidth); 
    73104                    if (bin >= bins) { 
    74105                        --bin; 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramPanel.java

    r7825 r7834  
    88import java.awt.Dimension; 
    99import java.awt.Graphics; 
     10import java.awt.event.MouseEvent; 
     11import java.awt.event.MouseListener; 
     12import java.awt.event.MouseMotionListener; 
    1013 
    1114import javax.swing.JPanel; 
     
    1518/** 
    1619 * 
    17  * @author aivar 
     20 * @author Aivar Grislis 
    1821 */ 
    1922public class HistogramPanel extends JPanel { 
    2023    static final int ONE_HEIGHT = 20; 
     24    static final int FUDGE_FACTOR = 2; 
    2125    private final Object _synchObject = new Object(); 
    2226    private int _width; 
     
    2529    private int[] _bins; 
    2630    private int _max; 
     31    private Integer _minCursor; 
     32    private Integer _maxCursor; 
     33    private boolean _draggingMinCursor; 
     34    private boolean _draggingMaxCursor; 
    2735     
    2836    /** 
     
    4048        _bins = null; 
    4149         
     50        _minCursor = _maxCursor = null; 
     51         
     52        _draggingMinCursor = _draggingMaxCursor = false; 
     53         
    4254        setPreferredSize(new Dimension(width, height)); 
     55        addMouseListener(new MouseListener() { 
     56            public void mousePressed(MouseEvent e) { 
     57                synchronized (_synchObject) { 
     58                    if (null != _minCursor && null != _maxCursor) { 
     59                        if (Math.abs(_minCursor - e.getX()) < FUDGE_FACTOR) { 
     60                            _draggingMinCursor = true; 
     61                        } 
     62                        else if (Math.abs(_maxCursor - e.getX()) < FUDGE_FACTOR) { 
     63                            _draggingMaxCursor = true; 
     64                        } 
     65                    } 
     66                } 
     67            } 
     68             
     69            public void mouseReleased(MouseEvent e) { 
     70                synchronized (_synchObject) { 
     71                    if (_draggingMinCursor) { 
     72                        _minCursor = e.getX(); //TODO adjust this and max to go to begin/end of histo 
     73                        _draggingMinCursor = false; 
     74                    } 
     75                    else if (_draggingMaxCursor) {  
     76                        _maxCursor = e.getX(); 
     77                        _draggingMaxCursor = false; 
     78                    }                     
     79                } 
     80            } 
     81             
     82            public void mouseEntered(MouseEvent e) { } 
     83             
     84            public void mouseExited(MouseEvent e) { } 
     85             
     86            public void mouseClicked(MouseEvent e) { } 
     87             
     88        }); 
     89        addMouseMotionListener(new MouseMotionListener() { 
     90            public void mouseMoved(MouseEvent e) { } 
     91             
     92            public void mouseDragged(MouseEvent e) { 
     93                synchronized (_synchObject) { 
     94                    if (_draggingMinCursor) { 
     95                        if (_maxCursor > e.getX()) { 
     96                            _minCursor = e.getX(); 
     97                        } 
     98                        repaint(); 
     99                    } 
     100                    else if (_draggingMaxCursor) { 
     101                        if (_minCursor < e.getX()) { 
     102                            _maxCursor = e.getX(); 
     103                        } 
     104                        repaint(); 
     105                    }     
     106                } 
     107            } 
     108        }); 
    43109    } 
    44110 
     
    51117        synchronized (_synchObject) { 
    52118            _bins = bins; 
     119            _max = Integer.MIN_VALUE; 
    53120            for (int i = 0; i < bins.length; ++i) { 
    54121                if (bins[i] > _max) { 
    55122                    _max = bins[i]; 
    56123                } 
     124            } 
     125        } 
     126        repaint(); 
     127    } 
     128 
     129    /** 
     130     * Changes cursors and redraws. 
     131     *  
     132     * @param minCursor 
     133     * @param maxCursor  
     134     */ 
     135    public void setCursors(Integer minCursor, Integer maxCursor) { 
     136        synchronized (_synchObject) { 
     137            _minCursor = minCursor; 
     138            _maxCursor = maxCursor; 
     139            if (null == _minCursor && null == _maxCursor) { 
     140                _draggingMinCursor = _draggingMaxCursor = false; 
    57141            } 
    58142        } 
     
    70154                        height = 0; 
    71155                    } 
     156                    // note that the log of 1 is zero; have to distinguish from 0 
    72157                    else if (1 == _bins[i]) { 
    73158                        height = ONE_HEIGHT; 
     
    84169                    g.drawLine(_inset + i, _height - height, _inset + i, _height); 
    85170                } 
    86                 /* 
    87                 int x; 
    88                 g.setXORMode(Color.MAGENTA); 
    89                 x = valueToPixel(_start); 
    90                 g.drawLine(x, 0, x, _height - 1); 
    91                 x = valueToPixel(_stop); 
    92                 g.drawLine(x, 0, x, _height - 1); 
    93                 */ 
     171                 
     172                if (null != _minCursor && null != _maxCursor) { 
     173                    g.setXORMode(Color.MAGENTA); 
     174                    g.drawLine(_minCursor, 0, _minCursor, _height - 1); 
     175                    g.drawLine(_maxCursor, 0, _maxCursor, _height - 1); 
     176                } 
    94177            } 
    95178        } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramTool.java

    r7833 r7834  
    6161        _frame.pack(); 
    6262        _frame.setVisible(true); 
     63         
     64       //TODO FOR A TEST: 
     65        _histogram.setCursors(3, 44); 
    6366    } 
    6467     
Note: See TracChangeset for help on using the changeset viewer.