Changeset 7892


Ignore:
Timestamp:
02/17/12 20:34:14 (7 years ago)
Author:
aivar
Message:

SLIM Plugin: Work in progress; make sure fits agree with TRI2.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
8 edited
1 moved

Legend:

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

    r7674 r7892  
    4343public class Excitation { 
    4444    private final String m_fileName; 
    45     private final float[] m_values; 
    46     private final float m_timeInc; 
     45    private final double[] m_values; 
     46    private final double m_timeInc; 
    4747    private int m_start; 
    4848    private int m_stop; 
    49     private float m_base; 
     49    private double m_base; 
    5050 
    5151    /** 
     
    5555     * @param values 
    5656     */ 
    57     public Excitation(String fileName, float[] values, float timeInc) { 
     57    public Excitation(String fileName, double[] values, double timeInc) { 
    5858        m_fileName = fileName; 
    5959        m_values = values; 
     
    7575     * @return 
    7676     */ 
    77     public float[] getValues() { 
     77    public double[] getValues() { 
    7878        return m_values; 
    7979    } 
     
    8484     * @return 
    8585     */ 
    86     public float getTimeInc() { 
     86    public double getTimeInc() { 
    8787        return m_timeInc; 
    8888    } 
     
    129129     * @param base 
    130130     */ 
    131     public void setBase(float base) { 
     131    public void setBase(double base) { 
    132132        m_base = base; 
    133133    } 
     
    138138     * @return 
    139139     */ 
    140     public float getBase() { 
     140    public double getBase() { 
    141141        return m_base; 
    142142    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ExcitationFileHandler.java

    r7794 r7892  
    7777    } 
    7878 
    79     public Excitation loadExcitation(String fileName, float timeInc) { 
     79    public Excitation loadExcitation(String fileName, double timeInc) { 
    8080        Excitation excitation = null; 
    81         float values[] = null; 
     81        double values[] = null; 
    8282        if (fileName.toLowerCase().endsWith(ICS)) { 
    8383            values = loadICSExcitationFile(fileName); 
     
    9595    } 
    9696 
    97     public Excitation createExcitation(String fileName, float[] values, float timeInc) { 
     97    public Excitation createExcitation(String fileName, double[] values, double timeInc) { 
    9898        Excitation excitation = null; 
    9999        boolean success = false; 
     
    113113    } 
    114114 
    115     private float[] loadICSExcitationFile(String fileName) { 
    116         float[] results = null; 
     115    private double[] loadICSExcitationFile(String fileName) { 
     116        double[] results = null; 
    117117        ICSReader icsReader = new ICSReader(); 
    118118        try { 
     
    127127                bins = icsReader.getSizeZ(); 
    128128            } 
    129             results = new float[bins]; 
     129            results = new double[bins]; 
    130130            byte bytes[]; 
    131131            if (false || icsReader.isInterleaved()) { //TODO ARG interleaved does not read the whole thing; was 130K, now 32767 
     
    134134                System.out.println("INTERLEAVED reads # bytes: " + bytes.length); 
    135135                for (int bin = 0; bin < bins; ++bin) { 
    136                     results[bin] = convertBytesToFloat(littleEndian, bitsPerPixel, bytes, bytesPerPixel * bin); 
     136                    results[bin] = convertBytesToDouble(littleEndian, bitsPerPixel, bytes, bytesPerPixel * bin); 
    137137                } 
    138138            } 
     
    140140                for (int bin = 0; bin < bins; ++bin) { 
    141141                    bytes = icsReader.openBytes(bin); 
    142                     results[bin] = convertBytesToFloat(littleEndian, bitsPerPixel, bytes, 0); 
     142                    results[bin] = convertBytesToDouble(littleEndian, bitsPerPixel, bytes, 0); 
    143143                } 
    144144            } 
     
    155155 
    156156    //TODO doesn't work; needed to interoperate with TRI2 
    157     private boolean saveICSExcitationFile(String fileName, float[] values) { 
     157    private boolean saveICSExcitationFile(String fileName, double[] values) { 
    158158        boolean success = false; 
    159159        ICSWriter icsWriter = new ICSWriter(); 
     
    162162        try { 
    163163            for (int bin = 0; bin < values.length; ++bin) { 
    164                 icsWriter.saveBytes(bin, convertFloatToBytes(values[bin])); 
     164                icsWriter.saveBytes(bin, convertDoubleToBytes(values[bin])); 
    165165            } 
    166166            success = true; 
     
    175175    } 
    176176 
    177     private float[] loadIRFExcitationFile(String fileName) { 
    178         float[] values = null; 
     177    private double[] loadIRFExcitationFile(String fileName) { 
     178        double[] values = null; 
    179179        try { 
    180180            ArrayList<Float> valuesArrayList = new ArrayList<Float>(); 
     
    185185                valuesArrayList.add(Float.parseFloat(line)); 
    186186            } 
    187             values = new float[valuesArrayList.size()]; 
     187            values = new double[valuesArrayList.size()]; 
    188188            for (int i = 0; i < valuesArrayList.size(); ++i) { 
    189189                values[i] = valuesArrayList.get(i); 
     
    196196    } 
    197197 
    198     private boolean saveIRFExcitationFile(String fileName, float[] values) { 
     198    private boolean saveIRFExcitationFile(String fileName, double[] values) { 
    199199        boolean success = false; 
    200200        try { 
     
    204204                    writer.append('\n'); 
    205205                } 
    206                 writer.append(Float.toString(values[i])); 
     206                writer.append(Double.toString(values[i])); 
    207207            } 
    208208            writer.flush(); 
     
    216216    } 
    217217 
    218     private byte[] convertFloatToBytes(float f) { 
     218    private byte[] convertDoubleToBytes(double d) { 
     219        float f = (float) d; 
    219220        int rawIntBits = Float.floatToRawIntBits(f); 
    220221        byte[] result = new byte[4]; 
     
    227228 
    228229    /** 
    229      * Converts a little-endian four byte array to a float. 
     230     * Converts a little-endian four byte array to a double. 
    230231     * 
    231232     * @param littleEndian byte order 
     
    235236     * @return 
    236237     */ 
    237     private float convertBytesToFloat(boolean littleEndian, int bitsPerPixel, byte[] bytes, int index) { 
    238         float returnValue = 0.0f; 
     238    private double convertBytesToDouble(boolean littleEndian, int bitsPerPixel, byte[] bytes, int index) { 
     239        double returnValue = 0.0f; 
    239240        if (32 == bitsPerPixel) { 
    240241            int i = 0; 
     
    295296                l |= bytes[index + 7] & 0xff; 
    296297            } 
    297             returnValue = (float) Double.longBitsToDouble(l); 
     298            returnValue = (double) Double.longBitsToDouble(l); 
    298299        } 
    299300        return returnValue; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7889 r7892  
    3535package loci.slim; 
    3636 
     37import loci.slim.heuristics.CursorHelper; 
    3738import ij.IJ; 
    3839import ij.ImagePlus; 
     
    344345                    int x = uiPanel.getX(); 
    345346                    int y = uiPanel.getY(); 
    346                     float[] values = new float[m_bins]; 
     347                    double[] values = new double[m_bins]; 
    347348                    for (int b = 0; b < m_bins; ++b) { 
    348                         values[b] = (float) getData(m_cursor, channel, x, y, b); 
     349                        values[b] = getData(m_cursor, channel, x, y, b); 
    349350                    } 
    350351                    Excitation excitation = ExcitationFileHandler.getInstance().createExcitation(fileName, values, m_timeRange); 
     
    474475            } 
    475476 
    476             float[] results = CursorHelper.estimateCursors(m_timeRange, excitation.getValues(), decay); 
     477            double[] results = CursorHelper.estimateCursors(m_timeRange, excitation.getValues(), decay); 
    477478            excitation.setStart((int) results[0]); 
    478479            excitation.setStop((int) results[1]); 
     
    626627 
    627628        // patch things up 
    628         m_timeRange = 10.0f / 64.0f; //TODO ARG this patches things up in accord with TRI2 for brian/gpl1.sdt; very odd value here NOTE this was with photon counts all divided by 10.0f above! might have cancelled out. 
     629        m_timeRange = 10.0f / 64.0f; //TODO ARG 2/13/12 was: 10.0f / 64.0f; //TODO ARG this patches things up in accord with TRI2 for brian/gpl1.sdt; very odd value here NOTE this was with photon counts all divided by 10.0f above! might have cancelled out. 
    629630                   //TODO the patch above worked when I was also dividing the photon count by 10.0f!!  should be 1/64? 
    630631        m_minWave = 400; 
     
    995996            } 
    996997            curveFitData.setYCount(yCount); 
     998            curveFitData.setTransStartIndex(0); 
     999            curveFitData.setTransFitStartIndex(m_startBin); 
     1000            curveFitData.setTransEndIndex(m_stopBin); 
    9971001            yFitted = new double[m_bins]; 
    9981002            curveFitData.setYFitted(yFitted); 
     1003             
     1004            // for TRI2 compatibility: 
     1005            if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     1006                // these lines give TRI2 compatible fit results 
     1007                int estimateStartIndex = 
     1008                        CursorHelper.getEstimateStartIndex 
     1009                            (yCount, m_startBin, m_stopBin); 
     1010                curveFitData.setTransEstimateStartIndex(estimateStartIndex); 
     1011                curveFitData.setIgnorePromptForIntegralEstimate(true); 
     1012            }          
    9991013 
    10001014            // use zero for current channel if it's the only one 
     
    10091023        // do the fit 
    10101024        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1011         getCurveFitter(uiPanel).fitData(dataArray, m_startBin, m_stopBin); 
     1025        getCurveFitter(uiPanel).fitData(dataArray); 
    10121026 
    10131027        // show decay and update UI parameters 
     
    10701084                } 
    10711085                curveFitData.setYCount(yCount); 
     1086                curveFitData.setTransStartIndex(0); 
     1087                curveFitData.setTransFitStartIndex(m_startBin); 
     1088                curveFitData.setTransEndIndex(m_stopBin); 
     1089                if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     1090                    // these lines give TRI2 compatible fit results 
     1091                    int estimateStartIndex = 
     1092                            CursorHelper.getEstimateStartIndex 
     1093                                (yCount, m_startBin, m_stopBin); 
     1094                    curveFitData.setTransEstimateStartIndex(estimateStartIndex); 
     1095                    curveFitData.setIgnorePromptForIntegralEstimate(true); 
     1096                } 
     1097                 
     1098                 
    10721099                yFitted = new double[m_bins]; 
    10731100                curveFitData.setYFitted(yFitted); 
     
    10871114        // do the fit 
    10881115        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1089         getCurveFitter(uiPanel).fitData(dataArray, m_startBin, m_stopBin); 
     1116        getCurveFitter(uiPanel).fitData(dataArray); 
    10901117 
    10911118        // show the decay graphs 
     
    11831210            yCount = new double[m_bins]; 
    11841211            for (int b = 0; b < m_bins; ++b) { 
    1185                 yCount[b] = getData(m_cursor, channel, x, y, b); 
    1186             } 
     1212                yCount[b] = getData(m_cursor, channel, x, y, b) / 10.0; //TODO ARG 2/13/12 lowest value was 10.0, s/b 1.0 
     1213            } 
     1214            int photons = 0; 
     1215            for (int c = 0; c < m_bins; ++c) { 
     1216                photons += yCount[c]; 
     1217            } 
     1218            System.out.println("PHOTONS " + photons); 
    11871219            curveFitData.setYCount(yCount); 
     1220            curveFitData.setTransStartIndex(0); 
     1221            curveFitData.setTransFitStartIndex(m_startBin); 
     1222            curveFitData.setTransEndIndex(m_stopBin); 
     1223            if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(uiPanel.getFunction())) { 
     1224                // these lines give TRI2 compatible fit results 
     1225                int estimateStartIndex = 
     1226                        CursorHelper.getEstimateStartIndex 
     1227                            (yCount, m_startBin, m_stopBin); 
     1228                curveFitData.setTransEstimateStartIndex(estimateStartIndex); 
     1229                curveFitData.setIgnorePromptForIntegralEstimate(true); 
     1230            } 
     1231            
    11881232            yFitted = new double[m_bins]; 
    11891233            curveFitData.setYFitted(yFitted); 
     
    12001244        // do the fit 
    12011245        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    1202         getCurveFitter(uiPanel).fitData(dataArray, m_startBin, m_stopBin); 
     1246        getCurveFitter(uiPanel).fitData(dataArray); 
    12031247 
    12041248        // show decay graph for visible channel 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/callable/FittingEngineCallable.java

    r7889 r7892  
    3939import loci.slim.fitting.params.IGlobalFitParams; 
    4040import loci.slim.fitting.params.IFitResults; 
     41import loci.slim.heuristics.CursorHelper; 
    4142 
    4243import loci.curvefitter.CurveFitData; 
    4344import loci.curvefitter.ICurveFitData; 
    4445import loci.curvefitter.ICurveFitter; 
     46import loci.curvefitter.ICurveFitter.FitAlgorithm; 
    4547 
    4648/** 
     
    7779        curveFitData.setChiSquareTarget(_globalParams.getChiSquareTarget()); 
    7880        curveFitData.setYCount(_localParams.getY()); 
     81        curveFitData.setTransStartIndex(0); 
     82        curveFitData.setTransFitStartIndex(_localParams.getFitStart()); 
     83        curveFitData.setTransEndIndex(_localParams.getFitStop());         
    7984        curveFitData.setSig(_localParams.getSig()); 
    8085        curveFitData.setParams(_localParams.getParams().clone()); // params is overwritten 
    8186        curveFitData.setYFitted(_localParams.getYFitted()); 
     87        if (_globalParams.getTRI2Compatible()) { 
     88            if (FitAlgorithm.SLIMCURVE_RLD_LMA.equals(_globalParams.getFitFunction())) { 
     89                // these lines give TRI2 compatible fit results 
     90                int estimateStartIndex = 
     91                        CursorHelper.getEstimateStartIndex 
     92                            (_localParams.getY(), _localParams.getFitStart(), _localParams.getFitStop()); 
     93                curveFitData.setTransEstimateStartIndex(estimateStartIndex); 
     94                curveFitData.setIgnorePromptForIntegralEstimate(true); 
     95            } 
     96        } 
     97         
    8298        ICurveFitData[] curveFitDataArray = new ICurveFitData[] { curveFitData }; 
    83  
    84         _curveFitter.fitData(curveFitDataArray, _localParams.getFitStart(), _localParams.getFitStop()); 
     99        _curveFitter.fitData(curveFitDataArray); 
    85100 
    86101        _result = new FitResults(); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/params/GlobalFitParams.java

    r7889 r7892  
    4646 */ 
    4747public class GlobalFitParams implements IGlobalFitParams { 
     48    private boolean _compatible; 
    4849    private FitAlgorithm _fitAlgorithm; 
    4950    private FitFunction _fitFunction; 
     
    5758    private int _startDecay; 
    5859    private int _stopDecay; 
     60 
     61    @Override 
     62    public void setTRI2Compatible(boolean compatible) { 
     63        _compatible = compatible; 
     64    } 
     65 
     66    @Override 
     67    public boolean getTRI2Compatible() { 
     68        return _compatible; 
     69    } 
    5970  
    6071    @Override 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/fitting/params/IGlobalFitParams.java

    r7889 r7892  
    4747public interface IGlobalFitParams { 
    4848     
     49    public void setTRI2Compatible(boolean compatible); 
     50     
     51    public boolean getTRI2Compatible(); 
     52     
    4953    public void setFitAlgorithm(FitAlgorithm fitAlgorithm); 
    5054     
  • trunk/projects/slim-plugin/src/main/java/loci/slim/heuristics/CursorHelper.java

    r7875 r7892  
    3333*/ 
    3434 
    35 package loci.slim; 
     35package loci.slim.heuristics; 
    3636 
    3737import loci.curvefitter.CurveFitData; 
     
    3939import loci.curvefitter.ICurveFitter; 
    4040import loci.curvefitter.ICurveFitter.FitAlgorithm; 
     41import loci.curvefitter.ICurveFitter.NoiseModel; 
    4142import loci.curvefitter.SLIMCurveFitter; 
    4243 
     
    5354    private static final int ATTEMPTS = 10; 
    5455 
    55     public static float[] estimateExcitationCursors(float[] excitation) { 
    56         float baseline; 
    57         float maxval; 
     56    public static double[] estimateExcitationCursors(double[] excitation) { 
     57        double baseline; 
     58        double maxval; 
    5859        int index; 
    5960        int startp = 0; 
    6061        int endp = 0; 
    6162        int i; 
    62         float[] diffed = new float[excitation.length]; 
     63        double[] diffed = new double[excitation.length]; 
    6364        int steepp; 
    6465 
     
    117118        } 
    118119 
    119         float[] returnValue = new float[3]; 
     120        double[] returnValue = new double[3]; 
    120121        returnValue[0] = startp; 
    121122        returnValue[1] = endp; 
     
    124125    } 
    125126 
    126     public static int[] estimateDecayCursors(float xInc, double[] decay) { 
     127    public static int[] estimateDecayCursors(double xInc, double[] decay) { 
    127128        int maxIndex = findMax(decay); 
    128129        double[] diffed = new double[maxIndex]; 
     
    147148    } 
    148149 
    149     public static float[] estimateCursors(float xInc, float[] prompt, double[] decay) { 
    150         float[] returnValue = new float[5]; 
    151         float baseline; 
    152         float maxval; // TRCursors.c has "unsigned short maxsval, maxval; float maxfval, *diffed;" 
     150    public static double[] estimateCursors(double xInc, double[] prompt, double[] decay) { 
     151        double[] returnValue = new double[5]; 
     152        double baseline; 
     153        double maxval; // TRCursors.c has "unsigned short maxsval, maxval; double maxfval, *diffed;" 
    153154        int index; 
    154155        int startp = 0; 
     
    157158        int endt = 0; 
    158159        int i; 
    159         float[] diffed = new float[prompt.length]; 
     160        double[] diffed = new double[prompt.length]; 
    160161        int steepp; 
    161162        int steept; 
     
    227228 
    228229        // "Differentiate" 
    229         double[] diffedd = new double[decay.length]; //TODO double vs float issues 
     230        double[] diffedd = new double[decay.length]; 
    230231        for (i = 0; i < index; ++i) { 
    231232            diffedd[i] = decay[i + 1] - decay[i]; 
     
    264265        System.out.println("prompt " + prompt.length + " decay " + decay.length); 
    265266 
    266         //TODO convert everything to float, not double 
    267         double[] response = new double[decay.length]; 
    268         for (int n = 0; n < decay.length; ++n) { 
    269             response[n] = decay[index]; 
    270         } 
    271  
    272267        for (i = 0; i < 2 * ATTEMPTS + 1; ++i, ++transStartIndex) { 
    273268 
     
    283278            curveFitData.setParams(param); //TODO param has random values!! 
    284279            curveFitData.setYCount(decay); 
     280            curveFitData.setTransStartIndex(0); 
     281            curveFitData.setTransFitStartIndex(fitStart); 
     282            curveFitData.setTransEstimateStartIndex(fitStart); 
     283            curveFitData.setTransEndIndex(fitStop);             
     284   
    285285            curveFitData.setSig(null); 
    286286            curveFitData.setYFitted(yFitted); 
     
    291291            curveFitter.setXInc(xInc); 
    292292            curveFitter.setFree(free); 
    293             curveFitter.setInstrumentResponse(response); 
    294  
    295             int ret = curveFitter.fitData(data, fitStart, fitStop); 
     293            curveFitter.setInstrumentResponse(decay); 
     294            curveFitter.setNoiseModel(NoiseModel.POISSON_DATA); 
     295 
     296            int ret = curveFitter.fitData(data); 
    296297 
    297298            if (ret >= 0) { 
     
    346347     * @return 
    347348     */ 
    348     private static float calcBgFromPrepulse(float[] prepulse, int n) { 
    349         float z = 0.0f; 
     349    private static double calcBgFromPrepulse(double[] prepulse, int n) { 
     350        double z = 0.0f; 
    350351 
    351352        if (z > 0) { 
    352             float val = 0.0f; 
     353            double val = 0.0f; 
    353354            for (int i = 0; i <n; ++i) { 
    354355                val += prepulse[i]; 
     
    357358        } 
    358359        return z; 
     360    } 
     361 
     362    /** 
     363     * Calculates the start index to use for a triple integral/RLD estimate 
     364     * fit before a LMA fit. 
     365     *  
     366     * Based on expParameterEstimation from TRFitting.c. 
     367     *  
     368     * @param trans 
     369     * @param transFitStartIndex 
     370     * @param transEndIndex 
     371     * @return  
     372     */ 
     373    public static int getEstimateStartIndex(double[] trans, int transFitStartIndex, int transEndIndex) { 
     374        int transEstimateStartIndex = transFitStartIndex + findMax(trans, transFitStartIndex, transEndIndex); 
     375        return transEstimateStartIndex; 
    359376    } 
    360377 
     
    365382     * @return 
    366383     */ 
    367     public static float[] estimateParameters(boolean useRLD, 
     384    public static double[] estimateParameters(boolean useRLD, 
    368385            boolean useBackground, 
    369             float[] trans, 
     386            double[] trans, 
    370387            int transFitStartIndex, 
    371388            int transStartIndex, 
    372389            int transEndIndex) { 
    373         float a, t, z; 
    374  
    375         // initialize 
     390        double a, t, z; 
     391 
     392        // initial guess 
    376393        a = 1000.0f; 
    377394        t = 2.0f; 
     
    392409        } 
    393410 
    394         return new float[] { z, a, t }; 
    395     } 
    396  
    397     private static int findMax(float[] values) { 
     411        return new double[] { z, a, t }; 
     412    } 
     413 
     414    private static int findMax(double[] values) { 
    398415        return findMax(values, 0, values.length); 
    399416    } 
    400417 
    401     private static int findMax(float[] values, int endIndex) { 
     418    private static int findMax(double[] values, int endIndex) { 
    402419        return findMax(values, 0, endIndex); 
    403420    } 
    404421 
    405     private static int findMax(float[] values, int startIndex, int endIndex) { 
     422    private static int findMax(double[] values, int startIndex, int endIndex) { 
    406423        int index = startIndex; 
    407         float max = values[startIndex]; 
     424        double max = values[startIndex]; 
    408425        for (int i = startIndex; i < endIndex; ++i) { 
    409426            if (values[i] > max) { 
     
    415432    } 
    416433 
    417     private static int findMin(float[] values, int endIndex) { 
     434    private static int findMin(double[] values, int endIndex) { 
    418435        return findMin(values, 0, endIndex); 
    419436    } 
    420437 
    421     private static int findMin(float[] values, int startIndex, int endIndex) { 
     438    private static int findMin(double[] values, int startIndex, int endIndex) { 
    422439        int index = startIndex; 
    423         float min = values[startIndex]; 
     440        double min = values[startIndex]; 
    424441        for (int i = startIndex; i < endIndex; ++i) { 
    425442            if (values[i] < min) { 
     
    430447        return index; 
    431448    } 
    432  
    433     private static int findMax(double[] values) { 
    434         return findMax(values, values.length); 
    435     } 
    436  
    437     private static int findMax(double[] values, int endIndex) { 
    438         int index = 0; 
    439         double max = 0.0f; 
    440         for (int i = 0; i < endIndex; ++i) { 
    441             if (values[i] > max) { 
    442                 max = values[i]; 
    443                 index = i; 
    444             } 
    445         } 
    446         return index; 
    447     } 
    448  
    449     private static int findMin(double[] values, int endIndex) { 
    450         int index = 0; 
    451         double min = Double.MAX_VALUE; 
    452         for (int i = 0; i < endIndex; ++i) { 
    453             if (values[i] < min) { 
    454                 min = values[i]; 
    455                 index = i; 
    456             } 
    457         } 
    458         return index; 
    459     } 
    460449} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationGraph.java

    r7674 r7892  
    8383    int m_start; 
    8484    int m_stop; 
    85     float m_base; 
     85    double m_base; 
    8686    int m_bins; 
    87     float m_count; 
     87    double m_count; 
    8888    StartStopBaseDraggingUI<JComponent> m_startStopBaseDraggingUI; 
    8989    IStartStopBaseListener m_startStopBaseListener; 
     
    110110     * @param values 
    111111     */ 
    112     ExcitationGraph(final int start, final int stop, final float base, 
    113             final int bins, float[] values, final float timeInc) { 
     112    ExcitationGraph(final int start, final int stop, final double base, 
     113            final int bins, double[] values, final double timeInc) { 
    114114        m_start = start; 
    115115        m_stop = stop; 
     
    118118        m_count = 0.0f; 
    119119        // find maximum count 
    120         for (float value : values) { 
     120        for (double value : values) { 
    121121            if (value > m_count) { 
    122122                m_count = value; 
     
    195195     * @return the chart 
    196196     */ 
    197     JFreeChart createChart(int bins, double timeInc, float[] values) { 
     197    JFreeChart createChart(int bins, double timeInc, double[] values) { 
    198198 
    199199        // create chart data 
     
    237237     * @param data from the fit 
    238238     */ 
    239     private void createDataset(int bins, double timeInc, float[] values) { 
     239    private void createDataset(int bins, double timeInc, double[] values) { 
    240240        XYSeries series = new XYSeries("Data"); 
    241241        double yData, yFitted; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationPanel.java

    r7674 r7892  
    8787        int start = excitation.getStart(); 
    8888        int stop = excitation.getStop(); 
    89         float base = excitation.getBase(); 
    90         float[] values = excitation.getValues(); 
     89        double base = excitation.getBase(); 
     90        double[] values = excitation.getValues(); 
    9191        int bins = values.length; 
    92         float timeInc = excitation.getTimeInc(); 
     92        double timeInc = excitation.getTimeInc(); 
    9393        ExcitationGraph excitationGraph = new ExcitationGraph(start, stop, base, bins, values, timeInc); 
    9494         
     
    114114 
    115115    public double[] getValues(int pixels) { 
    116         float floatValues[] = m_excitation.getValues(); 
    117         for (float fV : floatValues) { 
     116        double inValues[] = m_excitation.getValues(); 
     117        for (double fV : inValues) { 
    118118            System.out.print(" " + fV); 
    119119        } 
     
    123123        int start = m_excitation.getStart(); 
    124124        int stop = m_excitation.getStop(); 
    125         float base = m_excitation.getBase(); 
    126         double[] values = new double[floatValues.length]; 
     125        double base = m_excitation.getBase(); 
     126        double[] values = new double[inValues.length]; 
    127127        for (int i = 0; i < values.length; ++i) { 
    128128            if (i < start || i > stop) { 
    129129                values[i] = 0.0; 
    130130            } 
    131             else if (floatValues[i] > base) { 
    132                 values[i] = pixels * floatValues[i]; 
     131            else if (inValues[i] > base) { 
     132                values[i] = pixels * inValues[i]; 
    133133                System.out.println("pixels " + pixels + "  value " + values[i]); 
    134134            } 
Note: See TracChangeset for help on using the changeset viewer.