Changeset 7847 for trunk


Ignore:
Timestamp:
12/21/11 17:55:34 (8 years ago)
Author:
aivar
Message:

Format doubles to given number of digits. Entering new start/stop text affects LUT ranges.

Location:
trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram
Files:
1 added
7 edited

Legend:

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

    r7844 r7847  
    5959    private int _inset; 
    6060    private Color[] _color; 
    61     double _min; 
    62     double _max; 
     61    double _minView; 
     62    double _maxView; 
    6363    double _minLUT; 
    6464    double _maxLUT; 
    6565 
    6666    /** 
    67      * Constructor 
     67     * Constructor.  Note that for best results width should be 254, so that 
     68     * there is a 1:1 relationship between colors and pixels. 
    6869     * 
    6970     * @param width 
     
    8081        setPreferredSize(new Dimension(width + 2 * inset, height)); 
    8182 
    82         _min = _max = _minLUT = _maxLUT = 0.0f; 
     83        _minView = _maxView = _minLUT = _maxLUT = 0.0f; 
    8384    } 
    8485 
     
    9899     * Changes the values and redraws. 
    99100     *  
    100      * @param min 
    101      * @param max 
     101     * @param minView 
     102     * @param maxView 
    102103     * @param minLUT 
    103104     * @param maxLUT 
    104105     */ 
    105     public void setMinMax(double min, double max, double minLUT, double maxLUT) { 
     106    public void setMinMax(double minView, double maxView, 
     107            double minLUT, double maxLUT) { 
    106108        synchronized (_synchObject) { 
    107             _min = min; 
    108             _max = max; 
     109            _minView = minView; 
     110            _maxView = maxView; 
    109111            _minLUT = minLUT; 
    110112            _maxLUT = maxLUT; 
     
    161163 
    162164    /* 
    163      * Given a pixel value 0...253 
     165     * Given a pixel value 0..253 show appropriate color. 
     166     *  
    164167     * @param i 
    165168     * @return 
    166169     */ 
    167     //TODO this is WRONGO!!!!! 256 color version 
    168170    private Color colorize(int i) { 
     171        // default color 
    169172        Color color = _color[0]; 
    170         // wait till we have initial range 
    171         if (_min < _max) { 
    172             double value = _min + (_max - _min) * i / _width; 
     173         
     174        // wait till we have initial range before any colorization 
     175        if (_minView < _maxView) { 
     176             
     177            // what is the value for this pixel? 
     178            double value = _minView + (_maxView - _minView) * i / _width; 
     179             
     180            // if value within palette range 
    173181            if (value >= _minLUT && value <= _maxLUT) { 
    174                 int index = (int)((value - _minLUT) 
     182                 
     183                // compute color index 
     184                int index = 1 + (int)((value - _minLUT) 
    175185                        * _color.length / (_maxLUT - _minLUT)); 
    176                 index = Math.max(index, 0); 
    177                 index = Math.min(index, _color.length - 1); 
     186                 
     187                // constrain to 1..253 
     188                index = Math.max(index, 1); 
     189                index = Math.min(index, _color.length - 3); 
     190                 
     191                // get the color 
    178192                color = _color[index]; 
    179193            } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramData.java

    r7845 r7847  
    1515    private HistogramDataChannel[] _channel; 
    1616    private int _channelIndex; 
    17     private boolean _autoScale; 
     17    private boolean _autoRange; 
    1818    private boolean _combineChannels; 
    1919    private boolean _displayChannels; 
     
    3232        _title = title; 
    3333        _channel = channel; 
    34         _autoScale = true; 
     34        _autoRange = true; 
    3535        _combineChannels = true; 
    3636        _displayChannels = true; 
     
    4141    } 
    4242 
     43    /** 
     44     * Sets a listener for histogram data changes.  Listener is unique. 
     45     *  
     46     * @param listener  
     47     */ 
    4348    public void setListener(IHistogramDataListener listener) { 
    4449        _listener = listener; 
     
    6368    } 
    6469 
    65      
    6670    /** 
    6771     * Sets current channel index. 
     
    7377    } 
    7478 
     79    /** 
     80     * Gets whether or not histogram should automatically scale to values. 
     81     *  
     82     * @return whether automatically scales 
     83     */ 
     84    public boolean getAutoRange() { 
     85        return _autoRange; 
     86    } 
     87     
     88    /** 
     89     * Sets whether or not histogram should automatically scale to values. 
     90     *  
     91     * @param auto whether automatically scales 
     92     */ 
     93    public void setAutoRange(boolean autoRange) { 
     94        _autoRange = autoRange; 
     95    } 
     96 
     97    /** 
     98     * Gets whether or not histogram should combine all the channels. 
     99     *  
     100     * @return whether to combine all the channels 
     101     */ 
     102    public boolean getCombineChannels() { 
     103        return _combineChannels; 
     104    } 
     105 
     106    /** 
     107     * Sets whether or not histogram should combine all the channels. 
     108     *  
     109     * @param combineChannels 
     110     */ 
     111    public void setCombineChannels(boolean combineChannels) { 
     112        _combineChannels = combineChannels; 
     113    } 
     114     
     115    /** 
     116     * Gets whether or not histogram should display all channels. 
     117     *  
     118     * @return  
     119     */ 
    75120    public boolean getDisplayChannels() { 
    76121        return _displayChannels; 
    77122    } 
    78123 
     124    /** 
     125     * Sets whether or not histogram should display all channels. 
     126     *  
     127     * @param displayChannels  
     128     */ 
    79129    public void setDisplayChannels(boolean displayChannels) { 
    80  
    81     } 
    82  
    83     /** 
    84      * Gets whether or not histogram should combine all the channels. 
    85      *  
    86      * @return whether to combine all the channels 
    87      */ 
    88     public boolean getCombineChannels() { 
    89         return _combineChannels; 
    90     } 
    91  
    92     /** 
    93      * Sets whether or not histogram should combine all the channels. 
    94      *  
    95      * @param combineChannels 
    96      */ 
    97     public void setCombineChannels(boolean combineChannels) { 
    98         _combineChannels = combineChannels; 
    99     } 
    100  
    101     /** 
    102      * Gets whether or not histogram should automatically scale to values. 
    103      *  
    104      * @return whether automatically scales 
    105      */ 
    106     public boolean getAutoScale() { 
    107         return _autoScale; 
    108     } 
    109      
    110     /** 
    111      * Sets whether or not histogram should automatically scale to values. 
    112      *  
    113      * @param auto whether automatically scales 
    114      */ 
    115     public void setAutoScale(boolean autoScale) { 
    116         _autoScale = autoScale; 
    117     } 
    118      
     130        _displayChannels = displayChannels; 
     131    } 
     132 
    119133    /** 
    120134     * Gets minimum and maximum extents of the view. 
     
    207221        } 
    208222 
    209         if (_autoScale) { 
     223        if (_autoRange) { 
    210224            if (_combineChannels) { 
    211225                // LUT and view bounded by data for all channels 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramPanel.java

    r7838 r7847  
    1919 * bounds of the view.  Dragging the cursor off the edge stretches those bounds. 
    2020 * 
    21  * @author Aivar Grislis 
     21 * @author Aivar Grislis grislis at wisc dot edu 
    2222 */ 
    2323public class HistogramPanel extends JPanel { 
    24     static final int ONE_HEIGHT = 20; 
    25     static final int FUDGE_FACTOR = 4; 
     24    private static final int ONE_HEIGHT = 20; 
     25    private static final int FUDGE_FACTOR = 4; 
    2626    private IHistogramPanelListener _listener; 
    2727    private final Object _synchObject = new Object(); 
     
    3030    private int _inset; 
    3131    private int[] _bins; 
    32     private int _max; 
     32    private int _maxBinCount; 
    3333    private Integer _minCursor; 
    3434    private Integer _maxCursor; 
     
    7575            public void mouseReleased(MouseEvent e) { 
    7676                boolean changed = false; 
     77                int min = 0; // makes the compiler happy 
     78                int max = 0; 
    7779                synchronized (_synchObject) { 
    7880                    if (_draggingMinCursor) { 
     
    101103                        _draggingMaxCursor = false; 
    102104                        changed = true; 
    103                     }                     
     105                    } 
     106                    if (changed) { 
     107                        // convert to 0..width-1 range 
     108                        min = _minCursor - _inset + 1; 
     109                        max = _maxCursor - _inset - 1; 
     110                    } 
    104111                } 
    105112                if (changed) { 
     113                    if (null != _listener) { 
     114                        _listener.setMinMaxLUTPixels(min, max); 
     115                    } 
    106116                    repaint(); 
    107                     if (null != _listener) { 
    108                         // convert to 0..width - 1 range 
    109                         int min = _minCursor - _inset + 1; //TODO _min/_maxCursor c/b changed by now 
    110                         int max = _maxCursor - _inset - 1; 
    111                         _listener.setMinMax(min, max); 
    112                     } 
    113117                } 
    114118            } 
     
    133137            public void mouseDragged(MouseEvent e) { 
    134138                boolean changed = false; 
     139                int min = 0; // makes the compiler happy 
     140                int max = 0; 
    135141                synchronized (_synchObject) { 
    136142                    if (_draggingMinCursor) { 
     
    155161                        } 
    156162                        changed = true; 
    157                     }     
     163                    } 
     164                    if (changed) { 
     165                        // convert to 0..width-1 range 
     166                        min = _minCursor - _inset + 1; 
     167                        max = _maxCursor - _inset - 1; 
     168                    } 
     169 
    158170                } 
    159171                if (changed) { 
     172                    if (null != _listener) { 
     173                        // report dragged cursor position 
     174                        _listener.dragMinMaxPixels(min, max); 
     175                    } 
    160176                    repaint(); 
    161  
    162                     if (null != _listener) { 
    163                         // convert to 0..width - 1 range 
    164                         int min = _minCursor - _inset + 1; 
    165                         int max = _maxCursor - _inset - 1; 
    166                         // report dragged cursor position 
    167                         _listener.dragMinMax(min, max); 
    168                     } 
    169177                }   
    170178            } 
     
    187195     */ 
    188196    public void setBins(int[] bins) { 
    189         System.out.println("SET BINS"); 
    190197        synchronized (_synchObject) { 
    191198            _bins = bins; 
    192             _max = Integer.MIN_VALUE; 
     199            _maxBinCount = Integer.MIN_VALUE; 
    193200            for (int i = 0; i < bins.length; ++i) { 
    194                 if (bins[i] > _max) { 
    195                     _max = bins[i]; 
     201                if (bins[i] > _maxBinCount) { 
     202                    _maxBinCount = bins[i]; 
    196203                } 
    197204            } 
     
    201208 
    202209    /** 
    203      * Changes cursors and redraws. 
     210     * Changes cursors and redraws.  Note that when they are both null no 
     211     * cursor is diaplayed. 
    204212     *  
    205213     * @param minCursor 
     
    213221                _draggingMinCursor = _draggingMaxCursor = false; 
    214222            } 
     223            else { 
     224                // the cursors actually bracket the specified pixels 
     225                --_minCursor; 
     226                ++_maxCursor; 
     227            } 
    215228        } 
    216229        repaint(); 
    217230    } 
     231     
    218232 
    219233    @Override 
     
    232246                    } 
    233247                    else { 
    234                         height = (int) ((_height - ONE_HEIGHT) * Math.log(_bins[i]) / Math.log(_max)) + ONE_HEIGHT; 
     248                        height = (int) ((_height - ONE_HEIGHT) * Math.log(_bins[i]) / Math.log(_maxBinCount)) + ONE_HEIGHT; 
    235249                    } 
    236250                    if (height > _height) { 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/HistogramTool.java

    r7846 r7847  
    3333 
    3434/** 
    35  * This is the main class for this histogram tool.  It handles layout and wiring 
     35 * This is the main class for the histogram tool.  It handles layout and wiring 
    3636 * of UI components and the logic of updating the histogram. 
    3737 * 
     
    4949    private static HistogramTool INSTANCE = null; 
    5050    private final Object _synchObject = new Object(); 
     51    private JFrame _frame; 
    5152    private HistogramData _histogramData; 
    52     private JFrame _frame; 
    5353    private HistogramPanel _histogramPanel; 
    5454    private ColorBarPanel _colorBarPanel; 
     
    6464        _colorBarPanel = new ColorBarPanel(WIDTH, INSET, COLORBAR_HEIGHT); 
    6565        _colorBarPanel.setLUT(getLUT()); 
    66         _uiPanel = new UIPanel(); 
     66        _uiPanel = new UIPanel(true); 
    6767        _uiPanel.setListener(new UIPanelListener()); 
    6868 
     
    7575        _frame.pack(); 
    7676        _frame.setVisible(true); 
    77          
    78        //TODO FOR A TEST: 
    79         _histogramPanel.setCursors(3, 44); 
    8077    } 
    8178 
     
    107104        } 
    108105 
    109         //TODO ARG Kludge: 
    110106        // IJ converts the FloatProcessor to 8-bits and then uses this palette 
    111107        // for display.  Unfortunately values less than or greater than the LUT 
    112108        // range still get displayed with LUT colors.  To work around this, use 
    113         // only 254 of the LUT colors. 
     109        // only 254 of the LUT colors.  The first and last colors will represent 
     110        // values less than and greater than the LUT range respectively. 
    114111 
    115112        colorModel = PaletteFix.fixIndexColorModel(colorModel, Color.BLACK, Color.WHITE); 
     
    118115 
    119116    /** 
    120      * Gets a LUT. 
     117     * Gets a LUT.  Temporary expedient, belongs elsewhere. 
    121118     *  
    122119     * @return  
     
    129126 
    130127    /** 
     128     * This method should be called whenever a new set of histogram values is 
     129     * to be displayed (i.e. when a different image gets focus). 
     130     *  
    131131     * @param histogramData  
    132132     */ 
    133     //TODO this method is called from the focus listener only??? 
    134     //  what about changes during the fit? 
    135     // How is initial histogramData aassigned? 
    136133    public void setHistogramData(HistogramData histogramData) { 
     134        double[] minMaxView; 
     135        double[] minMaxLUT; 
    137136        synchronized (_synchObject) { 
    138137            _histogramData = histogramData; 
    139         } 
     138            _histogramData.setListener(new HistogramDataListener()); 
     139            minMaxView = _histogramData.getMinMaxView(); 
     140            minMaxLUT  = _histogramData.getMinMaxLUT(); 
     141        } 
     142         
    140143        if (_frame.isVisible()) { 
    141144            _frame.setVisible(true); 
    142145        } 
    143146        _frame.setTitle(histogramData.getTitle()); 
     147         
    144148        _histogramPanel.setBins(histogramData.binValues(WIDTH)); 
    145         _histogramData.setListener(new HistogramDataListener()); //TODO a new one, or reuse existing? 
     149        //_histogramPanel.setCursors(0.0, 0.0); set cursors if not autoranging 
     150 
     151        _uiPanel.setAutoRange(histogramData.getAutoRange()); 
     152        _uiPanel.setCombineChannels(histogramData.getCombineChannels()); 
     153        _uiPanel.setDisplayChannels(histogramData.getDisplayChannels()); 
     154        _uiPanel.setMinMaxLUT(minMaxLUT[0], minMaxLUT[1]); 
     155         
     156        _colorBarPanel.setMinMax(minMaxView[0], minMaxView[1], 
     157                minMaxLUT[0], minMaxLUT[1]); 
    146158    } 
    147159 
     
    180192            int[] bins = _histogramData.binValues(WIDTH); 
    181193            _histogramPanel.setBins(bins); 
    182             //TODO does this need to be fixed 256->254??? 
    183194            _colorBarPanel.setMinMax(minView, maxView, minLUT, maxLUT); 
    184195        } 
     
    189200     */ 
    190201    private class HistogramDataListener implements IHistogramDataListener { 
     202         
     203        @Override 
    191204        public void minMaxChanged(double minView, double maxView, 
    192205                double minLUT, double maxLUT) { 
     
    201214        private Timer _timer = null; 
    202215        private volatile int _dragPixels; 
    203          
    204         private HistogramPanelListener() { } 
    205216  
    206217        /** 
     
    212223         * @param max  
    213224         */ 
    214         public void setMinMax(int min, int max) { 
     225        public void setMinMaxLUTPixels(int min, int max) { 
    215226            killTimer(); 
    216227 
     
    218229            double minLUT = pixelToValue(min); 
    219230            double maxLUT = pixelToValue(max); 
    220  
     231             
    221232            // set min and max on UI panel 
    222233            _uiPanel.setMinMaxLUT(minLUT, maxLUT); 
    223234 
    224             // redraw image and save 
    225             _histogramData.setMinMaxLUT(minLUT, maxLUT); 
    226  
    227235            // redraw color bar 
    228236            _colorBarPanel.setMinMaxLUT(minLUT, maxLUT); 
     237             
     238            // save and redraw image 
     239            synchronized (_synchObject) { 
     240                _histogramData.setMinMaxLUT(minLUT, maxLUT); 
     241            } 
    229242        } 
    230243 
     
    237250         */ 
    238251        @Override 
    239         public void dragMinMax(int min, int max) { 
     252        public void dragMinMaxPixels(int min, int max) { 
    240253            System.out.println("dragMinMax(" + min + "," + max + ")"); 
    241254            if (min < 0 || max >= PaletteFix.ADJUSTED_SIZE) { 
     
    255268            } 
    256269            else { 
    257                 // dragging within bounds now, kill the periodic task 
     270                // dragging within bounds now, kill the periodic task, if any 
    258271                killTimer(); 
     272                _uiPanel.dragMinMaxLUT(pixelToValue(min), pixelToValue(max)); 
    259273            } 
    260274        } 
     
    310324                    _colorBarPanel.setMinMax(minView, maxView, minLUT, maxLUT); 
    311325                    System.out.println("set to " + minView + " " + maxView); 
    312                  //   _colorBarPanel. update color bar also 
    313326                } 
    314327            } 
     
    317330 
    318331    private class UIPanelListener implements IUIPanelListener { 
    319         //tOEOprivate UIPanelListener() { } 
    320         @Override 
    321         public void setAuto(boolean auto) { 
     332        @Override 
     333        public void setAutoRange(boolean autoRange) { 
     334            System.out.println("HistogramTool.UIPanelListener.setAutoRange(" + autoRange + ")"); 
     335            synchronized (_synchObject) { 
     336                 _histogramData.setAutoRange(autoRange); 
     337            } 
    322338             // turn on/off the cursors 
    323339            // they are usually at -1 & 255 
     
    327343            // autorange on, should calculate new bounds 
    328344        } 
    329  
    330         @Override 
    331         public void setMinMaxLUT(double min, double max) { 
    332             // user has typed in some new values 
    333             // can't be autoranging 
    334             // adjust cursors and color bar and possibly histogram 
     345         
     346        @Override 
     347        public void setCombineChannels(boolean combineChannels) { 
     348            synchronized (_synchObject) { 
     349                _histogramData.setCombineChannels(combineChannels); 
     350            } 
     351            //TODO 
     352            System.out.println("HistogramTool.UIPanelListener.setCombineChannels(" + combineChannels + ")"); 
     353        } 
     354         
     355        @Override 
     356        public void setDisplayChannels(boolean displayChannels) { 
     357            synchronized (_synchObject) { 
     358                _histogramData.setDisplayChannels(displayChannels); 
     359            } 
     360            //TODO 
     361            System.out.println("HistogramTool.UIPanelListener.setDisplayChannels(" + displayChannels + ")"); 
     362        } 
     363 
     364        @Override 
     365        public void setMinMaxLUT(double minLUT, double maxLUT) { 
     366            boolean changed = false; 
     367            double minView = 0; 
     368            double maxView = 0; 
     369             
     370            // silently ignores errors; c/b temporary condition such as setting 
     371            // maximum before minimum 
     372            if (minLUT < maxLUT) { 
     373                changed = true; 
     374                 
     375                synchronized (_synchObject) { 
     376                    // expand the view to fit the LUT 
     377                    double[] minMaxView = _histogramData.getMinMaxView(); 
     378                    minView = Math.min(minLUT, minMaxView[0]); 
     379                    maxView = Math.max(maxLUT, minMaxView[1]); 
     380                    _histogramData.setMinMaxView(minView, maxView); 
     381                    _histogramData.setMinMaxLUT(minLUT, maxLUT); 
     382                } 
     383            } 
     384 
     385            if (changed) { 
     386                System.out.println("CHANGED:" + minView + " " + maxView); 
     387                // update histogram and color bar 
     388                changed(minView, maxView, minLUT, maxLUT); 
     389            } 
     390            System.out.println("new min LUT is " + minLUT + "new max LUT is " + maxLUT);    
    335391        } 
    336392    } 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/IHistogramPanelListener.java

    r7838 r7847  
    2121     * @param max  
    2222     */ 
    23     public void setMinMax(int min, int max); 
     23    public void setMinMaxLUTPixels(int min, int max); 
    2424 
    2525    /** 
     
    2929     * @param max 
    3030     */ 
    31     public void dragMinMax(int min, int max); 
     31    public void dragMinMaxPixels(int min, int max); 
    3232 
    3333    /** 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/IUIPanelListener.java

    r7845 r7847  
    1313     
    1414    /** 
    15      * User has clicked the auto checkbox. 
     15     * User has clicked the auto ranging checkbox. 
    1616     *  
    17      * @param auto 
     17     * @param autoRange 
    1818     */ 
    19     public void setAuto(boolean auto); 
     19    public void setAutoRange(boolean autoRange); 
     20     
     21    /** 
     22     * User has clicked the combine channels checkbox. 
     23     */ 
     24    public void setCombineChannels(boolean combineChannels); 
    2025 
    2126    /** 
    22      * User has entered new min or max LUT values. 
     27     * User has clicked the display channels checkbox. 
     28     *  
     29     * @param displayChannels  
     30     */ 
     31    public void setDisplayChannels(boolean displayChannels); 
     32 
     33    /** 
     34     * User has entered new min/max LUT value. 
    2335     * 
    2436     * @param min 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/histogram/UIPanel.java

    r7846 r7847  
    1212import javax.swing.BoxLayout; 
    1313import javax.swing.JCheckBox; 
    14 import javax.swing.JComponent; 
    15 import javax.swing.JFrame; 
    16 import javax.swing.JLabel; 
    1714import javax.swing.JPanel; 
    18 import javax.swing.JFormattedTextField; 
    1915import javax.swing.JTextField; 
    2016 
    2117/** 
    22  * 
    23  * @author aivar 
     18 * This class holds the text fields that show the current minimum and maximum 
     19 * LUT range.  It also has checkboxes to control how the ranges are derived 
     20 * and displayed. 
     21 *  
     22 * @author Aivar Grislis grislis at wisc dot edu 
    2423 */ 
    2524public class UIPanel extends JPanel { 
     25    private static final int DIGITS = 4; 
    2626    IUIPanelListener _listener; 
    27     JCheckBox m_autoCheckBox; 
    28     JTextField m_startTextField; 
    29     JTextField m_stopTextField; 
    30     boolean m_auto; 
    31     double m_start; 
    32     double m_stop; 
    33     double m_min; 
    34     double m_max; 
    35  
    36     /** 
    37      * Constructor.  Passed in an initial state and a state change //TODO this doc. et. al. outdated 
    38      * listener. 
    39      * 
    40      * @param auto 
    41      * @param start 
    42      * @param stop 
    43      */ 
    44     UIPanel() { 
     27    JCheckBox _autoRangeCheckBox; 
     28    JCheckBox _combineChannelsCheckBox; 
     29    JCheckBox _displayChannelsCheckBox; 
     30    JTextField _minTextField; 
     31    JTextField _maxTextField; 
     32    boolean _autoRange; 
     33    boolean _combineChannels; 
     34    boolean _displayChannels; 
     35    double _minLUT; 
     36    double _maxLUT; 
     37 
     38    /** 
     39     * Constructor. 
     40     *  
     41     * @param hasChannels 
     42     */ 
     43    public UIPanel(boolean hasChannels) { 
    4544        super(); 
    46         //m_listener = listener; 
    47  
    48         m_auto = true; 
    49         m_start = m_stop = m_min = m_max = 0.0; //TODO gotta be a better way 
     45 
     46        // initial state 
     47        _autoRange = true; 
     48        _minLUT = _maxLUT = 0.0; 
    5049 
    5150        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS)); 
    5251 
     52        // make a panel for the min/max readouts 
    5353        JPanel readOutPanel = new JPanel(); 
    5454        readOutPanel.setLayout(new BoxLayout(readOutPanel, BoxLayout.X_AXIS)); 
    5555 
    56         m_startTextField = new JTextField(); 
    57         m_startTextField.setText("" + m_start); 
    58         m_startTextField.addActionListener( 
     56        _minTextField = new JTextField(); 
     57        _minTextField.addActionListener( 
    5958            new ActionListener() { 
    60                 public void actionPerformed(ActionEvent e) { 
    61                     m_start = Double.parseDouble(m_startTextField.getText()); 
    62                 //    m_listener.setRange(m_auto, m_start, m_stop, m_min, m_max); 
     59                public void actionPerformed(ActionEvent event) { 
     60                    try { 
     61                        _minLUT = Double.parseDouble(_minTextField.getText()); 
     62                        if (null != _listener) { 
     63                            _listener.setMinMaxLUT(_minLUT, _maxLUT); 
     64                        } 
     65                    } 
     66                    catch (NumberFormatException exception) { 
     67                        _minTextField.setText("" + _minLUT); 
     68                    } 
    6369                } 
    6470            } 
    6571        ); 
    66         readOutPanel.add(m_startTextField); 
    67  
    68         m_stopTextField = new JTextField(); 
    69         m_startTextField.setText("" + m_stop); 
    70         m_stopTextField.addActionListener( 
     72        readOutPanel.add(_minTextField); 
     73 
     74        _maxTextField = new JTextField(); 
     75        _maxTextField.addActionListener( 
    7176            new ActionListener() { 
    72                 public void actionPerformed(ActionEvent e) { 
    73                     m_stop = Double.parseDouble(m_stopTextField.getText()); 
    74                  //   m_listener.setRange(m_auto, m_start, m_stop, m_min, m_max); 
     77                public void actionPerformed(ActionEvent event) { 
     78                    try { 
     79                        _maxLUT = Double.parseDouble(_maxTextField.getText()); 
     80                        if (null != _listener) { 
     81                            _listener.setMinMaxLUT(_minLUT, _maxLUT); 
     82                        } 
     83                    } 
     84                    catch (NumberFormatException exception) { 
     85                        _maxTextField.setText("" + _maxLUT); 
     86                    } 
    7587                } 
    7688            } 
    7789        ); 
    78         readOutPanel.add(m_stopTextField); 
     90        readOutPanel.add(_maxTextField); 
    7991        add(readOutPanel); 
    8092  
    81         m_autoCheckBox = new JCheckBox("Auto", m_auto); 
    82         m_autoCheckBox.addItemListener( 
     93        _autoRangeCheckBox = new JCheckBox("Automatic Ranging", _autoRange); 
     94        _autoRangeCheckBox.addItemListener( 
    8395            new ItemListener() { 
    8496                public void itemStateChanged(ItemEvent e) { 
    85                     m_auto = m_autoCheckBox.isSelected(); 
    86                     if (m_auto) { 
    87                         m_start = m_min; 
    88                         m_startTextField.setText("" + m_start); 
    89  
    90                         m_stop = m_max; 
    91                         m_stopTextField.setText("" + m_stop); 
    92                     } 
    93                     enableAppropriately(); 
    94                  //   m_listener.setRange(m_auto, m_start, m_stop, m_min, m_max); 
     97                    _autoRange = _autoRangeCheckBox.isSelected(); 
     98                    enableTextFields(_autoRange); 
     99                    if (null != _listener) { 
     100                        _listener.setAutoRange(_autoRange); 
     101                    } 
    95102                } 
    96103            } 
    97104        ); 
    98         add(m_autoCheckBox); 
    99  
    100  
    101         enableAppropriately(); 
    102     } 
    103  
     105        add(_autoRangeCheckBox); 
     106         
     107        if (hasChannels) { 
     108            _combineChannelsCheckBox = 
     109                    new JCheckBox("Combine Channels", _combineChannels); 
     110            _combineChannelsCheckBox.addItemListener( 
     111                new ItemListener() { 
     112                    public void itemStateChanged(ItemEvent e) { 
     113                        _combineChannels = _combineChannelsCheckBox.isSelected(); 
     114                        if (null != _listener) { 
     115                            _listener.setCombineChannels(_combineChannels); 
     116                        } 
     117                    } 
     118                } 
     119            ); 
     120            add(_combineChannelsCheckBox); 
     121 
     122            _displayChannelsCheckBox = 
     123                    new JCheckBox("Display Channels", _displayChannels); 
     124            _displayChannelsCheckBox.addItemListener( 
     125                new ItemListener() { 
     126                    public void itemStateChanged(ItemEvent e) { 
     127                        _displayChannels = _displayChannelsCheckBox.isSelected(); 
     128                        if (null != _listener) { 
     129                            _listener.setDisplayChannels(_displayChannels); 
     130                        } 
     131                    } 
     132                } 
     133            ); 
     134            add(_displayChannelsCheckBox); 
     135        } 
     136 
     137        enableTextFields(_autoRange); 
     138    } 
     139 
     140    /** 
     141     * Sets a listener for this UI panel.  Listener is unique. 
     142     *  
     143     * @param listener  
     144     */ 
    104145    public void setListener(IUIPanelListener listener) { 
    105146        _listener = listener; 
    106147    } 
    107148 
    108     public void setAuto(boolean auto) { 
    109  
    110     } 
    111  
     149    public void setAutoRange(boolean autoRange) { 
     150        _autoRange = autoRange; 
     151        _autoRangeCheckBox.setSelected(autoRange); 
     152        enableTextFields(autoRange); 
     153    } 
     154     
     155    public void setCombineChannels(boolean combineChannels) { 
     156        _combineChannels = combineChannels; 
     157        _combineChannelsCheckBox.setSelected(combineChannels); 
     158    } 
     159     
     160    public void setDisplayChannels(boolean displayChannels) { 
     161        _displayChannels = displayChannels; 
     162        _displayChannelsCheckBox.setSelected(displayChannels); 
     163    } 
     164 
     165    /** 
     166     * Called when the user is dragging the cursors on the histogram panel. 
     167     *  
     168     * @param min 
     169     * @param max  
     170     */ 
     171    public void dragMinMaxLUT(double min, double max) { 
     172        System.out.println("UIPanel.dragMinMaxLUT"); 
     173        showMinMaxLUT(min, max); 
     174    } 
     175 
     176    /** 
     177     * Called when the user sets new cursors on the histogram panel. 
     178     *  
     179     * @param min 
     180     * @param max  
     181     */ 
    112182    public void setMinMaxLUT(double min, double max) { 
    113         System.out.println("SetMinMaxLUT " + min + " " + max); 
    114         m_startTextField.setText("" + min); 
    115         m_stopTextField.setText("" + max); 
    116     } 
    117  
    118     // not 
    119     /** 
    120      * IColorizeRangeListener method.  Gets external changes to settings. 
    121      * 
    122      * @param auto 
    123      * @param start 
    124      * @param stop 
    125      * @param min 
    126      * @param max 
    127      */ 
    128     public void setRange(boolean auto, double start, double stop, double min, double max) { 
    129         if (auto != m_auto) { 
    130             m_auto = auto; 
    131             m_autoCheckBox.setSelected(auto); 
    132             enableAppropriately(); 
    133         } 
    134  
    135         if (start != m_start) { 
    136             m_start = start; 
    137             m_startTextField.setText("" + start); 
    138         } 
    139  
    140         if (stop != m_stop) { 
    141             m_stop = stop; 
    142             m_stopTextField.setText("" + stop); 
    143         } 
    144         m_min = min; 
    145         m_max = max; 
    146     } 
    147  
    148     /** 
    149      * Enable/disable start/stop text fields. 
    150      */ 
    151     private void enableAppropriately() { 
    152         m_startTextField.setEnabled(!m_auto); 
    153         m_stopTextField.setEnabled(!m_auto); 
    154     } 
     183        System.out.println("UIPanel.setMinMaxLUT"); 
     184        showMinMaxLUT(min, max); 
     185        //TODO anything else?  if not combine these two methods 
     186    } 
     187 
     188    /** 
     189     * Enable/disable min/max text fields as appropriate. 
     190     */ 
     191    private void enableTextFields(boolean auto) { 
     192        _minTextField.setEnabled(!auto); 
     193        _maxTextField.setEnabled(!auto); 
     194    } 
     195 
     196    /* 
     197     * Shows the minimum and maximum LUT readouts.  Limits number of digits 
     198     * shown. 
     199     */ 
     200    private void showMinMaxLUT(double min, double max) { 
     201        DoubleFormatter minFormatter = new DoubleFormatter(true, DIGITS, min); 
     202        _minTextField.setText(minFormatter.getText()); 
     203        _minLUT = Double.parseDouble(_minTextField.getText()); 
     204        DoubleFormatter maxFormatter = new DoubleFormatter(false, DIGITS, max); 
     205        _maxTextField.setText(maxFormatter.getText()); 
     206        _maxLUT = Double.parseDouble(_maxTextField.getText()); 
     207    }     
    155208} 
Note: See TracChangeset for help on using the changeset viewer.