Changeset 7903 for trunk/projects


Ignore:
Timestamp:
02/24/12 20:28:14 (8 years ago)
Author:
aivar
Message:

SLIM Plugin: Changing start/stop bin integers to time value doubles to agree with TRI2 UI.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
4 added
2 deleted
7 edited
2 copied
2 moved

Legend:

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

    r7892 r7903  
    6868import loci.slim.colorizer.DataColorizer; 
    6969import loci.slim.colorizer.DataColorizer2; 
     70import loci.slim.heuristics.CursorHelper; 
    7071import loci.slim.process.IProcessor; 
    7172import loci.slim.process.Threshold; 
     73import loci.slim.ui.DecayGraph; 
    7274import loci.slim.ui.ExcitationPanel; 
    73 import loci.slim.ui.IStartStopListener; 
    7475import loci.slim.ui.IUserInterfacePanel; 
    7576import loci.slim.ui.IUserInterfacePanelListener; 
     
    8889import loci.slim.fitting.IDecayImage; 
    8990import loci.slim.fitting.IFittedImage; 
     91import loci.slim.fitting.config.Configuration; 
     92import loci.slim.fitting.cursor.FittingCursor; 
     93import loci.slim.fitting.cursor.IFittingCursorListener; 
     94import loci.slim.fitting.engine.IFittingEngine; 
    9095import loci.slim.fitting.images.ColorizedImageParser; 
    9196import loci.slim.fitting.params.IGlobalFitParams; 
    9297import loci.slim.fitting.params.LocalFitParams; 
    9398import loci.slim.fitting.params.GlobalFitParams; 
    94 import loci.slim.fitting.engine.IFittingEngine; 
    9599import loci.slim.fitting.params.ILocalFitParams; 
    96100import loci.slim.fitting.params.IFitResults; 
    97 import loci.slim.fitting.config.Configuration; 
     101 
    98102import loci.slim.fitting.FitInfo; 
    99103import loci.slim.fitting.images.ColorizedImageFitter; 
     
    125129     
    126130    private IFittingEngine _fittingEngine; 
     131    private FittingCursor _fittingCursor; 
    127132     
    128133    private static final String X = "X"; 
     
    272277        IEstimator estimator = new Estimator(); 
    273278         
     279        // cursor support 
     280        _fittingCursor = new FittingCursor(m_timeRange); 
     281         
    274282        // show the UI; do fits 
    275283        final IUserInterfacePanel uiPanel = new UserInterfacePanel(USE_TAU, m_analysis.getChoices(), m_binning.getChoices()); 
     284        uiPanel.setFittingCursor(_fittingCursor); 
    276285        uiPanel.setX(0); 
    277286        uiPanel.setY(0); 
    278         uiPanel.setStart(estimator.getStart(m_bins), false); 
    279         uiPanel.setStop(estimator.getStop(m_bins), false); 
     287        //TODO ARG these estimates s/n/b necessary; use the EstimateCursors class 
     288        //uiPanel.setStart(estimator.getStart(m_bins)); 
     289        //uiPanel.setStop(estimator.getStop(m_bins)); 
    280290        uiPanel.setThreshold(estimator.getThreshold()); 
    281291        uiPanel.setChiSquareTarget(estimator.getChiSquareTarget()); 
     
    310320                    // ordinarily these fits take place in the thread at the end  
    311321                    // of this method. 
     322                    //TODO ARG 
    312323                    // this is a hack until I refactor out a FittingEngine. 
    313                     fitPixel(uiPanel); 
     324                    fitPixel(uiPanel, _fittingCursor); 
    314325                } 
    315326                 
     
    382393                            uiPanel.setX(x); 
    383394                            uiPanel.setY(y); 
    384                             getFitSettings(m_grayScaleImage, uiPanel); 
     395                            getFitSettings(m_grayScaleImage, uiPanel, _fittingCursor); 
    385396                            // fit on the pixel clicked 
    386                             fitPixel(uiPanel); 
     397                            fitPixel(uiPanel, _fittingCursor); 
    387398                        } 
    388399                    } 
     
    413424 
    414425            // get settings of requested fit 
    415             getFitSettings(m_grayScaleImage, uiPanel); 
     426            getFitSettings(m_grayScaleImage, uiPanel, _fittingCursor); 
    416427 
    417428            // do the fit 
     
    432443    } 
    433444 
     445    /** 
     446     * This method gives an initial estimate of the decay cursors (start and 
     447     * stop values). 
     448     *  
     449     * @param uiPanel  
     450     */ 
    434451    private void updateDecayCursors(IUserInterfacePanel uiPanel) { 
    435         // sum selected channel 
     452        //TODO ARG the way this is working now, each channel has it's own 
     453        // start/stop cursors. 
    436454        double[] decay = new double[m_bins]; 
    437455        for (int i = 0; i < decay.length; ++i) { 
     
    440458        for (int y = 0; y < m_height; ++y) { 
    441459            for (int x = 0; x < m_width; ++x) { 
    442                 for (int b = 0; b < m_bins; ++b) { 
    443                     decay[b] += getData(m_cursor, m_channel, x, y, b); 
     460                for (int c = 0; c < m_channels; ++c) { 
     461                    for (int b = 0; b < m_bins; ++b) { 
     462                        decay[b] += getData(m_cursor, c, x, y, b); 
     463                    } 
    444464                } 
    445465            } 
     
    447467 
    448468        int[] results = CursorHelper.estimateDecayCursors(m_timeRange, decay); 
    449         uiPanel.setStart(results[0], false); 
    450         uiPanel.setStop(results[1], false); 
     469        int start = results[CursorHelper.DECAY_START]; 
     470        int stop = results[CursorHelper.DECAY_STOP]; 
     471         
     472        System.out.println("updateDecayCursors gets start " + start + " stop " + stop); 
     473        _fittingCursor.setDataStartBin(start); 
     474        _fittingCursor.setTransientStopBin(stop); 
     475        //TODO ARGuiPanel.setStart(start); 
     476       // uiPanel.setStop(stop); 
     477//TODO ARG I bet not here:        DecayGraph.getInstance().setStartStop(start, stop); 
     478        // uiPanel and DecayGraph will get changes from the FittingCursor listener 
    451479    } 
    452480 
     
    476504 
    477505            double[] results = CursorHelper.estimateCursors(m_timeRange, excitation.getValues(), decay); 
    478             excitation.setStart((int) results[0]); 
    479             excitation.setStop((int) results[1]); 
    480             excitation.setBase(results[2]); 
    481  
    482             uiPanel.setStart((int) results[3], false); 
    483             uiPanel.setStop((int) results[4], false); 
     506            _fittingCursor.setPromptStartBin   ((int) results[CursorHelper.PROMPT_START]); 
     507            _fittingCursor.setPromptStopBin    ((int) results[CursorHelper.PROMPT_STOP]); 
     508            _fittingCursor.setPromptBaselineValue    (results[CursorHelper.PROMPT_BASELINE]); 
     509            _fittingCursor.setTransientStartBin((int) results[CursorHelper.TRANSIENT_STOP]); 
     510            _fittingCursor.setDataStartBin     ((int) results[CursorHelper.TRANSIENT_STOP]); 
     511            _fittingCursor.setTransientStopBin ((int) results[CursorHelper.TRANSIENT_STOP]); 
    484512 
    485513            m_excitationPanel = new ExcitationPanel(excitation); 
     
    490518    } 
    491519 
    492     private void getFitSettings(IGrayScaleImage grayScalePanel, IUserInterfacePanel uiPanel) { 
     520    private void getFitSettings(IGrayScaleImage grayScalePanel, IUserInterfacePanel uiPanel, FittingCursor cursor) { 
    493521        m_channel        = grayScalePanel.getChannel(); 
    494522 
     
    500528        m_x              = uiPanel.getX(); 
    501529        m_y              = uiPanel.getY(); 
    502         m_startBin       = uiPanel.getStart(); 
    503         m_stopBin        = uiPanel.getStop(); 
    504530        m_threshold      = uiPanel.getThreshold(); 
    505531 
    506532        m_param          = uiPanel.getParameters(); 
    507533        m_free           = uiPanel.getFree(); 
     534         
     535        m_startBin       = cursor.getTransientStartBin(); 
     536        m_stopBin        = cursor.getTransientStopBin(); 
    508537    } 
    509538 
     
    695724    } 
    696725     
    697     private FitInfo getFitInfo(IGrayScaleImage grayScalePanel, IUserInterfacePanel uiPanel) { 
     726    private FitInfo getFitInfo( 
     727            IGrayScaleImage grayScalePanel, 
     728            IUserInterfacePanel uiPanel, 
     729            FittingCursor fittingCursor) { 
    698730        FitInfo fitInfo = new FitInfo(); 
    699731        fitInfo.setChannel(grayScalePanel.getChannel()); 
     
    705737        fitInfo.setAnalysisList(uiPanel.getAnalysisList()); 
    706738        fitInfo.setFitAllChannels(uiPanel.getFitAllChannels()); 
    707         fitInfo.setStartDecay(uiPanel.getStart()); 
    708         fitInfo.setStopDecay(uiPanel.getStop()); 
     739        fitInfo.setStartDecay(fittingCursor.getDataStartBin()); 
     740        fitInfo.setStopDecay(fittingCursor.getTransientStopBin()); 
    709741        fitInfo.setThreshold(uiPanel.getThreshold()); 
    710742        fitInfo.setChiSquareTarget(uiPanel.getChiSquareTarget()); 
     
    728760    private Image<DoubleType> fitImage(IUserInterfacePanel uiPanel) { 
    729761        // get fit settings from the UI panel 
    730         FitInfo fitInfo = getFitInfo(m_grayScaleImage, uiPanel); 
     762        FitInfo fitInfo = getFitInfo(m_grayScaleImage, uiPanel, _fittingCursor); 
    731763        fitInfo.setXInc(m_timeRange); 
    732764        if (null != m_excitationPanel) { 
     
    10361068            title += " Channel " + (m_channel + 1); 
    10371069        } 
    1038         showDecayGraph(title, uiPanel, irf, dataArray[visibleChannel]); 
     1070        showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[visibleChannel]); 
    10391071        uiPanel.setParameters(dataArray[visibleChannel].getParams()); 
    10401072 
     
    11331165                title += " Channel " + (m_channel + 1); 
    11341166            } 
    1135             showDecayGraph(title, uiPanel, irf, dataArray[dataIndex]); 
     1167            showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[dataIndex]); 
    11361168            double lifetime = dataArray[dataIndex].getParams()[3]; 
    11371169            if (lifetime < min) { 
     
    11791211    } 
    11801212 
    1181     // added kludge to make moving cursors in DecayGraph do a refit. 
    1182     private Image<DoubleType> fitPixel(IUserInterfacePanel uiPanel) { 
     1213    // added kludge to make moving cursors in DecayGraph do a refit. //TODO this has to change FittingCursor will know whenever cursors change. 
     1214    private Image<DoubleType> fitPixel( 
     1215            IUserInterfacePanel uiPanel, 
     1216            FittingCursor fittingCursor) { 
    11831217        int x = uiPanel.getX(); 
    11841218        int y = uiPanel.getY(); 
    1185         m_startBin = uiPanel.getStart(); 
    1186         m_stopBin = uiPanel.getStop(); 
     1219        m_startBin = fittingCursor.getDataStartBin(); 
     1220        m_stopBin = fittingCursor.getTransientStopBin(); 
     1221        System.out.println("m_startBin is " + m_startBin + " m_stopBin " + m_stopBin); 
     1222        System.out.println("_fittingCursor " + _fittingCursor.getTransientStartValue() + " " + _fittingCursor.getTransientStartBin() + " " + _fittingCursor.getTransientStopValue()); 
    11871223        return fitPixel(uiPanel, x, y); 
    11881224    } 
     
    12001236        ArrayList<ICurveFitData> curveFitDataList = new ArrayList<ICurveFitData>(); 
    12011237        double params[] = uiPanel.getParameters(); //TODO wrong; params should possibly come from already fitted data 
     1238        double chiSquareTarget = uiPanel.getChiSquareTarget(); 
    12021239        ICurveFitData curveFitData; 
    12031240        double yCount[]; 
     
    12211258            curveFitData.setTransFitStartIndex(m_startBin); 
    12221259            curveFitData.setTransEndIndex(m_stopBin); 
    1223             if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     1260            System.out.println("uiPanel.getFunction is " + uiPanel.getAlgorithm() + " SLIMCURVE_RLD_LMA is " + FitAlgorithm.SLIMCURVE_RLD_LMA); 
     1261            if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getAlgorithm())) { 
    12241262                // these lines give TRI2 compatible fit results 
    12251263                int estimateStartIndex = 
    12261264                        CursorHelper.getEstimateStartIndex 
    12271265                            (yCount, m_startBin, m_stopBin); 
     1266                System.out.append("m_startBin was " + m_startBin + " now estimageStartIndex is " + estimateStartIndex); 
    12281267                curveFitData.setTransEstimateStartIndex(estimateStartIndex); 
    12291268                curveFitData.setIgnorePromptForIntegralEstimate(true); 
     
    12321271            yFitted = new double[m_bins]; 
    12331272            curveFitData.setYFitted(yFitted); 
     1273            curveFitData.setChiSquareTarget(chiSquareTarget); 
    12341274 
    12351275            // use zero for current channel if it's the only one 
     
    12601300            visibleChannel = m_channel; 
    12611301        } 
    1262         showDecayGraph(title, uiPanel, irf, dataArray[visibleChannel]); 
     1302        showDecayGraph(title, uiPanel, _fittingCursor, irf, dataArray[visibleChannel]); 
    12631303 
    12641304        // update UI parameters 
     
    17851825     * @param data fitted data 
    17861826     */ 
    1787     private void showDecayGraph(final String title, final IUserInterfacePanel uiPanel, final double irf[], final ICurveFitData data) { 
    1788         loci.slim.refactor.ui.charts.IDecayGraph decayGraph = loci.slim.refactor.ui.charts.DecayGraph.getInstance(); 
     1827    private void showDecayGraph(final String title, 
     1828            final IUserInterfacePanel uiPanel, 
     1829            final FittingCursor fittingCursor, 
     1830            final double irf[], 
     1831            final ICurveFitData data) 
     1832    { 
     1833        loci.slim.ui.IDecayGraph decayGraph = loci.slim.ui.DecayGraph.getInstance(); 
    17891834        JFrame frame = decayGraph.init(uiPanel.getFrame(), m_bins, m_timeRange); 
    17901835        decayGraph.setTitle(title); 
    1791         int start = uiPanel.getStart(); 
    1792         int stop = uiPanel.getStop(); 
    1793         decayGraph.setStartStop(start, stop); 
     1836        decayGraph.setFittingCursor(fittingCursor); 
     1837        int transientStart = fittingCursor.getTransientStartBin(); 
     1838        int dataStart      = fittingCursor.getDataStartBin(); 
     1839        int transientStop  = fittingCursor.getTransientStopBin(); 
     1840        decayGraph.setStartStop(transientStart, dataStart, transientStop); 
    17941841        decayGraph.setData(irf, data); 
    1795         decayGraph.setStartStopListener( 
    1796             new IStartStopListener() { 
    1797                 public void setStartStop(int start, int stop) { 
    1798                     uiPanel.setStart(start, false); 
    1799                     uiPanel.setStop(stop, true); // do a refit 
    1800                 } 
    1801             } 
    1802         ); 
    18031842    } 
    18041843} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/FittingCursor.java

    r7889 r7903  
    3535package loci.slim.fitting.cursor; 
    3636 
     37import java.util.Collections; 
     38import java.util.HashSet; 
     39import java.util.Set; 
     40 
    3741/** 
    38  * Container for cursor information. 
     42 * Keeps cursor information.  Note that the actual fit process only deals with 
     43 * bin number indices, but we need to keep the time value to be compatible 
     44 * with TRI2. 
    3945 *  
    4046 * @author Aivar Grislis 
    4147 */ 
    42 public class Cursor implements ICursor { 
    43     private int _promptStart; 
    44     private int _promptStop; 
    45     private int _decayStart; 
    46     private int _decayStop; 
    47  
    48     @Override 
    49     public void setPromptStart(int bin) { 
    50         _promptStart = bin; 
    51     } 
    52  
    53     @Override 
    54     public int getPromptStart() { 
    55         return _promptStart; 
    56     } 
    57      
    58     @Override 
    59     public void setPromptStop(int bin) { 
    60         _promptStop = bin; 
    61     } 
    62  
    63     @Override 
    64     public int getPromptStop() { 
    65         return _promptStop; 
    66     } 
    67  
    68     @Override 
    69     public void setDecayStart(int bin) { 
    70         _decayStart = bin; 
    71     } 
    72  
    73     @Override 
    74     public int getDecayStart() { 
    75         return _decayStart; 
    76     } 
    77  
    78     @Override 
    79     public void setDecayStop(int bin) { 
    80         _decayStop = bin; 
    81     } 
    82  
    83     @Override 
    84     public int getDecayStop() { 
    85         return _decayStop; 
    86     }    
     48public class FittingCursor { 
     49    private double _inc; 
     50    private Set<IFittingCursorListener> _listeners; 
     51    private boolean _showBins; 
     52    private double _promptStartValue; 
     53    private double _promptStopValue; 
     54    private double _promptBaselineValue; 
     55    private double _transientStartValue; 
     56    private double _dataStartValue; 
     57    private double _transientStopValue; 
     58     
     59    public FittingCursor(double inc) { 
     60        _inc = inc; 
     61        _listeners = Collections.synchronizedSet(new HashSet<IFittingCursorListener>()); 
     62        _showBins = false; 
     63    } 
     64     
     65    public void addListener(IFittingCursorListener listener) {  
     66        _listeners.add(listener); 
     67    } 
     68     
     69    public void removeListener(IFittingCursorListener listener) { 
     70        _listeners.remove(listener); 
     71    } 
     72     
     73    public void setShowBins(boolean showBins) { 
     74        _showBins = showBins; 
     75    } 
     76     
     77    public boolean getShowBins() { 
     78        return _showBins; 
     79    } 
     80     
     81    public void setPromptStart(String promptStart) { 
     82         
     83    } 
     84     
     85    public String getPromptStart() { 
     86        StringBuffer returnValue = new StringBuffer(); 
     87        if (_showBins) { 
     88            returnValue.append(getPromptStartBin()); 
     89        } 
     90        else { 
     91            returnValue.append(getPromptStartValue()); 
     92        } 
     93        return returnValue.toString(); 
     94    } 
     95 
     96    public void setPromptStartBin(int bin) { 
     97        _promptStartValue = _inc * bin; 
     98        notifyListeners(); 
     99    } 
     100 
     101    public int getPromptStartBin() { 
     102        return (int) Math.floor(_promptStartValue / _inc); 
     103    } 
     104     
     105    public void setPromptStartValue(double value) { 
     106        _promptStartValue = value; 
     107        notifyListeners(); 
     108    } 
     109     
     110    public double getPromptStartValue() { 
     111        int bin = getPromptStartBin(); 
     112        return bin * _inc; 
     113    } 
     114     
     115    public void setPromptStop(String promptStop) { 
     116         
     117    } 
     118     
     119    public String getPromptStop() { 
     120        StringBuffer returnValue = new StringBuffer(); 
     121        if (_showBins) { 
     122            returnValue.append(getPromptStopBin()); 
     123        } 
     124        else { 
     125            returnValue.append(getPromptStopValue()); 
     126        } 
     127        return returnValue.toString(); 
     128    } 
     129 
     130    public void setPromptStopBin(int bin) { 
     131        _promptStopValue = _inc * bin; 
     132        notifyListeners(); 
     133    } 
     134 
     135    public int getPromptStopBin() { 
     136        return (int) Math.ceil(_promptStopValue / _inc); 
     137    } 
     138     
     139    public void setPromptStopValue(double value) { 
     140        _promptStopValue = value; 
     141        notifyListeners(); 
     142    } 
     143     
     144    public double getPromptStopValue() { 
     145        return _promptStopValue; 
     146    } 
     147     
     148    public void setPromptBaseline(String promptBaseline) { 
     149         
     150    } 
     151     
     152    public String getPromptBaseline() { 
     153        StringBuffer returnValue = new StringBuffer(); 
     154        if (_showBins) { 
     155            returnValue.append(getPromptBaselineBin()); 
     156        } 
     157        else { 
     158            returnValue.append(getPromptBaselineValue()); 
     159        } 
     160        return returnValue.toString(); 
     161    } 
     162 
     163    public void setPromptBaselineBin(int bin) { 
     164        _promptBaselineValue = _inc * bin; 
     165        notifyListeners(); 
     166    } 
     167     
     168    public int getPromptBaselineBin() { 
     169        return (int) Math.floor(_promptBaselineValue / _inc); 
     170    } 
     171     
     172    public void setPromptBaselineValue(double value) { 
     173        _promptBaselineValue = value; 
     174        notifyListeners(); 
     175    } 
     176     
     177    public double getPromptBaselineValue() { 
     178        return _promptBaselineValue; 
     179    } 
     180     
     181    public void setTransientStart(String transientStart) { 
     182         
     183    } 
     184     
     185    public String getTransientStart() { 
     186        StringBuffer returnValue = new StringBuffer(); 
     187        if (_showBins) { 
     188            returnValue.append(getTransientStartBin()); 
     189        } 
     190        else { 
     191            returnValue.append(getTransientStartValue()); 
     192        } 
     193        return returnValue.toString(); 
     194    } 
     195     
     196    public void setTransientStartBin(int bin) { 
     197        _transientStartValue = _inc * bin; 
     198        notifyListeners(); 
     199    } 
     200     
     201    public int getTransientStartBin() { 
     202        return (int) Math.floor(_transientStartValue / _inc); 
     203    } 
     204     
     205    public void setTransientStartValue(double value) { 
     206        _transientStartValue = value; 
     207        notifyListeners(); 
     208    } 
     209     
     210    public double getTransientStartValue() { 
     211        return _transientStartValue; 
     212    } 
     213     
     214    public void setDataStart(String dataStart) { 
     215         
     216    } 
     217     
     218    public String getDataStart() { 
     219        StringBuffer returnValue = new StringBuffer(); 
     220        if (_showBins) { 
     221            returnValue.append(getDataStartBin()); 
     222        } 
     223        else { 
     224            returnValue.append(getDataStartValue()); 
     225        } 
     226        return returnValue.toString(); 
     227    } 
     228     
     229    public void setDataStartBin(int bin) { 
     230        _dataStartValue = _inc * bin; 
     231        notifyListeners(); 
     232    } 
     233     
     234    public int getDataStartBin() { 
     235        return (int) Math.floor(_dataStartValue / _inc); 
     236    } 
     237     
     238    public void setDataStartValue(double value) { 
     239        _dataStartValue = value; 
     240        notifyListeners(); 
     241    } 
     242     
     243    public double getDataStartValue() { 
     244        return _dataStartValue; 
     245    } 
     246     
     247     
     248    public void setTransientStop(String transientStop) { 
     249         
     250    } 
     251     
     252    public String getTransientStop() { 
     253        StringBuffer returnValue = new StringBuffer(); 
     254        if (_showBins) { 
     255            returnValue.append(getTransientStopBin()); 
     256        } 
     257        else { 
     258            returnValue.append(getTransientStopValue()); 
     259        } 
     260        return returnValue.toString(); 
     261    } 
     262     
     263    public void setTransientStopBin(int bin) { 
     264        _transientStopValue = _inc * bin; 
     265        notifyListeners(); 
     266    } 
     267     
     268    public int getTransientStopBin() { 
     269        return (int) Math.ceil(_transientStopValue / _inc); 
     270    } 
     271     
     272    public void setTransientStopValue(double value) { 
     273        _transientStopValue = value; 
     274        notifyListeners(); 
     275    } 
     276     
     277    public double getTransientStopValue() { 
     278        return _transientStopValue; 
     279    } 
     280     
     281    public double binToValue(int bin, boolean isStart) { 
     282        return isStart ? 0.0 : 1.0; 
     283    } 
     284     
     285    public int valueToBin(double value) { 
     286        return 1; 
     287    } 
     288     
     289    private void notifyListeners() { 
     290        System.out.println("notify " + _listeners.size() + " listeners"); 
     291        for (IFittingCursorListener listener : _listeners) { 
     292            listener.cursorChanged(this); 
     293        } 
     294    } 
    87295} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/ICursorEstimator.java

    r7889 r7903  
    4141public interface ICursorEstimator { 
    4242     
    43     public ICursor globalCursor(double[] prompt, double[] decay); 
     43    public IFittingCursorListener globalCursor(double[] prompt, double[] decay); 
    4444     
    45     public ICursor localCursor(ICursor global, double[] prompt, double[] decay); 
     45    public IFittingCursorListener localCursor(FittingCursor global, double[] prompt, double[] decay); 
    4646     
    4747} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/IFittingCursorListener.java

    r7889 r7903  
    3939 * @author Aivar Grislis 
    4040 */ 
    41 public interface ICursor { 
     41public interface IFittingCursorListener { 
    4242     
    43     public void setPromptStart(int bin); 
    44      
    45     public int getPromptStart(); 
    46      
    47     public void setPromptStop(int bin); 
    48      
    49     public int getPromptStop(); 
    50      
    51     public void setDecayStart(int bin); 
    52      
    53     public int getDecayStart(); 
    54      
    55     public void setDecayStop(int bin); 
    56      
    57     public int getDecayStop(); 
     43    public void cursorChanged(FittingCursor cursor); 
    5844} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/cursor/LameCursorEstimator.java

    r7889 r7903  
    4545 
    4646    @Override 
    47     public ICursor globalCursor(double[] prompt, double[] decay) { 
    48         ICursor cursor = new Cursor(); 
    49         cursor.setPromptStart(getMostSteep(prompt)); 
    50         cursor.setPromptStop(getLeastSteep(prompt)); 
    51         cursor.setDecayStart(getMostSteep(decay)); 
    52         cursor.setDecayStop(7 * decay.length / 8); 
     47    public IFittingCursorListener globalCursor(double[] prompt, double[] decay) { 
     48        FittingCursor cursor = new FittingCursor(0.01); 
     49        cursor.setPromptStartBin(getMostSteep(prompt)); 
     50        cursor.setPromptStopBin(getLeastSteep(prompt)); 
     51        cursor.setTransientStartBin(getMostSteep(decay)); 
     52        cursor.setTransientStopBin(7 * decay.length / 8); 
    5353        return null; 
    5454    } 
    5555 
    5656    @Override 
    57     public ICursor localCursor(ICursor global, double[] prompt, double[] decay) { 
    58         ICursor cursor = new Cursor(); 
    59         cursor.setPromptStart(global.getPromptStart()); 
    60         cursor.setPromptStop(global.getPromptStop()); 
    61         cursor.setDecayStart(global.getDecayStart()); 
    62         cursor.setDecayStop(global.getDecayStop()); 
     57    public IFittingCursorListener localCursor(FittingCursor global, double[] prompt, double[] decay) { 
     58        FittingCursor cursor = new FittingCursor(0.01); 
     59        cursor.setPromptStartBin(global.getPromptStartBin()); 
     60        cursor.setPromptStopBin(global.getPromptStopBin()); 
     61        cursor.setTransientStartBin(global.getTransientStartBin()); 
     62        cursor.setTransientStopBin(global.getTransientStopBin()); 
    6363        return null; 
    6464    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/heuristics/CursorHelper.java

    r7892 r7903  
    5252 */ 
    5353public class CursorHelper { 
     54    public static final int PROMPT_START        = 0; 
     55    public static final int PROMPT_STOP         = 1; 
     56    public static final int PROMPT_BASELINE     = 2; 
     57    public static final int TRANSIENT_START     = 3; 
     58    public static final int TRANSIENT_FIT_START = 4; 
     59    public static final int TRANSIENT_STOP      = 5; 
     60    public static final int DECAY_START = 0; // use for 'estimateDecayCursors' results 
     61    public static final int DECAY_STOP  = 1; 
    5462    private static final int ATTEMPTS = 10; 
    5563 
     
    119127 
    120128        double[] returnValue = new double[3]; 
    121         returnValue[0] = startp; 
    122         returnValue[1] = endp; 
    123         returnValue[2] = baseline; 
     129        returnValue[PROMPT_START]    = startp; 
     130        returnValue[PROMPT_STOP]    = endp; 
     131        returnValue[PROMPT_BASELINE] = baseline; 
    124132        return returnValue; 
    125133    } 
     
    149157 
    150158    public static double[] estimateCursors(double xInc, double[] prompt, double[] decay) { 
    151         double[] returnValue = new double[5]; 
     159        double[] returnValue = new double[6]; 
    152160        double baseline; 
    153161        double maxval; // TRCursors.c has "unsigned short maxsval, maxval; double maxfval, *diffed;" 
     
    255263        transEndIndex = 9 * decay.length / 10; // "90% of transient" 
    256264        if (transEndIndex <= transStartIndex + 2 * ATTEMPTS) { // "oops" 
    257             returnValue[0] = startp; 
    258             returnValue[1] = endp; 
    259             returnValue[2] = baseline; 
    260             returnValue[3] = startt; 
    261             returnValue[4] = transEndIndex; 
     265            returnValue[PROMPT_START]        = startp; 
     266            returnValue[PROMPT_STOP]         = endp; 
     267            returnValue[PROMPT_BASELINE]     = baseline; 
     268            returnValue[TRANSIENT_START]     = transStartIndex; 
     269            returnValue[TRANSIENT_FIT_START] = startt; 
     270            returnValue[TRANSIENT_STOP]      = transEndIndex; 
     271             
    262272            return returnValue; //TODO "do_estimate_resets; do_estimate_frees; " 
    263273        } 
     
    314324            } 
    315325            System.out.println("index is " + index); 
    316             returnValue[0] = startp; 
    317             returnValue[1] = endp; 
    318             returnValue[2] = baseline; 
    319             returnValue[3] = startt; 
    320             returnValue[4] = transEndIndex; 
     326 
     327            returnValue[PROMPT_START]        = startp; 
     328            returnValue[PROMPT_STOP]         = endp; 
     329            returnValue[PROMPT_BASELINE]     = baseline; 
     330            returnValue[TRANSIENT_START]     = transStartIndex; 
     331            returnValue[TRANSIENT_FIT_START] = startt; 
     332            returnValue[TRANSIENT_STOP]      = transEndIndex; 
    321333            return returnValue; //TODO do estimate resets/frees??? 
    322334        } 
     
    329341        transStartIndex += index; 
    330342        transFitStartIndex = transStartIndex + (transEndIndex - transStartIndex) / 20; 
    331  
    332         returnValue[0] = startp; 
    333         returnValue[1] = endp; 
    334         returnValue[2] = baseline; 
    335         returnValue[3] = transStartIndex; 
    336         returnValue[4] = transFitStartIndex; 
    337         returnValue[5] = transEndIndex; 
     343         
     344        returnValue[PROMPT_START]        = startp; 
     345        returnValue[PROMPT_STOP]        = endp; 
     346        returnValue[PROMPT_BASELINE]    = baseline; 
     347        returnValue[TRANSIENT_START]    = transStartIndex; 
     348        returnValue[TRANSIENT_FIT_START] = transFitStartIndex; 
     349        returnValue[TRANSIENT_STOP]      = transEndIndex; 
    338350        return returnValue; 
    339351    } 
     
    372384     */ 
    373385    public static int getEstimateStartIndex(double[] trans, int transFitStartIndex, int transEndIndex) { 
    374         int transEstimateStartIndex = transFitStartIndex + findMax(trans, transFitStartIndex, transEndIndex); 
     386        System.out.println("transFitStartIndex is " + transFitStartIndex + " transEndIndex is " + transEndIndex); 
     387        System.out.println("finMax is " + findMax(trans, transFitStartIndex, transEndIndex)); 
     388        int transEstimateStartIndex = /*transFitStartIndex +*/ findMax(trans, transFitStartIndex, transEndIndex); 
    375389        return transEstimateStartIndex; 
    376390    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/DecayGraph.java

    r7886 r7903  
    2929*/ 
    3030 
    31 package loci.slim.refactor.ui.charts; 
     31package loci.slim.ui; 
    3232 
    3333import java.awt.BasicStroke; 
     
    4444 
    4545import loci.curvefitter.ICurveFitData; 
    46 import loci.slim.ui.IStartStopListener; 
     46import loci.slim.fitting.cursor.FittingCursor; 
     47import loci.slim.fitting.cursor.IFittingCursorListener; 
    4748 
    4849import org.jdesktop.jxlayer.JXLayer; 
     
    8182    static final Color FITTED_COLOR = Color.RED; 
    8283    static final Color BACK_COLOR = Color.WHITE; 
    83     static final Color START_COLOR = Color.BLUE.darker(); 
    84     static final Color STOP_COLOR = Color.RED.darker(); 
     84    static final Color TRANS_START_COLOR = Color.BLUE.darker(); 
     85    static final Color DATA_START_COLOR = Color.GREEN.darker(); 
     86    static final Color TRANS_STOP_COLOR = Color.RED.darker(); 
    8587    static final Color BASE_COLOR = Color.GREEN.darker(); 
    8688    static final Color RESIDUAL_COLOR = Color.BLACK; 
     
    8890    private static DecayGraph _instance; 
    8991    private JFrame _frame; 
    90     IStartStopListener _startStopListener; 
     92    FittingCursor _fittingCursor; 
     93    IFittingCursorListener _fittingCursorListener; 
    9194 
    9295    private StartStopDraggingUI<JComponent> _startStopDraggingUI; 
    9396    private double _timeInc; 
    9497    private int _bins; 
    95     private Integer _start; 
    96     private Integer _stop; 
     98    private Integer _transStart; 
     99    private Integer _dataStart; 
     100    private Integer _transStop; 
    97101    private boolean _logarithmic = true; 
    98102 
     
    121125        } 
    122126        return _instance; 
    123     } 
    124      
    125     /** 
    126      * Sets up a listener to listen for start/stop changes. 
    127      *  
    128      * @param startStopListener 
    129      */ 
    130     public void setStartStopListener(IStartStopListener startStopListener) { 
    131         _startStopListener = startStopListener; 
    132127    } 
    133128 
     
    165160 
    166161            // add start/stop vertical bar handling 
    167             _start = _stop = null; 
     162            _dataStart = _transStop = null; 
    168163            JXLayer<JComponent> layer = new JXLayer<JComponent>(panel); 
    169164            _startStopDraggingUI = 
     
    183178    } 
    184179     
     180    public void setFittingCursor(FittingCursor fittingCursor) { 
     181        if (null == _fittingCursor) { 
     182            _fittingCursorListener = new FittingCursorListener(); 
     183        } 
     184        else { 
     185            _fittingCursor.removeListener(_fittingCursorListener); 
     186        } 
     187        _fittingCursor = fittingCursor; 
     188        _fittingCursor.addListener(_fittingCursorListener); 
     189    } 
     190     
    185191    public void setTitle(final String title) { 
    186192        _frame.setTitle(title); 
     
    201207     * Changes (or initializes) the start and stop vertical bars. 
    202208     * 
    203      * @param start 
    204      * @param stop 
    205      */ 
    206     public void setStartStop(int start, int stop) { 
    207         if (null == _start) { 
     209     * @param transStart 
     210     * @param dataStart 
     211     * @param transStop 
     212     */ 
     213    public void setStartStop(int transStart, int dataStart, int transStop) { 
     214        if (null == _dataStart) { 
    208215            // initialize the vertical bars 
    209             double startValue = start * _timeInc; 
    210             double stopValue = stop * _timeInc; 
    211             double maxValue = _bins * _timeInc; 
     216            double transStartValue = transStart * _timeInc; 
     217            double dataStartValue  = dataStart  * _timeInc; 
     218            double transStopValue  = transStop  * _timeInc; 
     219            double maxValue        = _bins      * _timeInc; 
    212220            _startStopDraggingUI.setStartStopValues 
    213                     (startValue, stopValue, maxValue); 
    214         } 
    215  
    216         _start = start; 
    217         _stop = stop; 
     221                    (transStartValue, dataStartValue, transStopValue, maxValue); 
     222        } 
     223 
     224        _transStart = transStart; 
     225        _dataStart  = dataStart; 
     226        _transStop  = transStop; 
    218227 
    219228    } 
     
    224233     * and passes changes on to external listener. 
    225234     * 
    226      * @param startProportion 
    227      * @param stopProportion 
    228      */ 
    229     public void setStartStopProportion 
    230             (double startProportion, double stopProportion) 
     235     * @param transStartProportion 
     236     * @param dataStartProportion 
     237     * @param transStopProportion 
     238     */ 
     239    public void setStartStopProportion( 
     240            double transStartProportion, 
     241            double dataStartProportion, 
     242            double transStopProportion) 
    231243    { 
    232244        // calculate new start and stop 
    233         int start = (int) (startProportion * _bins + 0.5); 
    234         int stop = (int) (stopProportion * _bins + 0.5); 
     245        int transStart = (int) (transStartProportion * _bins + 0.5); 
     246        int dataStart  = (int) (dataStartProportion  * _bins + 0.5); 
     247        int transStop  = (int) (transStopProportion  * _bins + 0.5); 
    235248 
    236249        // if changed, notify listener 
    237         if (start != _start || stop != _stop) { 
    238             if (null != _startStopListener) { 
    239                 _startStopListener.setStartStop(start, stop); 
     250        if (transStart != _transStart || dataStart != _dataStart || 
     251                transStop != _transStop) 
     252        { 
     253            if (null != _fittingCursor) { 
     254                _fittingCursor.setTransientStartBin(transStart); 
     255                _fittingCursor.setDataStartBin(dataStart); 
     256                _fittingCursor.setTransientStopBin(transStop); 
    240257            } 
    241258        } 
     
    350367            series3.add(xCurrent, (yData > 0.0 ? yData : null)); 
    351368            // are we in fitted region? 
    352             if (_start <= i && i <= _stop) { 
     369            if (_dataStart <= i && i <= _transStop) { 
    353370                // yes, show fitted curve and residuals 
    354371                yFitted = data.getYFitted()[i]; 
     
    392409        private XYPlot _plot; 
    393410        private IStartStopProportionListener _listener; 
    394         boolean _draggingStartMarker = false; 
    395         boolean _draggingStopMarker = false; 
    396         private Double _startMarkerProportion; 
    397         private Double _stopMarkerProportion; 
     411        boolean _dragTransStartMarker = false; 
     412        boolean _dragDataStartMarker  = false; 
     413        boolean _dragTransStopMarker  = false; 
     414        private volatile Double _transStartMarkerProportion; 
     415        private volatile Double _dataStartMarkerProportion; 
     416        private volatile Double _transStopMarkerProportion; 
    398417        private int _y0; 
    399418        private int _y1; 
    400         private int _xStart; 
    401         private int _xStop; 
     419        private int _xTransStart; 
     420        private int _xDataStart; 
     421        private int _xTransStop; 
    402422 
    403423        /** 
     
    414434            _plot     = plot; 
    415435            _listener = listener; 
    416             _startMarkerProportion = null; 
    417             _stopMarkerProportion = null; 
     436            _transStartMarkerProportion = null; 
     437            _dataStartMarkerProportion  = null; 
     438            _transStopMarkerProportion  = null; 
    418439        } 
    419440 
    420441        void setStartStopValues 
    421                 (double startValue, double stopValue, double maxValue) 
     442                (double transStartValue, double dataStartValue, 
     443                double transStopValue, double maxValue) 
    422444        { 
    423445            Rectangle2D area = getDataArea(); 
     
    425447            double width = area.getWidth(); 
    426448            if (0.1 > width) { 
    427                 _startMarkerProportion = startValue / maxValue; 
    428                 _stopMarkerProportion = stopValue / maxValue; 
     449                _transStartMarkerProportion = transStartValue / maxValue; 
     450                _dataStartMarkerProportion  = dataStartValue  / maxValue; 
     451                _transStopMarkerProportion  = transStopValue  / maxValue; 
    429452            } 
    430453            else { 
    431454                double minRepresentedValue = screenToValue((int) x); 
    432455                double maxRepresentedValue = screenToValue((int) (x + width)); 
    433                 _startMarkerProportion = 
    434                         (float) (startValue - minRepresentedValue) / 
     456                _transStartMarkerProportion = 
     457                        (float) (transStartValue - minRepresentedValue) / 
    435458                            (maxRepresentedValue - minRepresentedValue); 
    436                 _stopMarkerProportion = 
    437                         (float) (stopValue - minRepresentedValue) / 
     459                _dataStartMarkerProportion = 
     460                        (float) (dataStartValue - minRepresentedValue) / 
     461                            (maxRepresentedValue - minRepresentedValue); 
     462                _transStopMarkerProportion = 
     463                        (float) (transStopValue - minRepresentedValue) / 
    438464                            (maxRepresentedValue - minRepresentedValue); 
    439465            } 
     
    453479            super.paintLayer(g2D, layer); 
    454480             
    455             if (null != _startMarkerProportion && null != _stopMarkerProportion) { 
     481            if (null != _transStartMarkerProportion && 
     482                    null != _dataStartMarkerProportion && 
     483                    null != _transStopMarkerProportion) { 
    456484                // adjust to current size 
    457485                Rectangle2D area = getDataArea(); 
     
    460488                _y1 = (int) (area.getY() + area.getHeight()); 
    461489                double width = area.getWidth(); 
    462                 _xStart = (int) Math.round(x + width * _startMarkerProportion) 
     490                _xTransStart = (int) Math.round(x + width * _transStartMarkerProportion) 
    463491                        + HORZ_TWEAK; 
    464                 _xStop = (int) Math.round(x + width * _stopMarkerProportion) 
     492                _xDataStart = (int) Math.round(x + width * _dataStartMarkerProportion) 
     493                        + HORZ_TWEAK; 
     494                _xTransStop = (int) Math.round(x + width * _transStopMarkerProportion) 
    465495                        + HORZ_TWEAK; 
    466496 
    467497                // custom painting is here 
    468498                g2D.setStroke(new BasicStroke(2f)); 
    469                 g2D.setXORMode(XORvalue(START_COLOR)); 
    470                 g2D.drawLine(_xStart, _y0, _xStart, _y1); 
    471                 g2D.setXORMode(XORvalue(STOP_COLOR)); 
    472                 g2D.drawLine(_xStop, _y0, _xStop, _y1);     
     499                g2D.setXORMode(XORvalue(TRANS_START_COLOR)); 
     500                g2D.drawLine(_xTransStart, _y0, _xTransStart, _y1); 
     501                g2D.setXORMode(XORvalue(DATA_START_COLOR)); 
     502                g2D.drawLine(_xDataStart, _y0, _xDataStart, _y1); 
     503                g2D.setXORMode(XORvalue(TRANS_STOP_COLOR)); 
     504                g2D.drawLine(_xTransStop, _y0, _xTransStop, _y1);     
    473505            } 
    474506        } 
     
    485517            super.processMouseMotionEvent(event, layer); 
    486518            if (event.getID() == MouseEvent.MOUSE_DRAGGED) { 
    487                 if (_draggingStartMarker || _draggingStopMarker) { 
     519                if (_dragTransStartMarker || _dragDataStartMarker 
     520                        || _dragTransStopMarker) { 
    488521                    double newProportion = getDraggedProportion(event); 
    489                     if (_draggingStartMarker) { 
    490                         if (newProportion <= _stopMarkerProportion) { 
    491                             _startMarkerProportion = newProportion; 
     522                    if (_dragTransStartMarker) { 
     523                        if (newProportion <= _dataStartMarkerProportion) { 
     524                            _transStartMarkerProportion = newProportion; 
     525                        } 
     526                        else { 
     527                            _transStartMarkerProportion = _dataStartMarkerProportion; 
     528                        } 
     529                    } 
     530                    else if (_dragDataStartMarker) { 
     531                        if (newProportion >= _transStartMarkerProportion) { 
     532                            if (newProportion <= _transStopMarkerProportion) { 
     533                                _dataStartMarkerProportion = newProportion; 
     534                            } 
     535                            else { 
     536                                _dataStartMarkerProportion = _transStopMarkerProportion; 
     537                            }; 
     538                        } 
     539                        else { 
     540                            _transStopMarkerProportion = _transStartMarkerProportion; 
    492541                        } 
    493542                    } 
    494543                    else { 
    495                         if (newProportion >= _startMarkerProportion) { 
    496                             _stopMarkerProportion = newProportion; 
     544                        if (newProportion >= _dataStartMarkerProportion) { 
     545                            _transStopMarkerProportion = newProportion; 
     546                        } 
     547                        else { 
     548                            _transStopMarkerProportion = _dataStartMarkerProportion; 
    497549                        } 
    498550                    } 
     
    537589        protected void processMouseEvent(MouseEvent e, JXLayer<? extends V> l) { 
    538590            super.processMouseEvent(e, l); 
    539             if (null != _startMarkerProportion && null != _stopMarkerProportion) { 
     591            if (null != _transStartMarkerProportion && null != _transStopMarkerProportion) { 
    540592                if (e.getID() == MouseEvent.MOUSE_PRESSED) { 
    541593                    int x = e.getX(); 
    542594                    int y = e.getY(); 
    543595                    if (y > _y0 - CLOSE_ENOUGH && y < _y1 + CLOSE_ENOUGH) { 
    544                         if (Math.abs(x - _xStart) < CLOSE_ENOUGH) { 
     596                        if (Math.abs(x - _xTransStart) < CLOSE_ENOUGH) { 
     597                            // check for superimposition 
     598                            if (_xTransStart == _xDataStart) { 
     599                                if (_xTransStart == _xTransStop) { 
     600                                    // all three superimposed 
     601                                    if (x - _xTransStart < 0) { 
     602                                        // start dragging trans start line 
     603                                        _dragTransStartMarker = true; 
     604                                    } 
     605                                    else { 
     606                                        // start dragging trans stop line 
     607                                        _dragTransStopMarker = true; 
     608                                    } 
     609                                } 
     610                                else { 
     611                                    // trans and data start superimposed 
     612                                    if (x - _xTransStart < 0) { 
     613                                        // start dragging trans start line 
     614                                        _dragTransStartMarker = true; 
     615                                    } 
     616                                    else { 
     617                                        // start dragging data start line 
     618                                        _dragDataStartMarker = true; 
     619                                    } 
     620                                } 
     621                            } 
    545622                            // start dragging start line 
    546                             _draggingStartMarker = true; 
    547  
    548                         } 
    549                         else if (Math.abs(x - _xStop) < CLOSE_ENOUGH) { 
    550                             // start dragging stop line 
    551                             _draggingStopMarker = true; 
     623                            _dragTransStartMarker = true; 
     624 
     625                        } 
     626                        else if (Math.abs(x - _xDataStart) < CLOSE_ENOUGH) { 
     627                            // check for superimposition 
     628                            if (_xDataStart == _xTransStop) { 
     629                                // data start and trans stop superimposed 
     630                                if (x - _xDataStart < 0) { 
     631                                    // start dragging data start line 
     632                                    _dragDataStartMarker = true; 
     633                                } 
     634                                else { 
     635                                    // start dragging trans stop line 
     636                                    _dragTransStopMarker = true; 
     637                                } 
     638                            } 
     639                            // start dragging data start line 
     640                            _dragDataStartMarker = true; 
     641                        } 
     642                        else if (Math.abs(x - _xTransStop) < CLOSE_ENOUGH) { 
     643                            // possible superimpositions already checked 
     644                             
     645                            // start dragging trans stop line 
     646                            _dragTransStopMarker = true; 
    552647                        } 
    553648                    } 
    554649                } 
    555650                if (e.getID() == MouseEvent.MOUSE_RELEASED) { 
    556                     _draggingStartMarker = _draggingStopMarker = false; 
     651                    _dragTransStartMarker = _dragDataStartMarker = _dragTransStopMarker = false; 
    557652                    SwingUtilities.invokeLater( 
    558653                            new Runnable() { 
     
    560655                                    if (null != _listener) { 
    561656                                        _listener.setStartStopProportion 
    562                                                 (_startMarkerProportion, 
    563                                                  _stopMarkerProportion); 
     657                                                (_transStartMarkerProportion, 
     658                                                 _dataStartMarkerProportion, 
     659                                                 _transStopMarkerProportion); 
    564660                                    } 
    565661                                } 
     
    591687                    (double) x, getDataArea(), RectangleEdge.TOP); 
    592688        } 
    593     } 
     689    }   
     690     
     691    private class FittingCursorListener implements IFittingCursorListener { 
     692        public void cursorChanged(FittingCursor cursor) { 
     693            int transientStart = cursor.getTransientStartBin(); 
     694            int dataStart      = cursor.getDataStartBin(); 
     695            int transientStop  = cursor.getTransientStopBin(); 
     696            System.out.println("CHANGED " + transientStart + " " + dataStart + " " + transientStop); 
     697        } 
     698    }     
    594699} 
    595700 
     
    601706interface IStartStopProportionListener { 
    602707    public void setStartStopProportion 
    603             (double startProportion, double stopProportion); 
     708            (double transStartProportion, double dataStartProportion, double transStopProportion); 
    604709} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationGraph.java

    r7892 r7903  
    4646import javax.swing.JPanel; 
    4747import javax.swing.SwingUtilities; 
    48  
    49 import loci.curvefitter.ICurveFitData; 
    50 import loci.slim.ui.IStartStopListener; 
    5148 
    5249import org.jdesktop.jxlayer.JXLayer; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IDecayGraph.java

    r7804 r7903  
    2929*/ 
    3030 
    31 package loci.slim.refactor.ui.charts; 
     31package loci.slim.ui; 
    3232 
    3333import javax.swing.JFrame; 
    3434 
    3535import loci.curvefitter.ICurveFitData; 
    36 import loci.slim.ui.IStartStopListener; 
     36import loci.slim.fitting.cursor.FittingCursor; 
    3737 
    3838/** 
     
    4242 */ 
    4343public interface IDecayGraph { 
    44     /** 
    45      * Sets up a listener to listen for start/stop changes. 
    46      *  
    47      * @param startStopListener 
    48      */ 
    49     public void setStartStopListener(IStartStopListener startStopListener); 
    50  
     44     
    5145    /** 
    5246     * Initialize the graph and returns the containing JFrame. 
     
    5751     */ 
    5852    public JFrame init(final JFrame frame, final int bins, final double timeInc); 
    59      
     53 
     54    /** 
     55     * Changes (or initializes) the cursor (start/stop bins/values) for the fit. 
     56     *  
     57     * @param fittingCursor  
     58     */ 
     59    public void setFittingCursor(FittingCursor fittingCursor); 
     60 
     61    /** 
     62     * Changes (or initializes) the title of the graph. 
     63     *  
     64     * @param title  
     65     */ 
    6066    public void setTitle(final String title); 
    6167 
     
    7177     * Changes (or initializes) the start and stop vertical bars. 
    7278     * 
    73      * @param start 
    74      * @param stop 
     79     * @param transientStart 
     80     * @param dataStart 
     81     * @param transientStop 
    7582     */ 
    76     public void setStartStop(int start, int stop); 
     83    public void setStartStop(int transientStart, int dataStart, int transientStop); 
    7784} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanel.java

    r7875 r7903  
    4141import loci.curvefitter.ICurveFitter.FitRegion; 
    4242import loci.curvefitter.ICurveFitter.NoiseModel; 
     43import loci.slim.fitting.cursor.FittingCursor; 
     44import loci.slim.fitting.cursor.IFittingCursorListener; 
    4345 
    4446/** 
     
    5254 */ 
    5355public interface IUserInterfacePanel { 
     56     
     57    public void setFittingCursor(FittingCursor fittingCursor); 
    5458 
    5559    /** 
     
    118122     */ 
    119123    public boolean getFitAllChannels(); 
    120  
    121     /** 
    122      * Gets starting bin of fit. 
    123      * 
    124      * @return start 
    125      */ 
    126     public int getStart(); 
    127  
    128     /** 
    129      * Sets starting bin of fit. 
    130      * 
    131      * @param bin 
    132      * @param refit 
    133      */ 
    134     public void setStart(int bin, boolean refit); 
    135  
    136     /** 
    137      * Gets stopping bin of fit (inclusive). 
    138      * 
    139      * @return stop 
    140      */ 
    141     public int getStop(); 
    142  
    143     /** 
    144      * Sets stopping bin of fit. 
    145      * 
    146      * @param bin 
    147      * @param refit 
    148      */ 
    149     public void setStop(int bin, boolean refit);  
    150124     
    151  
    152125    /** 
    153126     * Gets photon count threshold to fit a pixel. 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7889 r7903  
    6868import loci.curvefitter.ICurveFitter.FitRegion; 
    6969import loci.curvefitter.ICurveFitter.NoiseModel; 
     70import loci.slim.fitting.cursor.FittingCursor; 
     71import loci.slim.fitting.cursor.IFittingCursorListener; 
     72import loci.slim.fitting.cursor.ITransientCursorUI; 
    7073 
    7174/** 
     
    7578 */ 
    7679 
    77 public class UserInterfacePanel implements IUserInterfacePanel { 
     80public class UserInterfacePanel implements IUserInterfacePanel, ITransientCursorUI { 
    7881    // Unicode special characters 
    7982    private static final Character CHI    = '\u03c7'; 
     
    146149    private static final String EXCITATION_ITEMS[] = { EXCITATION_NONE, EXCITATION_FILE, EXCITATION_CREATE }; 
    147150     
     151    private FittingCursor _fittingCursor; 
     152    private IFittingCursorListener _fittingCursorListener; 
     153     
    148154    public IUserInterfacePanelListener m_listener; 
    149  
     155    private boolean m_showBins = true; 
    150156    int m_fittedParameterCount = 0; 
    151157 
     
    166172    JTextField m_xField; 
    167173    JTextField m_yField; 
    168     JTextField m_startField; 
    169     JTextField m_stopField; 
     174    JTextField m_transStartField; 
     175    JTextField m_dataStartField; 
     176    JTextField m_transStopField; 
    170177    JTextField m_thresholdField; 
    171178    JTextField m_chiSqTargetField; 
     
    327334        }); 
    328335    } 
     336     
     337    public void setFittingCursor(FittingCursor fittingCursor) { 
     338        if (null == _fittingCursor) { 
     339             
     340            _fittingCursorListener = new FittingCursorListener(); 
     341        } 
     342        else { 
     343            _fittingCursor.removeListener(_fittingCursorListener); 
     344        } 
     345        _fittingCursor = fittingCursor; 
     346        _fittingCursor.addListener(_fittingCursorListener); 
     347    } 
    329348 
    330349    public JFrame getFrame() { 
     
    500519        controlPanel.add(m_yField); 
    501520 
    502         JLabel startLabel = new JLabel("Start"); 
    503         startLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    504         controlPanel.add(startLabel); 
    505         m_startField = new JTextField(9); 
    506         controlPanel.add(m_startField); 
    507  
    508         JLabel stopLabel = new JLabel("Stop"); 
    509         stopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    510         controlPanel.add(stopLabel); 
    511         m_stopField = new JTextField(9); 
    512         controlPanel.add(m_stopField); 
     521        JLabel transStartLabel = new JLabel("Transient Start"); 
     522        transStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     523        controlPanel.add(transStartLabel); 
     524        m_transStartField = new JTextField(9); 
     525        controlPanel.add(m_transStartField); 
     526         
     527        JLabel dataStartLabel = new JLabel("Data Start"); 
     528        dataStartLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     529        controlPanel.add(dataStartLabel); 
     530        m_dataStartField = new JTextField(9); 
     531        controlPanel.add(m_dataStartField); 
     532 
     533        JLabel transStopLabel = new JLabel("Transient Stop"); 
     534        transStopLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     535        controlPanel.add(transStopLabel); 
     536        m_transStopField = new JTextField(9); 
     537        controlPanel.add(m_transStopField); 
    513538 
    514539        JLabel thresholdLabel = new JLabel("Threshold"); 
     
    569594 
    570595        // rows, cols, initX, initY, xPad, yPad 
    571         SpringUtilities.makeCompactGrid(controlPanel, 8, 2, 4, 4, 4, 4); 
     596        SpringUtilities.makeCompactGrid(controlPanel, 9, 2, 4, 4, 4, 4); 
    572597 
    573598        JPanel panel = new JPanel(new BorderLayout()); 
     
    967992        m_xField.setEditable(enable); 
    968993        m_yField.setEditable(enable); 
    969         m_startField.setEditable(enable); 
    970         m_stopField.setEditable(enable); 
     994        m_transStartField.setEditable(enable); 
     995        m_transStopField.setEditable(enable); 
    971996        m_thresholdField.setEditable(enable); 
    972997        m_chiSqTargetField.setEditable(enable); 
     
    11611186    } 
    11621187 
    1163     public int getStart() { 
    1164         return parseInt(m_startField); 
    1165     } 
    1166  
    1167     public void setStart(int start, boolean refit) { 
    1168         m_startField.setText("" + start); 
    1169         if (refit && null != m_listener) { 
    1170             m_listener.doPixelFit(); 
    1171         } 
     1188    public void setStart(int start) { 
     1189        m_transStartField.setText("" + start); 
    11721190    } 
    11731191 
    11741192    public int getStop() { 
    1175         return parseInt(m_stopField); 
    1176     } 
    1177  
    1178     public void setStop(int stop, boolean refit) { 
    1179         m_stopField.setText("" + stop); 
    1180         if (refit && null != m_listener) { 
    1181             m_listener.doPixelFit(); 
    1182         } 
     1193        return parseInt(m_transStopField); 
     1194    } 
     1195 
     1196    public void setStop(int stop) { 
     1197        m_transStopField.setText("" + stop); 
    11831198    } 
    11841199 
     
    13901405        return !checkBox.isSelected(); 
    13911406    } 
     1407     
     1408    /** 
     1409     * Gets the transient start cursor. 
     1410     *  
     1411     * @return  
     1412     */ 
     1413    public String getTransientStart() { 
     1414        return m_transStartField.getText();   
     1415    } 
     1416   
     1417    /** 
     1418     * Sets the transient start cursor. 
     1419     *  
     1420     * @param transientStart  
     1421     */ 
     1422    public void setTransientStart(String transientStart) { 
     1423        m_transStartField.setText(transientStart); 
     1424    } 
     1425     
     1426    /** 
     1427     * Gets the data start cursor. 
     1428     * @return  
     1429     */  
     1430    public String getDataStart() { 
     1431        return m_dataStartField.getText(); 
     1432    } 
     1433     
     1434    /** 
     1435     * Sets the data start cursor. 
     1436     * @return  
     1437     */ 
     1438    public void setDataStart(String dataStart) { 
     1439        m_dataStartField.setText(dataStart); 
     1440    } 
     1441 
     1442    /** 
     1443     * Gets the transient end cursor. 
     1444     *  
     1445     * @return  
     1446     */ 
     1447    public String getTransientStop() { 
     1448        return m_transStopField.getText(); 
     1449    } 
     1450 
     1451    /** 
     1452     * Sets the transient end cursor. 
     1453     *  
     1454     * @param transientStop  
     1455     */ 
     1456    public void setTransientStop(String transientStop) { 
     1457        m_transStopField.setText(transientStop); 
     1458    } 
    13921459 
    13931460    private int parseInt(JTextField field) { 
     
    14261493        return dialog.getNextString(); 
    14271494    } 
     1495     
     1496    private class FittingCursorListener implements IFittingCursorListener { 
     1497        public void cursorChanged(FittingCursor cursor) { 
     1498            if (cursor.getShowBins()) { 
     1499                int transStart = cursor.getTransientStartBin(); 
     1500                int dataStart  = cursor.getDataStartBin(); 
     1501                int transStop  = cursor.getTransientStopBin(); 
     1502                setTransientStart("" + transStart); 
     1503                setDataStart     ("" + dataStart); 
     1504                setTransientStop ("" + transStop); 
     1505            } 
     1506            else { 
     1507                double transStart = cursor.getTransientStartValue(); 
     1508                double dataStart  = cursor.getDataStartValue(); 
     1509                double transStop  = cursor.getTransientStopValue(); 
     1510                setTransientStart("" + transStart); 
     1511                setDataStart     ("" + dataStart); 
     1512                setTransientStop ("" + transStop); 
     1513            } 
     1514        } 
     1515    } 
    14281516} 
Note: See TracChangeset for help on using the changeset viewer.