Ignore:
Timestamp:
03/23/11 20:28:55 (9 years ago)
Author:
aivar
Message:

Moved loading an Excitation and setting up the ExcitationPanel to SLIMProcessor.

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

Legend:

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

    r7668 r7671  
    5353    public static float[] estimateExcitationCursors(float[] excitation) { 
    5454        float baseline; 
     55        float maxval; 
     56        int index; 
    5557        int startp = 0; 
    5658        int endp = 0; 
     59        int i; 
    5760        float[] diffed = new float[excitation.length]; 
    5861        int steepp; 
    5962 
    6063        // "Estimate prompt baseline; very rough and ready" 
    61         int index = findMax(excitation); 
    62         float maxval = excitation[index]; 
     64        index = findMax(excitation); 
     65        maxval = excitation[index]; 
    6366 
    6467        if (index > excitation.length * 3 /4) { // "integer arithmetic" 
     
    6871            baseline = 0.0f; 
    6972            int index2 = (index + excitation.length) / 2; 
    70             for (int i = index2; i < excitation.length; ++i) { 
     73            for (i = index2; i < excitation.length; ++i) { 
    7174                baseline += excitation[i]; 
    7275            } 
     
    7679        // "Where does the prompt first drop to (peak amplitude - baseline) / 10? 
    7780        // This could be silly if the baseline is silly; caveat emptor!" 
    78         for (int i = index; i > 0; --i) { 
     81        for (i = index; i > 0; --i) { 
    7982            if ((excitation[i] - baseline) < 0.1 * (maxval - baseline)) { 
    80                 startp = i; // "First estimate" 
    8183                break; 
    8284            } 
    8385        } 
     86        startp = i; // "First estimate" 
    8487 
    8588        // "And first drop away again?" 
    86         for (int i = index; i < excitation.length - 1; ++i) { 
     89        for (i = index; i < excitation.length - 1; ++i) { 
    8790            if ((excitation[i] - baseline) < 0.1 * (maxval - baseline)) { 
    88                 endp = i; 
    8991                break; 
    9092            } 
    9193        } 
     94        endp = i; 
    9295 
    9396        // "Differentiate" 
    94         for (int i = 0; i < index; ++i) { 
     97        for (i = 0; i < index; ++i) { 
    9598            diffed[i] = excitation[i + 1] - excitation[i]; 
    9699        } 
     
    119122    } 
    120123 
    121     public static float[] estimateCursors(float[] prompt, double[] decay) { 
     124    public static float[] estimateCursors(float xInc, float[] prompt, double[] decay) { 
    122125        float[] returnValue = new float[5]; 
    123126        float baseline; 
     127        float maxval; // TRCursors.c has "unsigned short maxsval, maxval; float maxfval, *diffed;" 
     128        int index; 
    124129        int startp = 0; 
    125130        int startt = 0; 
    126131        int endp = 0; 
    127132        int endt = 0; 
     133        int i; 
    128134        float[] diffed = new float[prompt.length]; 
    129135        int steepp; 
    130136        int steept; 
     137        // "For Marquardt fitting" 
     138        double param[] = new double[4]; 
     139        boolean free[] = new boolean[] { true, true, true }; 
     140        double[] yFitted = new double[decay.length]; 
     141        double[] chiSqTable = new double[2 * ATTEMPTS + 1]; 
     142        int transStartIndex; 
     143        int transFitStartIndex; 
     144        int transEndIndex; 
    131145 
    132146        // "Estimate prompt baseline; very rough and ready" 
    133         int index = findMax(prompt); 
    134         float maxval = prompt[index]; 
     147        index = findMax(prompt); 
     148        maxval = prompt[index]; 
    135149 
    136150        if (index > prompt.length * 3 /4) { // "integer arithmetic" 
     
    140154            baseline = 0.0f; 
    141155            int index2 = (index + prompt.length) / 2; 
    142             for (int i = index2; i < prompt.length; ++i) { 
     156            for (i = index2; i < prompt.length; ++i) { 
    143157                baseline += prompt[i]; 
    144158            } 
     
    148162        // "Where does the prompt first drop to (peak amplitude - baseline) / 10? 
    149163        // This could be silly if the baseline is silly; caveat emptor!" 
    150         for (int i = index; i > 0; --i) { 
     164        for (i = index; i > 0; --i) { 
    151165            if ((prompt[i] - baseline) < 0.1 * (maxval - baseline)) { 
    152                 startp = i; // "First estimate" 
    153166                break; 
    154167            } 
    155168        } 
     169        startp = i; // "First estimate" 
    156170 
    157171        // "And first drop away again?" 
    158         for (int i = index; i < prompt.length - 1; ++i) { 
     172        for (i = index; i < prompt.length - 1; ++i) { 
    159173            if ((prompt[i] - baseline) < 0.1 * (maxval - baseline)) { 
    160                 endp = i; 
    161174                break; 
    162175            } 
    163176        } 
     177        endp = i; 
    164178 
    165179        // "Differentiate" 
    166         for (int i = 0; i < index; ++i) { 
     180        for (i = 0; i < index; ++i) { 
    167181            diffed[i] = prompt[i + 1] - prompt[i]; 
    168182        } 
     
    188202 
    189203        // "Differentiate" 
    190         double[] diffedd = new double[decay.length]; 
    191         for (int i = 0; i < index; ++i) { 
     204        double[] diffedd = new double[decay.length]; //TODO double vs float issues 
     205        for (i = 0; i < index; ++i) { 
    192206            diffedd[i] = decay[i + 1] - decay[i]; 
    193207        } 
     
    202216        } 
    203217 
    204         // save estimates 
    205         returnValue[0] = startp; 
    206         returnValue[1] = endp; 
    207         returnValue[2] = baseline; 
    208         returnValue[3] = startt; 
    209         returnValue[4] = endt; //TODO ITS JUST ZERO HERE!! 
     218            // save estimates //TODO not in original 
     219            returnValue[0] = startp; 
     220            returnValue[1] = endp; 
     221            returnValue[2] = baseline; 
     222            returnValue[3] = startt; 
     223            returnValue[4] = endt; //TODO ITS JUST ZERO HERE!! 
    210224 
    211225        // "Now we've got estimates we can do some Marquardt fitting to fine-tune 
    212226        // the estimates" 
    213227 
    214         int gTransStartIndex = startt - ATTEMPTS; 
    215         if (gTransStartIndex < 0) { 
    216             gTransStartIndex = 0; 
    217         } 
    218         int gTransEndIndex = 9 * decay.length / 10; // "90% of transient" 
    219         if (gTransEndIndex <= gTransStartIndex + 2 * ATTEMPTS) { // "oops" 
    220             return returnValue; 
    221         } 
    222  
    223         double[] param = new double[3]; 
    224         boolean[] free = new boolean[] { true, true, true }; 
    225         double[] yFitted = new double[decay.length]; 
    226         double[] chiSqTable = new double[2 * ATTEMPTS + 1]; 
    227         for (int i = 0; i < 2 * ATTEMPTS + 1; ++i, ++gTransStartIndex) { 
    228             int fit_start = 0; // gTransFitStartIndex - gTransStartIndex; 
    229             int fit_end = gTransEndIndex - gTransStartIndex; 
    230  
    231             //int gTransFitStartIndex = gTransStartIndex; 
     228        transStartIndex = startt - ATTEMPTS; 
     229        if (transStartIndex < 0) { 
     230            transStartIndex = 0; 
     231        } 
     232        transEndIndex = 9 * decay.length / 10; // "90% of transient" 
     233        if (transEndIndex <= transStartIndex + 2 * ATTEMPTS) { // "oops" 
     234            System.out.println("oops return"); 
     235            return returnValue; //TODO "do_estimate_resets; do_estimate_frees; " 
     236        } 
     237 
     238        for (i = 0; i < 2 * ATTEMPTS + 1; ++i, ++transStartIndex) { 
     239 
     240            transFitStartIndex = transStartIndex; 
     241 
     242            int fitStart = transFitStartIndex - transStartIndex; 
     243            int fitStop = transEndIndex - transStartIndex; 
     244            int nData = transEndIndex - transStartIndex; 
     245            System.out.println("fitStart " + fitStart + " fitStop " + fitStop + " nData " + nData); 
    232246 
    233247            CurveFitData curveFitData = new CurveFitData(); 
    234             curveFitData.setParams(param); 
    235             curveFitData.setFree(free); 
     248            curveFitData.setParams(param); //TODO param has random values!! 
    236249            curveFitData.setYCount(decay); 
    237250            curveFitData.setSig(null); 
     
    240253 
    241254            SLIMCurveFitter curveFitter = new SLIMCurveFitter(SLIMCurveFitter.AlgorithmType.RLD_LMA); 
    242             int ret = 0; //curveFitter.fitData(data, fitStart, fitStop); 
     255            curveFitter.setXInc(xInc); 
     256            curveFitter.setFree(free); 
     257 
     258            int ret = curveFitter.fitData(data, fitStart, fitStop); 
    243259 
    244260            if (ret >= 0) { 
    245                 //System.out.println("for start " + fitStart + " stop " + fitStop + " chiSq is " + data[0].getChiSquare()); 
     261                System.out.println("for start " + fitStart + " stop " + fitStop + " chiSq is " + data[0].getChiSquare()); 
    246262                chiSqTable[i] = data[0].getChiSquare(); 
    247263            } 
    248264            else { 
     265                System.out.println("ret from fitData is " + ret); 
    249266                chiSqTable[i] = 1e10f; // "silly value" 
    250267            } 
     
    253270        // "Find the minimum chisq in this range" 
    254271        index = findMin(chiSqTable, 2 * ATTEMPTS + 1); 
    255         if (chiSqTable[index] > 9e9f) { 
     272        if (chiSqTable[index] > 9e9f) {  // "no luck here..." 
     273            System.out.println("no luck here return"); 
     274            for (double chiSq : chiSqTable) { 
     275                System.out.println("chiSq is " + chiSq); 
     276            } 
     277            System.out.println("index is " + index); 
    256278            return null; //TODO do estimate resets/frees??? 
    257279        } 
     280 
     281        // "Then we're rolling!" 
     282        transStartIndex = startt - ATTEMPTS; 
     283        if (transStartIndex < 0) { 
     284            transStartIndex = 0; 
     285        } 
     286        transStartIndex += index; 
     287        transFitStartIndex = transStartIndex + (transEndIndex - transStartIndex) / 20; 
    258288 
    259289        returnValue[0] = startp; 
    260290        returnValue[1] = endp; 
    261291        returnValue[2] = baseline; 
    262         returnValue[3] = startt; 
    263         returnValue[4] = endt; //TODO it's still zero!! 
     292        returnValue[3] = transStartIndex; 
     293        returnValue[4] = transFitStartIndex; 
     294        returnValue[5] = transEndIndex; 
    264295        return returnValue; 
    265296    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/DecayGraph.java

    r7668 r7671  
    214214        decayRenderer.setSeriesPaint(0, Color.green); 
    215215        decayRenderer.setSeriesPaint(1, Color.red); 
    216         decayRenderer.setSeriesPaint(2, Color.blue); 
     216        decayRenderer.setSeriesPaint(2, Color.darkGray); 
    217217 
    218218        m_decaySubPlot = new XYPlot(m_decayDataset, null, photonAxis, decayRenderer); 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/Excitation.java

    r7668 r7671  
    3636 
    3737/** 
    38  * TODO 
    39  * 
    40  * <dl><dt><b>Source code:</b></dt> 
    41  * <dd><a href="http://dev.loci.wisc.edu/trac/software/browser/trunk/projects/slim-plugin/src/main/java/loci/slim/Excitation.java">Trac</a>, 
    42  * <a href="http://dev.loci.wisc.edu/svn/software/trunk/projects/slim-plugin/src/main/java/loci/slim/Excitation.java">SVN</a></dd></dl> 
     38 * This class is a container for values for the instrument response function, 
     39 * aka excitation, aka prompt, aka lamp function. 
    4340 * 
    4441 * @author Aivar Grislis 
     
    5148    private float m_base; 
    5249 
     50    /** 
     51     * Creates an excitation with given filename and values. 
     52     * 
     53     * @param fileName 
     54     * @param values 
     55     */ 
    5356    public Excitation(String fileName, float[] values) { 
    5457        m_fileName = fileName; 
    5558        m_values = values; 
    56         float[] cursors = CursorHelper.estimateExcitationCursors(values); 
    57         System.out.println("start " + cursors[0] + " stop " + cursors[1] + " base " + cursors[2]); 
    58         m_start = (int) cursors[0]; 
    59         m_stop  = (int) cursors[1]; 
    60         m_base  = cursors[2]; 
    6159    } 
    6260 
     61    /** 
     62     * Gets the file name. 
     63     * 
     64     * @return 
     65     */ 
    6366    public String getFileName() { 
    6467        return m_fileName; 
    6568    } 
    6669 
     70    /** 
     71     * Gets the values of the excitation curve. 
     72     * 
     73     * @return 
     74     */ 
    6775    public float[] getValues() { 
    6876        return m_values; 
    6977    } 
    7078 
     79    /** 
     80     * Sets start cursor. 
     81     * 
     82     * @param start 
     83     */ 
     84    public void setStart(int start) { 
     85        m_start = start; 
     86    } 
     87 
     88    /** 
     89     * Gets start cursor. 
     90     * 
     91     * @return 
     92     */ 
    7193    public int getStart() { 
    7294        return m_start; 
    7395    } 
    7496 
     97    /** 
     98     * Sets the stop cursor. 
     99     *  
     100     * @param stop 
     101     */ 
     102    public void setStop(int stop) { 
     103        m_stop = stop; 
     104    } 
     105 
     106    /** 
     107     * Gets the stop cursor. 
     108     * 
     109     * @return 
     110     */ 
    75111    public int getStop() { 
    76112        return m_stop; 
    77113    } 
    78114 
     115    /** 
     116     * Sets the base cursor. 
     117     * 
     118     * @param base 
     119     */ 
     120    public void setBase(float base) { 
     121        m_base = base; 
     122    } 
     123 
     124    /** 
     125     * Gets the base cursor. 
     126     * 
     127     * @return 
     128     */ 
    79129    public float getBase() { 
    80130        return m_base; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ExcitationFileHandler.java

    r7668 r7671  
    118118        try { 
    119119            icsReader.setId(fileName); 
    120             System.out.println(" is single file " + icsReader.isSingleFile(fileName)); 
     120            //System.out.println(" is single file " + icsReader.isSingleFile(fileName)); 
    121121            String domains[] = icsReader.getDomains(); 
    122122            int lengths[] = icsReader.getChannelDimLengths(); 
    123             System.out.print("lengths"); 
    124             for (int i : lengths) { 
    125                 System.out.print(" " + i); 
    126             } 
    127             System.out.println(); 
     123            //System.out.print("lengths"); 
     124            //for (int i : lengths) { 
     125            //    System.out.print(" " + i); 
     126            //} 
     127            //System.out.println(); 
    128128            String types[] = icsReader.getChannelDimTypes(); 
    129129            int sizeX = icsReader.getSizeX(); 
     
    137137            int effSizeC = icsReader.getEffectiveSizeC(); 
    138138            boolean littleEndian = icsReader.isLittleEndian(); 
    139             System.out.println("size X Y Z T C " + sizeX + " " + sizeY + " " + sizeZ + " " + sizeT + " " + sizeC + " "); 
    140             System.out.println("bpp " + bpp + " dim order " + dimOrder + " pixelTYpe + " + pixelType + " effsizec " + effSizeC + " littleendian " + littleEndian); 
     139            //System.out.println("size X Y Z T C " + sizeX + " " + sizeY + " " + sizeZ + " " + sizeT + " " + sizeC + " "); 
     140            //System.out.println("bpp " + bpp + " dim order " + dimOrder + " pixelTYpe + " + pixelType + " effsizec " + effSizeC + " littleendian " + littleEndian); 
    141141 
    142142            System.out.println(icsReader.getFormat()); 
     
    146146            for (int bin = 0; bin < bins; ++bin) { 
    147147                bytes = icsReader.openBytes(bin); 
    148                 for (byte b : bytes) { 
    149                     System.out.print(" " + b); 
    150                 } 
    151                 System.out.println(); 
     148                //for (byte b : bytes) { 
     149                //    System.out.print(" " + b); 
     150                //} 
     151                //System.out.println(); 
    152152                results[bin] = convertBytesToFloat(bytes); 
    153153            } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7668 r7671  
    6767import loci.slim.binning.SLIMBinning; 
    6868import loci.slim.colorizer.DataColorizer; 
     69import loci.slim.ui.ExcitationPanel; 
    6970import loci.slim.ui.IStartStopListener; 
    7071import loci.slim.ui.IUserInterfacePanel; 
     
    131132    private volatile boolean m_fitted; 
    132133 
    133     //TODO total kludge; just to get started 
    134     private boolean m_fakeData = false; 
    135  
    136134    private static final String FILE_KEY = "file"; 
    137135    private String m_file; 
     
    173171    private SLIMBinning m_binning; 
    174172 
     173    private ExcitationPanel m_excitationPanel = null; 
    175174    private IGrayScaleImage m_grayScaleImage; 
    176175    // user sets these from the grayScalePanel 
     
    222221        boolean success = false; 
    223222        if (showFileDialog(getFileFromPreferences())) { 
    224             if (m_fakeData) { 
    225                 fakeData(); 
     223            m_image = loadImage(m_file); 
     224            if (getImageInfo(m_image)) { 
     225                saveFileInPreferences(m_file); 
    226226                success = true; 
    227             } 
    228             else { 
    229                 m_image = loadImage(m_file); 
    230                 if (getImageInfo(m_image)) { 
    231                     saveFileInPreferences(m_file); 
    232                     success = true; 
    233                 } 
    234227            } 
    235228        } 
     
    265258        uiPanel.setListener( 
    266259            new IUserInterfacePanelListener() { 
     260                /** 
     261                 * Triggers a fit. 
     262                 */ 
    267263                public void doFit() { 
    268264                    m_cancel = false; 
     
    270266                } 
    271267 
     268                /** 
     269                 * Cancels ongoing fit. 
     270                 */ 
    272271                public void cancelFit() { 
    273272                    m_cancel = true; 
    274273                } 
    275  
     274                /** 
     275                 * Quits running plugin. 
     276                 */ 
    276277                public void quit() { 
    277278                    m_quit = true; 
    278279                } 
    279280 
     281                /** 
     282                 * Loads an excitation curve from file. 
     283                 * 
     284                 * @param fileName 
     285                 * @return whether successful 
     286                 */ 
     287                public boolean loadExcitation(String fileName) { 
     288                    Excitation excitation = ExcitationFileHandler.getInstance().loadExcitation(fileName); 
     289                    return updateExcitation(uiPanel, excitation); 
     290                } 
     291 
     292                /** 
     293                 * Creates an excitation curve from currrent X, Y and saves to file. 
     294                 * 
     295                 * @param fileName 
     296                 * @return whether successful 
     297                 */ 
     298                public boolean createExcitation(String fileName) { 
     299                    int channel = m_grayScaleImage.getChannel(); 
     300                    int x = uiPanel.getX(); 
     301                    int y = uiPanel.getY(); 
     302                    float[] values = new float[m_timeBins]; 
     303                    for (int b = 0; b < m_timeBins; ++b) { 
     304                        values[b] = (float) getData(m_cursor, channel, x, y, b); 
     305                    } 
     306                    Excitation excitation = ExcitationFileHandler.getInstance().createExcitation(fileName, values); 
     307                    return updateExcitation(uiPanel, excitation); 
     308                } 
     309 
     310                /** 
     311                 * Cancels the current excitation curve, if any. 
     312                 * 
     313                 */ 
     314                public void cancelExcitation() { 
     315                    if (null != m_excitationPanel) { 
     316                        m_excitationPanel.quit(); 
     317                        m_excitationPanel = null; 
     318                        //TODO redo stop/start cursors on decay curve? 
     319                    } 
     320                } 
    280321            } 
    281322        ); 
     
    332373    } 
    333374 
     375    private boolean updateExcitation(IUserInterfacePanel uiPanel, Excitation excitation) { 
     376        boolean success = false; 
     377        if (null != excitation) { 
     378            if (null != m_excitationPanel) { 
     379                m_excitationPanel.quit(); 
     380            } 
     381 
     382            // sum selected channel 
     383            double[] decay = new double[m_timeBins]; 
     384            for (int i = 0; i < decay.length; ++i) { 
     385                decay[i] = 0.0; 
     386            } 
     387            for (int y = 0; y < m_height; ++y) { 
     388                for (int x = 0; x < m_width; ++x) { 
     389                    for (int b = 0; b < m_timeBins; ++b) { 
     390                        decay[b] += getData(m_cursor, m_channel, x, y, b); 
     391                    } 
     392                } 
     393            } 
     394 
     395            float[] results = CursorHelper.estimateCursors(m_timeRange, excitation.getValues(), decay); 
     396            excitation.setStart((int) results[0]); 
     397            excitation.setStop((int) results[1]); 
     398            excitation.setBase(results[2]); 
     399 
     400            uiPanel.setStart(22); 
     401            uiPanel.setStop(33); 
     402 
     403            m_excitationPanel = new ExcitationPanel(excitation); 
     404 
     405            success = true; 
     406        } 
     407        return success; 
     408    } 
     409 
    334410    private void getFitSettings(IGrayScaleImage grayScalePanel, IUserInterfacePanel uiPanel) { 
    335411        m_channel        = grayScalePanel.getChannel(); 
     
    363439        //TODO works with GenericDialogPlus, dialog.addFileField("File:", defaultFile, 24); 
    364440        dialog.addStringField("File", defaultFile); 
    365         dialog.addCheckbox("Fake data", m_fakeData); 
    366441        dialog.showDialog(); 
    367442        if (dialog.wasCanceled()) { 
    368443            return false; 
    369444        } 
    370  
    371445        m_file = dialog.getNextString(); 
    372         m_fakeData = dialog.getNextBoolean(); 
    373  
    374446        return true; 
    375447    } 
     
    474546    } 
    475547 
    476     private boolean fakeData() { 
    477         return true; 
    478     } 
    479548    /** 
    480549     * This routine creates an artificial set of data that is useful to test fitting. 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/ExcitationGraph.java

    r7668 r7671  
    125125 
    126126        // create the chart 
    127         JFreeChart chart = createChart(start, stop, bins, timeInc, values); 
     127        JFreeChart chart = createChart(bins, timeInc, values); 
    128128        ChartPanel chartPanel = new ChartPanel(chart, true, true, true, false, true); 
    129129        chartPanel.setDomainZoomable(false); 
     
    190190     * Creates the chart 
    191191     * 
    192      * @param start time bin 
    193      * @param stop time bin 
    194192     * @param bins number of bins 
    195193     * @param timeInc time increment per bin 
     
    197195     * @return the chart 
    198196     */ 
    199     JFreeChart createChart(int start, int stop, int bins, double timeInc, float[] values) { 
     197    JFreeChart createChart(int bins, double timeInc, float[] values) { 
    200198 
    201199        // create chart data 
    202         createDataset(start, stop, bins, timeInc, values); 
     200        createDataset(bins, timeInc, values); 
    203201 
    204202        // make a horizontal axis 
     
    235233     * Creates the data set for the chart 
    236234     * 
    237      * @param start time bin 
    238      * @param stop time bin 
    239235     * @param bins number of time bins 
    240236     * @param timeInc time increment per time bin 
    241237     * @param data from the fit 
    242238     */ 
    243     private void createDataset(int start, int stop, int bins, double timeInc, float[] values) { 
     239    private void createDataset(int bins, double timeInc, float[] values) { 
    244240        XYSeries series = new XYSeries("Data"); 
    245241        double yData, yFitted; 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanelListener.java

    r7668 r7671  
    3636 
    3737/** 
    38  * TODO 
    39  * 
    40  * <dl><dt><b>Source code:</b></dt> 
    41  * <dd><a href="http://dev.loci.wisc.edu/trac/software/browser/trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanelListener.java">Trac</a>, 
    42  * <a href="http://dev.loci.wisc.edu/svn/software/trunk/projects/slim-plugin/src/main/java/loci/slim/ui/IUserInterfacePanelListener.java">SVN</a></dd></dl> 
     38 * Listens for user input that triggers changes external to the ui panel. 
    4339 * 
    4440 * @author Aivar Grislis grislis at wisc.edu 
     
    6056     */ 
    6157    public void quit(); 
     58 
     59    /** 
     60     * Loads an excitation curve from file. 
     61     * 
     62     * @param fileName 
     63     * @return whether successful 
     64     */ 
     65    public boolean loadExcitation(String fileName); 
     66 
     67    /** 
     68     * Creates an excitation curve from currrent X, Y and saves to file. 
     69     * 
     70     * @param fileName 
     71     * @return whether successful 
     72     */ 
     73    public boolean createExcitation(String fileName); 
     74 
     75    /** 
     76     * Cancels the current excitation curve, if any. 
     77     * 
     78     */ 
     79    public void cancelExcitation(); 
    6280} 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java

    r7668 r7671  
    6464import ij.gui.GenericDialog; 
    6565 
    66 import loci.slim.Excitation; 
    67 import loci.slim.ExcitationFileHandler; 
    6866import loci.slim.ui.IUserInterfacePanel.FitAlgorithm; 
    6967import loci.slim.ui.IUserInterfacePanel.FitFunction; 
    7068import loci.slim.ui.IUserInterfacePanel.FitRegion; 
    71 import loci.slim.analysis.SLIMAnalysis; 
    72 import loci.slim.binning.SLIMBinning; 
    7369 
    7470/** 
    75  * TODO 
    76  * 
    77  * <dl><dt><b>Source code:</b></dt> 
    78  * <dd><a href="http://dev.loci.wisc.edu/trac/software/browser/trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java">Trac</a>, 
    79  * <a href="http://dev.loci.wisc.edu/svn/software/trunk/projects/slim-plugin/src/main/java/loci/slim/ui/UserInterfacePanel.java">SVN</a></dd></dl> 
     71 * Main user interface panel for the fit. 
    8072 * 
    8173 * @author Aivar Grislis grislis at wisc.edu 
     
    127119     
    128120    public IUserInterfacePanelListener m_listener; 
    129  
    130     private ExcitationPanel m_excitationPanel; 
    131121 
    132122    int m_fittedParameterCount = 0; 
     
    381371    } 
    382372 
    383     float[] m_values = null; 
    384  
    385373    /* 
    386374     * Creates a panel that has some settings that control the fit. 
     
    434422            new ActionListener() { 
    435423                public void actionPerformed(ActionEvent e) { 
    436                     Excitation excitation = null; 
    437  
    438424                    String selectedItem = (String) m_excitationComboBox.getSelectedItem(); 
    439                     System.out.println("selected " + selectedItem); 
     425                    boolean isExcitationLoaded = false; 
    440426                    if (EXCITATION_NONE.equals(selectedItem)) { 
    441                         if (null != m_excitationPanel) { 
    442                             m_excitationPanel.quit(); 
    443                             m_excitationPanel = null; 
     427                        if (null != m_listener) { 
     428                            m_listener.cancelExcitation(); 
    444429                        } 
    445430                    } 
    446431                    else if (EXCITATION_FILE.equals(selectedItem)) { 
    447432                        String fileName = getFileName("Load Excitation File", ""); 
    448                         if (null != fileName) { 
    449                             excitation = ExcitationFileHandler.getInstance().loadExcitation(fileName); 
    450                         } 
    451                         if (null != excitation) { 
    452                             m_values = excitation.getValues(); 
     433                        if (null != fileName && null != m_listener) { 
     434                            isExcitationLoaded = m_listener.loadExcitation(fileName); 
    453435                        } 
    454436                    } 
    455437                    else if (EXCITATION_CREATE.equals(selectedItem)) { 
    456438                        String fileName = getFileName("Save Excitation File", ""); 
    457                         if (null != fileName) { 
    458                             if (null != m_values) { 
    459                                 excitation = ExcitationFileHandler.getInstance().createExcitation(fileName, m_values); 
    460                             } 
     439                        if (null != fileName && null != m_listener) { 
     440                            isExcitationLoaded = m_listener.createExcitation(fileName); 
    461441                        } 
    462442                    } 
    463443 
    464                     if (null == excitation) { 
    465                         m_excitationComboBox.setSelectedItem(EXCITATION_NONE); 
     444                    if (isExcitationLoaded) { 
     445                        m_excitationComboBox.setSelectedItem(EXCITATION_FILE); 
    466446                    } 
    467447                    else { 
    468                         m_excitationComboBox.setSelectedItem(EXCITATION_FILE); 
    469                         m_excitationPanel = new ExcitationPanel(excitation); 
     448                        m_excitationComboBox.setSelectedItem(EXCITATION_NONE); 
    470449                    } 
    471450                } 
Note: See TracChangeset for help on using the changeset viewer.