5. 이미지 프로세싱(3)

https://95mkr.tistory.com/entry/OPENCV9?category=750764 

[OPENCV] 9. 이미지 프로세싱(4) - Warp

Warp

#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>

int main(){
    cv::Mat src;
    src = cv::imread("curve2.jpg", cv::IMREAD_COLOR);
    if(src.empty()){
        std::cout << "Can't Open Image" << std::endl;
        return -1;
    }

    cv::Mat ROI, HSV;
    ROI = src(cv::Rect(0,400,880,186));
    cv::cvtColor(src,HSV,cv::COLOR_BGR2HSV);
    cv::Scalar lower_white = cv::Scalar(0,0,200);
    cv::Scalar upper_white = cv::Scalar(180,50,255);
    cv::inRange(HSV, lower_white, upper_white, HSV);

    cv::Mat sharp, closing;
    cv::bilateralFilter(HSV, sharp, 5, 100, 100);
    cv::morphologyEx(sharp, closing, cv::MORPH_CLOSE, cv::Mat());
    
    cv::Point2f srcPt[4], dstPt[4];
    srcPt[0] = cv::Point2f(0,400);
    srcPt[1] = cv::Point2f(0,586);
    srcPt[2] = cv::Point2f(880,400);
    srcPt[3] = cv::Point2f(880,586);

    dstPt[0] = cv::Point2f(0,0);
    dstPt[1] = cv::Point2f(0,480);
    dstPt[2] = cv::Point2f(600,0);
    dstPt[3] = cv::Point2f(600,480);

    cv::Mat M = cv::getPerspectiveTransform(srcPt, dstPt);

    cv::Mat dst;
    cv::warpPerspective(closing, dst, M, cv::Size(600,480));

    cv::imshow("ROI", ROI);
    cv::imshow("RESULT", dst);
    cv::waitKey(0);

    return 0;

}

허프 변환

#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>

//Warping Image Parameter
float widthA, widthB, heightA, heightB;
float maxWidth, maxHeight;

//HoughLinesP Parameter
double rho = 1;
double theta = CV_PI/180;
int threshold = 10;
double minLineLength = 0;
double maxLineGap = 0;

// MAKING ROI MASK
cv::Mat regionOfInterset(cv::Mat img, cv::Point *vertices){
    cv::Mat mask = cv::Mat::zeros(img.size(), CV_8UC3);

    const cv::Point* ppt[1] = { vertices };
    int npt[] = { 4 };

    cv::fillPoly(mask, ppt, npt, 1, cv::Scalar::all(255), cv::LINE_8);
    
    cv::Mat dst;
    cv::bitwise_and(img, mask, dst);

    return dst;
}

// FIND WHITE COLOR(ROAD LINE)
cv::Mat findColorHSV(cv::Mat img){
    cv::Mat HSV;    
    cv::cvtColor(img, HSV, cv::COLOR_BGR2HSV);

    cv::Mat mask_white = cv::Mat::zeros(img.size(), CV_8UC1);
    cv::Scalar lower_white = cv::Scalar(0,0,200);
    cv::Scalar upper_white = cv::Scalar(180,50,255);
    cv::inRange(HSV, lower_white, upper_white, HSV);

    return HSV;
}

// CALCULATING MAX WIDTH, MAX HEIGHT SIZE FOR WARP
void maxValueCalculator(cv::Point2f srcPt[4]){
    widthA = sqrt((pow((srcPt[0].x - srcPt[1].x),2)) + (pow((srcPt[0].y - srcPt[1].y),2)));
    widthB = sqrt((pow((srcPt[2].x - srcPt[3].y),2)) + (pow((srcPt[2].y - srcPt[3].y),2)));
    maxWidth = std::max(int(widthA), int(widthB));

    heightA = sqrt((pow((srcPt[0].x - srcPt[3].x),2)) + (pow((srcPt[0].y - srcPt[3].y),2)));
    heightB = sqrt((pow((srcPt[1].x - srcPt[2].x),2)) + (pow((srcPt[1].y - srcPt[2].y),2)));
    maxHeight = std::max(int(heightA), int(heightB));
}

// DETECTING EDGE LINES
// SET line_row_theshold, line_high_threshold
// GOT A LINE VALUE WITHIN THE RANGE OF SLOPE
void edgeLines(cv::Mat img, cv::Mat &line_result, std::vector<cv::Vec4i> lines){
    int width = img.rows;
    
    for(size_t i = 0; i < lines.size(); i++){
        cv::Vec4i line = lines[i];
        int x1 = line[0];
        int y1 = line[1];
        int x2 = line[2];
        int y2 = line[3];

        float slope;
        if(x2 == x1){ slope = 999.; }
        else{ slope = fabsf((y1 - y2) / float(x1 - x2)); }

        float line_row_theshold = tan(15*CV_PI/180);
        float line_high_threshold = tan(89.9*CV_PI/180);

        if (line_row_theshold < slope && slope < line_high_threshold){
            if(x1 < width / 2){
                // left side edge
                cv::line(line_result, cv::Point(x1, y1), cv::Point(x2, y2), cv::Scalar(255,0,0), 2, cv::LINE_AA);
            } else {
                // right side edge
                cv::line(line_result, cv::Point(x1, y1), cv::Point(x2, y2), cv::Scalar(0,255,0), 2, cv::LINE_AA);
            }
        }
    }
}

int main(){
    cv::Mat src;
    src = cv::imread("curve2.jpg", cv::IMREAD_COLOR);
    cv::resize(src, src, cv::Size(src.cols/2, src.rows/2));
    if(src.empty()){
        std::cout << "Can't Open Image" << std::endl;
        return -1;
    }

    // ROI - RECTANGULAR POINT
    cv::Point rect[4];
    rect[0] = cv::Point(0,200);
    rect[1] = cv::Point(0,293);
    rect[2] = cv::Point(440,293);
    rect[3] = cv::Point(440,200);
    
    cv::Mat ROI = regionOfInterset(src, rect);
    cv::Mat HSV = findColorHSV(ROI);
    
    cv::Mat filtering, closing;
    cv::bilateralFilter(HSV, filtering, 5, 100, 100);
    cv::morphologyEx(filtering, closing, cv::MORPH_CLOSE, cv::Mat());
    
    // WARP
    // ORIGINAL IMAGE WIDTH, HEIGHT SIZE
    cv::Point2f srcPt[4];
    srcPt[0] = cv::Point2f(0,200);
    srcPt[1] = cv::Point2f(0,293);
    srcPt[2] = cv::Point2f(440,200);
    srcPt[3] = cv::Point2f(440,293);
    maxValueCalculator(srcPt);

    // RESULT IAMGE WIDTH, HEIGHT SIZE
    cv::Point2f dstPt[4];
    dstPt[0] = cv::Point2f(0,0);
    dstPt[1] = cv::Point2f(0, maxHeight - 1);
    dstPt[2] = cv::Point2f(maxWidth - 1,0);
    dstPt[3] = cv::Point2f(maxWidth - 1, maxHeight - 1);

    cv::Mat warping;
    cv::Mat M = cv::getPerspectiveTransform(srcPt, dstPt);
    cv::warpPerspective(closing, warping, M, cv::Size(maxWidth,maxHeight));

    cv::Mat canny;
    cv::Canny(closing, canny, 150, 270);

    // HOUGH TRANSFORM
    std::vector<cv::Vec4i> lines;
    cv::HoughLinesP(canny, lines, rho, theta, threshold, minLineLength, maxLineGap);

    cv::Mat line_result = cv::Mat::zeros(src.size(), CV_8UC3);
    edgeLines(src, line_result, lines);

    cv::Mat result; 
    cv::addWeighted(line_result, 1, src, 0.6, 0., result);

    cv::imshow("ORIGINAL", src);
    cv::imshow("RESULT", result);
    
    cv::waitKey(0);
    return 0;

}