[연구 노트] OpenCV의 + C ++ (칠)

 가장자리 처리
             루션 문제 에지
                경계점 이렇게 가장자리 처리되지있다 필터 3X3 화소는 필터링 된 커널과 완전히 중첩하지 않기 때문에 이미지 경계 픽셀은 컨볼 루션이 상기 컨볼 루션 연산을 할 수없는 경우, 5X5있을 때 두 개의 에지 픽셀이 처리되지 않는다.
             가장자리 처리
                등의 화소의 가장자리 주위에 3 × 패딩 따라서, 이미지의 에지가 처리되는 것을 보장하고 컨볼 루션 처리 후을 분리 컨벌루션 개시 에지 픽셀, 화소 값 0 또는 충전 블랙 RGB 전에 상승 에지 OpenCV의 기본 방법은 : BORDER_DEFAULT, 이외에도 여러 가지가있다 일반적으로 사용되는 다른
                   BORDER_CONSTANT --- 지정된 에지 화소 값 가득
                   에지 화소의 알려진 값으로 에지 픽셀 충전 --- BORDER_REPLICATE
                   BORDER_WRAP ---와 다른 쪽은 화소 충전을 보상하도록

             API는 이미지 가장자리 설명 --- API에 추가됩니다
                 copyMakeBorder (
                     매트 SRC에, // 입력 이미지
                     매트 DST, // 추가 에지 이미지
                     INT 탑, // 보통 위아래로 같은 값에 가장자리 길이,
                     INT 바닥,
                     INT 왼쪽,
                     INT 못했습니다 ,
                     INT borderType // 에지 형
                     스칼라 값
                 )

코드 보여줍니다

#include<opencv2/opencv.hpp>
#include<iostream>
#include<math.h>
using namespace cv;
int main(int argc, char** argv) {
    Mat src, dst;
    src = imread("C:\\Users\\Lenovo\\Desktop\\毕业设计\\AAAAAAA\\1.jpg");
    if (!src.data) {
        printf("could not load image...\n");
        return -1;
    }
    char INPUT_WIN[] = "input image";
    char OUTPUT_WIN[] = "Border image";
    namedWindow(INPUT_WIN, CV_WINDOW_AUTOSIZE);
    namedWindow(OUTPUT_WIN,CV_WINDOW_AUTOSIZE);
    imshow(INPUT_WIN, dst);

    int top = (int)(0.05 * src.rows);
    int left = (int)(0.05 * src.cols);
    int right = (int)(0.05 * src.cols);
    int bottom =(int)(0.05 * src.rows);
    RNG rng(12345);
    int borderType = BORDER_DEFAULT;

    int c = 0;
    while (true) {
        c = waitKey(500);
        if ((char)c == 27) {//ESC退出
            break;
        }
        if ((char)c == 'r') {
            borderType = BORDER_REPLICATE;
        }
        else if ((char)c == 'w') {
            borderType = BORDER_WRAP;
        }
        else if ((char)c == 'c') {
            borderType = BORDER_CONSTANT;
        }
        else {
            borderType = BORDER_DEFAULT;
        }
        Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
        copyMakeBorder(src, dst, top, bottom, left, right, borderType, color);
        imshow(OUTPUT_WIN, dst);
    }

    waitKey(0);
    return 0;
}

소벨 연산자
   회선 응용 프로그램 --- 이미지 에지 추출
       가장자리는 무엇인가 - 두드러진 중 하나입니다, 픽셀 값의 전환이 발생하는 위치되는 이미지의 특징 추출에, 이미지의 기능, 물체 감지 측면, Moshishibie 다른 사람들이 중요한 역할이
       잡을 수있는 방법을 / --- 첫 유도체 찾는 에지 화상 추출
       F - 델타 = F (X) (X-1), 델타 수록을 X 방향으로 변화의 화소, 강한 에지 신호를 나타내는, 그 이상.
    소벨 연산자
       이산 미분 연산자 (이산 미분 연산자) 영상 세기의 기울기를 계산 대략이다
       소벨 연산자 함수 미분 평활화 미분 가우시안 세트
       , 또한 제 미분 연산자, 미분 연산자로 알려져있는 X 방향 및 Y 방향으로 그라데이션 화상의 화상 수득 수평 양방향 유도체 수직
    Lapulasi 사업자의 이차 미분 연산자이다
       수직 구배의 수평 기울기
          = GX -1 0 1 Gy의 = -1 -2 - . (1)
               -2 0 2 0 0 0
               -1 0 1 2 1 1

            무게 차이에 따르면 확장

            최종 이미지 구배
               G = (GX * GX + Gy의 * Gy의) 제곱근
              사실 근사 알고리즘이 이용된다 : G를 = |은 GX | +가 | Gy를가 |
      소벨 연산자
        역수의 근사치를 얻 커널 = 3 매우 정확하지 SCHARR 함수의 수정 된 버전을 사용하여, 오퍼레이터는 다음과 같다
                . -3 0 -3 -10 -2 3
            은 GX = Gy를가 = 10 -10 0 0 0 0
                -2 0 3 3 10 3
        API는 소벨 :: CV의 설명
            CV : 소벨을 (
                InputArray의 SRC // 입력 화상
                outputArray의 DST // 출력 화상의 입력 화상 사이즈 일관된
                INT 깊이 // 출력 이미지 깊이
                의 INT DX // X 방향, 여러 1 차 도함수
                의 INT (DY), // Y 방향으로 여러 차 미분
                INT ksize, // 소벨 연산자 커널 크기, 1,3,5,7-해야합니다
                배 배율 = 1,
                더블 델타 = 0,
                INT borderType = BORDER_DEFAULT
            )

            입력 깊이 () 출력 깊이 (ddepth)
            CV_8U -1 / CV_16S / CV_32F / CV_64F
            CV_16U / CV_16S -1 / CV_32F / CV_64F
            CV_32F -1 / CV_32F / CV_64F
            CV_64F -1 / CV_64F

        OpenCV의 버전 SCHARR 향상된
            API가 SCHARR :: CV의 설명
              CV : SCHARR (
                  InputArray SRC에 // 입력 화상
                  OutputArray의 DST // 출력 화상의 입력 화상 사이즈 일관된
                  INT 깊이 // 출력 영상 깊이
                  , INT의 DX를 // X 방향 여러 1 차 도함수
                  의 INT (DY), // Y 방향의 여러 1 차 도함수
                  더블 배율 =. 1
                  번 델타 = 0,
                  INT borderType = BORDER_DEFAULT
              )

        단점 :
            잡음에 민감한 취약

        가우시안 잡음 평활화 흐림,
        계조 화상으로는
        x 및 y 경사 필요한
        혼합 XY의
        진폭 이미지

코드 보여줍니다

#include<opencv2/opencv.hpp>
            #include<iostream>
            #include<math.h>
            using namespace cv;
            int main(int argc,char** argv){
                Mat src,dst;
                src = imread("");
                if(!src.data){
                    printf("could not load image...\n");
                    return -1;
                }
                char INPUT_WIN[] = "Input image";
                char OUTPUT_WIN[] = "Output image";
                namedWindow(INPUT_WIN,CV_WINDOW_AUTOSIZE);
                imshow(INPUT_WIN,src);

                Mat gray_src;
                GaussianBlur(src,dst,Size(3,3),0,0);
                cvtColor(dst,gray_src,CV_BGR2GRAY);
                imshow("gray image",gray_src);

                Mat xgrad,ygrad;
                //原始版本
                //Sobel(gray_src,xgrad,CV_16S,1,0,3);
                //Sobel(gray_src,ygrad,CV_16S,0,1,3);

                //改进版本
                Scharr(gray_src,xgrad,CV_16S,1,0);
                Scharr(gray_src,ygrad,CV_16S,0,1);
                convertScaleAbs(xgrad,xgrad);
                convertScaleAbs(ygrad,ygrad);
                imshow("xgrad image",xgrad);
                imshow("ygrad image",ygrad);

                //第一种算法
                //Mat xygrad;
                //addWeighted(xgrad,0.5,ygrad,0.5,0.xygrad);
                //imshow("Final image",xygrad);

                //第二种算法，效果更好
                Mat xygrad = Mat(xgrad.size(),xgrad.type());
                int width = xgrad.cols;
                int height = xgrad.rows;
                for(int row = 0; row < height; row++){
                    for(int col = 0; col < width; col++){
                        int xg = xgrad.at<uchar>(row,col);
                        int yg = ygrad.at<uchar>(row,col);
                        int xy = xg + yg;
                        xygrad.at<uchar>(row,col) = saturate_cast<uchar>(xy);
                    }
                }

                waitKey(0);
                return 0;
            }

Laplance 조작
        이론
            설명 : 이차 미분의 변화의 최대 값이 0 인 경우, 즉, 에지가 제로이다. 이 이론에 따르면, 제 2 도함수가 계산 우리는 이미지 에지 추출의 2 차 도함수를 계산할 수있다.

            Laplance 연산자 :
              Laplance (F) = F (X)를 + F (Y)의 초 미분의 이차 미분이다
              관련 API의 CV : Laplance

            프로세스 흐름 :
               가우스 블러 --- 노이즈 (가우스 블러 ())
               계조 cvtColor로 변환된다 ()
               라플라스 --- 이차 미분을 계산 (라플라시안 ())
               의 절대 값의 converScaleAbs ()
               표시 결과

 #include<opencv2/opencv.hpp>
            #include<iostream>
            #include<math.h>
            using namespace cv;
            int main(int argc,char** argv){
                Mat src,dst;
                src = imread();
                if(!src.data){
                    printf("could not load image\n");
                    return -1;
                }
                namedWindow("input image",CV_WINDOW_AUTOSIZE);
                imshow("input image",src);

                Mat gray_src,edg_image;
                GaussianBlur(src,dst,Size(3,3),0,0);
                cvtColor(dst,gray_src,CV_BGR2GRAY);
                Laplacian(gray_src,edg_image,CV_16S,3);
                convertScaleAbs(edg_image,edg_image);
                //图像二值化
                threshold(edg_image,edg_image,0,255,THRESH_OTSU|THRESH_BINARY);
                namedWindow("output image",CV_WINDOW_AUTOSIZE);
                imshow("output image",edg_image);



                waitKey(0);
                return 0;
            }

캐니 에지 검출
       캐니 알고리즘 설명
           캐니 에지 검출 알고리즘은 1986 년
           좋은 에지 추출 알고리즘이다
           매우 일반적이고 매우 유용한 화상 처리 방법의
         단계 : CV : 캐니
            가우스 블러 --- 가우스 블러
            계조 변환 - --cvtColor
            --- 소벨 / SCHARR 그래디언트를 계산하는
            비 - 최대 억제 신호
            의 출력 이진 화상의 임계 값 레벨
          이 아닌 최대 억제 신호 :
             . 범용성 = Gy의 = 1 0 -1 -1 -1 -2
                  -2 0 0 2 0 0
                  -1 0 1. 2. 1. 1
            G * = Gy의 범용성은 GX + * Gy의 제곱근
            각도 = 아크 탄젠트 (GX / Gy의)
            상기 옐로우 180 22.5 0 내지 영역에서 157.5
            67.5 22.5의 범위에 녹지
            범위 67.5 블루 지역 - 112.5
            범위 112.5에서 적색 영역 - 157.5

            낮은 임계 치 화상 출력
               이 임계 값 T1을 T2, 상기 모든 유지된다 T2는 T1이 T2, T1보다 큰 이상이지만 모두가 상호 유지 화소로부터 떨어진 사람보다 작다. 마지막으로 이진 화상 출력을 얻기

               추천 높고 낮은 임계 비 T2 : T1 = 3; 2 : 1 고 임계치 T2이며, T1은 낮은 임계 값
       :: APIcv 캐니 ()
            캐니 (
                InputArray SRC에 // '비트 입력 화상 8-.
                OutputArray 가장자리 / 일반적으로 이진 이미지, 배경이 흑색 / 출력 에지 이미지
                들은 1/2 또는 1/3의 높은 임계 이중 THRESHOLD1 // 낮은 임계
                더블 THRESHOLD2 높은 임계 //
                INT aptertureSize // 소벨 연산자 크기는, 일반적으로 3 × 징. 3
                BOOL 선택 L2gradient // 진정한 수단 L2 정상화 또는 L1 정규화
            )

 #include<opencv2/opencv.hpp>
            #include<iostream>
            #include<math.h>
            using namespace cv;
            Mat src,dst,gray_src;
            int t1_value = 50;
            int max_value = 255;
            void Canny_Demo(int,void*);
            int main(int argc,char** argv){
                src = imread();
                if(!src.data){
                    printf("could not load image\n");
                    return -1;
                }
                namedWindow("input image",CV_WINDOW_AUTOSIZE);
                imshow("input image",src);

                cvtColor(src,gray_src,CV_BGR2GRAY);
                createTrackbar("Threshold Value","output image",&t1_value,max_value,Canny_Demo);
                Canny_Demo(0,0);
               
                waitKey(0);
                return 0;
            }
            void Canny_Demo(int,void*){
                Mat edge_output;
                blur(gray_src,gray_src,Size(3,3),Point(-1,-1),BORDER_DEFAULT);
                Canny(gray_src,edge_output,t1_value,t1_value * 2,3,false);
                dst.create(src.size(),src.type());
                src.copyTo(dst,edge_output);
                imshow("output image",dst);
            }