Transcript 화소값 기반 처리

3장. 화소값기반처리
임은경
3장 - 화소값 기반 처리
1
영상처리 – 화소값 기반 처리
차례 및 목적

차례
 영상의
밝기 조절
 영상의 명암 대비 조절
 히스토그램
 대수 변환
 명암 변환
 룩업 테이블을 이용한 처리 속도 개선
 이진 영상 변환
 논리 연산
 CxImage 제공 함수와 비교하여 구현하기
3장 - 화소값 기반 처리
2
영상처리 – 화소값 기반 처리
들어가기전에…

화소값 기반 처리
 영상처리의
가장 중요하면서도 기초적인 작업
 영상에 있는 특정한 화소값을 기반으로 처리되는 기
법
 특징



픽셀의 원래 값이나 위치에 기반한 픽셀 값 변경
픽셀의 독립적인 처리
다른 픽셀의 영향을 받지 않음
 장점

단순하지만, 강력한 기능
3장 - 화소값 기반 처리
3
영상처리 – 화소값 기반 처리
영상의 밝기 조절


영상의 밝기 조절에 관한 개념
영상의 덧셈 처리
 상수
덧셈 처리
 두 영상간의 덧셈 처리

영상의 뺄셈 처리
 상수
뺄셈 처리
 두 영상간의 뺄셈 처리

블렌딩 처리
3장 - 화소값 기반 처리
4
영상처리 – 화소값 기반 처리
영상의 밝기 조절

영상의 밝기 조절을 어떻게 구현될까?
 명암도
영상 256레벨…
 전체적으로

밝게 만들기 위해…
어떤 특정값을 더해주자.
 고려사항
특정값을 더해주면 밝아지고 , 특정값을 빼주면 어두워진다.
 특정값을 더하고나 뺄때, 0 이하가 되거나 255이상이 되면
…?
 산술연산 처리(arithmetic operation)

3장 - 화소값 기반 처리
5
영상처리 – 화소값 기반 처리
영상의 밝기 조절

산술 연산 처리
 화소값
기반 처리 중 하나
 두가지 형태의 작업


영상의 밝기값 조절
두 영상과의 처리
 사칙연산과의


차이
사칙 연산 : +, -, *, / 만 존재함
산술 연산 : 사칙연산, 거듭제곱, 절대값 등 다양한 형태의 연
산이 존재함
3장 - 화소값 기반 처리
6
영상처리 – 화소값 기반 처리
영상의 밝기 조절

덧셈 연산자


각 픽셀에 특정값을 더해주는 처리
특징


상수 값을 더해주므로서 밝기 값이 증가함.
식


앞의 식
 화소에 다른 영상의 화소를 더해주는 경우
뒤의 식
 화소에 특정 값을 더해주는 경우
3장 - 화소값 기반 처리
7
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의
처리 예제
12
20
212
222
199
199
24
222
199
185
185
28
54
183
175
33
232
58
183
35
3장 - 화소값 기반 처리
8
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의

처리 예제
덧셈하기 ( + 50점)
12
20
212
222
62
70
262
272
199
199
24
222
249
249
74
272
249
235
235
78
+50
199
185
185
28
54
183
175
33
104
233
225
83
232
58
183
35
282
108
233
85
3장 - 화소값 기반 처리
9
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 앞의
문제점…

255를 넘어가는 경우는 어떻게 처리해야 할까?

해결점
 255를 넘으면 즉 흰색보다 더 흰색이 없으므로… 최대의
흰색(255)를 할당하는 방법
 0보다 작으면 즉 검은색보다 더 검은색이 없으므로…
최저의 검은색(0)을 할당하는 방법
 255를 넘는 경우 wrapping을 시도함…
 256은 다시 0, 257은 1, 258은 2, 259는 3, 260은 4,
…
3장 - 화소값 기반 처리
10
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의

처리 예제
덧셈하기 ( + 50점)
+50
62
70
255
255
249
249
74
255
249
235
235
78
104
233
225
83
255
108
233
85
clipping
3장 - 화소값 기반 처리
11
영상처리 – 화소값 기반 처리
픽셀 단위의 산술 연산

덧셈 처리한 예제
+40
입력영상
출력 영상
255
출력 픽셀의 색상
40
0
255
입력 픽셀의 색상
255
3장 - 화소값 기반 처리
12
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의

처리 예제
덧셈하기 ( + 50점)
+50
62
70
6
16
249
249
74
16
249
235
235
78
104
233
225
83
26
108
233
85
Wrapping
3장 - 화소값 기반 처리
13
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의
처리 예제

덧셈하기 ( + 50점) + wrapping

함수의 모양
255
출력 픽셀의 색상
50
0
255
입력 픽셀의 색상
255
3장 - 화소값 기반 처리
14
영상처리 – 화소값 기반 처리
영상의 밝기 조절

결과 예제
+ 15
3장 - 화소값 기반 처리
-15
15
영상처리 – 화소값 기반 처리
영상의 밝기 조절

산술 처리 응용 분야
 영상의


상태에 따른 밝기값 조절
어두운 영상의 경우 밝게… 너무 밝은 영상은 어둡게
영상분할 후 특정 영역을 강조하기 위해 특정영역의 명암도
값을 더하거나 빼는 처리
3장 - 화소값 기반 처리
16
영상처리 – 화소값 기반 처리
영상의 밝기 조절

두 영상간의 가감 연산
 앞의
영상의 산술 연산은 상수에 대한 산술연산인데
비해, 두 개의 영상에 대해 산술 연산이 이루어짐
3장 - 화소값 기반 처리
17
영상처리 – 화소값 기반 처리
영상의 밝기 조절
두

두


영상간의 덧셈
덧셈은 두 영상의 병합과 같은 의미
영상간의 뺄셈
뺄셈은 두 영상의 차이값을 나타냄
두 개의 영상에서 차이가 큰 부분이 밝게 나타남
3장 - 화소값 기반 처리
18
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의
처리 예제(영상1)
12
20
212
222
199
199
24
222
199
185
185
28
54
183
175
33
232
58
183
35
3장 - 화소값 기반 처리
19
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 산술연산의
처리 예제(영상2)
0
255
0
255
0
255
0
255
0
255
0
255
0
255
0
255
0
255
0
255
3장 - 화소값 기반 처리
20
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 영상1
+ 영상2 (clipping 처리)
12
255
212
255
199
255
24
255
199
255
185
255
54
255
175
255
232
255
183
255
3장 - 화소값 기반 처리
21
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 영상1
- 영상2 (clipping 처리)
12
0
212
0
199
0
24
0
199
0
185
0
54
0
175
0
232
0
183
0
3장 - 화소값 기반 처리
22
영상처리 – 화소값 기반 처리
영상의 밝기 조절

덧셈 처리한 예제


두개의 영상에 대해 덧셈 처리한 예제
특정 부분을 강조해주고자 할 경우에 사용


마스크 영상의 검은색
 값이 0이므로 다른 영상의 색상을 그대로 나타냄
마스크 영상의 흰색
 흰색으로 나타남
3장 - 화소값 기반 처리
23
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 덧셈
처리한 예제
+
=
3장 - 화소값 기반 처리
24
영상처리 – 화소값 기반 처리
영상의 밝기 조절

두 영상간의 덧셈
3장 - 화소값 기반 처리
25
영상처리 – 화소값 기반 처리
영상의 밝기 조절

뺄셈 연산자


각 픽셀에 특정값을 빼주는 처리
특징


상수 값을 빼주므로서 밝기 값이 감소함.(명암도를 어둡게 함)
식


앞의 식
 화소에 다른 영상의 화소를 빼주는 경우
뒤의 식
 화소에 특정 값을 빼주는 경우
3장 - 화소값 기반 처리
26
영상처리 – 화소값 기반 처리
영상의 밝기 조절

뺄셈 처리한 예제
-40
출력 영상
입력영상
255
출력 픽셀의 색상
0
-40
3장 - 화소값 기반 처리
255
입력 픽셀의 색상
27
영상처리 – 화소값 기반 처리
영상의 밝기 조절

뺄셈 연산의 예제
3장 - 화소값 기반 처리
28
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 뺄셈
연산의 예제
-
=
3장 - 화소값 기반 처리
29
영상처리 – 화소값 기반 처리
영상의 밝기 조절
 뺄셈
연산의 예제
-
=
3장 - 화소값 기반 처리
30
영상처리 – 화소값 기반 처리
영상의 밝기 조절

두 영상간의 뺄셈
3장 - 화소값 기반 처리
31
영상처리 – 화소값 기반 처리
영상의 밝기 조절

블렌딩 처리



덧셈연산의 경우 두 영상의 선형 결합(linear convolution)을 통
해 두개의 영상이 각각의 가중치에 따라 동시에 보이것이 가능함
가중치를 어떻게 주느냐에 따라 다양한 결과가 나올 수 있는데,
이를 블렌딩(blending)이라 함
블렌딩 연산자
Q( x, y)    A( x, y)  (1   )  B( x, y)
3장 - 화소값 기반 처리
32
영상처리 – 화소값 기반 처리
영상의 밝기 조절

블렌딩 처리 예제
3장 - 화소값 기반 처리
33
영상처리 – 화소값 기반 처리
영상의 밝기 조절

두영상의 블렌딩 효과
3장 - 화소값 기반 처리
34
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절


영상의 명암 대비에 대한 개념
곱셈 처리
 명암

나눗셈 처리
 명암

대비를 넓게 펼쳐주는 역할
대비를 좁게 만들어주는 역할
밝기 조절과 조합
3장 - 화소값 기반 처리
35
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

명암 대비(contrast)
 영상
내의 밝은 부분과 어두운 부분이 서로 영향을 미
쳐서 상이함이 강조되어 지각되는 정도
 이 정도는 영상 내 밝거나 어두운 명암값의 분포로 평
가됨
 명암


대비의 명칭
낮은 명암 대비
 영상 내 대부분이 흐리거나 어둡거나 밝다. 즉 밝기값들
이 어느 한쪽에 치우쳐 있음
높은 명암 대비
 영상 내 어둡고, 밝은 부분이 다 포함된다. 즉 밝기값의
분포가 고르게 분포되어 있음
3장 - 화소값 기반 처리
36
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절


동시 대비
 2가지 색을 동시에 보는 경우에 일어나는 대비 효과를 의
미함
계시 대비
 시간적인 차를 두고 2가지 색을 차례로 볼때의 대비 효과
를 의미함
 명암


곱셈 연산을 수행하기
밝은 부분을 더 밝게 어두운 부분을 조금 밝게 표현함
 명암


대비를 높이려면…?
대비를 낮추려면…?
나눗셈 연산을 수행하기
밝은 부분은 아주 어둡게, 어두운 부분은 조금 어둡게 표현함.
3장 - 화소값 기반 처리
37
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

곱셈 및 나눗셈 연산자



각 픽셀에 특정값을 곱해주거나 나누어주는 처리
명암 대비 조절이 가능함
특징



상수 값을 곱해주는 경우
 영상을 밝게 만들어줌
 어두운 부분은 약간 밝게만 만들고 밝은 부분은 더욱 밝게 만들
어 영상으로 보다 선명하게 만들어주는 효과
상수 값을 나누어주는 경우
 영상을 어둡게 만들어줌
 어두운 부분은 조금 어둡게 밝은 부분은 더욱 어둡게 만들어 영
상의 대비가 아주 좁아짐
식
3장 - 화소값 기반 처리
38
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

곱셈 처리한 예제
x 1.2
입력영상
출력 영상
255
출력 픽셀의 색상
0
3장 - 화소값 기반 처리
255
입력 픽셀의 색상
39
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

나눗셈 처리한 예제
/ 1.2
입력영상
출력 영상
255
출력 픽셀의 색상
0
3장 - 화소값 기반 처리
255
입력 픽셀의 색상
40
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

곱셈 나눗셈의 예제
3장 - 화소값 기반 처리
41
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

결과에 따른 히스토그램
빈
도
수
빈
도
수
0
명암값
255
명암값
0
(a) 어두운 영상
255
(b) 밝은 영상
빈
도
수
빈
도
수
0
명암값
255
(c) 낮은 명암대비 영상
명암값
0
255
(d) 높은 명암대비 영상
3장 - 화소값 기반 처리
42
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절
 곱셈의
결과
3장 - 화소값 기반 처리
43
영상처리 – 화소값 기반 처리
영상의 명암 대비 조절

나눗셈의 결과
3장 - 화소값 기반 처리
44
영상처리 – 화소값 기반 처리
히스토그램



히스토그램 의 개념
히스토그램 평활화
히스토그램 스트레칭
3장 - 화소값 기반 처리
45
영상처리 – 화소값 기반 처리
히스토그램 처리

히스토그램 처리
 영상의
밝기값에 대한 분포를 보여주는 그래프
 영상분석을 위한 중요한 도구


영상의 밝기 구성
명암의 대비 등의 정보
 영상 개선 및 화질 향상을 위해 사용됨
 히스토그램


영상의 밝기값을 수평측으로 하고 수평축의 발기값에 대응되
는 크기를 가진 픽셀수가 영상 안에 몇 개나 되는지를 나타내
는 빈도수를 수직축으로 해서 만든 그래프
따라서 흑백영상의 경우 수평측은 0~255의 범위값을 가지며
, 수직축의 값은 영상의 크기와 밝기의 분포에 따라 달라짐
3장 - 화소값 기반 처리
46
영상처리 – 화소값 기반 처리
히스토그램 처리

작은 크기의 샘플영상에 대한 히스토그램
 모든
색상의 히스토그램 값을 모두 더하면 얼마인가?
3장 - 화소값 기반 처리
47
영상처리 – 화소값 기반 처리
히스토그램 처리

히스토그램 예제
3장 - 화소값 기반 처리
48
영상처리 – 화소값 기반 처리
히스토그램 처리

밝기 분포가 다른 영상의 예
3장 - 화소값 기반 처리
49
영상처리 – 화소값 기반 처리
히스토그램 처리
빈
도
수
빈
도
수
0
명암값
255
명암값
0
(a) 어두운 영상
255
(b) 밝은 영상
빈
도
수
빈
도
수
0
명암값
255
(c) 낮은 명암대비 영상
명암값
0
255
(d) 높은 명암대비 영상
3장 - 화소값 기반 처리
50
영상처리 – 화소값 기반 처리
히스토그램 용도

화질 향상
 우주공간에서

여러가지 잡영(image noise)의 영향으로 화질이 나쁨
 화질



촬영한 사진
개선용도로 히스토그램 분석법을 사용
사람이 알아보기 좋은 선명한 화질의 영상으로 변화
사람의 눈이 밝기보다는 대비에 훨씬 민감하다는 특징을 이
용
화질 개선 영상의 예제
3장 - 화소값 기반 처리
51
영상처리 – 화소값 기반 처리
히스토그램 용도

물체 인식
 공장


자동화용 영상처리
자동화 카메라를 통해 획득된 영상에서 생산공정에 놓여있는
물건의 결함을 검사하거나 형상을 인식하기 위해 사용
잔동화 카메라의 경우 조명 제어가 가능하므로 영상 이치화
를 통한 물체 분리에 사용됨
 물체인식


히스토그램의 형태를 분석하여 이치화를 수행
이치화란(image Binarization)
 픽셀의 밝기값이 0~255사이에 골고루 존재하는 영상을
영상 픽셀의 밝기값을 0 또는 255의 두 값으로 매핑하는
영상처리
3장 - 화소값 기반 처리
52
영상처리 – 화소값 기반 처리
히스토그램 용도
 영상
이치화 예제
이치화
물체 인식 결과
3장 - 화소값 기반 처리
53
영상처리 – 화소값 기반 처리
히스토그램 용도
 물체


인식
동전의 크기를 인식하여 동전을 분류하는 영상처리의 예제
이때 선결 되어야 할 작업
 동전을 배경부분과 분리하는 작업이 요구됨
 이치화를 사용
 앞의 그림은 이치화 값을 80으로 주었을때 나타난 결과
 80보다 큰 픽셀은 255로 매핑
 80보다 작은 픽셀은 0으로 매핑
 이런 이치화 값을 임계치(threshold value)라고 함
 컴퓨터 비젼에서의 연구 분야
3장 - 화소값 기반 처리
54
영상처리 – 화소값 기반 처리
히스토그램 평활화

히스토그램 평활화 (histogram equalization)
 기존
영상의 명암 값 분포를 재분배하여 일정한 분포
를 가진 히스토그램을 생성
histogram
histogram
평활화의 효과
0
255
입력 픽셀의 색상
3장 - 화소값 기반 처리
0
255
입력 픽셀의 색상
55
영상처리 – 화소값 기반 처리
히스토그램 평활화

히스토그램 평활화의 세 단계
1.
입력영상의 히스토그램 생성
- 명암값 j 의 빈도수 hist[j] 를 계산
2.
각 명암값 i 에 대하여 0부터 i 까지의 빈도수의 누적 값을 계산
i
sum[i]   hist [ j ]
j 0
3.
단계 2에서 구한 누적값을 정규화
1
n[i ]  sum[i ]   255
N
4.
( N  전체 픽셀 수)
입력영상에서 픽셀 값 i를 정규화된 값 n[i]로 변환하여
결과 영상 생성
3장 - 화소값 기반 처리
56
영상처리 – 화소값 기반 처리
히스토그램 평활화 예
원영상
히스토그램
3장 - 화소값 기반 처리
57
영상처리 – 화소값 기반 처리
히스토그램 평활화 예
평활화된
영상
히스토그램
정규화
3장 - 화소값 기반 처리
58
영상처리 – 화소값 기반 처리
히스토그램 평활화 적용 예
빈
도
수
원영상
0
명암값
255
결과 영상
3장 - 화소값 기반 처리
59
영상처리 – 화소값 기반 처리
히스토그램 평활화
영상이 어두운 영역에서 세밀한 부분을 가질
때에 효과적
3장 - 화소값 기반 처리
60
영상처리 – 화소값 기반 처리
히스토그램 평활화
3장 - 화소값 기반 처리
61
영상처리 – 화소값 기반 처리
히스토그램

히스토그램 평활화
3장 - 화소값 기반 처리
62
영상처리 – 화소값 기반 처리
히스토그램 스트레칭

히스토그램 스트레칭
 명암

대비 효과를 제공함
명암 대비란
 영상의 가장 어두운 부분과 밝은 부분의 차이를 나타냄
 명암 대비가 낮은 경우
 차이값이 크지 않아, 전체적으로 어둡거나 밝게 나타
남
 명암 대비가 높은 경우
 차이값이 크게 나타나고 전체적으로 밝기값이 골고
루 나타남
3장 - 화소값 기반 처리
63
영상처리 – 화소값 기반 처리
히스토그램 스트레칭

낮은 명암 대비


높은 명암 대비


히스토그램이 일부분에 집중
히스토그램이 두개의 큰 마루를
가짐
좋은 명암 대비


균일한 화소값 분포를 가짐
특정한 마루나 골이 부각되지 않
음
3장 - 화소값 기반 처리
64
영상처리 – 화소값 기반 처리
히스토그램 스트레칭
 히스토그램



연산의 비교
펼활화와 스트레칭
평활화 : 히스토그램을 늘리지만, 늘어나는 간격이 다름
스트레칭 : 히스토그램을 늘리기 효과, 늘어나는 간격이 같음
3장 - 화소값 기반 처리
65
영상처리 – 화소값 기반 처리
히스토그램 스트레칭


히스토그램이 모든 범위의 화소 값을 포함하도
록 영상을 확장
중앙에 집중된 히스토그램을 갖는 영상에 적합
P( x, y )  min
P ' ( x, y ) 
 255
max  min
min : 최저 화소값, max : 최고 화소값
3장 - 화소값 기반 처리
66
영상처리 – 화소값 기반 처리
히스토그램 스트레칭 예
빈
도
수
원영상
0
명암값
255
결과 영상
3장 - 화소값 기반 처리
67
영상처리 – 화소값 기반 처리
히스토그램

히스토그램 스트레칭
3장 - 화소값 기반 처리
68
영상처리 – 화소값 기반 처리
히스토그램

히스토그램 스트레칭
 스트레칭의
문제점
 해결
방법
 엔드인 탐색 스트레칭 기법이 있음

Low, high 즉 범위 값을 임의로 지정하여 명암 대비 스트레
칭을 수행함

0
x  low
 P( x, y )  low
P ' ( x, y )  
 255 low  x  high
 high  low
high  x

255
3장 - 화소값 기반 처리
69
영상처리 – 화소값 기반 처리
히스토그램

히스토그램 스트레칭(엔드인 탐색)
3장 - 화소값 기반 처리
70
영상처리 – 화소값 기반 처리
히스토그램

메모
 그외
히스토그램 관련 알고리즘
 히스토그램 수축


히스토그램 스트레칭 알고리즘과 반대 개념
범위를 지정하여 수축시킴으로서 명암 대비가 감소함
 히스토그램



단순히 히스토그램을 이동시킴
왼쪽으로 이동하면 명암도 레벨이 낮아져 어두운 영상이 생
성됨
오른쪽으로 이동하면 명암도 레벨이 높아져 밝은 영상이 생
성됨
 히스토그램

슬라이딩
명세화
원 영상에 우리가 원하는 히스토그램 데이터를 반영하면 새
로운 결과 영상을 얻게 됨
3장 - 화소값 기반 처리
71
영상처리 – 화소값 기반 처리
대수 함수 변환

로그 연산자(Logarithm Operator)
영상의 각 화소 점들에 각각 로그 변환을 취함으로써 영상의 밝기 값을
변화시키는 방법.
 각각의 화소 점에 로그 변환을 하는 이유는 인간이 빛(명암도)을 인지하
는 정도가 로그 함수를 따라 반응하는 것에 기반을 두고 있다.
 로그 변환을 수행하면 명암도가 낮은 영역은 세분화되어 표현되고 높은
영역은 조밀해져서 영상이 전체적으로 밝아지는 효과를 가져온다.

3장 - 화소값 기반 처리
72
영상처리 – 화소값 기반 처리
대수 함수 변환

로그 연산자 예제
3장 - 화소값 기반 처리
73
영상처리 – 화소값 기반 처리
대수 함수 변환

로그 연산자 예제
3장 - 화소값 기반 처리
74
영상처리 – 화소값 기반 처리
명암 변환






명암 변환에 대한 설명
널 변환
역 변환
감마 상관관계 변환
비트 플래너 슬라이싱 변환
비트 플래너 슬라이싱 변환을 이용한 워터마킹
3장 - 화소값 기반 처리
75
영상처리 – 화소값 기반 처리
명암 변환

명암 변환(Intensity transformation)
 미리
지정된 함수 f(x)를 바탕으로 이전 화소값을 새로
운 화소값으로 바꿔주는 알고리즘
 함수 f(x)가 어떻게 정의되는냐에 따라 영상의 질을 좌
우함
 함수 f(x)만 정의하면 구현은 매우 쉽다.
 x는 함수의 처리 전의 입력이고, f(x)는 처리 후의 출
력 결과를 의미함
3장 - 화소값 기반 처리
76
영상처리 – 화소값 기반 처리
명암 변환

널 변환
 f(x)
=x
 아무런 변환이 없는 형태
 원 영상과 같은 영상
 구현

Pp.269 참고
255
f(x) : 출력영상
 결과

그림 3.38
0
255
x : 입력 영상
3장 - 화소값 기반 처리
77
영상처리 – 화소값 기반 처리
명암 변환

역 변환
 Negative


연산자
가장 큰 칼라 큰 값에 영상의 포인트 값을 빼주는 연산
연산자
255
출력 픽셀의 색상
0
255
입력 픽셀의 색상
3장 - 화소값 기반 처리
78
영상처리 – 화소값 기반 처리
명암 변환

역 변환
3장 - 화소값 기반 처리
79
영상처리 – 화소값 기반 처리
명암 변환

감마 상관관계 변환
 감마
조절

컴퓨터 그래픽 분야에서 많이 사용
출력 영상의 밝기 정도를 전반적으로 조절하는 것
적절하게 조절하지 않으면 영상은 너무 밝거나 너무 어두워
모니터에 출력해도 잘 볼 수 없음
영상을 제대로 재생하려면 감마 조절이 필요함
감마 상관관계 변환 함수

명암도 영상에 적용하기 위해




 1
f ( x)  pow x, 
 r
 x 1
f ( x)  255 * pow
, 
 255.0 r 
3장 - 화소값 기반 처리
80
영상처리 – 화소값 기반 처리
명암 변환

감마 상관관계 함수
255
f(x) : 출력영상
0
255
x : 입력 영상
3장 - 화소값 기반 처리
81
영상처리 – 화소값 기반 처리
명암 변환

감마 상관관계 변환
Gamma = 1/ 0.7
3장 - 화소값 기반 처리
gamma = 1/1.7
82
영상처리 – 화소값 기반 처리
명암 변환

비트 플래너 슬라이싱 변환
 일반적으로
명암도 레벨은 0~255로 256가지 존재함
 처리시간의 부담등으로 레벨을 줄이는 것이 가능함
 2레벨, 4레벨, 8레벨, 16레벨 등이 있음
 8개의 비트값을 가지고 있어서 전체 영상은 각 비트값
으로 구성된 8개의 비트 플래인으로 구성됨
 2레벨


2개의 컬러로 표현하는 방법
총 8가지 방법이 존재함
 각 특정 비트 하나를 선정하여 그 비트가 0이냐 1이냐를
두고 검은색 및 흰색으로 mapping 하는 방법
3장 - 화소값 기반 처리
83
영상처리 – 화소값 기반 처리
명암 변환
 비트
플래너 슬라이싱 변환(0비트)
12
20
212
222
199
199
24
222
199
185
185
28
54
183
175
33
232
58
183
35
00001100
0
검은색
3장 - 화소값 기반 처리
84
영상처리 – 화소값 기반 처리
명암 변환

비트 플래너 슬라이싱 변환(7비트)
12
20
212
222
199
199
24
222
199
185
185
28
54
183
175
33
232
58
183
35
00001100
0
검은색
3장 - 화소값 기반 처리
85
영상처리 – 화소값 기반 처리
명암 변환
 4레벨


4가지 색상 이용
4가지 방법이 존재함. 7, 6비트. 5,4비트, 3,2비트. 1,0비트를
통해서 이들의 값을 00, 01, 10, 11중 어느곳에 포함되느냐
에 따라 4가지 형으로 mapping하는 방법
 8레벨


8가지 색상 이용
3개의 비트를 이용하여 8개의 그레이 컬러로 분할함
 16레벨


16개의 색상 이용
4개의 비트를 선정하여 16가지의 그레이 컬러로 분할하는 방
법
3장 - 화소값 기반 처리
86
영상처리 – 화소값 기반 처리
명암 변환

비트 플래너 슬라이싱 변환
6비트
7비트
4비트
5비트
3장 - 화소값 기반 처리
87
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 영상 변환
 영상의
화소 값이 임으로 정해진 임계치(Threshold)
Th보다 작으면 화소들의 값은 검은색 값으로 바꾸고
큰 값이면 흰색으로 바꾸는 과정
 Thresholding 기법의 하나

연산자(이치화 연산과 Thresholding 연산)
1 if f ( x, y)  Th
g ( x, y)  
else
0
g ( x, y)  Ri
if Ti1  f ( x, y)  Ti , i  1,...,N

첫번째 식은 두가지 영역으로 표현되어 이치화라고 하지
만, 두번째 식은 구현에 따라 여러가지 영역으로 표현하
는 Thresholding 기법의 하나이다.
3장 - 화소값 기반 처리
88
영상처리 – 화소값 기반 처리
이진 영상 변환
 이치화와
Thresholding의 함수 표현
255
255
출력 픽셀의 색상
출력 픽셀의 색상
0
255
0
255
입력 픽셀의 색상
입력 픽셀의 색상
임계치
임계치
3장 - 화소값 기반 처리
89
영상처리 – 화소값 기반 처리
이진 영상 변환

히스토그램 정보를 이용한 물체와 배경의 분리
임계치
임계치
3장 - 화소값 기반 처리
임계치
90
영상처리 – 화소값 기반 처리
이진 영상 변환

히스토그램을 사용한 이치화

산과 계곡의 분리



동전 영상에서 물체(동전) 영역은 170의 밝기값 근방에 모여 있음
배경은 밝기값 50근처에 모여 있음
이들을 분리하기 위해 적절한 임계치는 100임
적절한 임계치
3장 - 화소값 기반 처리
91
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환(단일 경계값)
1 if f ( x, y)  Threshold
g ( x, y)  
else
0
255
출력 픽셀의 색상
0
255
입력 픽셀의 색상
임계치
3장 - 화소값 기반 처리
92
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환 (threshold value : 128 (중간값))
3장 - 화소값 기반 처리
93
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환(이중 경계값)
1 if low  f ( x, y)  high
g ( x, y)  
else
0
255
출력 픽셀의 색상
0
255
입력 픽셀의 색상
임계치(low)
3장 - 화소값 기반 처리
임계치(high)
94
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환(이중 경계값)
3장 - 화소값 기반 처리
95
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환 (히스토그램 분포 이용)
경계값
otsu 알고리즘
(분산 최대법 알고리즘)
: 히스토그램을 어떤 경계값으로써 2개 나누었을 경우, 각 영역 사이의 분산이
최대로 되도록 경계값을 정하는 것
3장 - 화소값 기반 처리
96
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환 (히스토그램 분포 이용) 경계값 : 77
3장 - 화소값 기반 처리
97
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환 (보간적 경계값 설정 방법)
 히스토그램으로
모든 화소값의 평균값 계산
 평균값보다 더 낮은 화소들의 평균값 구하기
 평균값보다 더 높은 화소들의 평균값 구하기
3장 - 화소값 기반 처리
98
영상처리 – 화소값 기반 처리
이진 영상 변환

이진 변환 (보간적 경계값 설정 방법)
3장 - 화소값 기반 처리
99
영상처리 – 화소값 기반 처리
논리 변환

논리 연산자




산술 연산자와 마찬 가지로 영상간의 비트 연산처리 역시 가능
산술 연산자가 그레이레벨(gray-Level) 영상이나 칼라영상에서 사용
될 수 있었던 반면, 0과 1만을 처리할 수 있는 논리 연산자는 일반적
으로 바이너리 영상간에만 사용
논리 연산자에는 AND, OR, XOR, NOT 연산자
논리 변환의 용도
두
영상간의 상관 관계를 기반으로 객체 존재 파악, 특징
추출 등에 사용됨
3장 - 화소값 기반 처리
100
영상처리 – 화소값 기반 처리
논리 변환
 논리
연산자
3장 - 화소값 기반 처리
101
영상처리 – 화소값 기반 처리
논리 변환

논리 연산자의 예제
3장 - 화소값 기반 처리
102
영상처리 – 화소값 기반 처리
논리 변환

논리 연산자 예제
3장 - 화소값 기반 처리
103
영상처리 – 화소값 기반 처리
구현하기

밝기 조절 (상수 덧셈 연산)
 덧셈
연산
 클리핑 함수
 두 영상간의 덧셈
 상수 뺄셈 연산
 두 영상간의 뺄셈
 블렌딩 처리(두영상간의 덧셈)

명암 대비 조절
 곱셈
연산
 나눗셈 연산
3장 - 화소값 기반 처리
104
영상처리 – 화소값 기반 처리
구현하기

히스토그램을 이용한 명암 대비 조절
 히스토그램
그리기
 히스토그램 평활화
 히스토그램 스트레칭

함수를 이용한 픽셀 처리
 대수
함수(로그 함수)
 널 함수
 역 함수
 감마 함수
 비트 플레인 처리

2레벨, 4레벨, 8레벨, 16레벨
3장 - 화소값 기반 처리
105
영상처리 – 화소값 기반 처리
구현하기

이진 영상 변환
 단일
경계값을 이용
 이중 경계값을 이용
 히스토그램을 이용
 보간적 경계값 설정을 이용

논리 연산
 이진
영상에서의 논리 연산
 명암도 영상에서의 논리 연산
3장 - 화소값 기반 처리
106
영상처리 – 화소값 기반 처리
BYTE** CPixel::GS_add_constant( BYTE** gray_image, int height, int
width, int constant){
int i, j;
BYTE **result_image;
if( constant < -255 || constant > 255 )
{
GS_errMsg("constant의 범위는 -255 ~ 255입니다.");
return NULL;
}
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image[i][j] + constant);
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
107
영상처리 – 화소값 기반 처리
BYTE CPixel::GS_clamping(int var, int method){
int retVal = 0;
if( method < 0 || method > 1 ){
GS_errMsg("method 값의 범위를 넘어, 0으로 설정합니다.");
method = 0;
}
switch(method)
{
case 0 : // saturation
if( var > 255 ) retVal = (BYTE)255;
else if( var < 0 ) retVal = (BYTE)0;
else retVal = (BYTE)var;
break;
case 1 : // wrap
if( var > 255 ) retVal = (BYTE)(var % 256);
else if( var < 0 ) retVal = (BYTE)0;
else retVal = (BYTE)var;
break;
}
return retVal;
차례로…
108
3장 - 화소값 기반 처리
}
영상처리 – 화소값 기반 처리
// 두 영상간 덧셈을 한다.
BYTE **CPixel::GS_add_image(BYTE **gray_image1, BYTE
**gray_image2, int height, int width){
int i, j;
CColor cColor;
BYTE **result_image;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image1[i][j] +
gray_image2[i][j]);
}
}
return result_image;
차례로…
}
3장 - 화소값 기반 처리
109
영상처리 – 화소값 기반 처리
BYTE** CPixel::GS_subtract_constant( BYTE** gray_image, int height,
int width, int constant){
int i, j;
BYTE **result_image;
if( constant < -255 || constant > 255 )
{
GS_errMsg("constant의 범위는 -255 ~ 255입니다.");
return NULL;
}
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image[i][j] - constant);
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
110
영상처리 – 화소값 기반 처리
/ 두 영상간 뺄셈을 한다.
BYTE **CPixel::GS_subtract_image(BYTE **gray_image1, BYTE
**gray_image2, int height, int width){
int i, j;
CColor cColor;
BYTE **result_image;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image1[i][j] gray_image2[i][j]);
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
111
영상처리 – 화소값 기반 처리
BYTE **CPixel::GS_blending_effect(BYTE **gray_image1, BYTE
**gray_image2, int height, int width, double alpha){
int i, j;
double var;
CColor cColor;
BYTE **result_image;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++) {
var = alpha*(double)gray_image1[i][j] +
(1.0 - alpha)*(double)gray_image2[i][j];
result_image[i][j] = GS_clamping(var);
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
112
영상처리 – 화소값 기반 처리
// 영상에 상수를 곱한다.
BYTE **CPixel::GS_multiple_constant( BYTE** gray_image, int height,
int width, double constant){
int i, j;
BYTE **result_image; CColor cColor;
if( constant < 0.0 || constant > 255.0 )
{
GS_errMsg("constant의 범위는 0.0 ~ 255.0 입니다.");
return NULL;
}
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++){
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image[i][j] * constant);
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
113
영상처리 – 화소값 기반 처리
// 영상을 상수로 나눈다.
BYTE **CPixel::GS_divide_constant( BYTE** gray_image, int height, int
width, double constant){
int i, j;
BYTE **result_image; CColor cColor;
if( constant == 0.0 ) {
GS_errMsg("0으로 나눌 수는 없습니다.");
return NULL; }
if( constant < 0.0 || constant > 255.0 )
{
GS_errMsg("constant의 범위는 0.0 ~ 255.0 입니다.");
return NULL; }
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++){
for(j=0; j<width; j++)
{
result_image[i][j] = GS_clamping(gray_image[i][j] / constant);
}
}
return result_image;
차례로…
114
3장 - 화소값 기반 처리
}
영상처리 – 화소값 기반 처리
// 명암도 영상의 histogram을 생성한다.
BYTE **CHist::GS_imhist( int *hist_image_height,int *hist_image_width,
BYTE **gray_image, int height, int width, int max_length ){
int i, j;
int pixel;
int tmp_hist_height;
// 히스토그램 영상의 높이, 너비를 설정한다.
int hist_height = 128;
int hist_width = 256;
// 히스토그램 영상에서 배경색을 지정한다.
BYTE background_level = 192;
// 256개의 방을 갖는 히스토그램을 초기화한다.
int *histData = (int *)calloc( 256, sizeof(int) );
// 히스토그램을 구한다.
for(i=0; i<height; i++)
{
for(j=0; j<width; j++) {
// 해당 화소값에 대한 빈도수를 증가시킨다.
pixel = (int)gray_image[i][j];
histData[ pixel ]++;
}
차례로…
115
3장 - 화소값 기반 처리
}
영상처리 – 화소값 기반 처리
// 히스토그램에서 최대 빈도수를 찾는다.
if( max_length == 0) {
tmp_hist_height = max_length;
for(i=0; i<256; i++){
tmp_hist_height = __max( histData[i], tmp_hist_height );
}
}
else {
tmp_hist_height = max_length;
}
int hist_bar_height = 20;
// 명암도 띠의 높이를 설정
CColor cColor;
// 히스토그램 영상에 대한 메모리 할당
BYTE **tmp_hist_image1 = cColor.GS_alloc2D( tmp_hist_height, hist_width );
BYTE **tmp_hist_image2 = cColor.GS_alloc2D( tmp_hist_height, hist_width );
BYTE **hist_image = cColor.GS_alloc2D( hist_height + hist_bar_height,
hist_width );
차례로…
3장 - 화소값 기반 처리
116
영상처리 – 화소값 기반 처리
// STEP 1 : 히스토그램 영상을 생성한다.
int tmp = 0;
for(i=0; i<hist_width; i++) {
tmp = histData[i];
if( tmp == 0 || tmp > tmp_hist_height ) continue;
for( j=tmp-1; j>=0; j--){
tmp_hist_image1[j][i] = (BYTE)255; // 흰색
}
}
// STEP 2 : 배경색을 교체한다.
for(i=0; i<tmp_hist_height; i++){
for(j=0; j<hist_width; j++){
tmp_hist_image2[i][j] = tmp_hist_image1[i][j];
if( tmp_hist_image2[i][j] == 255 )
tmp_hist_image2[i][j] = (BYTE)0;
else
tmp_hist_image2[i][j] = background_level;
차례로…
}
3장 - 화소값 기반 처리
117
영상처리 – 화소값 기반 처리
// STEP 3 : 이웃화소 보간법을 이용하여 128 x 256에 맞게 축소한다.
BYTE **tmp_hist_image3 = GS_nearInterp(hist_height, hist_width,
tmp_hist_image2, tmp_hist_height, hist_width);
// STEP 4 : histogram bar를 삽입한다.
for(i=0; i<hist_height + hist_bar_height; i++){
for(j=0; j<hist_width; j++){
// histogram bar
if( i < hist_bar_height )
{
hist_image[i][j] = (BYTE)j;
}
else{
hist_image[i][j] = tmp_hist_image3[ i-hist_bar_height ][j];
}
}
}
*hist_image_height = hist_height + hist_bar_height;
차례로…
*hist_image_width = hist_width;
3장 - 화소값 기반 처리
118
영상처리 – 화소값 기반 처리
// 메모리 해제
free( histData );
cColor.GS_free2D( tmp_hist_image1, tmp_hist_height );
cColor.GS_free2D( tmp_hist_image2, tmp_hist_height );
cColor.GS_free2D( tmp_hist_image3, hist_height );
return hist_image;
}
차례로…
3장 - 화소값 기반 처리
119
영상처리 – 화소값 기반 처리
// 히스토그램 평활화
BYTE **CHist::GS_imhisteq( BYTE **gray_image, int height, int width ){
int i, j;
double var;
int pixel;
int image_length = height * width; int gray_level = 256;
CColor cColor;
BYTE **histeq_image = cColor.GS_alloc2D(height, width);
// 256개의 방을 갖는 히스토그램을 초기화한다.
int *histData = (int *)calloc( gray_level, sizeof(int) );
// 히스토그램 누적합
int *hist_bin_acc = (int *)calloc( gray_level, sizeof(int) );
// 정규화 누적합
double *hist_normal_sum = (double *)calloc( gray_level,
sizeof(double) );
차례로…
3장 - 화소값 기반 처리
120
영상처리 – 화소값 기반 처리
// 히스토그램을 구한다.
for(i=0; i<height; i++){
for(j=0; j<width; j++) {
pixel = (int)gray_image[i][j];
histData[ pixel ]++; // 해당 화소값에 대한 빈도수를 증가
}
}
// 누적 빈도수를 계산한다.
for(i=0; i<gray_level; i++)
{
// 첫 인덱스 부분은 누적합 시키지 않는다.
if( i == 0)
hist_bin_acc[0] = histData[0];
else
hist_bin_acc[i] = hist_bin_acc[i-1] + histData[i];
}
// 정규화한 누적합을 계산한다.
for(i=0; i<gray_level; i++) {
var = ((double)hist_bin_acc[i]/(double)image_length) * (gray_level
- 1.0);
차례로…
hist_normal_sum[i] = var;
3장 - 화소값 기반 처리
121
영상처리 – 화소값 기반 처리
// 히스토그램 평활화 과정을 거쳐 새로운 영상을 얻는다.
for(i=0; i<height; i++)
{
for(j=0; j<width; j++) {
pixel = (int)gray_image[i][j];
histeq_image[i][j] = (BYTE)hist_normal_sum[ pixel ];
}
}
// 메모리 해제
free(histData);
free(hist_bin_acc);
free(hist_normal_sum);
return histeq_image;
}
차례로…
3장 - 화소값 기반 처리
122
영상처리 – 화소값 기반 처리
// 히스토그램 스트레칭
BYTE **CHist::GS_imhist_streching( BYTE **gray_image, int height, int
width ){
int i, j;
int smallest_index = 0;
// 최소 빈도수를 가진 인덱스
int largest_index = 0;
// 최대 빈도스를 가진 인댁스
int max_level = 255; // 명암도 영상의 최고 레벨(in 8-bit)
int gray_level = 256;// 명암도 영상 레벨
int pixel;
int tmp1;
double tmp2;
CColor cColor;
CPixel cPixel;
// 히스토그램 스트레칭 수행 결과를 담을 영상
BYTE **hist_streching_image = cColor.GS_alloc2D(height, width);
// 256개의 방을 갖는 히스토그램을 초기화한다.
int *histData = (int *)calloc( gray_level, sizeof(int) );
int *newHistData = (int *)calloc( gray_level, sizeof(int) );
차례로…
3장 - 화소값 기반 처리
123
영상처리 – 화소값 기반 처리
// 히스토그램을 구한다.
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
// 해당 화소값에 대한 빈도수를 증가시킨다.
pixel = (int)gray_image[i][j];
histData[ pixel ]++;
}
}
// 왼쪽에서 존재하는 index를 찾는다.
for(i=0; i<gray_level; i++) {
tmp1 = histData[i];
if( tmp1 != 0 ) {
smallest_index = i;
break;
}
}
차례로…
3장 - 화소값 기반 처리
124
영상처리 – 화소값 기반 처리
// 오른쪽에서 존재하는 index를 찾는다.
for(i=gray_level-1; i>=0; i--){
tmp1 = histData[i];
if( tmp1 != 0 ){
largest_index = i;
break;
}
}
// 새로운 히스토그램을 생성한다.
for(i=0; i<gray_level; i++){
tmp2 = (double)(i-smallest_index)/(double)(largest_indexsmallest_index);
newHistData[i] = (int)(tmp2*max_level);
}
차례로…
3장 - 화소값 기반 처리
125
영상처리 – 화소값 기반 처리
// 히스토그램 스트레칭 결과를 영상에 담는다.
for(i=0; i<height; i++){
for(j=0; j<width; j++) {
tmp1 = (int)gray_image[i][j];
hist_streching_image[i][j] = cPixel.GS_clamping(
newHistData[tmp1] );
}
}
// 메모리 해제
free(histData);
free(newHistData);
return hist_streching_image;
}
차례로…
3장 - 화소값 기반 처리
126
영상처리 – 화소값 기반 처리
// 명암도 영상에 대해 대수함수를 수행한다.
BYTE **CPixel::GS_logarithm( BYTE **gray_image, int height, int width
){
int i, j;
int max_var = -1;
BYTE **result_image;
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
if( max_var < (int)gray_image[i][j] ) {
max_var = (int)gray_image[i][j];
}
}
}
// 배율상수
double constant = 255.0 / log(1+max_var);
double pixel;
차례로…
3장 - 화소값 기반 처리
127
영상처리 – 화소값 기반 처리
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
pixel = constant * log( 1.0 + (int)gray_image[i][j] );
result_image[i][j] = (int)pixel;
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
128
영상처리 – 화소값 기반 처리
// 명암도 영상에 대해 널 변환한다.
BYTE **CPixel::GS_null_trans( BYTE **gray_image, int height, int width )
{
int i, j;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = gray_image[i][j];
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
129
영상처리 – 화소값 기반 처리
// 명암도 영상에 대해 역 변환한다.
BYTE **CPixel::GS_inverse_trans( BYTE **gray_image, int height, int
width )
{
int i, j;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
result_image[i][j] = 255 - gray_image[i][j];
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
130
영상처리 – 화소값 기반 처리
// 명암도 영상에 대해 감마 상관관계 변환한다.
BYTE **CPixel::GS_gamma_trans( BYTE **gray_image, int height, int
width, double r ){
int i, j;
double var;
double gamma;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++) {
gamma = 1.0/r;
var = 255.0 * pow( (gray_image[i][j]/255.0), gamma );
result_image[i][j] = GS_clamping( var );
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
131
영상처리 – 화소값 기반 처리
// 비트 플래너 슬라이싱 변환, 1 bit만 추출(2 level 영상)
BYTE **CPixel::GS_1bit_planar_slicing(BYTE **gray_image, int height,
int width, int nbit){
int i, j;
int var;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
if( nbit < 0 || nbit > 7 )
{
GS_errMsg("nbit의 범위는 1 ~ 7 입니다.");
return NULL;
}
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
var = (int)gray_image[i][j];
if( nbit == 4 ) var = ((var & 0x10) >> 4)*255;
else if( nbit == 5 ) var = ((var & 0x20) >> 5)*255;
else if( nbit == 6 ) var = ((var & 0x40) >> 6)*255;
else if( nbit == 7 ) var = ((var & 0x80) >> 7)*255;
차례로…
3장 - 화소값 기반 처리
132
영상처리 – 화소값 기반 처리
result_image[i][j] = (BYTE)var;
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
133
영상처리 – 화소값 기반 처리
// 비트 플래너 슬라이싱 변환, 2 bit만 추출(4 level 영상)
BYTE **CPixel::GS_2bit_planar_slicing(BYTE **gray_image, int height,
int width){
int i, j;
int var;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
var = (((int)gray_image[i][j] & 0xC0) >> 6)*255/3;
result_image[i][j] = (BYTE)var;
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
134
영상처리 – 화소값 기반 처리
// 비트 플래너 슬라이싱 변환, 8 bit만 추출(16 level 영상)
BYTE **CPixel::GS_4bit_planar_slicing(BYTE **gray_image, int height,
int width){
int i, j;
int var;
CColor cColor;
BYTE **result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
var = (((int)gray_image[i][j] & 0xF0) >> 4)*255/15;
result_image[i][j] = (BYTE)var;
}
}
return result_image;
}
차례로…
3장 - 화소값 기반 처리
135
영상처리 – 화소값 기반 처리
// 단일 경계값을 이용한 이진 영상 변환
BYTE **CPixel::GS_gray2binary_unity( BYTE **gray_image, int height,
int width, int threshold ){
int i, j;
BYTE **result_image;
double pixel;
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
// 이진 영상 변환을 위한 LUT 생성
double *LUT = (double *)calloc(256, sizeof(double));
for(i=0; i<256; i++)
{
if( i > threshold ) LUT[i] = 1;
else LUT[i] = 0;
}
차례로…
3장 - 화소값 기반 처리
136
영상처리 – 화소값 기반 처리
for(i=0; i<height; i++){
for(j=0; j<width; j++)
{
pixel = LUT[ (int)gray_image[i][j] ];
result_image[i][j] = (BYTE)pixel;
}
}
free(LUT);
return result_image;
}
차례로…
3장 - 화소값 기반 처리
137
영상처리 – 화소값 기반 처리
// 이중 경계값을 이용한 이진 영상 변환
BYTE **CPixel::GS_gray2binary_dual( BYTE **gray_image, int height,
int width, int low_threshold, int high_threshold ){
int i, j;
BYTE **result_image; double pixel;
// 메모리 할당
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
// 이진 영상 변환을 위한 LUT 생성
double *LUT = (double *)calloc(256, sizeof(double));
for(i=0; i<256; i++) {
if( i >= low_threshold && i <= high_threshold ){
LUT[i] = 1;
}
else { LUT[i] = 0; }
}
차례로…
3장 - 화소값 기반 처리
138
영상처리 – 화소값 기반 처리
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
pixel = LUT[ (int)gray_image[i][j] ];
result_image[i][j] = (BYTE)pixel;
}
}
free(LUT);
return result_image;
}
3장 - 화소값 기반 처리
139
영상처리 – 화소값 기반 처리
// 히스토그램의 분포를 이용한 이진 영상 변환
BYTE **CPixel::GS_gray2binary_otsu( BYTE **gray_image, int
height, int width, int *otsu_threshold ){
int i, j;
int pixel;
// 히스토그램을 구한다.
int *histData = (int *)calloc( 256, sizeof(int) );
double *histPData = (double *)calloc( 256, sizeof(double) );
double *histCData = (double *)calloc( 256, sizeof(double) );
// 히스토그램을 구한다.
for(i=0; i<height; i++)
{
for(j=0; j<width; j++)
{
// 해당 화소값에 대한 빈도수를 증가시킨다.
pixel = (int)gray_image[i][j];
histData[ pixel ]++;
}
}
double sum = 0.0;
차례로…
3장 - 화소값 기반 처리
140
영상처리 – 화소값 기반 처리
for(i=0; i<256; i++) sum += (histData[i]);
for(i=0; i<256; i++) histPData[i] = (double)(histData[i])/sum;
for(i=0; i<256; i++) {
for(j=0; j<=i; j++) {
histCData[i] += histPData[j];
}
}
double *f = (double *)calloc( 256, sizeof(double) );
for(i=0; i<256; i++) {
for(j=0; j<=i; j++) {
f[i] += j * histPData[j];
}
}
double F = f[255];
double t = 0.0;
double *sigma = (double *)calloc( 256, sizeof(double) );
차례로…
3장 - 화소값 기반 처리
141
영상처리 – 화소값 기반 처리
for(i=0; i<256; i++) {
t = histCData[i] - histCData[i]*histCData[i];
if(t == 0) t = 0.000001;
sigma[i] = ((F*histCData[i] - f[i]) * (F * histCData[i] - f[i])) / t;
}
double maxSigma = -99999999.0; int threshold = -1;
for(i=0; i<256; i++){
if( sigma[i] > maxSigma ) {
threshold = i;
maxSigma = sigma[i];
}
}
*otsu_threshold = threshold;
// 메모리 해제
free(histData); free(histPData); free(histCData);
free(f); free(sigma);
return GS_gray2binary_unity(gray_image, height, width, threshold);
3장 - 화소값 기반 처리
142
영상처리 – 화소값 기반 처리
// 보간적 경계값 설정을 이용한 이진 영상 변환
BYTE **CPixel::GS_gray2binary_iterate( BYTE **gray_image, int
height, int width, int *iterate_threshold ){
int i, j;
int pixel;
double hist_sum = 0.0;
double hist_old_mean = 0.0;
double hist_mean = 0.0;
double low_sum;
double high_sum;
int
low_count;
int high_count;
int threshold;
int *histData = (int *)calloc( 256, sizeof(int) );
double *histPData = (double *)calloc( 256, sizeof(double) );
double *histCData = (double *)calloc( 256, sizeof(double) );
// 히스토그램을 구한다.
for(i=0; i<height; i++){
for(j=0; j<width; j++) {
pixel = (int)gray_image[i][j];
histData[ pixel ]++;
}
차례로…
143
3장 - 화소값 기반 처리
}
영상처리 – 화소값 기반 처리
for(i=0; i<256; i++) hist_sum += (histData[i]*i);
//히스토그램 합
hist_old_mean = hist_sum/(double)(height*width); // 히스토그램 평균
// 반복적으로 평균값을 계산한다.
do {
hist_mean = hist_old_mean;
// 초기화
low_sum = 0.0; high_sum = 0.0; low_count = 0; high_count = 0;
for (i=0; i<256; i++){
if( (double)i <= hist_old_mean ){
low_sum += histData[i]*i;
low_count += histData[i];
}
else{
high_sum += histData[i]*i;
high_count += histData[i];
}
차례로…
}
3장 - 화소값 기반 처리
144
영상처리 – 화소값 기반 처리
hist_old_mean = ( (low_sum/(double)low_count) +
(high_sum/(double)high_count) )/2.0;
} while(hist_old_mean != hist_mean);
threshold = (int)hist_old_mean;
*iterate_threshold = threshold;
// 메모리 해제
free(histData);
return GS_gray2binary_unity(gray_image, height, width, threshold);
}
차례로…
3장 - 화소값 기반 처리
145
영상처리 – 화소값 기반 처리
// 이진 영상에서의 논리 연산 - 논리 연산자(logical operator) 사용
BYTE **CPixel::GS_binary_logic( BYTE **binary_image1, BYTE
**binary_image2, int height, int width, int method ){
int i, j;
BYTE **result_image; BYTE var, var1, var2;
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++){
for(j=0; j<width; j++){
var1 = (binary_image1[i][j] == 0 ? 1 : 0);
var2 = (binary_image2[i][j] == 0 ? 1 : 0);
switch(method){
case 0 :
// AND
var = (var1 && var2);
break;
case 1 :
// NAND
var = !(var1 && var2);
break;
차례로…
3장 - 화소값 기반 처리
146
영상처리 – 화소값 기반 처리
case 2 :
case 3 :
case 4 :
case 5 :
// OR
var = (var1 || var2);
break;
// NOR
var = !(var1 || var2);
break;
// XOR
var = (var1 != var2 ? 1 : 0);
break;
// XNOR
var = (var1 == var2 ? 1 : 0);
break;
}
result_image[i][j] = (var == 0 ? 1 : 0);
} // end for
} // end for
return result_image;
3장 - 화소값 기반 처리
차례로…
147
영상처리 – 화소값 기반 처리
// 명암도 영상에서의 논리 연산 - 비트 연산자(bitwise operator) 사용
BYTE **CPixel::GS_gray_logic( BYTE **gray_image1, BYTE
**gray_image2, int height, int width, int method ){
int i, j;
BYTE **result_image; int var, var1, var2;
CColor cColor;
result_image = cColor.GS_alloc2D( height, width );
for(i=0; i<height; i++){
for(j=0; j<width; j++) {
var1 = (int)gray_image1[i][j];
var2 = (int)gray_image2[i][j];
switch(method){
case 0 :
// AND
var = (var1 & var2);
break;
case 1 :
// NAND
var = ~(var1 & var2);
break;
차례로…
3장 - 화소값 기반 처리
148
영상처리 – 화소값 기반 처리
case 2 :
case 3 :
case 4 :
case 5 :
// OR
var = (var1 | var2);
break;
// NOR
var = ~(var1 | var2);
break;
// XOR
var = var1 ^ var2;
break;
// Difference
var = var & (~var2);
break;
} // end switch
result_image[i][j] = (BYTE)var;
} // end for
} // end for
return result_image;
}
3장 - 화소값 기반 처리
차례로…
149
영상처리 – 화소값 기반 처리
레포트 -3
제공된 클래스를 이용하여 구현하기
 제공된


클래스
HIST.CPP, HIST.H
PIXEL.CPP, PIXEL.H
 제공된
클래스를 이용하여 3장의 메뉴를 만들고 다음
의 처리를 메뉴에 추가하여 구현해보라.






명암 밝기 – 상수 덧셈, 상수 뺄셈
명암 대비 – 상수 곱셈, 상수 나눗셈
히스토그램 – 히스토그램 보기, 히스토그램 평활화, 히스토그
램 스트레칭
명암 변환 함수 – 로그 함수, 널 함수, 역 함수, 감마 함수, 비
트 플레인(2레벨, 8레벨, 16레벨)
이진 변환 – 단일 경계값, 이진 경계값, 히스토그램 방법
논리 함수 - 명암도 논리 연산
3장 - 화소값 기반 처리
150
영상처리 – 화소값 기반 처리
레포트 -3 제출일

이주 후 수업 전날 밤 12시까지
 제출시
주의 사항

제목 : 레포트3_자신의학과학번이름
이름 : 자신의 이름
파일 첨부를 통해서 올려주세요.

파일 명 : 레포트3_자신의학과학번이름.ZIP


3장 - 화소값 기반 처리
151