18018707227

Committed 25 Sep 2025 07:35PM UTC coverage: 68.577% (-0.3%) from 68.889%

Build # 18018707227

Build Type

push

github

Committed by

paulmthompson

Commit Message

selection for lines appears to work well

Run Details

11 of 59 new or added lines in 2 files covered. (18.64%)

797 existing lines in 9 files now uncovered.

42024 of 61280 relevant lines covered (68.58%)

1133.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

14.5

/src/WhiskerToolbox/Media_Widget/MediaLine_Widget/MediaLine_Widget.cpp

#include "MediaLine_Widget.hpp"
#include "ui_MediaLine_Widget.h"

#include "CoreGeometry/point_geometry.hpp"
#include "DataManager/DataManager.hpp"
#include "DataManager/Lines/Line_Data.hpp"
#include "DataManager/Media/Media_Data.hpp"
#include "DataManager/Media/Video_Data.hpp"
#include "DataManager/transforms/Lines/Line_Angle/line_angle.hpp"
#include "DataManager/utils/polynomial/polynomial_fit.hpp"
#include "ImageProcessing/OpenCVUtility.hpp"
#include "Media_Widget/Media_Window/Media_Window.hpp"
#include "SelectionWidgets/LineAddSelectionWidget.hpp"
#include "SelectionWidgets/LineDrawAllFramesSelectionWidget.hpp"
#include "SelectionWidgets/LineEraseSelectionWidget.hpp"
#include "SelectionWidgets/LineNoneSelectionWidget.hpp"
#include "SelectionWidgets/LineSelectSelectionWidget.hpp"

#include <QButtonGroup>
#include <QCheckBox>
#include <QCursor>
#include <QGroupBox>
#include <QLabel>
#include <QMenu>
#include <QRadioButton>
#include <QSpinBox>
#include <QVBoxLayout>
#include <armadillo>
#include <iostream>
#include <opencv2/opencv.hpp>

MediaLine_Widget::MediaLine_Widget(std::shared_ptr<DataManager> data_manager, Media_Window * scene, QWidget * parent)
    : QWidget(parent),
      ui(new Ui::MediaLine_Widget),
      _data_manager{std::move(data_manager)},
      _scene{scene} {
    ui->setupUi(this);

    _selection_modes["(None)"] = Selection_Mode::None;
    _selection_modes["Add Points"] = Selection_Mode::Add;
    _selection_modes["Erase Points"] = Selection_Mode::Erase;
    _selection_modes["Select Line"] = Selection_Mode::Select;
    _selection_modes["Draw Across All Frames"] = Selection_Mode::DrawAllFrames;

    ui->selection_mode_combo->addItems(QStringList(_selection_modes.keys()));

    connect(ui->selection_mode_combo, &QComboBox::currentTextChanged, this, &MediaLine_Widget::_toggleSelectionMode);

    // Initialize the selection mode to match the current combo box selection
    _toggleSelectionMode(ui->selection_mode_combo->currentText());

    connect(ui->color_picker, &ColorPicker_Widget::colorChanged,
            this, &MediaLine_Widget::_setLineColor);
    connect(ui->color_picker, &ColorPicker_Widget::alphaChanged,
            this, &MediaLine_Widget::_setLineAlpha);

    // Connect line thickness controls
    connect(ui->line_thickness_slider, &QSlider::valueChanged,
            this, &MediaLine_Widget::_setLineThickness);
    connect(ui->line_thickness_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MediaLine_Widget::_setLineThickness);

    // Synchronize line thickness slider and spinbox
    connect(ui->line_thickness_slider, &QSlider::valueChanged,
            ui->line_thickness_spinbox, &QSpinBox::setValue);
    connect(ui->line_thickness_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            ui->line_thickness_slider, &QSlider::setValue);

    connect(ui->show_points_checkbox, &QCheckBox::toggled, this, &MediaLine_Widget::_toggleShowPoints);

    // Connect position marker controls
    connect(ui->show_position_marker_checkbox, &QCheckBox::toggled,
            this, &MediaLine_Widget::_toggleShowPositionMarker);
    connect(ui->position_percentage_slider, &QSlider::valueChanged,
            this, &MediaLine_Widget::_setPositionPercentage);
    connect(ui->position_percentage_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MediaLine_Widget::_setPositionPercentage);

    // Synchronize position percentage slider and spinbox
    connect(ui->position_percentage_slider, &QSlider::valueChanged,
            ui->position_percentage_spinbox, &QSpinBox::setValue);
    connect(ui->position_percentage_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            ui->position_percentage_slider, &QSlider::setValue);

    // Connect segment controls
    connect(ui->show_segment_checkbox, &QCheckBox::toggled,
            this, &MediaLine_Widget::_toggleShowSegment);
    connect(ui->segment_start_slider, &QSlider::valueChanged,
            this, &MediaLine_Widget::_setSegmentStartPercentage);
    connect(ui->segment_start_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MediaLine_Widget::_setSegmentStartPercentage);
    connect(ui->segment_end_slider, &QSlider::valueChanged,
            this, &MediaLine_Widget::_setSegmentEndPercentage);
    connect(ui->segment_end_spinbox, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MediaLine_Widget::_setSegmentEndPercentage);

    // Note: Removed direct slider-spinbox synchronization to prevent infinite loops
    // The synchronization is now handled within the percentage setter functions

    connect(ui->line_select_slider, &QSlider::valueChanged, this, &MediaLine_Widget::_lineSelectionChanged);

    _setupSelectionModePages();
}

void MediaLine_Widget::_setupSelectionModePages() {
    _noneSelectionWidget = new line_widget::LineNoneSelectionWidget();
    ui->mode_stacked_widget->addWidget(_noneSelectionWidget);

    _addSelectionWidget = new line_widget::LineAddSelectionWidget();
    ui->mode_stacked_widget->addWidget(_addSelectionWidget);

    connect(_addSelectionWidget, &line_widget::LineAddSelectionWidget::edgeSnappingToggled,
            this, &MediaLine_Widget::_toggleEdgeSnapping);
    connect(_addSelectionWidget, &line_widget::LineAddSelectionWidget::smoothingModeChanged,
            this, &MediaLine_Widget::_setSmoothingMode);
    connect(_addSelectionWidget, &line_widget::LineAddSelectionWidget::polynomialOrderChanged,
            this, &MediaLine_Widget::_setPolynomialOrder);
    connect(_addSelectionWidget, &line_widget::LineAddSelectionWidget::edgeThresholdChanged,
            this, &MediaLine_Widget::_setEdgeThreshold);
    connect(_addSelectionWidget, &line_widget::LineAddSelectionWidget::edgeSearchRadiusChanged,
            this, &MediaLine_Widget::_setEdgeSearchRadius);

    _eraseSelectionWidget = new line_widget::LineEraseSelectionWidget();
    ui->mode_stacked_widget->addWidget(_eraseSelectionWidget);

    connect(_eraseSelectionWidget, &line_widget::LineEraseSelectionWidget::eraserRadiusChanged,
            this, &MediaLine_Widget::_setEraserRadius);
    connect(_eraseSelectionWidget, &line_widget::LineEraseSelectionWidget::showCircleToggled,
            this, &MediaLine_Widget::_toggleShowHoverCircle);

    _selectSelectionWidget = new line_widget::LineSelectSelectionWidget();
    ui->mode_stacked_widget->addWidget(_selectSelectionWidget);

    connect(_selectSelectionWidget, &line_widget::LineSelectSelectionWidget::selectionThresholdChanged,
            this, [this](float threshold) {
                _line_selection_threshold = threshold;
                std::cout << "Line selection threshold set to: " << threshold << std::endl;
            });

    _drawAllFramesSelectionWidget = new line_widget::LineDrawAllFramesSelectionWidget();
    ui->mode_stacked_widget->addWidget(_drawAllFramesSelectionWidget);

    connect(_drawAllFramesSelectionWidget, &line_widget::LineDrawAllFramesSelectionWidget::lineDrawingStarted,
            this, [this]() {
                std::cout << "Line drawing started for all frames mode" << std::endl;
            });
    connect(_drawAllFramesSelectionWidget, &line_widget::LineDrawAllFramesSelectionWidget::lineDrawingCompleted,
            this, [this]() {
                std::cout << "Line drawing completed for all frames mode" << std::endl;
            });
    connect(_drawAllFramesSelectionWidget, &line_widget::LineDrawAllFramesSelectionWidget::applyToAllFrames,
            this, &MediaLine_Widget::_applyLineToAllFrames);

    ui->mode_stacked_widget->setCurrentIndex(0);
}

MediaLine_Widget::~MediaLine_Widget() {
    delete ui;
}

void MediaLine_Widget::showEvent(QShowEvent * event) {

    static_cast<void>(event);

    std::cout << "Show Event" << std::endl;
    connect(_scene, &Media_Window::leftClickMedia, this, &MediaLine_Widget::_clickedInVideo);
    connect(_scene, &Media_Window::rightClickMedia, this, &MediaLine_Widget::_rightClickedInVideo);
}

void MediaLine_Widget::hideEvent(QHideEvent * event) {

    static_cast<void>(event);

    std::cout << "Hide Event" << std::endl;
    disconnect(_scene, &Media_Window::leftClickMedia, this, &MediaLine_Widget::_clickedInVideo);
    disconnect(_scene, &Media_Window::rightClickMedia, this, &MediaLine_Widget::_rightClickedInVideo);

    // Clean up hover circle when switching away from line widget
    _scene->setShowHoverCircle(false);
}

void MediaLine_Widget::setActiveKey(std::string const & key) {
    _active_key = key;
    ui->name_label->setText(QString::fromStdString(key));

    // Set the color picker to the current line color if available
    if (!key.empty()) {
        auto config = _scene->getLineConfig(key);

        if (config) {
            ui->color_picker->setColor(QString::fromStdString(config.value()->hex_color));
            ui->color_picker->setAlpha(static_cast<int>(config.value()->alpha * 100));

            // Set line thickness controls
            ui->line_thickness_slider->blockSignals(true);
            ui->line_thickness_spinbox->blockSignals(true);
            ui->line_thickness_slider->setValue(config.value()->line_thickness);
            ui->line_thickness_spinbox->setValue(config.value()->line_thickness);
            ui->line_thickness_slider->blockSignals(false);
            ui->line_thickness_spinbox->blockSignals(false);

            // Update the show points checkbox directly from the UI file
            ui->show_points_checkbox->blockSignals(true);
            ui->show_points_checkbox->setChecked(config.value()->show_points);
            ui->show_points_checkbox->blockSignals(false);

            // Set position marker controls
            ui->show_position_marker_checkbox->blockSignals(true);
            ui->show_position_marker_checkbox->setChecked(config.value()->show_position_marker);
            ui->show_position_marker_checkbox->blockSignals(false);

            ui->position_percentage_slider->blockSignals(true);
            ui->position_percentage_spinbox->blockSignals(true);
            ui->position_percentage_slider->setValue(config.value()->position_percentage);
            ui->position_percentage_spinbox->setValue(config.value()->position_percentage);
            ui->position_percentage_slider->blockSignals(false);
            ui->position_percentage_spinbox->blockSignals(false);

            // Set segment controls
            ui->show_segment_checkbox->blockSignals(true);
            ui->show_segment_checkbox->setChecked(config.value()->show_segment);
            ui->show_segment_checkbox->blockSignals(false);

            ui->segment_start_slider->blockSignals(true);
            ui->segment_start_spinbox->blockSignals(true);
            ui->segment_start_slider->setValue(config.value()->segment_start_percentage);
            ui->segment_start_spinbox->setValue(config.value()->segment_start_percentage);
            ui->segment_start_slider->blockSignals(false);
            ui->segment_start_spinbox->blockSignals(false);

            ui->segment_end_slider->blockSignals(true);
            ui->segment_end_spinbox->blockSignals(true);
            ui->segment_end_slider->setValue(config.value()->segment_end_percentage);
            ui->segment_end_spinbox->setValue(config.value()->segment_end_percentage);
            ui->segment_end_slider->blockSignals(false);
            ui->segment_end_spinbox->blockSignals(false);

            // Reset line selection and update slider
            _current_line_index = 0;

            auto line_data = _data_manager->getData<LineData>(_active_key);
            if (line_data) {
                auto current_time = TimeFrameIndex(_data_manager->getCurrentTime());
                auto lines = line_data->getAtTime(current_time);

                // Update the slider with the number of lines
                int num_lines = static_cast<int>(lines.size());

                ui->line_select_slider->blockSignals(true);
                ui->line_select_slider->setMaximum(num_lines > 0 ? num_lines - 1 : 0);
                ui->line_select_slider->setValue(0);// Reset to first line
                ui->line_select_slider->setEnabled(num_lines > 1);
                ui->line_select_slider->blockSignals(false);
            }
        }
    }
}

void MediaLine_Widget::_setLineAlpha(int alpha) {
    float const alpha_float = static_cast<float>(alpha) / 100;

    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->alpha = alpha_float;
        }
        _scene->UpdateCanvas();
    }
}

void MediaLine_Widget::_setLineColor(QString const & hex_color) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->hex_color = hex_color.toStdString();
        }
        _scene->UpdateCanvas();
    }
}

void MediaLine_Widget::_clickedInVideo(qreal x_canvas, qreal y_canvas) {
    if (_active_key.empty()) {
        std::cout << "No active key" << std::endl;
        return;
    }

    auto line_data = _data_manager->getData<LineData>(_active_key);
    if (!line_data) {
        std::cout << "No line data for active key" << std::endl;
        return;
    }

    auto const x_media = static_cast<float>(x_canvas);
    auto const y_media = static_cast<float>(y_canvas);
    auto const current_time = TimeFrameIndex(_data_manager->getCurrentTime());
    auto const line_img_size = line_data->getImageSize();

    auto lines = line_data->getAtTime(current_time);

    switch (_selection_mode) {
        case Selection_Mode::None: {
            std::cout << "Selection mode is None" << std::endl;
            break;
        }
        case Selection_Mode::Add: {
            std::cout << "Selection mode is Add" << std::endl;
            _addPointToLine(x_media, y_media, current_time);
            break;
        }
        case Selection_Mode::Erase: {
            std::cout << "Selection mode is Erase" << std::endl;
            std::cout << "Not yet implemented" << std::endl;
            break;
        }
        case Selection_Mode::Select: {
            std::cout << "Selection mode is Select" << std::endl;
            
            // Use Media_Window's entity finding and selection system for group integration
            QPointF scene_pos(x_canvas * _scene->getXAspect(), y_canvas * _scene->getYAspect());
            std::string data_key, data_type;
            EntityId entity_id = _scene->findEntityAtPosition(scene_pos, data_key, data_type);
            
            if (entity_id != 0 && data_type == "line" && data_key == _active_key) {
                // Use the group-based selection system for consistency
                _scene->selectEntity(entity_id, data_key, data_type);
                std::cout << "Selected line entity " << entity_id << " in group system" << std::endl;
            } else {
                // Clear selections if no line found
                _scene->clearAllSelections();
                std::cout << "No line found within threshold - cleared selections" << std::endl;
            }
            break;
        }
        case Selection_Mode::DrawAllFrames: {
            std::cout << "Selection mode is DrawAllFrames" << std::endl;
            _addPointToDrawAllFrames(x_media, y_media);
            break;
        }
    }
}

void MediaLine_Widget::_addPointToLine(float x_media, float y_media, TimeFrameIndex current_time) {
    auto line_data = _data_manager->getData<LineData>(_active_key);
    auto lines = line_data->getAtTime(current_time);

    // Check if edge snapping is enabled
    bool use_edge_snapping = false;
    auto line_opts = _scene->getLineConfig(_active_key);
    if (line_opts.has_value()) {
        use_edge_snapping = line_opts.value()->edge_snapping;
    }

    if (use_edge_snapping && _edge_snapping_enabled) {

        if (_current_edges.empty()) {
            _detectEdges();
        }

        auto edge_point = _findNearestEdge(x_media, y_media);
        x_media = edge_point.first;
        y_media = edge_point.second;
    }

    if (lines.empty()) {
        // If no lines exist, create a new one with the single point
        _data_manager->getData<LineData>(_active_key)->addAtTime(current_time, Line2D{Point2D{x_media, y_media}});
        // After adding a new line, it's line index 0
        _current_line_index = 0;
        ui->line_select_slider->setValue(0);
    } else {
        if (_smoothing_mode == Smoothing_Mode::SimpleSmooth) {
            // Use the original smoothing approach with the selected line index
            _data_manager->getData<LineData>(_active_key)->addPointToLineInterpolate(current_time, _current_line_index, Point2D<float>{x_media, y_media});
        } else if (_smoothing_mode == Smoothing_Mode::PolynomialFit) {
            // Make sure current_line_index is valid
            if (_current_line_index >= static_cast<int>(lines.size())) {
                std::cout << "Warning: line index out of bounds, using first line" << std::endl;
                _current_line_index = 0;
                ui->line_select_slider->setValue(0);
            }

            // Get a copy of the current line using the selected index
            auto line = lines[_current_line_index];

            // If the line already exists, add interpolated points between the last point and the new point
            if (!line.empty()) {
                Point2D<float> const last_point = line.back();

                // Calculate distance between last point and new point
                float dx = x_media - last_point.x;
                float dy = y_media - last_point.y;
                float distance = std::sqrt(dx * dx + dy * dy);

                // Add interpolated points if the distance is significant
                if (distance > 5.0f) {// Threshold for adding interpolation
                    int num_interp_points = std::max(2, static_cast<int>(distance / 5.0f));
                    for (int i = 1; i <= num_interp_points; ++i) {
                        float t = static_cast<float>(i) / (num_interp_points + 1);
                        float interp_x = last_point.x + t * dx;
                        float interp_y = last_point.y + t * dy;
                        line.push_back(Point2D<float>{interp_x, interp_y});
                    }
                }
            }

            // Add the actual new point
            line.push_back(Point2D<float>{x_media, y_media});

            // Apply polynomial fitting if we have enough points
            if (line.size() >= 3) {
                _applyPolynomialFit(line, _polynomial_order);
            }

            // Update the line in the data manager
            std::vector<Line2D> updated_lines = lines;
            updated_lines[_current_line_index] = line;

            _data_manager->getData<LineData>(_active_key)->clearAtTime(current_time);
            for (auto const & updated_line: updated_lines) {
                _data_manager->getData<LineData>(_active_key)->addAtTime(current_time, updated_line);
            }
        }
    }

    _scene->UpdateCanvas();
    std::cout << "Added point (" << x_media << ", " << y_media << ") to line "
              << _active_key << " (index: " << _current_line_index << ")" << std::endl;
}

void MediaLine_Widget::_applyPolynomialFit(Line2D & line, int order) {
    if (line.size() < static_cast<size_t>(order + 1)) {
        // Not enough points for the requested polynomial order
        return;
    }

    // Extract x and y coordinates
    std::vector<double> t(line.size());
    std::vector<double> x_coords(line.size());
    std::vector<double> y_coords(line.size());

    // Use parameter t along the curve (0 to 1)
    for (size_t i = 0; i < line.size(); ++i) {
        t[i] = static_cast<double>(i) / (line.size() - 1);
        x_coords[i] = line[i].x;
        y_coords[i] = line[i].y;
    }

    // Fit polynomials to x(t) and y(t) using the function from line_angle.hpp
    std::vector<double> x_coeffs = fit_polynomial(t, x_coords, order);
    std::vector<double> y_coeffs = fit_polynomial(t, y_coords, order);

    if (x_coeffs.empty() || y_coeffs.empty()) {
        // Fall back to simple smoothing if fitting failed
        smooth_line(line);
        return;
    }

    // Generate smooth curve with more points
    int const num_points = std::max(100, static_cast<int>(line.size()) * 2);
    std::vector<Point2D<float>> smooth_line;
    smooth_line.reserve(num_points);

    for (int i = 0; i < num_points; ++i) {
        double t_param = static_cast<double>(i) / (num_points - 1);

        // Evaluate polynomials at t_param using the function from line_angle.hpp
        double x_val = evaluate_polynomial(x_coeffs, t_param);
        double y_val = evaluate_polynomial(y_coeffs, t_param);

        smooth_line.push_back(Point2D<float>{static_cast<float>(x_val), static_cast<float>(y_val)});
    }

    // Replace the original line with the smooth one
    line = Line2D(smooth_line);
}

void MediaLine_Widget::_setSmoothingMode(int index) {
    _smoothing_mode = static_cast<Smoothing_Mode>(index);
    std::cout << "Smoothing mode set to: " << index << std::endl;
}

void MediaLine_Widget::_setPolynomialOrder(int order) {
    _polynomial_order = order;
    std::cout << "Polynomial order set to: " << order << std::endl;
}

void MediaLine_Widget::_toggleSelectionMode(QString text) {
    _selection_mode = _selection_modes[text];
    std::cout << "MediaLine_Widget: Selection mode changed to: " << text.toStdString() 
              << " (enum value: " << static_cast<int>(_selection_mode) << ")" << std::endl;

    // Switch to the appropriate page in the stacked widget
    int pageIndex = static_cast<int>(_selection_mode);
    ui->mode_stacked_widget->setCurrentIndex(pageIndex);

    // Enable group selection ONLY when in "Select Line" mode
    bool enable_group_selection = (_selection_mode == Selection_Mode::Select);
    _scene->setGroupSelectionEnabled(enable_group_selection);
    std::cout << "MediaLine_Widget: Group selection " << (enable_group_selection ? "enabled" : "disabled") << std::endl;

    if (_selection_mode == Selection_Mode::Erase) {
        _scene->setShowHoverCircle(true);
        _scene->setHoverCircleRadius(_eraseSelectionWidget->getEraserRadius());
    } else {
        _scene->setShowHoverCircle(false);
    }
}

void MediaLine_Widget::_toggleShowPoints(bool checked) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->show_points = checked;
        }
        _scene->UpdateCanvas();
    }
}

void MediaLine_Widget::_toggleEdgeSnapping(bool checked) {
    _edge_snapping_enabled = checked;

    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->edge_snapping = checked;
        }

        // If enabling edge snapping, perform edge detection immediately
        if (checked) {
            _detectEdges();
        } else {
            // Clear cached edges when disabling
            _current_edges.release();
        }

        _scene->UpdateCanvas();
    }

    std::cout << "Edge snapping " << (checked ? "enabled" : "disabled") << std::endl;
}

void MediaLine_Widget::LoadFrame(int frame_id) {
    // Update the widget with the new frame
    // This could involve refreshing displays or updating UI elements
    // specific to the current frame

    // If we have an active line, we might want to update some UI
    // based on line data at this frame
    if (!_active_key.empty()) {
        auto line_data = _data_manager->getData<LineData>(_active_key);
        if (line_data) {
            auto lines = line_data->getAtTime(TimeFrameIndex(frame_id));

            // Update the line_select_slider's maximum value based on the number of lines
            int num_lines = static_cast<int>(lines.size());

            // Disconnect and reconnect to avoid triggering slider value changed signals
            // during this programmatic update
            ui->line_select_slider->blockSignals(true);

            // Set the maximum value to the number of lines - 1 (or 0 if there are no lines)
            // Slider indices are 0-based, so max should be (num_lines - 1) when there are lines
            ui->line_select_slider->setMaximum(num_lines > 0 ? num_lines - 1 : 0);

            // If the current slider value exceeds the new maximum, adjust it
            if (ui->line_select_slider->value() > ui->line_select_slider->maximum()) {
                ui->line_select_slider->setValue(ui->line_select_slider->maximum());
            }

            ui->line_select_slider->blockSignals(false);

            // Update slider enabled state
            ui->line_select_slider->setEnabled(num_lines > 1);

            std::cout << "Frame " << frame_id << ": Updated line selector for "
                      << num_lines << " lines in " << _active_key << std::endl;
        }
    }
}

void MediaLine_Widget::_lineSelectionChanged(int index) {
    if (_current_line_index == index) {
        return;// No change
    }

    _current_line_index = index;
    std::cout << "Selected line index: " << _current_line_index << std::endl;

    // Update any UI or visualization based on the selected line
    if (!_active_key.empty()) {
        auto line_data = _data_manager->getData<LineData>(_active_key);
        if (line_data) {
            auto current_time = TimeFrameIndex(_data_manager->getCurrentTime());
            auto lines = line_data->getAtTime(current_time);

            if (!lines.empty() && _current_line_index < static_cast<int>(lines.size())) {
                // Here you can perform any specific actions needed when a different line is selected
                // For example, updating a visualization to highlight the selected line

                // Request canvas update to reflect any visualization changes
                _scene->UpdateCanvas();
            }
        }
    }
}

void MediaLine_Widget::_setEdgeThreshold(int threshold) {
    _edge_threshold = threshold;
    std::cout << "Edge threshold set to: " << threshold << std::endl;
}

void MediaLine_Widget::_setEdgeSearchRadius(int radius) {
    _edge_search_radius = radius;
    std::cout << "Edge search radius set to: " << radius << std::endl;
}

void MediaLine_Widget::_detectEdges() {

    auto media = _data_manager->getData<MediaData>("media");
    if (!media) {
        std::cout << "No media data available for edge detection" << std::endl;
        return;
    }

    auto const current_time = _data_manager->getCurrentTime();
    auto frame_data = media->getProcessedData(current_time);

    // Convert raw frame data to cv::Mat
    /*
    int width = media->getWidth();
    int height = media->getHeight();
    
    // Create a grayscale image for edge detection
    cv::Mat gray_image;
    
    // Check the format of media data and create appropriate cv::Mat
    if (media->getFormat() == MediaData::DisplayFormat::Gray) {
        // Grayscale image
        gray_image = cv::Mat(height, width, CV_8UC1, frame_data.data());
    } else {
        // Color image (RGBA)
        _current_frame = cv::Mat(height, width, CV_8UC4, frame_data.data());
        
        // Convert to grayscale
        cv::cvtColor(_current_frame, gray_image, cv::COLOR_RGBA2GRAY);
    }
    */
    auto gray_image = ImageProcessing::convert_vector_to_mat(frame_data, media->getImageSize());

    //cv::Mat blurred;
    //cv::GaussianBlur(gray_image, blurred, cv::Size(5, 5), 1.5);
    //cv::Canny(blurred, _current_edges, _edge_threshold / 2, _edge_threshold);

    cv::Canny(gray_image, _current_edges, _edge_threshold / 2, _edge_threshold);

    std::cout << "Edge detection completed for frame " << current_time << std::endl;
    std::cout << "Edges detected: " << _current_edges.size() << std::endl;
}

std::pair<float, float> MediaLine_Widget::_findNearestEdge(float x, float y) {
    if (_current_edges.empty()) {
        return {x, y};
    }

    // Round x and y to integers (image coordinates)
    int x_int = static_cast<int>(std::round(x));
    int y_int = static_cast<int>(std::round(y));

    // Define search radius and initialize variables
    int radius = _edge_search_radius;
    float min_distance = radius * radius + 1;     // Initialize to something larger than possible
    std::pair<float, float> nearest_edge = {x, y};// Default to original point

    // Get image dimensions
    int width = _current_edges.cols;
    int height = _current_edges.rows;

    // Check if the point is within image bounds
    if (x_int < 0 || x_int >= width || y_int < 0 || y_int >= height) {
        std::cout << "Click point outside image bounds" << std::endl;
        return {x, y};
    }

    // Search in a square region around the clicked point
    for (int dy = -radius; dy <= radius; dy++) {
        for (int dx = -radius; dx <= radius; dx++) {
            // Calculate current point to check
            int nx = x_int + dx;
            int ny = y_int + dy;

            if (nx < 0 || nx >= width || ny < 0 || ny >= height) {
                continue;
            }

            // Check if this is an edge pixel
            if (_current_edges.at<uchar>(ny, nx) > 0) {
                // Calculate distance squared (avoid square root for performance)
                float d_squared = dx * dx + dy * dy;

                // Update nearest edge if this is closer
                if (d_squared < min_distance) {
                    min_distance = d_squared;
                    nearest_edge = {static_cast<float>(nx), static_cast<float>(ny)};
                }
            }
        }
    }

    if (min_distance < radius * radius + 1) {
        std::cout << "Found edge point at (" << nearest_edge.first << ", "
                  << nearest_edge.second << "), distance: " << std::sqrt(min_distance) << std::endl;
    } else {
        std::cout << "No edge found within radius " << radius << std::endl;
        cv::imwrite("edges.png", _current_edges);
    }

    return nearest_edge;
}

void MediaLine_Widget::_setEraserRadius(int radius) {
    if (_selection_mode == Selection_Mode::Erase) {
        _scene->setHoverCircleRadius(static_cast<double>(radius));
    }
    std::cout << "Eraser radius set to: " << radius << std::endl;
}

void MediaLine_Widget::_toggleShowHoverCircle(bool checked) {
    _scene->setShowHoverCircle(checked);
    std::cout << "Show hover circle " << (checked ? "enabled" : "disabled") << std::endl;
}

void MediaLine_Widget::_setLineThickness(int thickness) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->line_thickness = thickness;
        }
        _scene->UpdateCanvas();
    }

    // Synchronize slider and spinbox if the signal came from one of them
    QObject * sender_obj = sender();
    if (sender_obj == ui->line_thickness_slider) {
        ui->line_thickness_spinbox->blockSignals(true);
        ui->line_thickness_spinbox->setValue(thickness);
        ui->line_thickness_spinbox->blockSignals(false);
    } else if (sender_obj == ui->line_thickness_spinbox) {
        ui->line_thickness_slider->blockSignals(true);
        ui->line_thickness_slider->setValue(thickness);
        ui->line_thickness_slider->blockSignals(false);
    }

    std::cout << "Line thickness set to: " << thickness << std::endl;
}

void MediaLine_Widget::_toggleShowPositionMarker(bool checked) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->show_position_marker = checked;
        }
        _scene->UpdateCanvas();
    }
    std::cout << "Show position marker " << (checked ? "enabled" : "disabled") << std::endl;
}

void MediaLine_Widget::_setPositionPercentage(int percentage) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->position_percentage = percentage;
        }
        _scene->UpdateCanvas();
    }

    // Synchronize slider and spinbox if the signal came from one of them
    QObject * sender_obj = sender();
    if (sender_obj == ui->position_percentage_slider) {
        ui->position_percentage_spinbox->blockSignals(true);
        ui->position_percentage_spinbox->setValue(percentage);
        ui->position_percentage_spinbox->blockSignals(false);
    } else if (sender_obj == ui->position_percentage_spinbox) {
        ui->position_percentage_slider->blockSignals(true);
        ui->position_percentage_slider->setValue(percentage);
        ui->position_percentage_slider->blockSignals(false);
    }

    std::cout << "Position percentage set to: " << percentage << std::endl;
}

void MediaLine_Widget::_toggleShowSegment(bool checked) {
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->show_segment = checked;
        }
        _scene->UpdateCanvas();
    }
    std::cout << "Show segment " << (checked ? "enabled" : "disabled") << std::endl;
}

void MediaLine_Widget::_setSegmentStartPercentage(int percentage) {
    if (_is_updating_percentages) return;
    _is_updating_percentages = true;

    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            // Ensure start percentage doesn't exceed end percentage - 1%
            int max_start_percentage = line_opts.value()->segment_end_percentage - 1;
            if (percentage > max_start_percentage) {
                // Don't allow start to exceed end - 1%
                QObject * sender_obj = sender();
                if (sender_obj == ui->segment_start_slider) {
                    ui->segment_start_slider->blockSignals(true);
                    ui->segment_start_slider->setValue(max_start_percentage);
                    ui->segment_start_slider->blockSignals(false);
                } else if (sender_obj == ui->segment_start_spinbox) {
                    ui->segment_start_spinbox->blockSignals(true);
                    ui->segment_start_spinbox->setValue(max_start_percentage);
                    ui->segment_start_spinbox->blockSignals(false);
                }
                percentage = max_start_percentage;
            }

            line_opts.value()->segment_start_percentage = percentage;
        }
        _scene->UpdateCanvas();
    }

    // Synchronize the other control if this one was changed
    QObject * sender_obj = sender();
    if (sender_obj == ui->segment_start_slider) {
        ui->segment_start_spinbox->blockSignals(true);
        ui->segment_start_spinbox->setValue(percentage);
        ui->segment_start_spinbox->blockSignals(false);
    } else if (sender_obj == ui->segment_start_spinbox) {
        ui->segment_start_slider->blockSignals(true);
        ui->segment_start_slider->setValue(percentage);
        ui->segment_start_slider->blockSignals(false);
    }

    std::cout << "Segment start percentage set to: " << percentage << std::endl;
    _is_updating_percentages = false;
}

void MediaLine_Widget::_setSegmentEndPercentage(int percentage) {
    if (_is_updating_percentages) return;
    _is_updating_percentages = true;

    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            // Ensure end percentage doesn't go below start percentage + 1%
            int min_end_percentage = line_opts.value()->segment_start_percentage + 1;
            if (percentage < min_end_percentage) {
                // Don't allow end to go below start + 1%
                QObject * sender_obj = sender();
                if (sender_obj == ui->segment_end_slider) {
                    ui->segment_end_slider->blockSignals(true);
                    ui->segment_end_slider->setValue(min_end_percentage);
                    ui->segment_end_slider->blockSignals(false);
                } else if (sender_obj == ui->segment_end_spinbox) {
                    ui->segment_end_spinbox->blockSignals(true);
                    ui->segment_end_spinbox->setValue(min_end_percentage);
                    ui->segment_end_spinbox->blockSignals(false);
                }
                percentage = min_end_percentage;
            }

            line_opts.value()->segment_end_percentage = percentage;
        }
        _scene->UpdateCanvas();
    }

    // Synchronize the other control if this one was changed
    QObject * sender_obj = sender();
    if (sender_obj == ui->segment_end_slider) {
        ui->segment_end_spinbox->blockSignals(true);
        ui->segment_end_spinbox->setValue(percentage);
        ui->segment_end_spinbox->blockSignals(false);
    } else if (sender_obj == ui->segment_end_spinbox) {
        ui->segment_end_slider->blockSignals(true);
        ui->segment_end_slider->setValue(percentage);
        ui->segment_end_slider->blockSignals(false);
    }

    std::cout << "Segment end percentage set to: " << percentage << std::endl;
    _is_updating_percentages = false;
}

void MediaLine_Widget::_rightClickedInVideo(qreal x_canvas, qreal y_canvas) {
    // Only handle right-clicks in Select mode and when a line is selected
    int selected_line_index = _getSelectedLineIndexFromGroupSystem();
    if (_selection_mode != Selection_Mode::Select || selected_line_index < 0 || _active_key.empty()) {
        return;
    }

    auto x_media = static_cast<float>(x_canvas);
    auto y_media = static_cast<float>(y_canvas);

    // Check if the right-click is near the selected line
    int nearest_line = _findNearestLine(x_media, y_media);
    if (nearest_line == selected_line_index) {
        // Show context menu at the click position
        QPoint global_pos = QCursor::pos();
        _showLineContextMenu(global_pos);
    }
}

/**
 * @brief Calculate the minimum distance from a point to a line segment
 * @param point The point to measure distance from
 * @param line_start Start point of the line segment
 * @param line_end End point of the line segment
 * @return The minimum distance from the point to the line segment
 */
float MediaLine_Widget::_calculateDistanceToLineSegment(Point2D<float> const & point,
                                                        Point2D<float> const & line_start,
                                                        Point2D<float> const & line_end) {
    float dx = line_end.x - line_start.x;
    float dy = line_end.y - line_start.y;

    // Handle degenerate case where line segment is actually a point
    if (dx == 0.0f && dy == 0.0f) {
        return calc_distance(point, line_start);
    }

    // Calculate the parameter t for the closest point on the line segment
    float t = ((point.x - line_start.x) * dx + (point.y - line_start.y) * dy) / (dx * dx + dy * dy);

    // Clamp t to [0, 1] to stay within the line segment
    t = std::max(0.0f, std::min(1.0f, t));

    // Calculate the closest point on the line segment
    Point2D<float> closest_point = {
            line_start.x + t * dx,
            line_start.y + t * dy};

    // Return the distance from the point to the closest point on the line segment
    return calc_distance(point, closest_point);
}

int MediaLine_Widget::_findNearestLine(float x, float y) {
    if (_active_key.empty()) {
        return -1;
    }

    auto line_data = _data_manager->getData<LineData>(_active_key);
    if (!line_data) {
        return -1;
    }

    auto current_time = TimeFrameIndex(_data_manager->getCurrentTime());
    auto lines = line_data->getAtTime(current_time);

    if (lines.empty()) {
        return -1;
    }

    Point2D<float> click_point{x, y};
    int nearest_line_index = -1;
    float min_distance = _line_selection_threshold + 1;// Initialize beyond threshold

    for (int line_idx = 0; line_idx < static_cast<int>(lines.size()); ++line_idx) {
        auto const & line = lines[line_idx];

        if (line.empty()) {
            continue;
        }

        // Calculate distance to each line segment
        float min_segment_distance = std::numeric_limits<float>::max();
        for (size_t i = 0; i < line.size() - 1; ++i) {
            float segment_distance = _calculateDistanceToLineSegment(click_point, line[i], line[i + 1]);
            if (segment_distance < min_segment_distance) {
                min_segment_distance = segment_distance;
            }
        }

        // Also check distance to vertices for completeness
        float min_vertex_distance = std::numeric_limits<float>::max();
        for (auto const & vertex: line) {
            float vertex_distance = calc_distance(click_point, vertex);
            if (vertex_distance < min_vertex_distance) {
                min_vertex_distance = vertex_distance;
            }
        }

        float line_distance = std::min(min_vertex_distance, min_segment_distance);

        if (line_distance < min_distance) {
            min_distance = line_distance;
            nearest_line_index = line_idx;
            std::cout << "  -> New closest line!" << std::endl;
        }
    }

    return (min_distance <= _line_selection_threshold) ? nearest_line_index : -1;
}

void MediaLine_Widget::_selectLine(int line_index) {
    _selected_line_index = line_index;

    // Update the line display options to show the selected line differently
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->selected_line_index = line_index;
        }
        _scene->UpdateCanvas();
    }
}

void MediaLine_Widget::_clearLineSelection() {
    _selected_line_index = -1;

    // Update the line display options to clear selection
    if (!_active_key.empty()) {
        auto line_opts = _scene->getLineConfig(_active_key);
        if (line_opts.has_value()) {
            line_opts.value()->selected_line_index = -1;
        }
        _scene->UpdateCanvas();
    }
}

void MediaLine_Widget::_showLineContextMenu(QPoint const & position) {
    QMenu context_menu(this);

    // Create Move To submenu
    QMenu * move_menu = context_menu.addMenu("Move Line To");
    QMenu * copy_menu = context_menu.addMenu("Copy Line To");

    // Get available LineData keys
    auto available_keys = _getAvailableLineDataKeys();

    for (auto const & key: available_keys) {
        if (key != _active_key) {// Don't include the current key
            // Add to Move menu
            QAction * move_action = move_menu->addAction(QString::fromStdString(key));
            connect(move_action, &QAction::triggered, [this, key]() {
                _moveLineToTarget(key);
            });

            // Add to Copy menu
            QAction * copy_action = copy_menu->addAction(QString::fromStdString(key));
            connect(copy_action, &QAction::triggered, [this, key]() {
                _copyLineToTarget(key);
            });
        }
    }

    // Disable menus if no other LineData available
    if (available_keys.size() <= 1) {
        move_menu->setEnabled(false);
        copy_menu->setEnabled(false);
    }

    context_menu.exec(position);
}

std::vector<std::string> MediaLine_Widget::_getAvailableLineDataKeys() {
    return _data_manager->getKeys<LineData>();
}

void MediaLine_Widget::_moveLineToTarget(std::string const & target_key) {
    int selected_line_index = _getSelectedLineIndexFromGroupSystem();
    if (selected_line_index < 0 || _active_key.empty()) {
        return;
    }

    auto source_line_data = _data_manager->getData<LineData>(_active_key);
    auto target_line_data = _data_manager->getData<LineData>(target_key);

    if (!source_line_data || !target_line_data) {
        std::cerr << "Could not retrieve source or target LineData" << std::endl;
        return;
    }

    auto current_time = TimeFrameIndex(_data_manager->getCurrentTime());
    auto lines = source_line_data->getAtTime(current_time);

    if (selected_line_index >= static_cast<int>(lines.size())) {
        std::cerr << "Selected line index out of bounds" << std::endl;
        return;
    }

    // Get the selected line
    Line2D selected_line = lines[selected_line_index];

    // Add to target
    target_line_data->addAtTime(current_time, selected_line);

    // Remove from source by rebuilding the vector without the selected line
    std::vector<Line2D> remaining_lines;
    for (int i = 0; i < static_cast<int>(lines.size()); ++i) {
        if (i != selected_line_index) {
            remaining_lines.push_back(lines[i]);
        }
    }

    // Clear and rebuild source lines
    source_line_data->clearAtTime(TimeFrameIndex(current_time));
    for (auto const & line: remaining_lines) {
        source_line_data->addAtTime(current_time, line);
    }

    // Clear selection since the line was moved
    _scene->clearAllSelections();

    std::cout << "Moved line from " << _active_key << " to " << target_key << std::endl;
}

void MediaLine_Widget::_copyLineToTarget(std::string const & target_key) {
    int selected_line_index = _getSelectedLineIndexFromGroupSystem();
    if (selected_line_index < 0 || _active_key.empty()) {
        return;
    }

    auto source_line_data = _data_manager->getData<LineData>(_active_key);
    auto target_line_data = _data_manager->getData<LineData>(target_key);

    if (!source_line_data || !target_line_data) {
        std::cerr << "Could not retrieve source or target LineData" << std::endl;
        return;
    }

    auto current_time = TimeFrameIndex(_data_manager->getCurrentTime());
    auto lines = source_line_data->getAtTime(current_time);

    if (selected_line_index >= static_cast<int>(lines.size())) {
        std::cerr << "Selected line index out of bounds" << std::endl;
        return;
    }

    // Get the selected line and copy it to target
    Line2D selected_line = lines[selected_line_index];
    target_line_data->addAtTime(current_time, selected_line);

    std::cout << "Copied line from " << _active_key << " to " << target_key << std::endl;
}

void MediaLine_Widget::_addPointToDrawAllFrames(float x_media, float y_media) {
    if (_drawAllFramesSelectionWidget && _drawAllFramesSelectionWidget->isDrawingActive()) {
        _drawAllFramesSelectionWidget->addPoint(Point2D<float>{x_media, y_media});
        std::cout << "Added point (" << x_media << ", " << y_media << ") to all frames line" << std::endl;
    }
}

void MediaLine_Widget::_applyLineToAllFrames() {
    if (!_drawAllFramesSelectionWidget || _active_key.empty()) {
        std::cout << "Cannot apply line to all frames: widget not available or no active key" << std::endl;
        return;
    }

    auto line_points = _drawAllFramesSelectionWidget->getCurrentLinePoints();
    if (line_points.empty()) {
        std::cout << "No line points to apply to all frames" << std::endl;
        return;
    }

    auto line_data = _data_manager->getData<LineData>(_active_key);
    if (!line_data) {
        std::cout << "No line data available for active key" << std::endl;
        return;
    }

    // Get all frame times
    auto frame_times = _getAllFrameTimes();
    if (frame_times.empty()) {
        std::cout << "No frame times available" << std::endl;
        return;
    }

    // Create the line from points
    Line2D line_to_apply(line_points);

    // Apply the line to all frames
    int frames_processed = 0;
    for (auto const & frame_time: frame_times) {
        line_data->addAtTime(frame_time, line_to_apply, false);// Don't notify for each frame
        frames_processed++;
    }

    // Notify observers once at the end
    line_data->notifyObservers();

    // Clear the line points after applying
    _drawAllFramesSelectionWidget->clearLinePoints();

    std::cout << "Applied line to " << frames_processed << " frames" << std::endl;
    _scene->UpdateCanvas();
}

std::vector<TimeFrameIndex> MediaLine_Widget::_getAllFrameTimes() {
    std::vector<TimeFrameIndex> frame_times;

    // Get media data to determine total frame count
    auto media_data = _data_manager->getData<MediaData>("media");
    if (!media_data) {
        std::cout << "No media data available" << std::endl;
        return frame_times;
    }

    int total_frames = media_data->getTotalFrameCount();
    if (total_frames <= 0) {
        std::cout << "Invalid frame count: " << total_frames << std::endl;
        return frame_times;
    }

    // Create TimeFrameIndex for each frame
    frame_times.reserve(total_frames);
    for (int i = 0; i < total_frames; ++i) {
        frame_times.emplace_back(i);
    }

    return frame_times;
}

int MediaLine_Widget::_getSelectedLineIndexFromGroupSystem() const {
    // Get the selected entities from the group system
    auto selected_entities = _scene->getSelectedEntities();
    
    // If no entities are selected, return -1
    if (selected_entities.empty()) {
        return -1;
    }
    
    // For now, just return the first selected entity as the line index
    // EntityId for lines corresponds to their index in the line data
    EntityId first_selected = *selected_entities.begin();
    return static_cast<int>(first_selected);
}

paulmthompson / WhiskerToolbox / 18018707227

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous