OpenCV C++ Intermediate

[leggiero-crescendo]

이동변환 (translation transform - shift)

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

cv::Mat imgTranslation(const cv::Mat& src, cv::Mat& dst)
{
    CV_Assert(!src.empty());
    for (int y = 0; y < src.rows; y++){
        for (int x = 0; x < src.cols; x++){
            int x_ = x + 200;
            int y_ = y + 100;
            // 입력 영상과 출력 영상의 크기가 차이에 대한 해
            if (x_ >= dst.cols) continue;
            if (y_ >= dst.rows) continue;
            dst.at<uchar>(y_, x_) = src.at<uchar>(y, x);
        }
    }

    return dst;
}

int main() // argc : input num, argv : input char s  // char* argv[]와 char **argv는 모두 문자열 포인터 배열을 나타
{
    cv::Mat src = cv::imread("../resources/lenna.bmp",  cv::IMREAD_GRAYSCALE); // cmake-build-debug에서 실행됨으로,,,, 상위단으로 올라가서 다시 exaple로,,

    if (src.empty()) {
        std::cerr << "Image laod failed!" << std::endl;
        return -1;
    }

    cv::Mat dst = cv::Mat::zeros(src.rows, src.cols, CV_8UC1);
    // cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC1);
    dst = imgTranslation(src, dst);

    cv::imshow("src", src);
    cv::imshow("dst", dst);

    cv::waitKey(0);

    cv::destroyAllWindows();
}

[leggiero-crescendo]

전단변환

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

cv::Mat imgShear(const cv::Mat& src, const char* axis)
{
    CV_Assert(!src.empty());

    int src_rows;
    int src_cols;
    cv::Mat dst_c;
    double m = 0.5;

    if (axis == "x"){
        src_rows = src.rows;
        src_cols = src.cols * 3/2;
        cv::Mat dst(src_rows, src_cols, src.type(), cv::Scalar(0));
        for (int y = 0; y < src.rows; y++) {
            for (int x = 0; x < src.cols; x++) {
                int nx = int(m*y+x);
                int ny = y;
                dst.at<uchar>(ny, nx) = src.at<uchar>(y, x);
            }
        }
        dst_c = dst;
    }
    else{
        src_rows = src.rows * 3/2; // y-axis shear
        src_cols = src.cols;
        cv::Mat dst(src_rows, src_cols, src.type(), cv::Scalar(0));
        for (int y = 0; y < src.rows; y++) {
            for (int x = 0; x < src.cols; x++) {
                int nx = x;
                int ny = int(y + m*x);
                dst.at<uchar>(ny, nx) = src.at<uchar>(y, x);
            }
        }
        dst_c = dst;

    }
    return dst_c;
}

int main()
{
    char* shear_axis = "y";
    cv::Mat src = cv::imread("../resources/lenna.bmp",  cv::IMREAD_GRAYSCALE); 

    if (src.empty()) {
        std::cerr << "Image laod failed!" << std::endl;
        return -1;
    }

    cv::Mat dst = imgShear(src, shear_axis);

    cv::imshow("src", src);
    cv::imshow("dst", dst);

    cv::waitKey(0);

    cv::destroyAllWindows();
}

[leggiero-crescendo]

크기변환과 보간법

방법	설명
순방향 맵핑	scale 증가시 빈공간 발생
역방향맵핑	scale 증가시 빈공간은 없어지지만 단순하게 증가하기 때문에 계단형식(픽셀이 커지는 느낌)으로 출력됨
보간법(interpolation)	영상을 조금 더 매끄럽게 출력하기 위해 실수 좌표상에서 픽셀 값을 결정하기 위해 주변 픽셀 값을 이용해 값을 추	정하는 방법

[leggiero-crescendo]

회전변환과 기하학적 변환의 조합

[leggiero-crescendo]

어파인변환과 투시변환

[leggiero-crescendo]

컬러영상처리의 기초

• opencv에서 컬러 영상 다루기
• 컬러 영상의 픽셀 값 참조

• 컬러 영상을 그레이 스케일 영상으로 변환

  컬러 영상의 픽셀값 참조

  cv::Mat dst(src.rows, src.cols, src.type()); // 입력영상과 같은 크기, 입력형상의 타입 = CV_8UC3 , (Scalar(0,0,0)) -> initial option
  
  for (int y = 0; y < src.rows; y++){
    for (int x = 0; x<src.cols ; x++){
        // 아래 전체 과정은 : dst.at<Vec3b>(y,x) = Vec3b(255, 255, 255) - src.at<Vec3b>(y,x); 와 같음
        const cv::Vec3b& p1 = src.at<cv::Vec3b>(y, x); // 효율적이기 때문에 사용
        cv::Vec3b& p2 = dst.at<cv::Vec3b>(y, x); // 출력영상의 주소 값을 가져와서 출력 영상을 바꿔야하기 때문에 p2를 바꾸는 것이 목적이 아님 dst 바꿔야해서
  
        // p2 = Vec3b(255, 255, 255) - p1;
        p2[2] = 255 - p1[2];
        p2[1] = 255 - p1[1];
        p2[0] = 255 - p1[0];
  
    }
  }

BGR to Gray

  cv::Mat dst(src.rows, src.cols, CV_8UC3);
  cv::Mat dst_gray(src.rows, src.cols, CV_8UC1);

  // 아래 과정은 사실 cv::cvtColor(src, dst, COLOR_BGR2GRAY); 로 표현 가능
  for (int y = 0; y < src.rows; y++){
      for (int x = 0; x<src.cols ; x++){
          cv::Vec3b& p1 = src.at<cv::Vec3b>(y, x);
          uchar b = p1[0];
          uchar g = p1[1];
          uchar r = p1[2];
          // 실수연산을 많이 하면 느려짐
          uchar gray = (uchar)(0.2999 * r + 0.587 * g + 0.114 * b + 0.5);
          uchar gray_int = (uchar)((299*r+587*g+114*b)/1000); // 으로도 할 수 있지만 나눗셈이 비효율적
          // 이를 uchar gray= RGB2GRAY(r, g, b);
          dst.at<cv::Vec3b>(y, x) = gray;

      }
  }

[leggiero-crescendo]

색공간

• 색 인지
• 다양한 색공간: RGB, HSV, YCrCb
• 밝기 정보와 색 정보 특성

[leggiero-crescendo]

컬러 영상처리

• 컬러 영상의 히스토그램 평활화
• 컬러영상의 색감 바꾸기

컬러 영상의 히스토그램 평활화

• equalizeHist 함수는 grayscale 처럼 1채널에 대해서만 가능
• RGB를 각각 분리한 후 평활화 후 합치면 색감에 변화가 생김

• 색감을 제외하고 영상의 밝기에 대해서만 평활화를 진행하는 방법은?

  int equalizingHistogramColor()
  {
  // 1. 이미지 입력
  cv::Mat src = imread("../resources/mandrill.bmp", cv::IMREAD_COLOR);
  
  if (src.empty()) {
      std::cerr << "Image load failed!" << std::endl;
      return -1;
  }
  
  // 2. YCrCb 영역으로 변경 -> src_ycrcb 저장
  cv::Mat src_ycrcb;
  cvtColor(src, src_ycrcb, cv::COLOR_BGR2YCrCb);
  // 3. Y, Cr, Cb 영역 분리 => planes 결과 받기
  std::vector<cv::Mat> planes;
  split(src_ycrcb, planes);
  // 4. Y채널(planes[0])에 대해서만 equalize 시키기
  equalizeHist(planes[0], planes[0]);
  // 5. 결과 합치기 -> ycrcb
  cv::Mat dst_ycrcb;
  merge(planes, dst_ycrcb);
  // 6. ycrcb로 합친결과를 -> BGR 형식으로 변경하기
  cv::Mat dst;
  cvtColor(dst_ycrcb, dst, cv::COLOR_YCrCb2BGR);
  
  cv::imshow("src", src);
  cv::imshow("dst", dst);
  cv::waitKey();
  cv::destroyAllWindows();
  }

컬러 색감바꾸기

• RGB 자체를 바꾸던지

• Hue 값만을 바꿔서 조절할 수 있다 (아래는 Hue값만 바꾼 것)

  
  cv::Mat src = imread("girl.jpg", cv::IMREAD_COLOR);
  
  if (src.empty()) {
      std::cerr << "Image load failed!" << std::endl;
      return -1;
  }
  
  std::vector<cv::Mat> channels; // 3
  split(src, channels);
  
  for (int y = 0; y < src.rows; y++) {
      for (int x = 0; x < src.cols; x++) {
          channels[2].at<uchar>(y, x) = curve1[channels[2].at<uchar>(y, x)];
          channels[0].at<uchar>(y, x) = curve2[channels[0].at<uchar>(y, x)];
      }
  }
  
  cv::Mat dst;
  merge(channels, dst);
  
  cv::imshow("src", src);
  cv::imshow("dst", dst);
  cv::waitKey();
  cv::destroyAllWindows();

}

- [curve 1:upper curve 2 link:lower](https://github.com/leggiero-crescendo/Dev-perception/issues/4#issuecomment-1525720116)
![Screenshot from 2023-04-27 22-37-03](https://user-images.githubusercontent.com/125112464/234880988-72609678-14f7-419d-a618-abf578a16cb8.png)

[leggiero-crescendo]

특정 색상 영역 추출하기

• 색상 범위 지정 : HSV 범위값을 지정하여 -> 해당하는 영역을 얻어내는 것
• 히스토그램 역투영 : 원하는 영역을 기준으로 -> HSV 영역을 얻어내는 것
  • 영역 지정 후 -> 해당영역에 있는 hsv를 기준으로 필터링 하는 방법
  • 새로운 영상에서 유사색 추출

색상 범위 지정

int pos_hue1 = 50, pos_hue2 = 80, pos_sat1 = 150, pos_sat2 = 255;
cv::Mat src, src_hsv, dst, mask;

void on_hsv_changed(int, void*)
{
    cv::Scalar lowerb(pos_hue1, pos_sat1, 0);
    cv::Scalar upperb(pos_hue2, pos_sat2, 255);
    cv::inRange(src_hsv, lowerb, upperb, mask);

    cv::cvtColor(src, dst, COLOR_BGR2GRAY);
    cv::cvtColor(dst, dst, COLOR_GRAY2BGR);
    src.copyTo(dst, mask);

    cv::imshow("mask", mask);
    cv::imshow("dst", dst);
}

int main()
{
    src = imread("candies.png", IMREAD_COLOR);

    if (src.empty()) {
        std::cerr << "Image load failed!" << std::endl;
        return -1;
    }

    cv::cvtColor(src, src_hsv, COLOR_BGR2HSV);

    cv::namedWindow("src");
    cv::namedWindow("mask");
    cv::namedWindow("dst");

    cv::imshow("src", src);

    cv::createTrackbar("Lower Hue", "dst", &pos_hue1, 179, on_hsv_changed);
    cv::createTrackbar("Upper Hue", "dst", &pos_hue2, 179, on_hsv_changed);
    cv::createTrackbar("Lower Sat", "dst", &pos_sat1, 255, on_hsv_changed);
    cv::createTrackbar("Upper Sat", "dst", &pos_sat2, 255, on_hsv_changed);
    cv::on_hsv_changed(0, 0);

    cv::waitKey();
}

히스토그램 역투영

영역지정을 통한 히스토그램 역투영

int main()
{

    cv::Mat src = imread("cropland.png", cv::IMREAD_COLOR);

    if (src.empty()) {
        std::cerr << "Image load failed!" << std::endl;
        return -1;
    }
    // 사용자 영역선택
    cv::Rect rc = cv::selectROI(src);

    cv::Mat src_ycrcb;
    cv::cvtColor(src, src_ycrcb, COLOR_BGR2YCrCb);

    cv::Mat crop = src_ycrcb(rc);

    cv::Mat hist;
    int channels[] = {1, 2};
    int cr_bins = 128; int cb_bins = 128;
    int histSize[] = {cr_bins, cb_bins};
    float cr_range[] = {0, 256};
    float cb_range[] = {0, 256};
    const float* ranges[] = {cr_range, cb_range};

    // 부분 영상에 대한 히스토그램 계산
    cv::calcHist(&crop, 1, channels, Mat(), hist, 2, histSize, ranges);

    // 전체 영상에 대한 히스토그램 역투영진행
    cv::Mat backproj;
    cv::calcBackProject(&src_ycrcb, 1, channels, hist, backproj, ranges);

    cv::Mat dst = cv::Mat::zeros(src.rows, src.cols, CV_8UC3);
    src.copyTo(dst, backproj);

    //imshow("src", src);
    cv::imshow("dst", dst);
    cv::waitKey();
}

히스토그램 역투영을 통한 살색 검출

• 사전에 필요한 소스 : 레퍼런스 이미지와 레퍼런스 이미지에서 추출할 부분을 흰색 마스크, 필요없는 부분을 0으로 처리한 마스크이미지

int main() { // Calculate CrCb histogram from a reference image

cv::Mat ref, ref_ycrcb, mask;
ref = cv::imread("ref.png", cv::IMREAD_COLOR);
mask = cv::imread("mask.bmp", cv::IMREAD_GRAYSCALE);
cv::cvtColor(ref, ref_ycrcb, cv::COLOR_BGR2YCrCb);

cv::Mat hist;
int channels[] = { 1, 2 };
int cr_bins = 128; int cb_bins = 128;
int histSize[] = { cr_bins, cb_bins };
float cr_range[] = { 0, 256 };
float cb_range[] = { 0, 256 };
const float* ranges[] = { cr_range, cb_range };

cv::calcHist(&ref_ycrcb, 1, channels, mask, hist, 2, histSize, ranges);

if 1

cv::Mat hist_norm;
cv::normalize(hist, hist_norm, 0, 255, NORM_MINMAX, CV_8UC1);
cv::imshow("hist_norm", hist_norm);

endif

cv::Mat src, src_ycrcb;
src = cv::imread("people.png", IMREAD_COLOR);
cv::cvtColor(src, src_ycrcb, COLOR_BGR2YCrCb);

cv::Mat backproj;
cv::calcBackProject(&src_ycrcb, 1, channels, hist, backproj, ranges);

cv::GaussianBlur(backproj, backproj, Size(), 1.0);
backproj = backproj > 50;

cv::Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
src.copyTo(dst, backproj);

cv::imshow("ref", ref);
cv::imshow("mask", mask);
cv::imshow("src", src);
cv::imshow("backproj", backproj);
cv::imshow("dst", dst);
cv::waitKey();

}

[leggiero-crescendo]

에지검출과 소벨 필터

• 에지검출과 영상의 미분
• 다양한 미분 마스크
• 그래디언트
• 소벨 필터를 이용한 에지검출

[leggiero-crescendo]

케니 에지 검출기

• 케니 에지 검출 알고리즘
• 케니 에지 검출기 구현하기

[leggiero-crescendo]

허프변환 직선 검출과 원검출

• 허프 변환 직선 검출
• 허프 변환 원검출

[leggiero-crescendo]

코너 검출 방법

• 코너의 특징
• 해리스 코너 검출방법
• 추적하기 좋은 특징
• FAST 코너 검출방법

[leggiero-crescendo]

    // upper
    uchar curve1[256] = {
            0, 2, 3, 4, 7, 8, 9, 11,
            12, 14, 15, 16, 18, 19, 21, 22,
            24, 25, 27, 28, 30, 31, 33, 34,
            36, 37, 39, 40, 42, 43, 45, 46,
            47, 49, 50, 52, 53, 55, 56, 58,
            59, 61, 62, 63, 65, 66, 68, 69,
            71, 72, 73, 75, 76, 78, 79, 80,
            82, 83, 85, 86, 87, 89, 90, 91,
            93, 94, 95, 97, 98, 100, 101, 102,
            104, 105, 106, 107, 109, 110, 111, 113,
            114, 115, 117, 118, 119, 120, 122, 123,
            124, 125, 127, 128, 129, 130, 131, 133,
            134, 135, 136, 137, 139, 140, 141, 142,
            143, 144, 145, 146, 148, 149, 150, 151,
            152, 153, 154, 155, 156, 157, 158, 159,
            160, 161, 162, 164, 165, 165, 166, 167,
            168, 169, 170, 171, 172, 173, 174, 175,
            176, 177, 178, 179, 180, 180, 181, 182,
            183, 184, 185, 186, 186, 187, 188, 189,
            190, 191, 191, 192, 193, 194, 195, 195,
            196, 197, 198, 198, 199, 200, 201, 201,
            202, 203, 204, 204, 205, 206, 207, 207,
            208, 209, 209, 210, 211, 211, 212, 213,
            213, 214, 215, 215, 216, 217, 217, 218,
            219, 219, 220, 221, 221, 222, 222, 223,
            224, 224, 225, 226, 226, 227, 227, 228,
            229, 229, 230, 230, 231, 231, 232, 233,
            233, 234, 234, 235, 235, 236, 237, 237,
            238, 238, 239, 239, 240, 241, 241, 242,
            242, 243, 243, 244, 244, 245, 246, 246,
            247, 247, 248, 248, 249, 249, 250, 250,
            251, 252, 252, 253, 254, 254, 255, 255
    };
    // lower
    uchar curve2[256] = {
            0, 0, 1, 1, 1, 2, 3, 3,
            4, 4, 5, 6, 6, 7, 7, 8,
            8, 9, 9, 10, 10, 11, 11, 12,
            12, 13, 13, 14, 14, 15, 15, 16,
            17, 17, 18, 18, 19, 19, 20, 20,
            21, 21, 22, 23, 23, 24, 24, 25,
            25, 26, 27, 27, 28, 28, 29, 30,
            30, 31, 31, 32, 33, 33, 34, 35,
            35, 36, 37, 37, 38, 38, 39, 40,
            40, 41, 42, 43, 43, 44, 45, 45,
            46, 47, 47, 48, 49, 50, 50, 51,
            52, 53, 53, 54, 55, 56, 57, 57,
            58, 59, 60, 61, 61, 62, 63, 64,
            65, 66, 67, 68, 68, 69, 70, 71,
            72, 73, 74, 75, 76, 77, 78, 79,
            80, 81, 82, 82, 83, 85, 86, 87,
            88, 89, 90, 91, 92, 93, 94, 95,
            96, 97, 98, 99, 100, 102, 103, 104,
            105, 106, 107, 108, 110, 111, 112, 113,
            114, 115, 117, 118, 119, 120, 121, 123,
            124, 125, 126, 128, 129, 130, 131, 133,
            134, 135, 136, 138, 139, 140, 141, 143,
            144, 145, 147, 148, 149, 151, 152, 153,
            155, 156, 157, 159, 160, 161, 163, 164,
            165, 167, 168, 169, 171, 172, 174, 175,
            176, 178, 179, 180, 182, 183, 185, 186,
            187, 189, 190, 192, 193, 195, 196, 197,
            199, 200, 202, 203, 205, 206, 207, 209,
            210, 212, 213, 215, 216, 217, 219, 220,
            222, 223, 225, 226, 228, 229, 230, 232,
            233, 235, 236, 238, 239, 241, 242, 244,
            245, 246, 248, 249, 250, 252, 253, 255
    };