Added PlaceRectangle, NumberThreshold, CountContours, and Crop Operations

core/src/main/java/edu/wpi/grip/core/operations/Operations.java

@@ -43,5 +43,10 @@ public static void addOperations(EventBus eventBus) {
         eventBus.post(new OperationAddedEvent(new NTPublishOperation<>(BlobsReport.class)));
         eventBus.post(new OperationAddedEvent(new NTPublishOperation<>(LinesReport.class)));
         eventBus.post(new OperationAddedEvent(new PublishVideoOperation()));
+        eventBus.post(new OperationAddedEvent(new PlaceRectangleOperation()));
+        eventBus.post(new OperationAddedEvent(new NumberThresholdOperation()));
+        eventBus.post(new OperationAddedEvent(new CountContoursOperation()));
+        eventBus.post(new OperationAddedEvent(new CropOperation()));
     }
+    //eventBus.post(new OperationAddedEvent(new ));
 }

core/src/main/java/edu/wpi/grip/core/operations/composite/CountContoursOperation.java

@@ -0,0 +1,63 @@
+package edu.wpi.grip.core.operations.composite;
+
+import com.google.common.eventbus.EventBus;
+import edu.wpi.grip.core.*;
+
+import java.io.InputStream;
+import java.util.Optional;
+
+/**
+ * An {@link Operation} that takes in a list of contours and outputs a list of any contours in the input that match
+ * all of several criteria.  Right now, the user can specify a minimum area, minimum perimeter, and ranges for width
+ * and height.
+ * <p>
+ * This is useful because running a Find Contours on a real-life image typically leads to many small undesirable
+ * contours from noise and small objects, as well as contours that do not meet the expected characteristics of the
+ * feature we're actually looking for.  So, this operation can help narrow them down.
+ */
+public class CountContoursOperation implements Operation {
+
+    private final SocketHint<ContoursReport> contoursHint = new SocketHint.Builder<>(ContoursReport.class)
+            .identifier("Contours").initialValueSupplier(ContoursReport::new).build();
+
+    private final SocketHint<Number> amountHint =
+            SocketHints.Inputs.createNumberSpinnerSocketHint("Amount", 0, 0, Integer.MAX_VALUE);
+
+    @Override
+    public String getName() {
+        return "Count Contours";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Find number of contours.";
+    }
+
+    @Override
+    public Optional<InputStream> getIcon() {
+        return Optional.of(getClass().getResourceAsStream("/edu/wpi/grip/ui/icons/grip.png"));
+    }
+
+    @Override
+    public InputSocket<?>[] createInputSockets(EventBus eventBus) {
+        return new InputSocket<?>[]{
+                new InputSocket<>(eventBus, contoursHint)
+        };
+    }
+
+    @Override
+    public OutputSocket<?>[] createOutputSockets(EventBus eventBus) {
+        return new OutputSocket<?>[]{new OutputSocket<>(eventBus, amountHint)};
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
+        final InputSocket<ContoursReport> inputSocket = (InputSocket<ContoursReport>) inputs[0];
+
+        long amount = inputSocket.getValue().get().getContours().size();
+
+        final OutputSocket<Number> outputSocket = (OutputSocket<Number>) outputs[0];
+        outputSocket.setValue(amount);
+    }
+}

core/src/main/java/edu/wpi/grip/core/operations/composite/CropOperation.java

@@ -0,0 +1,68 @@
+package edu.wpi.grip.core.operations.composite;
+
+import com.google.common.eventbus.EventBus;
+import edu.wpi.grip.core.*;
+import org.bytedeco.javacpp.opencv_core;
+
+import java.io.InputStream;
+import java.util.Optional;
+
+import static org.bytedeco.javacpp.opencv_imgproc.rectangle;
+
+/**
+ * @author Jaxon A Brown
+ */
+public class CropOperation implements Operation {
+    private final SocketHint<opencv_core.Mat> inputHint = SocketHints.Inputs.createMatSocketHint("Input", false);
+    private final SocketHint<opencv_core.Point> p1Hint = SocketHints.Inputs.createPointSocketHint("P1", false);
+    private final SocketHint<opencv_core.Point> p2Hint = SocketHints.Inputs.createPointSocketHint("P2", false);
+
+    private final SocketHint<opencv_core.Mat> outputHint = SocketHints.Inputs.createMatSocketHint("Output", true);
+
+    @Override
+    public String getName() {
+        return "Crop";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Crop an image";
+    }
+
+    @Override
+    public Optional<InputStream> getIcon() {
+        return Optional.of(getClass().getResourceAsStream("/edu/wpi/grip/ui/icons/grip.png"));
+    }
+
+    @Override
+    public InputSocket<?>[] createInputSockets(EventBus eventBus) {
+        return new InputSocket<?>[]{
+                new InputSocket<>(eventBus, inputHint),
+                new InputSocket<>(eventBus, p1Hint),
+                new InputSocket<>(eventBus, p2Hint),
+        };
+    }
+
+    @Override
+    public OutputSocket<?>[] createOutputSockets(EventBus eventBus) {
+        return new OutputSocket<?>[]{
+                new OutputSocket<>(eventBus, outputHint)
+        };
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
+        final opencv_core.Mat input = ((InputSocket<opencv_core.Mat>) inputs[0]).getValue().get();
+        final opencv_core.Point p1 = ((InputSocket<opencv_core.Point>) inputs[1]).getValue().get();
+        final opencv_core.Point p2 = ((InputSocket<opencv_core.Point>) inputs[2]).getValue().get();
+
+        final OutputSocket<opencv_core.Mat> outputSocket = (OutputSocket<opencv_core.Mat>) outputs[0];
+        final opencv_core.Mat output;
+
+        opencv_core.Rect rect = new opencv_core.Rect(p1, p2);
+        output = new opencv_core.Mat(input, rect);
+
+        outputSocket.setValue(output);
+    }
+}

core/src/main/java/edu/wpi/grip/core/operations/composite/NumberThresholdOperation.java

@@ -0,0 +1,68 @@
+package edu.wpi.grip.core.operations.composite;
+
+import com.google.common.eventbus.EventBus;
+import edu.wpi.grip.core.*;
+
+import java.io.InputStream;
+import java.util.Optional;
+
+/**
+ * @author Jaxon A Brown
+ */
+public class NumberThresholdOperation implements Operation {
+    private final SocketHint<Number> numHint = SocketHints.Inputs.createNumberSpinnerSocketHint("Input", 0);
+    private final SocketHint<Number> minHint = SocketHints.Inputs.createNumberSpinnerSocketHint("Min", -1);
+    private final SocketHint<Number> maxHint = SocketHints.Inputs.createNumberSpinnerSocketHint("Max", 1);
+
+    private final SocketHint<Boolean> boolHint = SocketHints.Outputs.createBooleanSocketHint("Output", true);
+
+    @Override
+    public String getName() {
+        return "NumberThreshold";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Returns a boolean on weather or not the number is within the given range.";
+    }
+
+    @Override
+    public Optional<InputStream> getIcon() {
+        return Optional.of(getClass().getResourceAsStream("/edu/wpi/grip/ui/icons/grip.png"));
+    }
+
+    @Override
+    public InputSocket<?>[] createInputSockets(EventBus eventBus) {
+        return new InputSocket<?>[] {
+                new InputSocket<>(eventBus, numHint),
+                new InputSocket<>(eventBus, minHint),
+                new InputSocket<>(eventBus, maxHint),
+        };
+    }
+
+    @Override
+    public OutputSocket<?>[] createOutputSockets(EventBus eventBus) {
+        return new OutputSocket[] {
+                new OutputSocket<>(eventBus, boolHint)
+        };
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
+        final Number num = ((InputSocket<Number>) inputs[0]).getValue().get();
+        final Number min = ((InputSocket<Number>) inputs[1]).getValue().get();
+        final Number max = ((InputSocket<Number>) inputs[2]).getValue().get();
+
+        final OutputSocket<Boolean> outputSocket = (OutputSocket<Boolean>) outputs[0];
+
+        Boolean output;
+        if(min.doubleValue() <= num.doubleValue() && max.doubleValue() >= num.doubleValue()) {
+            output = true;
+        } else {
+            output = false;
+        }
+
+        outputSocket.setValue(output);
+    }
+}

core/src/main/java/edu/wpi/grip/core/operations/composite/PlaceRectangleOperation.java

@@ -0,0 +1,68 @@
+package edu.wpi.grip.core.operations.composite;
+
+import com.google.common.eventbus.EventBus;
+import edu.wpi.grip.core.*;
+import org.bytedeco.javacpp.opencv_core;
+
+import java.io.InputStream;
+import java.util.Optional;
+
+import static org.bytedeco.javacpp.opencv_imgproc.*;
+
+/**
+ * @author Jaxon A Brown
+ */
+public class PlaceRectangleOperation implements Operation {
+    private final SocketHint<opencv_core.Mat> inputHint = SocketHints.Inputs.createMatSocketHint("Input", false);
+    private final SocketHint<opencv_core.Point> p1Hint = SocketHints.Inputs.createPointSocketHint("P1", false);
+    private final SocketHint<opencv_core.Point> p2Hint = SocketHints.Inputs.createPointSocketHint("P2", false);
+
+    private final SocketHint<opencv_core.Mat> outputHint = SocketHints.Inputs.createMatSocketHint("Output", true);
+
+    @Override
+    public String getName() {
+        return "PlaceRectangle";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Place a red rectangle over the image.";
+    }
+
+    @Override
+    public Optional<InputStream> getIcon() {
+        return Optional.of(getClass().getResourceAsStream("/edu/wpi/grip/ui/icons/grip.png"));
+    }
+
+    @Override
+    public InputSocket<?>[] createInputSockets(EventBus eventBus) {
+        return new InputSocket<?>[]{
+                new InputSocket<>(eventBus, inputHint),
+                new InputSocket<>(eventBus, p1Hint),
+                new InputSocket<>(eventBus, p2Hint),
+        };
+    }
+
+    @Override
+    public OutputSocket<?>[] createOutputSockets(EventBus eventBus) {
+        return new OutputSocket<?>[]{
+                new OutputSocket<>(eventBus, outputHint)
+        };
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void perform(InputSocket<?>[] inputs, OutputSocket<?>[] outputs) {
+        final opencv_core.Mat input = ((InputSocket<opencv_core.Mat>) inputs[0]).getValue().get();
+        final opencv_core.Point p1 = ((InputSocket<opencv_core.Point>) inputs[1]).getValue().get();
+        final opencv_core.Point p2 = ((InputSocket<opencv_core.Point>) inputs[2]).getValue().get();
+
+        final OutputSocket<opencv_core.Mat> outputSocket = (OutputSocket<opencv_core.Mat>) outputs[0];
+        final opencv_core.Mat output = outputSocket.getValue().get();
+
+        input.copyTo(output);
+        rectangle(output, p1, p2, org.bytedeco.javacpp.helper.opencv_core.AbstractScalar.RED, 2, 1, 0);
+
+        outputSocket.setValue(output);
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,4 +1,4 @@
-#Mon Jan 04 19:05:21 EST 2016
+#Mon Jan 18 10:15:12 EST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME