From 5d3d50356848cfc1c147774878fdf9662eeec966 Mon Sep 17 00:00:00 2001 From: Gabriel Selzer Date: Mon, 5 Jun 2023 14:41:55 -0500 Subject: [PATCH] Allow conversion across boolean types --- .../net/imagej/ops/copy/CopyBooleanType.java | 58 +++++++++++++++++++ .../net/imagej/ops/copy/CopyNamespace.java | 12 ++++ .../java/net/imagej/ops/copy/CopyRAITest.java | 23 ++++++++ 3 files changed, 93 insertions(+) create mode 100644 src/main/java/net/imagej/ops/copy/CopyBooleanType.java diff --git a/src/main/java/net/imagej/ops/copy/CopyBooleanType.java b/src/main/java/net/imagej/ops/copy/CopyBooleanType.java new file mode 100644 index 000000000..f7c46ecfe --- /dev/null +++ b/src/main/java/net/imagej/ops/copy/CopyBooleanType.java @@ -0,0 +1,58 @@ +/* + * #%L + * ImageJ2 software for multidimensional image processing and analysis. + * %% + * Copyright (C) 2014 - 2022 ImageJ2 developers. + * %% + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * #L% + */ + +package net.imagej.ops.copy; + +import net.imagej.ops.Ops; +import net.imagej.ops.special.computer.AbstractUnaryComputerOp; +import net.imagej.ops.special.hybrid.AbstractUnaryHybridCF; +import net.imglib2.type.BooleanType; +import net.imglib2.type.Type; + +import org.scijava.Priority; +import org.scijava.plugin.Plugin; + +/** + * Copy {@link BooleanType} to another {@link BooleanType} + * + * @author Gabriel Selzer + * @param + * @param + */ +@Plugin(type = Ops.Copy.Type.class) +public class CopyBooleanType, B2 extends BooleanType> + extends AbstractUnaryComputerOp implements Ops.Copy.Type +{ + + @Override + public void compute(final B1 input, final B2 output) { + output.set(input.get()); + } + +} diff --git a/src/main/java/net/imagej/ops/copy/CopyNamespace.java b/src/main/java/net/imagej/ops/copy/CopyNamespace.java index adcc9aaac..7050cbedc 100644 --- a/src/main/java/net/imagej/ops/copy/CopyNamespace.java +++ b/src/main/java/net/imagej/ops/copy/CopyNamespace.java @@ -38,6 +38,7 @@ import net.imglib2.img.array.ArrayImg; import net.imglib2.roi.labeling.ImgLabeling; import net.imglib2.roi.labeling.LabelingMapping; +import net.imglib2.type.BooleanType; import net.imglib2.type.NativeType; import net.imglib2.type.Type; import net.imglib2.type.numeric.IntegerType; @@ -182,4 +183,15 @@ public > T type(final T out, final T in) { in); return result; } + + @OpMethod(op = net.imagej.ops.copy.CopyBooleanType.class) + public , B2 extends BooleanType> B2 type( + final B2 out, final B1 in) + { + @SuppressWarnings("unchecked") + final B2 result = (B2) ops().run(net.imagej.ops.copy.CopyType.class, out, + in); + return result; + } + } diff --git a/src/test/java/net/imagej/ops/copy/CopyRAITest.java b/src/test/java/net/imagej/ops/copy/CopyRAITest.java index 3591aa7d4..aa3731592 100644 --- a/src/test/java/net/imagej/ops/copy/CopyRAITest.java +++ b/src/test/java/net/imagej/ops/copy/CopyRAITest.java @@ -31,6 +31,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import net.imagej.ops.AbstractOpTest; import net.imagej.ops.special.hybrid.Hybrids; @@ -43,6 +44,8 @@ import net.imglib2.img.Img; import net.imglib2.img.array.ArrayImgFactory; import net.imglib2.img.planar.PlanarImgFactory; +import net.imglib2.type.logic.BitType; +import net.imglib2.type.logic.NativeBoolType; import net.imglib2.type.numeric.integer.UnsignedByteType; import net.imglib2.view.IntervalView; import net.imglib2.view.Views; @@ -55,6 +58,7 @@ * Test {@link CopyRAI}. * * @author Tim-Oliver Buchholz (University of Konstanz) + * @author Gabriel Selzer */ public class CopyRAITest extends AbstractOpTest { @@ -170,4 +174,23 @@ public void copyRAIDifferentSizeTest() { assertEquals(ops.stats().mean(outFromPlanar).getRealDouble(), 100.0, delta); } + + @Test + public void copyBooleanTypesTest() { + + final Img in = ops.create().img(new FinalDimensions(size2), + new NativeBoolType()); + Cursor cursor = in.cursor(); + while (cursor.hasNext()) { + cursor.next().set(true); + } + + final Img out = ops.create().img(new FinalDimensions(size2), + new BitType()); + + ops.run("copy.rai", out, in); + + assertTrue(out.firstElement().get()); + + } }