use of org.vcell.vmicro.op.Generate2DOptContextOp in project vcell by virtualcell.
the class VFrapProcess method compute.
public static VFrapProcessResults compute(ImageTimeSeries rawTimeSeriesImages, double bleachThreshold, double cellThreshold, LocalWorkspace localWorkspace, ClientTaskStatusSupport clientTaskStatusSupport) throws Exception {
GenerateCellROIsFromRawFrapTimeSeriesOp generateCellROIs = new GenerateCellROIsFromRawFrapTimeSeriesOp();
GeometryRoisAndBleachTiming geometryAndTiming = generateCellROIs.generate(rawTimeSeriesImages, cellThreshold);
GenerateNormalizedFrapDataOp generateNormalizedFrapData = new GenerateNormalizedFrapDataOp();
NormalizedFrapDataResults normalizedFrapResults = generateNormalizedFrapData.generate(rawTimeSeriesImages, geometryAndTiming.backgroundROI_2D, geometryAndTiming.indexOfFirstPostbleach);
GenerateBleachRoiOp generateROIs = new GenerateBleachRoiOp();
ROI bleachROI = generateROIs.generateBleachRoi(normalizedFrapResults.normalizedFrapData.getAllImages()[0], geometryAndTiming.cellROI_2D, bleachThreshold);
GenerateDependentImageROIsOp generateDependentROIs = new GenerateDependentImageROIsOp();
ROI[] dataROIs = generateDependentROIs.generate(geometryAndTiming.cellROI_2D, bleachROI);
NormalizedSampleFunction[] roiSampleFunctions = new NormalizedSampleFunction[dataROIs.length];
for (int i = 0; i < dataROIs.length; i++) {
roiSampleFunctions[i] = NormalizedSampleFunction.fromROI(dataROIs[i]);
}
GenerateReducedDataOp generateReducedNormalizedData = new GenerateReducedDataOp();
RowColumnResultSet reducedData = generateReducedNormalizedData.generateReducedData(normalizedFrapResults.normalizedFrapData, roiSampleFunctions);
ComputeMeasurementErrorOp computeMeasurementError = new ComputeMeasurementErrorOp();
RowColumnResultSet measurementError = computeMeasurementError.computeNormalizedMeasurementError(roiSampleFunctions, geometryAndTiming.indexOfFirstPostbleach, rawTimeSeriesImages, normalizedFrapResults.prebleachAverage, clientTaskStatusSupport);
GenerateTrivial2DPsfOp psf_2D = new GenerateTrivial2DPsfOp();
UShortImage psf = psf_2D.generateTrivial2D_Psf();
// RunRefSimulationOp runRefSimulationFull = new RunRefSimulationOp();
// GenerateReducedROIDataOp generateReducedRefSimData = new GenerateReducedROIDataOp();
RunRefSimulationFastOp runRefSimulationFast = new RunRefSimulationFastOp();
RowColumnResultSet refData = runRefSimulationFast.runRefSimFast(geometryAndTiming.cellROI_2D, normalizedFrapResults.normalizedFrapData, dataROIs, psf, localWorkspace, clientTaskStatusSupport);
final double refDiffusionRate = 1.0;
double[] refSimTimePoints = refData.extractColumn(0);
int numRois = refData.getDataColumnCount() - 1;
int numRefSimTimes = refData.getRowCount();
double[][] refSimData = new double[numRois][numRefSimTimes];
for (int roi = 0; roi < numRois; roi++) {
double[] roiData = refData.extractColumn(roi + 1);
for (int t = 0; t < numRefSimTimes; t++) {
refSimData[roi][t] = roiData[t];
}
}
ErrorFunction errorFunction = new ErrorFunctionNoiseWeightedL2();
OptModelOneDiff optModelOneDiff = new OptModelOneDiff(refSimData, refSimTimePoints, refDiffusionRate);
Generate2DOptContextOp generate2DOptContextOne = new Generate2DOptContextOp();
OptContext optContextOneDiff = generate2DOptContextOne.generate2DOptContext(optModelOneDiff, reducedData, measurementError, errorFunction);
RunProfileLikelihoodGeneralOp runProfileLikelihoodOne = new RunProfileLikelihoodGeneralOp();
ProfileData[] profileDataOne = runProfileLikelihoodOne.runProfileLikihood(optContextOneDiff, clientTaskStatusSupport);
// OptModelTwoDiffWithoutPenalty optModelTwoDiffWithoutPenalty = new OptModelTwoDiffWithoutPenalty(refSimData, refSimTimePoints, refDiffusionRate);
// Generate2DOptContextOp generate2DOptContextTwoWithoutPenalty = new Generate2DOptContextOp();
// OptContext optContextTwoDiffWithoutPenalty = generate2DOptContextTwoWithoutPenalty.generate2DOptContext(optModelTwoDiffWithoutPenalty, reducedData, measurementError);
// RunProfileLikelihoodGeneralOp runProfileLikelihoodTwoWithoutPenalty = new RunProfileLikelihoodGeneralOp();
// ProfileData[] profileDataTwoWithoutPenalty = runProfileLikelihoodTwoWithoutPenalty.runProfileLikihood(optContextTwoDiffWithoutPenalty, clientTaskStatusSupport);
OptModelTwoDiffWithPenalty optModelTwoDiffWithPenalty = new OptModelTwoDiffWithPenalty(refSimData, refSimTimePoints, refDiffusionRate);
Generate2DOptContextOp generate2DOptContextTwoWithPenalty = new Generate2DOptContextOp();
OptContext optContextTwoDiffWithPenalty = generate2DOptContextTwoWithPenalty.generate2DOptContext(optModelTwoDiffWithPenalty, reducedData, measurementError, errorFunction);
RunProfileLikelihoodGeneralOp runProfileLikelihoodTwoWithPenalty = new RunProfileLikelihoodGeneralOp();
ProfileData[] profileDataTwoWithPenalty = runProfileLikelihoodTwoWithPenalty.runProfileLikihood(optContextTwoDiffWithPenalty, clientTaskStatusSupport);
//
// SLOW WAY
//
// runRefSimulationFull.cellROI_2D,generateCellROIs.cellROI_2D);
// runRefSimulationFull.normalizedTimeSeries,generateNormalizedFrapData.normalizedFrapData);
// workflow.addTask(runRefSimulationFull);
// generateReducedRefSimData.imageTimeSeries,runRefSimulationFull.refSimTimeSeries);
// generateReducedRefSimData.imageDataROIs,generateDependentROIs.imageDataROIs);
// workflow.addTask(generateReducedRefSimData);
// DataHolder<RowColumnResultSet> reducedROIData = generateReducedRefSimData.reducedROIData;
// DataHolder<Double> refSimDiffusionRate = runRefSimulationFull.refSimDiffusionRate;
VFrapProcessResults results = new VFrapProcessResults(dataROIs, geometryAndTiming.cellROI_2D, bleachROI, normalizedFrapResults.normalizedFrapData, reducedData, profileDataOne, profileDataTwoWithPenalty);
return results;
}
use of org.vcell.vmicro.op.Generate2DOptContextOp 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);
}
}
use of org.vcell.vmicro.op.Generate2DOptContextOp in project vcell by virtualcell.
the class Generate2DOptContext method compute0.
@Override
protected void compute0(TaskContext context, final ClientTaskStatusSupport clientTaskStatusSupport) throws ExpressionException {
// get inputs
RowColumnResultSet normExpDataset = context.getData(normExpData);
RowColumnResultSet measurementErrorDataset = context.getData(normalizedMeasurementErrors);
OptModel optmodel = context.getData(optModel);
// do op
Generate2DOptContextOp op = new Generate2DOptContextOp();
ErrorFunction errorFunction = context.getData(this.errorFunction);
OptContext optcontext = op.generate2DOptContext(optmodel, normExpDataset, measurementErrorDataset, errorFunction);
// set output
context.setData(optContext, optcontext);
}
use of org.vcell.vmicro.op.Generate2DOptContextOp in project vcell by virtualcell.
the class KenworthyWorkflowTest method analyzeKeyworthy.
/**
* Fits raw image time series data to uniform disk models (with Guassian or Uniform fluorescence).
*
* @param rawTimeSeriesImages
* @param localWorkspace
* @throws Exception
*/
private static void analyzeKeyworthy(ImageTimeSeries<UShortImage> rawTimeSeriesImages, LocalWorkspace localWorkspace) throws Exception {
new DisplayTimeSeriesOp().displayImageTimeSeries(rawTimeSeriesImages, "raw images", (WindowListener) null);
double cellThreshold = 0.5;
GeometryRoisAndBleachTiming cellROIresults = new GenerateCellROIsFromRawFrapTimeSeriesOp().generate(rawTimeSeriesImages, cellThreshold);
ROI backgroundROI = cellROIresults.backgroundROI_2D;
ROI cellROI = cellROIresults.cellROI_2D;
int indexOfFirstPostbleach = cellROIresults.indexOfFirstPostbleach;
new DisplayImageOp().displayImage(backgroundROI.getRoiImages()[0], "background ROI", null);
new DisplayImageOp().displayImage(cellROI.getRoiImages()[0], "cell ROI", null);
NormalizedFrapDataResults normResults = new GenerateNormalizedFrapDataOp().generate(rawTimeSeriesImages, backgroundROI, indexOfFirstPostbleach);
ImageTimeSeries<FloatImage> normalizedTimeSeries = normResults.normalizedFrapData;
FloatImage prebleachAvg = normResults.prebleachAverage;
FloatImage normalizedPostbleach = normalizedTimeSeries.getAllImages()[0];
new DisplayTimeSeriesOp().displayImageTimeSeries(normalizedTimeSeries, "normalized images", (WindowListener) null);
//
// create a single bleach ROI by thresholding
//
double bleachThreshold = 0.80;
ROI bleachROI = new GenerateBleachRoiOp().generateBleachRoi(normalizedPostbleach, cellROI, bleachThreshold);
//
// only use bleach ROI for fitting etc.
//
// ROI[] dataROIs = new ROI[] { bleachROI };
//
// fit 2D Gaussian to normalized data to determine center, radius and K factor of bleach (assuming exp(-exp
//
FitBleachSpotOpResults fitSpotResults = new FitBleachSpotOp().fit(NormalizedSampleFunction.fromROI(bleachROI), normalizedTimeSeries.getAllImages()[0]);
double bleachFactorK_GaussianFit = fitSpotResults.bleachFactorK_GaussianFit;
double bleachRadius_GaussianFit = fitSpotResults.bleachRadius_GaussianFit;
double bleachRadius_ROI = fitSpotResults.bleachRadius_ROI;
double centerX_GaussianFit = fitSpotResults.centerX_GaussianFit;
double centerX_ROI = fitSpotResults.centerX_ROI;
double centerY_GaussianFit = fitSpotResults.centerY_GaussianFit;
double centerY_ROI = fitSpotResults.centerY_ROI;
NormalizedSampleFunction[] sampleFunctions = new NormalizedSampleFunction[] { NormalizedSampleFunction.fromROI(bleachROI) };
//
// get reduced data and errors for each ROI
//
RowColumnResultSet reducedData = new GenerateReducedDataOp().generateReducedData(normalizedTimeSeries, sampleFunctions);
RowColumnResultSet measurementErrors = new ComputeMeasurementErrorOp().computeNormalizedMeasurementError(sampleFunctions, indexOfFirstPostbleach, rawTimeSeriesImages, prebleachAvg, null);
ErrorFunction errorFunction = new ErrorFunctionKenworthy(reducedData);
//
// 2 parameter uniform disk model
//
OptModel uniformDisk2OptModel = new OptModelKenworthyUniformDisk2P(bleachRadius_ROI);
String title_u2 = "Uniform Disk Model - 2 parameters, (Rn=" + bleachRadius_ROI + ")";
OptContext uniformDisk2Context = new Generate2DOptContextOp().generate2DOptContext(uniformDisk2OptModel, reducedData, measurementErrors, errorFunction);
new DisplayInteractiveModelOp().displayOptModel(uniformDisk2Context, sampleFunctions, localWorkspace, title_u2, null);
//
// 3 parameter uniform disk model
//
OptModel uniformDisk3OptModel = new OptModelKenworthyUniformDisk3P(bleachRadius_ROI);
OptContext uniformDisk3Context = new Generate2DOptContextOp().generate2DOptContext(uniformDisk3OptModel, reducedData, measurementErrors, errorFunction);
String title_u3 = "Uniform Disk Model - 3 parameters, (Rn=" + bleachRadius_ROI + ")";
new DisplayInteractiveModelOp().displayOptModel(uniformDisk3Context, sampleFunctions, localWorkspace, title_u3, null);
//
// GaussianFit parameter uniform disk model
//
FloatImage prebleachBleachAreaImage = new FloatImage(prebleachAvg);
// mask-out all but the bleach area
prebleachBleachAreaImage.and(bleachROI.getRoiImages()[0]);
double prebleachAvgInROI = prebleachBleachAreaImage.getImageStatistics().meanValue;
OptModel gaussian2OptModel = new OptModelKenworthyGaussian(prebleachAvgInROI, bleachFactorK_GaussianFit, bleachRadius_GaussianFit, bleachRadius_ROI);
OptContext gaussianDisk2Context = new Generate2DOptContextOp().generate2DOptContext(gaussian2OptModel, reducedData, measurementErrors, errorFunction);
String title_g2 = "Gaussian Disk Model - 2 parameters (prebleach=" + prebleachAvgInROI + ",K=" + bleachFactorK_GaussianFit + ",Re=" + bleachRadius_GaussianFit + ",Rnom=" + bleachRadius_ROI + ")";
new DisplayInteractiveModelOp().displayOptModel(gaussianDisk2Context, sampleFunctions, localWorkspace, title_g2, null);
}
use of org.vcell.vmicro.op.Generate2DOptContextOp in project vcell by virtualcell.
the class KenworthyParticleTest method analyzeKeyworthy.
/**
* Fits raw image time series data to uniform disk models (with Guassian or Uniform fluorescence).
*
* @param rawTimeSeriesImages
* @param localWorkspace
* @throws Exception
*/
private static void analyzeKeyworthy(ImageTimeSeries<UShortImage> rawTimeSeriesImages, RowColumnResultSet reducedData, LocalWorkspace localWorkspace) throws Exception {
new DisplayTimeSeriesOp().displayImageTimeSeries(rawTimeSeriesImages, "raw images", (WindowListener) null);
// double cellThreshold = 0.5;
// GeometryRoisAndBleachTiming cellROIresults = new GenerateCellROIsFromRawFrapTimeSeriesOp().generate(rawTimeSeriesImages, cellThreshold);
// ROI backgroundROI = cellROIresults.backgroundROI_2D;
// ROI cellROI = cellROIresults.cellROI_2D;
// int indexOfFirstPostbleach = cellROIresults.indexOfFirstPostbleach;
//
// new DisplayImageOp().displayImage(backgroundROI.getRoiImages()[0], "background ROI", null);
// new DisplayImageOp().displayImage(cellROI.getRoiImages()[0], "cell ROI", null);
//
// NormalizedFrapDataResults normResults = new GenerateNormalizedFrapDataOp().generate(rawTimeSeriesImages, backgroundROI, indexOfFirstPostbleach);
// ImageTimeSeries<FloatImage> normalizedTimeSeries = normResults.normalizedFrapData;
// FloatImage prebleachAvg = normResults.prebleachAverage;
// FloatImage normalizedPostbleach = normalizedTimeSeries.getAllImages()[0];
//
//
// new DisplayTimeSeriesOp().displayImageTimeSeries(normalizedTimeSeries, "normalized images", (WindowListener)null);
// //
// // create a single bleach ROI by thresholding
// //
// double bleachThreshold = 0.80;
// ROI bleachROI = new GenerateBleachRoiOp().generateBleachRoi(normalizedPostbleach, cellROI, bleachThreshold);
//
// //
// // only use bleach ROI for fitting etc.
// //
// // ROI[] dataROIs = new ROI[] { bleachROI };
//
// //
// // fit 2D Gaussian to normalized data to determine center, radius and K factor of bleach (assuming exp(-exp
// //
// FitBleachSpotOpResults fitSpotResults = new FitBleachSpotOp().fit(NormalizedSampleFunction.fromROI(bleachROI), normalizedTimeSeries.getAllImages()[0]);
// double bleachFactorK_GaussianFit = fitSpotResults.bleachFactorK_GaussianFit;
// double bleachRadius_GaussianFit = fitSpotResults.bleachRadius_GaussianFit;
// double bleachRadius_ROI = fitSpotResults.bleachRadius_ROI;
// double centerX_GaussianFit = fitSpotResults.centerX_GaussianFit;
// double centerX_ROI = fitSpotResults.centerX_ROI;
// double centerY_GaussianFit = fitSpotResults.centerY_GaussianFit;
// double centerY_ROI = fitSpotResults.centerY_ROI;
//
// NormalizedSampleFunction[] sampleFunctions = new NormalizedSampleFunction[] {
// NormalizedSampleFunction.fromROI(bleachROI)
// };
//
// get reduced data and errors for each ROI
//
// RowColumnResultSet reducedData = new GenerateReducedDataOp().generateReducedData(normalizedTimeSeries, sampleFunctions);
RowColumnResultSet measurementErrors = new RowColumnResultSet(new String[] { reducedData.getColumnDescriptions()[0].getName(), reducedData.getColumnDescriptions()[1].getName() });
for (int i = 0; i < reducedData.getRowCount(); i++) {
double[] row = new double[] { reducedData.getRow(i)[0], Math.sqrt(reducedData.getRow(i)[1]) };
measurementErrors.addRow(row);
}
new DisplayPlotOp().displayPlot(reducedData, "raw reduced data", null);
new DisplayPlotOp().displayPlot(measurementErrors, "raw reduced noise", null);
//
// find large drop and determine first post-bleach timepoint.
//
double largestDrop = -1000000;
int indexLargestDrop = -1;
for (int i = 1; i < reducedData.getRowCount(); i++) {
double drop = reducedData.getRow(i - 1)[1] - reducedData.getRow(i)[1];
if (drop > largestDrop) {
indexLargestDrop = i;
largestDrop = drop;
}
}
System.out.println("index of first postbleach is " + indexLargestDrop);
//
// normalize data and noise and start with first post-bleach index;
//
RowColumnResultSet normalizedReducedData = new RowColumnResultSet(new String[] { reducedData.getColumnDescriptions()[0].getName(), reducedData.getColumnDescriptions()[1].getName() });
RowColumnResultSet normalizedNoiseData = new RowColumnResultSet(new String[] { reducedData.getColumnDescriptions()[0].getName(), reducedData.getColumnDescriptions()[1].getName() });
for (int i = indexLargestDrop; i < reducedData.getRowCount(); i++) {
double timeAfterBleach = reducedData.getRow(i)[0] - reducedData.getRow(indexLargestDrop)[0];
double normalizedData = reducedData.getRow(i)[1] / reducedData.getRow(0)[1];
double[] newDataRow = new double[] { timeAfterBleach, normalizedData };
normalizedReducedData.addRow(newDataRow);
double normalizedNoise = measurementErrors.getRow(i)[1] / reducedData.getRow(0)[1];
double[] newNoiseRow = new double[] { timeAfterBleach, normalizedNoise };
normalizedNoiseData.addRow(newNoiseRow);
}
new DisplayPlotOp().displayPlot(normalizedReducedData, "normalized reduced data", null);
new DisplayPlotOp().displayPlot(normalizedNoiseData, "normalized reduced noise", null);
NormalizedSampleFunction[] sampleFunctions = new NormalizedSampleFunction[] { NormalizedSampleFunction.createUniform("psf", null, null, new ISize(10, 10, 1)) };
ErrorFunction errorFunction = new ErrorFunctionKenworthy(normalizedReducedData);
// ErrorFunction errorFunction = new ErrorFunctionMeanSquared();
double bleachRadius_ROI = 2;
//
// 2 parameter uniform disk model
//
OptModel uniformDisk2OptModel = new OptModelKenworthyUniformDisk2P(bleachRadius_ROI);
String title_u2 = "Uniform Disk Model - 2 parameters, (Rn=" + bleachRadius_ROI + ")";
OptContext uniformDisk2Context = new Generate2DOptContextOp().generate2DOptContext(uniformDisk2OptModel, normalizedReducedData, normalizedNoiseData, errorFunction);
new DisplayInteractiveModelOp().displayOptModel(uniformDisk2Context, sampleFunctions, localWorkspace, title_u2, null);
//
// 3 parameter uniform disk model
//
OptModel uniformDisk3OptModel = new OptModelKenworthyUniformDisk3P(bleachRadius_ROI);
OptContext uniformDisk3Context = new Generate2DOptContextOp().generate2DOptContext(uniformDisk3OptModel, normalizedReducedData, normalizedNoiseData, errorFunction);
String title_u3 = "Uniform Disk Model - 3 parameters, (Rn=" + bleachRadius_ROI + ")";
new DisplayInteractiveModelOp().displayOptModel(uniformDisk3Context, sampleFunctions, localWorkspace, title_u3, null);
ProfileData[] profileData = new RunProfileLikelihoodGeneralOp().runProfileLikihood(uniformDisk3Context, null);
new DisplayProfileLikelihoodPlotsOp().displayProfileLikelihoodPlots(profileData, "3param model", null);
//
// GaussianFit parameter uniform disk model
//
// FloatImage prebleachBleachAreaImage = new FloatImage(prebleachAvg);
// prebleachBleachAreaImage.and(bleachROI.getRoiImages()[0]); // mask-out all but the bleach area
// double prebleachAvgInROI = prebleachBleachAreaImage.getImageStatistics().meanValue;
// OptModel gaussian2OptModel = new OptModelKenworthyGaussian(prebleachAvgInROI, bleachFactorK_GaussianFit, bleachRadius_GaussianFit, bleachRadius_ROI);
// OptContext gaussianDisk2Context = new Generate2DOptContextOp().generate2DOptContext(gaussian2OptModel, reducedData, measurementErrors, errorFunction);
// String title_g2 = "Gaussian Disk Model - 2 parameters (prebleach="+prebleachAvgInROI+",K="+bleachFactorK_GaussianFit+",Re="+bleachRadius_GaussianFit+",Rnom="+bleachRadius_ROI+")";
// new DisplayInteractiveModelOp().displayOptModel(gaussianDisk2Context, sampleFunctions, localWorkspace, title_g2, null);
}
Aggregations