OpenCV学习(6)--更多形态转化、Hit-or-Miss变换、Hit-or-Miss变换、图像金字塔

OpenCV更多形态转化：开盘、闭幕、形态梯度、顶帽、黑帽

static class MorphologyOperationsExample {
    // OpenCV更多的形态转化
    /*
    开盘：
        先侵蚀 后扩张 dst = open(src, element) = dilate(erode(src, element))
        去除亮色小物体
    闭幕：
        先扩张 后侵蚀 dst = close(src, element) = erode(dilate(src, element))
        去除暗区小孔
    形态梯度：
        dst = morph_grad(src, element) = dilate(src, element) - erode(src, element)
        找到对象轮廓
    顶帽：
        dst = tophat(src, element) = src - open(src, element)
    黑帽：
        dst = blackhat(src, element) = close(src, element) - src
    */

public:
    static int showExample(string imageName) {
        src = cv::imread(imageName, cv::IMREAD_COLOR);

        if (src.empty())
            return -1;

        cv::namedWindow("Morphology Transformations Demo", cv::WINDOW_AUTOSIZE);
        cv::createTrackbar("Operator:
 0: Opening - 1: Closing 
 2: Gradient - 3: Top Hat 
 4: Black Hat", "Morphology Transformations Demo", &morphOperator, maxOperator, MorphologyOperations);
        cv::createTrackbar("Element:
 0: Rect - 1: Cross - 2: Ellipse", "Morphology Transformations Demo", &morphElem, maxElem, MorphologyOperations);
        cv::createTrackbar("Kernel size:
 2n + 1", "Morphology Transformations Demo", &morphSize, maxKernelSize, MorphologyOperations);
        MorphologyOperations(0, 0);
        cv::waitKey(0);
        return 0;
    }

    static void MorphologyOperations(int, void*) {
        // Since MORPH_X : 2 3 4 5 6
        int operation = morphOperator + 2;
        cv::Mat element = cv::getStructuringElement(morphElem, cv::Size(2 * morphSize + 1, 2 * morphSize + 1), cv::Point(morphSize, morphSize));
        // cv::morphologyEx() 通过operation控制做什么操作
        // https://docs.opencv.org/4.2.0/d4/d86/group__imgproc__filter.html#gga7be549266bad7b2e6a04db49827f9f32a08d3cc3a2ace00cec488966d31fa29ea
        cv::morphologyEx(src, dst, operation, element);
        /*
        enum cv::MorphShapes {
            cv::MORPH_RECT = 0,
            cv::MORPH_CROSS = 1,
            cv::MORPH_ELLIPSE = 2
        }

        enum cv::MorphTypes {
            cv::MORPH_ERODE = 0,
            cv::MORPH_DILATE = 1,
            cv::MORPH_OPEN = 2,
            cv::MORPH_CLOSE = 3,
            cv::MORPH_GRADIENT = 4,
            cv::MORPH_TOPHAT = 5,
            cv::MORPH_BLACKHAT = 6,
            cv::MORPH_HITMISS = 7
        }
        */
        cv::imshow("Morphology Transformations Demo", dst);
    }

    // 需要在类外初始化
    static cv::Mat src;
    static cv::Mat dst;
    static int morphElem;  //  = 0
    static int morphSize;  //  = 0
    static int morphOperator;  //  = 0
    static int const maxOperator = 4;
    static int const maxElem = 2;
    static int const maxKernelSize = 21;
};

int MorphologyOperationsExample::morphElem = 0;
int MorphologyOperationsExample::morphSize = 0;
int MorphologyOperationsExample::morphOperator = 0;
cv::Mat MorphologyOperationsExample::src;
cv::Mat MorphologyOperationsExample::dst;

int useThisMorphologyOperationsExample(void) {
    MorphologyOperationsExample::showExample("blackWord.png");

    cv::waitKey(0);
    return 0;
}

Hit-or-Miss变换：

int exampleHist_or_Miss(void) {
    // Hit-or-Miss变换
    // 创建输入图片 
    cv::Mat inputImage = (cv::Mat_<uchar>(8, 8) <<
        0, 0, 0, 0, 0, 0, 0, 0,
        0, 255, 255, 255, 0, 0, 0, 255,
        0, 255, 255, 255, 0, 0, 0, 0,
        0, 255, 255, 255, 0, 255, 0, 0,
        0, 0, 255, 0, 0, 0, 0, 0,
        0, 0, 255, 0, 0, 255, 255, 0,
        0, 255, 0, 255, 0, 0, 255, 0,
        0, 255, 255, 255, 0, 0, 0, 0);

    cv::Mat kernel = (cv::Mat_<int>(3, 3) <<
        0, 1, 0,
        1, -1, 1,
        0, 1, 0);

    cv::Mat outputImage;
    cv::morphologyEx(inputImage, outputImage, cv::MORPH_HITMISS, kernel);
    const int rate = 10;
    kernel = (kernel + 1) * 127;
    kernel.convertTo(kernel, CV_8U);
    cv::resize(kernel, kernel, cv::Size(), rate, rate, cv::INTER_NEAREST);
    cv::imshow("kernel", kernel);
    cv::resize(inputImage, inputImage, cv::Size(), rate, rate, cv::INTER_NEAREST);
    cv::imshow("Original", inputImage);
    cv::resize(outputImage, outputImage, cv::Size(), rate, rate, cv::INTER_NEAREST);
    cv::imshow("Hit or Miss", outputImage);

    cv::waitKey(0);
    return 0;
}

提取水平线和垂直线：

int getHVExample(void) {
    // 使用形态学操作来提取水平和垂直线
    cv::Mat src = cv::imread("melody.png", cv::IMREAD_COLOR);

    if (src.empty()) {
        std::cout << "Read Failed!" << std::endl;
        return -1;
    }

    cv::imshow("Src", src);
    cv::Mat gray;

    if (src.channels() == 3) {
        cv::cvtColor(src, gray, cv::COLOR_BGR2GRAY);
    }
    else {
        gray = src;
    }

    cv::imshow("Gray", gray);
    cv::Mat bw;
    // 自适应阈值化函数adaptiveThreshold来实现自适应阈值处理
    // https://blog.csdn.net/wenhao_ir/article/details/51565517
    cv::adaptiveThreshold(~gray, bw, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 15, -2);
    cv::imshow("Binary", bw);

    cv::Mat horizontal = bw.clone();
    cv::Mat vertical = bw.clone();

    int horizontalsize = horizontal.cols / 30;
    cv::Mat horizontalStructure = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(horizontalsize, 1));
    cv::erode(horizontal, horizontal, horizontalStructure, cv::Point(-1, -1));
    cv::dilate(horizontal, horizontal, horizontalStructure, cv::Point(-1, -1));
    cv::imshow("Horizontal", horizontal);

    int verticalsize = vertical.rows / 30;
    cv::Mat verticalStructure = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(1, verticalsize));
    cv::erode(vertical, vertical, verticalStructure, cv::Point(-1, -1));
    cv::dilate(vertical, vertical, verticalStructure, cv::Point(-1, -1));
    cv::imshow("Vertical", vertical);

    // 对二进制图像进行非操作
    // https://blog.csdn.net/u011028345/article/details/77278467
    cv::bitwise_not(vertical, vertical);
    cv::imshow("vertical_bit", vertical);

    // 扩张边界 平滑图像 
    // 1 extract edges
    cv::Mat edges;
    cv::adaptiveThreshold(vertical, edges, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 3, -2);
    cv::imshow("Edges", edges);
    // 2 dilate edges
    cv::Mat kernel = cv::Mat::ones(2, 2, CV_8UC1);
    cv::dilate(edges, edges, kernel);
    cv::imshow("dilate", edges);
    // 3 src.copyTo(smooth)
    cv::Mat smooth;
    vertical.copyTo(smooth);
    // 4 blur smooth img
    // blur()函数可以用标准化的盒式过滤器来平滑图像。
    // https://blog.csdn.net/duwangthefirst/article/details/79971322
    cv::blur(smooth, smooth, cv::Size(2, 2));
    // 5 smooth.copyTo(src, edges)
    smooth.copyTo(vertical, edges);
    cv::imshow("smooth", vertical);


    cv::waitKey(0);
    return 0;
}

图像金字塔变换（扩大/缩小）：

int showPyramidsDemo(void) {
    // 图像金字塔
    // 将图像转化为与原始图像不同的大小 放大/缩小
    // 高斯金字塔：较常用，用于缩减图像
    // 拉普拉斯金字塔：从金字塔中较低的图像重建上采样图像（分辨率较低）
    cv::Mat src;
    cv::Mat dst;
    cv::Mat tmp;

    src = cv::imread("small.jpg", cv::IMREAD_COLOR);
    if (src.empty()) {
        std::cout << "Failed read!" << std::endl;
        return -1;
    }

    tmp = src;
    dst = tmp;
    cv::imshow("Pyramids Demo", src);

    cv::pyrUp(src, dst, cv::Size(src.cols * 2, src.rows * 2));
    cv::imshow("Up Demo", dst);
    //tmp = dst;

    cv::pyrDown(src, tmp, cv::Size(src.cols / 2, src.rows / 2));
    cv::imshow("Down Demo", tmp);
    //tmp = dst;
/*
    while (true) {
        char c = cv::waitKey(0);

        if (c == 27)
            break;
        if (c == 'u') {
            cv::pyrUp(tmp, dst, cv::Size(tmp.cols * 2, tmp.rows * 2));
            std::cout << "Zoom In: Image * 2" << std::endl;
        }
        if (c == 'd') {
            cv::pyrDown(tmp, dst, cv::Size(tmp.cols / 2, tmp.rows / 2));
            std::cout << "Zoom Out: Image / 2" << std::endl;
        }

        cv::imshow("Pyramids Demo", dst);
        tmp = dst;
    }
*/
    cv::waitKey(0);
    return 0;
}