平滑边缘

最新推荐文章于 2023-11-01 15:45:11 发布

Rareay

最新推荐文章于 2023-11-01 15:45:11 发布

阅读量3.8k

点赞数 5

分类专栏： # Opencv 文章标签： opencv 计算机视觉

本文链接：https://blog.csdn.net/qq_33236581/article/details/109407745

版权

Opencv 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

原创文章点击这里

1 Bezier数学原理

二阶贝塞尔曲线

图中， $P_1$ 为控制点，参数 $t$ 从 $[0, 1]$ 中取值，可以用下面的公式计算出从 $P_0$ 演变为 $P_2$ 过程中的点：

$B(t)=(1-t)^2 P_0 + 2t(1-t)P_1 + t^2P_2, t\in[0,1]$

三阶贝塞尔曲线

图中， $P_1$ 和 $P_2$ 为控制点，参数 $t$ 从 $[0, 1]$ 中取值，可以用下面的公式计算出从 $P_0$ 演变为 $P_3$ 过程中的点：

$B(t)=P_0(1-t)^3+3P_1t(1-t)^2+3P_2t^2(1-t)+P_3t^3,t\in[0,1]$

2 平滑有锯齿的多边形

平滑边缘是在 opencv 基础上完成的，主要思路如图所示：

图中，第一步是缩小尺寸，是为了缩小边缘的干扰，然后在缩小图的基础之上做中值滤波。这里为什么不直接对原图做中值滤波呢？主要是因为对原图做中值滤波需要较大的参数，计算量呈指数级增长，经测试，对上面的原图做中值滤波需要把参数设为25,运算时间70ms以上，大大超出了预期，所以采用对缩小图做中值滤波，然后把得到的顶点等比例还原。把顶点等比例还原后，为了减少对后面处理的干扰，需要删除距离很近的点，距离多少算近呢？可以用一个参数控制，随时调节。到这里，已经得到了一个基本轮廓，图案有明显的转折点，最后一步就是来平滑这些转折点。

最后一步的平滑用了 Bezier 三阶曲线公式（看一看上面的公式），所以计算两点之间的曲线需要另外两个控制点，所以需要把所有的控制点找出来，最后再用公式计算曲线上的点，方案参考下图：

步骤说明：

1 找到每条边的中点（或三等分点或n等分点）
2 连接顶点两边的中点
3 垂直平移该线段直到经过顶点P
4 此时线段两端点就是控制点
5 用控制点和顶点计算曲线上的点

明白了上面的图，基本就知道写代码的思路了，可能唯一有点疑问的是那条线段平移怎么计算，那就再看下图，在看图之前，得先知道图中的点 A、B 是那两个“中点”，把其中一个中点作为原点，P 是对应的顶点，所以 A、B、P 是已知的三个点：

看了图应该就明白，需要求解的是向量 $\vec{CP}$ ，两个中点就可以根据这个向量计算出控制。那点 C 的坐标怎么计算，好吧，高中知识，求两条直线的交点，直接看计算结果吧：

中点 $A (0, 0)$
中点 $B(a_1,b_1)$
顶点 $P(a_2,b_2)$
垂足 $C(\frac{a_1b_1b_2+a_1a_1a_2}{b_1b_1+a_1a_1}, \frac{b_1b_1b_2+a_1a_2b_1}{b_1b_1+a_1a_1})$

3 代码

看完了上面这些内容，就可以自己实现了，有兴趣可以参考这里的代码：

主函数

void main()
{
    std::string path = "~/mask/" + std::to_string(num) + ".jpg"; // 图片路径
    cv::Mat img = cv::imread(path, 1);

    // 如果img是多通道的，需要转换为单通道，如果是单通道就不要这三行
    std::vector<cv::Mat> channals;
    cv::split(img, channals);
    img = channals[0].clone();

    // 转换格式
    img.convertTo(img, CV_8U, 255.0);

    // 缩小尺寸
    int Size = 5; // 缩小倍数
    int W = 1000, H = 1000; //目标图像的尺寸
    cv::resize(img, img, cv::Size(W / Size, H / Size));

    // 中值滤波
    cv::medianBlur(img, img, 19);

    // 提取边缘，得到顶点
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(img, contours, hierarchy, cv::RETR_EXTERNAL, CV_CHAIN_APPROX_TC89_KCOS, cv::Point());

    // 放大顶点
    for (ulong i = 0; i < contours.size(); i++) {
        for (ulong j = 0; j < contours[i].size(); j++) {
            contours[i][j].x *= Size;
            contours[i][j].y *= Size;
        }
    }
    //cv::Mat imageContours = cv::Mat::zeros(cv::Size(W, H), CV_8UC1);

    // Bezier
    for (ulong i = 0; i < contours.size(); i++) {
        DeletePoint(contours[i], 20); // 删除比较近的顶点，表示20这个距离内的顶点会删除
        Bezier(contours[i], 3, 3); // Bezier，表示在相邻顶点间插入3个曲线点，弯曲弱化程度为3
    }
    cv::drawContours(imageContours, contours, -1, cv::Scalar(255), 2, 8, hierarchy);

    cv::imshow("2", imageContours);
    if (cv::waitKey(0))
        continue;
}

函数DeletePoint（删除比较近的点）

void DeletePoint(std::vector<cv::Point> &contour, int distence)
{
    std::vector<cv::Point> out;
    distence *= distence;
    for (ulong i = 0; i < contour.size(); i++) {
        if (i != 0) {
            cv::Point D = contour[i] - contour[i - 1];
            int d = D.x * D.x + D.y * D.y;
            if (d < distence) {
                continue;
            }
        }
        out.push_back(contour[i]);
    }
    contour.swap(out);
}

贝塞尔曲线

void Bezier(std::vector<cv::Point> &contour, int num， int strength)
{
    std::vector<cv::Point> out;
    std::vector<cv::Point> C_L, C_R;
    cv::Point P_last, P_CUR, P_next;
    for (ulong i = 0; i < contour.size(); i++) {
        P_CUR = contour[i];
        if (i == 0) {
            P_last = contour[contour.size() - 1];
            P_next = contour[i + 1];
        } else if (i == contour.size() - 1) {
            P_last = contour[i - 1];
            P_next = contour[0];
        } else {
            P_last = contour[i - 1];
            P_next = contour[i + 1];
        }
        cv::Point Z_L, Z_R;
        Z_L = P_CUR * (strength - 1) / strength + P_last / strength;
        Z_R = P_CUR * (strength - 1) / strength + P_next / strength;
        cv::Point P_1 = Z_R - Z_L;
        cv::Point P_2 = P_CUR - Z_L;
        int a1, b1, a2, b2, x, y;
        a1 = P_1.x; b1 = P_1.y; a2 = P_2.x; b2 = P_2.y;
        if (a1 != 0 && b1 != 0) {
             x = (a1 * b1 * b2 + a1 * a1 * a2) / (b1 * b1 + a1 * a1);
             y = (b1 * b1 * b2 + a1 * a2 * b1) / (b1 * b1 + a1 * a1);
        }
        cv::Point MOVE = P_2 - cv::Point(x, y);
        Z_L += MOVE;
        Z_R += MOVE;
        C_L.push_back(Z_L);
        C_R.push_back(Z_R);
    }
    for (ulong i = 0; i < contour.size(); i++) {
        out.push_back(contour[i]);
        for (int j = 1; j <= num; j++) {
            float t = j / (num + 1.0);
            cv::Point P_I;
            if (i != contour.size() - 1) {
                P_I = (1 - t) * (1 - t) * (1 - t) * contour[i]
                        + 3 * t * (1 - t) * (1 - t) * C_R[i]
                        + 3 * t * t * (1 - t) * C_L[i + 1]
                        + t * t * t * contour[i + 1];
            } else {
                P_I = (1 - t) * (1 - t) * (1 - t) * contour[i]
                        + 3 * t * (1 - t) * (1 - t) * C_R[i]
                        + 3 * t * t * (1 - t) * C_L[0]
                        + t * t * t * contour[0];
            }
            out.push_back(P_I);
        }
    }
    contour.swap(out);
}

Rareay

关注

5
点赞
踩
36

收藏

觉得还不错? 一键收藏
2
评论
平滑边缘

Bezier平滑锯齿边缘1 Bezier数学原理二阶贝塞尔曲线图中，P1P_1P1 为控制点，参数 ttt 从 [0,1][0,1][0,1] 中取值，可以用下面的公式计算出从 P0P_0P0 演变为 P2P_2P2 过程中的点：B(t)=(1−t)2P0+2t(1−t)P1+t2P2,t∈[0,1] B(t)=(1-t)^2 P_0 + 2t(1-t)P_1 + t^2P_2, t\in[0,1] B(t)=(1−t)2P0+2t(1−t)P1+t2P2,t∈[0,1]
复制链接

扫一扫