Examples with PeakResult uk.ac.sussex.gdsc.smlm.results.PeakResult used on opensource projects

Example 31 with PeakResult

use of uk.ac.sussex.gdsc.smlm.results.PeakResult in project GDSC-SMLM by aherbert.

the class CropResults method roiCropResults.

private void roiCropResults() {
    final MemoryPeakResults newResults = createNewResults();
    // These bounds are integer. But this is because the results are meant to come from an image.
    final Rectangle integerBounds = results.getBounds(true);
    final ImagePlus imp = WindowManager.getImage(settings.getRoiImage());
    if (imp == null) {
        IJ.error(TITLE, "No ROI image: " + settings.getRoiImage());
        return;
    }
    final CoordinatePredicate roiTest = CoordinatePredicateUtils.createContainsPredicate(imp.getRoi());
    if (roiTest == null) {
        IJ.error(TITLE, "Not an area ROI");
        return;
    }
    // Scale the results to the size of the image with the ROI
    final int roiImageWidth = imp.getWidth();
    final int roiImageHeight = imp.getHeight();
    final double ox = integerBounds.getX();
    final double oy = integerBounds.getY();
    final double xscale = roiImageWidth / integerBounds.getWidth();
    final double yscale = roiImageHeight / integerBounds.getHeight();
    final Predicate<PeakResult> testZ = getZFilter();
    results.forEach(DistanceUnit.PIXEL, (XyrResultProcedure) (x, y, result) -> {
        if (roiTest.test((x - ox) * xscale, (y - oy) * yscale) && testZ.test(result)) {
            newResults.add(result);
        }
    });
    if (settings.getPreserveBounds()) {
        newResults.setBounds(integerBounds);
    } else {
        newResults.setBounds(null);
        newResults.getBounds(true);
    }
    IJ.showStatus(newResults.size() + " Cropped localisations");
}

Example 32 with PeakResult

use of uk.ac.sussex.gdsc.smlm.results.PeakResult in project GDSC-SMLM by aherbert.

the class ClassificationMatchCalculator method getCoordinates.

/**
 * Build a map between the peak id (time point) and a list of coordinates that pass the filter.
 *
 * @param results the results
 * @param test the test
 * @return the coordinates
 */
public static TIntObjectHashMap<List<PeakResultPoint>> getCoordinates(MemoryPeakResults results, Predicate<PeakResult> test) {
    final TIntObjectHashMap<List<PeakResultPoint>> coords = new TIntObjectHashMap<>();
    if (results.size() > 0) {
        // Do not use HashMap directly to build the coords object since there
        // will be many calls to getEntry(). Instead sort the results and use
        // a new list for each time point
        results.sort();
        // Create list
        final LocalList<PeakResultPoint> tmpCoords = new LocalList<>();
        // Add the results for each frame
        final FrameCounter counter = results.newFrameCounter();
        results.forEach(DistanceUnit.PIXEL, (XyzrResultProcedure) (x, y, z, r) -> {
            if (counter.advance(r.getFrame()) && !tmpCoords.isEmpty()) {
                coords.put(counter.previousFrame(), tmpCoords.copy());
                tmpCoords.clear();
            }
            if (test.test(r)) {
                tmpCoords.add(new PeakResultPoint(r.getFrame(), x, y, z, r));
            }
        });
        if (!tmpCoords.isEmpty()) {
            coords.put(counter.currentFrame(), tmpCoords.copy());
        }
    }
    return coords;
}

Example 33 with PeakResult

use of uk.ac.sussex.gdsc.smlm.results.PeakResult in project GDSC-SMLM by aherbert.

the class Filter method filterSubset2.

/**
 * Filter the results.
 *
 * <p>Input PeakResults must be allocated a score for true positive, false positive, true negative
 * and false negative (accessed via the object property get methods). The filter is run and
 * results that pass accumulate scores for true positive and false positive, otherwise the scores
 * are accumulated for true negative and false negative. The simplest scoring scheme is to mark
 * valid results as tp=fn=1 and fp=tn=0 and invalid results the opposite.
 *
 * <p>The number of consecutive rejections are counted per frame. When the configured number of
 * failures is reached all remaining results for the frame are rejected. This assumes the results
 * are ordered by the frame.
 *
 * <p>Note that this method is to be used to score a set of results that may have been extracted
 * from a larger set since the number of consecutive failures before each peak are expected to be
 * stored in the origY property. Set this to zero and the results should be identical to
 * {@link #filterSubset(MemoryPeakResults, double[])}.
 *
 * <p>The number of failures before each peak is stored in the origX property of the PeakResult.
 *
 * @param results the results
 * @param score If not null will be populated with the fraction score [ tp, fp, tn, fn, p, n ]
 * @return the filtered results
 */
public MemoryPeakResults filterSubset2(MemoryPeakResults results, double[] score) {
    final MemoryPeakResults newResults = new MemoryPeakResults();
    final FrameCounter counter = new FrameCounter();
    newResults.copySettings(results);
    setup(results);
    final double[] s = new double[4];
    final Counter p = new Counter();
    results.forEach((PeakResultProcedure) peak -> {
        counter.advanceAndReset(peak.getFrame());
        counter.increment(peak.getOrigY());
        final boolean isPositive = accept(peak);
        if (isPositive) {
            peak.setOrigX(counter.getCount());
            counter.reset();
            newResults.add(peak);
        } else {
            counter.increment();
        }
        if (isPositive) {
            p.increment();
            s[TP] += peak.getTruePositiveScore();
            s[FP] += peak.getFalsePositiveScore();
        } else {
            s[FN] += peak.getFalseNegativeScore();
            s[TN] += peak.getTrueNegativeScore();
        }
    });
    end();
    if (score != null && score.length > 5) {
        score[0] = s[TP];
        score[1] = s[FP];
        score[2] = s[TN];
        score[3] = s[FN];
        score[4] = p.getCount();
        score[5] = (double) results.size() - p.getCount();
    }
    return newResults;
}

Example 34 with PeakResult

use of uk.ac.sussex.gdsc.smlm.results.PeakResult in project GDSC-SMLM by aherbert.

the class Filter method scoreSubset.

/**
 * Filter the results and return the performance score. Allows benchmarking the filter by marking
 * the results as true or false.
 *
 * <p>Any input PeakResult with an original value that is not zero will be treated as a true
 * result, all other results are false. The filter is run and the results are marked as true
 * positive, false negative and false positive.
 *
 * <p>The number of consecutive rejections are counted per frame. When the configured number of
 * failures is reached all remaining results for the frame are rejected. This assumes the results
 * are ordered by the frame.
 *
 * <p>Note that this method is to be used to score a subset that was generated using
 * {@link #filterSubset(MemoryPeakResults, int, double[])} since the number of consecutive
 * failures before each peak are expected to be stored in the origX property.
 *
 * @param resultsList a list of results to analyse
 * @param failures the number of failures to allow per frame before all peaks are rejected
 * @param tn The initial true negatives (used when the results have been pre-filtered)
 * @param fn The initial false negatives (used when the results have been pre-filtered)
 * @return the score
 */
public ClassificationResult scoreSubset(List<MemoryPeakResults> resultsList, final int failures, int tn, int fn) {
    final int[] s = new int[4];
    s[TN] = tn;
    s[FN] = fn;
    for (final MemoryPeakResults peakResults : resultsList) {
        setup(peakResults);
        final FrameCounter counter = new FrameCounter();
        peakResults.forEach((PeakResultProcedure) peak -> {
            counter.advanceAndReset(peak.getFrame());
            final boolean isTrue = peak.getOrigValue() != 0;
            counter.increment(peak.getOrigX());
            final boolean isPositive;
            if (counter.getCount() > failures) {
                isPositive = false;
            } else {
                isPositive = accept(peak);
            }
            if (isPositive) {
                counter.reset();
            } else {
                counter.increment();
            }
            if (isTrue) {
                if (isPositive) {
                    s[TP]++;
                } else {
                    s[FN]++;
                }
            } else if (isPositive) {
                s[FP]++;
            } else {
                s[TN]++;
            }
        });
        end();
    }
    return new ClassificationResult(s[TP], s[FP], s[TN], s[FN]);
}

Example 35 with PeakResult

use of uk.ac.sussex.gdsc.smlm.results.PeakResult in project GDSC-SMLM by aherbert.

the class HysteresisFilter method getSearchDistanceUsingCandidates.

/**
 * Find average precision of the candidates and use it for the search distance.
 *
 * @param peakResults the peak results
 * @param candidates the candidates
 * @return the search distance using candidates
 */
private double getSearchDistanceUsingCandidates(MemoryPeakResults peakResults, LinkedList<PeakResult> candidates) {
    final Gaussian2DPeakResultCalculator calculator = Gaussian2DPeakResultHelper.create(peakResults.getPsf(), peakResults.getCalibration(), Gaussian2DPeakResultHelper.LSE_PRECISION);
    double sum = 0;
    for (final PeakResult peakResult : candidates) {
        sum += calculator.getLsePrecision(peakResult.getParameters(), peakResult.getNoise());
    }
    final double nmPerPixel = peakResults.getNmPerPixel();
    return (sum / candidates.size()) * searchDistance / nmPerPixel;
}