Uniform Noise Adder

Author: gselzer

scijava-ops-image/src/main/java/org/scijava/ops/image/filter/addNoise/NoiseAdders.java

@@ -31,11 +31,15 @@
 
 import java.util.Random;
 
+import net.imglib2.Localizable;
 import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.loops.LoopBuilder;
 import net.imglib2.type.numeric.RealType;
 
+import net.imglib2.util.Intervals;
+import org.scijava.common3.MersenneTwisterFast;
 import org.scijava.function.Computers;
+import org.scijava.ops.spi.Nullable;
 
 /**
  * Contains Ops designed to add noise to populated images.
@@ -165,6 +169,60 @@ public static <I extends RealType<I>, O extends RealType<O>> void addNoise(final
 	public final Computers.Arity1<RandomAccessibleInterval<I>, RandomAccessibleInterval<O>> addPoissonNoiseIntervalSeedless = (input,
 			output) -> addPoissonNoise(input, new Random(0xabcdef1234567890L), output);
 
+	// -- UNIFORM NOISE -- //
+
+	/**
+	 * Sets the real component of an output real number to the addition of the real
+	 * component of an input real number with an amount of uniform noise.
+	 *
+	 * Note that this Op has changed relative to the older implementations; before
+	 * it operated on RealTypes, we now only provide the operation on
+	 * {@link RandomAccessibleInterval}s. This is due to the nature of {@link Random}: The old
+	 * implementation saved a {@link Random} and used it on each {@link RealType}
+	 * passed to the Op. This provided no deterministic output, as the same input
+	 * would yield two different outputs if called in succession. Thus in this
+	 * iteration of the Op we make it a requirement that the input must be an
+	 * {@link RandomAccessibleInterval}. Since the {@link Random} is created upon every call of the
+	 * Op it ensures that given the same seed and input data the output will always
+	 * be the same.
+	 *
+	 * @param input the input {@link RandomAccessibleInterval}
+	 * @param rangeMin the "most negative" value that can be added to each element
+	 * @param rangeMax the "most positive" value that can be added to each element
+	 * @param seed the seed to the random number generator
+	 * @param output the output {@link RandomAccessibleInterval}
+	 * @implNote op names='filter.addUniformNoise', type=Computer
+	 */
+	public static <I extends RealType<I>> void compute( //
+			RandomAccessibleInterval<I> input, //
+			I rangeMin, //
+			I rangeMax, //
+			@Nullable Long seed, //
+			RandomAccessibleInterval<I> output //
+	) {
+		// Set seed to default if necessary
+		if (seed == null) {
+			seed = 0xabcdef1234567890L;
+		}
+		// Construct the Random Number Generator
+		MersenneTwisterFast rng = new MersenneTwisterFast(seed);
+		// Find the range
+		I range = rangeMax.createVariable();
+		range.set(rangeMax);
+		range.sub(rangeMin);
+
+		// Loop over the images
+		LoopBuilder.setImages(input, output).forEachPixel( (i, o) -> {
+			// Random value = next double * range
+			o.set(range);
+			o.mul(rng.nextDouble(true, true));
+			// Add the range minimum
+			o.add(rangeMin);
+			// Add the original value
+			o.add(i);
+		});
+
+	}
 	// -- Static utility methods --
 
 	// Runs the below method on every element of the input iterables.

scijava-ops-image/src/test/java/org/scijava/ops/image/OpRegressionTest.java

@@ -42,7 +42,7 @@ public class OpRegressionTest {
 
 	@Test
 	public void opDiscoveryRegressionIT() {
-		long expected = 1868;
+		long expected = 1870;
 		long actual = ops.infos().size();
 		assertEquals(expected, actual);
 	}

scijava-ops-image/src/test/java/org/scijava/ops/image/filter/addNoise/NoiseAddersTest.java

@@ -0,0 +1,29 @@
+package org.scijava.ops.image.filter.addNoise;
+
+import net.imglib2.img.array.ArrayImgs;
+import net.imglib2.type.numeric.integer.ByteType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.scijava.ops.image.AbstractOpTest;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class NoiseAddersTest extends AbstractOpTest {
+
+    @Test
+    public void testAddUniformNoiseRegression() {
+        var input = ArrayImgs.bytes(2, 2);
+        ops.unary("image.fill").input(new ByteType((byte) 1)).output(input).compute();
+        var output = ArrayImgs.bytes(2, 2);
+        var rangeMin = new ByteType((byte) -1);
+        var rangeMax = new ByteType((byte) 1);
+        ops.ternary("filter.addUniformNoise").input(input, rangeMin, rangeMax).output(output).compute();
+        var cursor = output.cursor();
+        List<Byte> expected = Arrays.asList((byte) 0, (byte) 2, (byte) 1, (byte) 1);
+        for(var e : expected) {
+            Assertions.assertEquals(e, cursor.next().get());
+        }
+        Assertions.assertFalse(cursor.hasNext());
+    }
+}