Changeset 7867


Ignore:
Timestamp:
01/13/12 20:39:07 (8 years ago)
Author:
aivar
Message:

Refactoring.

Location:
trunk/projects/slim-plugin/src/main/java
Files:
3 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/FitInfo.java

    r7866 r7867  
    404404        _refineFit = refineFit; 
    405405    } 
     406 
     407    /** 
     408     * Gets number of exponential components. 
     409     *  
     410     * @return  
     411     */ 
     412    public int getComponents() { 
     413        int components = 0; 
     414        switch (_function) { 
     415            case SINGLE_EXPONENTIAL: 
     416            case STRETCHED_EXPONENTIAL: 
     417                components = 1; 
     418            case DOUBLE_EXPONENTIAL: 
     419                components = 2; 
     420            case TRIPLE_EXPONENTIAL: 
     421                components = 3; 
     422        } 
     423        return components; 
     424    } 
     425     
     426    /** 
     427     * Gets whether or not this is a stretched exponential fit. 
     428     *  
     429     * @return  
     430     */ 
     431    public boolean getStretched() { 
     432        return FitFunction.STRETCHED_EXPONENTIAL == _function; 
     433    } 
    406434} 
  • trunk/projects/slim-plugin/src/main/java/imagej/slim/fitting/IDecayImage.java

    r7866 r7867  
    66 
    77import mpicbg.imglib.image.Image; 
     8import mpicbg.imglib.type.numeric.RealType; 
    89import mpicbg.imglib.type.numeric.real.DoubleType; 
    910 
     
    1213 * @author Aivar Grislis 
    1314 */ 
    14 public interface IDecayImage { 
     15public interface IDecayImage<T extends RealType<T>> { 
    1516     
    1617    /** 
     
    4041     */ 
    4142    public int getBins(); 
     43 
     44    /** 
     45     * Gets whether or not to fit this pixel. 
     46     *  
     47     * @param x 
     48     * @param y 
     49     * @param channel 
     50     * @return  
     51     */ 
     52    public boolean fitThisPixel(int x, int y, int channel); 
    4253    
    4354    /** 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/DecayImageWrapper.java

    r7866 r7867  
    2121 * @author Aivar Grislis 
    2222 */ 
    23 public class InputImageWrapper implements IDecayImage { 
    24     private Image<DoubleType> _image; 
     23public class DecayImageWrapper<T extends RealType<T>> implements IDecayImage { 
     24    private Image<T> _image; 
    2525    private int _width; 
    2626    private int _height; 
    2727    private int _channels; 
    2828    private int _bins; 
    29     private LocalizableByDimCursor<DoubleType> _cursor; 
     29    private LocalizableByDimCursor<T> _cursor; 
    3030     
    31     public InputImageWrapper(Image<DoubleType> image) { 
     31    public DecayImageWrapper(Image<T> image) { 
    3232        _image = image; 
    3333        int[] dimensions = image.getDimensions(); 
    34         if (dimensions.length >= 4) { 
    35             _width = dimensions[0]; 
    36             _height = dimensions[1]; 
     34        //TODO this is a hack to handle IJ1 images 
     35        if (3 == dimensions.length) { 
     36            _width    = dimensions[0]; 
     37            _height   = dimensions[1]; 
     38            _channels = 1; 
     39            _bins     = dimensions[2]; 
     40        } 
     41        else if (4 == dimensions.length) { 
     42            _width    = dimensions[0]; 
     43            _height   = dimensions[1]; 
    3744            _channels = dimensions[2]; 
    38             _bins = dimensions[3]; 
    39             _cursor = _image.createLocalizableByDimCursor(); 
     45            _bins     = dimensions[3]; 
    4046        } 
     47        else throw new UnsupportedOperationException 
     48                ("Image dimensions " + dimensions.length + " not supported."); 
    4149    } 
    4250     
     
    8088    } 
    8189     
     90    @Override 
     91    public boolean fitThisPixel(int x, int y, int channel) { 
     92        return true; //TODO FOR NOW ONLY!! 
     93    } 
     94     
    8295    /** 
    8396     * Gets input pixel decay curve. 
     
    101114 
    102115    @Override 
    103     public Image<DoubleType> getImage() { 
     116    public Image<T> getImage() { 
    104117        return _image; 
    105118    } 
  • trunk/projects/slim-plugin/src/main/java/loci/slim/SLIMProcessor.java

    r7866 r7867  
    664664                case EACH: 
    665665                    // fit every pixel 
    666                     fittedImage = fitAllPixels(uiPanel); 
     666                    fittedImage = fitImage(uiPanel); ///TODO WAS OLD VERSION: fitAllPixels(uiPanel); 
    667667                    break; 
    668668            } 
     
    699699    } 
    700700     
    701     private IDecayImage wrapInputImage() { 
    702         IDecayImage returnValue = null; 
     701    private IFittedImage wrapOutputImage() { 
     702        IFittedImage returnValue = null; //TODO 
    703703        return returnValue; 
    704704    } 
    705      
    706     private IFittedImage wrapOutputImage() { 
    707         IFittedImage returnValue = null; 
    708         return returnValue; 
    709     } 
    710705 
    711706    private Image<DoubleType> fitImage(IUserInterfacePanel uiPanel) { 
     707        // get fit settings from the UI panel 
    712708        FitInfo fitInfo = getFitInfo(m_grayScaleImage, uiPanel); 
    713         IDecayImage decayImage = wrapInputImage(); 
    714         IFittedImage previousImage = wrapOutputImage(); 
     709         
     710        // set up images 
     711        IDecayImage decayImage = new DecayImageWrapper(m_image); 
     712        IFittedImage previousImage = null; 
    715713        IFittedImage newImage = wrapOutputImage(); 
    716         return fitImage(fitInfo, decayImage, previousImage, newImage); 
    717  
    718     } 
    719  
    720     private Image<DoubleType> fitImage(FitInfo fitInfo, IDecayImage decayImage, 
    721             IFittedImage previousImage, IFittedImage newImage) { 
     714         
     715        // get the fitting engine to use 
     716        IFittingEngine fittingEngine = Configuration.getInstance().getFittingEngine(); 
     717        return fitImage(fittingEngine, fitInfo, decayImage, previousImage, newImage); 
     718 
     719    } 
     720 
     721    /** 
     722     * Fits all the pixels in the image. 
     723     *  
     724     * @param fittingEngine fitting code to use 
     725     * @param fitInfo fit settings 
     726     * @param decayImage contains the decay data 
     727     * @param previousImage previous fit results, may be null 
     728     * @param newImage results of this fit 
     729     * @return  
     730     */ 
     731    private Image<DoubleType> fitImage( 
     732            IFittingEngine fittingEngine, 
     733            FitInfo fitInfo, 
     734            IDecayImage decayImage, 
     735            IFittedImage previousImage, 
     736            IFittedImage newImage) { 
     737  
     738        // get commonly-used items in local variables 
     739        int width = /*new*/decayImage.getWidth(); 
     740        int height = /*new*/decayImage.getHeight(); 
     741        int channels = /*new*/decayImage.getChannels(); 
     742        int[] dimension = new int[] { width, height, channels }; 
     743        int channel = fitInfo.getChannel(); 
     744        boolean fitAllChannels = fitInfo.getFitAllChannels(); 
     745 
     746        // needed to display progress bar 
     747        int pixelCount = 0; 
     748        int totalPixelCount = totalPixelCount(width, height, channels, fitAllChannels); 
     749        int pixelsToProcessCount = 0; 
     750  
     751        // handle optionally producing colorized images during the fit 
     752        ColorizedImageFitter imageColorizer = null; 
     753        String outputs = null; //TODO fitInfo.getFittedImages(); 
     754        if (null != outputs) { 
     755            int components = fitInfo.getComponents(); 
     756            boolean stretched = fitInfo.getStretched(); 
     757            ColorizedImageParser parser = new ColorizedImageParser(outputs, components, stretched); 
     758            ColorizedImageType[] outputImages = parser.getColorizedImages(); 
     759            imageColorizer.setUpFit(outputImages, dimension, components); 
     760            imageColorizer.beginFit(); 
     761        } 
     762   
     763        // initialize class used for 'chunky pixel' effect 
     764        IChunkyPixelTable chunkyPixelTable = new ChunkyPixelTableImpl(); 
     765         
     766        // set up global, image-wide fit parameters 
     767        IGlobalFitParams globalFitParams = new GlobalFitParams(); 
     768       ///TODO globalFitParams.setFitAlgorithm(fitInfo.getAlgorithm()); 
     769       ///TODO  globalFitParams.setFitFunction(fitInfo.getFunction()); 
     770        globalFitParams.setFree(fitInfo.getFree()); //TODO translateFree(uiPanel.getFunction(), uiPanel.getFree())); 
     771       ///TODO globalFitParams.setNoiseModel(fitInfo.getNoiseModel()); 
     772        globalFitParams.setChiSquareTarget(fitInfo.getChiSquareTarget()); 
     773        globalFitParams.setXInc(m_timeRange); //TODO NO NO NO 
     774        globalFitParams.setPrompt(null); 
     775        if (null != m_excitationPanel) { 
     776            globalFitParams.setPrompt(m_excitationPanel.getValues(1)); //TODO NO NO AGAIN no globals in this method! 
     777        } 
     778      
     779        List<ChunkyPixel> pixelList = new ArrayList<ChunkyPixel>();        
     780        List<ILocalFitParams> localFitParamsList = new ArrayList<ILocalFitParams>(); 
     781        
     782        // loop over all channels or just the current one 
     783        for (int c : getChannelIndices(fitAllChannels, channel, channels)) { 
     784            // 'chunky pixel' effect: draw staggered pixels, not sequential 
     785            ChunkyPixelEffectIterator pixelIterator = 
     786                    new ChunkyPixelEffectIterator(chunkyPixelTable, width, height); 
     787             
     788            while (!m_cancel && pixelIterator.hasNext()) { //TODO pass in a class that does the cancel notification 
     789                IJ.showProgress(++pixelCount, totalPixelCount); 
     790                ChunkyPixel pixel = pixelIterator.next(); 
     791                 
     792                int x = pixel.getX(); 
     793                int y = pixel.getY(); 
     794                if (decayImage.fitThisPixel(x, y, c)) { 
     795                    // set up local, pixel fit parameters 
     796                    ILocalFitParams localFitParams = new LocalFitParams(); 
     797                     
     798                    pixelList.add(pixel); 
     799                    localFitParamsList.add(localFitParams); 
     800                     
     801                    if (++pixelsToProcessCount >= PIXEL_COUNT) { 
     802                        pixelsToProcessCount = 0; 
     803                         
     804                        ChunkyPixel[] pixelArray = pixelList.toArray(new ChunkyPixel[0]); 
     805                        pixelList.clear(); 
     806                        ILocalFitParams[] localFitParamsArray = localFitParamsList.toArray(new ILocalFitParams[0]); 
     807                        localFitParamsList.clear(); 
     808                         
     809                        processPixels(fittingEngine, pixelArray, globalFitParams, localFitParamsArray, imageColorizer, newImage); 
     810                    } 
     811                } 
     812                 
     813 
     814 
     815                /* 
     816                 
     817                if (wantFitted(m_channel, pixel.getX(), pixel.getY())) { 
     818                    curveFitData = new CurveFitData(); 
     819                    curveFitData.setChannel(m_channel); 
     820                    curveFitData.setX(pixel.getX()); 
     821                    curveFitData.setY(pixel.getY()); 
     822                    curveFitData.setParams( 
     823                        useFittedParams ? 
     824                            getFittedParams(resultsCursor, m_channel, pixel.getX(), pixel.getY(), m_fittedParameterCount) : 
     825                                params.clone()); 
     826                    yCount = new double[m_timeBins]; 
     827                    for (int b = 0; b < m_timeBins; ++b) { 
     828                        yCount[b] = getData(pixelCursor, m_channel, pixel.getX(), pixel.getY(), b); //binnedData[m_channel][pixel.getY()][pixel.getX()][b]; 
     829                    } 
     830                    curveFitData.setYCount(yCount); 
     831                    yFitted = new double[m_timeBins]; 
     832                    curveFitData.setYFitted(yFitted); 
     833                    curveFitDataList.add(curveFitData); 
     834                    pixelList.add(pixel); 
     835 
     836                    // process the pixels 
     837                    if (++pixelsToProcessCount >= PIXEL_COUNT) { 
     838                        ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     839                        ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
     840                        processPixelsXYZ(data, pixels, imageFitter); 
     841                        curveFitDataList.clear(); 
     842                        pixelList.clear(); 
     843                        pixelsToProcessCount = 0; 
     844                    } 
     845                } 
     846                 */ 
     847            } 
     848        } 
     849         
     850        //TODO REENABLE THIS BECAUSE YOU"RE LOSING SOME PIXELS HERE: 
     851         
     852 /*       if (m_cancel) { 
     853            IJ.showProgress(0, 0); 
     854            cancelImageFit(); 
     855            imageFitter.cancelFit(); 
     856            return null; 
     857        } 
     858        else { 
     859            if (pixelsToProcessCount > 0) { 
     860                ICurveFitData[] data = curveFitDataList.toArray(new ICurveFitData[0]); 
     861                ChunkyPixel[] pixels = pixelList.toArray(new ChunkyPixel[0]); 
     862                processPixelsXYZ(data, pixels, imageFitter); 
     863            } 
     864            imageFitter.endFit(); 
     865        }   */ 
     866         
    722867        return null; 
    723868    } 
     
    739884            ChunkyPixel[] pixels, 
    740885            IGlobalFitParams globalFitParams, 
    741             List<ILocalFitParams> localFitParamsList, 
     886            ILocalFitParams[] localFitParams, 
    742887            ColorizedImageFitter imageColorizer, 
    743888            IFittedImage fittedImage) { 
     889 
     890        //TODO use Lists or just arrays? 
     891        List<ILocalFitParams> localFitParamsList = new ArrayList<ILocalFitParams>(); 
     892        for (ILocalFitParams lFP : localFitParams) { 
     893            localFitParamsList.add(lFP); 
     894        } 
    744895 
    745896        List<IFitResults> resultsList = 
Note: See TracChangeset for help on using the changeset viewer.