[OpenCV] Convert color to grayscale, Image Resizing and Rotation

Convert color image to grayscale image

---

1 Algorithm

 center position 과 window size(BLK)를 입력받는다. 입력받는 것들이 0보다 작을 경우에는 다시 입력하도록 do-while로 처리한다. (out of boundary) 

 시작하는 지점을 startX, startY, 끝나는 지점을 endX, endY 로 정의한다.

 >  startX = (centerX - BLK < 0)? 0 : centerX - BLK;

endX = (centerX + BLK > width) ? width : centerX + BLK;

startY = (centerY - BLK < 0) ? 0 : centerY - BLK;

endY = (centerY + BLK > height) ? height : centerY + BLK;

 y축 반복문은 startY ~ endY, x축 반복문은 startX ~ endX 까지 반복한다.

 > grayscale = (red + green + blue) / 3
 > red = green = blue = grayscale 

2 Code

#include <opencv2/imgproc.hpp>

#include <opencv2/highgui.hpp>

using namespace cv;

void main()

{

        int x, y, centerX, centerY, BLK;

        int startX, endX, startY, endY;

        Mat img = imread("test.jpg", CV_LOAD_IMAGE_COLOR);

        int width = img.cols;

        int height = img.rows;

        Mat Result = img.clone();

        do

        {

               printf("Input your center position and window size : ");

               scanf("%d %d %d", &centerX, &centerY, &BLK);

        

        } while (!(centerX >= 0 && centerY >= 0 && BLK > 0));

        

        startX = (centerX - BLK < 0)? 0 : centerX - BLK;

        endX = (centerX + BLK > width) ? width : centerX + BLK;

        startY = (centerY - BLK < 0) ? 0 : centerY - BLK;

        endY = (centerY + BLK > height) ? height : centerY + BLK;

        for (y = startY; y < endY; y++)

        {

               for (x = startX; x < endX; x++)

               {

                       int gray = (img.at<Vec3b>(y, x)[2] + img.at<Vec3b>(y, x)[1] + img.at<Vec3b>(y, x)[0]) / 3;

                       

                       Result.at<Vec3b>(y, x)[2] = gray;

                       Result.at<Vec3b>(y, x)[1] = gray;

                       Result.at<Vec3b>(y, x)[0] = gray;

               }

        }

        //imshow("color", img);

        imwrite("EE02_convert_color_to_gray.bmp", Result);

        printf("finished\n");

        waitKey(5000);

}

Image Resizing - NN(Nearest Neighbor)

---

  image resizing 방법에는 NN(Nearest Neighbor), Bi-linear, Bi-cubic 세 가지 방법이 존재한다. 다른 방법도 많다! 오늘 배운 내용은 NN, Bi-linear 두 가지 방법이다.

  우선 NN(Nearest Neighbor)을 이용해 두배 확대, 두배 축소를 간단히 구현해보았다. mini_pixel[3][3] 배열을 정의해서 두배 확대를 했고, big_pixel[6][6] 배열을 정의해서 두 배 축소를 했다. 코드와 결과는 아래와 같다. up scaling을 적용할 때에는 반복문을 기존 작은 배열에 맞추어 돌리면서 [y*2+0][x*2+0] 과 같이 접근하여 값을 대입했다. down scaling은 큰 배열에 맞추어 돌리면서 반복문을 2칸(down scaling 범위)씩 뛰어넘어 [y/2][x/2] 와 같이 접근하여 값을 대입했다. 둘 다 input에 맞춰서 반복문을 돌리면 되는 것 같다!

1 Up scaling 코드

 

        printf("2x up-scaling \n- - - - - - - - - - \n");

        for (y = 0; y < 3; y++)

        {

               for (x = 0; x < 3; x++)

               {

                       up_scaling[y * 2 + 0][x * 2 + 0] = mini_pixel[y][x];

                       up_scaling[y * 2 + 0][x * 2 + 1] = mini_pixel[y][x];

                       up_scaling[y * 2 + 1][x * 2 + 0] = mini_pixel[y][x];

                       up_scaling[y * 2 + 1][x * 2 + 1] = mini_pixel[y][x];

               }

        }

2 Down Scaling 코드 

        printf("1/2 down-scaling \n- - - - - - - - - - \n");

        for (y = 0; y < 6; y+=2)

        {

               for (x = 0; x < 6; x+=2)

               {

                       down_scaling[(int)(y / 2)][(int)(x / 2)] = big_pixel[y][x];

               }

        }

Image Resizing - Bi-linear interpolation 

---

  image resizing 을 하면서 만약 0.7 배율로 한다면, 기존 (1, 1)좌표 값은 (0.7, 0.7)이 된다. 이 픽셀이 갖게 되는 값을 계산할 때 주변 4개의 픽셀을 이용해 weighted sum 을 취한다. 픽셀의 값을 계산할 때 forward filling, backward filling 두 가지 방식이 있는데 forward filling은 input image 좌표에서 result image 좌표로 scale 을 곱해주는 방식이고, backward filling 방식은 result image 가 있다고 가정하여, 그 좌표에 1/scale 을 곱해 input image 에서 원래 어떤 위치에 존재했는가를 찾아가는 방식이다. 

  

  내가 사용한 변수는 result image의 좌표는 x, y 로 정의했고 input image의 좌표는 posX = x / scale, posY = y/scale 이라고 정의했다. scale이 나눠진 값이기 때문에 posX, posY 는 float data가 될 것이며 (int)posX, (int)posX + 1, (int)posY, (int)posY + 1 값들을 이용해서 주변 4개 픽셀 값으로 최종 픽셀 값을 계산한다. 핵심적인 부분은 아래 코드이다. 물론, result 객체는 미리 정의해두어야한다.

        for (y = 0; y < result.rows-1; y++)

        {

               for (x = 0; x < result.cols-1; x++)

               {

                       posX = x / scale;

                       posY = y / scale;

                       pre_posX = (int)posX;

                       next_posX = pre_posX + 1;

                       pre_posY = (int)posY;

                       next_posY = pre_posY + 1;

                       if (next_posX > width || next_posY > height)

                              continue;

                       //printf("(y, x) = (%d, %d) (posY, posX) = (%.2f, %.2f) ", y, x, posY, posX);

                       //printf("pre_posX, next_posX, pre_posY, next_posY : %d %d %d %d ", pre_posX, next_posX, pre_posY, next_posY);

                       for (i = 0; i < 3; i++)

                       {

                              posY_L[i] = (next_posY - posY)*img.at<Vec3b>(pre_posY, pre_posX)[i] + (posY - pre_posY)*img.at<Vec3b>(next_posY, pre_posX)[i];

                              // -> green

                              posY_R[i] = (next_posY - posY)*img.at<Vec3b>(pre_posY, next_posX)[i] + (posY - pre_posY)*img.at<Vec3b>(next_posY, next_posX)[i];

                              // -> pink

                              posX_U[i] = (next_posX - posX)*img.at<Vec3b>(pre_posY, pre_posX)[i] + (posX - pre_posX)*img.at<Vec3b>(pre_posY, next_posX)[i];

                              // -> yellow

                              posX_D[i] = (next_posX - posX)*img.at<Vec3b>(next_posY, pre_posX)[i] + (posX - pre_posX)*img.at<Vec3b>(next_posY, next_posX)[i];

                              // -> blue

                              new_pixel[i] = ((next_posX - posX)*posY_L[i] + (posX - pre_posX)*posY_R[i] + (next_posY - posY)*posX_U[i] + (posY - pre_posY)*posX_D[i]) / 2;

                              

                              result.at<Vec3b>(y, x)[i] = new_pixel[i];

                       }

                       //printf("-> %d %d %d\n", new_pixel[2], new_pixel[1], new_pixel[0]);

               }

        }

Image rotation with forward filling

---

  Input image(img 객체)를 원하는 입력 값(scale degree)으로 회전시켜 Output image(result 객체)에 픽셀 단위로 계산하여 저장한다. Output image(result 객체)는 input image와 사이즈는 같다는 점도 고려해준다.

  입력 받은 각도(scale degree)는 육십분법이기 때문에, 다음 식에 의하여 호도법으로 변환해준다. radian = scale * PI / 180 으로 계산한 후 삼각함수 계산 시에는 radian 값을 이용한다. 

  Rotation matrix 와 [x y]를 행렬 곱한 결과는 [posX posY] 이다. posX = x * cos(radian) – y * sin(radian), posY = x * sin(radian) + y * cos(radian) 으로 계산해준다. 

  여기서는 Input image의 중심 지점을 기준으로 회전해야 하므로 위의 식에서 변형해준다. posX = (x-centerX) * cos(radian) – (y-centerY) * sin(radian) + centerX, posY = (x-centerX) * sin(radian) + (y-centerY) * cos(radian) + centerY 으로 계산한다.

  핵심적인 코드는 다음과 같다.

  결과 사진은 10도, 45도, -45도 0도 회전한 사진이다. 180도 회전했을 때는 검은색 선이 생기면서 조금 깨진다. 약간의 깨짐은 있지만, 회전은 정상적으로 되는 것을 확인했다.

Image rotation with bi-linear interpolation

---

  Input image(img 객체)를 원하는 입력 값(scale degree)으로 회전시켜 Output image(result 객체)에 픽셀 단위로 계산하여 저장한다. Output image(result 객체)는 input image와 사이즈는 같다는 점도 고려해준다.

  입력 받은 각도(scale degree)는 육십분법이기 때문에, 다음 식에 의하여 호도법으로 변환해준다. radian = scale * PI / 180 으로 계산한 후 삼각함수 계산 시에는 radian 값을 이용한다. 

  Backward filling 방식으로 우선 result 의 x, y 좌표를 가지고 input image의 좌표 posX, posY 값을 찾는다. 값을 찾기 위해서는 위에서 사용한 rotation matrix의 inverse matrix를 찾아서 계산해준다. 중심을 기준으로 계산해주어야 하기 때문에, 중심 좌표(centerX, centerY) 변수를 이용해 아래 식을 계산해주었다.

  최종 역행렬은 [[cos -sin][sin cos]] 이고, posX = (x-centerX) * cos(radian) + (y-centerY) * sin(radian) + centerX, posY = -(x-centerX) * sin(radian) + (y-centerY) * cos(radian) + centerY 으로 input image의 좌표 값을 찾아준다.

  찾아낸 좌표는 float 값이기 때문에 bi-linear interpolation(양방향 선형 보간법)을 이용해서 주변 4개의 좌표들에 가중치를 주어 픽셀 값을 계산한다. 

  Bi-linear interpolation 방식을 이용하여 깨짐이 없음을 확인했다.