Rewrites Publishing to use GRIP ROS Types

Author: JLLeitschuh

.gitignore

@@ -85,5 +85,6 @@ node_modules
 bower_components
 
 #Generated files should be ignored as the are regenerated as a build step
-*/src/generated
+**/generated
+*/generated_tests
 /bin/

build.gradle

@@ -21,6 +21,21 @@ def getGitCommit = { ->
     return COMMIT_HASH
 }
 
+idea.project {
+    ipr.withXml { provider ->
+        def node = provider.asNode()
+        def compilerConfig = node.component.find { it.'@name' == 'CompilerConfiguration'}
+        compilerConfig.annotationProcessing[0].'@enabled' = 'true'
+//        def ccfg = node.component.find { it.@name == 'CompilerConfiguration' }
+//        ccfg.remove(ccfg.annotationProcessing)
+//        ccfg.append(new NodeBuilder().annotationProcessing() {
+//            profile(default: true, name: 'Default', enabled: true) {
+//                processorPath(useClasspath: true)
+//            }
+//        })
+    }
+}
+
 /*
  * Gets the version name from the latest Git tag
  * http://ryanharter.com/blog/2013/07/30/automatic-versioning-with-git-and-gradle/
@@ -146,7 +161,7 @@ project(":core") {
                 url = "http://first.wpi.edu/FRC/roborio/maven/development"
             }
             maven {
-                url = "https://github.com/rosjava/rosjava_mvn_repo/raw/master"
+                url = "https://github.com/WPIRoboticsProjects/rosjava_mvn_repo/raw/master"
             }
         }
     }
@@ -162,6 +177,7 @@ project(":core") {
         compile group: 'com.thoughtworks.xstream', name: 'xstream', version: '1.4.8'
         compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.4'
         compile group: 'com.google.guava', name: 'guava', version: '19.0'
+        compile group: 'com.google.auto.value', name: 'auto-value', version: '1.1'
         // We use the no_aop version of Guice because the aop isn't avaiable in arm java
         // http://stackoverflow.com/a/15235190/3708426
         // https://github.com/google/guice/wiki/OptionalAOP
@@ -170,6 +186,7 @@ project(":core") {
 
         // Network publishing dependencies
         compile group: 'org.ros.rosjava_core', name: 'rosjava', version: '[0.2,0.3)'
+        compile group: 'org.ros.rosjava_messages', name: 'grip_msgs', version: '0.0.1'
         compile group: 'edu.wpi.first.wpilib.networktables.java', name: 'NetworkTables', version: '3.0.0-SNAPSHOT', classifier: 'desktop'
         compile group: 'edu.wpi.first.wpilib.networktables.java', name: 'NetworkTables', version: '3.0.0-SNAPSHOT', classifier: 'arm'
     }
@@ -238,8 +255,8 @@ project(":core") {
 
     idea.module {
         sourceDirs += sourceSets.generated.java.srcDirs
+        sourceDirs += file('generated')
     }
-    // End IDE setup
 }
 
 project(":ui") {

core/src/main/java/edu/wpi/grip/core/PipelineRunner.java

@@ -13,14 +13,14 @@
 import edu.wpi.grip.core.events.RenderEvent;
 import edu.wpi.grip.core.events.RunPipelineEvent;
 import edu.wpi.grip.core.events.StopPipelineEvent;
+import edu.wpi.grip.core.util.SinglePermitSemaphore;
 import edu.wpi.grip.core.util.service.AutoRestartingService;
 import edu.wpi.grip.core.util.service.LoggingListener;
 import edu.wpi.grip.core.util.service.RestartableService;
 
 import javax.annotation.Nullable;
 import javax.inject.Inject;
 import java.util.concurrent.Executor;
-import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Supplier;
@@ -37,7 +37,7 @@ public class PipelineRunner implements RestartableService {
     /**
      * This is used to flag that the pipeline needs to run because of an update
      */
-    private final Semaphore pipelineFlag = new Semaphore(0);
+    private final SinglePermitSemaphore pipelineFlag = new SinglePermitSemaphore();
     private final Supplier<ImmutableList<Source>> sourceSupplier;
     private final Supplier<ImmutableList<Step>> stepSupplier;
     private final AutoRestartingService pipelineService;
@@ -62,13 +62,7 @@ public class PipelineRunner implements RestartableService {
                     protected void runOneIteration() throws InterruptedException {
                         if (!super.isRunning()) return;
 
-                        // Acquire the first this one should permit if there is at least one permit
                         pipelineFlag.acquire();
-                        // Acquire the rest of the permits from the flag
-                        // Every time release is called another permit is added.
-                        // We need to clean up any old permits that we may have been given.
-                        pipelineFlag.acquire(
-                                Math.max(0, pipelineFlag.availablePermits()));
 
                         if (!super.isRunning()) return;
                         runPipeline(super::isRunning);

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

@@ -9,11 +9,13 @@
 import edu.wpi.grip.core.events.OperationAddedEvent;
 import edu.wpi.grip.core.operations.composite.*;
 import edu.wpi.grip.core.operations.network.BooleanPublishable;
-import edu.wpi.grip.core.operations.network.Manager;
+import edu.wpi.grip.core.operations.network.MapNetworkPublisherFactory;
 import edu.wpi.grip.core.operations.network.NumberPublishable;
 import edu.wpi.grip.core.operations.network.Vector2D;
-import edu.wpi.grip.core.operations.network.networktables.NTKeyValuePublishOperation;
-import edu.wpi.grip.core.operations.network.ros.ROSKeyValuePublishOperation;
+import edu.wpi.grip.core.operations.network.networktables.NTPublishAnnotatedOperation;
+import edu.wpi.grip.core.operations.network.ros.JavaToMessageConverter;
+import edu.wpi.grip.core.operations.network.ros.ROSNetworkPublisherFactory;
+import edu.wpi.grip.core.operations.network.ros.ROSPublishOperation;
 import edu.wpi.grip.core.operations.opencv.MatFieldAccessor;
 import edu.wpi.grip.core.operations.opencv.MinMaxLoc;
 import edu.wpi.grip.core.operations.opencv.NewPointOperation;
@@ -31,10 +33,10 @@ public class Operations {
     private final ImmutableList<Supplier<Operation>> operations;
 
     @Inject
-    Operations(EventBus eventBus, @Named("ntManager") Manager ntManager, @Named("rosManager") Manager rosManager) {
+    Operations(EventBus eventBus, @Named("ntManager") MapNetworkPublisherFactory ntPublisherFactory, @Named("rosManager") ROSNetworkPublisherFactory rosPublishFactory) {
         this.eventBus = checkNotNull(eventBus, "EventBus cannot be null");
-        checkNotNull(ntManager, "ntManager cannot be null");
-        checkNotNull(rosManager, "rosManager cannot be null");
+        checkNotNull(ntPublisherFactory, "ntPublisherFactory cannot be null");
+        checkNotNull(rosPublishFactory, "rosPublishFactory cannot be null");
         this.operations = ImmutableList.of(
                 ResizeOperation::new,
                 BlurOperation::new,
@@ -53,33 +55,33 @@ public class Operations {
                 MatFieldAccessor::new,
                 NewPointOperation::new,
                 NewSizeOperation::new,
-                () -> new NTKeyValuePublishOperation<Number, NumberPublishable, Number>(ntManager, NumberPublishable::new) {
+                () -> new NTPublishAnnotatedOperation<Number, NumberPublishable, Double>(ntPublisherFactory, NumberPublishable::new) {
                 },
-                () -> new NTKeyValuePublishOperation<Boolean, BooleanPublishable, Boolean>(ntManager, BooleanPublishable::new) {
+                () -> new NTPublishAnnotatedOperation<Boolean, BooleanPublishable, Boolean>(ntPublisherFactory, BooleanPublishable::new) {
                 },
-                () -> new NTKeyValuePublishOperation<Point, Vector2D, Double>(ntManager, Vector2D::new) {
+                () -> new NTPublishAnnotatedOperation<Point, Vector2D, Double>(ntPublisherFactory, Vector2D::new) {
                 },
-                () -> new NTKeyValuePublishOperation<Size, Vector2D, Double>(ntManager, Vector2D::new) {
+                () -> new NTPublishAnnotatedOperation<Size, Vector2D, Double>(ntPublisherFactory, Vector2D::new) {
                 },
-                () -> new NTKeyValuePublishOperation<ContoursReport, ContoursReport, double[]>(ntManager) {
+                () -> new NTPublishAnnotatedOperation<ContoursReport, ContoursReport, double[]>(ntPublisherFactory) {
                 },
-                () -> new NTKeyValuePublishOperation<BlobsReport, BlobsReport, double[]>(ntManager) {
+                () -> new NTPublishAnnotatedOperation<BlobsReport, BlobsReport, double[]>(ntPublisherFactory) {
                 },
-                () -> new NTKeyValuePublishOperation<LinesReport, LinesReport, double[]>(ntManager) {
+                () -> new NTPublishAnnotatedOperation<LinesReport, LinesReport, double[]>(ntPublisherFactory) {
                 },
-                () -> new ROSKeyValuePublishOperation<Number, NumberPublishable, Number>(ntManager, NumberPublishable::new) {
+                () -> new ROSPublishOperation<Number>(rosPublishFactory, JavaToMessageConverter.FLOAT) {
                 },
-                () -> new ROSKeyValuePublishOperation<Boolean, BooleanPublishable, Boolean>(ntManager, BooleanPublishable::new) {
+                () -> new ROSPublishOperation<Boolean>(rosPublishFactory, JavaToMessageConverter.BOOL) {
                 },
-                () -> new ROSKeyValuePublishOperation<Point, Vector2D, Double>(ntManager, Vector2D::new) {
+//                () -> new ROSPublishOperation<Point, Vector2D, Double>(rosManager, Vector2D::new) {
+//                },
+//                () -> new ROSPublishOperation<Size, Vector2D, Double>(rosManager, Vector2D::new) {
+//                },
+                () -> new ROSPublishOperation<ContoursReport>(rosPublishFactory, JavaToMessageConverter.CONTOURS) {
                 },
-                () -> new ROSKeyValuePublishOperation<Size, Vector2D, Double>(ntManager, Vector2D::new) {
+                () -> new ROSPublishOperation<BlobsReport>(rosPublishFactory, JavaToMessageConverter.BLOBS) {
                 },
-                () -> new ROSKeyValuePublishOperation<ContoursReport, ContoursReport, double[]>(ntManager) {
-                },
-                () -> new ROSKeyValuePublishOperation<BlobsReport, BlobsReport, double[]>(ntManager) {
-                },
-                () -> new ROSKeyValuePublishOperation<LinesReport, LinesReport, double[]>(ntManager) {
+                () -> new ROSPublishOperation<LinesReport>(rosPublishFactory, JavaToMessageConverter.LINES) {
                 },
                 PublishVideoOperation::new,
                 DistanceTransformOperation::new,

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

@@ -1,9 +1,12 @@
 package edu.wpi.grip.core.operations.composite;
 
+import com.google.auto.value.AutoValue;
 import edu.wpi.grip.core.NoSocketTypeLabel;
-import edu.wpi.grip.core.operations.network.Publishable;
 import edu.wpi.grip.core.operations.network.PublishValue;
+import edu.wpi.grip.core.operations.network.Publishable;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Optional;
 
 import static org.bytedeco.javacpp.opencv_core.*;
@@ -46,6 +49,39 @@ public MatVector getContours() {
         return this.contours;
     }
 
+    @AutoValue
+    public static abstract class Contour {
+        static Contour create(double area, double centerX, double centerY, double width, double height, double solidity) {
+            return new AutoValue_ContoursReport_Contour(area, centerX, centerY, width, height, solidity);
+        }
+
+        public abstract double area();
+
+        public abstract double centerX();
+
+        public abstract double centerY();
+
+        public abstract double width();
+
+        public abstract double height();
+
+        public abstract double solidity();
+    }
+
+    public List<Contour> getProcessedContours() {
+        final List<Contour> processedContours = new ArrayList<>((int) contours.size());
+        double area[] = getArea();
+        double centerX[] = getCenterX();
+        double centerY[] = getCenterY();
+        double width[] = getWidth();
+        double height[] = getHeights();
+        double solidity[] = getSolidity();
+        for (int i = 0; i < contours.size(); i++) {
+            processedContours.add(Contour.create(area[i], centerX[i], centerY[i], width[i], height[i], solidity[i]));
+        }
+        return processedContours;
+    }
+
     /**
      * Compute the bounding boxes of all contours (if they haven't already been computed).  Bounding boxes are used
      * to compute several different properties, so it's probably not a good idea to compute them over and over again.

core/src/main/java/edu/wpi/grip/core/operations/network/BooleanPublishable.java

@@ -4,9 +4,9 @@
 import java.util.function.Function;
 
 /**
- * An adapter to allow booleans to be published from GRIP sockets into a {@link NetworkKeyValuePublisher}
+ * An adapter to allow booleans to be published from GRIP sockets into a {@link NetworkPublisher}
  *
- * @see KeyValuePublishOperation#PublishOperation(Manager, Class, Class, Function)
+ * @see PublishAnnotatedOperation#PublishAnnotatedOperation(MapNetworkPublisherFactory, Function)
  */
 @Immutable
 public final class BooleanPublishable implements Publishable {

core/src/main/java/edu/wpi/grip/core/operations/network/GRIPNetworkModule.java

@@ -4,6 +4,7 @@
 import com.google.inject.name.Names;
 import edu.wpi.grip.core.operations.network.networktables.NTManager;
 import edu.wpi.grip.core.operations.network.ros.ROSManager;
+import edu.wpi.grip.core.operations.network.ros.ROSNetworkPublisherFactory;
 
 /**
  * Defines any concrete implementation mappings between
@@ -15,10 +16,10 @@
 public final class GRIPNetworkModule extends AbstractModule {
     @Override
     protected void configure() {
-        bind(Manager.class)
+        bind(MapNetworkPublisherFactory.class)
                 .annotatedWith(Names.named("ntManager"))
                 .to(NTManager.class);
-        bind(Manager.class)
+        bind(ROSNetworkPublisherFactory.class)
                 .annotatedWith(Names.named("rosManager"))
                 .to(ROSManager.class);
     }

core/src/main/java/edu/wpi/grip/core/operations/network/Manager.java

@@ -1,17 +1,9 @@
 package edu.wpi.grip.core.operations.network;
 
 
-import java.util.Set;
-
 /**
  * A network manager that handles all of the API overhead for dealing with
  * a specific network protocol.
  */
 public interface Manager {
-    /**
-     *
-     * @param keys The possible set of keys that this network publisher can publish.
-     * @return A network publisher for the specific protocol.
-     */
-    <P> NetworkKeyValuePublisher<P> createPublisher(Class<P> publishType, Set<String> keys);
 }

core/src/main/java/edu/wpi/grip/core/operations/network/NetworkKeyValuePublisher.java renamed to core/src/main/java/edu/wpi/grip/core/operations/network/MapNetworkPublisher.java

@@ -7,29 +7,19 @@
 import java.util.Set;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
- * Manages the interface between the {@link KeyValuePublishOperation} and the actual network
- * protocol implemented by a specific {@link Manager}.
- * <p>
- * This class is designed to be in one of two states, either the set of keys
- * will be empty. In which case the name will be used as the publish key.
- * In the other case the keys list will be populated and each value will
- * need to be published with a specific key.
+ * Publishes a map of keys to values
+ *
+ * @param <T> The type of the 'value' in the string, value map that is being published
  */
-public abstract class NetworkKeyValuePublisher<T> extends NetworkPublisher {
+public abstract class MapNetworkPublisher<T> extends NetworkPublisher<Map<String, T>> {
     private final ImmutableSet<String> keys;
-    private final Class<T> publishType;
 
-    protected NetworkKeyValuePublisher(Class<T> publishType, Set<String> keys) {
+    protected MapNetworkPublisher(Set<String> keys) {
+        super();
         checkArgument(!keys.contains(""), "Keys can not contain the empty string");
         this.keys = ImmutableSet.copyOf(keys);
-        this.publishType = checkNotNull(publishType, "The publishType cannot be null");
-    }
-
-    protected final Class<T> getPublishType() {
-        return publishType;
     }
 
     /**
@@ -38,26 +28,26 @@ protected final Class<T> getPublishType() {
      *
      * @param publishMap the keyValues to publish
      */
-    final void publish(Map<String, T> publishMap) {
+    @Override
+    public final void publish(Map<String, T> publishMap) {
         final Map<String, T> publishMapCopy = ImmutableMap.copyOf(publishMap);
         if (!keys.isEmpty()) {
             publishMap.entrySet().forEach(key -> checkArgument(keys.contains(key), "Key must be in keys list: " + key));
         }
         checkNamePresent();
         if (!publishMapCopy.containsKey("")) {
             doPublish(publishMapCopy);
-        } else if(!publishMapCopy.keySet().isEmpty()){
-            doPublish(publishMapCopy.get(""));
+        } else if (!publishMapCopy.keySet().isEmpty()) {
+            doPublishSingle(publishMapCopy.get(""));
         } else {
             doPublish();
         }
     }
 
     /**
-     * Perform the publish with the key and value. The key is guaranteed to be in the
-     * {@link #keys} set.
+     * Publishes a key value mapping
      *
-     * @param publishMap the keyValues to publish
+     * @param publishMap The mapping of keys to values to be published
      */
     protected abstract void doPublish(Map<String, T> publishMap);
 
@@ -66,15 +56,10 @@ final void publish(Map<String, T> publishMap) {
      *
      * @param value The value to be published
      */
-    protected abstract void doPublish(T value);
+    protected abstract void doPublishSingle(T value);
 
     /**
      * Publishes nothing.
      */
     protected abstract void doPublish();
-
-    /**
-     * Close the network publisher. This should not throw an exception.
-     */
-    public abstract void close();
 }

core/src/main/java/edu/wpi/grip/core/operations/network/MapNetworkPublisherFactory.java

@@ -0,0 +1,12 @@
+package edu.wpi.grip.core.operations.network;
+
+
+import java.util.Set;
+
+/**
+ * A factory to create {@link MapNetworkPublisher MapNetworkPublishers}
+ */
+@FunctionalInterface
+public interface MapNetworkPublisherFactory {
+    <T> MapNetworkPublisher<T> create(Set<String> keys);
+}