Merge branch 'development' into pyrealsense2-wheel-script

Author: remibettan

.github/skills/pytest-infra.md

@@ -139,43 +139,48 @@ When migrating a legacy `test-*.py` to `pytest-*.py`:
 
 ## Handling `on_fail=test.ABORT`
 
-The legacy framework supported `with test.closure('Name', on_fail=test.ABORT):` — if that closure failed, all subsequent closures were skipped. In pytest, use the **`pytest-dependency`** plugin (already in `requirements.txt` and `plugins.py`).
+The legacy framework supported `with test.closure('Name', on_fail=test.ABORT):` — if that closure failed, all subsequent closures were skipped. In pytest, use a **module-level state dict** with `pytest.skip()`.
 
-**Pattern**: mark the prerequisite test with `@pytest.mark.dependency(scope='module')`, and each dependent test with `@pytest.mark.dependency(scope='module', depends=["prerequisite_name"])`. If the prerequisite fails or is skipped, all dependents are automatically skipped.
+> **Why not `pytest-dependency`?** The plugin requires exact test-name matching, but `pytest_generate_tests` (used by `device_each`) appends parametrized suffixes like `[D455-1234567890]`. The plugin cannot match `"test_foo"` against `"test_foo[D455-1234567890]"` — no regex, glob, or prefix support exists. The module-state pattern is zero-dependency and works regardless of parametrization.
+
+**Pattern**: the prerequisite test sets a flag in a module-level dict on success. Dependent tests check the flag and `pytest.skip()` if missing.
 
 ```python
-# Prerequisite test — asserts (hard fail if condition not met), registers as a dependency
-@pytest.mark.dependency(scope='module')
+_module_state = {}
+
 def test_advanced_mode_support(test_device_wrapped):
     """Prerequisite: camera must be in advanced mode."""
     dev, ctx = test_device_wrapped
     assert rs.rs400_advanced_mode(dev).is_enabled()
+    _module_state['am_ok'] = True
 
-# Dependent test — skipped automatically if test_advanced_mode_support failed/was skipped
-@pytest.mark.dependency(scope='module', depends=["test_advanced_mode_support"])
 def test_set_depth_control(test_device_wrapped):
+    if not _module_state.get('am_ok'):
+        pytest.skip("prerequisite test_advanced_mode_support failed")
     dev, ctx = test_device_wrapped
     ...
 ```
 
-**`scope='module'`**: limits dependency resolution to the current test file, so identically-named tests in other files do not interfere.
-
-**Parametrized tests**: when both the prerequisite and dependent tests share the same parametrization (e.g., `device_each`), `pytest-dependency` automatically matches per-parameter — `test_set_depth_control[D455-SN]` is only skipped if `test_advanced_mode_support[D455-SN]` specifically failed, not if a different device's run failed.
-
-**Chain of ABORTs**: if a file has multiple `on_fail=test.ABORT` closures in sequence, list all prerequisite names in `depends=`:
+**Chain of ABORTs**: if a file has multiple prerequisite tests in sequence, each sets its own flag. Dependents check the deepest prerequisite (which implicitly requires all prior ones to have passed):
 
 ```python
-@pytest.mark.dependency(scope='module')
+_module_state = {}
+
 def test_advanced_mode_support(...):   # first ABORT
     assert ...
+    _module_state['am_ok'] = True
 
-@pytest.mark.dependency(scope='module', depends=["test_advanced_mode_support"])
 def test_visual_preset_support(...):   # second ABORT
+    if not _module_state.get('am_ok'):
+        pytest.skip("prerequisite test_advanced_mode_support failed")
     assert ...
+    _module_state['preset_ok'] = True
 
-# Everything after the second ABORT depends on both
-@pytest.mark.dependency(scope='module', depends=["test_advanced_mode_support", "test_visual_preset_support"])
+# Everything after the second ABORT checks only 'preset_ok'
+# (preset_ok being set implies am_ok was set too)
 def test_set_depth_control(...):
+    if not _module_state.get('preset_ok'):
+        pytest.skip("prerequisite test_visual_preset_support failed")
     ...
 ```
 

common/viewer.cpp

@@ -3022,7 +3022,7 @@ namespace rs2
                     std::string excl_icon_str = rsutils::string::from() << textual_icons::exclamation_triangle
                                                 << " The following changes will take effect only after restarting the application";
                     ImGui::Text( "%s", excl_icon_str.c_str() );
-                    bool allow_partial_device = temp_cfg.get_nested< bool >( "context.partial-device-allowed", false );
+                    bool allow_partial_device = temp_cfg.get_nested< bool >( "context.partial-device-allowed", true );
                     if( ImGui::Checkbox( "Allow partial device initialization", &allow_partial_device ) )
                     {
                         temp_cfg.set_nested( "context.partial-device-allowed", allow_partial_device );

examples/enhanced-depth-range/live_minz_compare.py

@@ -41,6 +41,15 @@
 ir2 = profile.get_stream(rs.stream.infrared, 2).as_video_stream_profile()
 calib = Calibration.from_sdk(ir1.get_intrinsics(), ir1.get_extrinsics_to(ir2))
 
+# Meters per Z16 unit (RS2_OPTION_DEPTH_UNITS). Typical D4xx is 0.001 (raw
+# Z16 == mm), but high-accuracy presets and SR300 use other values, so we
+# must scale raw values by this factor to get true millimetres.
+try:
+    depth_scale = profile.get_device().first_depth_sensor().get_depth_scale()
+except Exception:
+    depth_scale = 0.001
+print(f"Depth scale: {depth_scale} m/unit ({depth_scale * 1000:.4f} mm/unit)")
+
 # ── 3. Construct the improver ───────────────────────────────────────────
 improver = DepthRangeImprover(calib)
 print(f"MinZ threshold: {improver.min_z_threshold_mm} mm")
@@ -81,7 +90,8 @@ def colorize_depth_mm(depth_mm: np.ndarray) -> np.ndarray:
         f = pipeline.wait_for_frames()
         ir_left  = np.asanyarray(f.get_infrared_frame(1).get_data())
         ir_right = np.asanyarray(f.get_infrared_frame(2).get_data())
-        depth_hw = np.asanyarray(f.get_depth_frame().get_data())
+        depth_hw = (np.asanyarray(f.get_depth_frame().get_data())
+                    * depth_scale * 1000.0).astype(np.uint16)
 
         depth_imp = improver.process(ir_left, ir_right, depth_hw)
 

examples/enhanced-depth-range/range_depth.cpp

@@ -26,6 +26,7 @@
 #include <csignal>
 #include <cstdint>
 #include <cstdio>
+#include <cstring>
 #include <vector>
 
 static volatile std::sig_atomic_t g_stop = 0;
@@ -49,6 +50,14 @@ int main() {
     auto calib = rs_depth::Calibration::from_sdk(ir1.get_intrinsics(),
                                                  ir1.get_extrinsics_to(ir2));
 
+    // Meters per Z16 unit (RS2_OPTION_DEPTH_UNITS). Typical D4xx = 0.001 (raw
+    // Z16 == mm), but high-accuracy presets and SR300 use other values — scale
+    // raw values to mm before passing to the improver and the MinZ comparison.
+    const float depth_scale = profile.get_device()
+                                     .first<rs2::depth_sensor>()
+                                     .get_depth_scale();
+    const float depth_to_mm = depth_scale * 1000.0f;
+
     // ── 3. Construct the improver (auto threshold = focal × baseline / 105)
     rs_depth::DepthRangeImprover improver(calib);
     const int T = calib.min_z_threshold_mm();
@@ -57,6 +66,7 @@ int main() {
 
     // ── 4. Stream + improve + live status line ────────────────────────
     std::vector<uint16_t> depth_imp(N);
+    std::vector<uint16_t> depth_mm(N);
     long long hw_total = 0, imp_total = 0, rescued_total = 0;
     int frames_seen = 0;
 
@@ -68,7 +78,20 @@ int main() {
 
         const uint8_t*  ir_left  = static_cast<const uint8_t*>(ir_l.get_data());
         const uint8_t*  ir_right = static_cast<const uint8_t*>(ir_r.get_data());
-        const uint16_t* depth_hw = static_cast<const uint16_t*>(depth.get_data());
+        const uint16_t* raw_z16  = static_cast<const uint16_t*>(depth.get_data());
+
+        // Convert raw Z16 → uint16 mm using the camera's depth_scale.
+        const uint16_t* depth_hw = depth_mm.data();
+        if (depth_to_mm == 1.0f) {
+            std::memcpy(depth_mm.data(), raw_z16, N * sizeof(uint16_t));
+        } else {
+            for (int i = 0; i < N; ++i) {
+                float mm = static_cast<float>(raw_z16[i]) * depth_to_mm;
+                depth_mm[i] = (mm > 65535.0f) ? 65535
+                            : (mm < 0.0f)     ? 0
+                                              : static_cast<uint16_t>(mm);
+            }
+        }
 
         // Mirrors Python's FrameMetadata.from_rs2_frameset — extracts width,
         // height, exposure/gain/laser-power/temperature for IR + depth + color.

examples/enhanced-depth-range/range_depth.py

@@ -34,6 +34,14 @@
 ir2 = profile.get_stream(rs.stream.infrared, 2).as_video_stream_profile()
 calib = Calibration.from_sdk(ir1.get_intrinsics(), ir1.get_extrinsics_to(ir2))
 
+# Meters per Z16 unit. Typical D4xx = 0.001 (raw Z16 == mm), but high-accuracy
+# presets and SR300 use other values — scale raw values to mm before comparing
+# against MinZ threshold (which is in mm).
+try:
+    depth_scale = profile.get_device().first_depth_sensor().get_depth_scale()
+except Exception:
+    depth_scale = 0.001
+
 # ── 3. Construct the improver (auto threshold = focal × baseline / 105) ─
 improver = DepthRangeImprover(calib)
 T = improver.min_z_threshold_mm
@@ -49,7 +57,8 @@
         f = pipeline.wait_for_frames()
         ir_left  = np.asanyarray(f.get_infrared_frame(1).get_data())
         ir_right = np.asanyarray(f.get_infrared_frame(2).get_data())
-        depth_hw = np.asanyarray(f.get_depth_frame().get_data())
+        depth_hw = (np.asanyarray(f.get_depth_frame().get_data())
+                    * depth_scale * 1000.0).astype(np.uint16)
 
         depth_imp = improver.process(ir_left, ir_right, depth_hw)
 

src/dds/rsdds-device-factory.cpp

@@ -157,7 +157,7 @@ rsdds_device_factory::rsdds_device_factory( std::shared_ptr< context > const & c
                                       << domain_id << "; cannot create '" << participant_name << "'" );
         }
         size_t device_initialization_timeout = dds_settings.nested( "device-initialization-timeout-ms" ).default_value< size_t >( 5000 );
-        bool partial_capabilities_allowed = ctx->get_settings().nested( "partial-device-allowed" ).default_value< bool >( false );
+        bool partial_capabilities_allowed = ctx->get_settings().nested( "partial-device-allowed" ).default_value< bool >( true );
         _watcher_singleton = domain.device_watcher.instance( _participant, device_initialization_timeout, partial_capabilities_allowed );
         _subscription = _watcher_singleton->subscribe(
             [liveliness = std::weak_ptr< context >( ctx ),

src/ds/ds-private.cpp

@@ -122,7 +122,7 @@ namespace librealsense
         bool is_partial_device_allowed( const std::shared_ptr< context > & ctx )
         {
             auto settings = ctx->get_settings();
-            return settings.nested( "partial-device-allowed" ).default_value< bool >( false );
+            return settings.nested( "partial-device-allowed" ).default_value< bool >( true );
         }
     } // librealsense::ds
 } // namespace librealsense

unit-tests/conftest.py

@@ -240,8 +240,13 @@ def pytest_configure(config):
     setup_test_logging(config)
 
     # Enable LibRS debug logging if --rslog (once, globally)
+    # log_to_console writes directly to stderr from C++. Pytest's default fd-level
+    # capture swallows it, so we downgrade to sys-level capture (Python only) which
+    # lets C++ stderr through while still capturing Python stdout/stderr.
     if rs and config.getoption("--rslog", default=False):
         rs.log_to_console(rs.log_severity.debug)
+        if config.option.capture == 'fd':
+            config.option.capture = 'sys'
 
     # Test discovery defaults (replaces pytest.ini which is .gitignored)
     config.addinivalue_line("python_files", "pytest-*.py")
@@ -579,7 +584,7 @@ def test_context(request, module_device_setup):
     if not rs:
         pytest.skip("pyrealsense2 not available")
 
-    ctx = rs.context()
+    ctx = rs.context({"device-mask":0xfe}) # Intel only (no platform camera when testing locally)
 
     if module_device_setup and len(list(ctx.devices)) == 0:
         pytest.fail("No devices visible in context after device setup")