cluster : clusters) {
- for (DoublePoint featureVector : cluster.getPoints()) {
- double distance = new EuclideanDistance().compute(cluster.getCenter().getPoint(), featureVector.getPoint());
- wcss += distance * distance;
- }
- }
- if (wcss > previousWCSS) {
- break;
- }
- previousWCSS = wcss;
- optimalK = k;
- }
- return optimalK;
- }
-
- public static float[] applyGaussianBlur(float[] input, int width, int height, float sigma) {
- // Create a Gaussian kernel
- int size = (int) Math.ceil(sigma * 3) * 2 + 1;
- float[] kernel = new float[size];
- float sum = 0;
- for (int i = 0; i < size; i++) {
- float x = (float) (i - (size - 1) / 2.0);
- kernel[i] = (float) Math.exp(-x * x / (2 * sigma * sigma));
- sum += kernel[i];
- }
- for (int i = 0; i < size; i++) {
- kernel[i] /= sum;
- }
-
- // Create a temporary array for the blurred image
- float[] temp = new float[input.length];
-
- // Blur each row
- for (int y = 0; y < height; y++) {
- for (int x = 0; x < width; x++) {
- float sum1 = 0;
- float sum2 = 0;
- for (int i = 0; i < size; i++) {
- int x1 = x + i - (size - 1) / 2;
- if(x1 < 0 || x1 >= width) {
- continue;
- }
- int index = y*width+x1;
- float value = input[index];
- float weight = kernel[i];
- sum1 += value * weight;
- sum2 += weight;
- }
- int index = y * width + x;
- temp[index] = sum1 / sum2;
- }
- }
-
- // Blur each column
- for (int x = 0; x < width; x++) {
- for (int y = 0; y < height; y++) {
- float sum1 = 0;
- float sum2 = 0;
- for (int i = 0; i < size; i++) {
- int y1 = y + i - (size - 1) / 2;
- if (y1 < 0 || y1 >= height) {
- continue;
- }
- int index = y1 * width + x;
- float value = temp[index];
- float weight = kernel[i];
- sum1 += value * weight;
- sum2 += weight;
- }
- int index = y * width + x;
- input[index] = sum1 / sum2;
- }
- }
-
- return input;
- }
-}
\ No newline at end of file
diff --git a/src/main/java/RelevanceMaskStack2D_.java b/src/main/java/RelevanceMaskStack2D_.java
index 6beeabf..2c7be2d 100644
--- a/src/main/java/RelevanceMaskStack2D_.java
+++ b/src/main/java/RelevanceMaskStack2D_.java
@@ -199,28 +199,28 @@ public void run(String s) {
// Write input image to the OpenCL device
clRefPixels = context.createFloatBuffer(wh, READ_ONLY);
- GlobalRedundancy.fillBufferWithFloatArray(clRefPixels, refPixels);
+ CLUtils.fillBufferWithFloatArray(clRefPixels, refPixels);
queue.putWriteBuffer(clRefPixels, true);
// Create OpenCL program
- String programStringGetLocalStatistics = GlobalRedundancy.getResourceAsString(RelevanceMask2D_.class, "kernelGetRelevanceMask2D.cl");
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$WIDTH$", "" + w);
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$HEIGHT$", "" + h);
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$PATCH_SIZE$", "" + patchSize);
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$BRW$", "" + bRW);
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$BRH$", "" + bRH);
- programStringGetLocalStatistics = GlobalRedundancy.replaceFirst(programStringGetLocalStatistics, "$EPSILON$", "" + EPSILON);
+ String programStringGetLocalStatistics = CLUtils.getResourceAsString(RelevanceMask2D_.class, "kernelGetRelevanceMask2D.cl");
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$WIDTH$", "" + w);
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$HEIGHT$", "" + h);
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$PATCH_SIZE$", "" + patchSize);
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$BRW$", "" + bRW);
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$BRH$", "" + bRH);
+ programStringGetLocalStatistics = CLUtils.replaceFirst(programStringGetLocalStatistics, "$EPSILON$", "" + EPSILON);
programGetLocalStatistics = context.createProgram(programStringGetLocalStatistics).build();
// Create, fill and write buffers
float[] localMeans = new float[wh];
clLocalMeans = context.createFloatBuffer(wh, READ_WRITE);
- GlobalRedundancy.fillBufferWithFloatArray(clLocalMeans, localMeans);
+ CLUtils.fillBufferWithFloatArray(clLocalMeans, localMeans);
queue.putWriteBuffer(clLocalMeans, true);
float[] localStds = new float[wh];
clLocalStds = context.createFloatBuffer(wh, READ_WRITE);
- GlobalRedundancy.fillBufferWithFloatArray(clLocalStds, localStds);
+ CLUtils.fillBufferWithFloatArray(clLocalStds, localStds);
queue.putWriteBuffer(clLocalStds, true);
// Create kernel and set kernel arguments
diff --git a/src/main/java/Utils.java b/src/main/java/Utils.java
new file mode 100644
index 0000000..764babc
--- /dev/null
+++ b/src/main/java/Utils.java
@@ -0,0 +1,1768 @@
+import ij.IJ;
+import ij.ImagePlus;
+import ij.ImageStack;
+import ij.WindowManager;
+import ij.measure.Calibration;
+import ij.plugin.LutLoader;
+import ij.process.FloatProcessor;
+import ij.process.ImageProcessor;
+import ij.process.LUT;
+import java.awt.image.IndexColorModel;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import static java.lang.Math.*;
+
+public class Utils {
+
+ public static float EPSILON = 0.0000001f;
+
+ // Private constructor to prevent instantiation
+ private Utils(){
+ throw new UnsupportedOperationException("Utility class");
+ }
+
+
+ // -------------------------- //
+ // ---- UNSORTED OBJECTS ---- //
+ // -------------------------- //
+
+ /**
+ * Custom object to hold a relevance mask.
+ */
+ public static class RelevanceMask {
+ private final float[] relevanceMask;
+ private final float relevanceConstant;
+ private final float threshold;
+ private final float noiseMeanVariance;
+
+
+ /**
+ * Constructs a {@link RelevanceMask} object.
+ *
+ * @param relevanceMask A flattened array of float values representing the binary relevance mask (values are either 0.0 or 1.0)
+ * @param threshold The relevance threshold used to calculate the relevance mask.
+ * @param relevanceConstant The relevance constant used to calculate the relevance mask.
+ * @param noiseMeanVariance The mean variance of the noise in the input image used to calculate the relevance mask.
+ */
+ public RelevanceMask(float[] relevanceMask, float relevanceConstant, float threshold, float noiseMeanVariance) {
+ this.relevanceMask = relevanceMask;
+ this.threshold = threshold;
+ this.relevanceConstant = relevanceConstant;
+ this.noiseMeanVariance = noiseMeanVariance;
+ }
+
+
+ /**
+ * Returns the binary relevance mask as flattened 1D array.
+ *
+ * @return A flattened 1D array of float values containing the relevance mask.
+ */
+ public float[] getRelevanceMask() {
+ return relevanceMask;
+ }
+
+
+ /**
+ * Returns the relevance constant used to calculate the relevance mask.
+ *
+ * @return The relevance constant used to calculate the relevance mask.
+ */
+ public float getRelevanceConstant() {
+ return relevanceConstant;
+ }
+
+
+ /**
+ * Returns the relevance threshold used to calculate the relevance mask (relevance constant * noiseMeanVariance).
+ *
+ * @return The relevance constant used to calculate the relevance mask.
+ */
+ public float getRelevanceThreshold() {
+ return threshold;
+ }
+
+
+ /**
+ * Returns the relevance threshold used to calculate the relevance mask (relevance constant * noiseMeanVariance).
+ *
+ * @return The relevance constant used to calculate the relevance mask.
+ */
+ public float getNoiseMeanVariance() {
+ return noiseMeanVariance;
+ }
+ }
+
+
+ // ----------------------------------------- //
+ // ---- OBJECTS FOR BLOCK REPETITION 2D ---- //
+ // ----------------------------------------- //
+
+ /**
+ * This class represents a 2D reference block after processing an input square or rectangle.
+ * Processing involves discarding pixels outside the inbound ellipse and normalizing the range.
+ * It provides accessor methods to retrieve block dimensions and statistical information.
+ */
+ public static class ReferenceBlock2D {
+ private final float[] pixels;
+ private final int width;
+ private final int height;
+ private final int radiusWidth;
+ private final int radiusHeight;
+ private final int size;
+ private final float mean;
+ private final float std;
+
+ /**
+ * Constructs a ReferenceBlock2D object with the specified parameters.
+ *
+ * @param pixels A 1D array of float values containing the normalized block pixels.
+ * @param width Block width in pixels.
+ * @param height Block height in pixels.
+ * @param radiusWidth Block radius along its width in pixels.
+ * @param radiusHeight Block radius along its height in pixels.
+ * @param size Total number of pixels in the block.
+ * @param mean Mean value of the block pixels.
+ * @param std Standard deviation of the block pixels.
+ */
+ public ReferenceBlock2D(float[] pixels, int width, int height, int radiusWidth,
+ int radiusHeight, int size, float mean, float std){
+
+ this.pixels = pixels;
+ this.width = width;
+ this.height = height;
+ this.radiusWidth = radiusWidth;
+ this.radiusHeight = radiusHeight;
+ this.size = size;
+ this.mean = mean;
+ this.std = std;
+ }
+
+
+ /**
+ * Returns the normalized block pixels.
+ *
+ * @return A 1D array of float values containing the normalized block pixels retained
+ * after processing.
+ */
+ public float[] getPixels() {
+ return pixels;
+ }
+
+ /**
+ * Returns the block width in pixels.
+ *
+ * @return Block width.
+ */
+ public int getWidth() {
+ return width;
+ }
+
+ /**
+ * Returns the block height in pixels.
+ *
+ * @return Block height.
+ */
+ public int getHeight() {
+ return height;
+ }
+
+ /**
+ * Returns the block radius along its width in pixels.
+ *
+ * @return Block width radius.
+ */
+ public int getRadiusWidth() {
+ return radiusWidth;
+ }
+
+ /**
+ * Returns the block radius along its height in pixels.
+ *
+ * @return Block height radius.
+ */
+ public int getRadiusHeight() {
+ return radiusHeight;
+ }
+
+ /**
+ * Returns the total number of pixels in the block.
+ *
+ * @return Size of the block.
+ */
+ public int getSize() {
+ return size;
+ }
+
+ /**
+ * Returns the mean value of the block pixels.
+ *
+ * @return Mean of the block.
+ */
+ public float getMean() {
+ return mean;
+ }
+
+ /**
+ * Returns the standard deviation of the block pixels.
+ *
+ * @return Standard deviation of the block.
+ */
+ public float getStd() {
+ return std;
+ }
+ }
+
+
+ /**
+ * Custom object to hold a 2D input image along with its dimensions and statistics.
+ */
+ public static class InputImage2D
+ {
+ private final float[] imageArray;
+ private final int width;
+ private final int height;
+ private final int size;
+
+ /**
+ * Constructs an InputImage2D object with the specified image data and dimensions.
+ *
+ * @param imageArray A 1D array of float values representing the input image pixels.
+ * @param width The width of the image in pixels.
+ * @param height The height of the image in pixels.
+ * @param size The total number of pixels in the image.
+ */
+ public InputImage2D(float[] imageArray, int width, int height, int size) {
+ this.imageArray = imageArray;
+ this.width = width;
+ this.height = height;
+ this.size = size;
+ }
+
+ /**
+ * Returns the input image pixels as a 1D array.
+ *
+ * @return A 1D array of float values containing the input image pixels.
+ */
+ public float[] getImageArray() {
+ return imageArray;
+ }
+
+ /**
+ * Returns the width of the image in pixels.
+ *
+ * @return The width of the image.
+ */
+ public int getWidth() {
+ return width;
+ }
+
+ /**
+ * Returns the height of the image in pixels.
+ *
+ * @return The height of the image.
+ */
+ public int getHeight() {
+ return height;
+ }
+
+ /**
+ * Returns the total number of pixels in the image.
+ *
+ * @return The size of the image.
+ */
+ public int getSize() {
+ return size;
+ }
+ }
+
+
+ // ----------------------------------------- //
+ // ---- OBJECTS FOR BLOCK REPETITION 3D ---- //
+ // ----------------------------------------- //
+
+ /**
+ * This class represents a 3D reference block after processing an input square or rectangle.
+ * Processing involves discarding pixels outside the inbound spheroid and normalizing the range.
+ * It provides accessor methods to retrieve block dimensions and statistical information.
+ */
+ public static class ReferenceBlock3D
+ {
+ private final float[] pixels;
+ private final int width;
+ private final int height;
+ private final int depth;
+ private final int radiusWidth;
+ private final int radiusHeight;
+ private final int radiusDepth;
+ private final int size;
+ private final float mean;
+ private final float std;
+
+ /**
+ * Constructs a ReferenceBlock3D object with the specified parameters.
+ *
+ * @param pixels A 1D array of float values containing the normalized block pixels.
+ * @param width Block width in pixels.
+ * @param height Block height in pixels.
+ * @param radiusWidth Block radius along its width in pixels.
+ * @param radiusHeight Block radius along its height in pixels.
+ * @param size Total number of pixels in the block.
+ * @param mean Mean value of the block pixels.
+ * @param std Standard deviation of the block pixels.
+ */
+ public ReferenceBlock3D(float[] pixels, int width, int height, int depth, int radiusWidth,
+ int radiusHeight, int radiusDepth, int size, float mean, float std){
+
+ this.pixels = pixels;
+ this.width = width;
+ this.height = height;
+ this.depth = depth;
+ this.radiusWidth = radiusWidth;
+ this.radiusHeight = radiusHeight;
+ this.radiusDepth = radiusDepth;
+ this.size = size;
+ this.mean = mean;
+ this.std = std;
+ }
+
+
+ /**
+ * Returns the normalized block pixels.
+ *
+ * @return A 1D array of float values containing the normalized block pixels retained
+ * after processing.
+ */
+ public float[] getPixels() {
+ return pixels;
+ }
+
+ /**
+ * Returns the block width in pixels.
+ *
+ * @return Block width.
+ */
+ public int getWidth() {
+ return width;
+ }
+
+ /**
+ * Returns the block height in pixels.
+ *
+ * @return Block height.
+ */
+ public int getHeight() {
+ return height;
+ }
+
+ /**
+ * Returns the block depth in pixels.
+ *
+ * @return Block height.
+ */
+ public int getDepth() {
+ return depth;
+ }
+
+ /**
+ * Returns the block radius along its width in pixels.
+ *
+ * @return Block width radius.
+ */
+ public int getRadiusWidth() {
+ return radiusWidth;
+ }
+
+ /**
+ * Returns the block radius along its height in pixels.
+ *
+ * @return Block height radius.
+ */
+ public int getRadiusHeight() {
+ return radiusHeight;
+ }
+
+ /**
+ * Returns the block radius along its height in pixels.
+ *
+ * @return Block height radius.
+ */
+ public int getRadiusDepth() {
+ return radiusDepth;
+ }
+
+ /**
+ * Returns the total number of pixels in the block.
+ *
+ * @return Size of the block.
+ */
+ public int getSize() {
+ return size;
+ }
+
+ /**
+ * Returns the mean value of the block pixels.
+ *
+ * @return Mean of the block.
+ */
+ public float getMean() {
+ return mean;
+ }
+
+ /**
+ * Returns the standard deviation of the block pixels.
+ *
+ * @return Standard deviation of the block.
+ */
+ public float getStd() {
+ return std;
+ }
+ }
+
+ /**
+ * Custom object to hold a 3D input image along with its dimensions and statistics.
+ */
+ public static class InputImage3D
+ {
+ private final float[] imageArray;
+ private final int width;
+ private final int height;
+ private final int depth;
+ private final int size;
+ private final Calibration calibration;
+ private final float gain;
+ private final float sigma;
+ private final float offset;
+
+ /**
+ * Constructs an InputImage2D object with the specified image data and dimensions.
+ *
+ * @param imageArray A 1D array of float values representing the input image pixels.
+ * @param width The width of the image in pixels.
+ * @param height The height of the image in pixels.
+ * @param size The total number of pixels in the image.
+ */
+ public InputImage3D(float[] imageArray, int width, int height, int depth, int size, Calibration calibration,
+ float gain, float sigma, float offset)
+ {
+ this.imageArray = imageArray;
+ this.width = width;
+ this.height = height;
+ this.depth = depth;
+ this.size = size;
+ this.calibration = calibration;
+ this.gain = gain;
+ this.sigma = sigma;
+ this.offset = offset;
+ }
+
+ /**
+ * Returns the input image pixels as a 1D array.
+ *
+ * @return A 1D array of float values containing the input image pixels.
+ */
+ public float[] getImageArray() {
+ return imageArray;
+ }
+
+ /**
+ * Returns the width of the image in pixels.
+ *
+ * @return The width of the image.
+ */
+ public int getWidth() {
+ return width;
+ }
+
+ /**
+ * Returns the height of the image in pixels.
+ *
+ * @return The height of the image.
+ */
+ public int getHeight() {
+ return height;
+ }
+
+ /**
+ * Returns the depth of the image in pixels.
+ *
+ * @return The height of the image.
+ */
+ public int getDepth() {
+ return depth;
+ }
+
+ /**
+ * Returns the total number of pixels in the image.
+ *
+ * @return The size of the image.
+ */
+ public int getSize() {
+ return size;
+ }
+
+ /**
+ * Returns the ImageJ calibration object of the image.
+ *
+ * @return The calibration object of the image.
+ */
+ public Calibration getCalibration(){
+ return calibration;
+ }
+
+ /**
+ * Returns the optimised "gain" parameter used in the VST.
+ *
+ * @return The calibration object of the image.
+ */
+ public float getGain(){
+ return gain;
+ }
+
+ /**
+ * Returns the optimised "sigma" parameter used in the VST.
+ *
+ * @return The calibration object of the image.
+ */
+ public float getSigma(){
+ return sigma;
+ }
+
+ /**
+ * Returns the optimised "offset" parameter used in the VST.
+ *
+ * @return The calibration object of the image.
+ */
+ public float getOffset(){
+ return offset;
+ }
+ }
+
+
+ // ----------------------------------------- //
+ // ---- METHODS FOR BLOCK REPETITION 2D ---- //
+ // ----------------------------------------- //
+
+ /**
+ * Retrieves a ReferenceBlock2D object from a 2D image containing a reference block.
+ *
+ * If the blockID or the block's dimensions are invalid (e.g., not odd), the function will return {@code null}.
+ * The block image must be 8-bit, 16-bit, or 32-bit; RGB is not supported.
+ *
+ * @param blockID The ImageJ/Fiji window ID of the image containing the reference block.
+ * @return A ReferenceBlock2D object, or {@code null} if the input image is invalid (i.e., window not found or even block dimensions).
+ */
+ public static ReferenceBlock2D getReferenceBlock2D(int blockID)
+ {
+ ImagePlus imp = WindowManager.getImage(blockID);
+
+ if (imp == null) {
+ IJ.error("Block image not found. Try again.");
+ return null;
+ }
+
+ ImageProcessor ip = imp.getProcessor();
+ FloatProcessor fp = ip.convertToFloatProcessor();
+ float[] blockProcessor = (float[]) fp.getPixels();
+ int bW = fp.getWidth(); // Block width
+ int bH = fp.getHeight(); // Block height
+ IJ.log("Block dimensions: " + bW + "x" + bH);
+
+ // Check if block dimensions are odd; return null if not
+ if (bW % 2 == 0 || bH % 2 == 0) {
+ IJ.error("Block dimensions must be odd (e.g., 3x3 or 5x5). Please try again.");
+ return null;
+ }
+
+ // Calculate block radius
+ int bRW = bW / 2; // Patch radius (x-axis)
+ int bRH = bH / 2; // Patch radius (y-axis)
+
+ // Get final block size (after removing pixels outside inbound circle/ellipse)
+ int blockSize = 0;
+ for (int j = 0; j < bH; j++) {
+ for (int i = 0; i < bW; i++) {
+ float dx = (float) (i - bRW);
+ float dy = (float) (j - bRH);
+ if (((dx * dx) / (float) (bRW * bRW)) + ((dy * dy) / (float) (bRH * bRH)) <= 1.0f) {
+ blockSize++;
+ }
+ }
+ }
+
+ // Get flattened block array (keeping only the pixels within the inbound circle/ellipse)
+ float[] blockArray = new float[blockSize];
+ int index = 0;
+ for (int j = 0; j < bH; j++) {
+ for (int i = 0; i < bW; i++) {
+ float dx = (float) (i - bRW);
+ float dy = (float) (j - bRH);
+ if (((dx * dx) / (float) (bRW * bRW)) + ((dy * dy) / (float) (bRH * bRH)) <= 1.0f) {
+ blockArray[index] = blockProcessor[j * bW + i];
+ index++;
+ }
+ }
+ }
+
+ // Calculate block min and max
+ float blockMin = Float.MAX_VALUE; // Initialize as a very large number
+ float blockMax = -Float.MAX_VALUE; // Initialize as a very small number
+
+ for (int i = 0; i < blockSize; i++) {
+ blockMin = Math.min(blockMin, blockArray[i]);
+ blockMax = Math.max(blockMax, blockArray[i]);
+ }
+
+ // Normalize and calculate mean
+ float blockMean = 0.0f;
+ for (int i = 0; i < blockSize; i++) {
+ blockArray[i] = (blockArray[i] - blockMin) / (blockMax - blockMin + EPSILON);
+ blockMean += blockArray[i];
+ }
+ blockMean /= (float) blockSize;
+
+ // Subtract mean
+ for (int i = 0; i < blockSize; i++) {
+ blockArray[i] = blockArray[i] - blockMean;
+ }
+
+ // Calculate block standard deviation
+ float blockStd = 0.0f;
+ for (int i = 0; i < blockSize; i++) {
+ blockStd += (blockArray[i] - blockMean) * (blockArray[i] - blockMean);
+ }
+ blockStd = (float) Math.sqrt(blockStd / ((float) (blockSize - 1)));
+
+ return new ReferenceBlock2D(blockArray, bW, bH, bRW, bRH, blockSize, blockMean, blockStd);
+ }
+
+
+ /**
+ * Retrieves an InputImage2D object from a 2D image, optionally stabilizing noise variance
+ * and normalizing the output.
+ *
+ * If the imageID is invalid, the function will return {@code null}.
+ *
+ * @param imageID The ImageJ/Fiji window ID of the image to be retrieved.
+ * @param stabiliseNoiseVariance If {@code true}, applies variance stabilization to the image.
+ * @param normalizeOutput If {@code true}, normalizes the pixel values of the image.
+ * @return An InputImage2D object, or {@code null} if the input image is invalid (i.e., window not found).
+ */
+ public static InputImage2D getInputImage2D(int imageID, boolean stabiliseNoiseVariance, boolean normalizeOutput)
+ {
+ // Get ImagePlus object
+ ImagePlus imp = WindowManager.getImage(imageID);
+
+ // Check if image dimensions are odd; return null if not found
+ if (imp == null) {
+ IJ.error("Image not found. Try again.");
+ return null;
+ }
+
+ // Get processors and dimensions
+ ImageProcessor ip = imp.getProcessor();
+ FloatProcessor fp = ip.convertToFloatProcessor();
+ float[] imageArray = (float[]) fp.getPixels();
+ int width = fp.getWidth();
+ int height = fp.getHeight();
+ int size = width * height;
+ IJ.log("Image dimensions: "+width+"x"+height);
+
+ float gain = 0.0f; // Placeholder
+ float sigma = 0.0f; // Placeholder
+ float offset = 0.0f; // Placeholder
+
+ if (stabiliseNoiseVariance) {
+ IJ.log("Stabilizing noise variance of the image...");
+ GATMinimizer2D minimizer = new GATMinimizer2D(imageArray, width, height, 1, 10, 100);
+ minimizer.run();
+ gain = (float) minimizer.gain;
+ sigma = (float) minimizer.sigma;
+ offset = (float) minimizer.offset;
+
+ imageArray = VarianceStabilisingTransform2D_.getGAT(imageArray, gain, sigma, offset);
+ }
+
+ if (normalizeOutput) {
+ // Get min and max
+ float imageMin = Float.MAX_VALUE;
+ float imageMax = -Float.MAX_VALUE;
+ for (int i = 0; i < size; i++) {
+ float pixelValue = imageArray[i];
+ imageMin = Math.min(imageMin, pixelValue);
+ imageMax = Math.max(imageMax, pixelValue);
+ }
+
+ // Normalize
+ for (int i = 0; i < size; i++) {
+ imageArray[i] = (imageArray[i] - imageMin) / (imageMax - imageMin + EPSILON);
+ }
+ }
+
+ return new InputImage2D(imageArray, width, height, size);
+ }
+
+ /**
+ * Retrieves an InputImage2D object from a 2D image, optionally stabilizing noise variance
+ * and normalizing the output.
+ *
+ * NOTE: This is an OVERLOAD method that takes an image array instead of an ImageJ image ID uses specific GAT parameter values to calculate the VST.
+ *
+ * If the imageID is invalid, the function will return {@code null}.
+ *
+ * @param imageArray An image array (float).
+ * @param imageWidth The width of the image.
+ * @param imageHeight The height of the image.
+ * @param stabiliseNoiseVariance If {@code true}, applies variance stabilization to the image.
+ * @param gain The gain to be used in the VST
+ * @param sigma The sigma to be used in the VST
+ * @param offset The offset to be used in the VST
+ * @param normalizeOutput If {@code true}, normalizes the pixel values of the image.
+ * @return An InputImage2D object, or {@code null} if the input image is invalid (i.e., window not found).
+ */
+ public static InputImage2D getInputImage2D(float[] imageArray, int imageWidth, int imageHeight,
+ boolean stabiliseNoiseVariance, float gain, float sigma, float offset,
+ boolean normalizeOutput)
+ {
+
+ int imageSize = imageWidth * imageHeight;
+
+ if (stabiliseNoiseVariance) {
+ IJ.log("Stabilizing noise variance of the image...");
+ imageArray = VarianceStabilisingTransform2D_.getGAT(imageArray, gain, sigma, offset);
+ }
+
+ if (normalizeOutput) {
+ // Get min and max
+ float imageMin = Float.MAX_VALUE;
+ float imageMax = -Float.MAX_VALUE;
+ for (int i = 0; i < imageSize; i++) {
+ float pixelValue = imageArray[i];
+ imageMin = Math.min(imageMin, pixelValue);
+ imageMax = Math.max(imageMax, pixelValue);
+ }
+
+ // Normalize
+ for (int i = 0; i < imageSize; i++) {
+ imageArray[i] = (imageArray[i] - imageMin) / (imageMax - imageMin + EPSILON);
+ }
+ }
+
+ return new InputImage2D(imageArray, imageWidth, imageHeight, imageSize);
+ }
+
+
+ /**
+ * Calculates the mean noise variance for a 2D reference pixel array.
+ *
+ * This method divides the reference pixel array into blocks and computes local variances.
+ * It then returns the average of the lowest 3% of these variances, scaled based on a specified formula.
+ *
+ * @param refPixels A 1D array (float32) containing the reference pixel values.
+ * @param w The width of the image (in pixels).
+ * @param h The height of the image (in pixels).
+ * @param wh The total number of pixels in the image (width * height).
+ * @return The calculated mean noise variance.
+ */
+ public static float getMeanNoiseVar2D(float[] refPixels, int w, int h, int wh)
+ {
+ int blockWidth, blockHeight;
+ int CIF = 352 * 288; // Resolution of a CIF file
+
+ // Determine block dimensions based on image size
+ if (wh <= CIF) {
+ blockWidth = 8;
+ blockHeight = 8;
+ } else {
+ blockWidth = 16;
+ blockHeight = 16;
+ }
+
+ // Calculate the number of blocks in each dimension
+ int nBlocksX = w / blockWidth; // number of blocks in each row
+ int nBlocksY = h / blockHeight; // number of blocks in each column
+ int nBlocks = nBlocksX * nBlocksY; // total number of blocks
+ float[] localVars = new float[nBlocks];
+ Arrays.fill(localVars, 0.0f);
+
+ // Calculate local variances
+ int index = 0;
+ for (int y = 0; y < nBlocksY; y++) {
+ for (int x = 0; x < nBlocksX; x++) {
+ float[] meanVar = getMeanAndVarBlock2D(refPixels, w, x*blockWidth, y*blockHeight, (x+1)*blockWidth, (y+1)*blockHeight);
+ localVars[index] = meanVar[1]; // Store variance
+ index++;
+ }
+ }
+
+ // Sort the local variances
+ Arrays.sort(localVars);
+
+ // Get the 3% lowest variances and calculate their average
+ int nVars = (int) (0.03f * (float) nBlocks + 1.0f); // Number of blocks corresponding to 3% of the total
+ float noiseVar = 0.0f;
+
+ for (int i = 0; i < nVars; i++) {
+ noiseVar += localVars[i];
+ }
+
+ // Calculate average of the lowest variances
+ noiseVar = Math.abs(noiseVar / (float) nVars);
+ noiseVar = (1.0f + 0.001f * (noiseVar - 40.0f)) * noiseVar;
+
+ return noiseVar;
+ }
+
+
+ /**
+ * Calculates the mean and variance of a block of pixels from a 1D pixel array in a single pass.
+ *
+ * This method computes the mean and variance for a specified rectangular block of pixels
+ * defined by its start and end coordinates.
+ *
+ * @param imageArray A 1D array (float32) containing the pixel values.
+ * @param imageWidth The width of the image (in pixels), used for indexing into the pixel array.
+ * @param xStart The starting x-coordinate (inclusive) of the block.
+ * @param yStart The starting y-coordinate (inclusive) of the block.
+ * @param xEnd The ending x-coordinate (exclusive) of the block.
+ * @param yEnd The ending y-coordinate (exclusive) of the block.
+ * @return A float array where the first element is the mean and the second element is the variance of the block.
+ */
+ public static float[] getMeanAndVarBlock2D(float[] imageArray, int imageWidth, int xStart, int yStart, int xEnd,
+ int yEnd)
+ {
+ float mean = 0.0f;
+ float var;
+ float sq_sum = 0.0f;
+
+ int blockWidth = xEnd - xStart; // Block width
+ int blockHeight = yEnd - yStart; // Block height
+ int blockSize = blockWidth * blockHeight; // Total number of pixels in the block
+
+ // Calculate the sum of pixel values and the sum of squared pixel values
+ for (int y=yStart; yThis method modifies the input image array by applying a provided mask,
+ * which scales each pixel in the image according to the corresponding value in the mask.
+ *
+ * @param imageArray An input image array (float32).
+ * @param imageWidth The width of the input image array.
+ * @param imageHeight The height of the input image array.
+ * @param mask A user-provided mask (float32).
+ * @return A masked image array (the modified input image array).
+ */
+ public static float[] applyMask2D(float[] imageArray, int imageWidth, int imageHeight, float[] mask)
+ {
+ // Apply mask
+ for (int y = 0; y < imageHeight; y++) {
+ for (int x = 0; x < imageWidth; x++) {
+ imageArray[y * imageWidth + x] *= mask[y * imageWidth + x];
+ }
+ }
+
+ return imageArray;
+ }
+
+
+ /**
+ * Calculate relevance mask based on structural relevance.
+ *
+ * This method generates a binary mask where the center pixels of each local neighborhood are assigned a value of zero
+ * if the local variance is below or equal to the relevance threshold, which is determined by the mean noise variance
+ * multiplied by a user-defined relevance constant.
+ *
+ * @param imageArray An input image array (float) used to calculate the mean noise variance and the relevance mask.
+ * @param imageWidth The width of the input image array.
+ * @param imageHeight The height of the input image array.
+ * @param blockRadiusWidth The width radius of the block used in the repetition analysis.
+ * @param blockRadiusHeight The height radius of the block used in the repetition analysis.
+ * @param localStds The local standard deviations array calculated with {@link CLUtils.getLocalStatistics2D()}.
+ * @param relevanceConstant A user-provided relevance constant to control the strength of the relevance filter.
+ * @return A {@link RelevanceMask} object.
+ */
+ public static RelevanceMask getRelevanceMask(float[] imageArray, int imageWidth, int imageHeight,
+ int blockRadiusWidth, int blockRadiusHeight, float[] localStds,
+ float relevanceConstant)
+ {
+ // Calculate noise mean variance
+ int imageSize = imageWidth * imageHeight;
+
+ float noiseMeanVariance = getMeanNoiseVar2D(imageArray, imageWidth, imageHeight, imageSize);
+ float relevanceThreshold = noiseMeanVariance*relevanceConstant;
+
+ // Calculate relevance mask
+ float[] relevanceMask = new float[imageSize];
+ Arrays.fill(relevanceMask, 0.0f); // Fill with zeros just to be sure
+ for (int y = blockRadiusHeight; y < imageHeight - blockRadiusHeight; y++) {
+ for (int x = blockRadiusWidth; x < imageWidth - blockRadiusWidth; x++) {
+ if ((localStds[y * imageWidth + x] * localStds[y * imageWidth + x]) <= relevanceThreshold) {
+ relevanceMask[y * imageWidth + x] = 0.0f; // Assign zero if local variance is below threshold
+ } else {
+ relevanceMask[y * imageWidth + x] = 1.0f; // Assign one if local variance is above threshold
+ }
+ }
+ }
+
+ return new RelevanceMask(relevanceMask, relevanceConstant, relevanceThreshold, noiseMeanVariance); // Return the relevance mask
+ }
+
+
+ /**
+ * Normalize an image (in-place) to a specified range, with the option to avoid masked pixels.
+ *
+ * This method calculates the minimum and maximum pixel values of the input image while excluding
+ * any masked pixels, and then normalizes the image based on these values.
+ *
+ * @param imageArray The input image array (float) to normalize.
+ * @param imageWidth The width of the input image array.
+ * @param imageHeight The height of the input image array.
+ * @param borderWidth The width of the border to exclude from the normalization calculation.
+ * @param borderHeight The height of the border to exclude from the normalization calculation.
+ * @param mask A binary mask (float) where masked pixels will be excluded from the calculation.
+ * @return A normalized image array (float) where pixel values are remapped to the range [0, 1].
+ */
+ public static float[] normalizeImage2D(float[] imageArray, int imageWidth, int imageHeight, int borderWidth,
+ int borderHeight, float[] mask)
+ {
+ // Find min and max
+ float imageMin = Float.MAX_VALUE;
+ float imageMax = -Float.MAX_VALUE;
+
+ if(mask==null) {
+ for (int y=borderHeight; y 0.0f) {
+ imageMin = min(imageArray[y*imageWidth+x], imageMin);
+ imageMax = max(imageArray[y*imageWidth+x], imageMax);
+ }
+ }
+ }
+ }
+
+ // Remap pixels
+ float[] normalizedArray = imageArray.clone();
+ if(mask==null) {
+ for (int y=borderHeight; y0.0f) {
+ normalizedArray[y*imageWidth+x] = (normalizedArray[y*imageWidth+x]-imageMin)/(imageMax-imageMin+EPSILON);
+ }
+ }
+ }
+ }
+ return normalizedArray;
+ }
+
+
+ // ----------------------------------------- //
+ // ---- METHODS FOR BLOCK REPETITION 3D ---- //
+ // ----------------------------------------- //
+
+ /**
+ * Retrieves a ReferenceBlock3D object from a 3D image containing a reference block.
+ *
+ * If the blockID or the block's dimensions are invalid (e.g., not odd), the function will return {@code null}.
+ * The block image must be 8-bit, 16-bit, or 32-bit; RGB is not supported.
+ *
+ * @param blockID The ImageJ/Fiji window ID of the image containing the reference block.
+ * @return A ReferenceBlock2D object, or {@code null} if the input image is invalid (i.e., window not found or even block dimensions).
+ */
+ public static ReferenceBlock3D getReferenceBlock3D(int blockID)
+ {
+ ImagePlus imp = WindowManager.getImage(blockID);
+
+ // Check if image is found
+ if (imp == null) {
+ IJ.error("Block image not found. Try again.");
+ throw new IllegalArgumentException("Block image not found.");
+ }
+
+ // Get block dimensions
+ ImageStack ims = imp.getStack();
+ int bW = ims.getWidth(); // Block width
+ int bH = ims.getHeight(); // Block height
+ int bZ = ims.getSize(); // block depth
+ int bRW = bW / 2; // Patch radius (x-axis)
+ int bRH = bH / 2; // Patch radius (y-axis)
+ int bRZ = bZ / 2; // Patch radius (z-axis)
+ IJ.log("Block dimensions: " + bW + "x" + bH + "x" + bZ);
+
+ // Check if block dimensions are odd
+ if (bW % 2 == 0 || bH % 2 == 0 || bZ % 2 == 0) {
+ IJ.error("Block dimensions must be odd (e.g., 3x3x3 or 5x5x5). Please try again.");
+ throw new IllegalArgumentException("Block dimensions must be odd.");
+ }
+
+ // Check if patch has at least 3 slices
+ if (bZ < 3) {
+ IJ.error("Block must have at least 3 slices. Please try again.");
+ throw new IllegalArgumentException("Reference block must have at least 3 slices.");
+ }
+
+ // Get final block size (after removing pixels outside the sphere/ellipsoid)
+ int blockSize = 0;
+ for (int z = 0; z < bZ; z++) {
+ for (int y = 0; y < bH; y++) {
+ for (int x = 0; x < bW; x++) {
+ float dx = (float) (x - bRW);
+ float dy = (float) (y - bRH);
+ float dz = (float) (z - bRZ);
+ if (((dx * dx) / (float) (bRW * bRW)) + ((dy * dy) / (float) (bRH * bRH)) + ((dz * dz) / (float) (bRZ * bRZ)) <= 1.0f) {
+ blockSize++;
+ }
+ }
+ }
+ }
+
+ // Get block array
+ float[][] blockArray = new float[bZ][bW * bH];
+ for (int z = 0; z < bZ; z++) {
+ for (int y = 0; y < bH; y++) {
+ for (int x = 0; x < bW; x++) {
+ blockArray[z][y*bW+x] = ims.getProcessor(z+1).convertToFloatProcessor().getf(x,y);
+ }
+ }
+ }
+
+ // Get flattened block array (keeping only the pixels within the inbound spheroid)
+ float[] blockArray1D = new float[blockSize];
+ int index = 0;
+ for (int z=0; zIf the imageID is invalid, the function will return {@code null}.
+ *
+ * @param imageID The ImageJ/Fiji window ID of the image to be retrieved.
+ * @param stabiliseNoiseVariance If {@code true}, applies variance stabilization to the image.
+ * @param normalizeOutput If {@code true}, normalizes the pixel values of the image.
+ * @return An InputImage3D object, or {@code null} if the input image is invalid (i.e., window not found).
+ */
+ public static InputImage3D getInputImage3D(int imageID, boolean stabiliseNoiseVariance, boolean normalizeOutput)
+ {
+ // Get ImagePlus object
+ ImagePlus imp = WindowManager.getImage(imageID);
+
+ // Check if image dimensions are odd; return null if not found
+ if (imp == null) {
+ IJ.error("Image not found. Try again.");
+ return null;
+ }
+
+ // Get calibration parameters
+ Calibration calibration = imp.getCalibration();
+
+ // Get ImageStack object
+ ImageStack ims = imp.getStack();
+
+ // Get processors and dimensions
+ //float[] imageArray = (float[]) fp.getPixels();
+ int width = ims.getWidth();
+ int height = ims.getHeight();
+ int depth = ims.getSize();
+ int size = width * height * depth;
+ IJ.log("Image dimensions: "+width+"x"+height+"x"+depth);
+
+ // Check if image has at least 3 slices, otherwise kill program
+ if (depth < 3) {
+ IJ.error("Image must have at least 3 slices. Please try again.");
+ return null;
+ }
+
+ // Get image stack array (float[z][wh])
+ float[][] stackArray = new float[depth][width*height];
+ for(int z=0; zIf the imageID is invalid, the function will return {@code null}.
+ *
+ * @param imageArray An image array of the image (float).
+ * @param stabiliseNoiseVariance If {@code true}, applies variance stabilization to the image.
+ * @param normalizeOutput If {@code true}, normalizes the pixel values of the image.
+ * @return An InputImage3D object, or {@code null} if the input image is invalid (i.e., window not found).
+ */
+ public static InputImage3D getInputImage3D(float[] imageArray, int width, int height, int depth, boolean stabiliseNoiseVariance, boolean normalizeOutput)
+ {
+
+ int size = width*height*depth;
+
+ // Stabilise noise variance
+ float gain = 0.0f; // Placeholder
+ float sigma = 0.0f; // Placeholder
+ float offset = 0.0f; // Placeholder
+
+ if (stabiliseNoiseVariance) {
+ IJ.log("Stabilizing noise variance of the image...");
+
+ // Get image stack array (float[z][wh])
+ float[][] stackArray = new float[depth][width*height];
+ for(int z=0; zThis method computes the mean and variance for a specified rectangular block of pixels
+ * defined by its start and end coordinates.
+ *
+ * @param pixels A 1D array (float32) containing the pixel values.
+ * @param imageWidth The width of the image (in pixels), used for indexing into the pixel array.
+ * @param imageHeight The height of the image (in pixels), used for indexing into the pixel array.
+ * @param xStart The starting x-coordinate (inclusive) of the block.
+ * @param yStart The starting y-coordinate (inclusive) of the block.
+ * @param zStart The starting z-coordinate (incusive) of the block.
+ * @param xEnd The ending x-coordinate (exclusive) of the block.
+ * @param yEnd The ending y-coordinate (exclusive) of the block.
+ * @param zEnd The ending z-coordinate (exclusive) of the block.
+ * @return A float array where the first element is the mean and the second element is the variance of the block.
+ */
+ public static float[] getMeanAndVarBlock3D(float[] pixels, int imageWidth, int imageHeight, int xStart, int yStart,
+ int zStart, int xEnd, int yEnd, int zEnd)
+ {
+ float mean = 0.0f;
+ float var;
+ float sq_sum = 0.0f;
+
+ int blockWidth = xEnd - xStart; // Block width
+ int blockHeight = yEnd - yStart; // Block height
+ int blockDepth = zEnd - zStart; // Block depth
+ int blockSize = blockWidth * blockHeight * blockDepth; // Total number of pixels in the block
+
+ // Calculate the sum of pixel values and the sum of squared pixel values
+ for(int z=zStart; zThis method divides the reference pixel array into blocks and computes local variances.
+ * It then returns the average of the lowest 3% of these variances, scaled based on a specified formula.
+ *
+ * @param refPixels A flattened 1-D array (float32) containing the reference pixel values.
+ * @param imageWidth The width of the image (in pixels).
+ * @param imageHeight The height of the image (in pixels).
+ * @param imageDepth the depth of the image (in pixels).
+ * @param imageSize The total number of pixels in the image (width * height * depth).
+ * @return The calculated mean noise variance.
+ *
+ public static float getMeanNoiseVar3D(float[] imageArray, int imageWidth, int imageHeight, int imageDepth, int imageSize) {
+ int blockWidth, blockHeight, blockDepth;
+ int CIF = 352 * 288; // Resolution of a CIF file
+
+ // Determine block dimensions based on image size
+ if (imageWidth*imageHeight <= CIF) {
+ blockWidth = 8;
+ blockHeight = 8;
+ blockDepth = 5; // TODO: this was arbitrary, didn't want to use more slices
+ } else {
+ blockWidth = 16;
+ blockHeight = 16;
+ blockDepth = 5; // TODO: this was arbitrary, didn't want to use more slices
+ }
+
+ // Calculate the number of blocks in each dimension
+ int nBlocksX = imageWidth / blockWidth; // number of blocks in each row
+ int nBlocksY = imageHeight / blockHeight; // number of blocks in each column
+ int nBlocksZ = imageDepth / blockDepth; // number of bocks in depth
+ int nBlocks = nBlocksX * nBlocksY * nBlocksZ; // total number of blocks
+ float[] localVars = new float[nBlocks];
+ Arrays.fill(localVars, 0.0f);
+
+ // Calculate local variances
+ int index = 0;
+ for(int z=0; zThis method generates a 3D binary mask where the center pixels of each local neighborhood are assigned a value of zero
+ * if the local variance is below or equal to the relevance threshold, which is determined by the mean noise variance
+ * multiplied by a user-defined relevance constant.
+ *
+ * @param imageWidth The width of the input image.
+ * @param imageHeight The height of the input image.
+ * @param imageDepth The depth of the input image.
+ * @param blockRadiusWidth The width radius of the block used in the repetition analysis.
+ * @param blockRadiusHeight The height radius of the block used in the repetition analysis.
+ * @param blockRadiusDepth The depth radius of the block used in the repetition analysis.
+ * @param localStds The local standard deviations array calculated with {@link CLUtils.getLocalStatistics3D()}.
+ * @param relevanceConstant A user-provided relevance constant to control the strength of the relevance filter.
+ * @return A binary mask (float) where center pixels of each local neighbourhood are assigned a value of zero if the local variance is below or equal
+ * to the relevance threshold; otherwise, they are assigned a value of one.
+ */
+ public static float[] getRelevanceMask3D(int imageWidth, int imageHeight, int imageDepth, int blockRadiusWidth,
+ int blockRadiusHeight, int blockRadiusDepth, float[] localStds,
+ float relevanceConstant)
+ {
+ // Calculate noise mean variance
+ float noiseMeanVariance = getMeanNoiseVar3D(imageWidth, imageHeight, imageDepth, blockRadiusWidth,
+ blockRadiusHeight, blockRadiusDepth, localStds);
+
+ // Calculate relevance mask
+ float[] relevanceMask = new float[imageWidth*imageHeight*imageDepth];
+ Arrays.fill(relevanceMask, 0.0f); // Fill with zeros just to be sure
+
+ for(int z=blockRadiusDepth; zThis method modifies the input image array by applying a provided mask,
+ * which scales each pixel in the image according to the corresponding value in the mask.
+ *
+ * @param imageArray An input image array (float32).
+ * @param imageWidth The width of the input image.
+ * @param imageHeight The height of the input image.
+ * @param imageDepth The depth of the input image.
+ * @param mask A user-provided binary mask (float32).
+ * @return A masked image array (the modified input image array).
+ */
+ public static float[] applyMask3D(float[] imageArray, int imageWidth, int imageHeight, int imageDepth, float[] mask)
+ {
+ // Apply mask
+ for(int z=0; zThis method calculates the minimum and maximum pixel values of the input image while excluding
+ * any masked pixels, and then normalizes the image based on these values.
+ *
+ * @param imageArray The input image array (float) to normalize.
+ * @param imageWidth The width of the input image array.
+ * @param imageHeight The height of the input image array.
+ * @param borderWidth The width of the border to exclude from the normalization calculation.
+ * @param borderHeight The height of the border to exclude from the normalization calculation.
+ * @param mask A binary mask (float) where masked pixels will be excluded from the calculation.
+ * @return A normalized image array (float) where pixel values are remapped to the range [0, 1].
+ */
+ public static float[] normalizeImage3D(float[] imageArray, int imageWidth, int imageHeight, int imageDepth, int borderWidth,
+ int borderHeight, int borderDepth, float[] mask)
+ {
+
+ // Find min and max
+ float imageMin = Float.MAX_VALUE;
+ float imageMax = -Float.MAX_VALUE;
+
+ if(mask==null) {
+ for (int z = borderDepth; z < imageDepth - borderDepth; z++) {
+ for (int y = borderHeight; y < imageHeight - borderHeight; y++) {
+ for (int x = borderWidth; x < imageWidth - borderWidth; x++) {
+ int index = imageWidth * imageHeight * z + y * imageWidth + x;
+ imageMin = min(imageArray[index], imageMin);
+ imageMax = max(imageArray[index], imageMax);
+ }
+ }
+ }
+ }else{
+ for (int z = borderDepth; z < imageDepth - borderDepth; z++) {
+ for (int y = borderHeight; y < imageHeight - borderHeight; y++) {
+ for (int x = borderWidth; x < imageWidth - borderWidth; x++) {
+ int index = imageWidth * imageHeight * z + y * imageWidth + x;
+ if (mask[index] > 0.0f) {
+ imageMin = min(imageArray[index], imageMin);
+ imageMax = max(imageArray[index], imageMax);
+ }
+ }
+ }
+ }
+ }
+
+ // Remap pixels
+ float[] normalizedImage = imageArray.clone();
+ if(mask==null) {
+ for (int z = borderDepth; z < imageDepth - borderDepth; z++) {
+ for (int y = borderHeight; y < imageHeight - borderHeight; y++) {
+ for (int x = borderWidth; x < imageWidth - borderWidth; x++) {
+ int index = imageWidth * imageHeight * z + y * imageWidth + x;
+ normalizedImage[index] = (imageArray[index] - imageMin) / (imageMax - imageMin + EPSILON);
+ }
+ }
+ }
+ }else{
+ for (int z = borderDepth; z < imageDepth - borderDepth; z++) {
+ for (int y = borderHeight; y < imageHeight - borderHeight; y++) {
+ for (int x = borderWidth; x < imageWidth - borderWidth; x++) {
+ int index = imageWidth * imageHeight * z + y * imageWidth + x;
+ if (mask[index] > 0.0f) {
+ normalizedImage[index] = (imageArray[index] - imageMin) / (imageMax - imageMin + EPSILON);
+ }
+ }
+ }
+ }
+ }
+
+ return normalizedImage;
+ }
+
+
+ // -------------------------- //
+ // ---- UNSORTED METHODS ---- //
+ // -------------------------- //
+
+ /**
+ * Normalizes an array to its range.
+ *
+ * @param array
+ * @return A copy of the original array, normalized to the range
+ */
+ public static float[] normalizeArray(float[] array)
+ {
+
+ // Cache variables
+ int arrayLength = array.length;
+
+ // Get min max
+ float arrayMin = Float.MAX_VALUE;
+ float arrayMax = -Float.MAX_VALUE;
+ for(int i=0; iThis method computes the mean, variance, and standard deviation of the input array.
+ *
+ * @param a The input array of float values.
+ * @return An array of float containing the mean, variance, and standard deviation in that order.
+ * Returns an array of zeros if the input array is empty.
+ */
+ private float[] meanVarStd(float[] a) {
+ int n = a.length;
+ if (n == 0) return new float[]{0, 0, 0}; // Return zeros for empty array
+
+ double sum = 0.0;
+ double sq_sum = 0.0;
+
+ // Calculate sum and squared sum
+ for (int i = 0; i < n; i++) {
+ sum += a[i];
+ sq_sum += a[i] * a[i];
+ }
+
+ double mean = sum / n; // Calculate mean
+ double variance = Math.abs(sq_sum / n - mean * mean); // Calculate variance
+ // abs() solves a bug where negative zeros appeared
+
+ return new float[]{(float) mean, (float) variance, (float) Math.sqrt(variance)}; // Return mean, variance, and std
+ }
+
+
+ /**
+ * Retrieve the image ID corresponding to a given title.
+ *
+ * @param titles Array of image titles.
+ * @param ids Array of image IDs.
+ * @param title The title to match.
+ * @return The matching image ID, or 0 if not found.
+ */
+ public static int getImageIDByTitle(String[] titles, int[] ids, String title) {
+ for (int i = 0; i < titles.length; i++) {
+ if (titles[i].equals(title)) {
+ return ids[i]; // Return the corresponding ID if title matches
+ }
+ }
+ throw new IllegalArgumentException("Title not found: " + title); // Throw exception if title not found
+ }
+
+
+ /**
+ * Display the results as a 2D image.
+ *
+ * @param inputImage The input image used for display dimensions.
+ * @param repetitionMap The calculated repetition map to display.
+ */
+ public static void displayResults2D(Utils.InputImage2D inputImage, float[] repetitionMap) {
+ FloatProcessor fp1 = new FloatProcessor(inputImage.getWidth(), inputImage.getHeight(), repetitionMap);
+ ImagePlus imp1 = new ImagePlus("Repetition Map", fp1);
+
+ // Apply SReD LUT
+ InputStream lutStream = Utils.class.getResourceAsStream("/luts/sred-jet.lut");
+ if (lutStream == null) {
+ IJ.error("Could not load SReD LUT. Using default LUT.");
+ } else {
+ try {
+ // Load LUT file
+ IndexColorModel icm = LutLoader.open(lutStream);
+ byte[] r = new byte[256];
+ byte[] g = new byte[256];
+ byte[] b = new byte[256];
+ icm.getReds(r);
+ icm.getGreens(g);
+ icm.getBlues(b);
+ LUT lut = new LUT(8, 256, r, g, b);
+
+ // Apply LUT to image
+ imp1.getProcessor().setLut(lut);
+ } catch (IOException e) {
+ IJ.error("Could not load SReD LUT: " + e.getMessage());
+ }
+ }
+
+ // Display results
+ imp1.show();
+ }
+
+
+ /**
+ * Display the results as a 3D image.
+ *
+ * @param inputImage The input image used for display dimensions.
+ * @param repetitionMap The calculated repetition map to display.
+ */
+ public static void displayResults3D(Utils.InputImage3D inputImage, float[] repetitionMap) {
+
+ int imageWidth = inputImage.getWidth();
+ int imageHeight = inputImage.getHeight();
+ int imageDepth = inputImage.getDepth();
+ ImageStack ims = new ImageStack(imageWidth, imageHeight, imageDepth);
+
+ for(int z=0; z=w-bRW || gy=h-bRH){
+ diff_std_map[gy*w+gx] = 0.0f;
+ return;
+ }
+
+
+ // -------------------------------------------------------------- //
+ // ---- Calculate absolute difference of standard deviations ---- //
+ // -------------------------------------------------------------- //
+
+ float test_std = local_stds[gy*w+gx];
+
+ diff_std_map[gy*w+gx] = fabs((float)ref_std - (float)test_std);
+}
diff --git a/src/main/resources/kernelGetPatchCosineSim2D.cl b/src/main/resources/kernelGetBlockCosineSimilarity2D.cl
similarity index 55%
rename from src/main/resources/kernelGetPatchCosineSim2D.cl
rename to src/main/resources/kernelGetBlockCosineSimilarity2D.cl
index d132013..9d2f041 100644
--- a/src/main/resources/kernelGetPatchCosineSim2D.cl
+++ b/src/main/resources/kernelGetBlockCosineSimilarity2D.cl
@@ -3,18 +3,20 @@
#define h $HEIGHT$
#define bRW $BRW$
#define bRH $BRH$
-#define ref_std $PATCH_STD$
+#define ref_std $BLOCK_STD$
#define EPSILON $EPSILON$
-kernel void kernelGetPatchCosineSim2D(
+
+kernel void kernelGetBlockCosineSimilarity2D(
global float* local_stds,
- global float* diff_std_map
+ global float* cosine_similarity_map
){
int gx = get_global_id(0);
int gy = get_global_id(1);
- // Bound check (avoids borders dynamically based on patch dimensions)
+ // Bound check (avoids borders dynamically based on block dimensions)
if(gx=w-bRW || gy=h-bRH){
+ cosine_similarity_map[gy*w+gx] = 0.0f;
return;
}
@@ -25,6 +27,6 @@ kernel void kernelGetPatchCosineSim2D(
float test_std = local_stds[gy*w+gx];
- float similarity = (ref_std*test_std) / (sqrt(ref_std*ref_std)*sqrt(test_std*test_std)+EPSILON);
- diff_std_map[gy*w+gx] = (float)fmax(0.0f, similarity);
+ float similarity = (ref_std*test_std) / (sqrt((float)ref_std*(float)ref_std)*sqrt((float)test_std*(float)test_std)+EPSILON);
+ cosine_similarity_map[gy*w+gx] = (float)fmax(0.0f, similarity);
}
diff --git a/src/main/resources/kernelGetBlockCosineSimilarity3D.cl b/src/main/resources/kernelGetBlockCosineSimilarity3D.cl
new file mode 100644
index 0000000..ff714ae
--- /dev/null
+++ b/src/main/resources/kernelGetBlockCosineSimilarity3D.cl
@@ -0,0 +1,31 @@
+//#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+#define imageWidth $WIDTH$
+#define imageHeight $HEIGHT$
+#define imageDepth $DEPTH$
+#define bRW $BRW$
+#define bRH $BRH$
+#define bRZ $BRZ$
+#define ref_std $BLOCK_STD$
+#define EPSILON $EPSILON$
+
+kernel void kernelGetBlockCosineSimilarity3D(
+ global float* local_stds,
+ global float* cosine_similarity_map
+){
+
+ int gx = get_global_id(0);
+ int gy = get_global_id(1);
+ int gz = get_global_id(2);
+
+ // Bound check (avoids borders dynamically based on block dimensions)
+ if(gx=imageWidth-bRW || gy=imageHeight-bRH || gz=imageDepth-bRZ){
+ cosine_similarity_map[imageWidth*imageHeight*gz+gy*imageWidth+gx] = 0.0f;
+ return;
+ }
+
+
+ // Calculate cosine similarity
+ float test_std = local_stds[imageWidth*imageHeight*gz+gy*imageWidth+gx];
+ float similarity = (ref_std*test_std) / (sqrt(ref_std*ref_std)*sqrt(test_std*test_std)+EPSILON);
+ cosine_similarity_map[imageWidth*imageHeight*gz+gy*imageWidth+gx] = (float)fmax(0.0f, similarity);
+}
diff --git a/src/main/resources/kernelGetPatchRmse2D.cl b/src/main/resources/kernelGetBlockNrmse2D.cl
similarity index 61%
rename from src/main/resources/kernelGetPatchRmse2D.cl
rename to src/main/resources/kernelGetBlockNrmse2D.cl
index ca39c4b..7f3d344 100644
--- a/src/main/resources/kernelGetPatchRmse2D.cl
+++ b/src/main/resources/kernelGetBlockNrmse2D.cl
@@ -1,16 +1,16 @@
//#pragma OPENCL EXTENSION cl_khr_fp64 : enable
#define w $WIDTH$
#define h $HEIGHT$
-#define patch_size $PATCH_SIZE$
+#define block_size $BLOCK_SIZE$
#define bW $BW$
#define bH $BH$
#define bRW $BRW$
#define bRH $BRH$
-#define ref_mean $PATCH_MEAN$
+#define ref_mean $BLOCK_MEAN$
#define EPSILON $EPSILON$
-kernel void kernelGetPatchRmse2D(
- global float* patch_pixels,
+kernel void kernelGetBlockNrmse2D(
+ global float* block_pixels,
global float* ref_pixels,
global float* local_means,
global float* rmse_map
@@ -19,8 +19,9 @@ kernel void kernelGetPatchRmse2D(
int gx = get_global_id(0);
int gy = get_global_id(1);
- // Bound check (avoids borders dynamically based on patch dimensions)
+ // Bound check (avoids borders dynamically based on block dimensions)
if(gx=w-bRW || gy=h-bRH){
+ rmse_map[gy*w+gx] = 0.0f;
return;
}
@@ -29,35 +30,35 @@ kernel void kernelGetPatchRmse2D(
// ---- Get mean-subtracted reference block ---- //
// --------------------------------------------- //
- __local float ref_patch[patch_size]; // Make a local copy to avoid slower reads from global memory
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
- for(int i=0; i=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ rmse_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+
+ // Get mean-subtracted reference block
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
+
+ for(int i=0; i=w-bRW || gy=h-bRH){
+ pearson_map[gy*w+gx] = 0.0f;
return;
}
@@ -31,35 +31,35 @@ kernel void kernelGetPatchPearson2D(
// ---- Get mean-subtracted reference block ---- //
// --------------------------------------------- //
- __local float ref_patch[patch_size]; // Make a local copy to avoid slower reads from global memory
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
- for(int i=0; i=imageWidth-bRW || gy=imageHeight-bRH || gz=imageDepth-bRZ){
+ pearson_map[imageWidth*imageHeight*gz+gy*imageWidth+gx] = 0.0f;
+ return;
+ }
+
+ // Get mean-subtracted and normalized reference block from buffer
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
+
+ for(int i=0; i=image_width-bRW || gy=image_height-bRH){
+ ssim_map[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Get mean-subtracted reference block
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
+
+ for(int i=0; i=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ ssim_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+
+ // --------------------------------------------- //
+ // ---- Get mean-subtracted reference block ---- //
+ // --------------------------------------------- //
+
+ __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory
+
+ for(int i=0; i=w-bRW || gy=h-bRH){
- return;
- }
-
-
- // ------------------------------------------------------------ //
- // ---- Check to avoid blocks with no structural relevance ---- //
- // ------------------------------------------------------------ //
-
- float ref_std = local_stds[gy*w+gx];
- float ref_var = (float)ref_std*(float)ref_std;
-
- if(ref_var=image_width-bRW || gy=image_height-bRH){
+ diff_std_map[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ float ref_std = local_stds[gy*image_width+gx];
+ float ref_var = (float)ref_std*(float)ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ diff_std_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ int ref_index = image_width*image_height*gz+gy*image_width+gx;
+ float ref_std = local_stds[ref_index];
+ float ref_var = ref_std*ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH){
+ cosine_sim_map[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ float ref_std = local_stds[gy*image_width+gx];
+ float ref_var = (float)ref_std*(float)ref_std;
+
+ if(ref_var=w-bRW || gy=h-bRH || gz=z-bRZ){
+ // Bound check to avoid borders
+ if(gx=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ cosine_sim_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
return;
}
-
- // ------------------------------------------------------------ //
- // ---- Check to avoid blocks with no structural relevance ---- //
- // ------------------------------------------------------------ //
-
- int ref_index = w * h * gz + gy * w + gx;
-
+ // Check to avoid blocks with no structural relevance
+ int ref_index = image_width*image_height*gz+gy*image_width+gx;
float ref_std = local_stds[ref_index];
float ref_var = ref_std*ref_std;
@@ -48,26 +37,22 @@ kernel void kernelGetCosineSimMap3D(
return;
}
-
- // -------------------------------------------------------------------- //
- // ---- Calculate similarity between the reference and test blocks ---- //
- // -------------------------------------------------------------------- //
-
+ // Calculate similarity between the reference and test blocks
float weight_sum = 0.0f;
float cosine_similarity_sum = 0.0f;
- for(int n=bRZ; n=image_width-bRW || gy=image_height-bRH){
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ float ref_std = local_stds[gy*image_width+gx];
+ float ref_var = (float)ref_std*(float)ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ rmse_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ int ref_index = image_width*image_height*gz+gy*image_width+gx;
+ float ref_std = local_stds[ref_index];
+ float ref_var = ref_std*ref_std;
+
+ if(ref_var=w-bRW || gy=h-bRH){
- return;
- }
-
-
- // ------------------------------------------------------------ //
- // ---- Check to avoid blocks with no structural relevance ---- //
- // ------------------------------------------------------------ //
-
- float ref_std = local_stds[gy*w+gx];
- float ref_var = (float)ref_std*(float)ref_std;
-
- if(ref_var=image_width-bRW || gy=image_height-bRH){
+ pearson_map[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ float ref_std = local_stds[gy*image_width+gx];
+ float ref_var = (float)ref_std*(float)ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ pearson_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ int ref_index = image_width*image_height*gz+gy*image_width+gx;
+ float ref_std = local_stds[ref_index];
+ float ref_var = ref_std*ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH){
+ ssim_map[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ float ref_std = local_stds[gy*image_width+gx];
+ float ref_var = (float)ref_std*(float)ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ ssim_map[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Check to avoid blocks with no structural relevance
+ int ref_index = image_width*image_height*gz+gy*image_width+gx;
+ float ref_std = local_stds[ref_index];
+ float ref_var = ref_std*ref_std;
+
+ if(ref_var=image_width-bRW || gy=image_height-bRH){
+ local_means[gy*image_width+gx] = 0.0f;
+ local_stds[gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Get block pixels
+ float block[block_size];
+ int index = 0;
+ for(int y=gy-bRH; y<=gy+bRH; y++){
+ for(int x=gx-bRW; x<=gx+bRW; x++){
+ // Extract only pixels within the inbound circle/ellipse
+ float dx = (float)(x-gx);
+ float dy = (float)(y-gy);
+ if(((dx*dx)/(float)(bRW*bRW))+((dy*dy)/(float)(bRH*bRH)) <= 1.0f){
+ block[index] = ref_pixels[y*image_width+x];
+ index++;
+ }
+ }
+ }
+
+ // Calculate block mean
+ float mean = 0.0f;
+ for(int i=0; i=image_width-bRW || gy=image_height-bRH || gz=image_depth-bRZ){
+ local_means[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ local_stds[image_width*image_height*gz+gy*image_width+gx] = 0.0f;
+ return;
+ }
+
+ // Get block pixels
+ float block[block_size];
+ int index = 0;
+ for(int z=gz-bRZ; z<=gz+bRZ; z++){
+ for(int y=gy-bRH; y<=gy+bRH; y++){
+ for(int x=gx-bRW; x<=gx+bRW; x++){
+ // Extract only pixels within the inbound spheroid
+ float dx = (float)(x-gx);
+ float dy = (float)(y-gy);
+ float dz = (float)(z-gz);
+ if(((dx*dx)/(float)(bRW*bRW))+((dy*dy)/(float)(bRH*bRH))+((dz*dz)/(float)(bRZ*bRZ)) <= 1.0f){
+ block[index] = ref_pixels[image_width*image_height*z+y*image_width+x];
+ index++;
+ }
+ }
+ }
+ }
+
+ // Calculate block mean
+ float mean = 0.0f;
+ for(int i=0; i=w-bRW || y0=h-bRH){
- return;
- }
-
- // Get reference patch max and min
- float min_x = ref_pixels[y0*w+x0];
- float max_x = ref_pixels[y0*w+x0];
-
- for(int j0=y0-bRH; j0<=y0+bRH; j0++){
- for(int i0=x0-bRW; i0<=x0+bRW; i0++){
- if(ref_pixels[j0*w+i0] < min_x){
- min_x = ref_pixels[j0*w+i0];
- }
- if(ref_pixels[j0*w+i0] > max_x){
- max_x = ref_pixels[j0*w+i0];
- }
- }
- }
-
- // Get normalized reference patch
- float ref_patch[patch_size] = {0.0f};
- float ref_mean = local_means[y0*w+x0];
- float ref_std = local_stds[y0*w+x0];
-
- int ref_counter = 0;
- for(int j0=y0-bRH; j0<=y0+bRH; j0++){
- for(int i0=x0-bRW; i0<=x0+bRW; i0++){
- ref_patch[ref_counter] = (ref_pixels[j0*w+i0] - ref_mean);
- ref_counter++;
- }
- }
-
- // For each comparison pixel...
- float weight = 0.0f;
- for(int y1=bRH; y1 max_y){
- max_y = ref_pixels[j1*w+i1];
- }
- }
- }
-
- // Get normalized comparison patch
- float comp_patch[patch_size];
- float comp_mean = local_means[y1*w+x1];
- float comp_std = local_stds[y1*w+x1];
- int comp_counter = 0;
- for(int j1=y1-bRH; j1<=y1+bRH; j1++){
- for(int i1=x1-bRW; i1<=x1+bRW; i1++){
- comp_patch[comp_counter] = (ref_pixels[j1*w+i1] - comp_mean);
- comp_counter++;
- }
- }
-
- // Calculate weight
- weight = getExpDecayWeight(local_stds[y0*w+x0], local_stds[y1*w+x1]);
-
- // Calculate NRMSE and MAE
- float nrmse = 0.0f;
- float mae = 0.0f;
-
- for(int i=0; i=w-bRW || gy=h-bRH){
- return;
- }
-
-
- // -------------------------- //
- // ---- Get patch pixels ---- //
- // -------------------------- //
-
- float patch[patch_size];
- int index = 0;
- for(int j=gy-bRH; j<=gy+bRH; j++){
- for(int i=gx-bRW; i<=gx+bRW; i++){
- // Extract only pixels within the inbound circle/ellipse
- float dx = (float)(i-gx);
- float dy = (float)(j-gy);
- if(((dx*dx)/(float)(bRW*bRW))+((dy*dy)/(float)(bRH*bRH)) <= 1.0f){
- patch[index] = ref_pixels[j*w+i];
- index++;
- }
- }
- }
-
-
- // ------------------------------ //
- // ---- Calculate patch mean ---- //
- // ------------------------------ //
-
- float mean = 0.0f;
- for(int i=0; i=w-bRW || gy=h-bRH || gz=z-bRZ){
- return;
- }
-
-
- // -------------------------- //
- // ---- Get patch pixels ---- //
- // -------------------------- //
-
- float patch[patch_size];
- int index = 0;
- for(int n=gz-bRZ; n<=gz+bRZ; n++){
- for(int j=gy-bRH; j<=gy+bRH; j++){
- for(int i=gx-bRW; i<=gx+bRW; i++){
- // Extract only pixels within the inbound circle/ellipse
- float dx = (float)(i-gx);
- float dy = (float)(j-gy);
- float dz = (float)(n-gz);
- if(((dx*dx)/(float)(bRW*bRW))+((dy*dy)/(float)(bRH*bRH))+((dz*dz)/(float)(bRZ*bRZ)) <= 1.0f){
- patch[index] = ref_pixels[w*h*n+j*w+i];
- index++;
- }
- }
- }
- }
-
-
- // ------------------------------ //
- // ---- Calculate patch mean ---- //
- // ------------------------------ //
-
- float mean = 0.0f;
- for(int i=0; i=w-bRW || gy=h-bRH || gz=z-bRZ){
- return;
- }
-
-
- // ------------------------------------------------------------------------ //
- // ---- Get mean-subtracted and normalized reference patch from buffer ---- //
- // ------------------------------------------------------------------------ //
-
- __local float ref_patch[patch_size]; // Make a local copy to avoid slower reads from global memory
-
- for(int i=0; i=w-bRW || gy=h-bRH){
- return;
- }
-
-
- // --------------------------------------------- //
- // ---- Get mean-subtracted reference block ---- //
- // --------------------------------------------- //
-
- __local float ref_patch[patch_size]; // Make a local copy to avoid slower reads from global memory
-
- for(int i=0; i=w-bRW || y0=h-bRH){
- return;
- }
-
- // Get reference patch
- float ref_patch[patch_size] = {0.0f};
- float ref_mean = local_means[y0*w+x0];
- float ref_std = local_stds[y0*w+x0];
- float ref_var = ref_std * ref_std;
-
- int ref_counter = 0;
- for(int j0=y0-bRH; j0<=y0+bRH; j0++){
- for(int i0=x0-bRW; i0<=x0+bRW; i0++){
- ref_patch[ref_counter] = ref_pixels[j0*w+i0] - ref_mean;
- ref_counter++;
- }
- }
-
- // For each comparison pixel...
- float weight = 0.0f;
-
- for(int y1=bRH; y1SReD>Block repetition, "Find block repetition (2D)", BlockRepetition2D_
+Plugins>SReD>Block repetition, "Find block repetition (3D)", BlockRepetition3D_
+
+Plugins>SReD>Global Repetition, "Global repetition (2D)", GlobalRepetition2D_
+Plugins>SReD>Global Repetition, "Global repetition (3D)", GlobalRepetition3D_
+
Plugins>SReD>Noise variance stabilisation, "Stabilise noise variance (2D)", VarianceStabilisingTransform2D_
Plugins>SReD>Noise variance stabilisation, "Stabilise noise variance (3D)", VarianceStabilisingTransform3D_
-Plugins>SReD>Block repetition, "Find block repetition (2D)", BlockRedundancy2D_
-Plugins>SReD>Block repetition, "Find block repetition (3D)", BlockRedundancy3D_
-Plugins>SReD>Block repetition, "Find block repetition (2D+T)", BlockRedundancy2DT_
-Plugins>SReD>Global Repetition, "Global repetition (2D)", RedundancyMap_
-Plugins>SReD>Global Repetition, "Global repetition (3D)", GlobalRepetition3D_
-Plugins>SReD, "Cluster repetition scores", ClassifyRedundancy_
-Plugins>SReD, "OpenCL Preferences...", OpenCLPreferences_
+
Plugins>SReD>Relevance Mask, "Calculate Relevance Mask (2D)", RelevanceMask2D_
Plugins>SReD>Relevance Mask, "Calculate Relevance Mask stack (2D)", RelevanceMaskStack2D_
Plugins>SReD>Relevance Mask, "Optimise Relevance Constant (2D)", OptimiseRelevanceMask_
+
Plugins>SReD>Tools, "Calculate image statistics (2D)", CalculateLocalMeans_
+Plugins>SReD>Tools, "Cluster repetition scores", ClassifyRedundancy_
+Plugins>SReD>Tools, "Go to SReD Wiki page", OpenGithubWiki_
+
+Plugins>SReD, "OpenCL Preferences...", OpenCLPreferences_
+
diff --git a/src/test/java/CLUtilsTest.java b/src/test/java/CLUtilsTest.java
new file mode 100644
index 0000000..7966f10
--- /dev/null
+++ b/src/test/java/CLUtilsTest.java
@@ -0,0 +1,1069 @@
+import static java.lang.Math.*;
+import static org.junit.jupiter.api.Assertions.*;
+import com.jogamp.opencl.*;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.FloatBuffer;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+public class CLUtilsTest {
+
+ @Nested
+ class OpenCLResourcesTest {
+
+ @Test
+ public void testOpenCLResourcesConstructor() {
+ // Initialize OpenCL context, device, and queue
+ CLContext context = null;
+ CLDevice device = null;
+ CLCommandQueue queue = null;
+
+ try {
+ // Create a default OpenCL context
+ CLPlatform platform = CLPlatform.listCLPlatforms()[0]; // Get the first platform
+ context = CLContext.create(platform);
+ device = context.getMaxFlopsDevice(); // Choose the best device
+ queue = device.createCommandQueue(); // Create a command queue
+
+ // Create an instance of OpenCLResources
+ CLUtils.OpenCLResources resources = new CLUtils.OpenCLResources(context, device, queue);
+
+ // Assertions to verify the properties of the OpenCLResources instance
+ assertNotNull(resources, "OpenCLResources instance should not be null.");
+ assertNotNull(resources.getContext(), "OpenCL context should not be null.");
+ assertNotNull(resources.getDevice(), "OpenCL device should not be null.");
+ assertNotNull(resources.getQueue(), "OpenCL command queue should not be null.");
+ assertEquals(context, resources.getContext(), "The context should match.");
+ assertEquals(device, resources.getDevice(), "The device should match.");
+ assertEquals(queue, resources.getQueue(), "The command queue should match.");
+
+ } catch (CLException e) {
+ fail("OpenCL initialization failed: " + e.getMessage());
+ } finally {
+ // Release resources if they were created
+ if (queue != null) queue.release();
+ if (context != null) context.release();
+ }
+ }
+ }
+
+ @Nested
+ class CLLocalStatisticsTest {
+
+ @Test
+ public void testCLLocalStatisticsConstructor() {
+ // Sample data for local means and standard deviations
+ float[] localMeans = {1.0f, 2.0f, 3.0f};
+ float[] localStds = {0.1f, 0.2f, 0.3f};
+
+ // Initialize OpenCL context, device, and queue
+ CLContext context = null;
+ CLDevice device = null;
+ CLCommandQueue queue = null;
+
+ CLPlatform platform = CLPlatform.listCLPlatforms()[0]; // Get the first platform
+ context = CLContext.create(platform);
+ device = context.getMaxFlopsDevice(); // Choose the best device
+ queue = device.createCommandQueue(); // Create a command queue
+
+ // Create mock OpenCL buffers (assuming these are valid)
+ CLBuffer clImageArray = context.createFloatBuffer(localMeans.length);
+ CLBuffer clLocalMeans = context.createFloatBuffer(localMeans.length);
+ CLBuffer clLocalStds = context.createFloatBuffer(localMeans.length);
+
+ // Create an instance of CLLocalStatistics
+ CLUtils.CLLocalStatistics localStatistics = new CLUtils.CLLocalStatistics(localMeans, localStds, clImageArray, clLocalMeans, clLocalStds);
+
+ // Assertions to verify the properties of the CLLocalStatistics instance
+ assertNotNull(localStatistics, "CLLocalStatistics instance should not be null.");
+ assertArrayEquals(localMeans, localStatistics.getLocalMeans(), "Local means should match.");
+ assertArrayEquals(localStds, localStatistics.getLocalStds(), "Local standard deviations should match.");
+ assertEquals(clImageArray, localStatistics.getCLImageArray(), "CL image array should match.");
+ assertEquals(clLocalMeans, localStatistics.getCLLocalMeans(), "CL local means buffer should match.");
+ assertEquals(clLocalStds, localStatistics.getCLLocalStds(), "CL local standard deviations buffer should match.");
+ }
+ }
+
+
+ // ------------------------------------------------------------------ //
+ // ---- METHODS FOR OPENCL INITIALISATION AND RESOURCE MANAGEMENT---- //
+ // ------------------------------------------------------------------ //
+
+ @Nested
+ class GetOpenCLResourcesTest {
+
+ @Test
+ public void testGetOpenCLResources() {
+
+ System.out.println("Library path: " + System.getProperty("java.library.path"));
+
+
+ // Call the method to get OpenCL resources
+ CLUtils.OpenCLResources resources = null;
+ boolean useDevice = false; // You can change this to true if you want to test user-defined device preferences
+
+ try {
+ resources = CLUtils.getOpenCLResources(useDevice);
+ } catch (RuntimeException e) {
+ fail("OpenCL initialization failed: " + e.getMessage());
+ }
+
+ // Assert that the resources are not null
+ assertNotNull(resources, "OpenCLResources should not be null.");
+
+ // Assert that the context, device, and queue are initialized
+ assertNotNull(resources.getContext(), "OpenCL context should not be null.");
+ assertNotNull(resources.getDevice(), "OpenCL device should not be null.");
+ assertNotNull(resources.getQueue(), "OpenCL command queue should not be null.");
+
+ // Assert properties of the device or context
+ CLDevice device = resources.getDevice();
+ assertTrue(device.getMaxComputeUnits() > 0, "Device should have compute units.");
+ assertTrue(device.getMaxClockFrequency() > 0, "Device should have a clock frequency.");
+ }
+ }
+
+
+ @Test
+ public void testCreateAndFillCLBuffer() {
+ // Create a CLContext
+ CLUtils.OpenCLResources resources = null;
+ try {
+ resources = CLUtils.getOpenCLResources(false);
+ } catch (RuntimeException e) {
+ fail("OpenCL initialization failed: " + e.getMessage());
+ }
+
+ // Sample data
+ int size = 5;
+ float[] inputArray = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+
+ // Create and fill CLBuffer
+ CLBuffer clBuffer = CLUtils.createAndFillCLBuffer(resources.getContext(), size, CLMemory.Mem.READ_WRITE, inputArray);
+
+ // Validate the CLBuffer is not null
+ assertNotNull(clBuffer, "CLBuffer should not be null.");
+
+ // Validate that the buffer has the expected size
+ assertEquals(size, clBuffer.getBuffer().capacity(), "CLBuffer size should match the input size.");
+
+ // Validate the contents of the buffer
+ FloatBuffer bufferContent = clBuffer.getBuffer();
+ for (int i = 0; i < size; i++) {
+ assertEquals(inputArray[i], bufferContent.get(i), "Buffer content at index " + i + " should match the input array.");
+ }
+
+ // Cleanup
+ clBuffer.release(); // Release the CLBuffer
+ resources.getContext().release();
+ }
+
+
+ @Test
+ public void testFillBufferWithFloatArray() {
+ // Create a CLContext
+ CLUtils.OpenCLResources resources = null;
+ try {
+ resources = CLUtils.getOpenCLResources(false);
+ } catch (RuntimeException e) {
+ fail("OpenCL initialization failed: " + e.getMessage());
+ }
+
+ // Sample data
+ int size = 5;
+ float[] inputArray = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+
+ // Create an empty CLBuffer
+ CLBuffer clBuffer = resources.getContext().createFloatBuffer(size, CLMemory.Mem.READ_WRITE);
+
+ // Fill the CLBuffer with the input array
+ CLUtils.fillBufferWithFloatArray(clBuffer, inputArray);
+
+ // Validate the CLBuffer is not null
+ assertNotNull(clBuffer, "CLBuffer should not be null.");
+
+ // Validate that the buffer has the expected size
+ assertEquals(size, clBuffer.getBuffer().capacity(), "CLBuffer size should match the input size.");
+
+ // Validate the contents of the buffer
+ FloatBuffer bufferContent = clBuffer.getBuffer();
+ for (int i = 0; i < size; i++) {
+ assertEquals(inputArray[i], bufferContent.get(i), "Buffer content at index " + i + " should match the input array.");
+ }
+
+ // Cleanup
+ clBuffer.release();
+ resources.getContext().release();
+ }
+
+
+ @Test
+ public void testGetResourceAsString() {
+ // Get the resource as a string
+ String resourceContent = CLUtils.getResourceAsString(CLUtils.class, "kernelGetBlockPearson2D.cl");
+
+ // Validate that the content is not null
+ assertNotNull(resourceContent, "Resource content should not be null.");
+
+ // Validate the content is as expected (update with your expected content)
+ String expectedContent = "//#pragma OPENCL EXTENSION cl_khr_fp64 : enable\n" +
+ "#define w $WIDTH$\n" +
+ "#define h $HEIGHT$\n" +
+ "#define block_size $BLOCK_SIZE$\n" +
+ "#define bW $BW$\n" +
+ "#define bH $BH$\n" +
+ "#define bRW $BRW$\n" +
+ "#define bRH $BRH$\n" +
+ "#define ref_std $BLOCK_STD$\n" +
+ "#define EPSILON $EPSILON$\n" +
+ "\n" +
+ "kernel void kernelGetBlockPearson2D(\n" +
+ " global float* block_pixels,\n" +
+ " global float* ref_pixels,\n" +
+ " global float* local_means,\n" +
+ " global float* local_stds,\n" +
+ " global float* pearson_map\n" +
+ "){\n" +
+ "\n" +
+ " int gx = get_global_id(0);\n" +
+ " int gy = get_global_id(1);\n" +
+ "\n" +
+ " // Bound check (avoids borders dynamically based on block dimensions)\n" +
+ " if(gx=w-bRW || gy=h-bRH){\n" +
+ " pearson_map[gy*w+gx] = 0.0f;\n" +
+ " return;\n" +
+ " }\n" +
+ "\n" +
+ "\n" +
+ " // --------------------------------------------- //\n" +
+ " // ---- Get mean-subtracted reference block ---- //\n" +
+ " // --------------------------------------------- //\n" +
+ "\n" +
+ " __local float ref_block[block_size]; // Make a local copy to avoid slower reads from global memory\n" +
+ "\n" +
+ " for(int i=0; i= 0.0f && value <= 1.0f); // Assuming result is normalized
+ }
+
+ // Check if result is as expected
+ for(int i=0; i= 0.0f && value <= 1.0f); // Assuming result is normalized
+ }
+
+ // Check if result is as expected
+ for(int i=0; i= 0.0f && value <= 1.0f); // Assuming result is normalized
+ }
+
+ // Check if result is as expected
+ for(int i=0; i= 0.0f && value <= 1.0f); // Assuming result is normalized
+ }
+
+ // Check if result is as expected
+ for(int i=0; i= 0.0f && value <= 1.0f); // Assuming result is normalized
+ }
+
+ // Check if result is as expected
+ for(int i=0; i 0);
+
+ // Check mean and std dev (expected values would depend on the generated block pixels)
+ assertEquals(0.5f, block.getMean(), 1e-6);
+ assertEquals(0.64549720287323f, block.getStd(), 1e-6);
+ }
+
+ @Test
+ public void testGetReferenceBlock2DEvenDimensions() {
+ // Create a new image with even dimensions (invalid case)
+ float[] evenPixels = {
+ 1, 2, 3, 4,
+ 2, 3, 4, 5,
+ 3, 4, 5, 6,
+ 4, 5, 6, 7
+ };
+ FloatProcessor evenFp = new FloatProcessor(4, 4, evenPixels);
+ ImagePlus evenImage = new ImagePlus("Even Dimension Image", evenFp);
+
+ // Set the new image as the current image
+ WindowManager.setTempCurrentImage(evenImage);
+
+ // Retrieve the block
+ Utils.ReferenceBlock2D block = Utils.getReferenceBlock2D(evenImage.getID());
+
+ assertNull(block, "Block should be null for even dimensions");
+ }
+
+ @Test
+ public void testGetReferenceBlock2DNonExistentBlock() {
+ // Simulate a case where block image doesn't exist
+ WindowManager.setTempCurrentImage(null);
+
+ Utils.ReferenceBlock2D block = Utils.getReferenceBlock2D(999); // Non-existent blockID
+
+ assertNull(block, "Block should be null if image not found");
+ }
+ }
+
+
+ @Nested
+ class GetInputImage2DTest {
+
+ @BeforeEach
+ public void setUp() {
+ // Clean WindowManager before each test
+ WindowManager.closeAllWindows();
+ }
+
+ @Test
+ public void testGetInputImage2D_NoStabilization_NoNormalization() {
+ // Set up image dimensions and data
+ int width = 3;
+ int height = 3;
+ float[] pixels = {
+ 0.0f, 0.1f, 0.2f,
+ 0.3f, 0.4f, 0.5f,
+ 0.6f, 0.7f, 0.8f
+ };
+
+ // Create FloatProcessor and ImagePlus
+ FloatProcessor fp = new FloatProcessor(width, height, pixels);
+ ImagePlus imp = new ImagePlus("Test Image", fp);
+
+ // Add the ImagePlus to the WindowManager
+ WindowManager.setTempCurrentImage(imp);
+ int imageID = imp.getID();
+
+ // Call the method
+ Utils.InputImage2D result = Utils.getInputImage2D(imageID, false, false);
+
+ // Verify the result
+ assertNotNull(result);
+ assertArrayEquals(pixels, result.getImageArray());
+ assertEquals(width, result.getWidth());
+ assertEquals(height, result.getHeight());
+ assertEquals(width * height, result.getSize());
+ }
+
+ @Test
+ public void testGetInputImage2D_WithNormalization() {
+ // Set up image dimensions and data
+ int width = 2;
+ int height = 2;
+ float[] pixels = {
+ 10.0f, 20.0f,
+ 30.0f, 40.0f
+ };
+
+ // Expected normalized output
+ float[] normalizedPixels = {
+ 0.0f, 0.3333f,
+ 0.6667f, 1.0f
+ };
+
+ // Create FloatProcessor and ImagePlus
+ FloatProcessor fp = new FloatProcessor(width, height, pixels);
+ ImagePlus imp = new ImagePlus("Test Image", fp);
+
+ // Add the ImagePlus to the WindowManager
+ WindowManager.setTempCurrentImage(imp);
+ int imageID = imp.getID();
+
+ // Call the method with normalization
+ Utils.InputImage2D result = Utils.getInputImage2D(imageID, false, true);
+
+ // Verify the result
+ assertNotNull(result);
+ assertEquals(width, result.getWidth());
+ assertEquals(height, result.getHeight());
+ assertEquals(width * height, result.getSize());
+
+ // Check normalized values with a small delta for floating-point comparison
+ for (int i = 0; i < normalizedPixels.length; i++) {
+ assertEquals(normalizedPixels[i], result.getImageArray()[i], 0.0001);
+ }
+ }
+
+ @Test
+ public void testGetInputImage2D_ImageNotFound() {
+ // Call the method with an invalid imageID
+ Utils.InputImage2D result = Utils.getInputImage2D(999, false, false);
+
+ // Verify that the method returns null when image is not found
+ assertNull(result);
+ }
+ }
+
+
+ @Nested
+ class GetInputImage2DTestOverloaded {
+
+ @Test
+ public void testGetInputImage2D_NoStabilization_NoNormalization() {
+ // Image setup
+ int width = 3;
+ int height = 3;
+ float[] pixels = {
+ 0.0f, 0.1f, 0.2f,
+ 0.3f, 0.4f, 0.5f,
+ 0.6f, 0.7f, 0.8f
+ };
+
+ // Call the method with no stabilization and no normalization
+ Utils.InputImage2D result = Utils.getInputImage2D(pixels, width, height, false, 0.0f, 0.0f, 0.0f, false);
+
+ // Verify the result
+ assertNotNull(result);
+ assertArrayEquals(pixels, result.getImageArray());
+ assertEquals(width, result.getWidth());
+ assertEquals(height, result.getHeight());
+ assertEquals(width * height, result.getSize());
+ }
+
+ @Test
+ public void testGetInputImage2D_WithNormalization() {
+ // Image setup
+ int width = 2;
+ int height = 2;
+ float[] pixels = {
+ 10.0f, 20.0f,
+ 30.0f, 40.0f
+ };
+
+ // Expected normalized output
+ float[] normalizedPixels = {
+ 0.0f, 0.3333f,
+ 0.6667f, 1.0f
+ };
+
+ // Call the method with normalization enabled
+ Utils.InputImage2D result = Utils.getInputImage2D(pixels, width, height, false, 0.0f, 0.0f, 0.0f, true);
+
+ // Verify the result
+ assertNotNull(result);
+ assertEquals(width, result.getWidth());
+ assertEquals(height, result.getHeight());
+ assertEquals(width * height, result.getSize());
+
+ // Check normalized values with a small delta for floating-point comparison
+ for (int i = 0; i < normalizedPixels.length; i++) {
+ assertEquals(normalizedPixels[i], result.getImageArray()[i], 0.0001);
+ }
+ }
+
+
+ }
+
+
+ @Nested
+ class GetMeanNoiseVarTest {
+
+ @Test
+ public void testGetMeanNoiseVar2D() {
+ // Setup a 100x100 image
+ int width = 100; // Image width
+ int height = 100; // Image height
+ float[] refPixels = new float[width * height]; // Initialize array for 100x100 image
+
+ // Fill the array with a simple pattern, e.g., a gradient
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ refPixels[y * width + x] = (float) (x + y * width) / (width * height);
+ }
+ }
+
+ // Calculate total number of pixels
+ int wh = width * height; // Total number of pixels
+
+ // Execute
+ float result = Utils.getMeanNoiseVar2D(refPixels, width, height, wh);
+
+ // Assertions
+ // Check that the result is greater than or equal to zero
+ assertTrue(result >= 0.0f, "The noise variance should be non-negative.");
+
+ // You can also add checks for specific expected values based on known input
+ // For instance, if you know the expected variance for this input
+ // assertEquals(expectedVariance, result, 0.01f); // Adjust tolerance as necessary
+ }
+ }
+
+
+ @Nested
+ class GetMeanAndVarBlock2DTest {
+
+ @Test
+ public void testGetMeanAndVarBlock2D() {
+ // Setup a 100x100 image with known pixel values
+ int width = 100;
+ int height = 100;
+ float[] imageArray = new float[width * height];
+
+ // Fill the array with a simple pattern (e.g., x + y)
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ imageArray[y * width + x] = (float) (x + y);
+ }
+ }
+
+ // Define the block to test (10x10 block starting at (10, 10))
+ int xStart = 10;
+ int yStart = 10;
+ int xEnd = 20; // Exclusive
+ int yEnd = 20; // Exclusive
+
+ // Execute the method
+ float[] meanVar = Utils.getMeanAndVarBlock2D(imageArray, width, xStart, yStart, xEnd, yEnd);
+
+ // Calculate expected mean and variance manually for the block (10x10 block from (10, 10) to (19, 19))
+ float sum = 0.0f;
+ int totalPixels = (xEnd - xStart) * (yEnd - yStart); // 10x10 = 100 pixels
+ for (int y = yStart; y < yEnd; y++) {
+ for (int x = xStart; x < xEnd; x++) {
+ sum += (x + y);
+ }
+ }
+ float expectedMean = sum / totalPixels;
+
+ // For variance, you can compute it similarly by iterating over the block and calculating the sum of squared differences
+ float varianceSum = 0.0f;
+ for (int y = yStart; y < yEnd; y++) {
+ for (int x = xStart; x < xEnd; x++) {
+ float value = (x + y);
+ varianceSum += Math.pow(value - expectedMean, 2);
+ }
+ }
+ float expectedVar = varianceSum / totalPixels;
+
+ // Assertions
+ assertEquals(expectedMean, meanVar[0], 0.01f, "Mean value should match the expected value.");
+ assertEquals(expectedVar, meanVar[1], 0.01f, "Variance value should match the expected value.");
+ }
+ }
+
+
+ @Nested
+ class ApplyMaskTest {
+
+ @Test
+ public void testApplyMask2D() {
+ // Setup a 3x3 image with known pixel values
+ int width = 3;
+ int height = 3;
+ float[] imageArray = new float[] {
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f
+ };
+
+ // Create a mask with known values (e.g., a mask that zeroes out some values)
+ float[] mask = new float[] {
+ 1.0f, 0.0f, 1.0f,
+ 0.0f, 1.0f, 0.0f,
+ 1.0f, 1.0f, 0.0f
+ };
+
+ // Expected result after applying the mask
+ float[] expectedResult = new float[] {
+ 1.0f, 0.0f, 3.0f,
+ 0.0f, 5.0f, 0.0f,
+ 7.0f, 8.0f, 0.0f
+ };
+
+ // Execute the method
+ float[] result = Utils.applyMask2D(imageArray, width, height, mask);
+
+ // Assertions to check if the result matches the expected result
+ assertArrayEquals(expectedResult, result);
+ }
+ }
+
+
+ @Test
+ public void GetRelevanceMaskTest() {
+ // Setup a larger 50x50 image with known pixel values
+ int width = 50;
+ int height = 50;
+
+ // Initialize the imageArray and localStds with some sample data (mock values for illustration)
+ float[] imageArray = new float[width * height];
+ float[] localStds = new float[width * height];
+
+ // Set a seed for reproducibility
+ Random random = new Random(42); // Fixed seed
+
+ // Fill the arrays with reproducible values
+ for (int i = 0; i < width * height; i++) {
+ imageArray[i] = (i % 50 == 0) ? 1.0f : 1.0f + random.nextFloat() * 2.0f; // Values between 1.0f and 3.0f
+ localStds[i] = (i % 50 == 0) ? 0.0f : random.nextFloat(); // Local standard deviations
+ }
+
+ // Parameters for the relevance mask
+ int blockRadiusWidth = 2; // Adjusted radius
+ int blockRadiusHeight = 2; // Adjusted radius
+ float relevanceConstant = 2.0f;
+
+ // Calculate expected noise mean variance based on mock data
+ float noiseMeanVariance = 0.25f; // Assuming pre-calculated based on input
+
+ // Create expected relevance mask (for a large test case, exact expected values may vary)
+ float relevanceThreshold = noiseMeanVariance * relevanceConstant;
+
+ // Execute the method
+ Utils.RelevanceMask relevanceMask = Utils.getRelevanceMask(imageArray, width, height, blockRadiusWidth, blockRadiusHeight, localStds, relevanceConstant);
+
+ // Assertions to check if the relevance mask is correctly generated
+ assertEquals(relevanceConstant, relevanceMask.getRelevanceConstant());
+ assertEquals(0.4694742262363434f, relevanceMask.getRelevanceThreshold());
+ assertEquals(0.2347371131181717, relevanceMask.getNoiseMeanVariance());
+
+ // Optionally check some values in the mask for correctness (e.g., expected ranges or patterns)
+ // Example: Check some central part of the mask
+ for (int y = 20; y < 30; y++) {
+ for (int x = 20; x < 30; x++) {
+ assertTrue(relevanceMask.getRelevanceMask()[y * width + x] == 1.0f || relevanceMask.getRelevanceMask()[y * width + x] == 0.0f);
+ }
+ }
+ }
+
+
+ @Nested
+ class NormalizeImage2DTest {
+
+ @Test
+ public void testNormalizeImageWithBinaryMask() {
+ // Setup: a small 4x4 image with known pixel values and a valid binary mask
+ int width = 4;
+ int height = 4;
+ int borderWidth = 1;
+ int borderHeight = 1;
+
+ float[] imageArray = new float[] {
+ 1.0f, 2.0f, 3.0f, 4.0f,
+ 5.0f, 6.0f, 7.0f, 8.0f,
+ 9.0f, 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f, 16.0f
+ };
+
+ // Binary mask (0.0f or 1.0f only)
+ float[] mask = new float[] {
+ 1.0f, 0.0f, 1.0f, 0.0f,
+ 1.0f, 1.0f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f
+ };
+
+ // Expected normalized array with the mask applied (min = 1.0, max = 16.0)
+ float[] expectedArray = new float[] {
+ 1.0f, 2.0f, 3.0f, 4.0f,
+ 5.0f, 0.0f, 7.0f, 8.0f,
+ 9.0f, 10.0f, 1.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f, 16.0f
+ };
+
+ // Run the normalization with a binary mask
+ float[] normalizedArray = Utils.normalizeImage2D(imageArray, width, height, borderWidth, borderHeight, mask);
+
+ // Assertions: Check that the normalized array is as expected
+ assertArrayEquals(expectedArray, normalizedArray, 0.0001f);
+ }
+
+ @Test
+ public void testNormalizeImageWithInvalidMask() {
+ // Setup: a small 4x4 image with known pixel values and an invalid mask (non-binary values)
+ int width = 4;
+ int height = 4;
+ int borderWidth = 0;
+ int borderHeight = 0;
+
+ float[] imageArray = new float[] {
+ 1.0f, 2.0f, 3.0f, 4.0f,
+ 5.0f, 6.0f, 7.0f, 8.0f,
+ 9.0f, 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f, 16.0f
+ };
+
+ // Invalid mask (contains values other than 0.0f or 1.0f)
+ float[] invalidMask = new float[] {
+ 1.0f, 0.5f, 1.0f, 0.0f,
+ 1.0f, 0.8f, 0.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f, 1.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f
+ };
+
+ // Expect an IllegalArgumentException due to non-binary mask values
+ assertThrows(IllegalArgumentException.class, () -> {
+ Utils.normalizeImage2D(imageArray, width, height, borderWidth, borderHeight, invalidMask);
+ });
+ }
+ }
+
+
+ // ----------------------------------------- //
+ // ---- METHODS FOR BLOCK REPETITION 3D ---- //
+ // ----------------------------------------- //
+
+ @Nested
+ class GetReferenceBlock3DTest {
+
+ @Test
+ public void testBlockRetrieval() {
+ // Create a 3D ImagePlus object (3x3x3 block) and assign it a window ID
+ int width = 3;
+ int height = 3;
+ int depth = 3;
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice with some values
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ fp.setf(x, y, (z + 1) * (x + 1) + y); // Some arbitrary pattern
+ }
+ }
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Image", stack);
+ imagePlus.show(); // This assigns it an ID in the WindowManager
+
+ // Get the blockID (WindowManager uses 1-based indexing)
+ int blockID = imagePlus.getID();
+
+ // Run the method
+ Utils.ReferenceBlock3D refBlock = Utils.getReferenceBlock3D(blockID);
+
+ // Assert that the block is not null
+ assertNotNull(refBlock);
+
+ // Assert block dimensions
+ assertEquals(width, refBlock.getWidth());
+ assertEquals(height, refBlock.getHeight());
+ assertEquals(depth, refBlock.getDepth());
+
+ // Assert blockSize matches the count of pixels within the ellipsoid
+ assertTrue(refBlock.getSize() > 0);
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false; // Prevents "Save changes?" prompt
+ imagePlus.close();
+ }
+
+ @Test
+ public void testOddDimensionValidation() {
+ // Create a 3D ImagePlus object with even dimensions (should fail)
+ int width = 4; // Even
+ int height = 3; // Odd
+ int depth = 3; // Odd
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Even Width Image", stack);
+ imagePlus.show();
+
+ // Run the method and expect an exception due to even dimensions
+ int blockID = imagePlus.getID();
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ Utils.getReferenceBlock3D(blockID);
+ });
+ assertEquals("Block dimensions must be odd.", exception.getMessage());
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+
+ @Test
+ public void testMinimumSlicesValidation() {
+ // Create a 3D ImagePlus object with fewer than 3 slices (should fail)
+ int width = 3;
+ int height = 3;
+ int depth = 1; // Less than 3 slices
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Few Slices Image", stack);
+ imagePlus.show();
+
+ // Run the method and expect an exception due to fewer than 3 slices
+ int blockID = imagePlus.getID();
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ Utils.getReferenceBlock3D(blockID);
+ });
+ assertEquals("Reference block must have at least 3 slices.", exception.getMessage());
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+
+ @Test
+ public void testNormalizationAndStatistics() {
+ // Create a 3x3x3 ImagePlus object for testing normalization and statistics
+ int width = 3;
+ int height = 3;
+ int depth = 3;
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice with a known pattern
+ float[][] slices = {
+ { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f },
+ { 9.0f, 8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f },
+ { 1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 2.0f, 4.0f, 6.0f, 8.0f }
+ };
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ fp.setPixels(slices[z]);
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Image for Stats", stack);
+ imagePlus.show();
+
+ // Get the blockID (WindowManager uses 1-based indexing)
+ int blockID = imagePlus.getID();
+
+ // Run the method
+ Utils.ReferenceBlock3D refBlock = Utils.getReferenceBlock3D(blockID);
+
+ // Validate the statistics of the block
+ assertNotNull(refBlock);
+
+ // Ensure that the mean and standard deviation have been computed
+ assertTrue(refBlock.getMean() != 0.0f);
+ assertTrue(refBlock.getStd() != 0.0f);
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+ }
+
+
+ @Nested
+ class GetInputImage3DTest {
+
+ @Test
+ public void testImageRetrieval() {
+ // Create a 3D ImagePlus object (3x3x3 block) and assign it a window ID
+ int width = 3;
+ int height = 3;
+ int depth = 3;
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice with some values
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ fp.setf(x, y, (z + 1) * (x + 1) + y); // Arbitrary values
+ }
+ }
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Image", stack);
+ imagePlus.show(); // Assigns an ID in WindowManager
+
+ // Get the imageID (WindowManager uses 1-based indexing)
+ int imageID = imagePlus.getID();
+
+ // Call the method (without stabilizing noise variance, but normalizing output)
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageID, false, true);
+
+ // Assertions
+ assertNotNull(inputImage, "Image should be retrieved successfully.");
+ assertEquals(width, inputImage.getWidth(), "Width should match.");
+ assertEquals(height, inputImage.getHeight(), "Height should match.");
+ assertEquals(depth, inputImage.getDepth(), "Depth should match.");
+ assertEquals(width * height * depth, inputImage.getSize(), "Size should match.");
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false; // Prevents "Save changes?" prompt
+ imagePlus.close();
+ }
+
+ @Test
+ public void testImageNotFound() {
+ // Call method with an invalid image ID
+ int invalidImageID = 9999; // Assuming this ID does not exist
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(invalidImageID, false, false);
+
+ // Assert that the method returns null when the image is not found
+ assertNull(inputImage, "Image should not be found and the method should return null.");
+ }
+
+ @Test
+ public void testInsufficientSlices() {
+ // Create an ImagePlus object with only 2 slices (should fail)
+ int width = 3;
+ int height = 3;
+ int depth = 2; // Less than 3 slices
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Few Slices Image", stack);
+ imagePlus.show(); // Assigns an ID in WindowManager
+
+ // Get the imageID
+ int imageID = imagePlus.getID();
+
+ // Call the method (should return null due to insufficient slices)
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageID, false, false);
+
+ // Assert that the method returns null when there are fewer than 3 slices
+ assertNull(inputImage, "Image must have at least 3 slices, method should return null.");
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+
+ @Test
+ public void testNormalization() {
+ // Create a 3x3x3 ImagePlus object for testing normalization
+ int width = 3;
+ int height = 3;
+ int depth = 3;
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice with a known pattern
+ float[][] slices = {
+ { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f }, // Slice 1
+ { 9.0f, 8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f }, // Slice 2
+ { 1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 2.0f, 4.0f, 6.0f, 8.0f } // Slice 3
+ };
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ fp.setPixels(slices[z]);
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Image for Normalization", stack);
+ imagePlus.show(); // Assigns an ID in WindowManager
+
+ // Get the imageID
+ int imageID = imagePlus.getID();
+
+ // Call the method with normalization enabled
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageID, false, true);
+
+ // Assertions
+ assertNotNull(inputImage, "Image should be retrieved successfully.");
+ float[] normalizedArray = inputImage.getImageArray();
+ assertNotNull(normalizedArray, "Array should not be null after normalization.");
+ assertEquals(width * height * depth, normalizedArray.length, "Array length should match image size.");
+
+ // Ensure array values are within the normalized range (0.0f - 1.0f)
+ for (float value : normalizedArray) {
+ assertTrue(value >= 0.0f && value <= 1.0f, "All values should be in the range [0.0, 1.0].");
+ }
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+
+ @Test
+ public void testNoiseVarianceStabilization() {
+ // Create a 3x3x3 ImagePlus object for testing noise variance stabilization
+ int width = 3;
+ int height = 3;
+ int depth = 3;
+ ImageStack stack = new ImageStack(width, height);
+
+ // Fill each slice with arbitrary values
+ for (int z = 0; z < depth; z++) {
+ FloatProcessor fp = new FloatProcessor(width, height);
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ fp.setf(x, y, (float) (Math.random() * 100)); // Random values
+ }
+ }
+ stack.addSlice(fp);
+ }
+ ImagePlus imagePlus = new ImagePlus("Test Image for Noise Variance", stack);
+ imagePlus.show(); // Assigns an ID in WindowManager
+
+ // Get the imageID
+ int imageID = imagePlus.getID();
+
+ // Call the method with noise variance stabilization enabled
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageID, true, false);
+
+ // Assertions
+ assertNotNull(inputImage, "Image should be retrieved successfully.");
+ assertEquals(width, inputImage.getWidth(), "Width should match the input image.");
+ assertEquals(height, inputImage.getHeight(), "Height should match the input image.");
+ assertEquals(depth, inputImage.getDepth(), "Depth should match the input image.");
+ assertDoesNotThrow(() -> {
+ float gain = inputImage.getGain();
+ float sigma = inputImage.getSigma();
+ float offset = inputImage.getOffset();
+ }, "Gain, sigma, and offset calculations should not throw exceptions.");
+
+ // Clean up ImageJ windows after the test
+ imagePlus.changes = false;
+ imagePlus.close();
+ }
+ }
+
+
+ @Nested
+ class GetInputImage3DOverloadTest {
+
+ @Test
+ void testGetInputImage3DWithoutNoiseStabilizationOrNormalization() {
+ // Setup: 3D image data (2x2x3)
+ int width = 2;
+ int height = 2;
+ int depth = 3;
+ float[] imageArray = new float[] {
+ 1.0f, 2.0f, 3.0f, 4.0f, // Slice 1
+ 5.0f, 6.0f, 7.0f, 8.0f, // Slice 2
+ 9.0f, 10.0f, 11.0f, 12.0f // Slice 3
+ };
+
+ // Test without stabilization or normalization
+ boolean stabiliseNoiseVariance = false;
+ boolean normalizeOutput = false;
+
+ // Run the method
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageArray, width, height, depth, stabiliseNoiseVariance, normalizeOutput);
+
+ // Assert that the image was returned correctly
+ assertNotNull(inputImage, "Image should be retrieved successfully.");
+ assertEquals(width, inputImage.getWidth());
+ assertEquals(height, inputImage.getHeight());
+ assertEquals(depth, inputImage.getDepth());
+
+ // Check that gain, sigma, and offset are still 0.0f
+ assertEquals(0.0f, inputImage.getGain(), 0.0001f);
+ assertEquals(0.0f, inputImage.getSigma(), 0.0001f);
+ assertEquals(0.0f, inputImage.getOffset(), 0.0001f);
+ }
+
+ @Test
+ void testGetInputImage3DWithNormalization() {
+ // Setup: 3D image data (2x2x3)
+ int width = 2;
+ int height = 2;
+ int depth = 3;
+ float[] imageArray = new float[] {
+ 1.0f, 2.0f, 3.0f, 4.0f, // Slice 1
+ 5.0f, 6.0f, 7.0f, 8.0f, // Slice 2
+ 9.0f, 10.0f, 11.0f, 12.0f // Slice 3
+ };
+
+ // Test with normalization but no noise stabilization
+ boolean stabiliseNoiseVariance = false;
+ boolean normalizeOutput = true;
+
+ // Expected normalized array (min = 1.0, max = 12.0)
+ float[] expectedArray = new float[] {
+ 0.0f, 0.090f, 0.181f, 0.272f,
+ 0.363f, 0.454f, 0.545f, 0.636f,
+ 0.727f, 0.818f, 0.909f, 1.0f
+ };
+
+ // Run the method
+ Utils.InputImage3D inputImage = Utils.getInputImage3D(imageArray, width, height, depth, stabiliseNoiseVariance, normalizeOutput);
+
+ // Assert that the image was returned correctly
+ assertNotNull(inputImage, "Image should be retrieved successfully.");
+ assertArrayEquals(expectedArray, inputImage.getImageArray(), 0.001f);
+ }
+ }
+
+
+ @Nested
+ class GetMeanAndVarBlock3DTest {
+
+ @Test
+ void testGetMeanAndVarBlock3D() {
+ // Setup: create a 3D image with known values (4x4x4)
+ int imageWidth = 4;
+ int imageHeight = 4;
+ int depth = 4;
+ float[] pixels = new float[] {
+ // Slice 1 (z=0)
+ 1.0f, 2.0f, 3.0f, 4.0f,
+ 5.0f, 6.0f, 7.0f, 8.0f,
+ 9.0f, 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f, 16.0f,
+ // Slice 2 (z=1)
+ 17.0f, 18.0f, 19.0f, 20.0f,
+ 21.0f, 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f, 28.0f,
+ 29.0f, 30.0f, 31.0f, 32.0f,
+ // Slice 3 (z=2)
+ 33.0f, 34.0f, 35.0f, 36.0f,
+ 37.0f, 38.0f, 39.0f, 40.0f,
+ 41.0f, 42.0f, 43.0f, 44.0f,
+ 45.0f, 46.0f, 47.0f, 48.0f,
+ // Slice 4 (z=3)
+ 49.0f, 50.0f, 51.0f, 52.0f,
+ 53.0f, 54.0f, 55.0f, 56.0f,
+ 57.0f, 58.0f, 59.0f, 60.0f,
+ 61.0f, 62.0f, 63.0f, 64.0f
+ };
+
+ // Define block coordinates (xStart, yStart, zStart, xEnd, yEnd, zEnd)
+ int xStart = 1, yStart = 1, zStart = 1;
+ int xEnd = 3, yEnd = 3, zEnd = 3; // This block is a 2x2x2 block from slice 2-3
+
+ // Expected mean and variance for the 2x2x2 block
+ float expectedMean = (22.0f + 23.0f + 26.0f + 27.0f + 38.0f + 39.0f + 42.0f + 43.0f) / 8.0f;
+ float expectedVariance = (float) (Math.pow(22.0 - expectedMean, 2) + Math.pow(23.0 - expectedMean, 2)
+ + Math.pow(26.0 - expectedMean, 2) + Math.pow(27.0 - expectedMean, 2)
+ + Math.pow(38.0 - expectedMean, 2) + Math.pow(39.0 - expectedMean, 2)
+ + Math.pow(42.0 - expectedMean, 2) + Math.pow(43.0 - expectedMean, 2)) / 8.0f;
+
+ // Run the method
+ float[] result = Utils.getMeanAndVarBlock3D(pixels, imageWidth, imageHeight, xStart, yStart, zStart, xEnd, yEnd, zEnd);
+
+ // Assert the mean and variance are correct
+ assertEquals(expectedMean, result[0], 0.0001f, "Mean should match expected value.");
+ assertEquals(expectedVariance, result[1], 0.0001f, "Variance should match expected value.");
+ }
+ }
+
+
+ @Nested
+ class GetNoiseMeanVar3DTest {
+
+ @Test
+ void testGetMeanNoiseVar3D() {
+ // Setup: define dimensions and localStds array
+ int imageWidth = 5;
+ int imageHeight = 5;
+ int imageDepth = 5;
+ int blockRadiusWidth = 1;
+ int blockRadiusHeight = 1;
+ int blockRadiusDepth = 1;
+
+ // Create a known localStds array (5x5x5), representing standard deviations at each pixel
+ float[] localStds = new float[] {
+ // Slice 1
+ 1.0f, 1.2f, 1.1f, 1.3f, 1.0f,
+ 1.1f, 1.3f, 1.2f, 1.3f, 1.0f,
+ 1.2f, 1.1f, 1.0f, 1.2f, 1.1f,
+ 1.3f, 1.1f, 1.3f, 1.2f, 1.0f,
+ 1.0f, 1.2f, 1.1f, 1.0f, 1.3f,
+ // Slice 2
+ 1.0f, 1.1f, 1.2f, 1.3f, 1.1f,
+ 1.2f, 1.3f, 1.0f, 1.3f, 1.1f,
+ 1.3f, 1.2f, 1.1f, 1.2f, 1.3f,
+ 1.1f, 1.3f, 1.2f, 1.1f, 1.0f,
+ 1.2f, 1.1f, 1.3f, 1.1f, 1.2f,
+ // Slice 3
+ 1.1f, 1.2f, 1.3f, 1.0f, 1.2f,
+ 1.3f, 1.2f, 1.1f, 1.0f, 1.3f,
+ 1.1f, 1.3f, 1.2f, 1.0f, 1.1f,
+ 1.2f, 1.0f, 1.1f, 1.2f, 1.3f,
+ 1.3f, 1.2f, 1.1f, 1.3f, 1.2f,
+ // Slice 4
+ 1.1f, 1.3f, 1.2f, 1.0f, 1.2f,
+ 1.0f, 1.3f, 1.1f, 1.3f, 1.2f,
+ 1.3f, 1.1f, 1.2f, 1.1f, 1.0f,
+ 1.2f, 1.0f, 1.3f, 1.1f, 1.2f,
+ 1.1f, 1.2f, 1.0f, 1.2f, 1.3f,
+ // Slice 5
+ 1.3f, 1.0f, 1.1f, 1.3f, 1.2f,
+ 1.0f, 1.1f, 1.2f, 1.1f, 1.3f,
+ 1.3f, 1.2f, 1.0f, 1.1f, 1.2f,
+ 1.0f, 1.3f, 1.1f, 1.2f, 1.1f,
+ 1.2f, 1.3f, 1.0f, 1.1f, 1.0f
+ };
+
+ float expectedMeanNoiseVar = 1.355f; // Example expected result
+
+ // Run the method
+ float result = Utils.getMeanNoiseVar3D(imageWidth, imageHeight, imageDepth, blockRadiusWidth, blockRadiusHeight, blockRadiusDepth, localStds);
+
+ // Assert the result is correct
+ assertEquals(expectedMeanNoiseVar, result, 0.001f, "Mean noise variance should match expected value.");
+ }
+ }
+
+
+ @Nested
+ class GetRelevanceMask3DTest {
+
+ @Test
+ void testGetRelevanceMask3D() {
+ // Setup: define dimensions and input parameters
+ int imageWidth = 5;
+ int imageHeight = 5;
+ int imageDepth = 5;
+ int blockRadiusWidth = 1;
+ int blockRadiusHeight = 1;
+ int blockRadiusDepth = 1;
+ float relevanceConstant = 1.0f;
+
+ // Create a known localStds array (5x5x5), representing standard deviations at each pixel
+ float[] localStds = new float[] {
+ // Slice 1
+ 1.0f, 1.2f, 1.1f, 1.3f, 1.0f,
+ 1.1f, 1.3f, 1.2f, 1.3f, 1.0f,
+ 1.2f, 1.1f, 1.0f, 1.2f, 1.1f,
+ 1.3f, 1.1f, 1.3f, 1.2f, 1.0f,
+ 1.0f, 1.2f, 1.1f, 1.0f, 1.3f,
+ // Slice 2
+ 1.0f, 1.1f, 1.2f, 1.3f, 1.1f,
+ 1.2f, 1.3f, 1.0f, 1.3f, 1.1f,
+ 1.3f, 1.2f, 1.1f, 1.2f, 1.3f,
+ 1.1f, 1.3f, 1.2f, 1.1f, 1.0f,
+ 1.2f, 1.1f, 1.3f, 1.1f, 1.2f,
+ // Slice 3
+ 1.1f, 1.2f, 1.3f, 1.0f, 1.2f,
+ 1.3f, 1.2f, 1.1f, 1.0f, 1.3f,
+ 1.1f, 1.3f, 1.2f, 1.0f, 1.1f,
+ 1.2f, 1.0f, 1.1f, 1.2f, 1.3f,
+ 1.3f, 1.2f, 1.1f, 1.3f, 1.2f,
+ // Slice 4
+ 1.1f, 1.3f, 1.2f, 1.0f, 1.2f,
+ 1.0f, 1.3f, 1.1f, 1.3f, 1.2f,
+ 1.3f, 1.1f, 1.2f, 1.1f, 1.0f,
+ 1.2f, 1.0f, 1.3f, 1.1f, 1.2f,
+ 1.1f, 1.2f, 1.0f, 1.2f, 1.3f,
+ // Slice 5
+ 1.3f, 1.0f, 1.1f, 1.3f, 1.2f,
+ 1.0f, 1.1f, 1.2f, 1.1f, 1.3f,
+ 1.3f, 1.2f, 1.0f, 1.1f, 1.2f,
+ 1.0f, 1.3f, 1.1f, 1.2f, 1.1f,
+ 1.2f, 1.3f, 1.0f, 1.1f, 1.0f
+ };
+
+ // Calculate expected mean noise variance
+ float expectedMeanNoiseVariance = Utils.getMeanNoiseVar3D(imageWidth, imageHeight, imageDepth, blockRadiusWidth,
+ blockRadiusHeight, blockRadiusDepth, localStds);
+
+ // Calculate the relevance mask
+ float[] relevanceMask = Utils.getRelevanceMask3D(imageWidth, imageHeight, imageDepth, blockRadiusWidth,
+ blockRadiusHeight, blockRadiusDepth, localStds, relevanceConstant);
+
+ // Verify the mask values
+ for (int z = blockRadiusDepth; z < imageDepth - blockRadiusDepth; z++) {
+ for (int y = blockRadiusHeight; y < imageHeight - blockRadiusHeight; y++) {
+ for (int x = blockRadiusWidth; x < imageWidth - blockRadiusWidth; x++) {
+ int index = imageWidth * imageHeight * z + y * imageWidth + x;
+ float localVariance = localStds[index] * localStds[index];
+ if (localVariance <= expectedMeanNoiseVariance * relevanceConstant) {
+ assertEquals(0.0f, relevanceMask[index], "Relevance mask value at (" + x + ", " + y + ", " + z + ") should be 0.0");
+ } else {
+ assertEquals(1.0f, relevanceMask[index], "Relevance mask value at (" + x + ", " + y + ", " + z + ") should be 1.0");
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+ @Nested
+ class ApplyMask3DTest {
+
+ @Test
+ void testApplyMask3D() {
+ // Setup: Define dimensions and initialize a test image and mask
+ int imageWidth = 3;
+ int imageHeight = 3;
+ int imageDepth = 3;
+
+ // Create a sample 3D image (3x3x3)
+ float[] imageArray = new float[] {
+ // Slice 1
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
+ // Slice 2
+ 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f,
+ 16.0f, 17.0f, 18.0f,
+ // Slice 3
+ 19.0f, 20.0f, 21.0f,
+ 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Create a mask (1.0f for keep, 0.0f for remove)
+ float[] mask = new float[] {
+ // Slice 1
+ 1.0f, 0.0f, 1.0f,
+ 1.0f, 1.0f, 0.0f,
+ 0.0f, 1.0f, 1.0f,
+ // Slice 2
+ 0.0f, 1.0f, 0.0f,
+ 1.0f, 0.0f, 1.0f,
+ 1.0f, 0.0f, 0.0f,
+ // Slice 3
+ 1.0f, 0.0f, 1.0f,
+ 0.0f, 1.0f, 0.0f,
+ 1.0f, 1.0f, 1.0f
+ };
+
+ // Expected result after applying mask
+ float[] expectedImageArray = new float[] {
+ // Slice 1
+ 1.0f, 0.0f, 3.0f,
+ 4.0f, 5.0f, 0.0f,
+ 0.0f, 8.0f, 9.0f,
+ // Slice 2
+ 0.0f, 11.0f, 0.0f,
+ 13.0f, 0.0f, 15.0f,
+ 16.0f, 0.0f, 0.0f,
+ // Slice 3
+ 19.0f, 0.0f, 21.0f,
+ 0.0f, 23.0f, 0.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Apply the mask
+ float[] resultImageArray = Utils.applyMask3D(imageArray, imageWidth, imageHeight, imageDepth, mask);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedImageArray, resultImageArray, "The masked image array does not match the expected output.");
+ }
+ }
+
+
+ @Nested
+ class NormalizeImage3DTest {
+
+
+ @Test
+ void testNormalizeImage3DWithoutMask() {
+ // Setup: Define dimensions and initialize a test image
+ int imageWidth = 3;
+ int imageHeight = 3;
+ int imageDepth = 3;
+
+ // Create a sample 3D image (3x3x3)
+ float[] imageArray = new float[] {
+ // Slice 1
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
+ // Slice 2
+ 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f,
+ 16.0f, 17.0f, 18.0f,
+ // Slice 3
+ 19.0f, 20.0f, 21.0f,
+ 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Define border dimensions
+ int borderWidth = 0;
+ int borderHeight = 0;
+ int borderDepth = 0;
+
+ // Expected result after normalization (values remapped to [0, 1])
+ float[] expectedNormalizedArray = new float[] {
+ // Slice 1
+ 0.0f, 0.03846154f, 0.07692308f,
+ 0.115384616f, 0.15384616f, 0.1923077f,
+ 0.23076923f, 0.26923078f, 0.30769232f,
+ // Slice 2
+ 0.34615386f, 0.3846154f, 0.42307693f,
+ 0.46153846f, 0.5f, 0.53846157f,
+ 0.5769231f, 0.61538464f, 0.65384614f,
+ // Slice 3
+ 0.6923077f, 0.7307692f, 0.7692308f,
+ 0.8076923f, 0.84615386f, 0.88461536f,
+ 0.9230769f, 0.96153843f, 1.0f
+ };
+
+ // Normalize the image without mask
+ float[] normalizedImage = Utils.normalizeImage3D(imageArray, imageWidth, imageHeight, imageDepth, borderWidth, borderHeight, borderDepth, null);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedImage, Utils.EPSILON, "The normalized image array does not match the expected output.");
+ }
+
+ @Test
+ void testNormalizeImage3DWithMask() {
+ // Setup: Define dimensions and initialize a test image with a mask
+ int imageWidth = 3;
+ int imageHeight = 3;
+ int imageDepth = 3;
+
+ // Create a sample 3D image (3x3x3)
+ float[] imageArray = new float[] {
+ // Slice 1
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
+ // Slice 2
+ 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f,
+ 16.0f, 17.0f, 18.0f,
+ // Slice 3
+ 19.0f, 20.0f, 21.0f,
+ 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Create a mask (1.0f for keep, 0.0f for remove)
+ float[] mask = new float[] {
+ // Slice 1
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ // Slice 2
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ // Slice 3
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f
+ };
+
+ // Define border dimensions
+ int borderWidth = 0;
+ int borderHeight = 0;
+ int borderDepth = 0;
+
+ // Expected result after normalization (same as without mask, since all values are included)
+ float[] expectedNormalizedArray = new float[] {
+ // Slice 1
+ 0.0f, 0.03846154f, 0.07692308f,
+ 0.115384616f, 0.15384616f, 0.1923077f,
+ 0.23076923f, 0.26923078f, 0.30769232f,
+ // Slice 2
+ 0.34615386f, 0.3846154f, 0.42307693f,
+ 0.46153846f, 0.5f, 0.53846157f,
+ 0.5769231f, 0.61538464f, 0.65384614f,
+ // Slice 3
+ 0.6923077f, 0.7307692f, 0.7692308f,
+ 0.8076923f, 0.84615386f, 0.88461536f,
+ 0.9230769f, 0.96153843f, 1.0f
+ };
+
+ // Normalize the image with mask
+ float[] normalizedImage = Utils.normalizeImage3D(imageArray, imageWidth, imageHeight, imageDepth, borderWidth, borderHeight, borderDepth, mask);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedImage, Utils.EPSILON, "The normalized image array with mask does not match the expected output.");
+ }
+
+ @Test
+ void testNormalizeImage3DWithMaskAndBorders() {
+ // Setup: Define dimensions and initialize a test image with a mask
+ int imageWidth = 3;
+ int imageHeight = 3;
+ int imageDepth = 3;
+
+ // Create a sample 3D image (3x3x3)
+ float[] imageArray = new float[] {
+ // Slice 1
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
+ // Slice 2
+ 10.0f, 11.0f, 12.0f,
+ 13.0f, 14.0f, 15.0f,
+ 16.0f, 17.0f, 18.0f,
+ // Slice 3
+ 19.0f, 20.0f, 21.0f,
+ 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Create a mask (1.0f for keep, 0.0f for remove)
+ float[] mask = new float[] {
+ // Slice 1
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ // Slice 2
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ // Slice 3
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f
+ };
+
+ // Define border dimensions
+ int borderWidth = 1;
+ int borderHeight = 1;
+ int borderDepth = 1;
+
+ // Expected result after normalization (with borders ignored)
+ float[] expectedNormalizedArray = new float[] {
+ // Slice 1
+ 1.0f, 2.0f, 3.0f,
+ 4.0f, 5.0f, 6.0f,
+ 7.0f, 8.0f, 9.0f,
+ // Slice 2
+ 10.0f, 11.0f, 12.0f,
+ 13.0f, 0.0f, 15.0f,
+ 16.0f, 17.0f, 18.0f,
+ // Slice 3
+ 19.0f, 20.0f, 21.0f,
+ 22.0f, 23.0f, 24.0f,
+ 25.0f, 26.0f, 27.0f
+ };
+
+ // Normalize the image with mask and borders
+ float[] normalizedImage = Utils.normalizeImage3D(imageArray, imageWidth, imageHeight, imageDepth, borderWidth, borderHeight, borderDepth, mask);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedImage, Utils.EPSILON, "The normalized image array with mask and borders does not match the expected output.");
+ }
+ }
+
+
+ // -------------------------- //
+ // ---- UNSORTED METHODS ---- //
+ // -------------------------- //
+
+ @Nested
+ class NormalizeArrayTest {
+
+ @Test
+ void testNormalizeArray() {
+ // Setup: Create a sample array
+ float[] inputArray = new float[] {3.0f, 5.0f, 1.0f, 8.0f, 2.0f};
+
+ // Expected normalized output based on the min (1.0f) and max (8.0f)
+ float[] expectedNormalizedArray = new float[] {
+ (3.0f - 1.0f) / (8.0f - 1.0f + Utils.EPSILON), // ≈ 0.25
+ (5.0f - 1.0f) / (8.0f - 1.0f + Utils.EPSILON), // ≈ 0.50
+ (1.0f - 1.0f) / (8.0f - 1.0f + Utils.EPSILON), // 0.0
+ (8.0f - 1.0f) / (8.0f - 1.0f + Utils.EPSILON), // 1.0
+ (2.0f - 1.0f) / (8.0f - 1.0f + Utils.EPSILON) // ≈ 0.125
+ };
+
+ // Normalize the array
+ float[] normalizedArray = Utils.normalizeArray(inputArray);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedArray, Utils.EPSILON, "The normalized array does not match the expected output.");
+ }
+
+ @Test
+ void testNormalizeArraySingleValue() {
+ // Test with an array of a single value
+ float[] inputArray = new float[] {5.0f};
+
+ // Normalizing a single value should return an array with the same value
+ float[] expectedNormalizedArray = new float[] {0.0f}; // Edge case
+
+ // Normalize the array
+ float[] normalizedArray = Utils.normalizeArray(inputArray);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedArray, Utils.EPSILON, "The normalized array with a single value does not match the expected output.");
+ }
+
+ @Test
+ void testNormalizeArrayWithNegativeValues() {
+ // Setup: Create a sample array with negative values
+ float[] inputArray = new float[] {-3.0f, -5.0f, -1.0f, -8.0f, -2.0f};
+
+ // Find min and max
+ float arrMin = Float.MAX_VALUE;
+ float arrMax = -Float.MAX_VALUE;
+ for(int i=0; i< inputArray.length; i++){
+ arrMin = min(arrMin, inputArray[i]);
+ arrMax = max(arrMax, inputArray[i]);
+ }
+
+ // Calculate expected normalized array
+ float[] expectedNormalizedArray = {
+ (inputArray[0]-arrMin)/(arrMax-arrMin+Utils.EPSILON),
+ (inputArray[1]-arrMin)/(arrMax-arrMin+Utils.EPSILON),
+ (inputArray[2]-arrMin)/(arrMax-arrMin+Utils.EPSILON),
+ (inputArray[3]-arrMin)/(arrMax-arrMin+Utils.EPSILON),
+ (inputArray[4]-arrMin)/(arrMax-arrMin+Utils.EPSILON),
+ };
+
+ // Normalize the array
+ float[] normalizedArray = Utils.normalizeArray(inputArray);
+
+ // Check that the result matches the expected result
+ assertArrayEquals(expectedNormalizedArray, normalizedArray, Utils.EPSILON, "The normalized array with negative values does not match the expected output.");
+ }
+ }
+
+
+ @Nested
+ class GetImageIDByTitleTest {
+
+ @Test
+ void testGetImageIDByTitle() {
+ String[] titles = {"Image1", "Image2", "Image3"};
+ int[] ids = {101, 102, 103};
+
+ // Test valid title
+ assertEquals(101, Utils.getImageIDByTitle(titles, ids, "Image1"));
+ assertEquals(102, Utils.getImageIDByTitle(titles, ids, "Image2"));
+ assertEquals(103, Utils.getImageIDByTitle(titles, ids, "Image3"));
+ }
+
+ @Test
+ void testGetImageIDByTitleNotFound() {
+ String[] titles = {"Image1", "Image2", "Image3"};
+ int[] ids = {101, 102, 103};
+
+ // Test title not found
+ Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+ Utils.getImageIDByTitle(titles, ids, "NonExistentImage");
+ });
+
+ String expectedMessage = "Title not found: NonExistentImage";
+ String actualMessage = exception.getMessage();
+ assertTrue(actualMessage.contains(expectedMessage));
+ }
+ }
+
+
+ @Nested
+ class DisplayResults2DTest {
+
+ @Test
+ void testDisplayResults2D() {
+ // Prepare a mock InputImage2D
+ int width = 100;
+ int height = 100;
+ int size = width*height;
+ float[] repetitionMap = new float[size];
+
+ // Fill repetition map with sample values
+ for (int i = 0; i < repetitionMap.length; i++) {
+ repetitionMap[i] = (float) i; // Sample values for the test
+ }
+ Utils.InputImage2D inputImage = new Utils.InputImage2D(repetitionMap, width, height, size);
+
+ // Call the method to display results
+ Utils.displayResults2D(inputImage, repetitionMap);
+
+ // Check if the image is displayed
+ ImagePlus displayedImage = WindowManager.getCurrentImage();
+ assertNotNull(displayedImage, "Image should be displayed.");
+
+ // Verify the image properties
+ assertEquals(width, displayedImage.getWidth(), "Width should match the input image width.");
+ assertEquals(height, displayedImage.getHeight(), "Height should match the input image height.");
+
+ // Check that the FloatProcessor is set up correctly
+ FloatProcessor fp = (FloatProcessor) displayedImage.getProcessor();
+ assertEquals(repetitionMap.length, fp.getPixelCount(), "Pixel count should match the repetition map size.");
+ }
+ }
+
+
+ @Nested
+ class DisplayResults3DTest {
+
+ @Test
+ public void testDisplayResults3D() {
+ // Prepare test data
+ int width = 5;
+ int height = 5;
+ int depth = 3;
+ float[] repetitionMap = new float[width * height * depth];
+ for (int z = 0; z < depth; z++) {
+ for (int y = 0; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ repetitionMap[width * height * z + y * width + x] = (float) (Math.random() * 100);
+ }
+ }
+ }
+
+ // Create calibration (as needed by InputImage3D)
+ Calibration calibration = new Calibration();
+ // Set any necessary calibration properties here if needed
+
+ // Create InputImage3D with all required parameters
+ Utils.InputImage3D inputImage = new Utils.InputImage3D(repetitionMap, width, height, depth, repetitionMap.length, calibration, 0.0f, 0.0f, 0.0f);
+
+ // Call the method under test
+ Utils.displayResults3D(inputImage, repetitionMap);
+
+ // Check if the ImagePlus was created and is not null
+ ImagePlus imp = WindowManager.getCurrentImage();
+ assertNotNull(imp, "The ImagePlus should be created and not null.");
+
+ // Check that the image stack has the correct dimensions
+ assertEquals(depth, imp.getStackSize(), "The image stack should have the correct depth.");
+ assertEquals(width, imp.getWidth(), "The image width should match the input width.");
+ assertEquals(height, imp.getHeight(), "The image height should match the input height.");
+
+ // Check if the LUT was applied correctly (this is more complex to test, you might need to validate visually or check properties)
+ // Additional assertions regarding the LUT can be added based on your requirements
+
+ // Clean up - close the image if you want to avoid clutter in your test suite
+ imp.close();
+ }
+ }
+}