Changeset 7658 for trunk/projects


Ignore:
Timestamp:
03/17/11 20:48:54 (9 years ago)
Author:
aivar
Message:

Fixed various bugs. Made export to text better.

Location:
trunk/projects/slim-plugin/src/main/java/loci/slim
Files:
6 edited

Legend:

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

    r7650 r7658  
    289289                            uiPanel.setX(x); 
    290290                            uiPanel.setY(y); 
     291                            getFitSettings(m_grayScaleImage, uiPanel); 
    291292                            // fit on the pixel clicked 
    292293                            fitPixel(uiPanel, x, y); 
     
    384385    private boolean getImageInfo(Image<T> image) { 
    385386        System.out.println("Image is " + image); 
    386         int[] dimensions = image.getDimensions(); 
    387         System.out.println("dimensions size is " + dimensions.length); 
     387        int[] dimensions = new int[0]; 
     388        try { 
     389            dimensions = image.getDimensions(); 
     390            System.out.println("dimensions size is " + dimensions.length); 
     391        } 
     392        catch (NullPointerException e) { 
     393            System.out.println("image.getDimensions throws NullPointerException " + e.getMessage()); 
     394            System.out.println("can't detect channels"); 
     395        } 
    388396        Integer xIndex, yIndex, lifetimeIndex, channelIndex; 
    389397        m_width = OldImageUtils.getWidth(image); 
     
    537545     */ 
    538546    private void fitData(IUserInterfacePanel uiPanel) { 
     547        Image<DoubleType> fittedImage = null; 
    539548        // only one fit at a time 
    540549        synchronized (m_synchFit) { 
     
    542551                case SUMMED: 
    543552                    // sum all pixels 
    544                     fitSummed(uiPanel); 
     553                    fittedImage = fitSummed(uiPanel); 
    545554                    break; 
    546555                case ROI: 
    547556                    // fit summed ROIs 
    548                     fitROIs(uiPanel); 
     557                    fittedImage = fitROIs(uiPanel); 
    549558                    break; 
    550559                case POINT: 
    551560                    // fit single pixel 
    552                     fitPixel(uiPanel, m_x, m_y); 
     561                    fittedImage = fitPixel(uiPanel, m_x, m_y); 
    553562                    break; 
    554563                case EACH: 
    555564                    // fit every pixel 
    556                     fitEachPixel(uiPanel); 
     565                    fittedImage = fitEachPixel(uiPanel); 
    557566                    break; 
    558567            } 
    559568        } 
    560         m_analysis.doAnalysis(uiPanel.getAnalysis(), m_fittedImage, uiPanel.getRegion(), uiPanel.getFunction()); //TODO get from uiPanel or get from global?  re-evaluate approach here 
     569        if (null != fittedImage) { 
     570            for (String analysis : uiPanel.getAnalysisList()) { 
     571                m_analysis.doAnalysis(analysis, fittedImage, uiPanel.getRegion(), uiPanel.getFunction()); //TODO get from uiPanel or get from global?  re-evaluate approach here 
     572            } 
     573        } 
    561574    } 
    562575 
     
    564577     * Sums all pixels and fits the result. 
    565578     */ 
    566     private void fitSummed(IUserInterfacePanel uiPanel) { 
     579    private Image<DoubleType> fitSummed(IUserInterfacePanel uiPanel) { 
    567580        double params[] = uiPanel.getParameters(); //TODO go cumulative 
    568581         
     
    622635        showDecayGraph("Summed ", uiPanel, dataArray, 0); 
    623636        uiPanel.setParameters(dataArray[0].getParams()); 
     637        return null; 
    624638    } 
    625639 
     
    627641     * Sums and fits each ROI. 
    628642     */ 
    629     private void fitROIs(IUserInterfacePanel uiPanel) { 
     643    private Image<DoubleType> fitROIs(IUserInterfacePanel uiPanel) { 
    630644        double params[] = uiPanel.getParameters(); 
    631645         
     
    708722        // update UI parameters 
    709723        uiPanel.setParameters(dataArray[0].getParams()); //TODO, just picked first ROI here! 
     724        return null; 
    710725    } 
    711726 
     
    716731     * @param y 
    717732     */ 
    718     private void fitPixel(IUserInterfacePanel uiPanel, int x, int y) { 
    719         double params[] = uiPanel.getParameters(); 
    720          
     733    private Image<DoubleType> fitPixel(IUserInterfacePanel uiPanel, int x, int y) { 
     734        Image<DoubleType> fittedPixels = null; 
     735 
    721736        // build the data 
    722737        ArrayList<ICurveFitData> curveFitDataList = new ArrayList<ICurveFitData>(); 
     738        double params[] = uiPanel.getParameters(); //TODO NO NO NO 
    723739        ICurveFitData curveFitData; 
    724740        double yCount[]; 
    725741        double yFitted[]; 
    726          
    727         curveFitData = new CurveFitData(); 
    728         curveFitData.setParams(params); 
    729         yCount = new double[m_timeBins]; 
    730         for (int b = 0; b < m_timeBins; ++b) { 
    731             yCount[b] = getData(m_cursor, m_channel, x, y, b); 
    732         } 
    733         curveFitData.setYCount(yCount); 
    734         yFitted = new double[m_timeBins]; 
    735         curveFitData.setYFitted(yFitted); 
    736         curveFitDataList.add(curveFitData); 
     742        for (int channel : getChannelIndices(m_channel, m_channels)) { 
     743            curveFitData = new CurveFitData(); 
     744            curveFitData.setParams(params); //TODO NO NO NO s/b either from UI or fitted point or fitted whole image 
     745            yCount = new double[m_timeBins]; 
     746            for (int b = 0; b < m_timeBins; ++b) { 
     747                yCount[b] = getData(m_cursor, channel, x, y, b); 
     748            } 
     749            curveFitData.setYCount(yCount); 
     750            yFitted = new double[m_timeBins]; 
     751            curveFitData.setYFitted(yFitted); 
     752            int nominalChannel = (-1 == m_channel) ? channel : 1; 
     753            curveFitData.setChannel(nominalChannel); 
     754            curveFitData.setX(0); 
     755            curveFitData.setY(0); 
     756            curveFitDataList.add(curveFitData); 
     757        } 
    737758         
    738759        // do the fit 
    739760        ICurveFitData dataArray[] = curveFitDataList.toArray(new ICurveFitData[0]); 
    740761        getCurveFitter(uiPanel).fitData(dataArray, m_startBin, m_stopBin); 
    741          
     762 
     763        // show decay graph for visible channel //TODO need m_visibleChannel or the like         
    742764        showDecayGraph("Pixel " + x + " " + y, uiPanel, dataArray, 0); 
    743765 
    744766        // update UI parameters 
    745767        uiPanel.setParameters(dataArray[0].getParams()); 
     768         
     769        // get the results 
     770        int channels = (-1 == m_channel) ? m_channels : 1; 
     771        //fittedPixels = makeImage(channels, 1, 1, uiPanel.getParameterCount()); //TODO ImgLib bug if you use 1, 1, 1, 4; see "imglibBug()" below. 
     772        fittedPixels = makeImage(channels + 1, 2, 2, uiPanel.getParameterCount()); //TODO this is a workaround; unused pixels will remain NaNs 
     773 
     774        LocalizableByDimCursor<DoubleType> resultsCursor = fittedPixels.createLocalizableByDimCursor();                
     775        setFittedParamsFromData(resultsCursor, dataArray); 
     776        return fittedPixels; 
     777    } 
     778 
     779    private void imglibBug() { 
     780        int dim[] = { 1, 1, 1, 4 }; 
     781        Image<DoubleType> image = new ImageFactory<DoubleType>(new DoubleType(), new PlanarContainerFactory()).createImage(dim, "Test"); 
     782 
     783        // initialize image 
     784        Cursor<DoubleType> cursor = image.createCursor(); 
     785        while (cursor.hasNext()) { 
     786            System.out.println("fwd"); 
     787            cursor.fwd(); 
     788            cursor.getType().set(Double.NaN); 
     789        } 
    746790    } 
    747791  
     
    753797     * Results of the fit go to VisAD for analysis. 
    754798     */ 
    755     private void fitEachPixel(IUserInterfacePanel uiPanel) { 
     799    private Image<DoubleType> fitEachPixel(IUserInterfacePanel uiPanel) { 
    756800        long start = System.nanoTime(); 
    757801        int pixelCount = 0; 
     
    773817            // can't use previous results 
    774818            useFittedParams = false; 
    775             int channels = m_channels; 
    776819            m_fittedParameterCount = uiPanel.getParameterCount(); 
    777             m_fittedImage = makeImage(channels, m_width, m_height, m_fittedParameterCount); 
     820            m_fittedImage = makeImage(m_channels, m_width, m_height, m_fittedParameterCount); 
    778821        } 
    779822        else { 
     
    802845                    dataColorizer.quit(); 
    803846                    cancelImageFit(); 
    804                     return; 
     847                    return null; 
    805848                } 
    806849                IJ.showProgress(++pixelCount, totalPixelCount); 
     
    851894           // dataColorizer.quit(); //TODO no longer visible in this code 
    852895            cancelImageFit(); 
    853             return; 
     896            return null; 
    854897        } 
    855898  
     
    884927                    if (m_cancel) { 
    885928                        cancelImageFit(); 
    886                         return; 
     929                        return null; 
    887930                    } 
    888931                } 
     
    909952        long elapsed = System.nanoTime() - start; 
    910953        System.out.println("nanoseconds " + elapsed); 
     954 
     955        return m_fittedImage; 
     956    } 
     957 
     958    /** 
     959     * Gets an array of channel indices to iterate over. 
     960     * 
     961     * @param channel selected channel, or -1 for all channels 
     962     * @param channels number of channels 
     963     * @return 
     964     */ 
     965    private int[] getChannelIndices(int channel, int channels) { 
     966        if (-1 == channel) { 
     967            int[] channelIndices = new int[channels]; 
     968            for (int c = 0; c < channels; ++c) { 
     969                channelIndices[c] = c; 
     970            } 
     971            return channelIndices; 
     972        } 
     973        else { 
     974            return new int[] { channel }; 
     975        } 
    911976    } 
    912977 
     
    9791044        Image<DoubleType> image = null; 
    9801045 
     1046        System.out.println("channels width height params " + channels + " " + width + " " + height + " " + parameters); 
     1047         
    9811048        // create image object 
    9821049        int dim[] = { width, height, channels, parameters }; //TODO when we keep chi square in image  ++parameters }; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/SLIMAnalysis.java

    r7296 r7658  
    2626 */ 
    2727public class SLIMAnalysis { 
    28     public static final String NONE = "None"; 
    2928    IndexItem<SLIMAnalyzer, ISLIMAnalyzer> m_plugins[]; 
    3029    String m_names[]; 
     
    3433        List<String> names = new ArrayList<String>(); 
    3534        List<IndexItem> plugins = new ArrayList<IndexItem>(); 
    36         names.add(NONE); 
    37         plugins.add(null); 
    3835 
    3936        // look for matches 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/plugins/Display.java

    r7651 r7658  
    6767@SLIMAnalyzer(name="Display Fit Results") 
    6868public class Display implements ISLIMAnalyzer { 
     69    // for accessing fit data 
     70    private static final int X_INDEX = 0; 
     71    private static final int Y_INDEX = 1; 
     72    private static final int C_INDEX = 2; 
     73    private static final int P_INDEX = 3; 
     74 
     75    // for defining display formulas 
    6976    private static final int X2_INDEX = 0; 
    7077    private static final int Z_INDEX = 1; 
     
    212219        // look at image dimensions 
    213220        int dimensions[] = image.getDimensions(); 
    214         //TODO for debugging only 
    215         for (int i = 0; i < dimensions.length; ++i) { 
    216             System.out.println("dim " + i + " " + dimensions[i]); 
    217         } 
    218         int xIndex = 0; 
    219         int yIndex = 1; 
    220         int cIndex = 2; 
    221         int pIndex = 3; 
    222         int width    = dimensions[xIndex]; 
    223         int height   = dimensions[yIndex]; 
    224         int channels = dimensions[cIndex]; 
    225         int params   = dimensions[pIndex]; 
     221        int width    = dimensions[X_INDEX]; 
     222        int height   = dimensions[Y_INDEX]; 
     223        int channels = dimensions[C_INDEX]; 
     224        int params   = dimensions[P_INDEX]; 
    226225 
    227226        // allow user to select formula to display 
     
    270269        // get the parameters for each pixel, 
    271270        for (int c = 0; c < channels; ++c) { 
    272             dimForCursor[cIndex] = c; 
     271            dimForCursor[C_INDEX] = c; 
    273272 
    274273            for (int y = 0; y < height; ++y) { 
    275                 dimForCursor[yIndex] = y; 
     274                dimForCursor[Y_INDEX] = y; 
    276275 
    277276                for (int x = 0; x < width; ++x) { 
    278                     dimForCursor[xIndex] = x; 
     277                    dimForCursor[X_INDEX] = x; 
    279278 
    280279                    // get the fitted parameters for c, y, x 
    281280                    for (int p = 0; p < params; ++p) { 
    282                         dimForCursor[pIndex] = p; 
     281                        dimForCursor[P_INDEX] = p; 
    283282 
    284283                        // get the fitted parameter 
     
    611610         */ 
    612611        private void calculate(int x, int y, double[] parameters) { 
     612            //TODO this only works because m_min value is currently displayed as 
     613            // black.  It should be displayed as lowest color of color range. 
     614            // There needs to be another mechanism to signal this pixel s/b 
     615            // displayed as black (wasn't fit). 
    613616            double result = 0.0; 
    614617            int indices[] = m_formula.getIndices(); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/analysis/plugins/ExportToText.java

    r7652 r7658  
    1313import java.io.FileWriter; 
    1414import java.io.IOException; 
     15import java.math.BigDecimal; 
     16import java.math.MathContext; 
     17import java.math.RoundingMode; 
    1518import java.util.prefs.*; 
    1619 
     
    2023import loci.slim.ui.IUserInterfacePanel.FitRegion; 
    2124 
     25import mpicbg.imglib.cursor.LocalizableByDimCursor; 
    2226import mpicbg.imglib.image.Image; 
     27import mpicbg.imglib.type.numeric.RealType; 
    2328import mpicbg.imglib.type.numeric.real.DoubleType; 
    2429 
     
    3136public class ExportToText implements ISLIMAnalyzer { 
    3237    private static final String FILE_KEY = "export_results_to_text"; 
     38    private static final int X_INDEX = 0; 
     39    private static final int Y_INDEX = 1; 
     40    private static final int C_INDEX = 2; 
     41    private static final int P_INDEX = 3; 
     42    private static final char TAB = '\t'; 
     43    private static final char EOL = '\n'; 
     44    private FileWriter m_fileWriter = null; 
     45    private MathContext m_context = new MathContext(4, RoundingMode.FLOOR); 
    3346 
    3447    public void analyze(Image<DoubleType> image, FitRegion region, FitFunction function) { 
     
    3952        } 
    4053    } 
     54 
     55    public static enum xFitRegion { 
     56        SUMMED, ROI, POINT, EACH 
     57    } 
     58 
     59    public static enum xFitAlgorithm { //TODO not really algorithm, usu. LMA 
     60       JAOLHO, /*AKUTAN,*/ BARBER_RLD, BARBER_LMA, MARKWARDT, BARBER2_RLD, BARBER2_LMA, SLIMCURVE_RLD, SLIMCURVE_LMA, SLIMCURVE_RLD_LMA 
     61    } 
     62 
     63    public static enum xFitFunction { 
     64        SINGLE_EXPONENTIAL, DOUBLE_EXPONENTIAL, TRIPLE_EXPONENTIAL, STRETCHED_EXPONENTIAL 
     65    } 
     66 
    4167 
    4268    public void export(String fileName, Image<DoubleType> image, FitRegion region, FitFunction function) { 
     
    5076        } 
    5177 
    52         FileWriter fileWriter = null; 
    5378        try { 
    54             fileWriter = new FileWriter(fileName); 
     79            m_fileWriter = new FileWriter(fileName); 
    5580        } catch (IOException e) { 
    5681            IJ.log("exception opening file " + fileName); 
     
    5883        } 
    5984 
    60         if (null != fileWriter) { 
    61             try 
    62             { 
    63  
    64                 if (hasRois) { 
    65                     fileWriter.write("x\ty\tROI\t"); 
     85        if (null != m_fileWriter) { 
     86            try { 
     87                // look at image dimensions 
     88                int dimensions[] = image.getDimensions(); 
     89                int width    = dimensions[X_INDEX]; 
     90                int height   = dimensions[Y_INDEX]; 
     91                int channels = dimensions[C_INDEX]; 
     92                int params   = dimensions[P_INDEX]; 
     93 
     94                // write headers 
     95                if (channels > 1) { 
     96                    writeChannelHeader(); 
    6697                } 
    67                 fileWriter.write("HELLO WORLD"); 
    68                 //Write the header 
    69                 fileWriter.write("x\ty\tROI\tIntensity\n"); 
    70  
    71                // for(int x = 0; x < imp.getWidth(); x++) 
    72               //  { 
    73                //     for(int y = 0; y < imp.getHeight(); y++) 
    74               //      { 
    75                       //  fw.write( x  + "\t" + y + "\t" + lookUpRoi(x, y) + "\t" + getPixel(floatType, ip, x, y)  + "\n" ); 
    76                 //    } 
    77              //   } 
    78                 fileWriter.close(); 
     98                switch (region) { 
     99                    case SUMMED: 
     100                    case POINT: 
     101                        writeHeader(function); 
     102                        break; 
     103                    case ROI: 
     104                        writeROIsHeader(); 
     105                        writeHeader(function); 
     106                        break; 
     107                    case EACH: 
     108                        writeXYHeader(); 
     109                        writeHeader(function); 
     110                        break; 
     111                } 
     112 
     113                // traverse the image 
     114                final LocalizableByDimCursor<?> cursor = image.createLocalizableByDimCursor(); 
     115                int dimForCursor[] = new int[4]; 
     116                double paramArray[] = new double[params]; 
     117 
     118                // get the parameters for each pixel, 
     119                for (int c = 0; c < channels; ++c) { 
     120                    dimForCursor[C_INDEX] = c; 
     121 
     122                    for (int y = 0; y < height; ++y) { 
     123                        dimForCursor[Y_INDEX] = y; 
     124 
     125                        for (int x = 0; x < width; ++x) { 
     126                            dimForCursor[X_INDEX] = x; 
     127 
     128                            // get the fitted parameters for c, y, x 
     129                            for (int p = 0; p < params; ++p) { 
     130                                dimForCursor[P_INDEX] = p; 
     131 
     132                                // get the fitted parameter 
     133                                cursor.moveTo(dimForCursor); 
     134                                paramArray[p] = ((RealType) cursor.getType()).getRealFloat(); 
     135                            } 
     136 
     137                            // if point has been fitted 
     138                            //TODO distinguish between not fitted and error in fit! 
     139                            if (!Double.isNaN(paramArray[0])) { 
     140                                if (channels > 1) { 
     141                                    writeChannel(c + 1); 
     142                                } 
     143 
     144                                switch (region) { 
     145                                    case SUMMED: 
     146                                    case POINT: 
     147                                        writeParams(function, paramArray); 
     148                                        break; 
     149                                    case ROI: 
     150                                        writeROI(x + 1); 
     151                                        writeParams(function, paramArray); 
     152                                    case EACH: 
     153                                        writeXY(x, y); 
     154                                        writeParams(function, paramArray); 
     155                                        break; 
     156                                } 
     157                            } 
     158 
     159                        } // x loop 
     160 
     161                    } // y loop 
     162 
     163                } // c loop 
     164 
     165                m_fileWriter.close(); 
    79166            } 
    80             catch (IOException e) 
    81             { 
    82                 System.out.println("IOEXCEPTION " + e); 
     167            catch (IOException e) { 
     168                System.out.println("Error writing file " + e.getMessage()); 
    83169                IJ.log("exception writing file"); 
    84170                IJ.handleException(e); 
     
    87173    } 
    88174 
     175    private void writeChannelHeader() throws IOException { 
     176        m_fileWriter.write("c\t"); 
     177    } 
     178 
     179    private void writeChannel(int channel) throws IOException { 
     180        m_fileWriter.write(channel + TAB); 
     181    } 
     182 
     183    private void writeHeader(FitFunction function) throws IOException { 
     184        switch (function) { 
     185            case SINGLE_EXPONENTIAL: 
     186                m_fileWriter.write("A\tT\tZ\tX2\n"); 
     187                break; 
     188            case DOUBLE_EXPONENTIAL: 
     189                m_fileWriter.write("A1\tT1\rA2\tT2\tZ\tX2\n"); 
     190                break; 
     191            case TRIPLE_EXPONENTIAL: 
     192                m_fileWriter.write("A1\tT1\tA2\tT2\tA3\tT3\tZ\tX2\n"); 
     193                break; 
     194            case STRETCHED_EXPONENTIAL: 
     195                m_fileWriter.write("A\tT\tH\tZ\tX2\n"); 
     196                break; 
     197        } 
     198    } 
     199 
     200    private void writeParams(FitFunction function, double[] paramArray) throws IOException { 
     201        switch (function) { 
     202            case SINGLE_EXPONENTIAL: 
     203                m_fileWriter.write("" + 
     204                        showParameter(paramArray[2]) + TAB +  // A 
     205                        showParameter(paramArray[3]) + TAB +  // T 
     206                        showParameter(paramArray[1]) + TAB +  // Z 
     207                        showParameter(paramArray[0]) + EOL    // X2 
     208                        ); 
     209                break; 
     210            case DOUBLE_EXPONENTIAL: 
     211                m_fileWriter.write("" + 
     212                        showParameter(paramArray[2]) + TAB +  // A1 
     213                        showParameter(paramArray[3]) + TAB +  // T1 
     214                        showParameter(paramArray[4]) + TAB +  // A2 
     215                        showParameter(paramArray[5]) + TAB +  // T2 
     216                        showParameter(paramArray[1]) + TAB +  // Z 
     217                        showParameter(paramArray[0]) + EOL    // X2 
     218                        ); 
     219                break; 
     220            case TRIPLE_EXPONENTIAL: 
     221                m_fileWriter.write("" + 
     222                        showParameter(paramArray[2]) + TAB +  // A1 
     223                        showParameter(paramArray[3]) + TAB +  // T1 
     224                        showParameter(paramArray[4]) + TAB +  // A2 
     225                        showParameter(paramArray[5]) + TAB +  // T2 
     226                        showParameter(paramArray[6]) + TAB +  // A3 
     227                        showParameter(paramArray[7]) + TAB +  // T3 
     228                        showParameter(paramArray[1]) + TAB +  // Z 
     229                        showParameter(paramArray[0]) + EOL    // X2 
     230                        ); 
     231                break; 
     232            case STRETCHED_EXPONENTIAL: 
     233                m_fileWriter.write("" + 
     234                        showParameter(paramArray[2]) + TAB +  // A 
     235                        showParameter(paramArray[3]) + TAB +  // T 
     236                        showParameter(paramArray[4]) + TAB +  // H 
     237                        showParameter(paramArray[1]) + TAB +  // Z 
     238                        showParameter(paramArray[0]) + EOL    // X2 
     239                        ); 
     240                break; 
     241        } 
     242    } 
     243 
     244    private void writeROIsHeader() throws IOException { 
     245        m_fileWriter.write("roi\t"); 
     246    } 
     247 
     248    private void writeROI(int roi) throws IOException { 
     249        m_fileWriter.write(roi + '\t'); 
     250    } 
     251 
     252    private void writeXYHeader() throws IOException { 
     253        m_fileWriter.write("x\ty\t"); 
     254    } 
     255 
     256    private void writeXY(int x, int y) throws IOException { 
     257        m_fileWriter.write("" + x + '\t' + y + '\t'); 
     258    } 
    89259 
    90260    private String getFileFromPreferences() { 
     
    110280    } 
    111281 
    112     /** 
    113      * Returns Roi number of a given pixel. 
    114      * 
    115      * @param x pixel x 
    116      * @param y pixel y 
    117      * @return which Roi number, 0 for none 
    118      */ 
    119     private int lookUpRoi(Roi rois[], int x, int y) { 
    120         for (int i = 0; i < rois.length; ++i) { 
    121             if (rois[i].contains(x, y)) { 
    122                 return i + 1; 
    123             } 
    124         } 
    125         return 0; 
     282    private String showParameter(double parameter) { 
     283        return BigDecimal.valueOf(parameter).round(m_context).toEngineeringString(); 
    126284    } 
    127285} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanel.java

    r7653 r7658  
    9595 
    9696    /** 
    97      * Gets analysis plugin name. 
    98      * 
    99      * @return analysis plugin name 
    100      */ 
    101     public String getAnalysis(); 
     97     * Gets analysis plugin names. 
     98     * 
     99     * @return analysis plugin names 
     100     */ 
     101    public String[] getAnalysisList(); 
    102102 
    103103    /** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7654 r7658  
    4444import java.awt.event.ItemEvent; 
    4545import java.awt.event.ItemListener; 
     46import java.util.ArrayList; 
     47import java.util.List; 
    4648 
    4749import javax.swing.border.Border; 
     
    109111 
    110112    private static final String EXCITATION_NONE = "None"; 
    111     private static final String EXCITATION_FILE = "File"; 
     113    private static final String EXCITATION_FILE = "Load from File"; 
    112114    private static final String EXCITATION_CREATE = "Use current X Y"; 
    113115     
     
    138140    JComboBox m_algorithmComboBox; 
    139141    JComboBox m_functionComboBox; 
    140     JComboBox m_analysisComboBox; 
     142    JCheckBox[] m_analysisCheckBoxList; 
    141143    JCheckBox m_fitAllChannels; 
    142144 
     
    349351        fitPanel.add(m_functionComboBox); 
    350352 
    351         JLabel analysisLabel = new JLabel("Analysis"); 
    352         analysisLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
    353         fitPanel.add(analysisLabel); 
    354         m_analysisComboBox = new JComboBox(analysisChoices); 
    355         fitPanel.add(m_analysisComboBox); 
    356  
     353        int choices = analysisChoices.length; 
     354        if (choices > 0) { 
     355            List<JCheckBox> checkBoxList = new ArrayList<JCheckBox>(); 
     356            boolean firstChoice = true; 
     357            for (String analysisChoice : analysisChoices) { 
     358                String labelString = firstChoice ? "Analysis" : ""; 
     359                firstChoice = false; 
     360                JLabel choiceLabel = new JLabel(labelString); 
     361                choiceLabel.setHorizontalAlignment(SwingConstants.RIGHT); 
     362                fitPanel.add(choiceLabel); 
     363                JCheckBox checkBox = new JCheckBox(analysisChoice); 
     364                fitPanel.add(checkBox); 
     365                checkBoxList.add(checkBox); 
     366            } 
     367            m_analysisCheckBoxList = checkBoxList.toArray(new JCheckBox[0]); 
     368        } 
     369         
    357370        // rows, cols, initX, initY, xPad, yPad 
    358         SpringUtilities.makeCompactGrid(fitPanel, 4, 2, 4, 4, 4, 4); 
     371        SpringUtilities.makeCompactGrid(fitPanel, 3 + choices, 2, 4, 4, 4, 4); 
    359372 
    360373        JPanel panel = new JPanel(new BorderLayout()); 
     
    845858        m_algorithmComboBox.setEnabled(enable); 
    846859        m_functionComboBox.setEnabled(enable); 
    847         m_analysisComboBox.setEnabled(enable); 
     860        for (JCheckBox checkBox : m_analysisCheckBoxList) { 
     861            checkBox.setEnabled(enable); 
     862        } 
     863        //m_analysisComboBox.setEnabled(enable); 
    848864        m_fitAllChannels.setEnabled(enable); 
    849865 
     
    967983    } 
    968984 
    969     public String getAnalysis() { 
    970         String selected = (String) m_analysisComboBox.getSelectedItem(); 
    971         return selected; 
     985    public String[] getAnalysisList() { 
     986        List<String> analysisList = new ArrayList<String>(); 
     987        for (JCheckBox checkBox : m_analysisCheckBoxList) { 
     988            if (checkBox.isSelected()) { 
     989                analysisList.add(checkBox.getText()); 
     990            } 
     991        } 
     992        return analysisList.toArray(new String[0]); 
    972993    } 
    973994 
Note: See TracChangeset for help on using the changeset viewer.