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

Example 1 with RawResultProcedure

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

the class CreateData method showSimulationParametersDialog.

private SimulationParameters showSimulationParametersDialog(ImagePlus imp, MemoryPeakResults results) {
    final int molecules = results.size();
    // Get the missing parameters from the user
    boolean fullSimulation = false;
    double sd = -1;
    if (!results.convertToPreferredUnits()) {
        IJ.error(TITLE, String.format("Results should be in the preferred units (%s,%s)", UnitHelper.getName(MemoryPeakResults.PREFERRED_DISTANCE_UNIT), UnitHelper.getName(MemoryPeakResults.PREFERRED_INTENSITY_UNIT)));
        return null;
    }
    // Get these from the data
    final RawResultProcedure sp = new RawResultProcedure(results);
    sp.getBixyz();
    final float[] signal = sp.intensity;
    float[] limits = MathUtils.limits(signal);
    final double minSignal = limits[0];
    final double maxSignal = limits[1];
    final double signalPerFrame = MathUtils.sum(signal) / molecules;
    final float[] depths = sp.z;
    limits = MathUtils.limits(depths);
    float depth = Math.max(Math.abs(limits[0]), Math.abs(limits[1]));
    final boolean fixedDepth = Double.compare(limits[0], limits[1]) == 0;
    final CalibrationWriter cal = results.getCalibrationWriter();
    final String iUnits = " " + UnitHelper.getName(cal.getIntensityUnit());
    final String zUnits = " " + UnitHelper.getName(cal.getDistanceUnit());
    // Get this from the user
    double background = -1;
    // Use last simulation parameters for missing settings.
    // This is good if we are re-running the plugin to load data.
    Rectangle lastCameraBounds = null;
    if (simulationParameters != null && simulationParameters.isLoaded()) {
        fullSimulation = simulationParameters.fullSimulation;
        sd = simulationParameters.sd;
        background = simulationParameters.background;
        if (!cal.hasBias()) {
            cal.setBias(simulationParameters.bias);
        }
        if (!cal.hasCountPerPhoton()) {
            cal.setCountPerPhoton(simulationParameters.gain);
        }
        if (!cal.hasQuantumEfficiency()) {
            cal.setQuantumEfficiency(simulationParameters.qe);
        }
        if (!cal.hasReadNoise()) {
            cal.setReadNoise(simulationParameters.readNoise);
        }
        if (!cal.hasCameraType()) {
            cal.setCameraType(simulationParameters.cameraType);
        }
        if (!cal.hasNmPerPixel()) {
            cal.setNmPerPixel(simulationParameters.pixelPitch);
        }
        if (!cal.hasCameraModelName()) {
            cal.setCameraModelName(simulationParameters.cameraModelName);
        }
        lastCameraBounds = simulationParameters.cameraBounds;
    }
    // Show a dialog to confirm settings
    final ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    final StringBuilder sb = new StringBuilder();
    sb.append("Results contain ").append(TextUtils.pleural(molecules, "molecule")).append('\n');
    sb.append("Min signal = ").append(MathUtils.rounded(minSignal)).append(iUnits).append('\n');
    sb.append("Max signal = ").append(MathUtils.rounded(maxSignal)).append(iUnits).append('\n');
    sb.append("Av signal = ").append(MathUtils.rounded(signalPerFrame)).append(iUnits).append('\n');
    if (fixedDepth) {
        sb.append("Fixed depth = ").append(MathUtils.rounded(depth)).append(zUnits).append('\n');
    }
    gd.addMessage(sb.toString());
    gd.addCheckbox("Flourophore_simulation", fullSimulation);
    gd.addNumericField("Gaussian_SD", sd, 3, 8, "nm");
    gd.addNumericField("Pixel_pitch", cal.getNmPerPixel(), 3, 8, "nm");
    gd.addNumericField("Background", background, 3, 8, "photon");
    // Camera type does not need the full simulation settings. Plus the units are different
    // so just re-implement.
    gd.addChoice("Camera_type", SettingsManager.getCameraTypeNames(), CalibrationProtosHelper.getName(cal.getCameraType()), new OptionListener<Integer>() {

        @Override
        public boolean collectOptions(Integer field) {
            cal.setCameraType(SettingsManager.getCameraTypeValues()[field]);
            return collectOptions(false);
        }

        @Override
        public boolean collectOptions() {
            return collectOptions(true);
        }

        private boolean collectOptions(boolean silent) {
            final CameraType cameraType = cal.getCameraType();
            final boolean isCcd = CalibrationProtosHelper.isCcdCameraType(cameraType);
            final ExtendedGenericDialog egd = new ExtendedGenericDialog(TITLE, null);
            if (isCcd) {
                egd.addNumericField("Total_gain", cal.getCountPerPhoton(), 3, 8, "count/photon");
                egd.addNumericField("Quantum_efficiency", cal.getQuantumEfficiency(), 3, 8, "e-/photon");
                egd.addNumericField("Read_noise", cal.getReadNoise(), 3, 8, "count");
                egd.addNumericField("Bias", cal.getBias(), 3, 8, "count");
            } else if (cameraType == CameraType.SCMOS) {
                final String[] models = CameraModelManager.listCameraModels(true);
                egd.addChoice("Camera_model_name", models, cal.getCameraModelName());
                egd.addNumericField("Quantum_efficiency", cal.getQuantumEfficiency(), 2, 6, "electron/photon");
            } else {
                IJ.error("Unsupported camera type " + CalibrationProtosHelper.getName(cameraType));
                return false;
            }
            egd.setSilent(silent);
            egd.showDialog(true, gd);
            if (egd.wasCanceled()) {
                return false;
            }
            if (isCcd) {
                cal.setCountPerPhoton(egd.getNextNumber());
                cal.setQuantumEfficiency(egd.getNextNumber());
                cal.setReadNoise(egd.getNextNumber());
                cal.setBias(egd.getNextNumber());
            } else if (cameraType == CameraType.SCMOS) {
                cal.setCameraModelName(egd.getNextChoice());
                cal.setQuantumEfficiency(Math.abs(egd.getNextNumber()));
            }
            return true;
        }
    });
    if (!fixedDepth) {
        gd.addNumericField("Depth", depth, 3, 8, "pixel");
    }
    gd.addHelp(HelpUrls.getUrl("load-benchmark-data"));
    gd.showDialog();
    if (gd.wasCanceled()) {
        return null;
    }
    fullSimulation = gd.getNextBoolean();
    sd = gd.getNextNumber();
    cal.setNmPerPixel(gd.getNextNumber());
    background = gd.getNextNumber();
    cal.setCameraType(SettingsManager.getCameraTypeValues()[gd.getNextChoiceIndex()]);
    float myDepth = depth;
    if (!fixedDepth) {
        myDepth = (float) gd.getNextNumber();
        if (myDepth < depth) {
            IJ.error(TITLE, String.format("Input depth is smaller than the depth guessed from the data: %f < %f", myDepth, depth));
            return null;
        }
        depth = myDepth;
    }
    gd.collectOptions();
    // Validate settings
    Rectangle modelBounds = null;
    try {
        ParameterUtils.isAboveZero("Gaussian SD", sd);
        ParameterUtils.isAboveZero("Pixel pitch", cal.getNmPerPixel());
        ParameterUtils.isPositive("Background", background);
        ParameterUtils.isAboveZero("Quantum efficiency", cal.getQuantumEfficiency());
        ParameterUtils.isEqualOrBelow("Quantum efficiency", cal.getQuantumEfficiency(), 1);
        if (cal.isCcdCamera()) {
            ParameterUtils.isAboveZero("Total gain", cal.getCountPerPhoton());
            ParameterUtils.isPositive("Read noise", cal.getReadNoise());
            ParameterUtils.isPositive("Bias", cal.getBias());
        } else if (cal.isScmos()) {
            // Load the model
            cameraModel = CameraModelManager.load(cal.getCameraModelName());
            if (cameraModel == null) {
                IJ.error(TITLE, "Unknown camera model for name: " + cal.getCameraModelName());
                return null;
            }
            int ox = 0;
            int oy = 0;
            if (lastCameraBounds != null) {
                ox = lastCameraBounds.x;
                oy = lastCameraBounds.y;
            }
            cameraModel = PeakFit.cropCameraModel(cameraModel, new Rectangle(ox, oy, imp.getWidth(), imp.getHeight()), null, false);
            modelBounds = cameraModel.getBounds();
            final IJImageSource imageSource = (IJImageSource) results.getSource();
            imageSource.setOrigin(modelBounds.x, modelBounds.y);
            cal.clearGlobalCameraSettings();
        } else {
            IJ.error(TITLE, "Unknown camera type: " + cal.getCameraType());
            return null;
        }
    } catch (final IllegalArgumentException ex) {
        IJ.error(TITLE, ex.getMessage());
        return null;
    }
    // Store calibration
    results.setCalibration(cal.getCalibration());
    final double a = cal.getNmPerPixel();
    final double bias = cal.getBias();
    final double gain = cal.getCountPerPhoton();
    final double readNoise = cal.getReadNoise();
    final double qe = cal.getQuantumEfficiency();
    // Note: The calibration will throw an exception if the converter cannot be created.
    // This is OK as the data will be invalid.
    // Convert +/- depth to total depth in nm
    depth = cal.getDistanceConverter(DistanceUnit.NM).convert(depth * 2);
    // Compute total background variance in photons
    final double backgroundVariance = background;
    // Do not add EM-CCD noise factor. The Mortensen formula also includes this factor
    // so this is "double-counting" the EM-CCD.
    // if (emCCD)
    // backgroundVariance *= 2;
    // Read noise is in ADUs. Convert to Photons to get contribution to background variance
    final double readNoiseInPhotons = readNoise / gain;
    // Get the expected value at each pixel in photons. Assuming a Poisson distribution this
    // is equal to the total variance at the pixel.
    final double b2 = backgroundVariance + readNoiseInPhotons * readNoiseInPhotons;
    // Convert values to photons
    final TypeConverter<IntensityUnit> ic = cal.getIntensityConverter(IntensityUnit.PHOTON);
    final SimulationParameters p = new SimulationParameters(molecules, fullSimulation, sd, a, ic.convert(minSignal), ic.convert(maxSignal), ic.convert(signalPerFrame), depth, fixedDepth, bias, gain, qe, readNoise, cal.getCameraType(), cal.getCameraModelName(), modelBounds, background, b2, createPsf(sd / a));
    p.loaded = true;
    return p;
}

Example 2 with RawResultProcedure

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

the class ImageJ3DResultsViewer method createAlphaFromIntensity.

@Nullable
private static float[] createAlphaFromIntensity(MemoryPeakResults results, double minA, double maxA) {
    final RawResultProcedure p = new RawResultProcedure(results);
    p.getI();
    final float[] intensity = p.intensity;
    final float[] limits = MathUtils.limits(intensity);
    final float min = limits[0];
    final float max = limits[1];
    if (min == max) {
        ImageJUtils.log("No per-item transparency as intensity is fixed");
        return null;
    }
    final double range = (maxA - minA) / (max - min);
    final float[] alpha = new float[intensity.length];
    for (int i = 0; i < alpha.length; i++) {
        // Lowest intensity has lowest alpha (more transparent)
        alpha[i] = (float) (minA + range * (intensity[i] - min));
    }
    return alpha;
}