Opencv形态学变换 膨胀腐蚀

//生成三种基元 矩形 十字 椭圆
cv::Mat my_get_morph_struct_element(cv::MorphShapes shapeType, cv::Size s)
{
    CV_Assert(shapeType == cv::MORPH_RECT || shapeType == cv::MORPH_CROSS || shapeType == cv::MORPH_ELLIPSE);

    cv::Mat mat = cv::Mat::zeros(s, CV_8UC1);
    switch (shapeType)
    {
        case cv::MORPH_RECT:
        {
            mat = 1;
            break;
        }
        case cv::MORPH_CROSS:
        {
            cv::Mat rowROI(mat, cv::Rect(0, s.height / 2, s.width, 1));
            rowROI = 1;
            cv::Mat colROI(mat, cv::Rect(s.width / 2, 0, 1, s.height));
            colROI = 1;
            break;
        }
        case cv::MORPH_ELLIPSE:
        {
            int a = s.width / 2;
            int b = s.height / 2;
            //椭圆 公式 (x-xc)^2 / a^2 + (y-yc)^2 / b^2 = 1
            for (int i = 0; i < s.height; i++)
            {
                int dy = i - b;
                int startx = 0;
                int endx = 0;
                if (std::abs(dy) <= b)
                {
                    int dx = 0;
                    if (b > 0)
                    {
                        dx = cv::saturate_cast<int>(a * std::sqrt(1 - (1.0 * dy / b)*(1.0 * dy / b)));
                    }
                    startx =std::max(a - dx, 0);
                    endx = std::min(a + dx + 1, s.width);
                }

                uchar * p = mat.ptr<uchar>(i);
                for (int j = startx; j < endx; j++)
                {
                    p[j] = 1;
                }
            }
            break;
        }
        default:
            CV_Assert(false);
            break;
    }

    return mat;
}

//测试自己生成的基元
void test_my_get_morph_struct_element()
{
    cv::MorphShapes shape = cv::MORPH_RECT;
    cv::Size s(7, 8);
    cv::Mat rectSE = cv::getStructuringElement(shape, s);
    cv::Mat myRectSE = my_get_morph_struct_element(shape, s);
    std::cout << "rectSE:
" << rectSE << std::endl;
    std::cout << "myrectSE:
" << myRectSE << std::endl;

    shape = cv::MORPH_CROSS;
    rectSE = cv::getStructuringElement(shape, s);
    myRectSE = my_get_morph_struct_element(shape, s);
    std::cout << "CROSSSE:
" << rectSE << std::endl;
    std::cout << "mCROSSSE:
" << myRectSE << std::endl;

    shape = cv::MORPH_ELLIPSE;
    rectSE = cv::getStructuringElement(shape, s);
    myRectSE = my_get_morph_struct_element(shape, s);
    std::cout << "MORPH_ELLIPSE:
" << rectSE << std::endl;
    std::cout << "mMORPH_ELLIPSE:
" << myRectSE << std::endl;
}

//侵蚀与膨胀变换：
//图像上的一个点，以这个点为中心(假设为(i,j)点)，结构元素的中心与这个中心重合
//然后取出图像上被结构元素覆盖的那一小片(对于边界处,作边界扩展),如果结构元素的值
//为1，则从这一小片图像中对于的位置取出值，所有结构元素为1的位置都取出了对应那一
//小片图像中的值后,这些值中再取出最大值和最小值，对于侵蚀变换，则点(i,j)的值设置
//为最小值,而膨胀变换,则点(i,j)的值设置为最大值。

/*
 *matPadded 按照结构元补充过边界后的矩阵
 */
cv::Mat my_erode_dilate(const cv::Mat& matPadded, const cv::Mat& se, bool isErode)
{
    CV_Assert(matPadded.type() == CV_8UC1);
    CV_Assert(se.type() == CV_8UC1);
    
    int rows = matPadded.rows - se.rows;
    int cols = matPadded.cols - se.cols;
    cv::Mat mat(rows, cols, CV_8UC1);
    for (int i = 0; i < rows; i++)
    {
        uchar *p = mat.ptr<uchar>(i);
        for (int j = 0; j < cols; j++)
        {
            cv::Mat roi(matPadded, cv::Rect(j, i, se.cols, se.rows));
            std::vector<uchar> v;
            for (int ii = 0; ii < roi.rows; ii++)
            {
                uchar * pp = roi.ptr<uchar>(ii);
                const uchar * ppp = se.ptr<uchar>(ii);
                for (int jj = 0; jj < roi.cols; jj++)
                {
                    if (ppp[jj] == 1)
                    {
                        v.push_back(pp[jj]);
                    }
                }
            }
            std::sort(v.begin(), v.end());
            p[j] = isErode ? v[0] : v[v.size() - 1];
        }
    }

    return mat;
}


void test_my_erode_dilate()
{
    cv::Mat src = cv::imread("D:\programfiles\OpenCV\opencv-4.4.0\samples\data\lena.jpg", IMREAD_GRAYSCALE);
    if (src.empty())
    {
        std::cout << "Failed to load img!!" << std::endl;
        return;
    }

    //opencv自带
    cv::MorphShapes shape = cv::MorphShapes::MORPH_ELLIPSE;
    cv::Size seSize(7, 8);
    cv::Mat se = cv::getStructuringElement(shape, seSize);
    cv::Mat erodeMat;
    cv::Mat dilateMat;
    cv::erode(src, erodeMat, se);
    cv::dilate(src, dilateMat, se);
    cv::imshow("erode", erodeMat);
    cv::imshow("dilate", dilateMat);

    //自己实现的
    //填充边界
    int padLeft = se.cols / 2;
    int padRight = (se.cols % 2 == 0) ? se.cols / 2 - 1 : se.cols / 2;
    int padTop = se.rows / 2;
    int padBot = (se.rows % 2 == 0) ? se.rows / 2 - 1 : se.rows / 2;
    cv::Mat paddedMat;
    cv::copyMakeBorder(src, paddedMat, padTop, padBot, padLeft, padRight, BORDER_REFLECT101);
    cv::Mat myErodeMat = my_erode_dilate(paddedMat, se, true);
    cv::Mat myDilateMat = my_erode_dilate(paddedMat, se, false);
    cv::imshow("myErodeMat", myErodeMat);
    cv::imshow("myDilateMat", myDilateMat);

    waitKey(0);
}