钉子绕线画

按照绕线画算法这篇博客给出的思路：

我也来尝试一下。

数据结构

      struct Point2 {
     	int x, y;
     	bool operator< (const Point2 b) const
      	{
     		if (x == b.x)return y < b.y;
     		return x < b.x;
      	}
      };
      struct PointPair {
      	Point2 p1, p2;
     	PointPair(Point2 a, Point2 b)
      	{
     		if (a < b)p1 = a, p2 = b;
     		else p1 = b, p2 = a;
      	}
     	bool operator< (const PointPair b)const
      	{
     		if (p1 < b.p1)return true;
     		if (b.p1 < p1)return false;
     		return p2 < b.p2;
      	}
      };
  
 

算法

      Mat imgMask;
      double meanPix(Mat& img, Point2 a, Point2 b)
      {
     	int len = max(abs(a.x - b.x), abs(a.y - b.y));
     	double dx = (a.x - b.x) * 1.0 / len;
     	double dy = (a.y - b.y) * 1.0 / len;
     	double x = b.x, y = b.y;
     	int s = 0;
     	for (int i = 1; i < len; i++) {
      		x += dx, y += dy;
      		s += int(img.at<unsigned char>(int(x), int(y))* imgMask.at<unsigned char>(int(x), int(y)));
      	}
     	return s * 1.0 / len;
      }
      void subPix(Mat& img, Point2 a, Point2 b, int d)
      {
     	int len = max(abs(a.x - b.x), abs(a.y - b.y));
     	double dx = (a.x - b.x) * 1.0 / len;
     	double dy = (a.y - b.y) * 1.0 / len;
     	double x = b.x, y = b.y;
     	int s = 0;
     	for (int i = 1; i < len; i++) {
      		x += dx, y += dy;
     		int pix = img.at<unsigned char>(int(x), int(y));
      		img.at<unsigned char>(int(x), int(y)) = max(0, pix - d);
      	}
      }
      void setPix(Mat& img, Point2 a, Point2 b, int d)
      {
     	int len = max(abs(a.x - b.x), abs(a.y - b.y));
     	double dx = (a.x - b.x) * 1.0 / len;
     	double dy = (a.y - b.y) * 1.0 / len;
     	double x = b.x, y = b.y;
     	int s = 0;
     	for (int i = 1; i < len; i++) {
      		x += dx, y += dy;
      		img.at<unsigned char>(int(x), int(y)) = d;
      	}
      }
      int main()
      {
     	const int n = 600;
     	int lineNum = 800;
      	Mat img = imread("D:/im.jpg", 0);
     	resize(img, img, Size(n + 1, n+ 1));
      	Mat src;
      	img = 255 - img;
     	imshow("img", img);
      	imgMask = img.clone();
     	blur(imgMask, imgMask, Size(19, 19));
     	//imshow("img2", imgMask);
      	vector<Point2>vp;
     	for (int i = 0; i < 360; i++) {
     		double r = i * 3.1415926 / 180;
      		vp.push_back({ int(n / 2 * sin(r)) + 300, int(n / 2 * cos(r)) + 300 });
      	}
      	Point2 p = vp[0];
      	map< Line, int>m;
     	for (auto& pi : vp)m[Line(pi, pi)] = 1;
      	Mat ans = img.clone();
      	ans = 255;
     	while (lineNum--) {
      		Point2 next = p;
     		double s0 = 0;
     		for (auto& pi : vp) {
     			if (m[Line(p, pi)])continue;
     			double s = meanPix(img, p, pi);
     			if (s0 < s)s0 = s, next = pi;
      		}
     		subPix(img, p, next, 100);
     		setPix(ans, p, next, 100);
      		m[Line(p, next)] = 1;
      		p = next;
      	}
     	//imshow("img3", img);
     	imshow("ans", ans);
     	waitKey(0);
     	return 0;
      }
  
 

结果：

 原图：

远处对比：

和某bao上的效果对比，还是有很大差距的。

我想了一下，上面的算法思路虽然简单，但是有效性确实有限。

比如这种情况：

要想一笔画，每一条弦都有用，就很难。

实际上应该运行一部分弦是没用的，这样就能得到这种解：

右边的2条弦没有命中目标，但是很有必要。

所以个人感觉某bao上的AI算法，应该是类似于分割算法，分割成若干直线。

文章来源: blog.csdn.net，作者：csuzhucong，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/nameofcsdn/article/details/124882214