add more image display UI

Author: Gin

SerialPrograms/CMakeLists.txt

@@ -894,6 +894,12 @@ file(GLOB MAIN_SOURCES
     Source/ML/ML_Panels.h
     Source/ML/Programs/ML_LabelImages.cpp
     Source/ML/Programs/ML_LabelImages.h
+    Source/ML/UI/ML_ImageDisplayCommandRow.cpp
+    Source/ML/UI/ML_ImageDisplayCommandRow.h
+    Source/ML/UI/ML_ImageDisplayOption.cpp
+    Source/ML/UI/ML_ImageDisplayOption.h
+    Source/ML/UI/ML_ImageDisplaySession.cpp
+    Source/ML/UI/ML_ImageDisplaySession.h
     Source/ML/UI/ML_ImageDisplayWidget.cpp
     Source/ML/UI/ML_ImageDisplayWidget.h
     Source/NintendoSwitch/Commands/NintendoSwitch_Commands_PushButtons.cpp

SerialPrograms/Source/ML/Programs/ML_LabelImages.cpp

@@ -195,7 +195,6 @@ LabelImages_Descriptor::LabelImages_Descriptor()
 
 LabelImages::LabelImages(const LabelImages_Descriptor& descriptor)
     : PanelInstance(descriptor)
-    , m_switch_control_option({}, false)
     , m_options(LockMode::UNLOCK_WHILE_RUNNING)
     , X("<b>X Coordinate:</b>", LockMode::UNLOCK_WHILE_RUNNING, 0.3, 0.0, 1.0)
     , Y("<b>Y Coordinate:</b>", LockMode::UNLOCK_WHILE_RUNNING, 0.3, 0.0, 1.0)
@@ -413,12 +412,12 @@ LabelImages_Widget::~LabelImages_Widget(){
 }
 LabelImages_Widget::LabelImages_Widget(
     QWidget& parent,
-    LabelImages& instance,
+    LabelImages& program,
     PanelHolder& holder
 )
-    : PanelWidget(parent, instance, holder)
-    , m_program(instance)
-    , m_session(instance.m_switch_control_option, 0, 0)
+    : PanelWidget(parent, program, holder)
+    , m_program(program)
+    , m_session(program.m_switch_control_option, 0, 0)
     , m_overlay_set(m_session.overlay())
     , m_drawn_box(*this, m_session.overlay())
 {
@@ -453,10 +452,10 @@ LabelImages_Widget::LabelImages_Widget(
         program.update_rendered_objects(this->m_overlay_set);
     });
 
-    m_option_widget = instance.m_options.make_QtWidget(*scroll_inner);
+    m_option_widget = program.m_options.make_QtWidget(*scroll_inner);
     scroll_layout->addWidget(&m_option_widget->widget());
 
-    const VideoSourceDescriptor* video_source_desc = instance.m_switch_control_option.m_video.descriptor().get();
+    const VideoSourceDescriptor* video_source_desc = program.m_switch_control_option.m_video.descriptor().get();
     auto image_source_desc = dynamic_cast<const VideoSourceDescriptor_StillImage*>(video_source_desc);
     if (image_source_desc != nullptr){
         const std::string image_path = image_source_desc->path();

SerialPrograms/Source/ML/Programs/ML_LabelImages.h

@@ -20,6 +20,8 @@
 #include "CommonFramework/VideoPipeline/VideoOverlayScopes.h"
 #include <QGraphicsScene>
 #include "ML/DataLabeling/SegmentAnythingModel.h"
+#include "ML/UI/ML_ImageDisplayOption.h"
+#include "ML/UI/ML_ImageDisplaySession.h"
 
 class QGraphicsView;
 class QGraphicsPixmapItem;
@@ -78,9 +80,8 @@ class LabelImages : public PanelInstance{
 private:
     friend class LabelImages_Widget;
     friend class DrawnBoundingBox;
-    // switch control options like what micro-controller 
-    // and what video source to use
-    NintendoSwitch::SwitchSystemOption m_switch_control_option;
+    // image display options like what image file is loaded
+    ImageDisplayOption m_switch_control_option;
     // the group option that holds rest of the options defined below:
     BatchOption m_options;
 
@@ -143,7 +144,7 @@ class LabelImages_Widget : public PanelWidget, public ConfigOption::Listener{
 
 private:
     LabelImages& m_program;
-    NintendoSwitch::SwitchSystemSession m_session;
+    ImageDisplaySession m_session;
     ImageDisplayWidget* m_switch_widget;
     VideoOverlaySet m_overlay_set;
     DrawnBoundingBox m_drawn_box;

SerialPrograms/Source/ML/UI/ML_ImageDisplayCommandRow.cpp

@@ -0,0 +1,264 @@
+/*  Command Row
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <QHBoxLayout>
+#include "Common/Qt/Options/ConfigWidget.h"
+#include "CommonFramework/GlobalSettingsPanel.h"
+#include "CommonFramework/Options/Environment/ThemeSelectorOption.h"
+#include "CommonFramework/Recording/StreamHistoryOption.h"
+#include "ML_ImageDisplayCommandRow.h"
+
+//#include <iostream>
+//using std::cout;
+//using std::endl;
+
+namespace PokemonAutomation{
+namespace ML{
+
+
+ImageDisplayCommandRow::~ImageDisplayCommandRow(){
+    m_session.remove_listener(*this);
+}
+ImageDisplayCommandRow::ImageDisplayCommandRow(
+    QWidget& parent,
+    VideoOverlaySession& session
+)
+    : QWidget(&parent)
+    , m_session(session)
+    , m_last_known_focus(false)
+    , m_last_known_state(ProgramState::STOPPED)
+{
+    QHBoxLayout* command_row = new QHBoxLayout(this);
+    command_row->setContentsMargins(0, 0, 0, 0);
+
+    command_row->addWidget(new QLabel("<b>Console Type:</b>", this), 2);
+    command_row->addSpacing(5);
+
+    QHBoxLayout* row = new QHBoxLayout();
+    command_row->addLayout(row, 12);
+
+
+#if 0
+    row->addWidget(new QLabel("<b>Keyboard Input:</b>", this), 2);
+    row->addSpacing(5);
+#endif
+
+    row->addStretch(100);
+
+    m_status = new QLabel(this);
+//    m_status->setVisible(false);
+    row->addWidget(m_status);
+    row->addSpacing(5);
+
+//    row->addWidget(new QLabel("<b>Overlays:<b>", this));
+
+    m_overlay_boxes = new QCheckBox("Boxes", this);
+    m_overlay_boxes->setChecked(session.enabled_boxes());
+    row->addWidget(m_overlay_boxes);
+
+    m_overlay_text = new QCheckBox("Text", this);
+    m_overlay_text->setHidden(true);    //  Nothing uses text overlay yet.
+    m_overlay_text->setChecked(session.enabled_text());
+    row->addWidget(m_overlay_text);
+
+    if (PreloadSettings::instance().DEVELOPER_MODE){
+        m_overlay_images = new QCheckBox("Masks", this);
+        m_overlay_images->setChecked(session.enabled_images());
+        row->addWidget(m_overlay_images);
+    }
+
+    m_overlay_log = new QCheckBox("Log", this);
+    m_overlay_log->setChecked(session.enabled_log());
+    row->addWidget(m_overlay_log);
+
+    m_overlay_stats = new QCheckBox("Stats", this);
+    m_overlay_stats->setChecked(session.enabled_stats());
+    row->addWidget(m_overlay_stats);
+
+    row->addSpacing(5);
+
+    m_load_profile_button = new QPushButton("Load Profile", this);
+    row->addWidget(m_load_profile_button, 2);
+
+    m_save_profile_button = new QPushButton("Save Profile", this);
+    row->addWidget(m_save_profile_button, 2);
+
+    m_screenshot_button = new QPushButton("Screenshot", this);
+//    m_screenshot_button->setToolTip("Take a screenshot of the console and save to disk.");
+    row->addWidget(m_screenshot_button, 2);
+
+
+//    m_test_button = new QPushButton("Test Button", this);
+//    row->addWidget(m_test_button, 3);
+
+    update_ui();
+
+    connect(
+        m_overlay_boxes, &QCheckBox::clicked,
+        this, [this](bool checked){ m_session.set_enabled_boxes(checked); }
+    );
+#if QT_VERSION < 0x060700
+    connect(
+        m_overlay_text, &QCheckBox::stateChanged,
+        this, [this](bool checked){ m_session.set_enabled_text(checked); }
+    );
+    connect(
+        m_overlay_images, &QCheckBox::stateChanged,
+        this, [this](bool checked){ m_session.set_enabled_images(checked); }
+    );
+    connect(
+        m_overlay_log, &QCheckBox::stateChanged,
+        this, [this](bool checked){ m_session.set_enabled_log(checked); }
+    );
+    connect(
+        m_overlay_stats, &QCheckBox::stateChanged,
+        this, [this](bool checked){ m_session.set_enabled_stats(checked); }
+    );
+#else
+    connect(
+        m_overlay_text, &QCheckBox::checkStateChanged,
+        this, [this](Qt::CheckState state){ m_session.set_enabled_text(state == Qt::Checked); }
+    );
+    if (PreloadSettings::instance().DEVELOPER_MODE){
+        connect(
+            m_overlay_images, &QCheckBox::checkStateChanged,
+            this, [this](Qt::CheckState state){ m_session.set_enabled_images(state == Qt::Checked); }
+        );
+    }
+    connect(
+        m_overlay_log, &QCheckBox::checkStateChanged,
+        this, [this](Qt::CheckState state){ m_session.set_enabled_log(state == Qt::Checked); }
+    );
+    connect(
+        m_overlay_stats, &QCheckBox::checkStateChanged,
+        this, [this](Qt::CheckState state){ m_session.set_enabled_stats(state == Qt::Checked); }
+    );
+#endif
+    connect(
+        m_load_profile_button, &QPushButton::clicked,
+        this, [this](bool) { emit load_profile(); }
+    );
+    connect(
+        m_save_profile_button, &QPushButton::clicked,
+        this, [this](bool) { emit save_profile(); }
+    );
+    connect(
+        m_screenshot_button, &QPushButton::clicked,
+        this, [this](bool){ emit screenshot_requested(); }
+    );
+
+#if (QT_VERSION_MAJOR == 6) && (QT_VERSION_MINOR >= 8)
+    if (IS_BETA_VERSION || PreloadSettings::instance().DEVELOPER_MODE){
+        m_video_button = new QPushButton("Video Capture", this);
+        command_row->addWidget(m_video_button, 2);
+        if (GlobalSettings::instance().STREAM_HISTORY->enabled()){
+            connect(
+                m_video_button, &QPushButton::clicked,
+                this, [this](bool){ emit video_requested(); }
+            );
+        }else{
+            m_video_button->setEnabled(false);
+            m_video_button->setToolTip("Please turn on Stream History to enable video capture.");
+        }
+    }
+#endif
+
+    m_session.add_listener(*this);
+}
+
+void ImageDisplayCommandRow::on_key_press(const QKeyEvent& key){
+    if (!m_last_known_focus){
+        m_session.add_log("Keyboard Command Suppressed: Not in focus.", COLOR_RED);
+        return;
+    }
+}
+void ImageDisplayCommandRow::on_key_release(const QKeyEvent& key){}
+
+void ImageDisplayCommandRow::set_focus(bool focused){
+    if (m_last_known_focus == focused){
+        return;
+    }
+    m_last_known_focus = focused;
+    update_ui();
+}
+
+void ImageDisplayCommandRow::update_ui(){
+//    cout << "ImageDisplayCommandRow::update_ui(): focus = " << m_last_known_focus << endl;
+
+    bool stopped = m_last_known_state == ProgramState::STOPPED;
+    m_load_profile_button->setEnabled(stopped);
+
+    if (!m_last_known_focus){
+        m_status->setText(
+            QString::fromStdString(
+                "Keyboard: " + html_color_text("&#x2b24;", COLOR_PURPLE)
+            )
+        );
+        return;
+    }
+
+    m_status->setText(
+        QString::fromStdString(
+            "Keyboard: " + html_color_text("&#x2b24;", COLOR_DARKGREEN)
+        )
+    );
+}
+
+void ImageDisplayCommandRow::on_state_changed(ProgramState state){
+    m_last_known_state = state;
+    update_ui();
+}
+
+
+void ImageDisplayCommandRow::on_overlay_enabled_boxes(bool enabled){
+    QMetaObject::invokeMethod(this, [this, enabled]{
+        this->m_overlay_boxes->setChecked(enabled);
+    }, Qt::QueuedConnection);
+}
+void ImageDisplayCommandRow::on_overlay_enabled_text(bool enabled){
+    QMetaObject::invokeMethod(this, [this, enabled]{
+        this->m_overlay_text->setChecked(enabled);
+    }, Qt::QueuedConnection);
+}
+void ImageDisplayCommandRow::on_overlay_enabled_images(bool enabled){
+    QMetaObject::invokeMethod(this, [this, enabled]{
+        this->m_overlay_images->setChecked(enabled);
+    }, Qt::QueuedConnection);
+}
+void ImageDisplayCommandRow::on_overlay_enabled_log(bool enabled){
+    QMetaObject::invokeMethod(this, [this, enabled]{
+        this->m_overlay_log->setChecked(enabled);
+    }, Qt::QueuedConnection);
+}
+void ImageDisplayCommandRow::on_overlay_enabled_stats(bool enabled){
+    QMetaObject::invokeMethod(this, [this, enabled]{
+        this->m_overlay_stats->setChecked(enabled);
+    }, Qt::QueuedConnection);
+}
+void ImageDisplayCommandRow::ready_changed(bool ready){
+//    cout << "ImageDisplayCommandRow::ready_changed(): " << ready << endl;
+    QMetaObject::invokeMethod(this, [this]{
+        update_ui();
+    }, Qt::QueuedConnection);
+}
+
+
+
+
+}
+}
+
+
+
+
+
+
+
+
+
+
+
+