Changeset 7294


Ignore:
Timestamp:
12/01/10 20:04:28 (9 years ago)
Author:
aivar
Message:

Added binning. Changed parameter order.

File:
1 edited

Legend:

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

    r7206 r7294  
    5858import loci.slim.ui.IStartStopListener; 
    5959import loci.slim.ui.IUserInterfacePanel; 
     60import loci.slim.ui.IUserInterfacePanel.FitAlgorithm; 
     61import loci.slim.ui.IUserInterfacePanel.FitFunction; 
     62import loci.slim.ui.IUserInterfacePanel.FitRegion; 
    6063import loci.slim.ui.IUserInterfacePanelListener; 
    6164import loci.slim.ui.UserInterfacePanel; 
     
    7174import loci.formats.IFormatReader; 
    7275import loci.slim.analysis.SLIMAnalysis; 
     76import loci.slim.binning.SLIMBinning; 
    7377 
    7478import mpicbg.imglib.container.planar.PlanarContainerFactory; 
     
    113117    private static final Character SUB_3  = '\u2083'; 
    114118 
    115     private static final double[] DEFAULT_SINGLE_EXP_PARAMS = { 100.0, 0.5, 0.5 }; 
    116     private static final double[] DEFAULT_DOUBLE_EXP_PARAMS = { 50.0, 0.5, 50, 0.25, 0.5 }; 
    117     private static final double[] DEFAULT_TRIPLE_EXP_PARAMS = { 40.0, 0.5, 30.0, 0.25, 30, 0.10, 0.5 }; 
    118     private static final double[] DEFAULT_STRETCH_EXP_PARAMS = { 100.0, 0.5, 0.5, 0.5 }; 
     119    private static final double[] DEFAULT_SINGLE_EXP_PARAMS  = { 0.0, 0.5, 100.0, 0.5 };                      // 0 C A T 
     120    private static final double[] DEFAULT_DOUBLE_EXP_PARAMS  = { 0.0, 0.5, 50.0, 0.5, 50, 0.25 };             // 0 C A1 T1 A2 T2 
     121    private static final double[] DEFAULT_TRIPLE_EXP_PARAMS  = { 0.0, 0.5, 40.0, 0.5, 30.0, 0.25, 30, 0.10 }; // 0 C A1 T1 A2 T2 A3 T3 
     122    private static final double[] DEFAULT_STRETCH_EXP_PARAMS = { 0.0, 0.5, 100.0, 0.5, 0.5 };                 // 0 C A T H 
    119123 
    120124    private Object m_synchFit = new Object(); 
     
    133137 
    134138    private Image<T> m_image; 
     139    private LocalizableByDimCursor<T> m_cursor; 
    135140 
    136141    // Actual data values, dimensioned [channel][row][column][bin] //TODO DEPRECATE 
    137     protected int[][][][] m_data; 
     142    protected int[][][][] Xm_data; 
    138143 
    139144    private ImageProcessor m_grayscaleImageProcessor; 
     
    145150 
    146151    // data parameters 
     152    private boolean m_hasChannels; 
    147153    private int m_channels; 
    148154    private int m_width; 
     
    160166    private int m_minWave, m_waveStep; //, m_maxWave; 
    161167 
    162     public enum FitRegion { 
    163         SUMMED, ROI, POINT, EACH 
    164     } 
    165  
    166     public enum FitAlgorithm { //TODO not really algorithm, usu. LMA 
    167        JAOLHO, /*AKUTAN,*/ BARBER_RLD, BARBER_LMA, MARKWARDT, BARBER2_RLD, BARBER2_LMA, SLIMCURVE_RLD, SLIMCURVE_LMA 
    168     } 
    169  
    170     public enum FitFunction { 
    171         SINGLE_EXPONENTIAL, DOUBLE_EXPONENTIAL, TRIPLE_EXPONENTIAL, STRETCHED_EXPONENTIAL 
    172     } 
    173  
    174168    private FitRegion m_region; 
    175169    private FitAlgorithm m_algorithm; 
     
    177171 
    178172    private SLIMAnalysis m_analysis; 
     173    private SLIMBinning m_binning; 
    179174 
    180175    private IGrayScaleImage m_grayScaleImage; 
     
    202197    public SLIMProcessor() { 
    203198        m_analysis = new SLIMAnalysis(); 
     199        m_binning = new SLIMBinning(); 
    204200        m_quit = false; 
    205201        m_cancel = false; 
     
    212208 
    213209        m_image = image; 
    214         if (newLoadData(image)) { 
     210        if (getImageInfo(image)) { 
    215211            // show the UI; do fits 
    216212            doFits(); 
     
    232228            else { 
    233229                m_image = loadImage(m_file); 
    234                 if (newLoadData(m_image)) { 
     230                if (getImageInfo(m_image)) { 
    235231                    saveFileInPreferences(m_file); 
    236232                    success = true; 
     
    257253    private void doFits() { 
    258254        // show the UI; do fits 
    259         final IUserInterfacePanel uiPanel = new UserInterfacePanel(USE_TAU, m_analysis); 
     255        final IUserInterfacePanel uiPanel = new UserInterfacePanel(USE_TAU, m_analysis.getChoices(), m_binning.getChoices()); 
    260256        uiPanel.setX(0); 
    261257        uiPanel.setY(0); 
     
    390386    } 
    391387    
    392     private boolean newLoadData(Image<T> image) { 
     388    private boolean getImageInfo(Image<T> image) { 
    393389        System.out.println("Image is " + image); 
    394390        int[] dimensions = image.getDimensions(); 
     
    400396        //TODO this is broken; returns 1 when there are 16 channels; corrected below 
    401397        System.out.println("ImageUtils.getNChannels returns " + m_channels); 
     398        m_hasChannels = false; 
    402399        if (dimensions.length > 3) { 
     400            m_hasChannels = true; 
    403401            m_channels = dimensions[3]; 
    404402        } 
    405403        System.out.println("corrected to " + m_channels); 
    406404        m_timeBins = ImageUtils.getDimSize(image, FormatTools.LIFETIME); 
    407         System.out.println("timeBins is " + m_timeBins); 
     405        System.out.println("width " + m_width + " height " + m_height + " timeBins " + m_timeBins + " channels " + m_channels); 
     406        m_cursor = image.createLocalizableByDimCursor(); 
     407        /* 
    408408        int index = 0; 
    409409        xIndex = index++; 
     
    417417        } 
    418418 
    419         System.out.println("width " + m_width + " height " + m_height + " timeBins " + m_timeBins + " channels " + m_channels); 
     419 
    420420        m_data = new int[m_channels][m_height][m_width][m_timeBins]; 
    421421        final LocalizableByDimCursor<T> cursor = image.createLocalizableByDimCursor(); 
     
    438438            } 
    439439        } 
    440         cursor.close(); 
     440        cursor.close();*/ 
    441441        // print out some useful information about the image 
    442442        //System.out.println(image); 
     
    459459        // patch things up 
    460460        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. 
     461                   //TODO the patch above worked when I was also dividing the photon count by 10.0f!!  should be 1/64? 
    461462        m_minWave = 400; 
    462463        m_waveStep = 10; 
     
    465466    } 
    466467 
     468    private boolean fakeData() { 
     469        return true; 
     470    } 
    467471    /** 
    468472     * This routine creates an artificial set of data that is useful to test fitting. 
     
    470474     * @return whether successful 
    471475     */ 
    472     private boolean fakeData() { 
     476   /* private boolean fakeData() { 
    473477        m_width = 50; 
    474478        m_height = 50; 
     
    511515        return true; 
    512516    } 
     517    */ 
    513518 
    514519    /** 
     
    587592                    for (int x = 0; x < m_width; ++x) { 
    588593                        for (int b = 0; b < m_timeBins; ++b) { 
    589                             yCount[b] += m_data[channel][y][x][b]; 
    590                             photons += m_data[channel][y][x][b]; 
     594                            double count = getData(m_cursor, channel, x, y, b); 
     595                            yCount[b] += count; 
     596                            photons += (int) count; 
    591597                        } 
    592598                    } 
     
    599605                for (int x = 0; x < m_width; ++x) { 
    600606                    for (int b = 0; b < m_timeBins; ++b) { 
    601                         yCount[b] += m_data[m_channel][y][x][b]; 
    602                         photons += m_data[m_channel][y][x][b]; 
     607                        double count = getData(m_cursor, m_channel, x, y, b); 
     608                        yCount[b] += count; 
     609                        photons += (int) count; 
    603610                    } 
    604611                } 
     
    619626        showDecayGraph(uiPanel, dataArray); 
    620627        uiPanel.setParameters(dataArray[0].getParams()); 
    621         uiPanel.setChiSquare(dataArray[0].getChiSquare()); 
    622628    } 
    623629 
     
    649655                        System.out.println("roi " + roiNumber + " x " + x + " Y " + y); 
    650656                        for (int b = 0; b < m_timeBins; ++b) { 
    651                            yCount[b] += m_data[m_channel][y][x][b]; 
     657                            yCount[b] += getData(m_cursor, m_channel, x, y, b); 
    652658                        } 
    653659                    } 
     
    686692 
    687693        // update UI parameters 
    688         uiPanel.setParameters(dataArray[0].getParams()); 
    689         uiPanel.setChiSquare(dataArray[0].getChiSquare()); //TODO what is the validity here of just choosing the first ROI?  How do we report multiple ROIs? 
     694        uiPanel.setParameters(dataArray[0].getParams()); //TODO, just picked first ROI here! 
    690695    } 
    691696 
     
    709714        yCount = new double[m_timeBins]; 
    710715        for (int b = 0; b < m_timeBins; ++b) { 
    711             yCount[b] = m_data[m_channel][m_height - y - 1][x][b]; 
    712             //System.out.println("" + b + " " + yCount[b]); 
     716            yCount[b] = getData(m_cursor, m_channel, x, m_height - y - 1, b); 
    713717        } 
    714718        curveFitData.setYCount(yCount); 
     
    725729        // update UI parameters 
    726730        uiPanel.setParameters(dataArray[0].getParams()); 
    727         uiPanel.setChiSquare(dataArray[0].getChiSquare()); 
    728731    } 
    729732  
     
    741744        int pixelsToProcessCount = 0; 
    742745 
     746        Image<T> workImage = m_image; 
     747        if (!SLIMBinning.NONE.equals(uiPanel.getBinning())) { 
     748            workImage = m_binning.doBinning(uiPanel.getBinning(),  m_image); 
     749        } 
     750        LocalizableByDimCursor<T> pixelCursor = workImage.createLocalizableByDimCursor(); 
     751 
    743752        ICurveFitter curveFitter = getCurveFitter(uiPanel);      
    744753        double params[] = uiPanel.getParameters(); 
    745754 
    746755        boolean useFittedParams; 
    747         LocalizableByDimCursor<DoubleType> cursor = null; 
     756        LocalizableByDimCursor<DoubleType> resultsCursor = null; 
    748757        if (null == m_fittedImage || uiPanel.getParameterCount() != m_fittedParameterCount) { 
    749758            // can't use previous results 
     
    757766            useFittedParams = uiPanel.refineFit(); 
    758767        } 
    759         cursor = m_fittedImage.createLocalizableByDimCursor(); 
     768        resultsCursor = m_fittedImage.createLocalizableByDimCursor(); 
    760769         
    761770        // build the data 
     
    765774        double yCount[]; 
    766775        double yFitted[]; 
    767  
    768     System.out.println("m_channel is " + m_channel); 
    769776 
    770777        // special handling for visible channel 
     
    791798                    curveFitData.setParams( 
    792799                            useFittedParams ? 
    793                                 getFittedParams(cursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
     800                                getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
    794801                                params.clone()); 
    795802                    yCount = new double[m_timeBins]; 
    796803                    for (int b = 0; b < m_timeBins; ++b) { 
    797                         yCount[b] = m_data[m_channel][pixel.getY()][pixel.getX()][b]; 
     804                        yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
    798805                    } 
    799806                    curveFitData.setYCount(yCount); 
     
    809816                        curveFitDataList.clear(); 
    810817                        curveFitter.fitData(data, m_startBin, m_stopBin); 
    811                         setFittedParamsFromData(cursor, data); 
     818                        setFittedParamsFromData(resultsCursor, data); 
    812819                        colorizePixels(dataColorizer, m_height, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
    813820                        pixelList.clear(); 
     
    821828                curveFitDataList.clear(); 
    822829                curveFitter.fitData(data, m_startBin, m_stopBin); 
    823                 setFittedParamsFromData(cursor, data); 
     830                setFittedParamsFromData(resultsCursor, data); 
    824831                colorizePixels(dataColorizer, m_height, m_channel, data, pixelList.toArray(new ChunkyPixel[0])); 
    825832            } 
     
    848855                         curveFitData.setParams( 
    849856                             useFittedParams ? 
    850                                  getFittedParams(cursor, channel, x, y, m_fittedParameterCount) : 
     857                                 getFittedParams(resultsCursor, channel, x, y, m_fittedParameterCount) : 
    851858                                 params.clone()); 
    852859                         yCount = new double[m_timeBins]; 
    853860                         for (int b = 0; b < m_timeBins; ++b) { 
    854                              yCount[b] = m_data[channel][y][x][b]; 
     861                             yCount[b] = getData(pixelCursor, channel, x, y, b); //binnedData[channel][y][x][b]; 
    855862                         } 
    856863                         curveFitData.setYCount(yCount); 
     
    871878                    curveFitDataList.clear(); 
    872879                    curveFitter.fitData(data, m_startBin, m_stopBin); 
    873                     setFittedParamsFromData(cursor, data); 
     880                    setFittedParamsFromData(resultsCursor, data); 
    874881                } 
    875882            } 
     
    879886            ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
    880887            curveFitter.fitData(data, m_startBin, m_stopBin); 
    881             setFittedParamsFromData(cursor, data); 
     888            setFittedParamsFromData(resultsCursor, data); 
    882889        } 
    883890 
     
    932939        } 
    933940        return returnValue; 
     941    } 
     942 
     943    private double getData(LocalizableByDimCursor<T> cursor, int channel, int x, int y, int bin) { 
     944        int dim[]; 
     945        if (m_hasChannels) { 
     946            dim = new int[] { x, y, bin, channel }; 
     947        } 
     948        else { 
     949            dim = new int[] { x, y, bin }; 
     950        } 
     951        cursor.moveTo(dim); 
     952        return cursor.getType().getRealFloat(); 
    934953    } 
    935954 
     
    11991218                break; 
    12001219            case SLIMCURVE_RLD: 
    1201                 curveFitter = new SLIMCurveFitter(0); 
     1220                curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.RLD); 
    12021221                break; 
    12031222            case SLIMCURVE_LMA: 
    1204                 curveFitter = new SLIMCurveFitter(1); 
     1223                curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.LMA); 
    12051224                break; 
    12061225        } 
     1226        ICurveFitter.FitFunction fitFunction = null; 
     1227        switch (uiPanel.getFunction()) { 
     1228            case SINGLE_EXPONENTIAL: 
     1229                fitFunction = ICurveFitter.FitFunction.SINGLE_EXPONENTIAL; 
     1230                break; 
     1231            case DOUBLE_EXPONENTIAL: 
     1232                fitFunction = ICurveFitter.FitFunction.DOUBLE_EXPONENTIAL; 
     1233                break; 
     1234            case TRIPLE_EXPONENTIAL: 
     1235                fitFunction = ICurveFitter.FitFunction.TRIPLE_EXPONENTIAL; 
     1236                break; 
     1237            case STRETCHED_EXPONENTIAL: 
     1238                fitFunction = ICurveFitter.FitFunction.STRETCHED_EXPONENTIAL; 
     1239                break; 
     1240        } 
     1241        curveFitter.setFitFunction(fitFunction); 
    12071242        curveFitter.setXInc(m_timeRange); 
    12081243        curveFitter.setFree(uiPanel.getFree()); 
Note: See TracChangeset for help on using the changeset viewer.