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/fitting/cursor
Files:
4 added
2 edited
2 moved

Legend:

Unmodified
Added
Removed
  • 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    } 
Note: See TracChangeset for help on using the changeset viewer.