시연 영상(유튜브)
<화소영역처리 개요>
<원본이미지 엠보싱 처리하기>
알고리즘
결과화면
function embossImage(){//엠보싱 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[-1.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 1.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 블러링 처리하기>
알고리즘
결과화면
function blurrImage(){//블러링 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inW;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[1.0/9, 1.0/9, 1.0/9],
[1.0/9, 1.0/9, 1.0/9],
[1.0/9, 1.0/9, 1.0/9]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
// for(let i=0;i<outH;i++)
// for(let k=0;k<outW;k++)
// tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본이미지 샤프닝 처리하기>
알고리즘
결과화면
function sharpenImage(){//샤프닝 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[-1,-1,-1],
[-1,9,-1],
[-1,-1,-1]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
// for(let i=0;i<outH;i++)
// for(let k=0;k<outW;k++)
// tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 가우시안 처리하기>
알고리즘
결과화면
function gaussianImage(){//가우시안 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[1.0/16, 1.0/8, 1.0/16],
[1.0/8, 1.0/4, 1.0/8],
[1.0/16, 1.0/8, 1.0/16]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
// for(let i=0;i<outH;i++)
// for(let k=0;k<outW;k++)
// tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 고주파 샤프닝 처리하기>
알고리즘
결과화면
function hpfSharpImage(){//고주파 샤프닝 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[-1.0/9, -1.0/9, -1.0/9],
[-1.0/9, 8.0/9, -1.0/9],
[-1.0/9, -1.0/9, -1.0/9]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
//고주파 샤프닝 100곱해줘야함
S += 100.0*tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 이동과 차분 처리하기>
알고리즘
결과화면
function sadImage(){//이동과 차분 에지검출 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0, -1.0, 0.0],
[-1.0, 2.0, 0.0],
[0.0, 0.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본이미지 유사연산자 처리하기>
알고리즘
결과화면
//절댓값계산 함수
//Math.abs()라는 기본라이브러리 함수를 써도된다.
function abs(su){
if(su>=0)return su;
else return -su;
}
function opImage(){//유사 연산자 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0, -1.0, 0.0],
[-1.0, 2.0, 0.0],
[0.0, 0.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let max = 0.0;//주변것을 곱한것중 제일 큰수
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
if(abs(tmpInImage[i+1][k+1]-tmpInImage[i+m][k+n])>=max)
max = abs(tmpInImage[i+1][k+1]-tmpInImage[i+m][k+n]);
tmpOutImage[i][k]=max;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 로버츠 마스크 수평/수직 처리하기>
알고리즘
결과화면
function robertsImage(){//로버츠 마스크
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[-1.0, 0.0, -1.0],
[0.0, 2.0, 0.0],
[0.0, 0.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본이미지 소벨 마스크 수평/수직 처리하기>
알고리즘
결과화면
function sobelImage(){//소벨 마스크 수평/수직
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0, -2.0, -2.0],
[2.0, 0.0, -2.0],
[2.0, 2.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본이미지 프리윗 마스크 수평/수직 처리하기>
알고리즘
결과화면
function prewittImage(){//프리윗 마스크 수평/수직
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0, -1.0, -2.0],
[1.0, 0.0, -1.0],
[2.0, 1.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 라플라시안 처리하기>
알고리즘
결과화면
function laplacianImage(){//라플라시안 처리 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0, 1.0, 0.0],
[1.0, -4.0, 1.0],
[0.0, 1.0, 0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+2);
for(let i=0;i<inH+2;i++)
tmpInImage[i]= new Array(inW+2);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+2;i++)
for(let k=0;k<inW+2;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+1][k+1]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<3;m++)
for(let n=0;n<3;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 로그 처리하기>
알고리즘
결과화면
function logImage(){//로그 처리 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0,0.0,-1.0,0.0,0.0],
[0.0,-1.0,-2.0,-1.0,0.0],
[-1.0,-2.0,16.0,-2.0,-1.0],
[0.0,-1.0,-2.0,-1.0,0.0],
[0.0,0.0,-1.0,0.0,0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+4);
for(let i=0;i<inH+4;i++)
tmpInImage[i]= new Array(inW+4);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+4;i++)
for(let k=0;k<inW+4;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+2][k+2]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<5;m++)
for(let n=0;n<5;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
<원본 이미지 도그 처리하기>
알고리즘
결과화면
function dogImage(){//도그 처리 알고리즘
//(중요!) 출력이미지의 크기가 결정--> 알고리즘에 의존
outH=inH;
outW=inW;
//출력 영상의 2차원 메모리 할당
outImage = new Array(outH);
for (let i = 0; i < outH; i++)
outImage[i] = new Array(outW);
//***진짜 영상처리 알고리즘 ***
//(짱! 중요) --> 마스크를 선택
let mask = [
[0.0,0.0,0.0,-1.0,-1.0,-1.0,0.0,0.0,0.0],
[0.0,-2.0,-3.0,-3.0,-3.0,-3.0,-3.0,-2.0,0.0],
[0.0,-3.0,-2.0,-1.0,-1.0,-1.0,-2.0,-3.0,0.0],
[-1.0,-3.0,-1.0,9.0,9.0,9.0,-1.0,-3.0,-1.0],
[-1.0,-3.0,-1.0,9.0,19.0,9.0,-1.0,-3.0,-1.0],
[-1.0,-3.0,-1.0,9.0,9.0,9.0,-1.0,-3.0,-1.0],
[0.0,-3.0,-2.0,-1.0,-1.0,-1.0,-2.0,-3.0,0.0],
[0.0,-2.0,-3.0,-3.0,-3.0,-3.0,-3.0,-2.0,0.0],
[0.0,0.0,0.0,-1.0,-1.0,-1.0,0.0,0.0,0.0]
];
//임시 입력 배열(입력배열 + 2)
let tmpInImage = new Array(inH+8);
for(let i=0;i<inH+8;i++)
tmpInImage[i]= new Array(inW+8);
//임시 출력 배열 (출력배열과 크기 동일)
let tmpOutImage = new Array(outH);
for (let i = 0; i < outH; i++)
tmpOutImage[i] = new Array(outW);
//임시 입력 배열 초기화(127로, 평균값, 인접값*)
for(let i=0;i<inH+8;i++)
for(let k=0;k<inW+8;k++)
tmpInImage[i][k]=127.0;
//입력 이미지 => 임시 입력 이미지의 중간에 쏙~
for(let i=0;i<inH;i++)
for(let k=0;k<inW;k++)
tmpInImage[i+4][k+4]=inImage[i][k];
//영상처리 알고리즘 --> 회선 연산(=긁어가기)
for(let i=0;i<inH;i++){
for(let k=0;k<inW;k++){
//한점처리
let S = 0.0;//9점을 곱해서 합한 결과
for(let m=0;m<9;m++)
for(let n=0;n<9;n++)
S += tmpInImage[i+m][k+n]*mask[m][n];
tmpOutImage[i][k]=S;
}
}
//후처리 작업 (마스크의 합계가 0이면 127정도를 더해주기를 고려)
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++)
tmpOutImage[i][k]+=127.0;
//임시 출력이미지 --> 원 출력이미지
for(let i=0;i<outH;i++)
for(let k=0;k<outW;k++){
if(tmpOutImage[i][k] > 255.0)
outImage[i][k]=255;
else if(tmpOutImage[i][k] < 0.0)
outImage[i][k]=0;
else
outImage[i][k]=parseInt(tmpOutImage[i][k]);
}
//***********************
displayImage();
}
