|
|
@@ -0,0 +1,1074 @@
|
|
|
+//#include "stdafx.h"
|
|
|
+#include "ImageLoc.h"
|
|
|
+#include <assert.h>
|
|
|
+#include <time.h>
|
|
|
+#include <numeric>
|
|
|
+#include "helpfunc.h"
|
|
|
+#include "imageView.hpp"
|
|
|
+
|
|
|
+
|
|
|
+using std::to_wstring;
|
|
|
+
|
|
|
+int check_transparent(Image* img)
|
|
|
+{
|
|
|
+ if (img->width < 2 || img->height < 2) return 0;
|
|
|
+ uint c0 = *img->begin();
|
|
|
+ bool x = c0 == img->at<uint>(0, img->width - 1) &&
|
|
|
+ c0 == img->at<uint>(img->height - 1, 0) &&
|
|
|
+ c0 == img->at<uint>(img->height - 1, img->width - 1);
|
|
|
+ if (!x) return 0;
|
|
|
+
|
|
|
+ int ct = 0;
|
|
|
+ for (auto it : *img)
|
|
|
+ if (it == c0) ++ct;
|
|
|
+ int total = img->height * img->width;
|
|
|
+ return total * 0.5 <= ct && ct < total ? ct : 0;
|
|
|
+}
|
|
|
+
|
|
|
+void get_match_points(const Image& img, vector<uint>& points)
|
|
|
+{
|
|
|
+ points.clear();
|
|
|
+ uint cbk = *img.begin();
|
|
|
+ for (int i = 0; i < img.height; ++i) {
|
|
|
+ for (int j = 0; j < img.width; ++j)
|
|
|
+ if (cbk != img.at<uint>(i, j)) points.push_back((i << 16) | j);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void gen_next(const Image& img, vector<int>& next)
|
|
|
+{
|
|
|
+ next.resize(img.width * img.height);
|
|
|
+
|
|
|
+ auto t = img.ptr<int>(0);
|
|
|
+ auto p = next.data();
|
|
|
+ p[0] = -1;
|
|
|
+ int k = -1, j = 0;
|
|
|
+ while (j < next.size() - 1) {
|
|
|
+ if (k == -1 || t[k] == t[j]) {
|
|
|
+ k++;
|
|
|
+ j++;
|
|
|
+ p[j] = k;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ k = p[k];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void Connectivity(const ImageBin& bin, ImageBin& rec) {}
|
|
|
+
|
|
|
+void extractConnectivity(const ImageBin& src, int threshold, std::vector<ImageBin>& out)
|
|
|
+{
|
|
|
+ ImageBin bin = src;
|
|
|
+ for (auto& it : bin) {
|
|
|
+ it = it > threshold ? 0xffu : 0;
|
|
|
+ }
|
|
|
+ ImageBin rec;
|
|
|
+ rec.create(bin.width, bin.height);
|
|
|
+ for (auto& it : rec) {
|
|
|
+ it = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+struct MatchContext {
|
|
|
+ imageView view;
|
|
|
+ Image* pic;
|
|
|
+ ImageBin* gray;
|
|
|
+ color_t dfcolor;
|
|
|
+ int tnorm;
|
|
|
+ vector<uint>& points;
|
|
|
+ int use_ts_match;
|
|
|
+};
|
|
|
+
|
|
|
+enum PicMatchType { PicMatchRGB = 0, PicMatchGray = 1, PicMatchTrans = 2 };
|
|
|
+
|
|
|
+// template <int picMatchType>
|
|
|
+// point_t PicViewMatch(MatchContext context, double sim, bool *stop) {
|
|
|
+// return point_t();
|
|
|
+// }
|
|
|
+// template <>
|
|
|
+// point_t PicViewMatch<PicMatchGray>(MatchContext context, double sim,
|
|
|
+// bool *stop) {
|
|
|
+// // 计算最大误差
|
|
|
+// int max_err_ct =
|
|
|
+// (context.pic->height * context.pic->width - context.use_ts_match) *
|
|
|
+// (1.0 - sim);
|
|
|
+// rect_t &block = context.view._block;
|
|
|
+// for (int i = block.y1; i < block.y2; ++i) {
|
|
|
+// for (int j = block.x1; j < block.x2; ++j) {
|
|
|
+// if (*stop) return point_t(-1, -1);
|
|
|
+// // 开始匹配
|
|
|
+// // quick check
|
|
|
+// if ((double)abs(context.tnorm -
|
|
|
+// region_sum(x, y, x + timg->width, y + timg->height)) /
|
|
|
+// (double)context.tnorm >
|
|
|
+// 1.0 - sim)
|
|
|
+// return 0;
|
|
|
+// int err = 0;
|
|
|
+// int maxErr = (1.0 - sim) * tnorm;
|
|
|
+// for (int i = 0; i < context.gray->height; i++) {
|
|
|
+// auto ptr = context.view._src.ptr(y + i) + x;
|
|
|
+// auto ptr2 = timg->ptr(i);
|
|
|
+// for (int j = 0; j < timg->width; j++) {
|
|
|
+// err += abs(*ptr - *ptr2);
|
|
|
+// ptr++;
|
|
|
+// ptr2++;
|
|
|
+// }
|
|
|
+// if (err > maxErr) return 0;
|
|
|
+// }
|
|
|
+
|
|
|
+// return 1;
|
|
|
+// // simple_match<false>(j, i, pic, dfcolor,tnorm, sim));
|
|
|
+// if (match_ret) {
|
|
|
+// *stop = true;
|
|
|
+// return point_t(j + _x1 + _dx, i + _y1 + _dy);
|
|
|
+// }
|
|
|
+
|
|
|
+// } // end for j
|
|
|
+// } // end for i
|
|
|
+// return point_t(-1, -1);
|
|
|
+//}
|
|
|
+
|
|
|
+ImageBase::ImageBase() : m_threadPool(std::thread::hardware_concurrency()) {
|
|
|
+ _x1 = _y1 = 0;
|
|
|
+ _dx = _dy = 0;
|
|
|
+}
|
|
|
+
|
|
|
+ImageBase::~ImageBase() {}
|
|
|
+
|
|
|
+void ImageBase::set_offset(int x1, int y1) {
|
|
|
+ _x1 = x1;
|
|
|
+ _y1 = y1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::GetPixel(long x, long y, color_t& cr) {
|
|
|
+ auto p = _src.ptr<color_t>(0);
|
|
|
+ // setlog("%d", _src.width);
|
|
|
+ // static_assert(sizeof(color_t) == 4);
|
|
|
+ cr = *p;
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::CmpColor(color_t color, std::vector<color_df_t>& colors,
|
|
|
+ double sim) {
|
|
|
+ for (auto& it : colors) {
|
|
|
+ if (IN_RANGE(color, it.color, it.df)) return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindColor(vector<color_df_t>& colors, int dir, long& x, long& y)
|
|
|
+{
|
|
|
+ for (auto& it : colors) { //对每个颜色描述
|
|
|
+
|
|
|
+ for (int i = 0; i < _src.height; ++i) {
|
|
|
+ auto p = _src.ptr<color_t>(i);
|
|
|
+ for (int j = 0; j < _src.width; ++j) {
|
|
|
+ if (IN_RANGE(*(p + j), it.color, it.df)) {
|
|
|
+ x = j + _x1 + _dx;
|
|
|
+ y = i + _y1 + _dy;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ x = y = -1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindColorEx(vector<color_df_t>& colors, TString& retstr) {
|
|
|
+ retstr.clear();
|
|
|
+ int find_ct = 0;
|
|
|
+ for (int i = 0; i < _src.height; ++i)
|
|
|
+ {
|
|
|
+ auto p = _src.ptr<color_t>(i);
|
|
|
+ for (int j = 0; j < _src.width; ++j)
|
|
|
+ {
|
|
|
+ for (auto& it : colors)
|
|
|
+ { //对每个颜色描述
|
|
|
+ if (IN_RANGE(*p, it.color, it.df))
|
|
|
+ {
|
|
|
+#ifdef UNICODE
|
|
|
+ retstr += std::to_wstring(j + _x1 + _dx) + _T(",") + std::to_wstring(i + _y1 + _dy);
|
|
|
+#else
|
|
|
+ retstr += std::to_string(j + _x1 + _dx) + _T(",") + std::to_string(i + _y1 + _dy);
|
|
|
+#endif
|
|
|
+ retstr += _T("|");
|
|
|
+ ++find_ct;
|
|
|
+ // return 1;
|
|
|
+ if (find_ct > _max_return_obj_ct) goto _quick_break;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+_quick_break:
|
|
|
+ if (!retstr.empty() && retstr.back() == _T('|')) retstr.pop_back();
|
|
|
+ return find_ct;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindMultiColor(std::vector<color_df_t>& first_color, std::vector<pt_cr_df_t>& offset_color, double sim, long dir, long& x, long& y)
|
|
|
+{
|
|
|
+ int max_err_ct = offset_color.size() * (1. - sim);
|
|
|
+ int err_ct;
|
|
|
+ for (int i = 0; i < _src.height; ++i)
|
|
|
+ {
|
|
|
+ auto p = _src.ptr<color_t>(i);
|
|
|
+ for (int j = 0; j < _src.width; ++j)
|
|
|
+ {
|
|
|
+ // step 1. find first color
|
|
|
+ for (auto& it : first_color)
|
|
|
+ { //对每个颜色描述
|
|
|
+ if (IN_RANGE(*p, it.color, it.df))
|
|
|
+ {
|
|
|
+ //匹配其他坐标
|
|
|
+ err_ct = 0;
|
|
|
+ for (auto& off_cr : offset_color)
|
|
|
+ {
|
|
|
+ int ptX = j + off_cr.x;
|
|
|
+ int ptY = i + off_cr.y;
|
|
|
+ if (ptX >= 0 && ptX < _src.width && ptY >= 0 && ptY < _src.height)
|
|
|
+ {
|
|
|
+ color_t currentColor = _src.at<color_t>(ptY, ptX);
|
|
|
+ if (!CmpColor(currentColor, off_cr.crdfs, sim))
|
|
|
+ ++err_ct;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ ++err_ct;
|
|
|
+ }
|
|
|
+ if (err_ct > max_err_ct)
|
|
|
+ goto _quick_break;
|
|
|
+ }
|
|
|
+ // ok
|
|
|
+ x = j + _x1 + _dx, y = i + _y1 + _dy;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _quick_break:
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ x = y = -1;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindMultiColorEx(std::vector<color_df_t>& first_color, std::vector<pt_cr_df_t>& offset_color, double sim, long dir, TString& retstr)
|
|
|
+{
|
|
|
+ int max_err_ct = offset_color.size() * (1. - sim);
|
|
|
+ int err_ct;
|
|
|
+ int find_ct = 0;
|
|
|
+ for (int i = 0; i < _src.height; ++i)
|
|
|
+ {
|
|
|
+ auto p = _src.ptr<color_t>(i);
|
|
|
+ for (int j = 0; j < _src.width; ++j)
|
|
|
+ {
|
|
|
+ // step 1. find first color
|
|
|
+ for (auto& it : first_color)
|
|
|
+ { //对每个颜色描述
|
|
|
+ if (IN_RANGE(*p, it.color, it.df))
|
|
|
+ {
|
|
|
+ //匹配其他坐标
|
|
|
+ err_ct = 0;
|
|
|
+ for (auto& off_cr : offset_color)
|
|
|
+ {
|
|
|
+ /* color_t currentColor = _src.at<color_t>(j + off_cr.x, i + off_cr.y);
|
|
|
+ if (!CmpColor(currentColor, off_cr.crdfs, sim)) ++err_ct;
|
|
|
+ if (err_ct > max_err_ct) goto _quick_break;*/
|
|
|
+
|
|
|
+ //
|
|
|
+ int ptX = j + off_cr.x;
|
|
|
+ int ptY = i + off_cr.y;
|
|
|
+ if (ptX >= 0 && ptX < _src.width && ptY >= 0 && ptY < _src.height)
|
|
|
+ {
|
|
|
+ color_t currentColor = _src.at<color_t>(ptY, ptX);
|
|
|
+ if (!CmpColor(currentColor, off_cr.crdfs, sim))
|
|
|
+ ++err_ct;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ ++err_ct;
|
|
|
+ }
|
|
|
+ if (err_ct > max_err_ct) goto _quick_break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // ok
|
|
|
+#ifdef UNICODE
|
|
|
+ retstr += std::to_wstring(j + _x1 + _dx) + _T(",") + std::to_wstring(i + _y1 + _dy);
|
|
|
+#else
|
|
|
+ retstr += std::to_string(j + _x1 + _dx) + _T(",") + std::to_string(i + _y1 + _dy);
|
|
|
+#endif
|
|
|
+ retstr += _T("|");
|
|
|
+ ++find_ct;
|
|
|
+ if (find_ct > _max_return_obj_ct)
|
|
|
+ goto _quick_return;
|
|
|
+ else
|
|
|
+ goto _quick_break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ _quick_break:
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+_quick_return:
|
|
|
+ if (!retstr.empty() && retstr.back() == _T('|')) retstr.pop_back();
|
|
|
+ return find_ct;
|
|
|
+ // x = y = -1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindPic(std::vector<Image*>& pics, color_t dfcolor, double sim, long& x, long& y)
|
|
|
+{
|
|
|
+ x = y = -1;
|
|
|
+ vector<uint> points;
|
|
|
+ int match_ret = 0;
|
|
|
+ ImageBin gimg;
|
|
|
+ _gray.fromImage4(_src);
|
|
|
+ record_sum(_gray);
|
|
|
+ int tnorm;
|
|
|
+ //将小循环放在最外面，提高处理速度
|
|
|
+ for (int pic_id = 0; pic_id < pics.size(); ++pic_id) {
|
|
|
+ auto pic = pics[pic_id];
|
|
|
+ int use_ts_match = check_transparent(pic);
|
|
|
+ if (use_ts_match)
|
|
|
+ get_match_points(*pic, points);
|
|
|
+ else {
|
|
|
+ gimg.fromImage4(*pic);
|
|
|
+ tnorm = sum(gimg.begin(), gimg.end());
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < _src.height; ++i) {
|
|
|
+ for (int j = 0; j < _src.width; ++j) {
|
|
|
+ // step 1. 边界检查
|
|
|
+ if (i + pic->height > _src.height || j + pic->width > _src.width)
|
|
|
+ continue;
|
|
|
+ // step 2. 计算最大误差
|
|
|
+ int max_err_ct =
|
|
|
+ (pic->height * pic->width - use_ts_match) * (1.0 - sim);
|
|
|
+ // step 3. 开始匹配
|
|
|
+
|
|
|
+ /*match_ret = (use_ts_match ? trans_match<false>(j, i, pic, dfcolor,
|
|
|
+ points, max_err_ct) : simple_match<false>(j, i, pic, dfcolor,
|
|
|
+ max_err_ct));*/
|
|
|
+ match_ret = (use_ts_match ? trans_match<false>(j, i, pic, dfcolor,
|
|
|
+ points, max_err_ct)
|
|
|
+ : real_match(j, i, &gimg, tnorm, sim));
|
|
|
+ // simple_match<false>(j, i, pic, dfcolor,tnorm, sim));
|
|
|
+ if (match_ret) {
|
|
|
+ x = j + _x1 + _dx;
|
|
|
+ y = i + _y1 + _dy;
|
|
|
+ return pic_id;
|
|
|
+ }
|
|
|
+
|
|
|
+ } // end for j
|
|
|
+ } // end for i
|
|
|
+ } // end for pics
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindPicTh(std::vector<Image*>& pics, color_t dfcolor, double sim, long& x, long& y)
|
|
|
+{
|
|
|
+ x = y = -1;
|
|
|
+ vector<uint> points;
|
|
|
+ int match_ret = 0;
|
|
|
+ ImageBin gimg;
|
|
|
+ _gray.fromImage4(_src);
|
|
|
+ record_sum(_gray);
|
|
|
+ int tnorm;
|
|
|
+ std::vector<rect_t> blocks;
|
|
|
+ //将小循环放在最外面，提高处理速度
|
|
|
+ for (int pic_id = 0; pic_id < pics.size(); ++pic_id)
|
|
|
+ {
|
|
|
+ auto pic = pics[pic_id];
|
|
|
+ int use_ts_match = check_transparent(pic);
|
|
|
+ if (use_ts_match)
|
|
|
+ get_match_points(*pic, points);
|
|
|
+ else {
|
|
|
+ gimg.fromImage4(*pic);
|
|
|
+ tnorm = sum(gimg.begin(), gimg.end());
|
|
|
+ }
|
|
|
+ auto pgimg = &gimg;
|
|
|
+ rect_t matchRect(0, 0, _src.width, _src.height);
|
|
|
+ matchRect.shrinkRect(pic->width, pic->height);
|
|
|
+ if (!matchRect.valid()) continue;
|
|
|
+ matchRect.divideBlock(m_threadPool.getThreadNum(),
|
|
|
+ matchRect.width() > matchRect.height(), blocks);
|
|
|
+ std::vector<std::future<point_t>> results;
|
|
|
+ bool stop = false;
|
|
|
+ for (size_t i = 0; i < m_threadPool.getThreadNum(); ++i)
|
|
|
+ {
|
|
|
+ results.push_back(m_threadPool.enqueue(
|
|
|
+ [this, dfcolor, points, pgimg, tnorm](rect_t& block, Image* pic,
|
|
|
+ int use_ts_match, double sim,
|
|
|
+ bool* stop) {
|
|
|
+ // 计算最大误差
|
|
|
+ int max_err_ct =
|
|
|
+ (pic->height * pic->width - use_ts_match) * (1.0 - sim);
|
|
|
+ for (int i = block.y1; i < block.y2; ++i) {
|
|
|
+ for (int j = block.x1; j < block.x2; ++j) {
|
|
|
+ if (*stop) return point_t(-1, -1);
|
|
|
+ // 开始匹配
|
|
|
+ int match_ret =
|
|
|
+ (use_ts_match ? trans_match<false>(j, i, pic, dfcolor,
|
|
|
+ points, max_err_ct)
|
|
|
+ : real_match(j, i, pgimg, tnorm, sim));
|
|
|
+ // simple_match<false>(j, i, pic, dfcolor,tnorm, sim));
|
|
|
+ if (match_ret) {
|
|
|
+ *stop = true;
|
|
|
+ return point_t(j + _x1 + _dx, i + _y1 + _dy);
|
|
|
+ }
|
|
|
+
|
|
|
+ } // end for j
|
|
|
+ } // end for i
|
|
|
+ return point_t(-1, -1);
|
|
|
+ },
|
|
|
+ blocks[i], pic, use_ts_match, sim, &stop));
|
|
|
+ // results.push_back(r);
|
|
|
+ }
|
|
|
+
|
|
|
+ // wait all
|
|
|
+ for (auto&& f : results) {
|
|
|
+ point_t p = f.get();
|
|
|
+ if (p.x != -1) {
|
|
|
+ x = p.x;
|
|
|
+ y = p.y;
|
|
|
+ // return pic_id;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (x != -1) {
|
|
|
+ return pic_id;
|
|
|
+ }
|
|
|
+
|
|
|
+ } // end for pics
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindPicEx(std::vector<Image*>& pics, color_t dfcolor, double sim, vpoint_desc_t& vpd)
|
|
|
+{
|
|
|
+ int obj_ct = 0;
|
|
|
+ vpd.clear();
|
|
|
+ vector<uint> points;
|
|
|
+ bool nodfcolor = color2uint(dfcolor) == 0;
|
|
|
+ int match_ret = 0;
|
|
|
+ ImageBin gimg;
|
|
|
+ _gray.fromImage4(_src);
|
|
|
+ record_sum(_gray);
|
|
|
+ int tnorm;
|
|
|
+ for (int pic_id = 0; pic_id < pics.size(); ++pic_id)
|
|
|
+ {
|
|
|
+ auto pic = pics[pic_id];
|
|
|
+ int use_ts_match = check_transparent(pic);
|
|
|
+
|
|
|
+ if (use_ts_match)
|
|
|
+ get_match_points(*pic, points);
|
|
|
+ else {
|
|
|
+ gimg.fromImage4(*pic);
|
|
|
+ tnorm = sum(gimg.begin(), gimg.end());
|
|
|
+ }
|
|
|
+ for (int i = 0; i < _src.height; ++i)
|
|
|
+ {
|
|
|
+ for (int j = 0; j < _src.width; ++j) {
|
|
|
+ // step 1. 边界检查
|
|
|
+ if (i + pic->height > _src.height || j + pic->width > _src.width)
|
|
|
+ continue;
|
|
|
+ // step 2. 计算最大误差
|
|
|
+ int max_err_ct =
|
|
|
+ (pic->height * pic->width - use_ts_match) * (1.0 - sim);
|
|
|
+ // step 3. 开始匹配
|
|
|
+
|
|
|
+ match_ret = (use_ts_match ? trans_match<false>(j, i, pic, dfcolor,
|
|
|
+ points, max_err_ct)
|
|
|
+ : real_match(j, i, &gimg, tnorm, sim));
|
|
|
+ if (match_ret) {
|
|
|
+ point_desc_t pd = { pic_id, point_t(j + _x1 + _dx, i + _y1 + _dy) };
|
|
|
+
|
|
|
+ vpd.push_back(pd);
|
|
|
+ ++obj_ct;
|
|
|
+ if (obj_ct > _max_return_obj_ct) goto _quick_return;
|
|
|
+ }
|
|
|
+
|
|
|
+ } // end for j
|
|
|
+ } // end for i
|
|
|
+ } // end for pics
|
|
|
+_quick_return:
|
|
|
+
|
|
|
+ return obj_ct;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindPicExTh(std::vector<Image*>& pics, color_t dfcolor, double sim, vpoint_desc_t& vpd)
|
|
|
+{
|
|
|
+ vpd.clear();
|
|
|
+ int obj_ct = 0;
|
|
|
+ vector<uint> points;
|
|
|
+ int match_ret = 0;
|
|
|
+ ImageBin gimg;
|
|
|
+ _gray.fromImage4(_src);
|
|
|
+ record_sum(_gray);
|
|
|
+ int tnorm;
|
|
|
+ std::vector<rect_t> blocks;
|
|
|
+ //将小循环放在最外面，提高处理速度
|
|
|
+ for (int pic_id = 0; pic_id < pics.size(); ++pic_id) {
|
|
|
+ auto pic = pics[pic_id];
|
|
|
+ int use_ts_match = check_transparent(pic);
|
|
|
+ if (use_ts_match)
|
|
|
+ get_match_points(*pic, points);
|
|
|
+ else {
|
|
|
+ gimg.fromImage4(*pic);
|
|
|
+ tnorm = sum(gimg.begin(), gimg.end());
|
|
|
+ }
|
|
|
+ auto pgimg = &gimg;
|
|
|
+ rect_t matchRect(0, 0, _src.width, _src.height);
|
|
|
+ matchRect.shrinkRect(pic->width, pic->height);
|
|
|
+ if (!matchRect.valid()) continue;
|
|
|
+ matchRect.divideBlock(m_threadPool.getThreadNum(),
|
|
|
+ matchRect.width() > matchRect.height(), blocks);
|
|
|
+ std::vector<std::future<vpoint_t>> results;
|
|
|
+ for (size_t i = 0; i < m_threadPool.getThreadNum(); ++i)
|
|
|
+ {
|
|
|
+ results.push_back(m_threadPool.enqueue(
|
|
|
+ [this, dfcolor, points, pgimg, tnorm](rect_t& block, Image* pic,
|
|
|
+ int use_ts_match, double sim)->vpoint_t {
|
|
|
+ vpoint_t vp;
|
|
|
+ // 计算最大误差
|
|
|
+ int max_err_ct =
|
|
|
+ (pic->height * pic->width - use_ts_match) * (1.0 - sim);
|
|
|
+ for (int i = block.y1; i < block.y2; ++i) {
|
|
|
+ for (int j = block.x1; j < block.x2; ++j) {
|
|
|
+ // 开始匹配
|
|
|
+ int match_ret =
|
|
|
+ (use_ts_match ? trans_match<false>(j, i, pic, dfcolor,
|
|
|
+ points, max_err_ct)
|
|
|
+ : real_match(j, i, pgimg, tnorm, sim));
|
|
|
+ // simple_match<false>(j, i, pic, dfcolor,tnorm, sim));
|
|
|
+ if (match_ret) {
|
|
|
+ vp.push_back(point_t(j + _x1 + _dx, i + _y1 + _dy));
|
|
|
+ }
|
|
|
+
|
|
|
+ } // end for j
|
|
|
+ } // end for i
|
|
|
+ return vp;
|
|
|
+ },
|
|
|
+ blocks[i], pic, use_ts_match, sim));
|
|
|
+ // results.push_back(r);
|
|
|
+ }
|
|
|
+ // wait all
|
|
|
+ for (auto&& f : results) {
|
|
|
+ vpoint_t vp = f.get();
|
|
|
+ if (vp.size() > 0) {
|
|
|
+
|
|
|
+ for (auto& p : vp) {
|
|
|
+ point_desc_t pd = { pic_id,p };
|
|
|
+
|
|
|
+ vpd.push_back(pd);
|
|
|
+ ++obj_ct;
|
|
|
+ if (obj_ct > _max_return_obj_ct) goto _quick_return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // return pic_id;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+_quick_return:
|
|
|
+
|
|
|
+ return obj_ct;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindColorBlock(double sim, long count, long height, long width, long& x, long& y)
|
|
|
+{
|
|
|
+ x = y = -1;
|
|
|
+ record_sum(_binary);
|
|
|
+ for (int i = 0; i <= _binary.height - height; ++i) {
|
|
|
+ for (int j = 0; j < _binary.width - width; ++j) {
|
|
|
+ if (region_sum(j, i, j + width, i + height) >= count) {
|
|
|
+ x = j + _x1 + _dx;
|
|
|
+ y = i + _y1 + _dy;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindColorBlockEx(double sim, long count, long height, long width, TString& retstr)
|
|
|
+{
|
|
|
+ record_sum(_binary);
|
|
|
+ int cnt = 0;
|
|
|
+ for (int i = 0; i <= _binary.height - height; ++i) {
|
|
|
+ for (int j = 0; j < _binary.width - width; ++j) {
|
|
|
+ if (region_sum(j, i, j + width, i + height) >= count) {
|
|
|
+ TCHAR buff[20];
|
|
|
+ wsprintf(buff, _T("%d,%d|"), j + _x1 + _dx, i + _y1 + _dy);
|
|
|
+ retstr += buff;
|
|
|
+ ++cnt;
|
|
|
+ if (cnt > _max_return_obj_ct) goto _quick_return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+_quick_return:
|
|
|
+ if (cnt) {
|
|
|
+ retstr.pop_back();
|
|
|
+ }
|
|
|
+ return cnt;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::FindLine(double sim, TString& outStr)
|
|
|
+{
|
|
|
+ outStr.clear();
|
|
|
+ int h = sqrt(_binary.width * _binary.width + _binary.height * _binary.height) + 2;
|
|
|
+ _sum.create(360, h);
|
|
|
+ //行：距离，列：角度
|
|
|
+ _sum.fill(0);
|
|
|
+ for (int i = 0; i < _binary.height; i++)
|
|
|
+ {
|
|
|
+ for (int j = 0; j < _binary.width; j++) {
|
|
|
+ if (_binary.at(i, j) == WORD_COLOR) {
|
|
|
+ for (int t = 0; t < 360; t++) {
|
|
|
+ int d =
|
|
|
+ j * cos(t * 0.0174532925) + i * sin(t * 0.0174532925); //可以优化
|
|
|
+ assert(d <= h);
|
|
|
+ if (d >= 0) _sum.at<int>(d, t)++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ int maxRow = 0, maxCol = 0;
|
|
|
+ int maxval = -1;
|
|
|
+ for (int i = 0; i < _sum.height; i++)
|
|
|
+ {
|
|
|
+ for (int j = 0; j < _sum.width; j++) {
|
|
|
+ if (_sum.at<int>(i, j) > maxval) {
|
|
|
+ maxRow = i;
|
|
|
+ maxCol = j;
|
|
|
+ maxval = _sum.at<int>(i, j);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // setlog("degree=%d,dis=%d,val=%d", maxCol, maxRow, maxval);
|
|
|
+ TCHAR buffer[256];
|
|
|
+ wsprintf(buffer, _T("%d,%d"), maxCol, maxRow);
|
|
|
+ outStr = buffer;
|
|
|
+ return maxval;
|
|
|
+}
|
|
|
+
|
|
|
+template <bool nodfcolor>
|
|
|
+long ImageBase::simple_match(long x, long y, Image* timg, color_t dfcolor, int tnorm, double sim)
|
|
|
+{
|
|
|
+ int err_ct = 0;
|
|
|
+ // quick check
|
|
|
+ if ((double)abs(tnorm - region_sum(x, y, x + timg->width, y + timg->height)) >
|
|
|
+ (double)tnorm * (1.0 - sim))
|
|
|
+ return 0;
|
|
|
+ int max_error = (1.0 - sim) * timg->size();
|
|
|
+ uint* pscreen_top, * pscreen_bottom, * pimg_top, * pimg_bottom;
|
|
|
+ pscreen_top = _src.ptr<uint>(y) + x;
|
|
|
+ pscreen_bottom = _src.ptr<uint>(y + timg->height - 1) + x;
|
|
|
+ pimg_top = timg->ptr<uint>(0);
|
|
|
+ pimg_bottom = timg->ptr<uint>(timg->height - 1);
|
|
|
+ while (pscreen_top <= pscreen_bottom)
|
|
|
+ {
|
|
|
+ auto ps1 = pscreen_top, ps2 = pscreen_top + timg->width - 1;
|
|
|
+ auto ps3 = pscreen_bottom, ps4 = pscreen_bottom + timg->width - 1;
|
|
|
+ auto pt1 = pimg_top, pt2 = pimg_top + timg->width - 1;
|
|
|
+ auto pt3 = pimg_bottom, pt4 = pimg_bottom + timg->width - 1;
|
|
|
+ while (ps1 <= ps2) {
|
|
|
+ if (nodfcolor) {
|
|
|
+ if (*ps1++ != *pt1++) ++err_ct; // top left
|
|
|
+ if (*ps2-- != *pt2--) ++err_ct; // top right
|
|
|
+ if (*ps3++ != *pt3++) ++err_ct; // bottom left
|
|
|
+ if (*ps4-- != *pt4--) ++err_ct; // bottom right
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if (!IN_RANGE(*(color_t*)ps1++, *(color_t*)pt1++, dfcolor)) ++err_ct;
|
|
|
+ if (!IN_RANGE(*(color_t*)ps2--, *(color_t*)pt2--, dfcolor)) ++err_ct;
|
|
|
+ if (!IN_RANGE(*(color_t*)ps3++, *(color_t*)pt3++, dfcolor)) ++err_ct;
|
|
|
+ if (!IN_RANGE(*(color_t*)ps4--, *(color_t*)pt4--, dfcolor)) ++err_ct;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (err_ct > max_error) return 0;
|
|
|
+ }
|
|
|
+ pscreen_top += _src.width;
|
|
|
+ pscreen_bottom -= _src.width;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+template <bool nodfcolor>
|
|
|
+long ImageBase::trans_match(long x, long y, Image* timg, color_t dfcolor, vector<uint> pts, int max_error)
|
|
|
+{
|
|
|
+ int err_ct = 0, k, dx, dy;
|
|
|
+ int left, right;
|
|
|
+ left = 0;
|
|
|
+ right = pts.size() - 1;
|
|
|
+ while (left <= right)
|
|
|
+ {
|
|
|
+ auto it = pts[left];
|
|
|
+ if (nodfcolor) {
|
|
|
+ if (_src.at<uint>(y + PTY(pts[left]), x + PTX(pts[left])) !=
|
|
|
+ timg->at<uint>(PTY(pts[left]), PTX(pts[left])))
|
|
|
+ ++err_ct;
|
|
|
+ if (_src.at<uint>(y + PTY(pts[right]), x + PTX(pts[right])) !=
|
|
|
+ timg->at<uint>(PTY(pts[right]), PTX(pts[right])))
|
|
|
+ ++err_ct;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ color_t cr1, cr2;
|
|
|
+ cr1 = _src.at<color_t>(y + PTY(pts[left]), x + PTX(pts[left]));
|
|
|
+ cr2 = timg->at<color_t>(PTY(pts[left]), PTX(pts[left]));
|
|
|
+ if (!IN_RANGE(cr1, cr2, dfcolor)) ++err_ct;
|
|
|
+ cr1 = _src.at<color_t>(y + PTY(pts[right]), x + PTX(pts[right]));
|
|
|
+ cr2 = timg->at<color_t>(PTY(pts[right]), PTX(pts[right]));
|
|
|
+ if (!IN_RANGE(cr1, cr2, dfcolor)) ++err_ct;
|
|
|
+ }
|
|
|
+
|
|
|
+ ++left;
|
|
|
+ --right;
|
|
|
+ if (err_ct > max_error) return 0;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+long ImageBase::real_match(long x, long y, ImageBin* timg, int tnorm, double sim)
|
|
|
+{
|
|
|
+ // quick check
|
|
|
+ if ((double)abs(tnorm - region_sum(x, y, x + timg->width, y + timg->height)) / (double)tnorm > 1.0 - sim)
|
|
|
+ return 0;
|
|
|
+ int err = 0;
|
|
|
+ int maxErr = (1.0 - sim) * tnorm;
|
|
|
+ for (int i = 0; i < timg->height; i++) {
|
|
|
+ auto ptr = _gray.ptr(y + i) + x;
|
|
|
+ auto ptr2 = timg->ptr(i);
|
|
|
+ for (int j = 0; j < timg->width; j++) {
|
|
|
+ err += abs(*ptr - *ptr2);
|
|
|
+ ptr++;
|
|
|
+ ptr2++;
|
|
|
+ }
|
|
|
+ if (err > maxErr) return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+void ImageBase::record_sum(const ImageBin& gray)
|
|
|
+{
|
|
|
+ //为了减少边界判断，这里多多加一行一列
|
|
|
+ _sum.create(gray.width + 1, gray.height + 1);
|
|
|
+ _sum.fill(0);
|
|
|
+ int m = _sum.height;
|
|
|
+ int n = _sum.width;
|
|
|
+ for (int i = 1; i < m; i++) {
|
|
|
+ for (int j = 1; j < n; j++) {
|
|
|
+ int s = 0;
|
|
|
+
|
|
|
+ s += _sum.at<int>(i - 1, j);
|
|
|
+
|
|
|
+ s += _sum.at<int>(i, j - 1);
|
|
|
+
|
|
|
+ s -= _sum.at<int>(i - 1, j - 1);
|
|
|
+ s += (int)gray.at(i - 1, j - 1);
|
|
|
+ _sum.at<int>(i, j) = s;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+int ImageBase::region_sum(int x1, int y1, int x2, int y2) {
|
|
|
+ int ans = _sum.at<int>(y2, x2) - _sum.at<int>(y2, x1) - _sum.at<int>(y1, x2) +
|
|
|
+ _sum.at<int>(y1, x1);
|
|
|
+ return ans;
|
|
|
+}
|
|
|
+
|
|
|
+constexpr int MIN_CUT_W = 5;
|
|
|
+constexpr int MIN_CUT_H = 2;
|
|
|
+
|
|
|
+int ImageBase::get_bk_color(inputbin bin) {
|
|
|
+ int y[256] = { 0 };
|
|
|
+ auto ptr = bin.pixels.data();
|
|
|
+ int n = bin.pixels.size();
|
|
|
+ for (int i = 0; i < n; ++i) y[ptr[i]]++;
|
|
|
+ // scan max
|
|
|
+ int m = 0;
|
|
|
+ for (int i = 1; i < 256; ++i) {
|
|
|
+ if (y[i] > y[m]) m = i;
|
|
|
+ }
|
|
|
+ return m;
|
|
|
+}
|
|
|
+
|
|
|
+void ImageBase::bgr2binary(vector<color_df_t>& colors) {
|
|
|
+ if (_src.empty()) return;
|
|
|
+ int ncols = _src.width, nrows = _src.height;
|
|
|
+ _binary.fromImage4(_src);
|
|
|
+ for (int i = 0; i < nrows; ++i) {
|
|
|
+ auto psrc = _src.ptr<color_t>(i);
|
|
|
+
|
|
|
+ auto pbin = _binary.ptr(i);
|
|
|
+ for (int j = 0; j < ncols; ++j) {
|
|
|
+ uchar g1 = psrc->toGray();
|
|
|
+ *pbin = WORD_BKCOLOR;
|
|
|
+ for (auto& it : colors) { //对每个颜色描述
|
|
|
+ if (abs(g1 - it.color.toGray()) <= it.df.toGray()) {
|
|
|
+ *pbin = WORD_COLOR;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ++pbin;
|
|
|
+ ++psrc;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //_binary.create(ncols, nrows);
|
|
|
+ // for (int i = 0; i < nrows; ++i) {
|
|
|
+ // auto psrc = _src.ptr<color_t>(i);
|
|
|
+ // auto pbin = _binary.ptr(i);
|
|
|
+ // for (int j = 0; j < ncols; ++j) {
|
|
|
+ // *pbin = WORD_BKCOLOR;
|
|
|
+ // for (auto& it : colors) {//对每个颜色描述
|
|
|
+ // if (IN_RANGE(*psrc, it.color, it.df)) {
|
|
|
+ // *pbin = WORD_COLOR;
|
|
|
+ // break;
|
|
|
+ // }
|
|
|
+ // }
|
|
|
+ // ++pbin; ++psrc;
|
|
|
+ // }
|
|
|
+ //}
|
|
|
+ // test
|
|
|
+ // cv::imwrite("src.png", _src);
|
|
|
+ // cv::imwrite("binary.png", _binary);
|
|
|
+}
|
|
|
+
|
|
|
+//二值化
|
|
|
+void ImageBase::bgr2binarybk(const vector<color_df_t>& bk_colors) {
|
|
|
+ //创建二值图
|
|
|
+ _binary.create(_src.width, _src.height);
|
|
|
+ memset(_binary.pixels.data(), WORD_BKCOLOR, _binary.size());
|
|
|
+ int n = _binary.size();
|
|
|
+ auto pdst = _binary.data();
|
|
|
+ if (bk_colors.size() == 0) { // auto
|
|
|
+ //转为灰度图
|
|
|
+ _gray.fromImage4(_src);
|
|
|
+
|
|
|
+ //获取背景颜色
|
|
|
+ int bkcolor = get_bk_color(_gray);
|
|
|
+
|
|
|
+ auto pgray = _gray.data();
|
|
|
+ for (int i = 0; i < n; ++i) {
|
|
|
+ pdst[i] =
|
|
|
+ (std::abs((int)pgray[i] - bkcolor) < 20 ? WORD_BKCOLOR : WORD_COLOR);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ for (auto bk : bk_colors) {
|
|
|
+ for (int i = 0; i < n; ++i) {
|
|
|
+ auto c = (color_t*)(_src.pdata + i * 4);
|
|
|
+ if (!IN_RANGE(*c, bk.color, bk.df)) pdst[i] = WORD_COLOR;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//垂直方向投影到x轴
|
|
|
+void ImageBase::binshadowx(const rect_t& rc, std::vector<rect_t>& out_put) {
|
|
|
+ // qDebug("in x rc:%d,%d,%d,%d", rc.x1, rc.y1, rc.x2, rc.y2);
|
|
|
+ out_put.clear();
|
|
|
+ // ys.clear();
|
|
|
+ // Mat paintx(binary.size(), CV_8UC1, cv::Scalar(255));
|
|
|
+ // //创建一个全白图片，用作显示
|
|
|
+
|
|
|
+ // int* blackcout = new int[binary.cols];
|
|
|
+ std::vector<int> vx;
|
|
|
+ vx.resize(_binary.width);
|
|
|
+ memset(&vx[0], 0, _binary.width * 4);
|
|
|
+ for (int j = rc.x1; j < rc.x2; j++) {
|
|
|
+ for (int i = rc.y1; i < rc.y2; i++) {
|
|
|
+ if (_binary.at(i, j) == WORD_COLOR) {
|
|
|
+ vx[j]++; //垂直投影按列在x轴进行投影
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int startindex = 0;
|
|
|
+ int endindex = 0;
|
|
|
+ bool inblock = false; //是否遍历到字符位置
|
|
|
+ rect_t roi;
|
|
|
+ for (int j = rc.x1; j < rc.x2; j++) {
|
|
|
+ if (!inblock && vx[j] != 0) //进入有字符区域
|
|
|
+ {
|
|
|
+ inblock = true;
|
|
|
+ startindex = j;
|
|
|
+ // std::cout << "startindex:" << startindex << std::endl;
|
|
|
+ }
|
|
|
+ // if (inblock&&vx[j] == 0) //进入空白区
|
|
|
+ else if (inblock && vx[j] == 0 &&
|
|
|
+ j - startindex >= MIN_CUT_W) //进入空白区域，且宽度不小于1
|
|
|
+ {
|
|
|
+ endindex = j;
|
|
|
+ inblock = false;
|
|
|
+ // Mat roi = binary.colRange(startindex, endindex + 1);
|
|
|
+
|
|
|
+ roi.x1 = startindex;
|
|
|
+ roi.y1 = rc.y1;
|
|
|
+ roi.x2 = endindex;
|
|
|
+ roi.y2 = rc.y2;
|
|
|
+ // qDebug("out xrc:%d,%d,%d,%d", roi.x1, roi.y1, roi.x2, roi.y2);
|
|
|
+ out_put.push_back(roi);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // special case
|
|
|
+ if (inblock) {
|
|
|
+ roi.x1 = startindex;
|
|
|
+ roi.y1 = rc.y1;
|
|
|
+ roi.x2 = rc.x2;
|
|
|
+ roi.y2 = rc.y2;
|
|
|
+ out_put.push_back(roi);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//投影到y轴
|
|
|
+void ImageBase::binshadowy(const rect_t& rc, std::vector<rect_t>& out_put) {
|
|
|
+ // qDebug("in y rc:%d,%d,%d,%d", rc.x1, rc.y1, rc.x2, rc.y2);
|
|
|
+ out_put.clear();
|
|
|
+ //是否为白色或者黑色根据二值图像的处理得来
|
|
|
+ // Mat painty(binary.size(), CV_8UC1, cv::Scalar(255)); //初始化为全白
|
|
|
+ //水平投影
|
|
|
+ // int* pointcount = new int[binary.rows]; //在二值图片中记录行中特征点的个数
|
|
|
+ std::vector<int> vy;
|
|
|
+ vy.resize(_binary.height);
|
|
|
+ memset(&vy[0], 0, _binary.height * 4); //注意这里需要进行初始化
|
|
|
+
|
|
|
+ for (int i = rc.y1; i < rc.y2; i++) {
|
|
|
+ for (int j = rc.x1; j < rc.x2; j++) {
|
|
|
+ if (_binary.at(i, j) == WORD_COLOR) {
|
|
|
+ vy[i]++; //记录每行中黑色点的个数 //水平投影按行在y轴上的投影
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // std::vector<Mat> result;
|
|
|
+ int startindex = 0;
|
|
|
+ int endindex = 0;
|
|
|
+ bool inblock = false; //是否遍历到字符位置
|
|
|
+ rect_t roi;
|
|
|
+ for (int i = rc.y1; i < rc.y2; i++) {
|
|
|
+ if (!inblock && vy[i] != 0) //进入有字符区域
|
|
|
+ {
|
|
|
+ inblock = true;
|
|
|
+ startindex = i;
|
|
|
+ // std::cout << "startindex:" << startindex << std::endl;
|
|
|
+ }
|
|
|
+ // if (inblock&&vy[i] == 0) //进入空白区
|
|
|
+ if (inblock && vy[i] == 0 &&
|
|
|
+ i - startindex >= MIN_CUT_H) //进入空白区,且高度不小于1
|
|
|
+ {
|
|
|
+ endindex = i;
|
|
|
+ inblock = false;
|
|
|
+
|
|
|
+ roi.x1 = rc.x1;
|
|
|
+ roi.y1 = startindex;
|
|
|
+ roi.x2 = rc.x2;
|
|
|
+ roi.y2 = endindex;
|
|
|
+ out_put.push_back(roi);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (inblock) {
|
|
|
+ roi.x1 = rc.x1;
|
|
|
+ roi.y1 = startindex;
|
|
|
+ roi.x2 = rc.x2;
|
|
|
+ roi.y2 = rc.y2;
|
|
|
+ out_put.push_back(roi);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void ImageBase::bin_image_cut(int min_word_h, const rect_t& inrc, rect_t& outrc)
|
|
|
+{
|
|
|
+ //水平裁剪，缩小高度
|
|
|
+ std::vector<int> v;
|
|
|
+ outrc = inrc;
|
|
|
+ int i, j;
|
|
|
+ v.resize(_binary.height);
|
|
|
+ for (auto& it : v) it = 0;
|
|
|
+ for (i = inrc.y1; i < inrc.y2; ++i) {
|
|
|
+ for (j = inrc.x1; j < inrc.x2; ++j)
|
|
|
+ v[i] += (_binary.at(i, j) == WORD_COLOR ? 1 : 0);
|
|
|
+ }
|
|
|
+ i = inrc.y1;
|
|
|
+ while (v[i] == 0) i++;
|
|
|
+ outrc.y1 = i;
|
|
|
+ i = inrc.y2 - 1;
|
|
|
+ while (v[i] == 0) i--;
|
|
|
+ if (i + 1 - outrc.y1 > min_word_h) outrc.y2 = i + 1;
|
|
|
+ //垂直裁剪.缩小宽度
|
|
|
+ v.resize(_binary.width);
|
|
|
+ for (auto& it : v) it = 0;
|
|
|
+
|
|
|
+ for (i = inrc.y1; i < inrc.y2; ++i) {
|
|
|
+ for (j = inrc.x1; j < inrc.x2; ++j)
|
|
|
+ v[j] += _binary.at(i, j) == WORD_COLOR ? 1 : 0;
|
|
|
+ }
|
|
|
+ i = inrc.x1;
|
|
|
+ while (v[i] == 0) i++;
|
|
|
+ outrc.x1 = i;
|
|
|
+ i = inrc.x2 - 1;
|
|
|
+ while (v[i] == 0) i--;
|
|
|
+ outrc.x2 = i + 1;
|
|
|
+}
|
|
|
+
|
|
|
+void ImageBase::get_rois(int min_word_h, std::vector<rect_t>& vroi)
|
|
|
+{
|
|
|
+ vroi.clear();
|
|
|
+ std::vector<rect_t> vrcx, vrcy;
|
|
|
+ rect_t rc;
|
|
|
+ rc.x1 = rc.y1 = 0;
|
|
|
+ rc.x2 = _binary.width;
|
|
|
+ rc.y2 = _binary.height;
|
|
|
+ binshadowy(rc, vrcy);
|
|
|
+ for (int i = 0; i < vrcy.size(); ++i) {
|
|
|
+ binshadowx(vrcy[i], vrcx);
|
|
|
+ for (int j = 0; j < vrcx.size(); j++) {
|
|
|
+ if (vrcx[j].width() >= min_word_h)
|
|
|
+ bin_image_cut(min_word_h, vrcx[j], vrcx[j]);
|
|
|
+ vroi.push_back(vrcx[j]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+inline int full_match(const ImageBin& binary, rect_t& rc, const uint8_t* data) {
|
|
|
+ //匹配
|
|
|
+ int idx = 0;
|
|
|
+ for (int x = rc.x1; x < rc.x2; ++x) {
|
|
|
+ for (int y = rc.y1; y < rc.y2; ++y) {
|
|
|
+ int val = GET_BIT(data[idx / 8], idx & 7);
|
|
|
+ if (binary.at(y, x) != val) return 0;
|
|
|
+ idx++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+inline int part_match(const ImageBin& binary, rect_t& rc, int max_error,
|
|
|
+ const uint8_t* data) {
|
|
|
+ //匹配
|
|
|
+ //匹配
|
|
|
+ int err_ct = 0;
|
|
|
+ int idx = 0;
|
|
|
+ for (int x = rc.x1; x < rc.x2; ++x) {
|
|
|
+ for (int y = rc.y1; y < rc.y2; ++y) {
|
|
|
+ int val = GET_BIT(data[idx / 8], idx & 7);
|
|
|
+ if (binary.at(y, x) != val) {
|
|
|
+ ++err_ct;
|
|
|
+ if (err_ct > max_error) return 0;
|
|
|
+ }
|
|
|
+ idx++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+inline void fill_rect(ImageBin& record, const rect_t& rc) {
|
|
|
+ int w = rc.width();
|
|
|
+ for (int y = rc.y1; y < rc.y2; ++y) {
|
|
|
+ uchar* p = record.ptr(y) + rc.x1;
|
|
|
+ memset(p, 1, sizeof(uchar) * w);
|
|
|
+ }
|
|
|
+}
|
