Depth Vision and Segment Vision in the conformance suite (1.21) [skip publish]

The conformance driver reads both readings in the wire's shapes, and
the readings' sizes and grid dimensions must be whole numbers of at
least 0, as the suite holds them; a negative one makes the reading an
UnknownReading. CI on conformance suite 1.21.

Author: bynnit

.github/workflows/ci.yml

@@ -9,8 +9,8 @@ permissions:
   contents: read
 
 env:
-  # The conformance suite commit this SDK is tested against (suite 1.20, tag v1.20, for specification 1.3). Change it here only.
-  CONFORMANCE_REF: b9e549115c5d7e20fa33da9ebb187a06c8a26eca
+  # The conformance suite commit this SDK is tested against (suite 1.21, tag v1.21, for specification 1.3). Change it here only.
+  CONFORMANCE_REF: 2de217d7fbfbed7fb712bd9b0197605a8857e8f7
 
 # Every action is pinned to a commit SHA; the tag it was resolved from follows as a comment.
 jobs:

src/main/java/com/bynn/decisionnode/Responses.java

@@ -190,8 +190,8 @@ private static DepthReading depthReading(Map<String, Object> raw) {
         Long width = integer(raw.get("width"));
         Long height = integer(raw.get("height"));
         Object ahead = raw.get("ahead");
-        if (!(image instanceof String) || dirs == null || dirs.size() != 7 || !(ground instanceof Boolean) || rows == null
-                || cols == null || grid == null || depths == null || width == null || height == null
+        if (!(image instanceof String) || dirs == null || dirs.size() != 7 || !(ground instanceof Boolean) || !whole(rows)
+                || !whole(cols) || grid == null || depths == null || !whole(width) || !whole(height)
                 || (ahead != null && Json.asDouble(ahead) == null)) {
             return null;
         }
@@ -227,7 +227,7 @@ private static SegmentReading segmentReading(Map<String, Object> raw) {
         List<Object> found = Json.asList(raw.get("instances"));
         Object source = raw.get("depth_source");
         Object hfov = raw.get("assumed_hfov_deg");
-        if (!(image instanceof String) || width == null || height == null || prompts == null || found == null
+        if (!(image instanceof String) || !whole(width) || !whole(height) || prompts == null || found == null
                 || (source != null && !(source instanceof String)) || (hfov != null && Json.asDouble(hfov) == null)) {
             return null;
         }
@@ -314,6 +314,11 @@ private static SegmentInstance segmentInstance(Map<String, Object> m) {
                 polygon, area, centroid, opening, depth, size);
     }
 
+    /** A JSON integer of at least 0. */
+    private static boolean whole(Long n) {
+        return n != null && n >= 0;
+    }
+
     /** A JSON array of numbers, as doubles; null when it is not one. */
     private static List<Double> numberList(Object value) {
         List<Object> list = Json.asList(value);

src/test/java/com/bynn/decisionnode/ConformanceTest.java

@@ -1128,6 +1128,33 @@ static Map<String, Object> normReading(Reading r) {
                 list.add(e);
             }
             n.put("matches", list);
+        } else if (r instanceof DepthReading dr) {
+            n.put("kind", "bynn_depth");
+            n.put("image", dr.image());
+            n.put("ahead", dr.ahead());
+            n.put("directions", dr.directions());
+            n.put("ground", dr.ground());
+            n.put("grid_rows", dr.gridRows());
+            n.put("grid_cols", dr.gridCols());
+            n.put("grid", dr.grid());
+            n.put("depth_min", dr.depthMin());
+            n.put("depth_max", dr.depthMax());
+            n.put("depth_median", dr.depthMedian());
+            n.put("width", dr.width());
+            n.put("height", dr.height());
+        } else if (r instanceof SegmentReading sr) {
+            n.put("kind", "bynn_segment");
+            n.put("image", sr.image());
+            n.put("width", sr.width());
+            n.put("height", sr.height());
+            n.put("prompts", sr.prompts());
+            n.put("depth_source", sr.depthSource());
+            n.put("assumed_hfov_deg", sr.assumedHfovDeg());
+            List<Object> instances = new ArrayList<>();
+            for (SegmentInstance i : sr.instances()) {
+                instances.add(normInstance(i));
+            }
+            n.put("instances", instances);
         } else if (r instanceof OcrReading o) {
             n.put("kind", "ocr");
             n.put("image", o.image());
@@ -1140,6 +1167,67 @@ static Map<String, Object> normReading(Reading r) {
         return n;
     }
 
+    /** A Segment Vision match in the wire's fields and shapes: points as [x, y], an empty part as null. */
+    static Map<String, Object> normInstance(SegmentInstance i) {
+        Map<String, Object> n = new LinkedHashMap<>();
+        n.put("label", i.label());
+        n.put("score", i.score());
+        n.put("box", List.of(i.box().x1(), i.box().y1(), i.box().x2(), i.box().y2()));
+        n.put("polygon", pointList(i.polygon()));
+        n.put("area", i.area());
+        n.put("centroid", pointPair(i.centroid()));
+        if (i.opening() == null) {
+            n.put("opening", null);
+        } else {
+            Map<String, Object> o = new LinkedHashMap<>();
+            o.put("polygon", pointList(i.opening().polygon()));
+            o.put("centroid", pointPair(i.opening().centroid()));
+            o.put("width", i.opening().width());
+            o.put("height", i.opening().height());
+            o.put("offset", pointPair(i.opening().offset()));
+            o.put("area", i.opening().area());
+            n.put("opening", o);
+        }
+        if (i.depth() == null) {
+            n.put("depth", null);
+        } else {
+            Map<String, Object> d = new LinkedHashMap<>();
+            d.put("median", i.depth().median());
+            d.put("opening_median", i.depth().openingMedian());
+            d.put("opening_rim_median", i.depth().openingRimMedian());
+            n.put("depth", d);
+        }
+        if (i.sizeM() == null) {
+            n.put("size_m", null);
+        } else {
+            Map<String, Object> s = new LinkedHashMap<>();
+            s.put("width", i.sizeM().width());
+            s.put("height", i.sizeM().height());
+            if (i.sizeM().opening() == null) {
+                s.put("opening", null);
+            } else {
+                Map<String, Object> so = new LinkedHashMap<>();
+                so.put("width", i.sizeM().opening().width());
+                so.put("height", i.sizeM().opening().height());
+                s.put("opening", so);
+            }
+            n.put("size_m", s);
+        }
+        return n;
+    }
+
+    private static List<Object> pointPair(SegmentPoint p) {
+        return List.of(p.x(), p.y());
+    }
+
+    private static List<Object> pointList(List<SegmentPoint> points) {
+        List<Object> out = new ArrayList<>();
+        for (SegmentPoint p : points) {
+            out.add(pointPair(p));
+        }
+        return out;
+    }
+
     static Map<String, Object> normBox(FaceBox b) {
         Map<String, Object> box = new LinkedHashMap<>();
         box.put("x1", b.x1());

src/test/java/com/bynn/decisionnode/VisionReadingsTest.java

@@ -59,8 +59,9 @@ void aMalformedDepthReadingIsGeneric() throws Exception {
                 + DEPTH.replace("\"grid_rows\":2", "\"grid_rows\":2.5") + ","
                 + DEPTH.replace("[1.5,2,2.25]", "[1.5,null,2.25]") + ","
                 + DEPTH.replace("\"ahead\":2.41", "\"ahead\":\"far\"") + ","
-                + DEPTH.replace("\"depth_median\":2.35,", "") + "]");
-        assertEquals(8, r.size());
+                + DEPTH.replace("\"depth_median\":2.35,", "") + ","
+                + DEPTH.replace("\"width\":1280", "\"width\":-1") + "]");
+        assertEquals(9, r.size());
         r.forEach(each -> assertEquals("bynn_depth", assertInstanceOf(UnknownReading.class, each).booster()));
     }
 
@@ -116,8 +117,9 @@ void aMalformedSegmentReadingIsGeneric() throws Exception {
                 + head + INSTANCE.replace("{\"width\":0.8,\"height\":2.0}", "{\"width\":0.8}") + "]},"
                 + head + INSTANCE.replace("\"label\":\"door\",", "") + "]},"
                 + "{\"image\":\"hall\",\"width\":1280,\"height\":720,\"prompts\":[1],\"instances\":[]},"
-                + "{\"image\":\"hall\",\"width\":1280,\"height\":720,\"prompts\":[\"door\"],\"instances\":[],\"depth_source\":5}]");
-        assertEquals(9, r.size());
+                + "{\"image\":\"hall\",\"width\":1280,\"height\":720,\"prompts\":[\"door\"],\"instances\":[],\"depth_source\":5},"
+                + "{\"image\":\"hall\",\"width\":1280,\"height\":-720,\"prompts\":[\"door\"],\"instances\":[]}]");
+        assertEquals(10, r.size());
         r.forEach(each -> assertEquals("bynn_segment", assertInstanceOf(UnknownReading.class, each).booster()));
         assertFalse(r.isEmpty());
     }