Ignore:
Timestamp:
09/20/10 14:55:07 (9 years ago)
Author:
aivar
Message:

Added SLIMCURVE fit algorithms.
Worked on JavaDoc.

File:
1 edited

Legend:

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

    r6942 r6966  
    137137 
    138138    public enum FitAlgorithm { //TODO not really algorithm, usu. LMA 
    139        JAOLHO, /*AKUTAN,*/ BARBER_RLD, BARBER_LMA, MARKWARDT, BARBER2_RLD, BARBER2_LMA 
     139       JAOLHO, /*AKUTAN,*/ BARBER_RLD, BARBER_LMA, MARKWARDT, BARBER2_RLD, BARBER2_LMA, SLIMCURVE_RLD, SLIMCURVE_LMA 
    140140    } 
    141141 
     
    174174    private float m_chiSqTarget; 
    175175 
     176    /** 
     177     * Run thread for the plugin. 
     178     * 
     179     * @param arg 
     180     */ 
    176181    public void run(String arg) { 
    177182        // ask for which file to load 
     
    212217    } 
    213218 
     219    /** 
     220     * Prompts for a .sdt file. 
     221     * 
     222     * @param defaultFile 
     223     * @return 
     224     */ 
    214225    private boolean showFileDialog(String defaultFile) { 
    215226        //TODO shouldn't UI be in separate class? 
     
    230241    } 
    231242 
    232     // based on loci.slim.SlimData constructor 
     243    /** 
     244     * Loads the .sdt file. 
     245     * Based on the loci.slim.SlimData constructor. 
     246     * 
     247     * @param file 
     248     * @return 
     249     */ 
    233250    private boolean loadFile(String file) { 
    234251        if (m_fakeData) return true; 
     
    279296    } 
    280297 
    281    private boolean fakeData() { 
     298    /** 
     299     * This routine creates an artificial set of data that is useful to test fitting. 
     300     * 
     301     * @return 
     302     */ 
     303    private boolean fakeData() { 
    282304        m_width = 50; 
    283305        m_height = 50; 
     
    321343    } 
    322344 
     345    /** 
     346     * Restores file name from Java Preferences. 
     347     * 
     348     * @return 
     349     */ 
    323350    private String getFileFromPreferences() { 
    324351       Preferences prefs = Preferences.userNodeForPackage(this.getClass()); 
     
    326353    } 
    327354 
     355    /** 
     356     * Saves the file name to Java Preferences. 
     357     * 
     358     * @param file 
     359     */ 
    328360    private void saveFileInPreferences(String file) { 
    329361        Preferences prefs = Preferences.userNodeForPackage(this.getClass()); 
     
    331363    } 
    332364 
     365    /** 
     366     * This dialog shows the parameters from the .sdt file.  Currently this is 
     367     * only for display.  I believe SLIMPlotter lets you edit them. 
     368     * 
     369     * @return 
     370     */ 
    333371    private boolean showParamsDialog() { 
    334372        //TODO shouldn't UI be in separate class? 
     
    348386    } 
    349387 
    350     // based on loci.slim.SlimData constructor 
     388    /** 
     389     * Loads the data from the .sdt file. 
     390     * Based on loci.slim.SlimData constructor. 
     391     * 
     392     * @return whether or not successful 
     393     */ 
    351394    private boolean loadData() { 
    352395        boolean success = false; 
     
    393436    } 
    394437 
     438    /** 
     439     * This routine sums all of the photon data and creates a grayscale 
     440     * image for the data. 
     441     * 
     442     * @return 
     443     */ 
    395444    private boolean createGlobalGrayScale() { 
    396445        int[][] pixels = new int[m_width][m_height]; 
     
    426475    } 
    427476 
     477    /** 
     478     * This dialog box collects settings relating to the fit.  Pressing OK 
     479     * starts the fit, Cancel cancels the whole plugin. 
     480     * 
     481     * @return 
     482     */ 
    428483    private boolean showFitDialog() { 
    429484        NonBlockingGenericDialog dialog = new NonBlockingGenericDialog("Fit Type"); 
     
    434489        dialog.addChoice( 
    435490            "Algorithm", 
    436             new String[] { "Jaolho", /*"Akutan",*/ "old Barber RLD", "old Barber LMA", "Markwardt", "Barber NR RLD", "Barber NR LMA" }, 
     491            new String[] { "Jaolho", /*"Akutan",*/ "old Barber RLD", "old Barber LMA", "Markwardt", "Barber NR RLD", "Barber NR LMA", "SLIMCurve RLD", "SLIMCurve LMA" }, 
    437492            "Jaolho"); 
    438493        dialog.addChoice( 
     
    450505    } 
    451506 
     507    // The following was an attempt to drive the fitting process from the OK button on the 
     508    // Fit Dialog. 
    452509/*    private class MyDialogListener implements DialogListener { 
    453510        public boolean dialogItemChanged(GenericDialog dialog, AWTEvent e) { 
     
    477534    }*///TODO unfortunately NonBlockingGenericDialog doesn't call this for OK or Cancel button! 
    478535 
     536    /** 
     537     * This dialog box collects settings for the current fit. 
     538     * 
     539     * @return 
     540     */ 
    479541    private boolean showFitParamsDialog() { 
    480542        GenericDialog dialog = new GenericDialog("Fit Params"); 
     
    587649    } 
    588650 
     651    /** 
     652     * This routine does the fit, once all settings have 
     653     * been specified. 
     654     * 
     655     * Note that fitting each pixel is a special case, which is 
     656     * handled by fitEachPixel.  This routine therefore only 
     657     * handles fitting a single set of data from a single pixel 
     658     * or summed from all the pixels.  It can also sum the data 
     659     * and fit by ROI. 
     660     */ 
    589661    private void fitData() { 
    590662        if (m_region.EACH == m_region) { 
     
    761833            case BARBER2_LMA: 
    762834                curveFitter = new GrayNRCurveFitter(1); 
     835                break; 
     836            case SLIMCURVE_RLD: 
     837                curveFitter = new SLIMCurveFitter(0); 
     838                break; 
     839            case SLIMCURVE_LMA: 
     840                curveFitter = new SLIMCurveFitter(1); 
    763841                break; 
    764842        } 
     
    881959    int m_maxValue = -1; 
    882960 
     961    /** 
     962     * Fits each & every pixel in the image that is 
     963     * selected by fitThisPixel. 
     964     * 
     965     * Starts up a DataColorizer to show dynamically colorized 
     966     * lifetimes. 
     967     * 
     968     * Uses a ChunkyPixelEffectIterator to decide which pixel to 
     969     * fit next.  Batches up pixels and calls processPixels to 
     970     * do the fit. 
     971     */ 
    883972    private void fitEachPixel() { 
     973        long start = System.nanoTime(); 
     974 
    884975        // build the params 
    885976        double params[] = null; 
     
    9131004        } 
    9141005        //TODO problem: only use predetermined params for a fixed fit? 
    915          for (int i = 0; i < params.length; ++i) { 
    916              params[i] = 1.0; 
    917         } 
    918          params[0] = m_fitA1; 
    919          params[1] = m_fitT1; 
    920          params[2] = m_fitC; 
     1006        for (int i = 0; i < params.length; ++i) { 
     1007            params[i] = 1.0; 
     1008        } 
     1009        params[0] = m_fitA1; 
     1010        params[1] = m_fitT1; 
     1011        params[2] = m_fitC; 
    9211012 
    9221013        // show colorized lifetimes 
     
    9691060            processPixels(dataColorizer, m_height, curveFitDataList.toArray(new ICurveFitData[0]), pixelList.toArray(new ChunkyPixel[0])); 
    9701061        } 
    971         System.out.println("m_maxX, " + m_maxX + " m_maxY " + m_maxY + " m_maxVaue " + m_maxValue); 
    972     } 
    973  
    974 //    void processPixels(ImagePlus imagePlus, ImageProcessor imageProcessor, ICurveFitData data[], ChunkyPixel pixels[]) { 
     1062        long elapsed = System.nanoTime() - start; 
     1063        System.out.println("m_maxX, " + m_maxX + " m_maxY " + m_maxY + " m_maxVaue " + m_maxValue + " nanoseconds " + elapsed); 
     1064    } 
     1065 
     1066    /** 
     1067     * Processes (fits) a batch of pixels. 
     1068     * 
     1069     * @param dataColorizer automatically sets colorization range and updates colorized image 
     1070     * @param height passed in to fix a vertical orientation problem 
     1071     * @param data list of data corresponding to pixels to be fitted 
     1072     * @param pixels parallel list of rectangles with which to draw the fitted pixel 
     1073     */ 
    9751074    void processPixels(DataColorizer dataColorizer, int height, ICurveFitData data[], ChunkyPixel pixels[]) { 
    9761075        // do the fit 
     
    9991098                curveFitter = new GrayNRCurveFitter(1); 
    10001099                break; 
     1100            case SLIMCURVE_RLD: 
     1101                curveFitter = new SLIMCurveFitter(0); 
     1102                break; 
     1103            case SLIMCURVE_LMA: 
     1104                curveFitter = new SLIMCurveFitter(1); 
     1105                break; 
    10011106        } 
    10021107        curveFitter.setXInc(m_timeRange); 
     
    10051110        curveFitter.fitData(data, startBin, m_stopBin); 
    10061111 
    1007         // draw as you go 
     1112        // draw as you go; 'chunky' pixels get smaller as the overall fit progresses 
    10081113        for (int i = 0; i < pixels.length; ++i) { 
    10091114            ChunkyPixel pixel = pixels[i]; 
     
    10291134            for (int x = pixel.getX(); x < pixel.getX() + pixel.getWidth(); ++x) { 
    10301135                for (int y = pixel.getY(); y < pixel.getY() + pixel.getHeight(); ++y) { 
    1031                     if (fitThisPixel(x, y)) { //TODO WAS if (isIncluded(x, y))  { 
    1032                         //imageProcessor.drawPixel(x, height - y - 1); 
     1136                    if (fitThisPixel(x, y)) { 
     1137                        // (flip vertically) 
    10331138                        dataColorizer.setData(firstTime, x, height - y - 1 , lifetime); 
    10341139                        firstTime = false; 
     
    10401145    } 
    10411146 
     1147    /** 
     1148     * Checks criterion for whether this pixel needs to get fitted or drawn. 
     1149     * 
     1150     * @param x 
     1151     * @param y 
     1152     * @return whether to include or ignore this pixel 
     1153     */ 
    10421154    boolean fitThisPixel(int x, int y) { 
    1043         if (m_threshold <= m_grayscaleImageProcessor.getPixel(x,m_height - y - 1)) { 
     1155        if (m_threshold <= m_grayscaleImageProcessor.getPixel(x, m_height - y - 1)) { 
    10441156            if (m_grayscaleImageProcessor.getPixel(x, m_height - y - 1) > m_maxValue) { 
    10451157                m_maxValue = m_grayscaleImageProcessor.getPixel(x, m_height - y - 1); 
     
    10501162        } 
    10511163        else { 
    1052             // System.out.println("dont fit " + m_grayscaleImageProcessor.getPixel(x, y) + " x " + x + " y " + y); 
    10531164            return false; 
    10541165        } 
    10551166    } 
     1167 
     1168    /** 
     1169     * Checks whether a given pixel is included in ROIs.  If no ROIs are 
     1170     * selected then all pixels are included. 
     1171     * 
     1172     * @param x 
     1173     * @param y 
     1174     * @return whether or not included in ROIs 
     1175     */ 
    10561176 
    10571177    boolean isIncluded(int x, int y) { 
     
    10701190    } 
    10711191 
     1192    /** 
     1193     * Gets a list of ROIs (may be empty). 
     1194     * 
     1195     * @return array of ROIs. 
     1196     */ 
    10721197    private Roi[] getRois() { 
    10731198        Roi[] rois = {}; 
     
    10791204    } 
    10801205 
    1081     private Color lifetimeColorMap(double max, double lifetime) { 
     1206    /** 
     1207     * Colorizes a given lifetime value. 
     1208     * 
     1209     * Note this is much cruder than the DataColorizer that is 
     1210     * used in fitEachPixel. 
     1211     * 
     1212     * @param max 
     1213     * @param lifetime 
     1214     * @return 
     1215     */ 
     1216 
     1217     private Color lifetimeColorMap(double max, double lifetime) { 
    10821218        Color returnColor = Color.BLACK; 
    10831219        if (lifetime > 0.0) { 
     
    10931229    } 
    10941230 
     1231     /** 
     1232      * Interpolates between two colors based on a blend factor. 
     1233      * 
     1234      * @param start color 
     1235      * @param end color 
     1236      * @param blend factor 
     1237      * @return interpolated color 
     1238      */ 
    10951239    private Color interpolateColor(Color start, Color end, double blend) { 
    10961240        int startRed   = start.getRed(); 
     
    11061250    } 
    11071251 
     1252    /** 
     1253     * Interpolates a single RGB component between two values based on 
     1254     * a blend factor. 
     1255     * 
     1256     * @param start component value 
     1257     * @param end component value 
     1258     * @param blend factor 
     1259     * @return interpolated component value 
     1260     */ 
    11081261    private int interpolateColorComponent(int start, int end, double blend) { 
    11091262        return (int)(blend * (end - start) + start); 
Note: See TracChangeset for help on using the changeset viewer.