Add area-probe drag overlay and stats

ssh4net · ssh4net · commit 65fc04a42dc1 · 2026-03-11T08:51:02.000+09:00
Implement area-probe rectangle dragging and per-rectangle statistics and UI. Adds viewer state (drag active, start/end UVs, lines) and new APIs (reset_area_probe_overlay, update_area_probe_overlay) plus helper functions to compute rectangle stats and build placeholder/result text lines. Integrates drag behavior into image view input handling (start/update/stop drag, draw translucent selection rect, suppress pan/zoom while probing), resets area probe on image load/clear, and exposes area_probe_lines in the test-engine JSON output. Also adds a test-run flag to force the drag overlay during automation.
diff --git a/src/imiv/imiv_actions.cpp b/src/imiv/imiv_actions.cpp
@@ -39,6 +39,7 @@ namespace {
         reset_view_navigation_state(viewer);
         viewer.probe_valid = false;
         viewer.probe_channels.clear();
+        reset_area_probe_overlay(viewer);
     }
 
 }  // namespace
@@ -145,6 +146,7 @@ load_viewer_image(VulkanState& vk_state, ViewerState& viewer,
     reset_view_navigation_state(viewer);
     viewer.probe_valid = false;
     viewer.probe_channels.clear();
+    reset_area_probe_overlay(viewer);
     if (viewer.image.width > 0 && viewer.image.height > 0) {
         const int center_x = viewer.image.width / 2;
         const int center_y = viewer.image.height / 2;
diff --git a/src/imiv/imiv_frame.cpp b/src/imiv/imiv_frame.cpp
@@ -172,12 +172,27 @@ write_test_engine_viewer_state_json(const std::filesystem::path& out_path,
     test_engine_json_write_vec2(f, viewer.max_scroll);
     std::fputs(",\n  \"fit_image_to_window\": ", f);
     std::fputs(ui_state.fit_image_to_window ? "true" : "false", f);
+    std::fputs(",\n  \"loaded_image_count\": ", f);
+    std::fprintf(f, "%d", static_cast<int>(viewer.loaded_image_paths.size()));
+    std::fputs(",\n  \"current_image_index\": ", f);
+    std::fprintf(f, "%d", viewer.current_path_index);
+    std::fputs(",\n  \"drag_overlay_active\": ", f);
+    std::fputs(viewer.drag_overlay_active ? "true" : "false", f);
+    std::fputs(",\n  \"area_probe_drag_active\": ", f);
+    std::fputs(viewer.area_probe_drag_active ? "true" : "false", f);
     std::fputs(",\n  \"image_size\": [", f);
     std::fprintf(f, "%d,%d", viewer.image.width, viewer.image.height);
     std::fputs("],\n  \"display_size\": [", f);
     std::fprintf(f, "%d,%d", display_width, display_height);
     std::fputs("],\n  \"orientation\": ", f);
     std::fprintf(f, "%d", viewer.image.orientation);
+    std::fputs(",\n  \"area_probe_lines\": [", f);
+    for (size_t i = 0; i < viewer.area_probe_lines.size(); ++i) {
+        if (i > 0)
+            std::fputs(", ", f);
+        test_engine_json_write_escaped(f, viewer.area_probe_lines[i].c_str());
+    }
+    std::fputs("]", f);
     std::fputs("\n}\n", f);
     std::fflush(f);
     std::fclose(f);
@@ -367,6 +382,8 @@ draw_viewer_ui(ViewerState& viewer, PlaceholderUiState& ui_state,
         ui_state.show_pixelview_window   = true;
         ui_state.show_area_probe_window  = true;
     }
+    if (env_flag_is_truthy("IMIV_IMGUI_TEST_ENGINE_SHOW_DRAG_OVERLAY"))
+        viewer.drag_overlay_active = true;
 
     collect_viewer_shortcuts(viewer, ui_state, actions, request_exit);
 #if defined(IMGUI_ENABLE_TEST_ENGINE)
diff --git a/src/imiv/imiv_image_view.cpp b/src/imiv/imiv_image_view.cpp
@@ -171,6 +171,11 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
 
     const bool has_image = !viewer.image.path.empty();
     if (has_image) {
+        if (ui_state.show_area_probe_window && viewer.area_probe_lines.empty())
+            reset_area_probe_overlay(viewer);
+        if (!ui_state.show_area_probe_window)
+            viewer.area_probe_drag_active = false;
+
         const ImVec2 image_size = image_layout.image_size;
         ImTextureRef main_texture_ref;
         ImTextureRef closeup_texture_ref;
@@ -307,11 +312,12 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
             }
         }
 
-        const ImGuiIO& io         = ImGui::GetIO();
-        const ImVec2 mouse        = io.MousePos;
-        const bool mouse_in_image = point_in_rect(mouse,
-                                                  coord_map.image_rect_min,
-                                                  coord_map.image_rect_max);
+        const ImGuiIO& io          = ImGui::GetIO();
+        const ImVec2 mouse         = io.MousePos;
+        const bool area_probe_mode = ui_state.show_area_probe_window;
+        const bool mouse_in_image  = point_in_rect(mouse,
+                                                   coord_map.image_rect_min,
+                                                   coord_map.image_rect_max);
         const bool mouse_in_viewport
             = point_in_rect(mouse, coord_map.viewport_rect_min,
                             coord_map.viewport_rect_max);
@@ -331,6 +337,9 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
         const bool empty_viewport_clicked_right
             = viewport_accepts_mouse && !mouse_in_image
               && ImGui::IsMouseClicked(ImGuiMouseButton_Right);
+        const ImVec2 clamped_mouse
+            = clamp_pos_to_rect(mouse, coord_map.image_rect_min,
+                                coord_map.image_rect_max);
 
         ImVec2 source_uv(0.0f, 0.0f);
         int px = 0;
@@ -350,12 +359,48 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
             viewer.probe_channels.clear();
         }
 
+        if (area_probe_mode) {
+            ImVec2 area_source_uv(0.5f, 0.5f);
+            const bool have_area_source_uv
+                = screen_to_source_uv(coord_map, clamped_mouse, area_source_uv);
+            const bool area_probe_accepts_mouse
+                = viewport_accepts_mouse || image_canvas_accepts_mouse
+                  || viewer.area_probe_drag_active;
+            if (!viewer.area_probe_drag_active && area_probe_accepts_mouse
+                && ImGui::IsMouseDown(ImGuiMouseButton_Left)
+                && have_area_source_uv) {
+                viewer.area_probe_drag_active   = true;
+                viewer.area_probe_drag_start_uv = area_source_uv;
+                viewer.area_probe_drag_end_uv   = area_source_uv;
+            }
+            if (viewer.area_probe_drag_active && have_area_source_uv)
+                viewer.area_probe_drag_end_uv = area_source_uv;
+            if (viewer.area_probe_drag_active) {
+                int xbegin = 0;
+                int ybegin = 0;
+                int xend   = 0;
+                int yend   = 0;
+                if (source_uv_to_pixel(coord_map,
+                                       viewer.area_probe_drag_start_uv, xbegin,
+                                       ybegin)
+                    && source_uv_to_pixel(coord_map,
+                                          viewer.area_probe_drag_end_uv, xend,
+                                          yend)) {
+                    update_area_probe_overlay(viewer, xbegin, ybegin, xend,
+                                              yend);
+                }
+                if (!ImGui::IsMouseDown(ImGuiMouseButton_Left))
+                    viewer.area_probe_drag_active = false;
+            }
+        }
+
         bool want_pan       = false;
         bool want_zoom_drag = false;
         if (viewport_accepts_mouse || image_canvas_accepts_mouse
             || viewer.pan_drag_active || viewer.zoom_drag_active) {
             if (ui_state.mouse_mode == 1) {
-                want_pan = ImGui::IsMouseDown(ImGuiMouseButton_Left)
+                want_pan = (!area_probe_mode
+                            && ImGui::IsMouseDown(ImGuiMouseButton_Left))
                            || ImGui::IsMouseDown(ImGuiMouseButton_Right)
                            || ImGui::IsMouseDown(ImGuiMouseButton_Middle);
             } else if (ui_state.mouse_mode == 0) {
@@ -364,7 +409,8 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
                       && (viewer.pan_drag_active || image_canvas_accepts_mouse
                           || viewport_accepts_mouse);
                 const bool want_alt_left_pan
-                    = io.KeyAlt && ImGui::IsMouseDown(ImGuiMouseButton_Left)
+                    = !area_probe_mode && io.KeyAlt
+                      && ImGui::IsMouseDown(ImGuiMouseButton_Left)
                       && (viewer.pan_drag_active || image_canvas_accepts_mouse
                           || viewport_accepts_mouse);
                 want_pan       = want_middle_pan || want_alt_left_pan;
@@ -373,7 +419,7 @@ draw_image_window_contents(ViewerState& viewer, PlaceholderUiState& ui_state,
                                  && (viewer.zoom_drag_active
                                      || image_canvas_accepts_mouse
                                      || viewport_accepts_mouse);
-                if (!io.KeyAlt
+                if (!area_probe_mode && !io.KeyAlt
                     && (image_canvas_clicked_left || image_canvas_clicked_right
                         || empty_viewport_clicked_left
                         || empty_viewport_clicked_right)) {
diff --git a/src/imiv/imiv_overlays.cpp b/src/imiv/imiv_overlays.cpp
@@ -129,6 +129,103 @@ namespace {
         return true;
     }
 
+    bool compute_rect_stats(const LoadedImage& image, int xbegin, int ybegin,
+                            int xend, int yend, std::vector<double>& out_min,
+                            std::vector<double>& out_max,
+                            std::vector<double>& out_avg, int& out_samples,
+                            ProbeStatsSemantics semantics
+                            = ProbeStatsSemantics::OIIOFloat)
+    {
+        out_min.clear();
+        out_max.clear();
+        out_avg.clear();
+        out_samples = 0;
+        if (image.width <= 0 || image.height <= 0 || image.nchannels <= 0)
+            return false;
+
+        const int xmin = std::clamp(std::min(xbegin, xend), 0, image.width - 1);
+        const int xmax = std::clamp(std::max(xbegin, xend), 0, image.width - 1);
+        const int ymin = std::clamp(std::min(ybegin, yend), 0,
+                                    image.height - 1);
+        const int ymax = std::clamp(std::max(ybegin, yend), 0,
+                                    image.height - 1);
+        if (xmax < xmin || ymax < ymin)
+            return false;
+
+        const size_t channels = static_cast<size_t>(image.nchannels);
+        out_min.assign(channels, std::numeric_limits<double>::infinity());
+        out_max.assign(channels, -std::numeric_limits<double>::infinity());
+        out_avg.assign(channels, 0.0);
+
+        std::vector<double> sample;
+        for (int y = ymin; y <= ymax; ++y) {
+            for (int x = xmin; x <= xmax; ++x) {
+                if (!sample_loaded_pixel_with_semantics(image, x, y, semantics,
+                                                        sample)) {
+                    continue;
+                }
+                if (sample.size() != channels)
+                    continue;
+                for (size_t c = 0; c < channels; ++c) {
+                    out_min[c] = std::min(out_min[c], sample[c]);
+                    out_max[c] = std::max(out_max[c], sample[c]);
+                    out_avg[c] += sample[c];
+                }
+                ++out_samples;
+            }
+        }
+
+        if (out_samples <= 0) {
+            out_min.clear();
+            out_max.clear();
+            out_avg.clear();
+            return false;
+        }
+        for (double& value : out_avg)
+            value /= static_cast<double>(out_samples);
+        return true;
+    }
+
+    void build_area_probe_placeholder_lines(const LoadedImage& image,
+                                            std::vector<std::string>& out_lines)
+    {
+        out_lines.clear();
+        out_lines.emplace_back("Area Probe:");
+        if (image.width <= 0 || image.height <= 0 || image.nchannels <= 0)
+            return;
+        for (int c = 0; c < image.nchannels; ++c) {
+            const std::string channel
+                = pixel_preview_channel_label(image, static_cast<int>(c));
+            out_lines.emplace_back(Strutil::fmt::format(
+                "{:<5}: [min:  -----  max:  -----  avg:  -----]", channel));
+        }
+    }
+
+    void build_area_probe_result_lines(const LoadedImage& image,
+                                       const std::vector<double>& min_values,
+                                       const std::vector<double>& max_values,
+                                       const std::vector<double>& avg_values,
+                                       std::vector<std::string>& out_lines)
+    {
+        out_lines.clear();
+        out_lines.emplace_back("Area Probe:");
+        const int channel_count = std::max(1, image.nchannels);
+        for (int c = 0; c < channel_count; ++c) {
+            const std::string channel
+                = pixel_preview_channel_label(image, static_cast<int>(c));
+            if (static_cast<size_t>(c) < min_values.size()
+                && static_cast<size_t>(c) < max_values.size()
+                && static_cast<size_t>(c) < avg_values.size()) {
+                out_lines.emplace_back(Strutil::fmt::format(
+                    "{:<5}: [min: {:>6.3f}  max: {:>6.3f}  avg: {:>6.3f}]",
+                    channel, min_values[c], max_values[c], avg_values[c]));
+            } else {
+                out_lines.emplace_back(Strutil::fmt::format(
+                    "{:<5}: [min:  -----  max:  -----  avg:  -----]", channel));
+            }
+        }
+    }
+
     std::string format_probe_iv_float(double value)
     {
         if (value < 10.0)
@@ -358,6 +455,40 @@ namespace {
 
 }  // namespace
 
+void
+reset_area_probe_overlay(ViewerState& viewer)
+{
+    viewer.area_probe_drag_active   = false;
+    viewer.area_probe_drag_start_uv = ImVec2(0.0f, 0.0f);
+    viewer.area_probe_drag_end_uv   = ImVec2(0.0f, 0.0f);
+    build_area_probe_placeholder_lines(viewer.image, viewer.area_probe_lines);
+}
+
+void
+update_area_probe_overlay(ViewerState& viewer, int xbegin, int ybegin, int xend,
+                          int yend)
+{
+    if (viewer.image.path.empty()) {
+        viewer.area_probe_lines.clear();
+        return;
+    }
+
+    std::vector<double> min_values;
+    std::vector<double> max_values;
+    std::vector<double> avg_values;
+    int sample_count = 0;
+    if (!compute_rect_stats(viewer.image, xbegin, ybegin, xend, yend,
+                            min_values, max_values, avg_values, sample_count,
+                            ProbeStatsSemantics::OIIOFloat)) {
+        build_area_probe_placeholder_lines(viewer.image,
+                                           viewer.area_probe_lines);
+        return;
+    }
+
+    build_area_probe_result_lines(viewer.image, min_values, max_values,
+                                  avg_values, viewer.area_probe_lines);
+}
+
 OverlayPanelRect
 draw_pixel_closeup_overlay(const ViewerState& viewer,
                            PlaceholderUiState& ui_state,
@@ -697,38 +828,35 @@ draw_area_probe_overlay(const ViewerState& viewer,
     if (!ui_state.show_area_probe_window || !map.valid)
         return;
 
-    std::vector<std::string> lines;
-    lines.emplace_back("Area Probe:");
-    if (viewer.image.path.empty()) {
-        lines.emplace_back("No image loaded.");
-    } else {
-        std::vector<double> min_values;
-        std::vector<double> max_values;
-        std::vector<double> avg_values;
-        int sample_count = 0;
-        const bool have_stats
-            = viewer.probe_valid
-              && compute_area_stats(viewer.image, viewer.probe_x,
-                                    viewer.probe_y, ui_state.closeup_avg_pixels,
-                                    min_values, max_values, avg_values,
-                                    sample_count,
-                                    ProbeStatsSemantics::OIIOFloat);
-
-        const int channel_count = std::max(1, viewer.image.nchannels);
-        for (int c = 0; c < channel_count; ++c) {
-            const std::string channel
-                = pixel_preview_channel_label(viewer.image,
-                                              static_cast<int>(c));
-            if (have_stats && static_cast<size_t>(c) < min_values.size()
-                && static_cast<size_t>(c) < max_values.size()
-                && static_cast<size_t>(c) < avg_values.size()) {
-                lines.emplace_back(Strutil::fmt::format(
-                    "{:<5}: [min: {:>6.3f}  max: {:>6.3f}  avg: {:>6.3f}]",
-                    channel, min_values[c], max_values[c], avg_values[c]));
-            } else {
-                lines.emplace_back(Strutil::fmt::format(
-                    "{:<5}: [min:  -----  max:  -----  avg:  -----]", channel));
-            }
+    if (viewer.area_probe_drag_active) {
+        ImVec2 start_screen(0.0f, 0.0f);
+        ImVec2 end_screen(0.0f, 0.0f);
+        if (source_uv_to_screen(map, viewer.area_probe_drag_start_uv,
+                                start_screen)
+            && source_uv_to_screen(map, viewer.area_probe_drag_end_uv,
+                                   end_screen)) {
+            const ImVec2 rect_min(std::min(start_screen.x, end_screen.x),
+                                  std::min(start_screen.y, end_screen.y));
+            const ImVec2 rect_max(std::max(start_screen.x, end_screen.x),
+                                  std::max(start_screen.y, end_screen.y));
+            ImDrawList* draw_list = ImGui::GetWindowDrawList();
+            draw_list->PushClipRect(map.viewport_rect_min,
+                                    map.viewport_rect_max, true);
+            draw_list->AddRectFilled(rect_min, rect_max,
+                                     IM_COL32(52, 128, 255, 76), 0.0f);
+            draw_list->AddRect(rect_min, rect_max, IM_COL32(96, 176, 255, 220),
+                               0.0f, 0, 1.2f);
+            draw_list->PopClipRect();
+        }
+    }
+
+    std::vector<std::string> lines = viewer.area_probe_lines;
+    if (lines.empty()) {
+        if (viewer.image.path.empty()) {
+            lines.emplace_back("Area Probe:");
+            lines.emplace_back("No image loaded.");
+        } else {
+            build_area_probe_placeholder_lines(viewer.image, lines);
         }
     }
 
diff --git a/src/imiv/imiv_ui.h b/src/imiv/imiv_ui.h
@@ -29,6 +29,11 @@ bool
 sample_loaded_pixel(const LoadedImage& image, int x, int y,
                     std::vector<double>& out_channels);
 void
+reset_area_probe_overlay(ViewerState& viewer);
+void
+update_area_probe_overlay(ViewerState& viewer, int xbegin, int ybegin, int xend,
+                          int yend);
+void
 draw_padded_message(const char* message, float x_pad = 10.0f,
                     float y_pad = 6.0f);
 void
diff --git a/src/imiv/imiv_viewer.h b/src/imiv/imiv_viewer.h
@@ -44,6 +44,10 @@ struct ViewerState {
     int probe_x             = 0;
     int probe_y             = 0;
     std::vector<double> probe_channels;
+    bool area_probe_drag_active     = false;
+    ImVec2 area_probe_drag_start_uv = ImVec2(0.0f, 0.0f);
+    ImVec2 area_probe_drag_end_uv   = ImVec2(0.0f, 0.0f);
+    std::vector<std::string> area_probe_lines;
     bool pan_drag_active           = false;
     bool zoom_drag_active          = false;
     ImVec2 drag_prev_mouse         = ImVec2(0.0f, 0.0f);
diff --git a/src/imiv/tools/imiv_gui_test_run.py b/src/imiv/tools/imiv_gui_test_run.py
