private static void writeBlocksLabelMultisetType(
		final RandomAccessibleInterval<UnsignedLongType> canvas,
		final long[] blocks,
		final DatasetSpec datasetSpec,
		final BlockSpec blockSpec,
		final TLongObjectHashMap<BlockDiff> blockDiff) throws IOException {
	final RandomAccessibleInterval<LabelMultisetType> highestResolutionData = N5LabelMultisets.openLabelMultiset(datasetSpec.container, datasetSpec.dataset);
	for (final long blockId : blocks) {
		blockSpec.fromLinearIndex(blockId);
		final IntervalView<Pair<LabelMultisetType, UnsignedLongType>> backgroundWithCanvas = Views.interval(Views.pair(highestResolutionData, canvas), blockSpec.asInterval());
		final int numElements = (int) Intervals.numElements(backgroundWithCanvas);
		final byte[] byteData = LabelUtils.serializeLabelMultisetTypes(new BackgroundCanvasIterable(Views.flatIterable(backgroundWithCanvas)), numElements);
		final ByteArrayDataBlock dataBlock = new ByteArrayDataBlock(Intervals.dimensionsAsIntArray(backgroundWithCanvas), blockSpec.pos, byteData);
		datasetSpec.container.writeBlock(datasetSpec.dataset, datasetSpec.attributes, dataBlock);
		blockDiff.put(blockId, createBlockDiffFromCanvas(backgroundWithCanvas));
	}
}
 

@Override
public void run() {
	// parse the spacing, and scales strings.
	spacing = checkDimensions(spacingString, input.numDimensions(), "Spacings");
	scales = Arrays.stream(scaleString.split(regex)).mapToInt(Integer::parseInt)
		.toArray();
	Dimensions resultDims = Views.addDimension(input, 0, scales.length - 1);
	// create output image, potentially-filtered input
	result = opService.create().img(resultDims, new FloatType());

	for (int s = 0; s < scales.length; s++) {
		// Determine whether or not the user would like to apply the gaussian
		// beforehand and do it.
		RandomAccessibleInterval<T> vesselnessInput = doGauss ? opService.filter()
			.gauss(input, scales[s]) : input;
		IntervalView<FloatType> scaleResult = Views.hyperSlice(result, result
			.numDimensions() - 1, s);
		opService.filter().frangiVesselness(scaleResult, vesselnessInput, spacing,
			scales[s]);
	}
}
 

@Override
public RandomAccessibleInterval<T> calculate(final RandomAccessibleInterval<T> input, final Interval interval) {
	boolean oneSizedDims = false;

	if (dropSingleDimensions) {
		for (int d = 0; d < interval.numDimensions(); d++) {
			if (interval.dimension(d) == 1) {
				oneSizedDims = true;
				break;
			}
		}
	}

	if (Intervals.equals(input, interval) && !oneSizedDims)
		return input;
	if (!Intervals.contains(input, interval))
		throw new RuntimeException("Intervals don't match!");
	IntervalView<T> res = Views.offsetInterval(input, interval);
	return oneSizedDims ? Views.dropSingletonDimensions(res) : res;
}
 

/**
 * Add 0s before axis minimum.
 * 
 * @param input Input RAI
 * @return An extended and cropped version of input
 */
private <T extends RealType<T>> RandomAccessibleInterval<T> addLeadingZeros(
	RandomAccessibleInterval<T> input)
{
	final long[] min = Intervals.minAsLongArray(input);
	final long[] max = Intervals.maxAsLongArray(input);

	for (int i = 0; i < max.length; i++) {
		min[i]--;
	}

	final T realZero = Util.getTypeFromInterval(input).copy();
	realZero.setZero();

	final ExtendedRandomAccessibleInterval<T, RandomAccessibleInterval<T>> extendedImg = Views.extendValue(input,
		realZero);
	final IntervalView<T> offsetInterval = Views.interval(extendedImg,
		min, max);
	
	return Views.zeroMin(offsetInterval);
}
 

@Override
public void compute(final RandomAccessibleInterval<T> input,
	final RandomAccessibleInterval<T> output)
{
	// input may potentially be translated
	final long[] translation = new long[input.numDimensions()];
	input.min(translation);

	final IntervalView<T> tmpInterval = Views.interval(Views.translate(
		(RandomAccessible<T>) tmpCreator.calculate(input), translation), output);

	gauss1.compute(input, tmpInterval);
	gauss2.compute(input, output);

	// TODO: Match the Subtract Op in initialize() once we have BinaryOp
	ops().run(Ops.Math.Subtract.class, output, output, tmpInterval);
}
 

@Test
public void testIntervalTranslate() {
	Img<DoubleType> img = ArrayImgs.doubles(10,10);

	IntervalView<DoubleType> expected = Views.translate(img, 2, 5);
	IntervalView<DoubleType> actual = ops.transform().translateView(img, 2, 5);

	for (int i = 0; i < ((MixedTransformView<DoubleType>) expected.getSource()).getTransformToSource().getMatrix().length; i++) {
		for (int j = 0; j < ((MixedTransformView<DoubleType>) expected.getSource()).getTransformToSource().getMatrix()[i].length; j++) {
			assertEquals(((MixedTransformView<DoubleType>) expected.getSource()).getTransformToSource().getMatrix()[i][j], ((MixedTransformView<DoubleType>) actual.getSource()).getTransformToSource().getMatrix()[i][j],
					1e-10);
		}
	}
	
	assertTrue(Intervals.equals(expected, actual));
}
 

@Test
public void IntervalHyperSliceTest() {

	final Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10, 10 },
			new DoubleType());

	final IntervalView<DoubleType> il2 = Views.hyperSlice((RandomAccessibleInterval<DoubleType>) img, 1, 8);
	final IntervalView<DoubleType> opr = ops.transform().hyperSliceView(img, 1, 8);

	for (int i = 0; i < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
			.getMatrix().length; i++) {
		for (int j = 0; j < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
				.getMatrix()[i].length; j++) {
			assertEquals(
					((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource().getMatrix()[i][j],
					((MixedTransformView<DoubleType>) opr.getSource()).getTransformToSource().getMatrix()[i][j],
					1e-10);
		}
	}

	assertEquals(img.numDimensions() - 1, opr.numDimensions());
}
 

@Test
public void permuteCoordinatesInverseOfDimensionTest() {
	Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[]{2, 2}, new DoubleType());
	Cursor<DoubleType> c = img.cursor();
	MersenneTwisterFast r = new MersenneTwisterFast(SEED);
	while (c.hasNext()) {
		c.next().set(r.nextDouble());
	}
	
	IntervalView<DoubleType> out = Views.permuteCoordinatesInverse(img, new int[]{0, 1}, 1);
	
	Cursor<DoubleType> il2 = out.cursor();
	RandomAccess<DoubleType> opr = ops.transform().permuteCoordinatesInverseView(img, new int[]{0, 1}, 1).randomAccess();
	
	while (il2.hasNext()) {
		il2.next();
		opr.setPosition(il2);
		assertEquals(il2.get().get(), opr.get().get(), 1e-10);
	}
}
 

@Test
public void testIntervalPermuteCoordinates() {
	Img<DoubleType> img = ArrayImgs.doubles(2, 2);
	Cursor<DoubleType> c = img.cursor();
	MersenneTwisterFast r = new MersenneTwisterFast(SEED);
	while (c.hasNext()) {
		c.next().set(r.nextDouble());
	}
	IntervalView<DoubleType> expected = Views.permuteCoordinates(img, new int[]{0, 1});
	Cursor<DoubleType> e = expected.cursor();
	RandomAccessibleInterval<DoubleType> actual = ops.transform().permuteCoordinatesView(img, new int[]{0, 1});
	RandomAccess<DoubleType> actualRA = actual.randomAccess();
	
	while (e.hasNext()) {
		e.next();
		actualRA.setPosition(e);
		assertEquals(e.get().get(), actualRA.get().get(), 1e-10);
	}
	
	assertTrue(Intervals.equals(expected, actual));
	
}
 

@Test
public void testIntervalPermuteDimensionCoordinates() {
	Img<DoubleType> img = ArrayImgs.doubles(2, 2);
	Cursor<DoubleType> c = img.cursor();
	MersenneTwisterFast r = new MersenneTwisterFast(SEED);
	while (c.hasNext()) {
		c.next().set(r.nextDouble());
	}
	IntervalView<DoubleType> expected = Views.permuteCoordinates(img, new int[]{0, 1}, 1);
	Cursor<DoubleType> e = expected.cursor();
	RandomAccessibleInterval<DoubleType> actual = ops.transform().permuteCoordinatesView(img, new int[]{0, 1}, 1);
	RandomAccess<DoubleType> actualRA = actual.randomAccess();
	
	while (e.hasNext()) {
		e.next();
		actualRA.setPosition(e);
		assertEquals(e.get().get(), actualRA.get().get(), 1e-10);
	}
	
	assertTrue(Intervals.equals(expected, actual));
	
}
 

@Test
public void testIntervalPermuteInverseCoordinates() {
	Img<DoubleType> img = ArrayImgs.doubles(2, 2);
	Cursor<DoubleType> c = img.cursor();
	MersenneTwisterFast r = new MersenneTwisterFast(SEED);
	while (c.hasNext()) {
		c.next().set(r.nextDouble());
	}
	IntervalView<DoubleType> expected = Views.permuteCoordinatesInverse(img, new int[]{0, 1});
	Cursor<DoubleType> e = expected.cursor();
	RandomAccessibleInterval<DoubleType> actual = ops.transform().permuteCoordinatesInverseView(img, new int[]{0, 1});
	RandomAccess<DoubleType> actualRA = actual.randomAccess();
	
	while (e.hasNext()) {
		e.next();
		actualRA.setPosition(e);
		assertEquals(e.get().get(), actualRA.get().get(), 1e-10);
	}
	
	assertTrue(Intervals.equals(expected, actual));
	
}
 

@Test
public void testIntervalPermuteInverseDimensionCoordinates() {
	Img<DoubleType> img = ArrayImgs.doubles(2, 2);
	Cursor<DoubleType> c = img.cursor();
	MersenneTwisterFast r = new MersenneTwisterFast(SEED);
	while (c.hasNext()) {
		c.next().set(r.nextDouble());
	}
	IntervalView<DoubleType> expected = Views.permuteCoordinatesInverse(img, new int[]{0, 1}, 1);
	Cursor<DoubleType> e = expected.cursor();
	RandomAccessibleInterval<DoubleType> actual = ops.transform().permuteCoordinatesInverseView(img, new int[]{0, 1}, 1);
	RandomAccess<DoubleType> actualRA = actual.randomAccess();
	
	while (e.hasNext()) {
		e.next();
		actualRA.setPosition(e);
		assertEquals(e.get().get(), actualRA.get().get(), 1e-10);
	}
	
	assertTrue(Intervals.equals(expected, actual));
	
}
 

@Test
public void testIntervalRotate() {
	final Img<DoubleType> img = ArrayImgs.doubles(20,10);

	final IntervalView<DoubleType> il2 = Views.rotate((RandomAccessibleInterval<DoubleType>) img, 1, 0);
	final IntervalView<DoubleType> opr = (IntervalView<DoubleType>) ops.transform().rotateView((RandomAccessibleInterval<DoubleType>) img, 1, 0);

	for (int i = 0; i < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
			.getMatrix().length; i++) {
		for (int j = 0; j < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
				.getMatrix()[i].length; j++) {
			assertEquals(
					((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource().getMatrix()[i][j],
					((MixedTransformView<DoubleType>) opr.getSource()).getTransformToSource().getMatrix()[i][j],
					1e-10);
		}
	}
}
 

@Test
public void testIntervalRotateInterval() {
	final Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 20, 10 }, new DoubleType());

	final IntervalView<DoubleType> il2 = Views.rotate((RandomAccessibleInterval<DoubleType>) img, 1, 0);
	final IntervalView<DoubleType> opr = ops.transform().rotateView((RandomAccessibleInterval<DoubleType>) img, 1, 0);

	assertEquals(img.min(1), il2.min(0));
	assertEquals(img.max(1), il2.max(0));
	assertEquals(img.min(0), -il2.max(1));
	assertEquals(img.max(0), -il2.min(1));

	for (int i = 0; i < il2.numDimensions(); i++) {
		assertEquals(il2.max(i), opr.max(i));
		assertEquals(il2.min(i), opr.min(i));
	}

}
 

@Test
public void intervalInvertAxisTest() {

	final Img<DoubleType> img = new ArrayImgFactory<DoubleType>().create(new int[] { 10, 10 }, new DoubleType());

	final IntervalView<DoubleType> il2 = Views.invertAxis(img, 1);
	final IntervalView<DoubleType> opr = ops.transform().invertAxisView(img, 1);

	for (int i = 0; i < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
			.getMatrix().length; i++) {
		for (int j = 0; j < ((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource()
				.getMatrix()[i].length; j++) {
			assertEquals(
					((MixedTransformView<DoubleType>) il2.getSource()).getTransformToSource().getMatrix()[i][j],
					((MixedTransformView<DoubleType>) opr.getSource()).getTransformToSource().getMatrix()[i][j],
					1e-10);
		}
	}
}
 

/** Test the op with a 2x2 square. The square is in the middle of a 4x4 img */
@Test
public void testSquare() {
	// SETUP
	final Img<BitType> img = ArrayImgs.bits(4, 4);
	final IntervalView<BitType> square = Views.offsetInterval(img, new long[] {
		1, 1 }, new long[] { 2, 2 });
	square.cursor().forEachRemaining(BitType::setOne);

	// EXECUTE
	final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img,
		Boolean.TRUE);

	// VERIFY
	assertEquals("Wrong number of foreground elements in interval", 4,
		countForeground(result));
	final IntervalView<BitType> resultSquare = Views.offsetInterval(result,
		new long[] { 1, 1 }, new long[] { 2, 2 });
	assertTrue("Wrong number of foreground elements in object", allForeground(
		resultSquare));
}
 

/**
 * Test the op with a 3x3 square with a hole in the middle. The square is in
 * the middle of a 5x5 img
 */
@Test
public void testOutlineSquare() {
	// SETUP
	final Img<BitType> img = ArrayImgs.bits(5, 5);
	final IntervalView<BitType> square = Views.offsetInterval(img, new long[] {
		1, 1 }, new long[] { 3, 3 });
	square.cursor().forEachRemaining(BitType::setOne);
	final RandomAccess<BitType> access = square.randomAccess();
	access.setPosition(new long[] { 1, 1 });
	access.get().setZero();

	// EXECUTION
	final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img,
		Boolean.TRUE);

	// VERIFY
	assertEquals("Wrong number of foreground elements in interval", 8,
		countForeground(result));
	final IntervalView<BitType> resultSquare = Views.offsetInterval(result,
		new long[] { 1, 1 }, new long[] { 3, 3 });
	assertEquals("Wrong number of foreground elements in object", 8,
		countForeground(resultSquare));
	assertPositionBackground(result, new long[] { 2, 2 });
}
 

/**
 * Test the op with a 3x3 square starting from (0,1) in a 5x5 img
 *
 * @see Outline#compute(RandomAccessibleInterval, Boolean,
 *      RandomAccessibleInterval)
 * @see #testEdgeSquare()
 */
@Test
public void testEdgeSquare() {
	// SETUP
	final Img<BitType> img = ArrayImgs.bits(5, 5);
	final IntervalView<BitType> square = Views.offsetInterval(img, new long[] {
		0, 1 }, new long[] { 3, 3 });
	square.cursor().forEachRemaining(BitType::setOne);

	// EXECUTION
	final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img,
		Boolean.TRUE);

	// VERIFY
	assertEquals("Wrong number of foreground elements in interval", 7,
		countForeground(result));
	final IntervalView<BitType> resultSquare = Views.offsetInterval(result,
		new long[] { 0, 1 }, new long[] { 3, 3 });
	assertEquals("Wrong number of foreground elements in object", 7,
		countForeground(resultSquare));
	assertPositionBackground(result, new long[] { 0, 2 });
	assertPositionBackground(result, new long[] { 1, 2 });
}
 

/**
 * Test the op with a 3x3 square starting from (0,1) in a 5x5 img without
 * excluding edges
 *
 * @see Outline#compute(RandomAccessibleInterval, Boolean,
 *      RandomAccessibleInterval)
 * @see #testEdgeSquare()
 */
@Test
public void testEdgeSquareExcludeEdgesFalse() {
	// SETUP
	final Img<BitType> img = ArrayImgs.bits(5, 5);
	final IntervalView<BitType> square = Views.offsetInterval(img, new long[] {
		0, 1 }, new long[] { 3, 3 });
	square.cursor().forEachRemaining(BitType::setOne);

	final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img,
		Boolean.FALSE);

	assertEquals("Wrong number of foreground elements in interval", 8,
		countForeground(result));
	final IntervalView<BitType> resultSquare = Views.offsetInterval(result,
		new long[] { 0, 1 }, new long[] { 3, 3 });
	assertEquals("Wrong number of foreground elements in object", 8,
		countForeground(resultSquare));
	assertPositionBackground(result, new long[] { 1, 2 });
}
 

/**
 * Test the op with a 3x3x3x3 hypercube. The cube is in the middle of a
 * 5x5x5x5 img
 */
@Test
public void testHyperCube() {
	// SETUP
	final Img<BitType> img = ArrayImgs.bits(5, 5, 5, 5);
	final IntervalView<BitType> hyperCube = Views.offsetInterval(img,
		new long[] { 1, 1, 1, 1 }, new long[] { 3, 3, 3, 3 });
	hyperCube.cursor().forEachRemaining(BitType::setOne);

	// EXECUTE
	final Img<BitType> result = (Img<BitType>) ops.morphology().outline(img,
		Boolean.TRUE);

	// VERIFY
	assertEquals("Wrong number of foreground elements in interval", 80,
		countForeground(result));
	final IntervalView<BitType> resultHyperCube = Views.offsetInterval(result,
		new long[] { 1, 1, 1, 1 }, new long[] { 3, 3, 3, 3 });
	assertEquals("Wrong number of foreground elements in object", 80,
		countForeground(resultHyperCube));
	assertPositionBackground(result, new long[] { 2, 2, 2, 2 });
}
 

@Test
public void testNonZeroMinimumInterval() {

	Img<ByteType> img3D = ArrayImgs.bytes(50, 50, 3);
	IntervalView<ByteType> interval2D = Views.interval(img3D,
			new FinalInterval(new long[] { 25, 25, 2 }, new long[] { 35, 35, 2 }));
	final int[] xyAxis = new int[] { 0, 1 };

	// iterate through every slice, should return a single
	// RandomAccessibleInterval<?> from 25, 25, 2 to 35, 35, 2

	final SlicesII<ByteType> hyperSlices = new SlicesII<>(interval2D, xyAxis, true);
	final Cursor<RandomAccessibleInterval<ByteType>> c = hyperSlices.cursor();
	int i = 0;
	while (c.hasNext()) {
		c.next();
		i++;
	}

	assertEquals(1, i);
}
 

@Test
public void testCreateFromRaiDifferentType() {
	final IntervalView<ByteType> input =
		Views.interval(PlanarImgs.bytes(10, 10, 10), new FinalInterval(
			new long[] { 10, 10, 1 }));

	final Img<?> res = (Img<?>) ops.run(CreateImgFromDimsAndType.class, input,
		new ShortType());

	assertEquals("Image Type: ", ShortType.class, res.firstElement().getClass());

	assertArrayEquals("Image Dimensions: ", Intervals
		.dimensionsAsLongArray(input), Intervals.dimensionsAsLongArray(res));

	assertEquals("Image Factory: ", ArrayImgFactory.class, res.factory()
		.getClass());
}
 

@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void copyRAIDifferentSizeTest() {

	// create a copy op
	final UnaryHybridCF<IntervalView<UnsignedByteType>, RandomAccessibleInterval<UnsignedByteType>> copy =
		(UnaryHybridCF) Hybrids.unaryCF(ops, CopyRAI.class,
			RandomAccessibleInterval.class, IntervalView.class);

	assertNotNull(copy);

	final Img<UnsignedByteType> out = ops.create().img(new FinalDimensions(
		size2), new UnsignedByteType());

	// copy view to output and assert that is equal to the mean of the view
	copy.compute(view, out);
	assertEquals(ops.stats().mean(out).getRealDouble(), 100.0, delta);

	// also try with a planar image
	final Img<UnsignedByteType> outFromPlanar = ops.create().img(
		new FinalDimensions(size2), new UnsignedByteType());

	copy.compute(viewPlanar, outFromPlanar);
	assertEquals(ops.stats().mean(outFromPlanar).getRealDouble(), 100.0, delta);

}
 

@Test
public void testHyperCube() {
	// SETUP
	final double[] expectedSizes = DoubleStream.of(4, 2, 1).map(i -> -Math.log(
		i)).toArray();
	final double[] expectedCounts = DoubleStream.of(1, 16, 16).map(Math::log)
		.toArray();
	final Img<BitType> img = ArrayImgs.bits(4, 4, 4, 4);
	final IntervalView<BitType> hyperView = Views.offsetInterval(img,
		new long[] { 1, 1, 1, 1 }, new long[] { 2, 2, 2, 2 });
	hyperView.forEach(BitType::setOne);

	// EXECUTE
	final List<ValuePair<DoubleType, DoubleType>> points = ops.topology()
		.boxCount(img, 4L, 1L, 2.0);

	// VERIFY
	for (int i = 0; i < expectedSizes.length; i++) {
		assertEquals(expectedSizes[i], points.get(i).a.get(), 1e-12);
		assertEquals(expectedCounts[i], points.get(i).b.get(), 1e-12);
	}
}
 

/**
 * Test box counting with a hyper cube and one grid translation (should find a
 * better fit than in @see {@link #testHyperCube()})
 */
@Test
public void testHyperCubeTranslations() {
	final double[] expectedSizes = DoubleStream.of(4, 2, 1).map(i -> -Math.log(
		i)).toArray();
	final double[] expectedCounts = DoubleStream.of(1, 1, 16).map(Math::log)
		.toArray();
	final Img<BitType> img = ArrayImgs.bits(4, 4, 4, 4);
	final IntervalView<BitType> hyperView = Views.offsetInterval(img,
		new long[] { 1, 1, 1, 1 }, new long[] { 2, 2, 2, 2 });
	hyperView.forEach(BitType::setOne);

	// EXECUTE
	final List<ValuePair<DoubleType, DoubleType>> points = ops.topology()
		.boxCount(img, 4L, 1L, 2.0, 1L);

	// VERIFY
	for (int i = 0; i < expectedSizes.length; i++) {
		assertEquals(expectedSizes[i], points.get(i).a.get(), 1e-12);
		assertEquals(expectedCounts[i], points.get(i).b.get(), 1e-12);
	}
}
 

@Test
public void testUnevenBoxes() {
	// SETUP
	final int size = 10;
	final int max = size - 1;
	final long boxSize = size - 1;
	final Img<BitType> img = ArrayImgs.bits(size, size, size);
	final IntervalView<BitType> lastXYSlice = Views.interval(img,
			new long[] { 0, 0, max}, new long[] { max, max, max});
	lastXYSlice.forEach(BitType::setOne);

	// EXECUTE
	final List<ValuePair<DoubleType, DoubleType>> points = ops.topology()
			.boxCount(img, boxSize, boxSize, 3.0);

	// VERIFY
	final ValuePair<DoubleType, DoubleType> point = points.get(0);
	assertEquals(point.b.get(), Math.log(4), 1e-12);
}
 

@Override
public void load(final SingleCellArrayImg<UnsignedByteType, ?> cell) throws Exception
{
	LOG.debug(
			"Populating cell {} {} {}",
			Intervals.minAsLongArray(cell),
			Intervals.maxAsLongArray(cell),
			cell.size()
	         );
	final IntervalView<U> label2Interval        = Views.interval(data2, cell);
	final Cursor<T> label1Cursor                = Views.flatIterable(Views.interval(data1, cell)).cursor();
	final Cursor<U> label2Cursor                = Views.flatIterable(label2Interval).cursor();
	final Cursor<UnsignedByteType> targetCursor = cell.localizingCursor();

	//		cell.forEach( UnsignedByteType::setZero );
	while (targetCursor.hasNext())
	{
		final UnsignedByteType targetType = targetCursor.next();
		final T                label1Type = label1Cursor.next();
		final U                label2Type = label2Cursor.next();
		if (targetType.get() == 0)
		{
			if (check1.test(label1Type) && check2.test(label2Type))
			{
				FloodFill.fill(
						Views.extend(label2Interval, new OutOfBoundsConstantValueFactory<>(extension)),
						Views.extendValue(cell, new UnsignedByteType(1)),
						targetCursor,
						new UnsignedByteType(1),
						new DiamondShape(1),
						(s, t) -> check2.test(s) && t.get() == 0
				              );
			}
		}
	}
}
 

public static <D> void visitEveryDisplayPixel(
		final DataSource<D, ?> dataSource,
		final ViewerPanelFX viewer,
		final Consumer<D> doAtPixel)
{
	final ViewerState viewerState = viewer.getState().copy();

	final AffineTransform3D viewerTransform = new AffineTransform3D();
	viewerState.getViewerTransform(viewerTransform);

	final AffineTransform3D screenScaleTransform = new AffineTransform3D();
	viewer.getRenderUnit().getScreenScaleTransform(0, screenScaleTransform);
	final int level = viewerState.getBestMipMapLevel(screenScaleTransform, dataSource);

	final AffineTransform3D sourceTransform = new AffineTransform3D();
	dataSource.getSourceTransform(0, level, sourceTransform);

	final RealRandomAccessible<D> interpolatedSource = dataSource.getInterpolatedDataSource(0, level, Interpolation.NEARESTNEIGHBOR);

	final RealTransformRealRandomAccessible<D, InverseRealTransform> transformedSource  = RealViews.transformReal(
			interpolatedSource,
			sourceTransform);

	final int w = (int) viewer.getWidth();
	final int h = (int) viewer.getHeight();
	final IntervalView<D> dataOnScreen =
			Views.interval(
					Views.hyperSlice(
							RealViews.affine(transformedSource, viewerTransform), 2, 0),
					new FinalInterval(w, h));

	final Cursor<D> cursor = Views.flatIterable(dataOnScreen).cursor();
	while (cursor.hasNext())
		doAtPixel.accept(cursor.next());
}
 

/**
 * Invert the d-axis while preserving interval bounds.
 *
 * @param input the source
 * @param d the axis to invert
 */
@OpMethod(
	op = net.imagej.ops.transform.invertAxisView.IntervalInvertAxisView.class)
public <T> IntervalView<T> invertAxisView(
	final RandomAccessibleInterval<T> input, final int d)
{
	return (IntervalView<T>) ops().run(Ops.Transform.InvertAxisView.class,
		input, d);
}
 

/**
 * Translate the source such that the upper left corner is at the origin
 *
 * @param input the source.
 * @return view of the source translated to the origin
 */
@OpMethod(op = net.imagej.ops.transform.zeroMinView.DefaultZeroMinView.class)
public <T> IntervalView<T> zeroMinView(
	final RandomAccessibleInterval<T> input)
{
	return (IntervalView<T>) ops().run(Ops.Transform.ZeroMinView.class, input);
}