Add HKR MinZ Control viewer UI, fix embedded-filter-model crash, quiet preset-glob noise

embedded-filter-model.h/.cpp:
- Fix a real crash: populate_options()/embedded_filter_enable_disable() read/wrote
  RS2_OPTION_EMBEDDED_FILTER_ENABLED unconditionally, which throws for any composite-only
  embedded filter (this predates the MinZ work - the already-shipped temporal filter has
  the same gap). Now guarded with supports().
- Enumerate composite options separately from scalar ones (own registry, see
  rs_composite_option.h) via a new _composite_option_ids list.
- Add a hardcoded editor for RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL: checkbox/radio/sliders
  for all 5 rs2_minz_control fields, grouped in a framed box with minimal indent, a
  send-only button (no auto-readback), and the control's description as a hover tooltip
  instead of an always-visible line.

device-model.cpp: the advanced-mode preset scan calls glob() unconditionally, which
throws whenever the presets folder doesn't exist yet (the common, expected case) - added
an isDir() pre-check (already available via the existing glob.h include) so that no
longer throws at all instead of relying on the surrounding catch.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Evgeni Raikhel

common/device-model.cpp

@@ -325,24 +325,35 @@ namespace rs2
 
         auto path = rsutils::os::get_special_folder( rsutils::os::special_folder::user_documents );
         path += "librealsense2/presets/";
-        try
+        // glob_rec() (third-party/filesystem/glob.h) throws whenever opendir() fails - which is
+        // the common, expected case here (most machines have never created this folder). Check
+        // first instead of relying on the exception: avoids a first-chance throw/catch on nearly
+        // every device refresh, which was showing up as debugger noise unrelated to any real bug.
+        if( isDir( path, nullptr ) )
         {
-            std::string name = dev.get_info(RS2_CAMERA_INFO_NAME);
-            std::smatch match;
-            if( ! std::regex_search( name, match, std::regex( "^RealSense (\\S+)" ) ) )
-                throw std::runtime_error( "cannot parse device name from '" + name + "'" );
+            try
+            {
+                std::string name = dev.get_info(RS2_CAMERA_INFO_NAME);
+                std::smatch match;
+                if( ! std::regex_search( name, match, std::regex( "^RealSense (\\S+)" ) ) )
+                    throw std::runtime_error( "cannot parse device name from '" + name + "'" );
 
-            glob(
-                path,
-                std::string( match[1] ) + " *.preset",
-                [&]( std::string const & file ) {
-                    advanced_mode_settings_file_names.insert( path + file );
-                },
-                false );  // recursive
+                glob(
+                    path,
+                    std::string( match[1] ) + " *.preset",
+                    [&]( std::string const & file ) {
+                        advanced_mode_settings_file_names.insert( path + file );
+                    },
+                    false );  // recursive
+            }
+            catch( const std::exception & e )
+            {
+                LOG_WARNING( "Exception caught trying to detect presets: " << e.what() );
+            }
         }
-        catch( const std::exception & e )
+        else
         {
-            LOG_WARNING( "Exception caught trying to detect presets: " << e.what() );
+            LOG_INFO( "Presets folder not found under " << path << ", skipping detection");
         }
     }
 

common/embedded-filter-model.cpp

@@ -54,10 +54,150 @@ namespace rs2
 
             id_and_model.second.draw_option( update_read_only_options, is_streaming, error_message, *viewer.not_model );
         }
+
+        // Composite options have no generic per-field editing UI (see embedded-filter-model.h) -
+        // RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL gets a hardcoded editor below; everything else
+        // just shows read-only metadata (description, byte size).
+        for( auto id : _composite_option_ids )
+        {
+            try
+            {
+                if( id == RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL )
+                {
+                    // No always-visible description line here - draw_minz_control_editor shows
+                    // it as a tooltip on hovering the framed control instead, to save vertical
+                    // space in this narrow side panel.
+                    draw_minz_control_editor( error_message );
+                    continue;
+                }
+
+                // TextWrapped, not TextDisabled - this side panel is narrow enough that a
+                // one-line description reliably clips instead of just looking dim.
+                ImGui::PushStyleColor( ImGuiCol_Text, ImGui::GetStyle().Colors[ImGuiCol_TextDisabled] );
+                ImGui::TextWrapped( "%s", _embedded_filter->get_composite_option_description( id ) );
+                ImGui::PopStyleColor();
+
+                auto bytes = _embedded_filter->get_composite_option( id );
+                ImGui::TextDisabled( "  (%zu bytes, composite option - no generic editor yet)", bytes.size() );
+            }
+            catch( const std::exception& e )
+            {
+                error_message = e.what();
+            }
+        }
+    }
+
+    void embedded_filter_model::draw_minz_control_editor( std::string & error_message )
+    {
+        const auto id = RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL;
+
+        if( ! _minz_editor_initialized )
+        {
+            try
+            {
+                _minz_editor_value = _embedded_filter->get_composite_option_as< rs2_minz_control >( id );
+                _minz_editor_initialized = true;
+            }
+            catch( const std::exception & e )
+            {
+                error_message = e.what();
+                return;
+            }
+        }
+
+        // Minimal indent - just enough padding that widget text doesn't sit flush on the frame
+        // border - rather than the tree's full default indent, so the group sits as far left as
+        // the panel allows.
+        ImGui::Indent( 4.0f );
+        ImGui::Dummy( ImVec2( 0, 2 ) );
+
+        float frame_left = ImGui::GetCursorScreenPos().x - 4.0f;
+        float frame_top = ImGui::GetCursorScreenPos().y - 4.0f;
+        float frame_width = ImGui::GetContentRegionAvail().x + 4.0f;
+
+        bool enable = _minz_editor_value.enable != 0;
+        if( ImGui::Checkbox( "Enable##minz", &enable ) )
+            _minz_editor_value.enable = enable ? 1 : 0;
+
+        // Every label below sits on its own line, with the interactive widget using a "##"-only
+        // (invisible) label - this side panel is too narrow for "label: [====slider====] value"
+        // all on one line; ImGui doesn't wrap inline widget labels, it just clips them.
+        // Downscale ratio only ever takes {1,2,4} - radio buttons, not a slider, so the user
+        // can't land on an invalid value like 3 (mirrors the field validation tool's own UI).
+        ImGui::Text( "Downscale Ratio:" );
+        for( int v : { 1, 2, 4 } )
+        {
+            ImGui::SameLine();
+            if( ImGui::RadioButton( ( std::to_string( v ) + "##minz_ratio" ).c_str(), _minz_editor_value.downscale_ratio == v ) )
+                _minz_editor_value.downscale_ratio = v;
+        }
+
+        ImGui::Text( "Disparity Shift:" );
+        int shift = _minz_editor_value.disparity_shift;
+        if( ImGui::SliderInt( "##minz_shift", &shift, 0, 512 ) )
+            _minz_editor_value.disparity_shift = shift;
+
+        ImGui::Text( "Threshold (mm):" );
+        int threshold = _minz_editor_value.threshold;
+        if( ImGui::SliderInt( "##minz_threshold", &threshold, 0, 65535 ) )
+            _minz_editor_value.threshold = threshold;
+
+        bool manual = _minz_editor_value.threshold_mode != 0;
+        if( ImGui::Checkbox( "Manual Threshold##minz", &manual ) )
+            _minz_editor_value.threshold_mode = manual ? 1 : 0;
+        if( ImGui::IsItemHovered() )
+            ImGui::SetTooltip( "Unchecked = Auto (firmware-computed threshold)" );
+
+        // Send-only: writes the edited struct atomically and leaves the displayed fields as the
+        // user set them. Does not read back - if the device clamps or overrides a value (e.g.
+        // Auto-mode threshold), the fields won't reflect that until the panel is next reopened
+        // or re-initialized, which is an accepted tradeoff for a single-purpose button.
+        if( ImGui::Button( "Send##minz" ) )
+        {
+            try
+            {
+                _embedded_filter->set_composite_option_from( id, _minz_editor_value );
+            }
+            catch( const std::exception & e )
+            {
+                error_message = e.what();
+            }
+        }
+
+        ImGui::Dummy( ImVec2( 0, 2 ) );
+        float frame_bottom = ImGui::GetCursorScreenPos().y;
+        ImVec2 frame_min( frame_left, frame_top );
+        ImVec2 frame_max( frame_left + frame_width, frame_bottom );
+        ImGui::GetWindowDrawList()->AddRect(
+            frame_min, frame_max,
+            ImGui::GetColorU32( ImGuiCol_Border ),
+            3.0f,    // rounding
+            0,       // flags
+            2.0f );  // thickness - visually ties every MinZ widget to one control
+
+        // The description (formerly an always-visible wrapped line above the frame) is now a
+        // hover tooltip on the frame itself, to save vertical space in this narrow side panel.
+        if( ImGui::IsMouseHoveringRect( frame_min, frame_max ) )
+        {
+            try
+            {
+                ImGui::SetTooltip( "%s", _embedded_filter->get_composite_option_description( id ) );
+            }
+            catch( const std::exception & )
+            {
+                // Best-effort tooltip only - a failure here shouldn't disrupt the editor itself.
+            }
+        }
+
+        ImGui::Unindent( 4.0f );
     }
 
     void embedded_filter_model::embedded_filter_enable_disable(bool actual)
     {
+        // Composite-only embedded filters (e.g. HKR MinZ Control) register no scalar options at
+        // all, including this one - nothing to toggle here for them.
+        if( ! _embedded_filter->supports( RS2_OPTION_EMBEDDED_FILTER_ENABLED ) )
+            return;
         _embedded_filter->set_option(RS2_OPTION_EMBEDDED_FILTER_ENABLED, actual ? 1.0f : 0.0f);
         _enabled = _embedded_filter->get_option(RS2_OPTION_EMBEDDED_FILTER_ENABLED);
     }
@@ -76,7 +216,17 @@ namespace rs2
                                                                 model ? &model->_options_invalidated : nullptr,
                                                                 error_message );
         }
-        _enabled = _embedded_filter->get_option(RS2_OPTION_EMBEDDED_FILTER_ENABLED);
+
+        // Composite options are enumerated separately - completely different registry from
+        // scalar rs2_option (see rs_composite_option.h) - so this is its own loop, not folded
+        // into the one above.
+        _composite_option_ids = _embedded_filter->get_supported_composite_options();
+
+        // Composite-only embedded filters (e.g. HKR MinZ Control) don't register this scalar
+        // option at all - _enabled keeps its default (true, see embedded-filter-model.h) instead
+        // of throwing here.
+        if( _embedded_filter->supports( RS2_OPTION_EMBEDDED_FILTER_ENABLED ) )
+            _enabled = _embedded_filter->get_option(RS2_OPTION_EMBEDDED_FILTER_ENABLED);
 
         try
         {

common/embedded-filter-model.h

@@ -4,8 +4,10 @@
 #pragma once
 
 #include <librealsense2/rs.hpp>
+#include <librealsense2/h/rs_hkr_minz_control.h>
 #include <functional>
 #include <string>
+#include <vector>
 
 
 namespace rs2
@@ -37,6 +39,13 @@ namespace rs2
                            bool is_streaming,
                            std::string & error_message );
 
+        // PROTOTYPE / DEMO: hardcoded editor for RS2_COMPOSITE_OPTION_HKR_MINZ_CONTROL
+        // specifically, called from draw_options() when that id is among _composite_option_ids.
+        // There is no generic per-field composite-option editor (would need per-struct schema
+        // knowledge generic view code doesn't have) - this special-cases the one struct by id,
+        // same way application code is expected to (see rs_hkr_minz_control.h).
+        void draw_minz_control_editor( std::string & error_message );
+
         std::shared_ptr<rs2::embedded_filter> get_filter() { return _embedded_filter; }
 
         void enable( bool e = true )
@@ -65,6 +74,19 @@ namespace rs2
         bool _enabled = true;
         std::shared_ptr<rs2::embedded_filter> _embedded_filter;
         std::map< rs2_option, option_model > _options_id_to_model;
+        // Composite options are a completely separate identity/registry space from scalar
+        // rs2_option (see rs_composite_option.h) - enumerated and drawn through their own loop
+        // in populate_options()/draw_options() rather than folded into _options_id_to_model.
+        // There is no generic per-field editing UI for these yet (that would need per-struct
+        // schema knowledge no generic view code has) - draw_options() shows read-only metadata
+        // only (description, byte size).
+        std::vector< rs2_composite_option_id > _composite_option_ids;
         std::string _name;
+
+        // PROTOTYPE / DEMO: local editing buffer for draw_minz_control_editor(). Seeded from a
+        // GET on first draw, then only mutated by user edits until "Apply" sends it and refreshes
+        // from a readback GET - never sent on every frame.
+        bool _minz_editor_initialized = false;
+        rs2_minz_control _minz_editor_value{};
     };
 }