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

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

File:
1 moved

Legend:

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