refactor: nn

Author: MistEO

source/MaaFramework/Instance/InstanceInternalAPI.hpp

@@ -17,20 +17,22 @@ class ControllerAgent;
 MAA_CTRL_NS_END
 
 MAA_NS_BEGIN
-class InstanceStatus;
-MAA_NS_END
 
-MAA_VISION_NS_BEGIN
-class CustomRecognizer;
-using CustomRecognizerPtr = std::shared_ptr<CustomRecognizer>;
-MAA_VISION_NS_END
+class InstanceStatus;
 
-MAA_TASK_NS_BEGIN
-class CustomAction;
-using CustomActionPtr = std::shared_ptr<CustomAction>;
-MAA_TASK_NS_END
+struct CustomRecognizerSession
+{
+    MaaCustomRecognizerHandle recognizer_ = nullptr;
+    MaaTransparentArg recognizer_arg_ = nullptr;
+    InstanceInternalAPI* inst_ = nullptr;
+};
 
-MAA_NS_BEGIN
+struct CustomActionSession
+{
+    MaaCustomActionHandle action_ = nullptr;
+    MaaTransparentArg action_arg_ = nullptr;
+    InstanceInternalAPI* inst_ = nullptr;
+};
 
 struct InstanceInternalAPI : public NonCopyable
 {
@@ -39,8 +41,8 @@ struct InstanceInternalAPI : public NonCopyable
     virtual MAA_CTRL_NS::ControllerAgent* inter_controller() = 0;
     virtual InstanceStatus* inter_status() = 0;
     virtual void notify(std::string_view msg, const json::value& details = json::value()) = 0;
-    virtual MAA_VISION_NS::CustomRecognizerPtr custom_recognizer(const std::string& name) = 0;
-    virtual MAA_TASK_NS::CustomActionPtr custom_action(const std::string& name) = 0;
+    virtual CustomRecognizerSession custom_recognizer(const std::string& name) = 0;
+    virtual CustomActionSession custom_action(const std::string& name) = 0;
 };
 
-MAA_NS_END
+MAA_NS_END

source/MaaFramework/Vision/NeuralNetworkClassifier.cpp

@@ -8,56 +8,63 @@
 
 MAA_VISION_NS_BEGIN
 
-std::pair<NeuralNetworkClassifier::ResultsVec, size_t> NeuralNetworkClassifier::analyze() const
+NeuralNetworkClassifier::NeuralNetworkClassifier(
+    cv::Mat image,
+    NeuralNetworkClassifierParam param,
+    std::shared_ptr<Ort::Session> session,
+    std::string name)
+    : VisionBase(std::move(image), std::move(name))
+    , param_(std::move(param))
+    , session_(std::move(session))
+{
+    analyze();
+}
+
+void NeuralNetworkClassifier::analyze()
 {
     LogFunc << name_;
 
     if (!session_) {
         LogError << "OrtSession not loaded";
-        return {};
+        return;
     }
     if (param_.cls_size == 0) {
         LogError << "cls_size == 0";
-        return {};
+        return;
     }
     if (param_.cls_size != param_.labels.size()) {
         LogError << "cls_size != labels.size()" << VAR(param_.cls_size)
                  << VAR(param_.labels.size());
-        return {};
+        return;
     }
 
     auto start_time = std::chrono::steady_clock::now();
-    ResultsVec results = foreach_rois();
-    auto cost = duration_since(start_time);
-    LogTrace << name_ << "Raw:" << VAR(results) << VAR(cost);
 
-    const auto& expected = param_.expected;
-    filter(results, expected);
+    auto results = classify_all_rois();
+    add_results(std::move(results), param_.expected);
 
-    cost = duration_since(start_time);
-    LogTrace << name_ << "Filter:" << VAR(results) << VAR(expected) << VAR(cost);
+    sort();
 
-    sort(results);
-    size_t index = preferred_index(results);
-    return { results, index };
+    auto cost = duration_since(start_time);
+    LogTrace << name_ << VAR(all_results_) << VAR(filtered_results_) << VAR(cost);
 }
 
-NeuralNetworkClassifier::ResultsVec NeuralNetworkClassifier::foreach_rois() const
+NeuralNetworkClassifier::ResultsVec NeuralNetworkClassifier::classify_all_rois()
 {
     if (param_.roi.empty()) {
         return { classify(cv::Rect(0, 0, image_.cols, image_.rows)) };
     }
-
-    ResultsVec results;
-    for (const cv::Rect& roi : param_.roi) {
-        Result res = classify(roi);
-        results.emplace_back(std::move(res));
+    else {
+        ResultsVec results;
+        for (const cv::Rect& roi : param_.roi) {
+            Result res = classify(roi);
+            results.emplace_back(std::move(res));
+        }
+        return results;
     }
-
-    return results;
 }
 
-NeuralNetworkClassifier::Result NeuralNetworkClassifier::classify(const cv::Rect& roi) const
+NeuralNetworkClassifier::Result NeuralNetworkClassifier::classify(const cv::Rect& roi)
 {
     if (!session_) {
         LogError << "OrtSession not loaded";
@@ -114,17 +121,33 @@ NeuralNetworkClassifier::Result NeuralNetworkClassifier::classify(const cv::Rect
     result.label = param_.labels[result.cls_index];
     result.box = roi;
 
-    draw_result(result);
+    if (debug_draw_) {
+        auto draw = draw_result(result);
+        handle_draw(draw);
+    }
 
     return result;
 }
 
-void NeuralNetworkClassifier::draw_result(const Result& res) const
+void NeuralNetworkClassifier::add_results(ResultsVec results, const std::vector<size_t>& expected)
 {
-    if (!debug_draw_) {
-        return;
-    }
+    std::ranges::copy_if(results, std::back_inserter(filtered_results_), [&](const auto& res) {
+        return std::ranges::find(expected, res.cls_index) != expected.end();
+    });
+
+    merge_vector_(all_results_, std::move(results));
+}
+
+void NeuralNetworkClassifier::sort()
+{
+    sort_(all_results_);
+    sort_(filtered_results_);
+
+    handle_index(filtered_results_.size(), param_.result_index);
+}
 
+cv::Mat NeuralNetworkClassifier::draw_result(const Result& res) const
+{
     cv::Mat image_draw = draw_roi(res.box);
     cv::Point pt(res.box.x + res.box.width + 5, res.box.y + 20);
 
@@ -140,21 +163,10 @@ void NeuralNetworkClassifier::draw_result(const Result& res) const
         pt.y += 20;
     }
 
-    handle_draw(image_draw);
-}
-
-void NeuralNetworkClassifier::filter(ResultsVec& results, const std::vector<size_t>& expected) const
-{
-    if (expected.empty()) {
-        return;
-    }
-
-    std::erase_if(results, [&](const Result& res) {
-        return std::find(expected.begin(), expected.end(), res.cls_index) == expected.end();
-    });
+    return image_draw;
 }
 
-void NeuralNetworkClassifier::sort(ResultsVec& results) const
+void NeuralNetworkClassifier::sort_(ResultsVec& results) const
 {
     switch (param_.order_by) {
     case ResultOrderBy::Horizontal:
@@ -178,14 +190,4 @@ void NeuralNetworkClassifier::sort(ResultsVec& results) const
     }
 }
 
-size_t NeuralNetworkClassifier::preferred_index(const ResultsVec& results) const
-{
-    auto index_opt = pythonic_index(results.size(), param_.result_index);
-    if (!index_opt) {
-        return SIZE_MAX;
-    }
-
-    return *index_opt;
-}
-
-MAA_VISION_NS_END
+MAA_VISION_NS_END

source/MaaFramework/Vision/NeuralNetworkClassifier.h

@@ -1,4 +1,5 @@
 #pragma once
+#pragma once
 
 #include <ostream>
 #include <vector>
@@ -29,23 +30,36 @@ class NeuralNetworkClassifier : public VisionBase
     using ResultsVec = std::vector<Result>;
 
 public:
-    void set_param(NeuralNetworkClassifierParam param) { param_ = std::move(param); }
+    NeuralNetworkClassifier(
+        cv::Mat image,
+        NeuralNetworkClassifierParam param,
+        std::shared_ptr<Ort::Session> session,
+        std::string name = "");
 
-    void set_session(std::shared_ptr<Ort::Session> session) { session_ = std::move(session); }
+    const ResultsVec& all_results() const { return all_results_; }
 
-    std::pair<ResultsVec, size_t> analyze() const;
+    const ResultsVec& filtered_results() const { return filtered_results_; }
 
 private:
-    ResultsVec foreach_rois() const;
-    Result classify(const cv::Rect& roi) const;
-    void draw_result(const Result& res) const;
+    void analyze();
+
+    ResultsVec classify_all_rois();
+    Result classify(const cv::Rect& roi);
 
-    void filter(ResultsVec& results, const std::vector<size_t>& expected) const;
-    void sort(ResultsVec& results) const;
-    size_t preferred_index(const ResultsVec& results) const;
+    void add_results(ResultsVec results, const std::vector<size_t>& expected);
+    void sort();
+
+private:
+    cv::Mat draw_result(const Result& res) const;
+    void sort_(ResultsVec& results) const;
 
-    NeuralNetworkClassifierParam param_;
+private:
+    const NeuralNetworkClassifierParam param_;
     std::shared_ptr<Ort::Session> session_ = nullptr;
+
+private:
+    ResultsVec all_results_;
+    ResultsVec filtered_results_;
 };
 
 MAA_VISION_NS_END