use of cbit.vcell.VirtualMicroscopy.FloatImage 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 cbit.vcell.VirtualMicroscopy.FloatImage in project vcell by virtualcell.
the class ComputeMeasurementError method compute0.
@Override
protected void compute0(TaskContext context, final ClientTaskStatusSupport clientTaskStatusSupport) throws Exception {
ROI[] rois = context.getData(imageDataROIs);
int indexPostbleach = context.getData(indexFirstPostbleach);
ImageTimeSeries<UShortImage> rawImageDataset = context.getData(rawImageTimeSeries);
FloatImage prebleachAvgImage = context.getData(prebleachAverage);
ArrayList<NormalizedSampleFunction> roiSampleFunctions = new ArrayList<NormalizedSampleFunction>();
for (int i = 0; i < rois.length; i++) {
roiSampleFunctions.add(NormalizedSampleFunction.fromROI(rois[i]));
}
// do op
ComputeMeasurementErrorOp op = new ComputeMeasurementErrorOp();
NormalizedSampleFunction[] roiSampleFunctionArray = roiSampleFunctions.toArray(new NormalizedSampleFunction[0]);
RowColumnResultSet rowColumnResultSet = op.computeNormalizedMeasurementError(roiSampleFunctionArray, indexPostbleach, rawImageDataset, prebleachAvgImage, clientTaskStatusSupport);
// set output
context.setData(normalizedMeasurementError, rowColumnResultSet);
}
use of cbit.vcell.VirtualMicroscopy.FloatImage in project vcell by virtualcell.
the class RunSimulation2D method compute0.
@Override
protected void compute0(TaskContext context, final ClientTaskStatusSupport clientTaskStatusSupport) throws Exception {
// get input
LocalWorkspace localWorkspace = context.getLocalWorkspace();
Simulation sim = context.getData(simulation_2D);
String dataVar = context.getData(dataVarName);
// do op
RunSimulation2DOp op = new RunSimulation2DOp();
ImageTimeSeries<FloatImage> solution = op.runRefSimulation(localWorkspace, sim, dataVar, clientTaskStatusSupport);
// set output
context.setData(simTimeSeries, solution);
}
use of cbit.vcell.VirtualMicroscopy.FloatImage in project vcell by virtualcell.
the class RunRefSimulationFast method compute0.
@Override
protected void compute0(TaskContext context, final ClientTaskStatusSupport clientTaskStatusSupport) throws Exception {
ImageTimeSeries<FloatImage> normTimeSeries = context.getData(normalizedTimeSeries);
ROI cellROI = context.getData(cellROI_2D);
ROI[] imageDataRois = context.getData(imageDataROIs);
UShortImage psf = context.getData(this.psf);
// do op
RunRefSimulationFastOp op = new RunRefSimulationFastOp();
RowColumnResultSet reducedData = op.runRefSimFast(cellROI, normTimeSeries, imageDataRois, psf, context.getLocalWorkspace(), clientTaskStatusSupport);
// set output
context.setData(reducedROIData, reducedData);
// always D = 1,
context.setData(refSimDiffusionRate, op.getReferenceDiffusionCoef());
}
use of cbit.vcell.VirtualMicroscopy.FloatImage in project vcell by virtualcell.
the class FitTimeSeries method main.
public static void main(String[] args) {
try {
int numX = 100;
int numY = 100;
double center_i = 52.44;
double center_j = 51.39;
double K = 30;
double high = 0.9;
double sigma2 = 4;
float[] pixels = new float[numX * numY];
Origin origin = new Origin(0, 0, 0);
Extent extent = new Extent(1, 1, 1);
FloatImage image = new FloatImage(pixels, origin, extent, numX, numY, 1);
int index = 0;
for (int j = 0; j < numY; j++) {
for (int i = 0; i < numX; i++) {
double radius = ((i - center_i) * (i - center_i) + (j - center_j) * (j - center_j));
pixels[index++] = (float) (high - FastMath.exp(-K * FastMath.exp(-radius / sigma2)));
}
}
double init_center_i = 50;
double init_center_j = 50;
double init_sigma2 = 2;
GaussianFitResults fitResults = fitToGaussian(init_center_i, init_center_j, init_sigma2, image);
System.out.println(fitResults);
} catch (Exception e) {
e.printStackTrace();
}
}
Aggregations