use of gdsc.smlm.results.ExtendedPeakResult in project GDSC-SMLM by aherbert.
the class PeakFit method processResults.
private boolean processResults(FitEngine engine, ArrayList<PeakResult> sliceCandidates, int slice) {
// Process results
int[] maxIndices = new int[sliceCandidates.size()];
int count = 0;
ArrayList<PeakResult> processedResults = new ArrayList<PeakResult>(sliceCandidates.size());
for (PeakResult result : sliceCandidates) {
// Add ExtendedPeakResults to the results if they span multiple frames (they are the result of previous fitting).
if (result instanceof ExtendedPeakResult && result.getFrame() != result.getEndFrame()) {
processedResults.add(result);
} else {
// Fit single frame results.
maxIndices[count++] = result.origX + bounds.width * result.origY;
}
}
if (!processedResults.isEmpty())
this.results.addAll(processedResults);
if (count != 0) {
float[] data = source.get(slice);
if (data == null)
return false;
FitParameters fitParams = new FitParameters();
fitParams.maxIndices = Arrays.copyOf(maxIndices, count);
FitJob job = new ParameterisedFitJob(fitParams, slice, data, bounds);
engine.run(job);
}
return true;
}
use of gdsc.smlm.results.ExtendedPeakResult in project GDSC-SMLM by aherbert.
the class DiffusionRateTest method record.
private int record(double[] xyz, int id, int peak, Statistics stats2D, Statistics stats3D, StoredDataStatistics jumpDistances2D, StoredDataStatistics jumpDistances3D, double[] origin, MemoryPeakResults results) {
final double dx = xyz[0] - origin[0];
final double dy = xyz[1] - origin[1];
final double dz = xyz[2] - origin[2];
final double jump2D = dx * dx + dy * dy;
jumpDistances2D.add(jump2D);
jumpDistances3D.add(jump2D + dz * dz);
for (int i = 0; i < 3; i++) origin[i] = xyz[i];
final double d2 = squared2D(xyz);
stats2D.add(d2);
stats3D.add(d2 + xyz[2] * xyz[2]);
final float[] params = new float[7];
params[Gaussian2DFunction.X_POSITION] = (float) xyz[0];
params[Gaussian2DFunction.Y_POSITION] = (float) xyz[1];
params[Gaussian2DFunction.SIGNAL] = 10f;
params[Gaussian2DFunction.X_SD] = params[Gaussian2DFunction.Y_SD] = 1;
final float noise = 0.1f;
results.add(new ExtendedPeakResult(peak, (int) params[Gaussian2DFunction.X_POSITION], (int) params[Gaussian2DFunction.Y_POSITION], 10, 0, noise, params, null, peak, id));
return ++peak;
}
use of gdsc.smlm.results.ExtendedPeakResult in project GDSC-SMLM by aherbert.
the class PCPALMClusters method doClustering.
/**
* Extract the results from the PCPALM molecules using the area ROI and then do clustering to obtain the histogram
* of molecules per cluster.
*
* @return
*/
private HistogramData doClustering() {
// Perform clustering analysis to generate the histogram of cluster sizes
PCPALMAnalysis analysis = new PCPALMAnalysis();
ArrayList<Molecule> molecules = analysis.cropToRoi(WindowManager.getCurrentImage());
if (molecules.size() < 2) {
error("No results within the crop region");
return null;
}
Utils.log("Using %d molecules (Density = %s um^-2) @ %s nm", molecules.size(), Utils.rounded(molecules.size() / analysis.croppedArea), Utils.rounded(distance));
long s1 = System.nanoTime();
ClusteringEngine engine = new ClusteringEngine(1, clusteringAlgorithm, new IJTrackProgress());
if (multiThread)
engine.setThreadCount(Prefs.getThreads());
engine.setTracker(new IJTrackProgress());
IJ.showStatus("Clustering ...");
ArrayList<Cluster> clusters = engine.findClusters(convertToPoint(molecules), distance);
IJ.showStatus("");
if (clusters == null) {
Utils.log("Aborted");
return null;
}
nMolecules = molecules.size();
Utils.log("Finished : %d total clusters (%s ms)", clusters.size(), Utils.rounded((System.nanoTime() - s1) / 1e6));
// Save cluster centroids to a results set in memory. Then they can be plotted.
MemoryPeakResults results = new MemoryPeakResults(clusters.size());
results.setName(TITLE);
// Set an arbitrary calibration so that the lifetime of the results is stored in the exposure time
// The results will be handled as a single mega-frame containing all localisation.
results.setCalibration(new Calibration(100, 1, PCPALMMolecules.seconds * 1000));
// Make the standard deviation such that the Gaussian volume will be 95% at the distance threshold
final float sd = (float) (distance / 1.959964);
int id = 0;
for (Cluster c : clusters) {
results.add(new ExtendedPeakResult((float) c.x, (float) c.y, sd, c.n, ++id));
}
MemoryPeakResults.addResults(results);
// Get the data for fitting
float[] values = new float[clusters.size()];
for (int i = 0; i < values.length; i++) values[i] = clusters.get(i).n;
float yMax = (int) Math.ceil(Maths.max(values));
int nBins = (int) (yMax + 1);
float[][] hist = Utils.calcHistogram(values, 0, yMax, nBins);
HistogramData histogramData = (calibrateHistogram) ? new HistogramData(hist, frames, area, units) : new HistogramData(hist);
saveHistogram(histogramData);
return histogramData;
}
use of gdsc.smlm.results.ExtendedPeakResult in project GDSC-SMLM by aherbert.
the class DiffusionRateTest method aggregateIntoFrames.
private void aggregateIntoFrames(ArrayList<Point> points, boolean addError, double precisionInPixels, RandomGenerator[] random) {
if (myAggregateSteps < 1)
return;
MemoryPeakResults results = new MemoryPeakResults(points.size() / myAggregateSteps);
Calibration cal = new Calibration(settings.pixelPitch, 1, myAggregateSteps * 1000.0 / settings.stepsPerSecond);
results.setCalibration(cal);
results.setName(TITLE + " Aggregated");
MemoryPeakResults.addResults(results);
lastSimulatedDataset[1] = results.getName();
int id = 0;
int peak = 1;
int n = 0;
double cx = 0, cy = 0;
// Get the mean square distance
double sum = 0;
int count = 0;
PeakResult last = null;
for (Point result : points) {
final boolean newId = result.id != id;
if (n >= myAggregateSteps || newId) {
if (n != 0) {
final float[] params = new float[7];
double[] xyz = new double[] { cx / n, cy / n };
if (addError)
xyz = addError(xyz, precisionInPixels, random);
params[Gaussian2DFunction.X_POSITION] = (float) xyz[0];
params[Gaussian2DFunction.Y_POSITION] = (float) xyz[1];
params[Gaussian2DFunction.SIGNAL] = n;
params[Gaussian2DFunction.X_SD] = params[Gaussian2DFunction.Y_SD] = 1;
final float noise = 0.1f;
PeakResult r = new ExtendedPeakResult(peak, (int) params[Gaussian2DFunction.X_POSITION], (int) params[Gaussian2DFunction.Y_POSITION], n, 0, noise, params, null, peak, id);
results.add(r);
if (last != null) {
sum += last.distance2(r);
count++;
}
last = r;
n = 0;
cx = cy = 0;
peak++;
}
if (newId) {
// Increment the frame so that tracing analysis can distinguish traces
peak++;
last = null;
id = result.id;
}
}
n++;
cx += result.x;
cy += result.y;
}
// Final peak
if (n != 0) {
final float[] params = new float[7];
double[] xyz = new double[] { cx / n, cy / n };
if (addError)
xyz = addError(xyz, precisionInPixels, random);
params[Gaussian2DFunction.X_POSITION] = (float) xyz[0];
params[Gaussian2DFunction.Y_POSITION] = (float) xyz[1];
params[Gaussian2DFunction.SIGNAL] = n;
params[Gaussian2DFunction.X_SD] = params[Gaussian2DFunction.Y_SD] = 1;
final float noise = 0.1f;
PeakResult r = new ExtendedPeakResult(peak, (int) params[Gaussian2DFunction.X_POSITION], (int) params[Gaussian2DFunction.Y_POSITION], n, 0, noise, params, null, peak, id);
results.add(r);
if (last != null) {
sum += last.distance2(r);
count++;
}
}
// MSD in pixels^2 / frame
double msd = sum / count;
// Convert to um^2/second
Utils.log("Aggregated data D=%s um^2/s, Precision=%s nm, N=%d, step=%s s, mean=%s um^2, MSD = %s um^2/s", Utils.rounded(settings.diffusionRate), Utils.rounded(myPrecision), count, Utils.rounded(results.getCalibration().getExposureTime() / 1000), Utils.rounded(msd / conversionFactor), Utils.rounded((msd / conversionFactor) / (results.getCalibration().getExposureTime() / 1000)));
msdAnalysis(points);
}
use of gdsc.smlm.results.ExtendedPeakResult in project GDSC-SMLM by aherbert.
the class CreateData method savePulses.
/**
* Create a set of results that represent the molecule continuous on-times (pulses)
*
* @param localisations
* @param results
* @param title
*/
private void savePulses(List<LocalisationModel> localisations, MemoryPeakResults results, String title) {
sortLocalisationsByIdThenTime(localisations);
MemoryPeakResults traceResults = copyMemoryPeakResults("Pulses");
LocalisationModel start = null;
int currentId = -1;
int n = 0;
float[] params = new float[7];
double noise = 0;
int lastT = -1;
for (LocalisationModel localisation : localisations) {
if (currentId != localisation.getId() || lastT + 1 != localisation.getTime()) {
if (n > 0) {
params[Gaussian2DFunction.BACKGROUND] /= n;
params[Gaussian2DFunction.X_POSITION] /= n;
params[Gaussian2DFunction.Y_POSITION] /= n;
params[Gaussian2DFunction.X_SD] /= n;
params[Gaussian2DFunction.Y_SD] /= n;
ExtendedPeakResult p = new ExtendedPeakResult(start.getTime(), (int) Math.round(start.getX()), (int) Math.round(start.getY()), 0, 0, (float) (Math.sqrt(noise)), params, null, lastT, currentId);
// if (p.getPrecision(107, 1) > 2000)
// {
// System.out.printf("Weird precision = %g (%d)\n", p.getPrecision(107, 1), n);
// }
traceResults.add(p);
}
start = localisation;
currentId = localisation.getId();
n = 0;
params = new float[7];
noise = 0;
}
final double[] data = localisation.getData();
params[Gaussian2DFunction.BACKGROUND] += data[0];
params[Gaussian2DFunction.X_POSITION] += localisation.getX();
params[Gaussian2DFunction.Y_POSITION] += localisation.getY();
params[Gaussian2DFunction.SIGNAL] += localisation.getIntensity();
noise += data[1] * data[1];
params[Gaussian2DFunction.X_SD] += data[2];
params[Gaussian2DFunction.Y_SD] += data[3];
n++;
lastT = localisation.getTime();
}
// Final pulse
if (n > 0) {
params[Gaussian2DFunction.BACKGROUND] /= n;
params[Gaussian2DFunction.X_POSITION] /= n;
params[Gaussian2DFunction.Y_POSITION] /= n;
params[Gaussian2DFunction.X_SD] /= n;
params[Gaussian2DFunction.Y_SD] /= n;
traceResults.add(new ExtendedPeakResult(start.getTime(), (int) Math.round(start.getX()), (int) Math.round(start.getY()), 0, 0, (float) (Math.sqrt(noise)), params, null, lastT, currentId));
}
traceResults.end();
}
Aggregations