drawdown-arcore-depth 0.1.5 → 0.1.6

package/README.md

@@ -190,6 +190,11 @@ No ArUco marker is required by the native ARCore workflow. The existing RFID/NFC
 The DBH sampler now anchors front-surface range with ARCore Raw Depth plus the matching confidence image (confidence >= 128). Smoothed Depth is used only after a high-confidence foreground tree range has been established, to fill the trunk surface for multi-row boundary estimation. This prevents distant outdoor background depth from being mistaken for the trunk.
 
 
-## 0.1.5 diagnostic sweep
+## 0.1.6 diagnostic sweep
 
-Version 0.1.5 keeps the 0.1.4 Raw Depth DBH acceptance geometry unchanged and adds compact native sweep diagnostics. `captureDbhSweep()` now reports per-stage frame counts and `nativeRejectionCounts` so zero-observation field failures can be diagnosed without retaining camera or depth frames.
+Version 0.1.6 keeps the 0.1.4 Raw Depth DBH acceptance geometry unchanged and adds compact native sweep diagnostics. `captureDbhSweep()` now reports per-stage frame counts and `nativeRejectionCounts` so zero-observation field failures can be diagnosed without retaining camera or depth frames.
+
+
+## 0.1.6 Raw Depth anchor diagnostics
+
+0.1.6 keeps the 0.1.5 DBH acceptance algorithm unchanged and adds compact numeric diagnostics around the mapped crosshair at 10, 20 and 30 pixel radii. It reports non-zero/in-range Raw Depth counts, confidence threshold counts (64/96/128/160), the highest confidence in the eligible 0.5–5 m range and the associated depth. These diagnostics do not influence the accepted DBH result.

package/android/src/main/java/org/drawdown/arcoredepth/DepthObservationSampler.java

@@ -47,11 +47,12 @@ final class DepthObservationSampler {
         boolean rawPatchReached = false;
         boolean smoothDepthMatchReached = false;
         boolean boundaryConsensusReached = false;
+        RawAnchorDiagnostics rawAnchorDiagnostics = null;
 
         if (camera.getTrackingState() != TrackingState.TRACKING) {
             return DepthSampleResult.failure(
                     "tracking_not_tracking",
-                    false, false, false, false, false, false, false);
+                    false, false, false, false, false, false, false, rawAnchorDiagnostics);
         }
         trackingFrame = true;
 
@@ -65,7 +66,7 @@ final class DepthObservationSampler {
             } catch (NotYetAvailableException e) {
                 return DepthSampleResult.failure(
                         "raw_depth_not_yet_available",
-                        trackingFrame, false, false, false, false, false, false);
+                        trackingFrame, false, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
             try {
@@ -73,7 +74,7 @@ final class DepthObservationSampler {
             } catch (NotYetAvailableException e) {
                 return DepthSampleResult.failure(
                         "raw_confidence_not_available",
-                        trackingFrame, rawDepthFrame, false, false, false, false, false);
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
             try {
@@ -81,7 +82,7 @@ final class DepthObservationSampler {
             } catch (NotYetAvailableException e) {
                 return DepthSampleResult.failure(
                         "smooth_depth_not_available",
-                        trackingFrame, rawDepthFrame, false, false, false, false, false);
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
             CameraIntrinsics intrinsics = camera.getImageIntrinsics();
@@ -90,18 +91,18 @@ final class DepthObservationSampler {
             if (focal == null || focal.length < 2 || imageDimensions == null || imageDimensions.length < 2) {
                 return DepthSampleResult.failure(
                         "image_intrinsics_missing",
-                        trackingFrame, rawDepthFrame, false, false, false, false, false);
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
-            // Keep the 0.1.4 geometry assumptions unchanged; 0.1.5 only makes
-            // failures observable instead of silently returning null.
+            // Keep the 0.1.5 measurement geometry/thresholds unchanged; 0.1.6 only adds
+            // Raw Depth anchor diagnostics around the mapped crosshair.
             if (rawDepth.getWidth() != rawConfidence.getWidth()
                     || rawDepth.getHeight() != rawConfidence.getHeight()
                     || rawDepth.getWidth() != smoothDepth.getWidth()
                     || rawDepth.getHeight() != smoothDepth.getHeight()) {
                 return DepthSampleResult.failure(
                         "image_size_mismatch",
-                        trackingFrame, rawDepthFrame, false, false, false, false, false);
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
             float[] viewCenter = new float[] { viewWidth / 2f, viewHeight / 2f };
@@ -116,15 +117,17 @@ final class DepthObservationSampler {
             if (mappedCenter == null) {
                 return DepthSampleResult.failure(
                         "image_to_depth_mapping_failed",
-                        trackingFrame, rawDepthFrame, false, false, false, false, false);
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
             mappedCenterReached = true;
+            rawAnchorDiagnostics = collectRawAnchorDiagnostics(
+                    rawDepth, rawConfidence, mappedCenter[0], mappedCenter[1]);
 
             RawAnchor anchor = findRawAnchor(rawDepth, rawConfidence, mappedCenter[0], mappedCenter[1]);
             if (anchor == null) {
                 return DepthSampleResult.failure(
                         "no_confident_raw_anchor",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, false, false, false, false);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, false, false, false, false, rawAnchorDiagnostics);
             }
             rawAnchorReached = true;
 
@@ -140,7 +143,7 @@ final class DepthObservationSampler {
             if (rawPatch.size() < MIN_RAW_PATCH_SAMPLES) {
                 return DepthSampleResult.failure(
                         "insufficient_raw_patch_samples",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, false, false, false);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, false, false, false, rawAnchorDiagnostics);
             }
             rawPatchReached = true;
 
@@ -149,7 +152,7 @@ final class DepthObservationSampler {
             if (centerDepthMm < MIN_TARGET_DEPTH_MM || centerDepthMm > MAX_TARGET_DEPTH_MM) {
                 return DepthSampleResult.failure(
                         "target_depth_out_of_range",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false, rawAnchorDiagnostics);
             }
 
             // Locate the foreground surface in the smoothed depth image, but only
@@ -164,7 +167,7 @@ final class DepthObservationSampler {
             if (centerX < 0) {
                 return DepthSampleResult.failure(
                         "no_smooth_depth_match",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false, rawAnchorDiagnostics);
             }
             smoothDepthMatchReached = true;
 
@@ -178,7 +181,7 @@ final class DepthObservationSampler {
             if (boundary == null || boundary.rightX - boundary.leftX < 3) {
                 return DepthSampleResult.failure(
                         "boundary_no_consensus",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, false);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, false, rawAnchorDiagnostics);
             }
             boundaryConsensusReached = true;
 
@@ -188,12 +191,12 @@ final class DepthObservationSampler {
                     || boundary.rightX >= depthWidth - 1 - EDGE_MARGIN_PX) {
                 return DepthSampleResult.failure(
                         "boundary_touches_edge",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
             if (boundaryWidth > depthWidth * MAX_TRUNK_WIDTH_FRACTION) {
                 return DepthSampleResult.failure(
                         "boundary_too_wide",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             float[] leftImage = depthToImage(frame, smoothDepth, boundary.leftX, anchor.y);
@@ -201,7 +204,7 @@ final class DepthObservationSampler {
             if (leftImage == null || rightImage == null) {
                 return DepthSampleResult.failure(
                         "depth_to_image_mapping_failed",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double dx = rightImage[0] - leftImage[0];
@@ -210,7 +213,7 @@ final class DepthObservationSampler {
             if (!Double.isFinite(imageWidthPx) || imageWidthPx < 8.0) {
                 return DepthSampleResult.failure(
                         "image_width_too_small",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double normalizedAngularWidth = Math.sqrt(
@@ -221,7 +224,7 @@ final class DepthObservationSampler {
                     || normalizedAngularWidth > 0.95) {
                 return DepthSampleResult.failure(
                         "angular_width_invalid",
-                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached);
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double effectiveFocalPx = imageWidthPx / normalizedAngularWidth;
@@ -256,7 +259,7 @@ final class DepthObservationSampler {
                     boundaryConfidence,
                     centerMadMm / 1000.0,
                     System.currentTimeMillis());
-            return DepthSampleResult.success(observation);
+            return DepthSampleResult.success(observation, rawAnchorDiagnostics);
         } catch (Exception e) {
             return DepthSampleResult.failure(
                     "unexpected_exception",
@@ -266,7 +269,8 @@ final class DepthObservationSampler {
                     rawAnchorReached,
                     rawPatchReached,
                     smoothDepthMatchReached,
-                    boundaryConsensusReached);
+                    boundaryConsensusReached,
+                    rawAnchorDiagnostics);
         } finally {
             if (smoothDepth != null) smoothDepth.close();
             if (rawConfidence != null) rawConfidence.close();
@@ -274,6 +278,77 @@ final class DepthObservationSampler {
         }
     }
 
+    private static RawAnchorDiagnostics collectRawAnchorDiagnostics(
+            Image rawDepth,
+            Image confidence,
+            int centerX,
+            int centerY) {
+        RawAnchorDiagnostics.RadiusDiagnostics radius10 = scanRawRadius(rawDepth, confidence, centerX, centerY, 10);
+        RawAnchorDiagnostics.RadiusDiagnostics radius20 = scanRawRadius(rawDepth, confidence, centerX, centerY, 20);
+        RawAnchorDiagnostics.RadiusDiagnostics radius30 = scanRawRadius(rawDepth, confidence, centerX, centerY, 30);
+        return new RawAnchorDiagnostics(
+                centerX,
+                centerY,
+                rawDepth.getWidth(),
+                rawDepth.getHeight(),
+                radius10,
+                radius20,
+                radius30);
+    }
+
+    private static RawAnchorDiagnostics.RadiusDiagnostics scanRawRadius(
+            Image rawDepth,
+            Image confidence,
+            int centerX,
+            int centerY,
+            int radius) {
+        int sampled = 0;
+        int nonZero = 0;
+        int inRange = 0;
+        int atLeast64 = 0;
+        int atLeast96 = 0;
+        int atLeast128 = 0;
+        int atLeast160 = 0;
+        int maxConfidenceInRange = 0;
+        int depthAtMaxConfidence = 0;
+
+        for (int y = Math.max(0, centerY - radius);
+             y <= Math.min(rawDepth.getHeight() - 1, centerY + radius);
+             y++) {
+            for (int x = Math.max(0, centerX - radius);
+                 x <= Math.min(rawDepth.getWidth() - 1, centerX + radius);
+                 x++) {
+                sampled += 1;
+                int depthMm = getDepthMm(rawDepth, x, y);
+                if (depthMm <= 0) continue;
+                nonZero += 1;
+                if (depthMm < MIN_TARGET_DEPTH_MM || depthMm > MAX_TARGET_DEPTH_MM) continue;
+                inRange += 1;
+                int conf = getConfidence(confidence, x, y);
+                if (conf >= 64) atLeast64 += 1;
+                if (conf >= 96) atLeast96 += 1;
+                if (conf >= 128) atLeast128 += 1;
+                if (conf >= 160) atLeast160 += 1;
+                if (conf > maxConfidenceInRange) {
+                    maxConfidenceInRange = conf;
+                    depthAtMaxConfidence = depthMm;
+                }
+            }
+        }
+
+        return new RawAnchorDiagnostics.RadiusDiagnostics(
+                radius,
+                sampled,
+                nonZero,
+                inRange,
+                atLeast64,
+                atLeast96,
+                atLeast128,
+                atLeast160,
+                maxConfidenceInRange,
+                depthAtMaxConfidence);
+    }
+
     private static RawAnchor findRawAnchor(Image rawDepth, Image confidence, int centerX, int centerY) {
         RawAnchor best = null;
         double bestScore = Double.POSITIVE_INFINITY;

package/android/src/main/java/org/drawdown/arcoredepth/DepthSampleResult.java

@@ -15,6 +15,7 @@ final class DepthSampleResult {
     final boolean rawPatch;
     final boolean smoothDepthMatch;
     final boolean boundaryConsensus;
+    final RawAnchorDiagnostics rawAnchorDiagnostics;
 
     DepthSampleResult(
             DepthObservation observation,
@@ -25,7 +26,8 @@ final class DepthSampleResult {
             boolean rawAnchor,
             boolean rawPatch,
             boolean smoothDepthMatch,
-            boolean boundaryConsensus) {
+            boolean boundaryConsensus,
+            RawAnchorDiagnostics rawAnchorDiagnostics) {
         this.observation = observation;
         this.rejectionReason = rejectionReason;
         this.trackingFrame = trackingFrame;
@@ -35,6 +37,7 @@ final class DepthSampleResult {
         this.rawPatch = rawPatch;
         this.smoothDepthMatch = smoothDepthMatch;
         this.boundaryConsensus = boundaryConsensus;
+        this.rawAnchorDiagnostics = rawAnchorDiagnostics;
     }
 
     static DepthSampleResult failure(
@@ -45,7 +48,8 @@ final class DepthSampleResult {
             boolean rawAnchor,
             boolean rawPatch,
             boolean smoothDepthMatch,
-            boolean boundaryConsensus) {
+            boolean boundaryConsensus,
+            RawAnchorDiagnostics rawAnchorDiagnostics) {
         return new DepthSampleResult(
                 null,
                 reason,
@@ -55,10 +59,11 @@ final class DepthSampleResult {
                 rawAnchor,
                 rawPatch,
                 smoothDepthMatch,
-                boundaryConsensus);
+                boundaryConsensus,
+                rawAnchorDiagnostics);
     }
 
-    static DepthSampleResult success(DepthObservation observation) {
-        return new DepthSampleResult(observation, null, true, true, true, true, true, true, true);
+    static DepthSampleResult success(DepthObservation observation, RawAnchorDiagnostics rawAnchorDiagnostics) {
+        return new DepthSampleResult(observation, null, true, true, true, true, true, true, true, rawAnchorDiagnostics);
     }
 }

package/android/src/main/java/org/drawdown/arcoredepth/DrawDownArCoreDepthPlugin.java

@@ -46,8 +46,8 @@ import java.util.Map;
                 @Permission(alias = "camera", strings = { Manifest.permission.CAMERA })
         })
 public class DrawDownArCoreDepthPlugin extends Plugin {
-    private static final String PLUGIN_VERSION = "0.1.5";
-    private static final String METHOD_VERSION = "arcore-raw-depth-cylinder-v4-diagnostics";
+    private static final String PLUGIN_VERSION = "0.1.6";
+    private static final String METHOD_VERSION = "arcore-raw-depth-cylinder-v5-anchor-diagnostics";
     private static final long WARMUP_MS = 1200L;
 
     private final Handler mainHandler = new Handler(Looper.getMainLooper());
@@ -72,6 +72,7 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
     private int minObservations = 5;
     private final List<DepthObservation> sweepObservations = new ArrayList<>();
     private final Map<String, Integer> sweepRejectionCounts = new LinkedHashMap<>();
+    private final List<RawAnchorDiagnostics> sweepRawAnchorDiagnostics = new ArrayList<>();
     private int totalFrameCount = 0;
     private int trackingFrameCount = 0;
     private int rawDepthFrameCount = 0;
@@ -264,6 +265,7 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             pendingSweepCall = call;
             sweepObservations.clear();
             sweepRejectionCounts.clear();
+            sweepRawAnchorDiagnostics.clear();
             totalFrameCount = 0;
             trackingFrameCount = 0;
             rawDepthFrameCount = 0;
@@ -408,6 +410,9 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
                 if (sampleResult.rawPatch) rawPatchCount += 1;
                 if (sampleResult.smoothDepthMatch) smoothDepthMatchCount += 1;
                 if (sampleResult.boundaryConsensus) boundaryConsensusCount += 1;
+                if (sampleResult.rawAnchorDiagnostics != null) {
+                    sweepRawAnchorDiagnostics.add(sampleResult.rawAnchorDiagnostics);
+                }
 
                 if (sampleResult.rejectionReason != null) {
                     int current = sweepRejectionCounts.containsKey(sampleResult.rejectionReason)
@@ -440,6 +445,7 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
         PluginCall sweepCall;
         List<DepthObservation> observations;
         Map<String, Integer> rejectionCounts;
+        List<RawAnchorDiagnostics> rawAnchorDiagnostics;
         int framesTotal;
         int framesTracking;
         int framesRawDepth;
@@ -458,6 +464,7 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             sweepActive = false;
             observations = new ArrayList<>(sweepObservations);
             rejectionCounts = new LinkedHashMap<>(sweepRejectionCounts);
+            rawAnchorDiagnostics = new ArrayList<>(sweepRawAnchorDiagnostics);
             framesTotal = totalFrameCount;
             framesTracking = trackingFrameCount;
             framesRawDepth = rawDepthFrameCount;
@@ -468,6 +475,7 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             boundariesConsensus = boundaryConsensusCount;
             sweepObservations.clear();
             sweepRejectionCounts.clear();
+            sweepRawAnchorDiagnostics.clear();
         }
 
         JSArray observationArray = new JSArray();
@@ -480,6 +488,12 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             rejectionObject.put(entry.getKey(), entry.getValue());
         }
 
+        JSArray rawDiagnosticArray = new JSArray();
+        for (RawAnchorDiagnostics diagnostics : rawAnchorDiagnostics) {
+            rawDiagnosticArray.put(diagnostics.toJsObject());
+        }
+        JSObject rawDiagnosticSummary = buildRawAnchorDiagnosticSummary(rawAnchorDiagnostics);
+
         JSObject result = new JSObject();
         result.put("observations", observationArray);
         result.put("deviceModel", Build.MANUFACTURER + " " + Build.MODEL);
@@ -498,6 +512,8 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
         result.put("boundaryConsensusCount", boundariesConsensus);
         result.put("nativeValidObservationCount", observations.size());
         result.put("nativeRejectionCounts", rejectionObject);
+        result.put("rawAnchorDiagnostics", rawDiagnosticArray);
+        result.put("rawAnchorDiagnosticSummary", rawDiagnosticSummary);
         sweepCall.resolve(result);
 
         if (!stoppedByCaller) {
@@ -507,6 +523,93 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
         }
     }
 
+    private static JSObject buildRawAnchorDiagnosticSummary(List<RawAnchorDiagnostics> diagnostics) {
+        JSObject summary = new JSObject();
+        summary.put("frameCount", diagnostics.size());
+        if (diagnostics.isEmpty()) {
+            return summary;
+        }
+
+        int minX = Integer.MAX_VALUE;
+        int maxX = Integer.MIN_VALUE;
+        int minY = Integer.MAX_VALUE;
+        int maxY = Integer.MIN_VALUE;
+        int rawWidth = 0;
+        int rawHeight = 0;
+
+        for (RawAnchorDiagnostics item : diagnostics) {
+            minX = Math.min(minX, item.centerX);
+            maxX = Math.max(maxX, item.centerX);
+            minY = Math.min(minY, item.centerY);
+            maxY = Math.max(maxY, item.centerY);
+            rawWidth = item.imageWidth;
+            rawHeight = item.imageHeight;
+        }
+
+        summary.put("mappedCenterMinX", minX);
+        summary.put("mappedCenterMaxX", maxX);
+        summary.put("mappedCenterMinY", minY);
+        summary.put("mappedCenterMaxY", maxY);
+        summary.put("rawDepthWidth", rawWidth);
+        summary.put("rawDepthHeight", rawHeight);
+        summary.put("radius10", summarizeRawRadius(diagnostics, 10));
+        summary.put("radius20", summarizeRawRadius(diagnostics, 20));
+        summary.put("radius30", summarizeRawRadius(diagnostics, 30));
+        return summary;
+    }
+
+    private static JSObject summarizeRawRadius(List<RawAnchorDiagnostics> diagnostics, int radius) {
+        long totalSampled = 0L;
+        long totalNonZero = 0L;
+        long totalInRange = 0L;
+        long total64 = 0L;
+        long total96 = 0L;
+        long total128 = 0L;
+        long total160 = 0L;
+        int frames64 = 0;
+        int frames96 = 0;
+        int frames128 = 0;
+        int frames160 = 0;
+        int maxConfidence = 0;
+        int depthAtMaxConfidence = 0;
+
+        for (RawAnchorDiagnostics item : diagnostics) {
+            RawAnchorDiagnostics.RadiusDiagnostics r = item.forRadius(radius);
+            totalSampled += r.sampledPixelCount;
+            totalNonZero += r.nonZeroDepthCount;
+            totalInRange += r.inRangeDepthCount;
+            total64 += r.confidenceAtLeast64Count;
+            total96 += r.confidenceAtLeast96Count;
+            total128 += r.confidenceAtLeast128Count;
+            total160 += r.confidenceAtLeast160Count;
+            if (r.confidenceAtLeast64Count > 0) frames64 += 1;
+            if (r.confidenceAtLeast96Count > 0) frames96 += 1;
+            if (r.confidenceAtLeast128Count > 0) frames128 += 1;
+            if (r.confidenceAtLeast160Count > 0) frames160 += 1;
+            if (r.maxConfidenceInRange > maxConfidence) {
+                maxConfidence = r.maxConfidenceInRange;
+                depthAtMaxConfidence = r.depthMmAtMaxConfidenceInRange;
+            }
+        }
+
+        JSObject obj = new JSObject();
+        obj.put("radiusPx", radius);
+        obj.put("totalSampledPixelCount", totalSampled);
+        obj.put("totalNonZeroDepthCount", totalNonZero);
+        obj.put("totalInRangeDepthCount", totalInRange);
+        obj.put("totalConfidenceAtLeast64Count", total64);
+        obj.put("totalConfidenceAtLeast96Count", total96);
+        obj.put("totalConfidenceAtLeast128Count", total128);
+        obj.put("totalConfidenceAtLeast160Count", total160);
+        obj.put("framesWithConfidenceAtLeast64", frames64);
+        obj.put("framesWithConfidenceAtLeast96", frames96);
+        obj.put("framesWithConfidenceAtLeast128", frames128);
+        obj.put("framesWithConfidenceAtLeast160", frames160);
+        obj.put("maxConfidenceInRange", maxConfidence);
+        obj.put("depthMmAtMaxConfidenceInRange", depthAtMaxConfidence);
+        return obj;
+    }
+
     private void cleanupSession() {
         sweepActive = false;
 

package/android/src/main/java/org/drawdown/arcoredepth/RawAnchorDiagnostics.java

@@ -0,0 +1,106 @@
+package org.drawdown.arcoredepth;
+
+import com.getcapacitor.JSObject;
+
+/**
+ * Compact numeric diagnostics describing Raw Depth around the mapped crosshair.
+ * These values never influence the accepted DBH measurement; they exist only
+ * to distinguish confidence-threshold failures from coordinate/search failures.
+ */
+final class RawAnchorDiagnostics {
+    static final int[] RADII = new int[] { 10, 20, 30 };
+
+    final int centerX;
+    final int centerY;
+    final int imageWidth;
+    final int imageHeight;
+    final RadiusDiagnostics radius10;
+    final RadiusDiagnostics radius20;
+    final RadiusDiagnostics radius30;
+
+    RawAnchorDiagnostics(
+            int centerX,
+            int centerY,
+            int imageWidth,
+            int imageHeight,
+            RadiusDiagnostics radius10,
+            RadiusDiagnostics radius20,
+            RadiusDiagnostics radius30) {
+        this.centerX = centerX;
+        this.centerY = centerY;
+        this.imageWidth = imageWidth;
+        this.imageHeight = imageHeight;
+        this.radius10 = radius10;
+        this.radius20 = radius20;
+        this.radius30 = radius30;
+    }
+
+    RadiusDiagnostics forRadius(int radius) {
+        if (radius == 10) return radius10;
+        if (radius == 20) return radius20;
+        return radius30;
+    }
+
+    JSObject toJsObject() {
+        JSObject obj = new JSObject();
+        obj.put("mappedCenterX", centerX);
+        obj.put("mappedCenterY", centerY);
+        obj.put("rawDepthWidth", imageWidth);
+        obj.put("rawDepthHeight", imageHeight);
+        obj.put("radius10", radius10.toJsObject());
+        obj.put("radius20", radius20.toJsObject());
+        obj.put("radius30", radius30.toJsObject());
+        return obj;
+    }
+
+    static final class RadiusDiagnostics {
+        final int radiusPx;
+        final int sampledPixelCount;
+        final int nonZeroDepthCount;
+        final int inRangeDepthCount;
+        final int confidenceAtLeast64Count;
+        final int confidenceAtLeast96Count;
+        final int confidenceAtLeast128Count;
+        final int confidenceAtLeast160Count;
+        final int maxConfidenceInRange;
+        final int depthMmAtMaxConfidenceInRange;
+
+        RadiusDiagnostics(
+                int radiusPx,
+                int sampledPixelCount,
+                int nonZeroDepthCount,
+                int inRangeDepthCount,
+                int confidenceAtLeast64Count,
+                int confidenceAtLeast96Count,
+                int confidenceAtLeast128Count,
+                int confidenceAtLeast160Count,
+                int maxConfidenceInRange,
+                int depthMmAtMaxConfidenceInRange) {
+            this.radiusPx = radiusPx;
+            this.sampledPixelCount = sampledPixelCount;
+            this.nonZeroDepthCount = nonZeroDepthCount;
+            this.inRangeDepthCount = inRangeDepthCount;
+            this.confidenceAtLeast64Count = confidenceAtLeast64Count;
+            this.confidenceAtLeast96Count = confidenceAtLeast96Count;
+            this.confidenceAtLeast128Count = confidenceAtLeast128Count;
+            this.confidenceAtLeast160Count = confidenceAtLeast160Count;
+            this.maxConfidenceInRange = maxConfidenceInRange;
+            this.depthMmAtMaxConfidenceInRange = depthMmAtMaxConfidenceInRange;
+        }
+
+        JSObject toJsObject() {
+            JSObject obj = new JSObject();
+            obj.put("radiusPx", radiusPx);
+            obj.put("sampledPixelCount", sampledPixelCount);
+            obj.put("nonZeroDepthCount", nonZeroDepthCount);
+            obj.put("inRangeDepthCount", inRangeDepthCount);
+            obj.put("confidenceAtLeast64Count", confidenceAtLeast64Count);
+            obj.put("confidenceAtLeast96Count", confidenceAtLeast96Count);
+            obj.put("confidenceAtLeast128Count", confidenceAtLeast128Count);
+            obj.put("confidenceAtLeast160Count", confidenceAtLeast160Count);
+            obj.put("maxConfidenceInRange", maxConfidenceInRange);
+            obj.put("depthMmAtMaxConfidenceInRange", depthMmAtMaxConfidenceInRange);
+            return obj;
+        }
+    }
+}

package/dist/esm/definitions.d.ts

@@ -1,66 +1,129 @@
 export type ArcoreRangeSource = 'arcore_depth16' | 'arcore_raw_depth' | 'arcore_surface_hit';
 export type BoundaryConfidence = 'high' | 'medium' | 'low';
+
 export interface SupportResult {
-    isSupported: boolean;
-    hasDepthApi: boolean;
-    pluginVersion?: string;
-    message?: string;
+  isSupported: boolean;
+  hasDepthApi: boolean;
+  pluginVersion?: string;
+  message?: string;
 }
+
 export interface StartDbhSessionOptions {
-    /** RFID/NFC tree tag is the field anchor that identifies the 1.3 m DBH plane. */
-    anchorType?: 'rfid_tag';
-    targetHeightM: 1.3;
-    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
-    markerDictionary?: 'DICT_6X6_250';
-    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
-    markerId?: 0;
-    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
-    markerSizeCm?: 10;
+  /** RFID/NFC tree tag is the field anchor that identifies the 1.3 m DBH plane. */
+  anchorType?: 'rfid_tag';
+  targetHeightM: 1.3;
+  /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+  markerDictionary?: 'DICT_6X6_250';
+  /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+  markerId?: 0;
+  /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+  markerSizeCm?: 10;
 }
+
 export interface StartDbhSessionResult {
-    started: boolean;
-    installationRequested?: boolean;
-    message?: string;
+  started: boolean;
+  installationRequested?: boolean;
+  message?: string;
 }
+
 export interface CaptureDbhSweepOptions {
-    durationMs: number;
-    minObservations: number;
-    maxObservations: number;
-    retainFrames: false;
+  durationMs: number;
+  minObservations: number;
+  maxObservations: number;
+  retainFrames: false;
 }
+
 export interface DbhObservation {
-    frontSurfaceDepthM: number;
-    /** Effective focal length in pixels along the measured trunk-width axis. */
-    focalLengthXPx: number;
-    /** Trunk tangent-to-tangent apparent width in corresponding image pixels. */
-    trunkWidthPx: number;
-    rangeSource: ArcoreRangeSource;
-    trackingConfidence?: number;
-    boundaryConfidence?: BoundaryConfidence;
-    depthMadM?: number;
-    timestampMs?: number;
+  frontSurfaceDepthM: number;
+  /** Effective focal length in pixels along the measured trunk-width axis. */
+  focalLengthXPx: number;
+  /** Trunk tangent-to-tangent apparent width in corresponding image pixels. */
+  trunkWidthPx: number;
+  rangeSource: ArcoreRangeSource;
+  trackingConfidence?: number;
+  boundaryConfidence?: BoundaryConfidence;
+  depthMadM?: number;
+  timestampMs?: number;
 }
+
+export interface RawAnchorRadiusDiagnostics {
+  radiusPx: number;
+  sampledPixelCount: number;
+  nonZeroDepthCount: number;
+  inRangeDepthCount: number;
+  confidenceAtLeast64Count: number;
+  confidenceAtLeast96Count: number;
+  confidenceAtLeast128Count: number;
+  confidenceAtLeast160Count: number;
+  maxConfidenceInRange: number;
+  depthMmAtMaxConfidenceInRange: number;
+}
+
+export interface RawAnchorFrameDiagnostics {
+  mappedCenterX: number;
+  mappedCenterY: number;
+  rawDepthWidth: number;
+  rawDepthHeight: number;
+  radius10: RawAnchorRadiusDiagnostics;
+  radius20: RawAnchorRadiusDiagnostics;
+  radius30: RawAnchorRadiusDiagnostics;
+}
+
+export interface RawAnchorRadiusSummary {
+  radiusPx: number;
+  totalSampledPixelCount: number;
+  totalNonZeroDepthCount: number;
+  totalInRangeDepthCount: number;
+  totalConfidenceAtLeast64Count: number;
+  totalConfidenceAtLeast96Count: number;
+  totalConfidenceAtLeast128Count: number;
+  totalConfidenceAtLeast160Count: number;
+  framesWithConfidenceAtLeast64: number;
+  framesWithConfidenceAtLeast96: number;
+  framesWithConfidenceAtLeast128: number;
+  framesWithConfidenceAtLeast160: number;
+  maxConfidenceInRange: number;
+  depthMmAtMaxConfidenceInRange: number;
+}
+
+export interface RawAnchorDiagnosticSummary {
+  frameCount: number;
+  mappedCenterMinX?: number;
+  mappedCenterMaxX?: number;
+  mappedCenterMinY?: number;
+  mappedCenterMaxY?: number;
+  rawDepthWidth?: number;
+  rawDepthHeight?: number;
+  radius10?: RawAnchorRadiusSummary;
+  radius20?: RawAnchorRadiusSummary;
+  radius30?: RawAnchorRadiusSummary;
+}
+
 export interface CaptureDbhSweepResult {
-    observations: DbhObservation[];
-    deviceModel?: string;
-    arcoreVersion?: string;
-    pluginVersion?: string;
-    methodVersion?: string;
-    totalFrameCount?: number;
-    trackingFrameCount?: number;
-    rawDepthFrameCount?: number;
-    mappedCenterCount?: number;
-    rawAnchorCount?: number;
-    rawPatchCount?: number;
-    smoothDepthMatchCount?: number;
-    boundaryConsensusCount?: number;
-    nativeValidObservationCount?: number;
-    nativeRejectionCounts?: Record<string, number>;
+  observations: DbhObservation[];
+  deviceModel?: string;
+  arcoreVersion?: string;
+  pluginVersion?: string;
+  methodVersion?: string;
+  totalFrameCount?: number;
+  trackingFrameCount?: number;
+  rawDepthFrameCount?: number;
+  mappedCenterCount?: number;
+  rawAnchorCount?: number;
+  rawPatchCount?: number;
+  smoothDepthMatchCount?: number;
+  boundaryConsensusCount?: number;
+  nativeValidObservationCount?: number;
+  nativeRejectionCounts?: Record<string, number>;
+  rawAnchorDiagnostics?: RawAnchorFrameDiagnostics[];
+  rawAnchorDiagnosticSummary?: RawAnchorDiagnosticSummary;
 }
+
 export interface DrawDownArCoreDepthPlugin {
-    checkSupport(): Promise<SupportResult>;
-    startDbhSession(options: StartDbhSessionOptions): Promise<StartDbhSessionResult>;
-    captureDbhSweep(options: CaptureDbhSweepOptions): Promise<CaptureDbhSweepResult>;
-    stopDbhSession(): Promise<void>;
+  checkSupport(): Promise<SupportResult>;
+  startDbhSession(options: StartDbhSessionOptions): Promise<StartDbhSessionResult>;
+  captureDbhSweep(options: CaptureDbhSweepOptions): Promise<CaptureDbhSweepResult>;
+  stopDbhSession(): Promise<void>;
 }
-//# sourceMappingURL=definitions.d.ts.map
+
+//# sourceMappingURL=definitions.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "drawdown-arcore-depth",
-  "version": "0.1.5",
-  "description": "Small Android-only Capacitor 8 bridge for ARCore Raw Depth DBH observations with native sweep diagnostics.",
+  "version": "0.1.6",
+  "description": "Small Android-only Capacitor 8 bridge for ARCore Raw Depth DBH observations with native Raw Depth anchor diagnostics.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",