膨胀腐蚀代码C++

以下是使用C++实现的膨胀和腐蚀操作的代码：

#include <iostream>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

int main(int argc, char** argv)
{
    // 读取图像
    Mat src = imread("lena.jpg", IMREAD_GRAYSCALE);

    // 定义结构元素
    Mat element = getStructuringElement(MORPH_RECT, Size(3, 3));

    // 膨胀操作
    Mat dilate_img;
    dilate(src, dilate_img, element);

    // 腐蚀操作
    Mat erode_img;
    erode(src, erode_img, element);

    // 显示结果
    imshow("src", src);
    imshow("dilate", dilate_img);
    imshow("erode", erode_img);
    waitKey(0);

    return 0;
}

在代码中，我们首先读取图像，然后定义一个结构元素。接着，我们利用dilate函数对图像进行膨胀操作，利用erode函数对图像进行腐蚀操作。最后，我们输出结果。

相关问题

膨胀腐蚀代码纯C++，不调用opencv

以下是使用纯C++实现的膨胀和腐蚀操作的代码：

#include <iostream>
#include <vector>

using namespace std;

// 定义结构元素
const int SE_SIZE = 3;
const int SE[SE_SIZE][SE_SIZE] = {
    {0, 1, 0},
    {1, 1, 1},
    {0, 1, 0}
};

// 膨胀操作
void dilate(const vector<vector<int>>& src, vector<vector<int>>& dst)
{
    int rows = src.size();
    int cols = src[0].size();
    dst.resize(rows, vector<int>(cols, 0));
    for (int i = 1; i < rows - 1; i++)
    {
        for (int j = 1; j < cols - 1; j++)
        {
            int max_val = 0;
            for (int m = -1; m <= 1; m++)
            {
                for (int n = -1; n <= 1; n++)
                {
                    int val = src[i + m][j + n] + SE[m + 1][n + 1];
                    if (val > max_val)
                        max_val = val;
                }
            }
            dst[i][j] = max_val;
        }
    }
}

// 腐蚀操作
void erode(const vector<vector<int>>& src, vector<vector<int>>& dst)
{
    int rows = src.size();
    int cols = src[0].size();
    dst.resize(rows, vector<int>(cols, 0));
    for (int i = 1; i < rows - 1; i++)
    {
        for (int j = 1; j < cols - 1; j++)
        {
            int min_val = 255;
            for (int m = -1; m <= 1; m++)
            {
                for (int n = -1; n <= 1; n++)
                {
                    int val = src[i + m][j + n] - SE[m + 1][n + 1];
                    if (val < min_val)
                        min_val = val;
                }
            }
            dst[i][j] = min_val;
        }
    }
}

int main()
{
    // 读取图像
    Mat src = imread("lena.jpg", IMREAD_GRAYSCALE);

    // 转换为二维数组
    vector<vector<int>> src_vec(src.rows, vector<int>(src.cols, 0));
    for (int i = 0; i < src.rows; i++)
    {
        for (int j = 0; j < src.cols; j++)
        {
            src_vec[i][j] = src.at<uchar>(i, j);
        }
    }

    // 膨胀操作
    vector<vector<int>> dilate_img;
    dilate(src_vec, dilate_img);

    // 腐蚀操作
    vector<vector<int>> erode_img;
    erode(src_vec, erode_img);

    // 转换为Mat类型并显示结果
    Mat dilate_mat(src.rows, src.cols, CV_8UC1);
    Mat erode_mat(src.rows, src.cols, CV_8UC1);
    for (int i = 0; i < src.rows; i++)
    {
        for (int j = 0; j < src.cols; j++)
        {
            dilate_mat.at<uchar>(i, j) = dilate_img[i][j];
            erode_mat.at<uchar>(i, j) = erode_img[i][j];
        }
    }
    imshow("src", src);
    imshow("dilate", dilate_mat);
    imshow("erode", erode_mat);
    waitKey(0);

    return 0;
}

在代码中，我们首先读取图像，然后将其转换为二维数组。接着，我们定义了膨胀和腐蚀操作的函数，利用定义的结构元素对图像进行操作。最后，我们将结果转换为Mat类型并输出。

opencv腐蚀膨胀c++

Opencv中的腐蚀（Erosion）和膨胀（Dilation）是形态学图像处理中常用的基本操作。腐蚀可以将图像中的物体边界向内侵蚀，而膨胀则可以将图像中的物体边界向外扩张。这些操作可以用来去除噪声、分离物体、连接物体等。在C++中，可以使用OpenCV的函数`erode()`和`dilate()`来实现。

例如，下面是使用`erode()`函数进行腐蚀操作的示例代码：

Mat src_img = imread("input.jpg"); // 读入图像
Mat dst_img; // 定义输出图像
Mat element = getStructuringElement(MORPH_RECT, Size(3, 3)); // 定义结构元素
erode(src_img, dst_img, element); // 进行腐蚀操作

其中，`src_img`为输入图像，`dst_img`为输出图像，`element`为结构元素，`MORPH_RECT`表示使用矩形结构元素，`Size(3, 3)`表示结构元素大小为3x3。

同样地，使用`dilate()`函数进行膨胀操作也类似：

Mat src_img = imread("input.jpg"); // 读入图像
Mat dst_img; // 定义输出图像
Mat element = getStructuringElement(MORPH_RECT, Size(3, 3)); // 定义结构元素
dilate(src_img, dst_img, element); // 进行膨胀操作