created CreateImgFromArray for UnsignedByteType

Author: Xanthorapedia

src/main/java/net/imagej/ops/create/CreateNamespace.java

@@ -107,6 +107,16 @@ public Img<DoubleType> img(final int[] dims) {
 	public Img<DoubleType> img(final long[] dims) {
 		return img(new FinalDimensions(dims), new DoubleType());
 	}
+	
+	@OpMethod(op = net.imagej.ops.create.img.CreateImgFromArray.class)
+	public <T extends NativeType<T>> Img<T> img(final byte[] in1,
+		final Dimensions in2)
+	{
+		@SuppressWarnings("unchecked")
+		final Img<T> result = (Img<T>) ops().run(
+			Ops.Create.Img.class, in1, in2);
+		return result;
+	}
 
 	@OpMethod(op = net.imagej.ops.create.img.CreateImgFromDimsAndType.class)
 	public <T extends NativeType<T>> Img<T> img(final Dimensions in1,

src/main/java/net/imagej/ops/create/img/CreateImgFromArray.java

@@ -0,0 +1,104 @@
+/*
+ * #%L
+ * ImageJ software for multidimensional image processing and analysis.
+ * %%
+ * Copyright (C) 2014 - 2017 ImageJ 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.create.img;
+
+import org.scijava.Priority;
+import org.scijava.plugin.Parameter;
+import org.scijava.plugin.Plugin;
+
+import net.imagej.ops.Ops;
+import net.imagej.ops.special.computer.AbstractUnaryComputerOp;
+import net.imagej.ops.special.computer.Computers;
+import net.imagej.ops.special.computer.UnaryComputerOp;
+import net.imagej.ops.special.function.AbstractUnaryFunctionOp;
+import net.imglib2.Cursor;
+import net.imglib2.Dimensions;
+import net.imglib2.IterableInterval;
+import net.imglib2.img.Img;
+import net.imglib2.img.ImgFactory;
+import net.imglib2.img.array.ArrayImgFactory;
+import net.imglib2.type.NativeType;
+import net.imglib2.type.numeric.integer.UnsignedByteType;
+import net.imglib2.type.numeric.real.DoubleType;
+
+/**
+ * Create an {@link Img} from an array using its type
+ * {@code T}.
+ *
+ * @author Dasong Gao
+ * @param <T>
+ */
+@Plugin(type = Ops.Create.Img.class, priority = Priority.HIGH_PRIORITY)
+public class CreateImgFromArray<T extends NativeType<T>> extends AbstractUnaryFunctionOp<byte[], Img<T>> implements
+Ops.Create.Img {
+	
+	@Parameter(required = true)
+	private Dimensions dims;
+	
+	@Parameter(required = false)
+	private ImgFactory<T> factory;
+	
+	private Img<T> output;
+	
+	private T type;
+	
+	public static void main(String[] args) {
+		
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Img<T> calculate(final byte[] input) {
+		//output = (Img<T>) ops().run(CreateImgFromDimsAndType.class, dims, new UnsignedByteType());
+		//output = (Img<T>) ops().run(Ops.Create.Img.class, dims, new UnsignedByteType());
+		
+		
+		
+		type = (T) new UnsignedByteType();
+		if (factory == null) {
+			factory = dims == null ? ops().create().imgFactory() :
+				ops().create().imgFactory(dims);
+		}
+		output = Imgs.create((ImgFactory<T>) factory, dims, type);
+		long[] imgDims = new long[dims.numDimensions()];
+		for (int i = 0; i < imgDims.length; i++)
+			imgDims[i] = dims.dimension(i);
+		Cursor<T> cursor = output.cursor();
+		while (cursor.hasNext()) {
+			T value = cursor.next();
+			int inputIndex = 0;
+			for (int i = 0; i < imgDims.length; i++)
+				inputIndex += cursor.getLongPosition(i) * (i - 1 < 0 ? 1 : imgDims[i - 1]);
+			value.set((T) new UnsignedByteType(input[inputIndex]));
+		}
+		return output;
+	}
+
+}

src/test/java/net/imagej/ops/create/CreateImgTest.java

@@ -35,6 +35,7 @@
 import java.util.Random;
 
 import net.imagej.ops.AbstractOpTest;
+import net.imagej.ops.create.img.CreateImgFromArray;
 import net.imagej.ops.create.img.CreateImgFromDimsAndType;
 import net.imagej.ops.create.img.CreateImgFromImg;
 import net.imagej.ops.create.img.CreateImgFromInterval;
@@ -64,7 +65,11 @@
  * @author Daniel Seebacher (University of Konstanz)
  * @author Tim-Oliver Buchholz (University of Konstanz)
  */
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
 
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
 public class CreateImgTest extends AbstractOpTest {
 
 	private static final int TEST_SIZE = 100;
@@ -133,6 +138,42 @@ public void testImgFromImg() {
 		assertEquals(img.firstElement().getClass(), newImg.firstElement()
 			.getClass());
 	}
+	
+	@Test
+	public void testImgFromArray() {
+		final Random randomGenerator = new Random();
+
+		for (int i = 0; i < 1; i++) {
+
+			// between 2 and 5 dimensions
+			//final long[] dim = new long[randomGenerator.nextInt(4) + 2];
+			//final long[] dim = new long[2];
+			final long[] dim = {256, 1};
+			
+			// source array length
+			int srcLen = 1;
+			
+			// between 2 and 10 pixels per dimensions
+			for (int j = 0; j < dim.length; j++) {
+				//dim[j] = randomGenerator.nextInt(9) + 2;
+				//dim[j] = 100;
+				srcLen *= dim[j];
+			}
+			
+			byte[] arr = new byte[srcLen];
+			
+			for (int j = 0; j < srcLen; j++)
+				arr[j] = (byte) (j % 256);
+
+			// create img
+			@SuppressWarnings("unchecked")
+			final Img<UnsignedByteType> img = (Img<UnsignedByteType>) ops.run(
+				CreateImgFromArray.class, arr, dim);
+			net.imglib2.img.display.imagej.ImageJFunctions.show(img);
+//			assertArrayEquals("Image Dimensions:", dim, Intervals
+//				.dimensionsAsLongArray(img));
+		}
+	}
 
 	@Test
 	public void testImageFactory() {