drawdown-arcore-depth 0.1.4 → 0.1.6

package/README.md

@@ -188,3 +188,13 @@ No ArUco marker is required by the native ARCore workflow. The existing RFID/NFC
 ## v0.1.4 Raw Depth field fix
 
 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.6 diagnostic sweep
+
+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

@@ -39,29 +39,70 @@ final class DepthObservationSampler {
     private static final double MIN_TARGET_DEPTH_MM = 500.0;
     private static final double MAX_TARGET_DEPTH_MM = 5000.0;
 
-    DepthObservation sample(Frame frame, Camera camera, int viewWidth, int viewHeight) {
+    DepthSampleResult sample(Frame frame, Camera camera, int viewWidth, int viewHeight) {
+        boolean trackingFrame = false;
+        boolean rawDepthFrame = false;
+        boolean mappedCenterReached = false;
+        boolean rawAnchorReached = false;
+        boolean rawPatchReached = false;
+        boolean smoothDepthMatchReached = false;
+        boolean boundaryConsensusReached = false;
+        RawAnchorDiagnostics rawAnchorDiagnostics = null;
+
         if (camera.getTrackingState() != TrackingState.TRACKING) {
-            return null;
+            return DepthSampleResult.failure(
+                    "tracking_not_tracking",
+                    false, false, false, false, false, false, false, rawAnchorDiagnostics);
         }
+        trackingFrame = true;
+
+        Image rawDepth = null;
+        Image rawConfidence = null;
+        Image smoothDepth = null;
+        try {
+            try {
+                rawDepth = frame.acquireRawDepthImage16Bits();
+                rawDepthFrame = true;
+            } catch (NotYetAvailableException e) {
+                return DepthSampleResult.failure(
+                        "raw_depth_not_yet_available",
+                        trackingFrame, false, false, false, false, false, false, rawAnchorDiagnostics);
+            }
 
-        try (
-                Image rawDepth = frame.acquireRawDepthImage16Bits();
-                Image rawConfidence = frame.acquireRawDepthConfidenceImage();
-                Image smoothDepth = frame.acquireDepthImage16Bits()) {
+            try {
+                rawConfidence = frame.acquireRawDepthConfidenceImage();
+            } catch (NotYetAvailableException e) {
+                return DepthSampleResult.failure(
+                        "raw_confidence_not_available",
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
+            }
+
+            try {
+                smoothDepth = frame.acquireDepthImage16Bits();
+            } catch (NotYetAvailableException e) {
+                return DepthSampleResult.failure(
+                        "smooth_depth_not_available",
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
+            }
 
             CameraIntrinsics intrinsics = camera.getImageIntrinsics();
             float[] focal = intrinsics.getFocalLength();
             int[] imageDimensions = intrinsics.getImageDimensions();
             if (focal == null || focal.length < 2 || imageDimensions == null || imageDimensions.length < 2) {
-                return null;
+                return DepthSampleResult.failure(
+                        "image_intrinsics_missing",
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
-            // ARCore documents raw depth, confidence and smoothed depth as the same size.
+            // 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 null;
+                return DepthSampleResult.failure(
+                        "image_size_mismatch",
+                        trackingFrame, rawDepthFrame, false, false, false, false, false, rawAnchorDiagnostics);
             }
 
             float[] viewCenter = new float[] { viewWidth / 2f, viewHeight / 2f };
@@ -74,13 +115,21 @@ final class DepthObservationSampler {
 
             int[] mappedCenter = imageToDepth(frame, rawDepth, imageCenter[0], imageCenter[1]);
             if (mappedCenter == null) {
-                return null;
+                return DepthSampleResult.failure(
+                        "image_to_depth_mapping_failed",
+                        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 null;
+                return DepthSampleResult.failure(
+                        "no_confident_raw_anchor",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, false, false, false, false, rawAnchorDiagnostics);
             }
+            rawAnchorReached = true;
 
             double rawToleranceMm = clamp(anchor.depthMm * 0.10, 100.0, 250.0);
             List<Integer> rawPatch = collectConfidentRawPatch(
@@ -92,13 +141,18 @@ final class DepthObservationSampler {
                     rawToleranceMm,
                     anchor.depthMm);
             if (rawPatch.size() < MIN_RAW_PATCH_SAMPLES) {
-                return null;
+                return DepthSampleResult.failure(
+                        "insufficient_raw_patch_samples",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, false, false, false, rawAnchorDiagnostics);
             }
+            rawPatchReached = true;
 
             double centerDepthMm = median(rawPatch);
             double centerMadMm = mad(rawPatch, centerDepthMm);
             if (centerDepthMm < MIN_TARGET_DEPTH_MM || centerDepthMm > MAX_TARGET_DEPTH_MM) {
-                return null;
+                return DepthSampleResult.failure(
+                        "target_depth_out_of_range",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false, rawAnchorDiagnostics);
             }
 
             // Locate the foreground surface in the smoothed depth image, but only
@@ -111,8 +165,11 @@ final class DepthObservationSampler {
                     centerDepthMm,
                     clamp(centerDepthMm * 0.10, 100.0, 250.0));
             if (centerX < 0) {
-                return null;
+                return DepthSampleResult.failure(
+                        "no_smooth_depth_match",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, false, false, rawAnchorDiagnostics);
             }
+            smoothDepthMatchReached = true;
 
             double toleranceMm = clamp(centerDepthMm * 0.08, 80.0, 220.0);
             Boundary boundary = findConsensusBoundary(
@@ -122,28 +179,41 @@ final class DepthObservationSampler {
                     centerDepthMm,
                     toleranceMm);
             if (boundary == null || boundary.rightX - boundary.leftX < 3) {
-                return null;
+                return DepthSampleResult.failure(
+                        "boundary_no_consensus",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, false, rawAnchorDiagnostics);
             }
+            boundaryConsensusReached = true;
 
             int depthWidth = smoothDepth.getWidth();
             int boundaryWidth = boundary.rightX - boundary.leftX;
             if (boundary.leftX <= EDGE_MARGIN_PX
-                    || boundary.rightX >= depthWidth - 1 - EDGE_MARGIN_PX
-                    || boundaryWidth > depthWidth * MAX_TRUNK_WIDTH_FRACTION) {
-                return null;
+                    || boundary.rightX >= depthWidth - 1 - EDGE_MARGIN_PX) {
+                return DepthSampleResult.failure(
+                        "boundary_touches_edge",
+                        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, rawAnchorDiagnostics);
             }
 
             float[] leftImage = depthToImage(frame, smoothDepth, boundary.leftX, anchor.y);
             float[] rightImage = depthToImage(frame, smoothDepth, boundary.rightX, anchor.y);
             if (leftImage == null || rightImage == null) {
-                return null;
+                return DepthSampleResult.failure(
+                        "depth_to_image_mapping_failed",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double dx = rightImage[0] - leftImage[0];
             double dy = rightImage[1] - leftImage[1];
             double imageWidthPx = Math.hypot(dx, dy);
             if (!Double.isFinite(imageWidthPx) || imageWidthPx < 8.0) {
-                return null;
+                return DepthSampleResult.failure(
+                        "image_width_too_small",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double normalizedAngularWidth = Math.sqrt(
@@ -152,7 +222,9 @@ final class DepthObservationSampler {
             if (!Double.isFinite(normalizedAngularWidth)
                     || normalizedAngularWidth <= 0.0
                     || normalizedAngularWidth > 0.95) {
-                return null;
+                return DepthSampleResult.failure(
+                        "angular_width_invalid",
+                        trackingFrame, rawDepthFrame, mappedCenterReached, rawAnchorReached, rawPatchReached, smoothDepthMatchReached, boundaryConsensusReached, rawAnchorDiagnostics);
             }
 
             double effectiveFocalPx = imageWidthPx / normalizedAngularWidth;
@@ -178,7 +250,7 @@ final class DepthObservationSampler {
                 boundaryConfidence = "low";
             }
 
-            return new DepthObservation(
+            DepthObservation observation = new DepthObservation(
                     centerDepthMm / 1000.0,
                     effectiveFocalPx,
                     imageWidthPx,
@@ -187,11 +259,94 @@ final class DepthObservationSampler {
                     boundaryConfidence,
                     centerMadMm / 1000.0,
                     System.currentTimeMillis());
-        } catch (NotYetAvailableException e) {
-            return null;
+            return DepthSampleResult.success(observation, rawAnchorDiagnostics);
         } catch (Exception e) {
-            return null;
+            return DepthSampleResult.failure(
+                    "unexpected_exception",
+                    trackingFrame,
+                    rawDepthFrame,
+                    mappedCenterReached,
+                    rawAnchorReached,
+                    rawPatchReached,
+                    smoothDepthMatchReached,
+                    boundaryConsensusReached,
+                    rawAnchorDiagnostics);
+        } finally {
+            if (smoothDepth != null) smoothDepth.close();
+            if (rawConfidence != null) rawConfidence.close();
+            if (rawDepth != null) rawDepth.close();
+        }
+    }
+
+    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) {

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

@@ -0,0 +1,69 @@
+package org.drawdown.arcoredepth;
+
+/**
+ * One attempted native ARCore sample. A failed sample carries a stable reason
+ * plus milestone flags so the sweep can explain where frames are being lost
+ * without persisting camera/depth frames.
+ */
+final class DepthSampleResult {
+    final DepthObservation observation;
+    final String rejectionReason;
+    final boolean trackingFrame;
+    final boolean rawDepthFrame;
+    final boolean mappedCenter;
+    final boolean rawAnchor;
+    final boolean rawPatch;
+    final boolean smoothDepthMatch;
+    final boolean boundaryConsensus;
+    final RawAnchorDiagnostics rawAnchorDiagnostics;
+
+    DepthSampleResult(
+            DepthObservation observation,
+            String rejectionReason,
+            boolean trackingFrame,
+            boolean rawDepthFrame,
+            boolean mappedCenter,
+            boolean rawAnchor,
+            boolean rawPatch,
+            boolean smoothDepthMatch,
+            boolean boundaryConsensus,
+            RawAnchorDiagnostics rawAnchorDiagnostics) {
+        this.observation = observation;
+        this.rejectionReason = rejectionReason;
+        this.trackingFrame = trackingFrame;
+        this.rawDepthFrame = rawDepthFrame;
+        this.mappedCenter = mappedCenter;
+        this.rawAnchor = rawAnchor;
+        this.rawPatch = rawPatch;
+        this.smoothDepthMatch = smoothDepthMatch;
+        this.boundaryConsensus = boundaryConsensus;
+        this.rawAnchorDiagnostics = rawAnchorDiagnostics;
+    }
+
+    static DepthSampleResult failure(
+            String reason,
+            boolean trackingFrame,
+            boolean rawDepthFrame,
+            boolean mappedCenter,
+            boolean rawAnchor,
+            boolean rawPatch,
+            boolean smoothDepthMatch,
+            boolean boundaryConsensus,
+            RawAnchorDiagnostics rawAnchorDiagnostics) {
+        return new DepthSampleResult(
+                null,
+                reason,
+                trackingFrame,
+                rawDepthFrame,
+                mappedCenter,
+                rawAnchor,
+                rawPatch,
+                smoothDepthMatch,
+                boundaryConsensus,
+                rawAnchorDiagnostics);
+    }
+
+    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

@@ -36,7 +36,9 @@ import com.google.ar.core.exceptions.UnavailableUserDeclinedInstallationExceptio
 import android.opengl.GLSurfaceView;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 @CapacitorPlugin(
         name = "DrawDownArCoreDepth",
@@ -44,7 +46,8 @@ import java.util.List;
                 @Permission(alias = "camera", strings = { Manifest.permission.CAMERA })
         })
 public class DrawDownArCoreDepthPlugin extends Plugin {
-    private static final String PLUGIN_VERSION = "0.1.4";
+    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());
@@ -68,6 +71,16 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
     private int maxObservations = 10;
     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;
+    private int mappedCenterCount = 0;
+    private int rawAnchorCount = 0;
+    private int rawPatchCount = 0;
+    private int smoothDepthMatchCount = 0;
+    private int boundaryConsensusCount = 0;
 
     @PluginMethod
     public void checkSupport(PluginCall call) {
@@ -251,6 +264,16 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
 
             pendingSweepCall = call;
             sweepObservations.clear();
+            sweepRejectionCounts.clear();
+            sweepRawAnchorDiagnostics.clear();
+            totalFrameCount = 0;
+            trackingFrameCount = 0;
+            rawDepthFrameCount = 0;
+            mappedCenterCount = 0;
+            rawAnchorCount = 0;
+            rawPatchCount = 0;
+            smoothDepthMatchCount = 0;
+            boundaryConsensusCount = 0;
             minObservations = requestedMin;
             maxObservations = requestedMax;
             sampleIntervalMs = Math.max(100L, durationMs / Math.max(1, requestedMax * 2));
@@ -372,32 +395,65 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
 
         try {
             Camera camera = frame.getCamera();
-            DepthObservation observation = sampler.sample(frame, camera, viewWidth, viewHeight);
-            if (observation == null) {
-                return;
-            }
+            DepthSampleResult sampleResult = sampler.sample(frame, camera, viewWidth, viewHeight);
 
             boolean reachedMax = false;
             synchronized (sweepLock) {
                 if (!sweepActive || pendingSweepCall == null) {
                     return;
                 }
-                sweepObservations.add(observation);
-                reachedMax = sweepObservations.size() >= maxObservations;
+                totalFrameCount += 1;
+                if (sampleResult.trackingFrame) trackingFrameCount += 1;
+                if (sampleResult.rawDepthFrame) rawDepthFrameCount += 1;
+                if (sampleResult.mappedCenter) mappedCenterCount += 1;
+                if (sampleResult.rawAnchor) rawAnchorCount += 1;
+                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)
+                            ? sweepRejectionCounts.get(sampleResult.rejectionReason)
+                            : 0;
+                    sweepRejectionCounts.put(sampleResult.rejectionReason, current + 1);
+                }
+
+                if (sampleResult.observation != null) {
+                    sweepObservations.add(sampleResult.observation);
+                    reachedMax = sweepObservations.size() >= maxObservations;
+                }
             }
 
             if (reachedMax) {
                 mainHandler.post(() -> finishSweep(false));
             }
         } catch (Exception ignored) {
-            // Invalid frames are simply skipped; the app's aggregate QA rejects
-            // a sweep with too few valid observations.
+            synchronized (sweepLock) {
+                totalFrameCount += 1;
+                int current = sweepRejectionCounts.containsKey("unexpected_exception")
+                        ? sweepRejectionCounts.get("unexpected_exception")
+                        : 0;
+                sweepRejectionCounts.put("unexpected_exception", current + 1);
+            }
         }
     }
 
     private void finishSweep(boolean stoppedByCaller) {
         PluginCall sweepCall;
         List<DepthObservation> observations;
+        Map<String, Integer> rejectionCounts;
+        List<RawAnchorDiagnostics> rawAnchorDiagnostics;
+        int framesTotal;
+        int framesTracking;
+        int framesRawDepth;
+        int centersMapped;
+        int anchorsRaw;
+        int patchesRaw;
+        int matchesSmooth;
+        int boundariesConsensus;
         synchronized (sweepLock) {
             sweepCall = pendingSweepCall;
             if (sweepCall == null) {
@@ -407,7 +463,19 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             pendingSweepCall = null;
             sweepActive = false;
             observations = new ArrayList<>(sweepObservations);
+            rejectionCounts = new LinkedHashMap<>(sweepRejectionCounts);
+            rawAnchorDiagnostics = new ArrayList<>(sweepRawAnchorDiagnostics);
+            framesTotal = totalFrameCount;
+            framesTracking = trackingFrameCount;
+            framesRawDepth = rawDepthFrameCount;
+            centersMapped = mappedCenterCount;
+            anchorsRaw = rawAnchorCount;
+            patchesRaw = rawPatchCount;
+            matchesSmooth = smoothDepthMatchCount;
+            boundariesConsensus = boundaryConsensusCount;
             sweepObservations.clear();
+            sweepRejectionCounts.clear();
+            sweepRawAnchorDiagnostics.clear();
         }
 
         JSArray observationArray = new JSArray();
@@ -415,12 +483,37 @@ public class DrawDownArCoreDepthPlugin extends Plugin {
             observationArray.put(observation.toJsObject());
         }
 
+        JSObject rejectionObject = new JSObject();
+        for (Map.Entry<String, Integer> entry : rejectionCounts.entrySet()) {
+            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);
         result.put("arcoreVersion", installedArcoreVersion());
+        result.put("pluginVersion", PLUGIN_VERSION);
+        result.put("methodVersion", METHOD_VERSION);
         result.put("minimumRequested", minObservations);
         result.put("stoppedByCaller", stoppedByCaller);
+        result.put("totalFrameCount", framesTotal);
+        result.put("trackingFrameCount", framesTracking);
+        result.put("rawDepthFrameCount", framesRawDepth);
+        result.put("mappedCenterCount", centersMapped);
+        result.put("rawAnchorCount", anchorsRaw);
+        result.put("rawPatchCount", patchesRaw);
+        result.put("smoothDepthMatchCount", matchesSmooth);
+        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) {
@@ -430,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,54 +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;
+  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.4",
-  "description": "Small Android-only Capacitor 8 bridge for ARCore Depth DBH observations.",
+  "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",