Search in sources :

Example 1 with GenerateActivationRoiOp

use of org.vcell.vmicro.op.GenerateActivationRoiOp in project vcell by virtualcell.

the class PhotoactivationExperimentTest method analyzePhotoactivation.

/**
 * Fits raw image time series data to uniform disk models (with Guassian or Uniform fluorescence).
 *
 * @param rawTimeSeriesImages
 * @param localWorkspace
 * @throws Exception
 */
private static void analyzePhotoactivation(ImageTimeSeries<UShortImage> rawTimeSeriesImages, LocalWorkspace localWorkspace) throws Exception {
    // 
    // correct the timestamps (1 per second).
    // 
    double[] timeStamps = rawTimeSeriesImages.getImageTimeStamps();
    for (int i = 0; i < timeStamps.length; i++) {
        timeStamps[i] = i;
    }
    new DisplayTimeSeriesOp().displayImageTimeSeries(rawTimeSeriesImages, "raw images", (WindowListener) null);
    ImageTimeSeries<UShortImage> blurredRaw = blurTimeSeries(rawTimeSeriesImages);
    new DisplayTimeSeriesOp().displayImageTimeSeries(blurredRaw, "blurred raw images", (WindowListener) null);
    double cellThreshold = 0.4;
    GeometryRoisAndActivationTiming cellROIresults = new GenerateCellROIsFromRawPhotoactivationTimeSeriesOp().generate(blurredRaw, cellThreshold);
    ROI backgroundROI = cellROIresults.backgroundROI_2D;
    ROI cellROI = cellROIresults.cellROI_2D;
    int indexOfFirstPostactivation = cellROIresults.indexOfFirstPostactivation;
    boolean backgroundSubtract = false;
    boolean normalizeByPreActivation = false;
    NormalizedPhotoactivationDataResults normResults = new GenerateNormalizedPhotoactivationDataOp().generate(rawTimeSeriesImages, backgroundROI, indexOfFirstPostactivation, backgroundSubtract, normalizeByPreActivation);
    ImageTimeSeries<FloatImage> normalizedTimeSeries = normResults.normalizedPhotoactivationData;
    FloatImage preactivationAvg = normResults.preactivationAverageImage;
    FloatImage normalizedPostactivation = normalizedTimeSeries.getAllImages()[0];
    new DisplayTimeSeriesOp().displayImageTimeSeries(normalizedTimeSeries, "normalized images", (WindowListener) null);
    // 
    // create a single bleach ROI by thresholding
    // 
    double activatedThreshold = 1000;
    ROI activatedROI = new GenerateActivationRoiOp().generateActivatedRoi(blurredRaw.getAllImages()[indexOfFirstPostactivation], cellROI, activatedThreshold);
    new DisplayImageOp().displayImage(activatedROI.getRoiImages()[0], "activated roi", null);
    new DisplayImageOp().displayImage(cellROI.getRoiImages()[0], "cell roi", null);
    new DisplayImageOp().displayImage(backgroundROI.getRoiImages()[0], "background roi", null);
    {
        // 
        // only use bleach ROI for fitting etc.
        // 
        NormalizedSampleFunction[] dataROIs = new NormalizedSampleFunction[] { NormalizedSampleFunction.fromROI(activatedROI) };
        // 
        // get reduced data and errors for each ROI
        // 
        RowColumnResultSet reducedData = new GenerateReducedDataOp().generateReducedData(normalizedTimeSeries, dataROIs);
        RowColumnResultSet measurementErrors = new ComputeMeasurementErrorOp().computeNormalizedMeasurementError(dataROIs, indexOfFirstPostactivation, rawTimeSeriesImages, preactivationAvg, null);
        DisplayPlotOp displayReducedData = new DisplayPlotOp();
        displayReducedData.displayPlot(reducedData, "reduced data", null);
        DisplayPlotOp displayMeasurementError = new DisplayPlotOp();
        displayMeasurementError.displayPlot(measurementErrors, "measurement error", null);
        // 
        // 2 parameter uniform disk model
        // 
        Parameter tau = new Parameter("tau", 0.001, 200.0, 1.0, 0.1);
        Parameter f_init = new Parameter("f_init", 0.5, 4000, 1.0, 1.0);
        Parameter f_final = new Parameter("f_final", 0.01, 4000, 1.0, 0.5);
        Parameter[] parameters = new Parameter[] { tau, f_init, f_final };
        OptModel optModel = new OptModel("photoactivation (activated roi)", parameters) {

            @Override
            public double[][] getSolution0(double[] newParams, double[] solutionTimePoints) {
                double tau = newParams[0];
                double max = newParams[1];
                double offset = newParams[2];
                double[][] solution = new double[1][solutionTimePoints.length];
                for (int i = 0; i < solution[0].length; i++) {
                    double t = solutionTimePoints[i];
                    solution[0][i] = offset + (max - offset) * Math.exp(-t / tau);
                }
                return solution;
            }

            @Override
            public double getPenalty(double[] parameters2) {
                return 0;
            }
        };
        ErrorFunction errorFunction = new ErrorFunctionNoiseWeightedL2();
        OptContext uniformDisk2Context = new Generate2DOptContextOp().generate2DOptContext(optModel, reducedData, measurementErrors, errorFunction);
        new DisplayInteractiveModelOp().displayOptModel(uniformDisk2Context, dataROIs, localWorkspace, "nonspatial photoactivation - activated ROI only", null);
    }
    {
        // 
        // only activation ROI for chemistry, cellROI for bleaching
        // 
        NormalizedSampleFunction[] dataROIs = new NormalizedSampleFunction[] { NormalizedSampleFunction.fromROI(activatedROI), NormalizedSampleFunction.fromROI(cellROI) };
        // 
        // get reduced data and errors for each ROI
        // 
        RowColumnResultSet reducedData = new GenerateReducedDataOp().generateReducedData(normalizedTimeSeries, dataROIs);
        RowColumnResultSet measurementErrors = new ComputeMeasurementErrorOp().computeNormalizedMeasurementError(dataROIs, indexOfFirstPostactivation, rawTimeSeriesImages, preactivationAvg, null);
        DisplayPlotOp displayReducedData = new DisplayPlotOp();
        displayReducedData.displayPlot(reducedData, "reduced data (2)", null);
        DisplayPlotOp displayMeasurementError = new DisplayPlotOp();
        displayMeasurementError.displayPlot(measurementErrors, "measurement error (2)", null);
        // 
        // 2 parameter uniform disk model
        // 
        Parameter tau_active = new Parameter("tau_active", 0.001, 200.0, 1.0, 0.1);
        Parameter f_active_init = new Parameter("f_active_init", 0.5, 4000, 1.0, 1.0);
        Parameter f_active_amplitude = new Parameter("f_active_amplitude", 0.01, 4000, 1.0, 0.5);
        Parameter f_cell_init = new Parameter("f_cell_init", 0.01, 4000, 1.0, 0.1);
        Parameter f_cell_amplitude = new Parameter("f_cell_amplitude", 0.01, 4000, 1.0, 0.1);
        Parameter tau_cell = new Parameter("tau_cell", 0.00001, 200, 1.0, 1);
        Parameter[] parameters = new Parameter[] { tau_active, f_active_init, f_active_amplitude, tau_cell, f_cell_init, f_cell_amplitude };
        OptModel optModel = new OptModel("photoactivation (activated and cell rois)", parameters) {

            @Override
            public double[][] getSolution0(double[] newParams, double[] solutionTimePoints) {
                double tau_active = newParams[0];
                double max_active = newParams[1];
                double amplitude_active = newParams[2];
                double tau_cell = newParams[3];
                double max_cell = newParams[4];
                double amplitude_cell = newParams[5];
                final int ACTIVE_ROI = 0;
                final int CELL_ROI = 1;
                final int NUM_ROIS = 2;
                double[][] solution = new double[NUM_ROIS][solutionTimePoints.length];
                for (int i = 0; i < solution[0].length; i++) {
                    double t = solutionTimePoints[i];
                    solution[ACTIVE_ROI][i] = (max_active - amplitude_active) + (amplitude_active) * Math.exp(-t / tau_active) * Math.exp(-t / tau_cell);
                    solution[CELL_ROI][i] = (max_cell - amplitude_cell) + (amplitude_cell) * Math.exp(-t / tau_cell);
                }
                return solution;
            }

            @Override
            public double getPenalty(double[] parameters2) {
                return 0;
            }
        };
        ErrorFunctionNoiseWeightedL2 errorFunction = new ErrorFunctionNoiseWeightedL2();
        OptContext uniformDisk2Context = new Generate2DOptContextOp().generate2DOptContext(optModel, reducedData, measurementErrors, errorFunction);
        new DisplayInteractiveModelOp().displayOptModel(uniformDisk2Context, dataROIs, localWorkspace, "nonspatial photoactivation - activated and cell ROIs", null);
    }
}
Also used : FloatImage(cbit.vcell.VirtualMicroscopy.FloatImage) GenerateCellROIsFromRawPhotoactivationTimeSeriesOp(org.vcell.vmicro.op.GenerateCellROIsFromRawPhotoactivationTimeSeriesOp) ErrorFunctionNoiseWeightedL2(org.vcell.vmicro.workflow.data.ErrorFunctionNoiseWeightedL2) OptContext(org.vcell.vmicro.workflow.data.OptContext) OptModel(org.vcell.vmicro.workflow.data.OptModel) DisplayPlotOp(org.vcell.vmicro.op.display.DisplayPlotOp) NormalizedPhotoactivationDataResults(org.vcell.vmicro.op.GenerateNormalizedPhotoactivationDataOp.NormalizedPhotoactivationDataResults) DisplayImageOp(org.vcell.vmicro.op.display.DisplayImageOp) DisplayTimeSeriesOp(org.vcell.vmicro.op.display.DisplayTimeSeriesOp) GeometryRoisAndActivationTiming(org.vcell.vmicro.op.GenerateCellROIsFromRawPhotoactivationTimeSeriesOp.GeometryRoisAndActivationTiming) DisplayInteractiveModelOp(org.vcell.vmicro.op.display.DisplayInteractiveModelOp) GenerateActivationRoiOp(org.vcell.vmicro.op.GenerateActivationRoiOp) GenerateReducedDataOp(org.vcell.vmicro.op.GenerateReducedDataOp) RowColumnResultSet(cbit.vcell.math.RowColumnResultSet) ErrorFunction(org.vcell.vmicro.workflow.data.ErrorFunction) UShortImage(cbit.vcell.VirtualMicroscopy.UShortImage) Generate2DOptContextOp(org.vcell.vmicro.op.Generate2DOptContextOp) ROI(cbit.vcell.VirtualMicroscopy.ROI) ComputeMeasurementErrorOp(org.vcell.vmicro.op.ComputeMeasurementErrorOp) Parameter(cbit.vcell.opt.Parameter) GenerateNormalizedPhotoactivationDataOp(org.vcell.vmicro.op.GenerateNormalizedPhotoactivationDataOp)

Aggregations

FloatImage (cbit.vcell.VirtualMicroscopy.FloatImage)1 ROI (cbit.vcell.VirtualMicroscopy.ROI)1 UShortImage (cbit.vcell.VirtualMicroscopy.UShortImage)1 RowColumnResultSet (cbit.vcell.math.RowColumnResultSet)1 Parameter (cbit.vcell.opt.Parameter)1 ComputeMeasurementErrorOp (org.vcell.vmicro.op.ComputeMeasurementErrorOp)1 Generate2DOptContextOp (org.vcell.vmicro.op.Generate2DOptContextOp)1 GenerateActivationRoiOp (org.vcell.vmicro.op.GenerateActivationRoiOp)1 GenerateCellROIsFromRawPhotoactivationTimeSeriesOp (org.vcell.vmicro.op.GenerateCellROIsFromRawPhotoactivationTimeSeriesOp)1 GeometryRoisAndActivationTiming (org.vcell.vmicro.op.GenerateCellROIsFromRawPhotoactivationTimeSeriesOp.GeometryRoisAndActivationTiming)1 GenerateNormalizedPhotoactivationDataOp (org.vcell.vmicro.op.GenerateNormalizedPhotoactivationDataOp)1 NormalizedPhotoactivationDataResults (org.vcell.vmicro.op.GenerateNormalizedPhotoactivationDataOp.NormalizedPhotoactivationDataResults)1 GenerateReducedDataOp (org.vcell.vmicro.op.GenerateReducedDataOp)1 DisplayImageOp (org.vcell.vmicro.op.display.DisplayImageOp)1 DisplayInteractiveModelOp (org.vcell.vmicro.op.display.DisplayInteractiveModelOp)1 DisplayPlotOp (org.vcell.vmicro.op.display.DisplayPlotOp)1 DisplayTimeSeriesOp (org.vcell.vmicro.op.display.DisplayTimeSeriesOp)1 ErrorFunction (org.vcell.vmicro.workflow.data.ErrorFunction)1 ErrorFunctionNoiseWeightedL2 (org.vcell.vmicro.workflow.data.ErrorFunctionNoiseWeightedL2)1 OptContext (org.vcell.vmicro.workflow.data.OptContext)1