change hessian to use compositeview

Author: EikeHeinz

src/main/java/net/imagej/ops/filter/FilterNamespace.java

@@ -857,28 +857,16 @@ RandomAccessibleInterval<V> gauss(final RandomAccessibleInterval<T> in,
 	// -- hessian --
 
 	@OpMethod(op = net.imagej.ops.filter.hessian.HessianRAI.class)
-	public <T extends RealType<T>> RandomAccessibleInterval<T> hessian(
+	public <T extends RealType<T>> CompositeIntervalView<T, RealComposite<T>> hessian(
 		final RandomAccessibleInterval<T> in)
 	{
 		@SuppressWarnings("unchecked")
-		final RandomAccessibleInterval<T> result =
-			(RandomAccessibleInterval<T>) ops().run(
+		final CompositeIntervalView<T, RealComposite<T>> result =
+			(CompositeIntervalView<T, RealComposite<T>>) ops().run(
 				net.imagej.ops.filter.hessian.HessianRAI.class, in);
 		return result;
 	}
 
-	@OpMethod(op = net.imagej.ops.filter.hessian.HessianRAI.class)
-	public <T extends RealType<T>> RandomAccessibleInterval<T> hessian(
-		final RandomAccessibleInterval<T> out,
-		final RandomAccessibleInterval<T> in)
-	{
-		@SuppressWarnings("unchecked")
-		final RandomAccessibleInterval<T> result =
-			(RandomAccessibleInterval<T>) ops().run(
-				net.imagej.ops.filter.hessian.HessianRAI.class, out, in);
-		return result;
-	}
-
 	// -- ifft --
 
 	/** Executes the "ifft" operation on the given arguments. */

src/main/java/net/imagej/ops/filter/hessian/HessianRAI.java

@@ -29,20 +29,19 @@
 
 package net.imagej.ops.filter.hessian;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import net.imagej.ops.Ops;
-import net.imagej.ops.Ops.Filter.Hessian;
 import net.imagej.ops.special.chain.RAIs;
 import net.imagej.ops.special.computer.UnaryComputerOp;
-import net.imagej.ops.special.function.Functions;
+import net.imagej.ops.special.function.AbstractUnaryFunctionOp;
 import net.imagej.ops.special.function.UnaryFunctionOp;
-import net.imagej.ops.special.hybrid.AbstractUnaryHybridCF;
-import net.imglib2.Dimensions;
-import net.imglib2.FinalDimensions;
 import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.type.numeric.RealType;
-import net.imglib2.util.Util;
-import net.imglib2.view.IntervalView;
 import net.imglib2.view.Views;
+import net.imglib2.view.composite.CompositeIntervalView;
+import net.imglib2.view.composite.RealComposite;
 
 import org.scijava.plugin.Plugin;
 
@@ -57,20 +56,16 @@
 
 @Plugin(type = Ops.Filter.Hessian.class)
 public class HessianRAI<T extends RealType<T>>
-		extends AbstractUnaryHybridCF<RandomAccessibleInterval<T>, RandomAccessibleInterval<T>> implements Hessian {
+		extends AbstractUnaryFunctionOp<RandomAccessibleInterval<T>, CompositeIntervalView<T, RealComposite<T>>>
+		implements Ops.Filter.Hessian {
 
 	private UnaryComputerOp<RandomAccessibleInterval<T>, RandomAccessibleInterval<T>>[] derivativeComputers;
 
-	@SuppressWarnings("rawtypes")
-	private UnaryFunctionOp<Dimensions, RandomAccessibleInterval> createRAIFromDim;
-
 	private UnaryFunctionOp<RandomAccessibleInterval<T>, RandomAccessibleInterval<T>> createRAIFromRAI;
 
 	@SuppressWarnings("unchecked")
 	@Override
 	public void initialize() {
-		createRAIFromDim = Functions.unary(ops(), Ops.Create.Img.class, RandomAccessibleInterval.class,
-				Dimensions.class, Util.getTypeFromInterval(in()).createVariable());
 		createRAIFromRAI = RAIs.function(ops(), Ops.Create.Img.class, in());
 
 		derivativeComputers = new UnaryComputerOp[in().numDimensions()];
@@ -80,29 +75,19 @@ public void initialize() {
 	}
 
 	@Override
-	public void compute1(RandomAccessibleInterval<T> input, RandomAccessibleInterval<T> output) {
-		int iteration = 0;
-
-		for (int i = 0; i < input.numDimensions(); i++) {
+	public CompositeIntervalView<T, RealComposite<T>> compute1(RandomAccessibleInterval<T> input) {
+		List<RandomAccessibleInterval<T>> derivatives = new ArrayList<>();
+		for (int i = 0; i < derivativeComputers.length; i++) {
 			RandomAccessibleInterval<T> derivative = createRAIFromRAI.compute1(input);
 			derivativeComputers[i].compute1(input, derivative);
-			for (int j = 0; j < input.numDimensions(); j++) {
-				IntervalView<T> out = Views.hyperSlice(Views.hyperSlice(output, 3, 0), 2, iteration);
+			for (int j = 0; j < derivativeComputers.length; j++) {
+				RandomAccessibleInterval<T> out = createRAIFromRAI.compute1(input);
 				derivativeComputers[j].compute1(derivative, out);
-				iteration++;
+				derivatives.add(out);
 			}
 		}
+		RandomAccessibleInterval<T> stackedDerivatives = Views.stack(derivatives);
+		return Views.collapseReal(stackedDerivatives);
 	}
 
-	@SuppressWarnings("unchecked")
-	@Override
-	public RandomAccessibleInterval<T> createOutput(RandomAccessibleInterval<T> input) {
-		long[] dims = new long[input.numDimensions() + 2];
-		for (int i = 0; i < dims.length - 1; i++) {
-			dims[i] = input.dimension(i);
-		}
-		dims[dims.length - 1] = input.numDimensions() * input.numDimensions();
-		Dimensions dim = FinalDimensions.wrap(dims);
-		return createRAIFromDim.compute1(dim);
-	}
 }

src/test/java/net/imagej/ops/filter/hessian/HessianFilterTest.java

@@ -33,13 +33,13 @@
 
 import net.imagej.ops.AbstractOpTest;
 import net.imglib2.Cursor;
-import net.imglib2.RandomAccess;
-import net.imglib2.RandomAccessibleInterval;
 import net.imglib2.img.Img;
 import net.imglib2.type.numeric.real.FloatType;
 import net.imglib2.util.Util;
-import net.imglib2.view.IntervalView;
 import net.imglib2.view.Views;
+import net.imglib2.view.composite.CompositeIntervalView;
+import net.imglib2.view.composite.CompositeView;
+import net.imglib2.view.composite.RealComposite;
 
 import org.junit.Test;
 
@@ -77,49 +77,43 @@ public void test() {
 			}
 		}
 
-		RandomAccessibleInterval<FloatType> out = ops.filter().hessian(img);
-
-		IntervalView<FloatType> xx = Views.hyperSlice(Views.hyperSlice(out, 3, 0), 2, 0);
-		IntervalView<FloatType> xy = Views.hyperSlice(Views.hyperSlice(out, 3, 0), 2, 1);
-		IntervalView<FloatType> yx = Views.hyperSlice(Views.hyperSlice(out, 3, 0), 2, 2);
-		IntervalView<FloatType> yy = Views.hyperSlice(Views.hyperSlice(out, 3, 0), 2, 3);
-
-		Cursor<FloatType> xyCursor = xy.cursor();
-		Cursor<FloatType> yxCursor = yx.cursor();
-		while (xyCursor.hasNext()) {
-			xyCursor.fwd();
-			yxCursor.fwd();
-			assertEquals(xyCursor.get(), yxCursor.get());
+		CompositeIntervalView<FloatType, RealComposite<FloatType>> out = ops.filter().hessian(img);
+		
+		
+		Cursor<RealComposite<FloatType>> outCursor = Views.iterable(out).cursor();
+		
+		while (outCursor.hasNext()) {
+			RealComposite<FloatType> values = outCursor.next();
+			assertEquals(values.get(1), values.get(2));
 		}
+
+		CompositeView<FloatType, RealComposite<FloatType>>.CompositeRandomAccess outRA = out.randomAccess();
+		
 		// two numbers represent a coordinate: 20|0 ; 21|0 ...
 		int[] positions = new int[] { 20, 0, 21, 0, 19, 31, 19, 30 };
 		float[] valuesXX = new float[] { 16.0f, -16.0f, 15.0f, 11.0f };
 		float[] valuesXY = new float[] { 0.0f, 0.0f, 1.0f, 3.0f };
 		float[] valuesYY = new float[] { 0.0f, 0.0f, 15.0f, 15.0f };
 
-		RandomAccess<FloatType> xxRA = xx.randomAccess();
-		RandomAccess<FloatType> xyRA = xy.randomAccess();
-		RandomAccess<FloatType> yyRA = yy.randomAccess();
-
-		FloatType type = Util.getTypeFromInterval(out).createVariable();
+		FloatType type = Util.getTypeFromInterval(img).createVariable();
 		int i = 0;
 		int j = 0;
 		while (i < positions.length - 1) {
 			int[] pos = new int[2];
 			pos[0] = positions[i];
 			pos[1] = positions[i + 1];
 
-			xxRA.setPosition(pos);
+			outRA.setPosition(pos);
 			type.set(valuesXX[j]);
-			assertEquals(type, xxRA.get());
+			assertEquals(type, outRA.get().get(0));
 
-			xyRA.setPosition(pos);
+			outRA.setPosition(pos);
 			type.set(valuesXY[j]);
-			assertEquals(type, xyRA.get());
+			assertEquals(type, outRA.get().get(1));
 
-			yyRA.setPosition(pos);
+			outRA.setPosition(pos);
 			type.set(valuesYY[j]);
-			assertEquals(type, yyRA.get());
+			assertEquals(type, outRA.get().get(3));
 
 			i += 2;
 			j++;