Add more transformers and ops

Treiblesschorle · gselzer · commit 07181845fbcd · 2019-04-12T12:54:01.000-05:00
diff --git a/src/main/java/org/scijava/ops/copy/CopyOpCollection.java b/src/main/java/org/scijava/ops/copy/CopyOpCollection.java
@@ -0,0 +1,23 @@
+package org.scijava.ops.copy;
+
+import org.scijava.core.Priority;
+import org.scijava.ops.OpField;
+import org.scijava.ops.core.Computer;
+import org.scijava.ops.core.OpCollection;
+import org.scijava.param.Parameter;
+import org.scijava.plugin.Plugin;
+import org.scijava.struct.ItemIO;
+
+@Plugin(type = OpCollection.class)
+public class CopyOpCollection {
+
+	@OpField(names = "cp, copy", priority = Priority.LOW)
+	@Parameter(key = "array")
+	@Parameter(key = "arrayCopy", type = ItemIO.OUTPUT)
+	public static final Computer<double[], double[]> copyDoubleArray = (from, to) -> {
+		for (int i = 0; i < to.length; i++) {
+			to[i] = from[i];
+		}
+	};
+
+}
diff --git a/src/main/java/org/scijava/ops/create/CreateOpCollection.java b/src/main/java/org/scijava/ops/create/CreateOpCollection.java
@@ -0,0 +1,20 @@
+package org.scijava.ops.create;
+
+import java.util.function.Function;
+
+import org.scijava.core.Priority;
+import org.scijava.ops.OpField;
+import org.scijava.ops.core.OpCollection;
+import org.scijava.param.Parameter;
+import org.scijava.plugin.Plugin;
+import org.scijava.struct.ItemIO;
+
+@Plugin(type = OpCollection.class)
+public class CreateOpCollection {
+
+	@OpField(names = "create, src, source", priority = Priority.LOW)
+	@Parameter(key = "array")
+	@Parameter(key = "arrayLike", type = ItemIO.OUTPUT)
+	public static final Function<double[], double[]> createDoubleArray = from -> new double[from.length];
+
+}
diff --git a/src/main/java/org/scijava/ops/transform/impl/ComputerToFunctionTransformer.java b/src/main/java/org/scijava/ops/transform/impl/ComputerToFunctionTransformer.java
@@ -0,0 +1,48 @@
+package org.scijava.ops.transform.impl;
+
+import java.lang.reflect.Type;
+import java.util.function.Function;
+
+import org.scijava.ops.OpService;
+import org.scijava.ops.core.Computer;
+import org.scijava.ops.matcher.OpRef;
+import org.scijava.ops.transform.OpTransformer;
+import org.scijava.ops.transform.TypeModUtils;
+import org.scijava.ops.util.Adapt;
+import org.scijava.ops.util.Functions;
+import org.scijava.plugin.Plugin;
+import org.scijava.types.Nil;
+
+@Plugin(type = OpTransformer.class)
+public class ComputerToFunctionTransformer implements OpTransformer {
+
+	@Override
+	public Object transform(OpService opService, OpRef ref, Object src) {
+		if (src instanceof Computer) {
+			// TODO what happens if we actually have several?
+			Type[] outTypes = ref.getOutTypes();
+			Type[] argTypes = ref.getArgs();
+			try {
+				Function srcOp = Functions.unary(opService, "create", Nil.of(argTypes[0]), Nil.of(outTypes[0]));
+				return Adapt.Computers.asFunction((Computer) src, srcOp);
+			} catch (Exception e) {
+				//TODO
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public OpRef getFromTransformTo(OpRef toRef) {
+		Type[] refTypes = toRef.getTypes();
+		boolean hit = TypeModUtils.replaceRawTypes(refTypes, Function.class, Computer.class);
+		if (hit) {
+			// The computer has a ItemIO.BOTH as second functional parameter of type functional output.
+			// Hence, we need to add it after the first functional input.
+			Type[] computerArgs = TypeModUtils.insert(toRef.getArgs(), toRef.getOutTypes()[0], 1);
+			return OpRef.fromTypes(toRef.getName(), refTypes, toRef.getOutTypes(), computerArgs);
+		}
+		return null;
+	}
+
+}
diff --git a/src/main/java/org/scijava/ops/transform/impl/LiftFunctionToListTransformer.java b/src/main/java/org/scijava/ops/transform/impl/LiftFunctionToListTransformer.java
@@ -0,0 +1,52 @@
+package org.scijava.ops.transform.impl;
+
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.function.Function;
+
+import org.scijava.ops.OpService;
+import org.scijava.ops.matcher.OpRef;
+import org.scijava.ops.transform.OpTransformer;
+import org.scijava.ops.transform.TypeModUtils;
+import org.scijava.ops.util.Maps;
+import org.scijava.plugin.Plugin;
+
+@Plugin(type = OpTransformer.class)
+public class LiftFunctionToListTransformer implements OpTransformer {
+
+	@Override
+	public Object transform(OpService opService, OpRef fromRef, Object src) {
+		if (src instanceof Function) {
+			try {
+				return Maps.Lift.Functions.list((Function) src);
+			} catch (Exception e) {
+				// TODO
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public OpRef getFromTransformTo(OpRef toRef) {
+		// TODO put the code below into a utils method
+		Type[] refTypes = toRef.getTypes();
+		boolean typesChanged = TypeModUtils.unliftParameterizedTypes(refTypes, Function.class, List.class);
+		// TODO We assume here that the functional input is the first Type in
+		// this list and all others are secondary args if there are any (we do
+		// not want to touch them as they are not part of op transformations).
+		// Should always be the case as during structification of the ops,
+		// the functional args are always checked first. Hence, they always
+		// need to be requested first and are thus at the beginning of the list.
+		// From the functional type we know how many there must be.
+		Type[] args = toRef.getArgs();
+		boolean argsChanged = TypeModUtils.unliftTypes(args, List.class);
+		Type[] outs = toRef.getOutTypes();
+		boolean outsChanged = TypeModUtils.unliftTypes(outs, List.class);
+		
+		if (typesChanged && argsChanged && outsChanged) {
+			return OpRef.fromTypes(toRef.getName(), refTypes, outs, args);
+		}
+		return null;
+	}
+
+}
diff --git a/src/main/java/org/scijava/ops/util/Maps.java b/src/main/java/org/scijava/ops/util/Maps.java
@@ -1,7 +1,9 @@
 package org.scijava.ops.util;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import org.scijava.ops.core.Computer;
 
@@ -21,6 +23,10 @@ public static class Functions {
 			private Functions() {
 			}
 			
+			public static <I, O> Function<List<I>, List<O>> list(final Function<I, O> function) {
+				return iter -> iter.stream().map(function).collect(Collectors.toList());
+			}
+			
 			public static <I, O> Function<Iterable<I>, Iterable<O>> iterable(final Function<I, O> function) {
 				return iter -> () -> Streams.stream(iter).map(function).iterator();
 			}
