영상 처리 프로그래밍 - 화소점 처리

화소점 처리
원 화소의 값이나 위치를 바탕으로 단일 화소 값을 변경하는 기술
ex) 영상 반전, 밝게하기, 어둡게하기, 흑백, 감마처리 등등

<동일 영상>
-원본 이미지로부터 추출한 픽셀 각각의 정보를 출력 이미지의 픽셀에 그대로 저장

outImage[i][k] = inImage[i][k];

function equalImage() { // 동일 영상 알고리즘
            // (중요!) 출력 이미지의 크기가 결정 ---> 알고리즘에 의존...
            outH = inH;
            outW = inW;
            // 출력 영상의 2차원 메모리 할당
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    outImage[i][k] = inImage[i][k];
                }
            }
            // ******************************
            displayImage();
        }코드를 입력하세요

<영상 반전>
-화소 최대 값인 255에서 원본 이미지의 화소값만큼 빼서 출력

outImage[i][k] = 255-inImage[i][k]

function reverseImage() { // 영상 반전 알고리즘
            // (중요!) 출력 이미지의 크기가 결정 ---> 알고리즘에 의존...
            outH = inH;
            outW = inW;
            // 출력 영상의 2차원 메모리 할당
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    outImage[i][k] = 255 - inImage[i][k];
                }
            }
            // ******************************
            displayImage();
        }

<밝게하기(+50)>
-원본 이미지에 입력한 값(vlaue)만큼 더해서 밝게하기
-만약 원본 이미지+value의 값이 255 초과시 255로 저장
-전체적으로 밝아진다

if ( In+value > 255)
Out=255
Else
Out = In+value

function addImage() { // 영상 밝게하기 알고리즘
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let value =  parseInt(prompt("숫자 :", "100"));
            // let value = parseInt(addValue.value);
            // alert(value);
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    if (inImage[i][k] + value > 255)
                        outImage[i][k] = 255;
                    else 
                        outImage[i][k] = inImage[i][k] + value;
                    }
                }
            // ******************************
            displayImage();
        }

<어둡게하기(-50)>
-원본 이미지에 입력한 값(vlaue)만큼 빼서 어둡게하기
-만약 원본 이미지-value의 값이 0 미만시 0으로 저장
-전체적으로 어두워진다

if ( In-value < 0)
Out=0
Else
Out = In-value

function subImage() { // 영상 어둡게하기 알고리즘
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let value =  parseInt(prompt("숫자 :", "100"));
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    if (inImage[i][k] - value < 0)
                        outImage[i][k] = 0;
                    else 
                        outImage[i][k] = inImage[i][k] - value;
                    }
                }
            // ******************************
            displayImage();
        }

<곱하기(×2)>
-원본 이미지에 입력한 값(vlaue)만큼 곱하기
-만약 원본 이미지* value의 값이 255 초과시 255로 저장
-밝은 곳과 어두운 곳에 따라 값이 달라지는 경향

if ( In*value > 255)
Out=255
Else
Out = In * value

function mulImage() { // 밝기 곱셈처리 알고리즘
           // 밝은 곳이나 어두운 곳에 따라 값이 달라지는 경향
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let value =  parseInt(prompt("숫자 :", "2"));
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    if (inImage[i][k] * value > 255)
                        outImage[i][k] = 255;
                    else 
                        outImage[i][k] = inImage[i][k] * value;
                    }
                }
            // ******************************
            displayImage();
        }

<나누기(÷2)>
-원본 이미지에 입력한 값(vlaue)만큼 나누기
-밝은 곳과 어두운 곳에 따라 값이 달라지는 경향

Out = In / value

function divImage() { // 밝기 나눗셈처리 알고리즘
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let value =  parseInt(prompt("숫자(0제외) :", "2"));
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    outImage[i][k] = inImage[i][k] / value;
                }
            }
            // ******************************
            displayImage();
        }

<흑백(127기준)>
-원본 이미지의 화소값을 중앙 값인 127을 기준으로 127보다 작으면 0, 크면 255로 값으로 출력

if ( In > 127)
Out=255
Else
Out = 0

function black127Image() { // 흑백처리하기 (127기준) 알고리즘
            outH = inH;
            outW = inW;
            // 출력 영상의 2차원 메모리 할당
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                if (inImage[i][k]>127){
                    outImage[i][k] = 255;
                    }else{
                    outImage[i][k] = 0;
                    }
                }
            }
            // ******************************
            displayImage();
        }

<흑백(평균기준)>
-원본 이미지의 화소의 평균보다 높으면 흰색(0), 낮으면 검은색(255)으로 출력

avg = sum/ 전체 픽셀수

if ( In > avg)
Out=255
Else
Out = 0

function blackAvgImage() { // 흑백처리하기 (평균기준) 알고리즘
            outH = inH;
            outW = inW;
            // 출력 영상의 2차원 메모리 할당
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let sum = 0;
            let cnt = 0;
            let avg = 0;
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                    sum += inImage[i][k];
                    cnt++;
                }
            }
            avg = parseInt(sum/cnt);
            
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                if (inImage[i][k]>avg){
                    outImage[i][k] = 255;
                    }else {
                    outImage[i][k] = 0;
                    }
                }
            }
            // ******************************
            displayImage();
        }

<파라볼라(캡)>
-CAP 파라볼라 수식을 통해 만든 코드
-밝은 곳이 입체적으로 보이는 성질

outImage[i][k] = Math.pow((inImage[i][k]/127-1), 2) * 255

function pbCapImage() { // 파라볼라 알고리즘
            outH = inH;
            outW = inW;
            // 출력 영상의 2차원 메모리 할당
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            // out = 255 * ( in / 127 - 1) ** 2
            let LUT = new Array(256);
            // 미리 계산해 놓기
            for (let i=0; i<256; i++) {
                LUT[i] = 255.0 * Math.pow((i / 127.0 - 1), 2);
            }
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {                    
                    outImage[i][k] = LUT[inImage[i][k]];
                }
            }
            // ******************************
            displayImage();
        }

<파라볼라(컵)>
-CAP 파라볼라 수식을 통해 만든 코드
-어두운 곳이 입체적으로 보이는 성질

outImage[i][k] = Math.pow((inImage[i][k]/127-1), 2) * (-255) + 255

function pbCupImage() { // 파라볼라 알고리즘
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
             // out = 255 * ( in / 127 - 1) ** 2
            let LUT = new Array(256);
            // 미리 계산해 놓기
            for (let i=0; i<256; i++) {
                LUT[i] = (-255) * Math.pow((i/127-1), 2) + 255; 
            }
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {                    
                    outImage[i][k] = LUT[inImage[i][k]];
                }
            }
            // ******************************
            displayImage();
        }

<감마처리(1.5)>
-감마 보정식에 대입하여 결과 출력
-감마값이 1보다 크면 영상이 어두워지고, 1보다 작으면 영상이 밝아진다

outImage[i][k] = 255 * Math.pow((inImage[i][k]/255), value)

function gammaImage() { // 감마보정 알고리즘 (0.2~1.8)
            // 원본 이미지로부터 추출한 픽셀의 정보를 감마 보정식에 대입한 결과를 출력 이미지의 각 픽셀에 저장
            outH = inH;
            outW = inW;
            outImage = new Array(outH);
            for(let i=0; i<outH; i++)
                outImage[i] = new Array(outW);
            // **** 진짜 영상처리 알고리즘 *****
            let value = parseInt(prompt("감마값입력","1.5"));
            if(value<0)
                    value=1/(1-value);
                else
                    value+=1;
            for (let i=0; i<inH; i++) {
                for (let k=0; k<inW; k++) {
                 outImage[i][k] = 255 * Math.pow((inImage[i][k]/255), value);
                }
            }
            // ******************************
            displayImage();
        }