Changeset 7930


Ignore:
Timestamp:
03/23/12 16:55:29 (7 years ago)
Author:
aivar
Message:

SLIM Plugin: Transient cursors not applied properly. Part of Ticket #678. Fixed chart problems #679 and flakey cursors #680.

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

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7922 r7930  
    399399                        double dataStart      = results[CursorEstimator.DATA_START]; 
    400400                        double transientStop  = results[CursorEstimator.TRANSIENT_STOP]; 
    401                         _fittingCursor.suspendNotifications(true); 
     401                        _fittingCursor.suspendNotifications(); 
     402                        _fittingCursor.setHasPrompt(true); 
    402403                        _fittingCursor.setPromptBaselineValue(promptBaseline); 
    403404                        _fittingCursor.setPromptStartValue   (promptStart); 
     
    405406                        _fittingCursor.setTransientStartValue(transientStart); 
    406407                        _fittingCursor.setDataStartValue     (dataStart); 
    407                         _fittingCursor.suspendNotifications(false); 
    408408                        _fittingCursor.setTransientStopValue (transientStop); 
     409                        _fittingCursor.sendNotifications(); 
    409410                    } 
    410411                    else { 
     
    525526 
    526527        // want to batch all of the fitting cursor notifications to listeners 
    527         _fittingCursor.suspendNotifications(true); 
     528        _fittingCursor.suspendNotifications(); 
    528529        _fittingCursor.setTransientStartBin(transientStart); 
    529530        _fittingCursor.setDataStartBin(dataStart); 
    530         _fittingCursor.suspendNotifications(false); 
    531531        _fittingCursor.setTransientStopBin(transientStop); 
     532        _fittingCursor.sendNotifications(); 
    532533    } 
    533534 
     
    556557    private boolean updateExcitation(IUserInterfacePanel uiPanel, Excitation excitation) { 
    557558        boolean success = false; 
     559        System.out.println("###update excitation " + excitation); 
    558560        if (null != excitation) { 
    559561            if (null != m_excitationPanel) { 
     
    576578             
    577579            // want all the fitting cursor listeners to get everything at once 
    578             _fittingCursor.suspendNotifications(true); 
     580            _fittingCursor.suspendNotifications(); 
     581            _fittingCursor.setHasPrompt(true); 
    579582            _fittingCursor.setPromptStartBin   ((int) results[CursorEstimator.PROMPT_START]); 
    580583            _fittingCursor.setPromptStopBin    ((int) results[CursorEstimator.PROMPT_STOP]); 
     
    582585            _fittingCursor.setTransientStartBin((int) results[CursorEstimator.TRANSIENT_START]); 
    583586            _fittingCursor.setDataStartBin     ((int) results[CursorEstimator.DATA_START]); 
    584             _fittingCursor.suspendNotifications(false); 
    585587            _fittingCursor.setTransientStopBin ((int) results[CursorEstimator.TRANSIENT_STOP]); 
     588            _fittingCursor.sendNotifications(); 
    586589 
    587590            m_excitationPanel = new ExcitationPanel(excitation, _fittingCursor); //TODO ARG excitation cursor change refit problem here; get new values before excitation ready for refit 
     
    10761079            curveFitData.setYCount(yCount); 
    10771080            curveFitData.setTransStartIndex(0); 
    1078             curveFitData.setTransFitStartIndex(m_startBin); 
     1081            curveFitData.setDataStartIndex(m_startBin); 
    10791082            curveFitData.setTransEndIndex(m_stopBin); 
    10801083            yFitted = new double[m_bins]; 
     
    11591162                curveFitData.setYCount(yCount); 
    11601163                curveFitData.setTransStartIndex(0); 
    1161                 curveFitData.setTransFitStartIndex(m_startBin); 
     1164                curveFitData.setDataStartIndex(m_startBin); 
    11621165                curveFitData.setTransEndIndex(m_stopBin); 
    11631166                if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     
    13051308            curveFitData.setYCount(yCount); 
    13061309            curveFitData.setTransStartIndex(transStartIndex); //TODO ARG 0); 
    1307             curveFitData.setTransFitStartIndex(dataStartIndex); //TODO ARG m_startBin); 
     1310            curveFitData.setDataStartIndex(dataStartIndex); //TODO ARG m_startBin); 
    13081311            curveFitData.setTransEndIndex(transStopIndex); //TODO ARG m_stopBin); 
    13091312            System.out.println("uiPanel.getFunction is " + uiPanel.getAlgorithm() + " SLIMCURVE_RLD_LMA is " + FitAlgorithm.SLIMCURVE_RLD_LMA); 
     
    17421745        decayGraph.setTitle(title); 
    17431746        decayGraph.setFittingCursor(fittingCursor); 
    1744         int transientStart = fittingCursor.getTransientStartBin(); 
    1745         int dataStart      = fittingCursor.getDataStartBin(); 
    1746         int transientStop  = fittingCursor.getTransientStopBin(); 
    1747         decayGraph.setStartStop(transientStart, dataStart, transientStop); 
     1747        double transStart = fittingCursor.getTransientStartValue(); 
     1748        double dataStart  = fittingCursor.getDataStartValue(); 
     1749        double transStop  = fittingCursor.getTransientStopValue(); 
     1750        decayGraph.setStartStop(transStart, dataStart, transStop); 
    17481751        decayGraph.setData(data); 
    17491752    } 
     
    17621765         
    17631766        public void cursorChanged(FittingCursor cursor) { 
    1764             boolean refit = false; 
    1765              
    17661767            // get current cursor values 
    1767             int transStart  = cursor.getTransientStartBin(); 
    1768             int dataStart   = cursor.getDataStartBin(); 
    1769             int transStop   = cursor.getTransientStopBin(); 
    1770             int promptStart = cursor.getPromptStartBin(); 
    1771             int promptStop  = cursor.getPromptStopBin(); 
     1768            int transStart        = cursor.getTransientStartBin(); 
     1769            int dataStart         = cursor.getDataStartBin(); 
     1770            int transStop         = cursor.getTransientStopBin(); 
     1771            int promptStart       = cursor.getPromptStartBin(); 
     1772            int promptStop        = cursor.getPromptStopBin(); 
    17721773            double promptBaseline = cursor.getPromptBaselineValue(); 
    17731774             
    1774             // look for changes vs. saved cursor values 
    1775             if (null != _transStart && transStart != _transStart) { 
     1775            // look for changes, current vs. saved cursor values 
     1776            boolean refit = false; 
     1777            if (null == _transStart 
     1778                    || null == _dataStart 
     1779                    || null == _transStop 
     1780                    || null == _promptStart 
     1781                    || null == _promptStop 
     1782                    || null == _promptBaseline 
     1783                    || transStart     != _transStart 
     1784                    || dataStart      != _dataStart 
     1785                    || transStop      != _transStop 
     1786                    || promptStart    != _promptStart 
     1787                    || promptStop     != _promptStop 
     1788                    || promptBaseline != _promptBaseline) { 
    17761789                refit = true; 
    17771790            } 
    1778             if (null != _dataStart && dataStart != _dataStart) { 
    1779                 refit = true; 
    1780             } 
    1781             if (null != _transStop && transStop != _transStop) { 
    1782                 refit = true; 
    1783             } 
    1784             if (null != _promptStart && promptStart != _promptStart) { 
    1785                 refit = true; 
    1786             } 
    1787             if (null != _promptStop && promptStop != _promptStop) { 
    1788                 refit = true; 
    1789             } 
    1790             if (null != _promptBaseline && promptBaseline != _promptBaseline) { 
    1791                 refit = true; 
    1792             } 
    1793              
    1794             // update saved cursor values 
    1795             _transStart = transStart; 
    1796             _dataStart = dataStart; 
    1797             _transStop = transStop; 
    1798             _promptStart = promptStart; 
    1799             _promptStop = promptStop; 
    1800             _promptBaseline = promptBaseline; 
    18011791             
    18021792            // trigger refit 
    1803             if (refit) { 
    1804                 System.out.println("REFIT"); 
     1793            if (refit) {    
     1794                // update saved cursor values for next time 
     1795                _transStart     = transStart; 
     1796                _dataStart      = dataStart; 
     1797                _transStop      = transStop; 
     1798                _promptStart    = promptStart; 
     1799                _promptStop     = promptStop; 
     1800                _promptBaseline = promptBaseline; 
     1801 
    18051802                fitPixel(m_uiPanel, _fittingCursor); 
    18061803            } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/callable/FittingEngineCallable.java

    r7922 r7930  
    8080        curveFitData.setYCount(_localParams.getY()); 
    8181        curveFitData.setTransStartIndex(0); 
    82         curveFitData.setTransFitStartIndex(_localParams.getFitStart()); 
     82        curveFitData.setDataStartIndex(_localParams.getFitStart()); 
    8383        curveFitData.setTransEndIndex(_localParams.getFitStop());         
    8484        curveFitData.setSig(_localParams.getSig()); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursor.java

    r7915 r7930  
    3636 
    3737import java.util.Collections; 
     38import java.util.ConcurrentModificationException; 
    3839import java.util.HashSet; 
    3940import java.util.Set; 
     
    7172        _inc = inc; 
    7273        _bins = bins; 
    73         _listeners = Collections.synchronizedSet(new HashSet<IFittingCursorListener>()); 
     74        _listeners = new HashSet<IFittingCursorListener>(); 
    7475        _showBins = false; 
    7576        _suspend = false; 
     
    8283     * @param listener  
    8384     */ 
    84     public void addListener(IFittingCursorListener listener) {  
    85         _listeners.add(listener); 
     85    public void addListener(IFittingCursorListener listener) { 
     86        System.out.println("add listener " + listener); 
     87        synchronized (_listeners) { 
     88            if (!_listeners.contains(listener)) { 
     89                _listeners.add(listener); 
     90            } 
     91        } 
    8692    } 
    8793 
     
    9298     */ 
    9399    public void removeListener(IFittingCursorListener listener) { 
    94         _listeners.remove(listener); 
     100        System.out.println("remove listener " + listener); 
     101        synchronized (_listeners) { 
     102            _listeners.remove(listener); 
     103        } 
    95104    } 
    96105 
     
    114123 
    115124    /** 
    116      * Used to turn on/off listener notifications.  Mainly if several cursor 
    117      * settings need to be changed in one batch, turn off listener notifications, 
    118      * make all but one cursor settings change, then turn on listener  
    119      * notifications and make the last cursor settings change. 
    120      *  
    121      * @param suspend  
    122      */ 
    123     public void suspendNotifications(boolean suspend) { 
    124         _suspend = suspend; 
     125     * Temporarily suspends listener notifications.  Used when several cursors 
     126     * change at the same time.  Call suspendNotifications followed by cursor 
     127     * changes followed by sendNotifications. 
     128     */ 
     129    public void suspendNotifications() { 
     130        _suspend = true; 
     131    } 
     132 
     133    /** 
     134     * Used to send listener notifications after a batched change. 
     135     */ 
     136    public void sendNotifications() { 
     137        _suspend = false; 
     138        notifyListeners(); 
    125139    } 
    126140 
     
    668682     */ 
    669683    private void notifyListeners() { 
     684        boolean success = false; 
    670685        if (!_suspend) { 
    671             for (IFittingCursorListener listener : _listeners) { 
    672                 listener.cursorChanged(this); 
    673             } 
    674         } 
    675     } 
    676      
    677   
    678     //TODO ARG 
    679     // These two methods support round-tripping from int -> double ->int and 
    680     // double -> int -> double. 
    681     // 
    682     private static int doubleToInt(boolean low, double inc, double value) { 
    683         int returnValue = 0; 
    684         if (low) { 
    685             returnValue = (int) Math.floor(value / inc); 
    686         } 
    687         else { 
    688             returnValue = (int) Math.ceil(value / inc) + 1; 
    689         } 
    690         return returnValue; 
    691     } 
    692      
    693     private static double intToDouble(boolean low, double inc, int value) { 
    694         double returnValue = 0.0; 
    695         if (low) { 
    696             returnValue = inc * value + inc / 8192; 
    697         } 
    698         else { 
    699             returnValue = inc * (value - 1) - inc / 8192; 
    700         } 
    701         return returnValue; 
    702     } 
    703      
    704     private static double randomDouble(java.util.Random random, int range) { 
    705         return random.nextDouble() * range; 
    706     } 
    707      
    708     public static void main(String [] args) 
    709     { 
    710         int lowProbs = 0, highProbs = 0; 
    711         java.util.Random random = new java.util.Random(); 
    712         for (int i = 0; i < 300000; ++i) { 
    713             double d = randomDouble(random, 10); // random 0.0...10.0 
    714             int fred = doubleToInt(true, 0.01, d); 
    715             double wilma = intToDouble(true, 0.01, fred); 
    716             int barney = doubleToInt(true, 0.01, wilma); 
    717             if (fred != barney) { 
    718                 System.out.println("random is " + d + " to int low is " + fred + " back to double " + wilma + " to int " + barney); 
    719                 ++lowProbs; 
    720             } 
    721             if (d / wilma > 1.05 || d / wilma < 0.95) { 
    722                 System.out.println("d is " + d + " and wilma " + wilma); 
    723                 ++lowProbs; 
    724             } 
    725             fred = doubleToInt(false, 0.01, d); 
    726             wilma = intToDouble(false, 0.01, fred); 
    727             barney = doubleToInt(false, 0.01, wilma); 
    728             if (fred != barney) { 
    729                 System.out.println("random is " + d + " to int high is " + fred + " back to double " + wilma + " to int " + barney); 
    730                 ++highProbs; 
    731             } 
    732             if (d / wilma > 1.05 || d / wilma < 0.95) { 
    733                 System.out.println("d is " + d + " and wilma is " + wilma); 
    734                 ++highProbs; 
    735             } 
    736            // System.out.println("random " + d + " to int high " + fred + " back to double " + wilma + " to int low " + barney); 
    737         } 
    738         System.out.println(" " + lowProbs + " low, " + highProbs + " high oout of 30000"); 
    739         System.exit(0); 
    740     } 
    741      
     686            while (!success) { 
     687                try { 
     688                    synchronized (_listeners) { 
     689                        for (IFittingCursorListener listener : _listeners) { 
     690                            listener.cursorChanged(this); 
     691                        } 
     692                    } 
     693                    success = true; 
     694                } 
     695                catch (ConcurrentModificationException e) { 
     696                    // avoid timing issues 
     697                } 
     698            } 
     699        } 
     700    } 
    742701} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursorHelper.java

    r7915 r7930  
    3737            _fittingCursorListener = new FittingCursorListener(); 
    3838        } 
    39         else { 
     39        else if (_fittingCursor != fittingCursor) { 
    4040            _fittingCursor.removeListener(_fittingCursorListener); 
    4141        } 
     
    186186    private void showFittingCursor() { 
    187187        if (null != _fittingCursorUI) { 
     188            System.out.println("In FittingCursorHelper.showFittingCursor"); 
    188189            _fittingCursorUI.setTransientStart(_fittingCursor.getTransientStart()); 
    189190            _fittingCursorUI.setDataStart(_fittingCursor.getDataStart()); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/heuristics/CursorEstimator.java

    r7922 r7930  
    174174    public static double[] estimateCursors(double xInc, double[] prompt, 
    175175            double[] decay, double chiSqTarget) { 
     176        System.out.println("xInc " + xInc + " prompt " + prompt + " decay " + decay + " chiSqTarget " + chiSqTarget); 
    176177        double[] returnValue = new double[6]; 
    177178        double baseline; 
     
    311312            curveFitData.setYCount(adjustedDecay); 
    312313            curveFitData.setTransStartIndex(0); 
    313             curveFitData.setTransFitStartIndex(fitStart); 
     314            curveFitData.setDataStartIndex(fitStart); 
    314315            curveFitData.setTransEstimateStartIndex(fitStart); //TODO ARG this shit has to go; was an early way to handle TRI2 quirkiness; w/b better to call quirky estimator routines from SLIMCurveFitter rather than having these oddball variables to kludge in quirkiness 
    315316            curveFitData.setTransEndIndex(fitStop);             
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/DecayGraph.java

    r7915 r7930  
    7979    static final int DECAY_WEIGHT = 4; 
    8080    static final int RESIDUAL_WEIGHT = 1; 
    81     static final int HORZ_TWEAK = 4; 
     81    static final int HORZ_TWEAK = 1; 
    8282    static final Color DECAY_COLOR = Color.GRAY.darker(); 
    8383    static final Color FITTED_COLOR = Color.RED; 
     
    9797    private double _timeInc; 
    9898    private int _bins; 
    99     private Integer _transStart; 
    100     private Integer _dataStart; 
    101     private Integer _transStop; 
     99    private double _maxValue; 
     100    private Double _transStart; 
     101    private Double _dataStart; 
     102    private Double _transStop; 
    102103    private boolean _logarithmic = true; 
    103104 
     
    145146            _bins = bins; 
    146147            _timeInc = timeInc; 
     148            _maxValue = timeInc * bins; 
    147149             
    148150            if (null != _frame) { 
     
    165167            _startStopDraggingUI = 
    166168                    new StartStopDraggingUI<JComponent> 
    167                             (panel, _decaySubPlot, this); 
     169                            (panel, _decaySubPlot, this, _maxValue); 
    168170            layer.setUI(_startStopDraggingUI); 
    169171 
     
    189191            _fittingCursorListener = new FittingCursorListener(); 
    190192        } 
    191         else { 
     193        else if (_fittingCursor != fittingCursor) { 
    192194            _fittingCursor.removeListener(_fittingCursorListener); 
    193195        } 
     
    212214     */ 
    213215    public void setData(ICurveFitData data) { 
    214         createDatasets(10, 200, _bins, _timeInc, data); 
    215  
    216     } 
    217  
    218     /** 
    219      * Changes (or initializes) the start and stop vertical bars. 
     216        createDatasets(_bins, _timeInc, data); 
     217 
     218    } 
     219 
     220    /** 
     221     * Changes or initializes the start and stop vertical bars. 
    220222     * 
    221223     * @param transStart 
     
    223225     * @param transStop 
    224226     */ 
    225     public void setStartStop(int transStart, int dataStart, int transStop) { 
    226         if (null == _dataStart) { 
    227             // initialize the vertical bars 
    228             double transStartValue = transStart * _timeInc; 
    229             double dataStartValue  = dataStart  * _timeInc; 
    230             double transStopValue  = transStop  * _timeInc; 
    231             double maxValue        = _bins      * _timeInc; 
    232             _startStopDraggingUI.setStartStopValues 
    233                     (transStartValue, dataStartValue, transStopValue, maxValue); 
    234         } 
    235  
    236         _transStart = transStart; 
    237         _dataStart  = dataStart; 
    238         _transStop  = transStop; 
    239  
     227    public void setStartStop(double transStart, double dataStart, double transStop) { 
     228        _startStopDraggingUI.setStartStopValues(transStart, dataStart, transStop); 
    240229    } 
    241230 
     
    255244    { 
    256245        // calculate new start and stop 
    257         int transStart = (int) (transStartProportion * _bins + 0.5); 
    258         int dataStart  = (int) (dataStartProportion  * _bins + 0.5); 
    259         int transStop  = (int) (transStopProportion  * _bins + 0.5); 
     246        double transStart = transStartProportion * _maxValue; 
     247        double dataStart  = dataStartProportion  * _maxValue; 
     248        double transStop  = transStopProportion  * _maxValue; 
    260249 
    261250        // if changed, notify cursor listeners 
    262         if (transStart != _transStart || dataStart != _dataStart || 
    263                 transStop != _transStop) 
     251        if (null == _transStart || transStart != _transStart 
     252                || null == _dataStart || dataStart != _dataStart 
     253                || null == _transStop || transStop != _transStop) 
    264254        { 
     255            _transStart = transStart; 
     256            _dataStart  = dataStart; 
     257            _transStop  = transStop; 
     258             
    265259            if (null != _fittingCursor) { 
    266                 _fittingCursor.setTransientStartBin(transStart); 
    267                 _fittingCursor.setDataStartBin(dataStart); 
    268                 _fittingCursor.setTransientStopBin(transStop); 
     260                _fittingCursor.setTransientStartValue(transStart); 
     261                _fittingCursor.setDataStartValue(dataStart); 
     262                _fittingCursor.setTransientStopValue(transStop); 
    269263            } 
    270264        } 
     
    344338     * Creates the data sets for the chart 
    345339     * 
    346      * @param start time bin 
    347      * @param stop time bin 
    348340     * @param bins number of time bins 
    349341     * @param timeInc time increment per time bin 
    350342     * @param data from the fit 
    351343     */ 
    352     private void createDatasets(int start, int stop, int bins, double timeInc, 
    353             ICurveFitData data) 
    354     { 
     344    private void createDatasets(int bins, double timeInc, ICurveFitData data) 
     345    {        
    355346        XYSeries series2 = new XYSeries("Fitted"); 
    356347        XYSeries series3 = new XYSeries("Data"); 
    357348        XYSeries series4 = new XYSeries("Residuals"); 
    358349 
    359         double yData, yFitted; 
    360         double xCurrent = 0; 
     350        // show transient data; find the maximum transient data in this pass 
     351        double yDataMax = Double.MIN_VALUE; 
     352        double xCurrent = 0.0; 
    361353        for (int i = 0; i < bins; ++i) { 
    362             yData = data.getYCount()[i]; 
     354            // show transient data 
     355            double yData = data.getYCount()[i]; 
     356             
     357            // keep track of maximum 
     358            if (yData > yDataMax) { 
     359                yDataMax = yData; 
     360            } 
     361             
    363362            // logarithmic plots can't handle <= 0.0 
    364363            series3.add(xCurrent, (yData > 0.0 ? yData : null)); 
    365             // are we in fitted region? 
    366             if (_dataStart <= i && i <= _transStop) { 
    367                 // yes, show fitted curve and residuals 
    368                 yFitted = data.getYFitted()[i]; 
    369                 // logarithmic plots can't handle <= 0 
    370                 if (yFitted > 0.0) { 
     364             
     365            xCurrent += timeInc; 
     366        } 
     367         
     368        int transStart = data.getTransStartIndex(); 
     369        int dataStart  = data.getDataStartIndex(); 
     370        int transEnd   = data.getTransEndIndex(); 
     371 
     372        // show fitted & residuals 
     373        xCurrent = 0.0; 
     374        for (int i = 0; i < bins; ++i) { 
     375            // only within cursors 
     376            if (transStart <= i && i <= transEnd) { 
     377                // from transStart..transEnd show fitted 
     378                double yFitted = data.getYFitted()[i - transStart]; 
     379  
     380                // don't allow fitted to grow the chart downward or upward 
     381                if (1.0 <= yFitted && yFitted <= yDataMax) { 
    371382                    series2.add(xCurrent, yFitted); 
     383                } 
     384                else { 
     385                    series2.add(xCurrent, null); 
     386                } 
     387                 
     388                // from dataStart..transEnd show residuals 
     389                if (dataStart <= i && 0.0 < yFitted) { 
     390                    double yData = data.getYCount()[i]; 
    372391                    series4.add(xCurrent, yData - yFitted); 
    373392                } 
    374393                else { 
    375                     series2.add(xCurrent, null); 
    376394                    series4.add(xCurrent, null); 
    377395                } 
     
    381399                series4.add(xCurrent, null); 
    382400            } 
     401             
    383402            xCurrent += timeInc; 
    384403        } 
     
    405424        private XYPlot _plot; 
    406425        private IStartStopProportionListener _listener; 
    407         boolean _dragTransStartMarker = false; 
    408         boolean _dragDataStartMarker  = false; 
    409         boolean _dragTransStopMarker  = false; 
     426        private double _maxValue; 
     427        private boolean _dragTransStartMarker = false; 
     428        private boolean _dragDataStartMarker  = false; 
     429        private boolean _dragTransStopMarker  = false; 
    410430        private volatile Double _transStartMarkerProportion; 
    411431        private volatile Double _dataStartMarkerProportion; 
     
    423443         * @param plot within the chart 
    424444         * @param listener to be notified when user drags start/stop vertical bars 
     445         * @param maxValue used to scale cursors 
    425446         */ 
    426447        StartStopDraggingUI(ChartPanel panel, XYPlot plot, 
    427                 IStartStopProportionListener listener) 
     448                IStartStopProportionListener listener, double maxValue) 
    428449        { 
    429450            _panel    = panel; 
    430451            _plot     = plot; 
    431452            _listener = listener; 
    432             _transStartMarkerProportion = null; 
    433             _dataStartMarkerProportion  = null; 
    434             _transStopMarkerProportion  = null; 
     453            _maxValue = maxValue; 
    435454        } 
    436455 
    437456        void setStartStopValues 
    438457                (double transStartValue, double dataStartValue, 
    439                 double transStopValue, double maxValue) 
     458                double transStopValue) 
    440459        { 
    441             Rectangle2D area = getDataArea(); 
    442             double x = area.getX(); 
    443             double width = area.getWidth(); 
    444             if (0.1 > width) { 
    445                 _transStartMarkerProportion = transStartValue / maxValue; 
    446                 _dataStartMarkerProportion  = dataStartValue  / maxValue; 
    447                 _transStopMarkerProportion  = transStopValue  / maxValue; 
    448             } 
    449             else { 
    450                 double minRepresentedValue = screenToValue((int) x); 
    451                 double maxRepresentedValue = screenToValue((int) (x + width)); 
    452                 _transStartMarkerProportion = 
    453                         (float) (transStartValue - minRepresentedValue) / 
    454                             (maxRepresentedValue - minRepresentedValue); 
    455                 _dataStartMarkerProportion = 
    456                         (float) (dataStartValue - minRepresentedValue) / 
    457                             (maxRepresentedValue - minRepresentedValue); 
    458                 _transStopMarkerProportion = 
    459                         (float) (transStopValue - minRepresentedValue) / 
    460                             (maxRepresentedValue - minRepresentedValue); 
    461             } 
    462         } 
     460            _transStartMarkerProportion = transStartValue / _maxValue; 
     461            _dataStartMarkerProportion  = dataStartValue  / _maxValue; 
     462            _transStopMarkerProportion  = transStopValue  / _maxValue; 
     463        } 
     464 
    463465 
    464466        /** 
     
    477479            if (null != _transStartMarkerProportion && 
    478480                    null != _dataStartMarkerProportion && 
    479                     null != _transStopMarkerProportion) { 
     481                    null != _transStopMarkerProportion) 
     482            { 
    480483                // adjust to current size 
    481484                Rectangle2D area = getDataArea(); 
     
    691694    private class FittingCursorListener implements IFittingCursorListener { 
    692695        public void cursorChanged(FittingCursor cursor) { 
    693             int transientStart = cursor.getTransientStartBin(); 
    694             int dataStart      = cursor.getDataStartBin(); 
    695             int transientStop  = cursor.getTransientStopBin(); 
    696             setStartStop(transientStart, dataStart, transientStop); 
     696            double transStart = cursor.getTransientStartValue(); 
     697            double dataStart  = cursor.getDataStartValue(); 
     698            double transStop  = cursor.getTransientStopValue(); 
     699            setStartStop(transStart, dataStart, transStop); 
    697700            _frame.repaint(); 
    698             System.out.println("CHANGED " + transientStart + " " + dataStart + " " + transientStop); 
    699701        } 
    700702    }     
     
    707709 */ 
    708710interface IStartStopProportionListener { 
    709     public void setStartStopProportion 
    710             (double transStartProportion, double dataStartProportion, double transStopProportion); 
     711    public void setStartStopProportion( 
     712            double transStartProportion, 
     713            double dataStartProportion, 
     714            double transStopProportion); 
    711715} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationGraph.java

    r7910 r7930  
    3737import java.awt.BasicStroke; 
    3838import java.awt.Color; 
     39import java.awt.Dimension; 
    3940import java.awt.Graphics2D; 
    4041import java.awt.event.MouseEvent; 
     
    7475 */ 
    7576public class ExcitationGraph implements IStartStopBaseProportionListener { 
    76     static final int HORZ_TWEAK = 0; //TODO this was necessary for the fitted decay graph: 4; 
     77    static final Dimension SIZE = new java.awt.Dimension(500, 270); 
     78    static final String PHOTON_AXIS_LABEL = "Photons"; 
     79    static final String TIME_AXIS_LABEL = "Time"; 
     80    static final String UNITS_LABEL = "nanoseconds"; 
     81    static final int HORZ_TWEAK = 1; 
     82    static final int VERT_TWEAK = 1; 
    7783    static final Color EXCITATION_COLOR = Color.GRAY; 
    7884    static final Color BACK_COLOR = Color.WHITE; 
     
    8086    static final Color STOP_COLOR = Color.RED.darker(); 
    8187    static final Color BASE_COLOR = Color.GREEN.darker(); 
    82     JFrame _frame; 
     88    Double _start; 
     89    Double _stop; 
     90    Double _base; 
     91    int _bins; 
     92    double _maxHorzValue; 
     93    double _maxVertValue; 
    8394    FittingCursor _fittingCursor; 
    8495    IFittingCursorListener _fittingCursorListener; 
    85     int _start; 
    86     int _stop; 
    87     double _base; 
    88     int _bins; 
    89     double _count; 
    9096    StartStopBaseDraggingUI<JComponent> _startStopBaseDraggingUI; 
    9197    boolean _headless = false; 
     
    94100    XYSeriesCollection _excitationDataset; 
    95101    XYSeriesCollection _residualDataset; 
     102    JFrame _frame; 
    96103    static ChartPanel _panel; 
    97104    JXLayer<JComponent> _layer; 
    98  
    99     JFreeChart _decayChart; 
    100     JFreeChart _residualsChart; 
    101105 
    102106    /** 
     
    104108     * decay curve. 
    105109     * 
    106      * @param start time bin 
    107      * @param stop time bin 
    108      * @param base count 
     110     * @param start time value 
     111     * @param stop time value 
     112     * @param base value 
    109113     * @param bins number of bins 
    110114     * @param timeInc time increment per bin 
    111115     * @param values 
    112116     */ 
    113     ExcitationGraph(final int start, final int stop, final double base, 
     117    ExcitationGraph(final double start, final double stop, final double base, 
    114118            final int bins, double[] values, final double timeInc) { 
    115119        _start = start; 
     
    117121        _base = base; 
    118122        _bins = bins; 
    119         _count = 0.0f; 
    120         // find maximum count 
     123 
     124        // compute maximum values for width and height 
     125        _maxHorzValue = timeInc * bins; 
     126        _maxVertValue = 0.0f; 
    121127        for (double value : values) { 
    122             if (value > _count) { 
    123                 _count = value; 
     128            if (value > _maxVertValue) { 
     129                _maxVertValue = value; 
    124130            } 
    125131        } 
     
    127133        // create the chart 
    128134        JFreeChart chart = createChart(bins, timeInc, values); 
    129         ChartPanel chartPanel = new ChartPanel(chart, true, true, true, false, true); 
     135        ChartPanel chartPanel = new ChartPanel 
     136                (chart, true, true, true, false, true); 
    130137        chartPanel.setDomainZoomable(false); 
    131138        chartPanel.setRangeZoomable(false); 
    132         chartPanel.setPreferredSize(new java.awt.Dimension(500, 270)); 
     139        chartPanel.setPreferredSize(SIZE); 
    133140 
    134141        // Add JXLayer to draw/drag start/stop bars 
    135142        _layer = new JXLayer<JComponent>(chartPanel); 
    136         _startStopBaseDraggingUI = new StartStopBaseDraggingUI<JComponent>(chartPanel, _excitationPlot, this); 
     143        _startStopBaseDraggingUI = new StartStopBaseDraggingUI<JComponent> 
     144                (chartPanel, _excitationPlot, this, _maxHorzValue, _maxVertValue); 
    137145        _layer.setUI(_startStopBaseDraggingUI); 
    138146 
     
    140148        // initialize the vertical bars that show start and stop time bins and 
    141149        // the horizontal bar with the base count. 
    142         _startStopBaseDraggingUI.setStartStopBaseValues( 
    143                 timeInc * start, timeInc * stop, timeInc * bins, 
    144                 base, _count); 
     150        _startStopBaseDraggingUI.setStartStopBaseValues(_start, _stop, _base); 
    145151    } 
    146152 
     
    158164            _fittingCursorListener = new FittingCursorListener(); 
    159165        } 
    160         else { 
     166        else if (_fittingCursor != fittingCursor) { 
    161167            _fittingCursor.removeListener(_fittingCursorListener); 
    162168        } 
     
    174180     */ 
    175181    public void setStartStopBaseProportion( 
    176             double startProportion, double stopProportion, double baseProportion) { 
    177         int start = (int) (startProportion * _bins + 0.5); 
    178         int stop = (int) (stopProportion * _bins + 0.5); 
    179         int base = (int) (baseProportion * _count + 0.5); 
    180         //System.out.println("start " + start + " stop " + stop); 
     182            double startProportion, 
     183            double stopProportion, 
     184            double baseProportion) 
     185    { 
     186        // calculate new start, stop and base 
     187        double start = startProportion * _maxHorzValue; 
     188        double stop  = stopProportion  * _maxHorzValue; 
     189        double base  = baseProportion  * _maxVertValue; 
     190         
    181191        if (start != _start || stop != _stop || base != _base) { 
    182             _fittingCursor.setPromptStartBin(start); 
    183             _fittingCursor.setPromptStopBin(stop); 
    184             _fittingCursor.setPromptBaselineValue(base); 
     192            _start = start; 
     193            _stop  = stop; 
     194            _base  = base; 
     195             
     196            if (null != _fittingCursor) { 
     197                _fittingCursor.setPromptStartValue(start); 
     198                _fittingCursor.setPromptStopValue(stop); 
     199                _fittingCursor.setPromptBaselineValue(base); 
     200            } 
    185201        } 
    186202    } 
     
    200216 
    201217        // make a horizontal axis 
    202         NumberAxis timeAxis = new NumberAxis("Time"); 
    203         timeAxis.setLabel("nanoseconds"); 
     218        NumberAxis timeAxis = new NumberAxis(TIME_AXIS_LABEL); 
     219        timeAxis.setLabel(UNITS_LABEL); 
    204220        timeAxis.setRange(0.0, (bins - 1) * timeInc); 
    205221 
     
    207223        NumberAxis photonAxis; 
    208224        if (_logarithmic) { 
    209             photonAxis = new LogarithmicAxis("Photons"); 
     225            photonAxis = new LogarithmicAxis(PHOTON_AXIS_LABEL); 
    210226        } 
    211227        else { 
    212             photonAxis = new NumberAxis("Photons"); 
     228            photonAxis = new NumberAxis(PHOTON_AXIS_LABEL); 
    213229        } 
    214230 
     
    261277     * @param <V> component 
    262278     */ 
    263     static class StartStopBaseDraggingUI<V extends JComponent> extends AbstractLayerUI<V> { 
     279    static class StartStopBaseDraggingUI<V extends JComponent> 
     280            extends AbstractLayerUI<V> 
     281    { 
    264282        private static final int CLOSE_ENOUGH = 4; // pizels 
    265283        private ChartPanel _panel; 
    266284        private XYPlot _plot; 
     285        private double _maxHorzValue; 
     286        private double _maxVertValue; 
    267287        private IStartStopBaseProportionListener _listener; 
    268288        boolean _draggingStartMarker = false; 
    269289        boolean _draggingStopMarker = false; 
    270290        boolean _draggingBaseMarker = false; 
    271         private double _startMarkerProportion = 0.25; 
    272         private double _stopMarkerProportion = 0.75; 
    273         private double _baseMarkerProportion = 0.25; 
     291        private volatile Double _startMarkerProportion; 
     292        private volatile Double _stopMarkerProportion; 
     293        private volatile Double _baseMarkerProportion; 
    274294        private int _x0; 
    275295        private int _y0; 
     
    287307         * @param listener to be notified when user drags start/stop/base bars 
    288308         */ 
    289         StartStopBaseDraggingUI(ChartPanel panel, XYPlot plot, IStartStopBaseProportionListener listener) { 
    290             _panel    = panel; 
    291             _plot     = plot; 
    292             _listener = listener; 
    293         } 
    294  
    295         void setStartStopBaseValues(double startValue, double stopValue, double maxHorzValue, double baseValue, double maxVertValue) { 
    296             Rectangle2D area = getDataArea(); 
    297             double x = area.getX(); 
    298             double y = area.getY(); 
    299             double width = area.getWidth(); 
    300             double height = area.getHeight(); 
    301  
    302             if (0.1 > width) { 
    303                 _startMarkerProportion = startValue / maxHorzValue; 
    304                 _stopMarkerProportion = stopValue / maxHorzValue; 
    305             } 
    306             else { 
    307                 double minRepresentedValue = horzScreenToValue((int) x); 
    308                 double maxRepresentedValue = horzScreenToValue((int) (x + width)); 
    309                 _startMarkerProportion = (startValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    310                 _stopMarkerProportion = (stopValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    311             } 
    312  
    313             if (0.1 > height) { 
    314                 _baseMarkerProportion = baseValue / maxVertValue; 
    315             } 
    316             else { 
    317                 double minRepresentedValue = vertScreenToValue((int) y); 
    318                 double maxRepresentedValue = vertScreenToValue((int) (y + height)); 
    319                 _baseMarkerProportion = (baseValue - minRepresentedValue) / (maxRepresentedValue - minRepresentedValue); 
    320             } 
     309        StartStopBaseDraggingUI(ChartPanel panel, XYPlot plot, 
     310                IStartStopBaseProportionListener listener, 
     311                double maxHorzValue, double maxVertValue) 
     312        { 
     313            _panel        = panel; 
     314            _plot         = plot; 
     315            _listener     = listener; 
     316            _maxHorzValue = maxHorzValue; 
     317            _maxVertValue = maxVertValue; 
     318        } 
     319 
     320        void setStartStopBaseValues 
     321                (double startValue, double stopValue, double baseValue) 
     322        { 
     323            _startMarkerProportion = startValue / _maxHorzValue; 
     324            _stopMarkerProportion  = stopValue  / _maxHorzValue; 
     325            _baseMarkerProportion  = baseValue  / _maxVertValue; 
    321326        } 
    322327 
     
    326331         * Overrides 'paintLayer()', not 'paint()'. 
    327332         * 
    328          * @param g2 
     333         * @param g2D 
    329334         * @param l 
    330335         */ 
    331336        @Override 
    332         protected void paintLayer(Graphics2D g2, JXLayer<? extends V> l) { 
     337        protected void paintLayer(Graphics2D g2D, JXLayer<? extends V> l) { 
    333338            // this paints layer as is 
    334             super.paintLayer(g2, l); 
    335  
    336             // adjust to current size 
    337             Rectangle2D area = getDataArea(); 
    338             double x = area.getX(); 
    339             double y = area.getY(); 
    340             _x0 = (int) area.getX(); 
    341             _y0 = (int) area.getY(); 
    342             _x1 = (int) (area.getX() + area.getWidth()); 
    343             _y1 = (int) (area.getY() + area.getHeight()); 
    344             double width = area.getWidth(); 
    345             double height = area.getHeight(); 
    346             _xStart = (int) Math.round(x + width * _startMarkerProportion) + HORZ_TWEAK; 
    347             _xStop = (int) Math.round(x + width * _stopMarkerProportion) + HORZ_TWEAK; 
    348             _yBase = (int) Math.round(y + height * (1 - _baseMarkerProportion)); 
    349  
    350             // custom painting is here 
    351             g2.setStroke(new BasicStroke(2f)); 
    352             g2.setXORMode(XORvalue(START_COLOR)); 
    353             g2.drawLine(_xStart, _y0, _xStart, _y1); 
    354             g2.setXORMode(XORvalue(STOP_COLOR)); 
    355             g2.drawLine(_xStop, _y0, _xStop, _y1); 
    356             g2.setXORMode(XORvalue(BASE_COLOR)); 
    357             g2.drawLine(_x0, _yBase, _x1, _yBase); 
     339            super.paintLayer(g2D, l); 
     340             
     341            if (null != _startMarkerProportion 
     342                    && null != _stopMarkerProportion 
     343                    && null != _baseMarkerProportion) 
     344            { 
     345                // adjust to current size 
     346                Rectangle2D area = getDataArea(); 
     347                double x = area.getX(); 
     348                double y = area.getY(); 
     349                _x0 = (int) area.getX(); 
     350                _y0 = (int) area.getY(); 
     351                _x1 = (int) (area.getX() + area.getWidth()); 
     352                _y1 = (int) (area.getY() + area.getHeight()); 
     353                double width = area.getWidth(); 
     354                double height = area.getHeight(); 
     355                _xStart = (int) Math.round(x + width * _startMarkerProportion) 
     356                        + HORZ_TWEAK; 
     357                _xStop  = (int) Math.round(x + width * _stopMarkerProportion) 
     358                        + HORZ_TWEAK; 
     359                _yBase  = (int) Math.round(y + height * (1.0 - _baseMarkerProportion)) 
     360                        + VERT_TWEAK; 
     361 
     362                // custom painting is here 
     363                g2D.setStroke(new BasicStroke(2f)); 
     364                g2D.setXORMode(XORvalue(START_COLOR)); 
     365                g2D.drawLine(_xStart, _y0, _xStart, _y1); 
     366                g2D.setXORMode(XORvalue(STOP_COLOR)); 
     367                g2D.drawLine(_xStop, _y0, _xStop, _y1); 
     368                g2D.setXORMode(XORvalue(BASE_COLOR)); 
     369                g2D.drawLine(_x0, _yBase, _x1, _yBase); 
     370            } 
     371 
    358372        } 
    359373 
     
    373387                            _startMarkerProportion = newProportion; 
    374388                        } 
     389                        else { 
     390                            _startMarkerProportion = _stopMarkerProportion; 
     391                        } 
    375392                    } 
    376393                    else { 
    377394                        if (newProportion >= _startMarkerProportion) { 
    378395                            _stopMarkerProportion = newProportion; 
     396                        } 
     397                        else { 
     398                            _stopMarkerProportion = _startMarkerProportion; 
    379399                        } 
    380400                    } 
     
    405425         */ 
    406426        private double getHorzDraggedProportion(MouseEvent e) { 
    407             Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     427            Rectangle2D dataArea = 
     428                    _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
    408429            Rectangle2D area = getDataArea(); 
    409             double proportion = ((double) e.getX() - area.getX()) / area.getWidth(); 
     430            double proportion = ((double) e.getX() - area.getX()) 
     431                    / area.getWidth(); 
    410432            if (proportion < 0.0) { 
    411433                proportion = 0.0; 
     
    425447         */ 
    426448        private double getVertDraggedProportion(MouseEvent e) { 
    427             Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     449            Rectangle2D dataArea = 
     450                    _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
    428451            Rectangle2D area = getDataArea(); 
    429452            //double proportion = ((double) e.getY() - area.getY()) / area.getHeight(); 
    430             double proportion = ((double) area.getY() + area.getHeight() - e.getY()) / area.getHeight(); 
     453            double proportion = 
     454                    ((double) area.getY() + area.getHeight() - e.getY()) 
     455                        / area.getHeight(); 
    431456            if (proportion < 0.0) { 
    432457                proportion = 0.0; 
     
    445470        protected void processMouseEvent(MouseEvent e, JXLayer<? extends V> l) { 
    446471            super.processMouseEvent(e, l); 
    447             if (e.getID() == MouseEvent.MOUSE_PRESSED) { 
    448                 int x = e.getX(); 
    449                 int y = e.getY(); 
    450                 if (y > _y0 - CLOSE_ENOUGH && y < _y1 + CLOSE_ENOUGH) { 
    451                     if (Math.abs(x - _xStart) < CLOSE_ENOUGH) { 
    452                         // start dragging start line 
    453                         _draggingStartMarker = true; 
    454  
    455                     } 
    456                     else if (Math.abs(x - _xStop) < CLOSE_ENOUGH) { 
    457                         // start dragging stop line 
    458                         _draggingStopMarker = true; 
    459                     } 
    460                     else if (Math.abs(y - _yBase) < CLOSE_ENOUGH) { 
    461                         // start dragging base line 
    462                         _draggingBaseMarker = true; 
     472            if (null != _startMarkerProportion && null != _stopMarkerProportion && null != _baseMarkerProportion) { 
     473                if (e.getID() == MouseEvent.MOUSE_PRESSED) { 
     474                    int x = e.getX(); 
     475                    int y = e.getY(); 
     476                    if (y > _y0 - CLOSE_ENOUGH && y < _y1 + CLOSE_ENOUGH) { 
     477                        if (Math.abs(x - _xStart) < CLOSE_ENOUGH) { 
     478                            // check for superimposition 
     479                            if (_xStart == _xStop) { 
     480                                // both superimposed 
     481                                if ( x < _xStart) { 
     482                                    // start dragging start line 
     483                                    _draggingStartMarker = true; 
     484                                } 
     485                                else { 
     486                                     // start dragging stop line 
     487                                    _draggingStopMarker = true; 
     488                                } 
     489                            } 
     490                            else { 
     491                                // no superimposition, start dragging start line 
     492                                _draggingStartMarker = true; 
     493                            } 
     494                        } 
     495                        else if (Math.abs(x - _xStop) < CLOSE_ENOUGH) { 
     496                            // start dragging stop line 
     497                            _draggingStopMarker = true; 
     498                        } 
     499                        else if (Math.abs(y - _yBase) < CLOSE_ENOUGH) { 
     500                            // start dragging base line 
     501                            _draggingBaseMarker = true; 
     502                        } 
    463503                    } 
    464504                } 
    465             } 
    466             if (e.getID() == MouseEvent.MOUSE_RELEASED) { 
    467                 _draggingStartMarker = _draggingStopMarker = _draggingBaseMarker = false; 
    468                 SwingUtilities.invokeLater( 
    469                         new Runnable() { 
    470                             public void run() { 
    471                                 _listener.setStartStopBaseProportion(_startMarkerProportion, _stopMarkerProportion, _baseMarkerProportion); 
    472                             } 
    473                 }); 
     505                if (e.getID() == MouseEvent.MOUSE_RELEASED) { 
     506                    _draggingStartMarker = _draggingStopMarker 
     507                            = _draggingBaseMarker = false; 
     508                    SwingUtilities.invokeLater( 
     509                            new Runnable() { 
     510                                public void run() { 
     511                                    _listener.setStartStopBaseProportion( 
     512                                            _startMarkerProportion, 
     513                                            _stopMarkerProportion, 
     514                                            _baseMarkerProportion); 
     515                                } 
     516                    }); 
     517                } 
    474518            } 
    475519        } 
     
    480524         * @return 2D rectangle area 
    481525         */ 
     526        @Deprecated 
    482527        private Rectangle2D getDataArea() { 
    483528            Rectangle2D dataArea = _panel.getChartRenderingInfo().getPlotInfo().getDataArea(); 
     
    491536         * @return chart value 
    492537         */ 
     538        @Deprecated 
    493539        private double horzScreenToValue(int x) { 
    494540            return _plot.getDomainAxis().java2DToValue((double) x, getDataArea(), RectangleEdge.TOP); 
     
    501547         * @return chart value 
    502548         */ 
     549        @Deprecated 
    503550        private double vertScreenToValue(int y) { 
    504551            return _plot.getRangeAxis().java2DToValue((double) y, getDataArea(), RectangleEdge.LEFT); 
     
    508555    private class FittingCursorListener implements IFittingCursorListener { 
    509556        public void cursorChanged(FittingCursor cursor) { 
    510             int promptStart       = cursor.getPromptStartBin(); 
    511             int promptStop        = cursor.getPromptStopBin(); 
     557            double promptStart    = cursor.getPromptStartValue(); 
     558            double promptStop     = cursor.getPromptStopValue(); 
    512559            double promptBaseline = cursor.getPromptBaselineValue(); 
    513560            if (null != _frame) { 
    514561                _frame.repaint(); 
    515562            } 
    516             System.out.println("PROMPT CHANGED " + promptStart + " " + promptStop + " " + promptBaseline); 
    517563        } 
    518564    }   
     
    526572 */ 
    527573interface IStartStopBaseProportionListener { 
    528     public void setStartStopBaseProportion(double startProportion, double stopProportion, double baseProportion); 
     574    public void setStartStopBaseProportion( 
     575            double startProportion, 
     576            double stopProportion,  
     577            double baseProportion); 
    529578} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationPanel.java

    r7915 r7930  
    8383        this.setTitle("Instrument Response Function"); 
    8484         
    85         int start = fittingCursor.getPromptStartBin(); 
    86         int stop  = fittingCursor.getPromptStopBin(); 
     85        double start = fittingCursor.getPromptStartValue(); 
     86        double stop  = fittingCursor.getPromptStopValue(); 
    8787        double base = fittingCursor.getPromptBaselineValue(); 
    8888 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IDecayGraph.java

    r7915 r7930  
    8181     * @param transientStop 
    8282     */ 
    83     public void setStartStop(int transientStart, int dataStart, int transientStop); 
     83    public void setStartStop(double transientStart, double dataStart, double transientStop); 
    8484} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7922 r7930  
    382382        enablePromptCursors(false); 
    383383 
    384         // show initial cursors 
     384        // set up and show initial cursors 
    385385        _fittingCursorHelper.setFittingCursorUI(this); 
    386386    } 
Note: See TracChangeset for help on using the changeset viewer.