fz-mirrors/MaaAssistantArknights
0
0
Fork 0
mirror of https://github.com/MaaAssistantArknights/MaaAssistantArknights.git synced 2026-07-17 10:00:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

chore.重命名一个task config key, 与文档保持同步

Browse Source
This commit is contained in:
MistEO
2022-03-07 15:42:57 +08:00
parent a680092a71
commit d2a18a5f9f
4 changed files with 202 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/MeoAssistant/AsstTypes.h
View File

@@ -231,7 +231,7 @@ namespace asst
{
virtual ~OcrTaskInfo() = default;
std::vector<std::string> text; // 文字的容器，匹配到这里面任一个，就算匹配上了
bool need_full_match = false; // 是否需要全匹配，否则搜索到子串就算匹配上了
bool full_match = false; // 是否需要全匹配，否则搜索到子串就算匹配上了
std::unordered_map<std::string, std::string>
replace_map; // 部分文字容易识别错，字符串强制replace之后，再进行匹配
};

206
src/MeoAssistant/OcrImageAnalyzer.cpp
View File

@@ -9,155 +9,155 @@
bool asst::OcrImageAnalyzer::analyze()
{
m_ocr_result.clear();
m_ocr_result.clear();
std::vector<TextRectProc> preds_vec;
std::vector<TextRectProc> preds_vec;
if (!m_replace.empty()) {
TextRectProc text_replace = [&](TextRect& tr) -> bool {
for (const auto& [regex, new_str] : m_replace) {
tr.text = std::regex_replace(tr.text, std::regex(regex), new_str);
}
return true;
};
preds_vec.emplace_back(text_replace);
}
if (!m_replace.empty()) {
TextRectProc text_replace = [&](TextRect& tr) -> bool {
for (const auto& [regex, new_str] : m_replace) {
tr.text = std::regex_replace(tr.text, std::regex(regex), new_str);
}
return true;
};
preds_vec.emplace_back(text_replace);
}
if (!m_required.empty()) {
if (m_full_match) {
TextRectProc required_match = [&](TextRect& tr) -> bool {
return std::find(m_required.cbegin(), m_required.cend(), tr.text) != m_required.cend();
};
preds_vec.emplace_back(required_match);
}
else {
TextRectProc required_search = [&](TextRect& tr) -> bool {
auto is_sub = [&tr](const std::string& str) -> bool {
if (tr.text.find(str) == std::string::npos) {
return false;
}
tr.text = str;
return true;
};
return std::find_if(m_required.cbegin(), m_required.cend(), is_sub) != m_required.cend();
};
preds_vec.emplace_back(required_search);
}
}
if (!m_required.empty()) {
if (m_full_match) {
TextRectProc required_match = [&](TextRect& tr) -> bool {
return std::find(m_required.cbegin(), m_required.cend(), tr.text) != m_required.cend();
};
preds_vec.emplace_back(required_match);
}
else {
TextRectProc required_search = [&](TextRect& tr) -> bool {
auto is_sub = [&tr](const std::string& str) -> bool {
if (tr.text.find(str) == std::string::npos) {
return false;
}
tr.text = str;
return true;
};
return std::find_if(m_required.cbegin(), m_required.cend(), is_sub) != m_required.cend();
};
preds_vec.emplace_back(required_search);
}
}
preds_vec.emplace_back(m_pred);
preds_vec.emplace_back(m_pred);
TextRectProc all_pred = [&](TextRect& tr) -> bool {
for (const auto& pred : preds_vec) {
if (pred && !pred(tr)) {
return false;
}
}
return true;
};
TextRectProc all_pred = [&](TextRect& tr) -> bool {
for (const auto& pred : preds_vec) {
if (pred && !pred(tr)) {
return false;
}
}
return true;
};
auto& aip_ocr = Resrc.cfg().get_options().aip_ocr;
bool need_local = true;
if (aip_ocr.enable) {
if (aip_ocr.accurate) {
need_local = !AipOcr::get_instance().request_ocr_accurate(m_image, m_ocr_result, all_pred);
}
else {
need_local = !AipOcr::get_instance().request_ocr_general(m_image, m_ocr_result, all_pred);
}
}
if (need_local) {
m_ocr_result = Resrc.ocr().recognize(m_image, m_roi, all_pred, m_without_det);
}
//log.trace("ocr result", m_ocr_result);
return !m_ocr_result.empty();
auto& aip_ocr = Resrc.cfg().get_options().aip_ocr;
bool need_local = true;
if (aip_ocr.enable) {
if (aip_ocr.accurate) {
need_local = !AipOcr::get_instance().request_ocr_accurate(m_image, m_ocr_result, all_pred);
}
else {
need_local = !AipOcr::get_instance().request_ocr_general(m_image, m_ocr_result, all_pred);
}
}
if (need_local) {
m_ocr_result = Resrc.ocr().recognize(m_image, m_roi, all_pred, m_without_det);
}
//log.trace("ocr result", m_ocr_result);
return !m_ocr_result.empty();
}
void asst::OcrImageAnalyzer::set_use_cache(bool is_use) noexcept
{
m_use_cache = is_use;
m_use_cache = is_use;
}
void asst::OcrImageAnalyzer::set_required(std::vector<std::string> required, bool full_match) noexcept
{
m_required = std::move(required);
m_full_match = full_match;
m_required = std::move(required);
m_full_match = full_match;
}
void asst::OcrImageAnalyzer::set_replace(std::unordered_map<std::string, std::string> replace) noexcept
{
m_replace = std::move(replace);
m_replace = std::move(replace);
}
void asst::OcrImageAnalyzer::set_task_info(OcrTaskInfo task_info) noexcept
{
m_required = std::move(task_info.text);
m_full_match = task_info.need_full_match;
m_replace = std::move(task_info.replace_map);
m_use_cache = task_info.cache;
m_required = std::move(task_info.text);
m_full_match = task_info.full_match;
m_replace = std::move(task_info.replace_map);
m_use_cache = task_info.cache;
if (m_use_cache && !m_region_of_appeared.empty()) {
m_roi = m_region_of_appeared;
m_without_det = true;
}
else {
set_roi(task_info.roi);
m_without_det = false;
}
if (m_use_cache && !m_region_of_appeared.empty()) {
m_roi = m_region_of_appeared;
m_without_det = true;
}
else {
set_roi(task_info.roi);
m_without_det = false;
}
}
void asst::OcrImageAnalyzer::set_task_info(std::shared_ptr<TaskInfo> task_ptr)
{
set_task_info(*std::dynamic_pointer_cast<OcrTaskInfo>(task_ptr));
set_task_info(*std::dynamic_pointer_cast<OcrTaskInfo>(task_ptr));
}
void asst::OcrImageAnalyzer::set_region_of_appeared(Rect region) noexcept
{
m_region_of_appeared = std::move(region);
if (m_use_cache && !m_region_of_appeared.empty()) {
m_roi = m_region_of_appeared;
m_without_det = true;
}
m_region_of_appeared = std::move(region);
if (m_use_cache && !m_region_of_appeared.empty()) {
m_roi = m_region_of_appeared;
m_without_det = true;
}
}
void asst::OcrImageAnalyzer::set_pred(const TextRectProc& pred)
{
m_pred = pred;
m_pred = pred;
}
const std::vector<asst::TextRect>& asst::OcrImageAnalyzer::get_result() const noexcept
{
return m_ocr_result;
return m_ocr_result;
}
void asst::OcrImageAnalyzer::sort_result()
{
// 按位置排个序
std::sort(m_ocr_result.begin(), m_ocr_result.end(),
[](const TextRect& lhs, const TextRect& rhs) -> bool {
if (std::abs(lhs.rect.y - rhs.rect.y) < 5) { // y差距较小则理解为是同一排的，按x排序
return lhs.rect.x < rhs.rect.x;
}
else {
return lhs.rect.y < rhs.rect.y;
}
}
);
// 按位置排个序
std::sort(m_ocr_result.begin(), m_ocr_result.end(),
[](const TextRect& lhs, const TextRect& rhs) -> bool {
if (std::abs(lhs.rect.y - rhs.rect.y) < 5) { // y差距较小则理解为是同一排的，按x排序
return lhs.rect.x < rhs.rect.x;
}
else {
return lhs.rect.y < rhs.rect.y;
}
}
);
}
void asst::OcrImageAnalyzer::sort_result_by_required()
{
if (m_required.empty()) {
return;
}
if (m_required.empty()) {
return;
}
std::unordered_map<std::string, size_t> m_req_cache;
for (size_t i = 0; i != m_required.size(); ++i) {
m_req_cache.emplace(m_required.at(i), i + 1);
}
std::unordered_map<std::string, size_t> m_req_cache;
for (size_t i = 0; i != m_required.size(); ++i) {
m_req_cache.emplace(m_required.at(i), i + 1);
}
std::sort(m_ocr_result.begin(), m_ocr_result.end(),
[&m_req_cache](const auto& lhs, const auto& rhs) -> bool {
return m_req_cache[lhs.text] < m_req_cache[rhs.text];
});
}
std::sort(m_ocr_result.begin(), m_ocr_result.end(),
[&m_req_cache](const auto& lhs, const auto& rhs) -> bool {
return m_req_cache[lhs.text] < m_req_cache[rhs.text];
});
}

194
src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
View File

@@ -10,137 +10,137 @@
#include "RuntimeStatus.h"
asst::ProcessTaskImageAnalyzer::ProcessTaskImageAnalyzer(const cv::Mat image, std::vector<std::string> tasks_name)
: AbstractImageAnalyzer(image),
m_tasks_name(std::move(tasks_name))
: AbstractImageAnalyzer(image),
m_tasks_name(std::move(tasks_name))
{
;
;
}
asst::ProcessTaskImageAnalyzer::~ProcessTaskImageAnalyzer() = default;
bool asst::ProcessTaskImageAnalyzer::match_analyze(std::shared_ptr<TaskInfo> task_ptr)
{
if (!m_match_analyzer) {
m_match_analyzer = std::make_unique<MatchImageAnalyzer>(m_image);
}
const auto match_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(task_ptr);
m_match_analyzer->set_task_info(match_task_ptr);
auto region_opt = m_status->get_region(match_task_ptr->name);
if (region_opt) {
m_match_analyzer->set_region_of_appeared(region_opt.value());
}
if (!m_match_analyzer) {
m_match_analyzer = std::make_unique<MatchImageAnalyzer>(m_image);
}
const auto match_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(task_ptr);
m_match_analyzer->set_task_info(match_task_ptr);
auto region_opt = m_status->get_region(match_task_ptr->name);
if (region_opt) {
m_match_analyzer->set_region_of_appeared(region_opt.value());
}
if (m_match_analyzer->analyze()) {
m_result = match_task_ptr;
m_result_rect = m_match_analyzer->get_result().rect;
m_status->set_region(match_task_ptr->name, m_result_rect);
return true;
}
return false;
if (m_match_analyzer->analyze()) {
m_result = match_task_ptr;
m_result_rect = m_match_analyzer->get_result().rect;
m_status->set_region(match_task_ptr->name, m_result_rect);
return true;
}
return false;
}
bool asst::ProcessTaskImageAnalyzer::ocr_analyze(std::shared_ptr<TaskInfo> task_ptr)
{
std::shared_ptr<OcrTaskInfo> ocr_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(task_ptr);
std::shared_ptr<OcrTaskInfo> ocr_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(task_ptr);
// 先尝试从缓存的结果里找
//for (const TextRect& tr : m_ocr_cache) {
// TextRect temp = tr;
// for (const auto& [regex, new_str] : ocr_task_ptr->replace_map) {
// temp.text = std::regex_replace(temp.text, std::regex(regex), new_str);
// }
// for (const auto& text : ocr_task_ptr->text) {
// bool flag = false;
// if (ocr_task_ptr->need_full_match) {
// if (temp.text == text) {
// flag = true;
// }
// }
// else if (temp.text.find(text) != std::string::npos) {
// flag = true;
// }
// // 即使找到了，也得在ROI里才行，不然过滤掉
// if (flag && ocr_task_ptr->roi.include(tr.rect)) {
// m_result = ocr_task_ptr;
// m_result_rect = tr.rect;
// ocr_task_ptr->region_of_appeared = m_result_rect;
// Log.trace("ProcessTaskImageAnalyzer::ocr_analyze | found in cache", tr.to_string());
// return true;
// }
// }
//}
if (!m_ocr_analyzer) {
m_ocr_analyzer = std::make_unique<OcrImageAnalyzer>(m_image);
}
m_ocr_analyzer->set_task_info(ocr_task_ptr);
auto region_opt = m_status->get_region(ocr_task_ptr->name);
if (region_opt) {
m_ocr_analyzer->set_region_of_appeared(region_opt.value());
}
// 先尝试从缓存的结果里找
//for (const TextRect& tr : m_ocr_cache) {
// TextRect temp = tr;
// for (const auto& [regex, new_str] : ocr_task_ptr->replace_map) {
// temp.text = std::regex_replace(temp.text, std::regex(regex), new_str);
// }
// for (const auto& text : ocr_task_ptr->text) {
// bool flag = false;
// if (ocr_task_ptr->full_match) {
// if (temp.text == text) {
// flag = true;
// }
// }
// else if (temp.text.find(text) != std::string::npos) {
// flag = true;
// }
// // 即使找到了，也得在ROI里才行，不然过滤掉
// if (flag && ocr_task_ptr->roi.include(tr.rect)) {
// m_result = ocr_task_ptr;
// m_result_rect = tr.rect;
// ocr_task_ptr->region_of_appeared = m_result_rect;
// Log.trace("ProcessTaskImageAnalyzer::ocr_analyze | found in cache", tr.to_string());
// return true;
// }
// }
//}
if (!m_ocr_analyzer) {
m_ocr_analyzer = std::make_unique<OcrImageAnalyzer>(m_image);
}
m_ocr_analyzer->set_task_info(ocr_task_ptr);
auto region_opt = m_status->get_region(ocr_task_ptr->name);
if (region_opt) {
m_ocr_analyzer->set_region_of_appeared(region_opt.value());
}
bool ret = m_ocr_analyzer->analyze();
bool ret = m_ocr_analyzer->analyze();
if (ret) {
m_ocr_analyzer->sort_result_by_required();
const auto& ocr_result = m_ocr_analyzer->get_result();
auto& res = ocr_result.front();
m_result = ocr_task_ptr;
m_result_rect = res.rect;
m_status->set_region(ocr_task_ptr->name, m_result_rect);
//m_ocr_cache.insert(m_ocr_cache.end(), ocr_result.begin(), ocr_result.end());
Log.trace("ProcessTaskImageAnalyzer::ocr_analyze | found", res.to_string());
}
return ret;
if (ret) {
m_ocr_analyzer->sort_result_by_required();
const auto& ocr_result = m_ocr_analyzer->get_result();
auto& res = ocr_result.front();
m_result = ocr_task_ptr;
m_result_rect = res.rect;
m_status->set_region(ocr_task_ptr->name, m_result_rect);
//m_ocr_cache.insert(m_ocr_cache.end(), ocr_result.begin(), ocr_result.end());
Log.trace("ProcessTaskImageAnalyzer::ocr_analyze | found", res.to_string());
}
return ret;
}
void asst::ProcessTaskImageAnalyzer::reset() noexcept
{
//m_ocr_cache.clear();
m_ocr_analyzer = nullptr;
m_match_analyzer = nullptr;
//m_ocr_cache.clear();
m_ocr_analyzer = nullptr;
m_match_analyzer = nullptr;
}
bool asst::ProcessTaskImageAnalyzer::analyze()
{
m_result = nullptr;
m_result_rect = Rect();
m_result = nullptr;
m_result_rect = Rect();
for (const std::string& task_name : m_tasks_name) {
auto task_ptr = m_task_data->get(task_name);
for (const std::string& task_name : m_tasks_name) {
auto task_ptr = m_task_data->get(task_name);
switch (task_ptr->algorithm) {
case AlgorithmType::JustReturn:
m_result = task_ptr;
return true;
case AlgorithmType::MatchTemplate:
if (match_analyze(task_ptr)) {
return true;
}
break;
case AlgorithmType::OcrDetect:
if (ocr_analyze(task_ptr)) {
return true;
}
break;
default:
break;
}
}
return false;
switch (task_ptr->algorithm) {
case AlgorithmType::JustReturn:
m_result = task_ptr;
return true;
case AlgorithmType::MatchTemplate:
if (match_analyze(task_ptr)) {
return true;
}
break;
case AlgorithmType::OcrDetect:
if (ocr_analyze(task_ptr)) {
return true;
}
break;
default:
break;
}
}
return false;
}
void asst::ProcessTaskImageAnalyzer::set_image(const cv::Mat image)
{
AbstractImageAnalyzer::set_image(image);
reset();
AbstractImageAnalyzer::set_image(image);
reset();
}
void asst::ProcessTaskImageAnalyzer::set_tasks(std::vector<std::string> tasks_name)
{
m_tasks_name = std::move(tasks_name);
m_tasks_name = std::move(tasks_name);
}
void asst::ProcessTaskImageAnalyzer::set_status(std::shared_ptr<RuntimeStatus> status) noexcept
{
m_status = status;
}
m_status = status;
}

2
src/MeoAssistant/TaskData.cpp
View File

@@ -85,7 +85,7 @@ bool asst::StaticTaskData::parse(const json::value& json)
for (const json::value& text : task_json.at("text").as_array()) {
ocr_task_info_ptr->text.emplace_back(text.as_string());
}
ocr_task_info_ptr->need_full_match = task_json.get("need_match", false);
ocr_task_info_ptr->full_match = task_json.get("fullMatch", false);
if (task_json.contains("ocrReplace")) {
for (const json::value& rep : task_json.at("ocrReplace").as_array()) {
ocr_task_info_ptr->replace_map.emplace(rep.as_array()[0].as_string(), rep.as_array()[1].as_string());