3장. 화소값기반처리 임은경 3장 - 화소값 기반 처리.

Presentation on theme: "3장. 화소값기반처리 임은경 3장 - 화소값 기반 처리."— Presentation transcript:

1 3장. 화소값기반처리 임은경 3장 - 화소값 기반 처리

2 차례 및 목적 차례 영상의 밝기 조절 영상의 명암 대비 조절 히스토그램 대수 변환 명암 변환
룩업 테이블을 이용한 처리 속도 개선 이진 영상 변환 논리 연산 CxImage 제공 함수와 비교하여 구현하기 3장 - 화소값 기반 처리

3 들어가기전에… 화소값 기반 처리 영상처리의 가장 중요하면서도 기초적인 작업 영상에 있는 특정한 화소값을 기반으로 처리되는 기법
특징 픽셀의 원래 값이나 위치에 기반한 픽셀 값 변경 픽셀의 독립적인 처리 다른 픽셀의 영향을 받지 않음 장점 단순하지만, 강력한 기능 3장 - 화소값 기반 처리

4 영상의 밝기 조절 영상의 밝기 조절에 관한 개념 영상의 덧셈 처리 영상의 뺄셈 처리 블렌딩 처리 상수 덧셈 처리
두 영상간의 덧셈 처리 영상의 뺄셈 처리 상수 뺄셈 처리 두 영상간의 뺄셈 처리 블렌딩 처리 3장 - 화소값 기반 처리

5 영상의 밝기 조절 영상의 밝기 조절을 어떻게 구현될까? 명암도 영상 256레벨… 전체적으로 밝게 만들기 위해… 고려사항
어떤 특정값을 더해주자. 고려사항 특정값을 더해주면 밝아지고 , 특정값을 빼주면 어두워진다. 특정값을 더하고나 뺄때, 0 이하가 되거나 255이상이 되면…? 산술연산 처리(arithmetic operation) 3장 - 화소값 기반 처리

6 영상의 밝기 조절 산술 연산 처리 화소값 기반 처리 중 하나 두가지 형태의 작업 사칙연산과의 차이 영상의 밝기값 조절
두 영상과의 처리 사칙연산과의 차이 사칙 연산 : +, -, *, / 만 존재함 산술 연산 : 사칙연산, 거듭제곱, 절대값 등 다양한 형태의 연산이 존재함 3장 - 화소값 기반 처리

7 영상의 밝기 조절 덧셈 연산자 각 픽셀에 특정값을 더해주는 처리 특징 식 상수 값을 더해주므로서 밝기 값이 증가함. 앞의 식
화소에 다른 영상의 화소를 더해주는 경우 뒤의 식 화소에 특정 값을 더해주는 경우 3장 - 화소값 기반 처리

8 영상의 밝기 조절 산술연산의 처리 예제 12 20 212 222 199 199 24 222 199 185 185 28 54 183 175 33 232 58 183 35 3장 - 화소값 기반 처리

9 영상의 밝기 조절 산술연산의 처리 예제 덧셈하기 ( + 50점) 12 20 212 222 62 70 262 272 199
24 222 249 249 74 272 +50 199 185 185 28 249 235 235 78 54 183 175 33 104 233 225 83 232 58 183 35 282 108 233 85 3장 - 화소값 기반 처리

10 영상의 밝기 조절 앞의 문제점… 255를 넘어가는 경우는 어떻게 처리해야 할까? 해결점
255를 넘으면 즉 흰색보다 더 흰색이 없으므로… 최대의 흰색(255)를 할당하는 방법 0보다 작으면 즉 검은색보다 더 검은색이 없으므로… 최저의 검은색(0)을 할당하는 방법 255를 넘는 경우 wrapping을 시도함… 256은 다시 0, 257은 1, 258은 2, 259는 3, 260은 4, … 3장 - 화소값 기반 처리

11 영상의 밝기 조절 산술연산의 처리 예제 덧셈하기 ( + 50점) 62 70 255 255 249 249 74 255 +50
clipping 249 235 235 78 104 233 225 83 255 108 233 85 3장 - 화소값 기반 처리

12 픽셀 단위의 산술 연산 입력영상 출력 영상 덧셈 처리한 예제 +40 출력 픽셀의 색상 40 255 입력 픽셀의 색상 255
255 출력 픽셀의 색상 40 입력 픽셀의 색상 255 3장 - 화소값 기반 처리

13 영상의 밝기 조절 산술연산의 처리 예제 덧셈하기 ( + 50점) 62 70 6 16 249 249 74 16 +50
Wrapping 249 235 235 78 104 233 225 83 26 108 233 85 3장 - 화소값 기반 처리

14 영상의 밝기 조절 산술연산의 처리 예제 덧셈하기 ( + 50점) + wrapping 함수의 모양 출력 픽셀의 색상 50 255
255 출력 픽셀의 색상 50 입력 픽셀의 색상 255 3장 - 화소값 기반 처리

15 영상의 밝기 조절 결과 예제 3장 - 화소값 기반 처리

16 영상의 밝기 조절 산술 처리 응용 분야 영상의 상태에 따른 밝기값 조절 어두운 영상의 경우 밝게… 너무 밝은 영상은 어둡게
영상분할 후 특정 영역을 강조하기 위해 특정영역의 명암도 값을 더하거나 빼는 처리 3장 - 화소값 기반 처리

17 영상의 밝기 조절 두 영상간의 가감 연산 앞의 영상의 산술 연산은 상수에 대한 산술연산인데 비해, 두 개의 영상에 대해 산술 연산이 이루어짐 3장 - 화소값 기반 처리

18 영상의 밝기 조절 두 영상간의 덧셈 두 영상간의 뺄셈 덧셈은 두 영상의 병합과 같은 의미 뺄셈은 두 영상의 차이값을 나타냄
두 개의 영상에서 차이가 큰 부분이 밝게 나타남 3장 - 화소값 기반 처리

19 영상의 밝기 조절 산술연산의 처리 예제(영상1) 12 20 212 222 199 199 24 222 199 185 185 28
54 183 175 33 232 58 183 35 3장 - 화소값 기반 처리

20 영상의 밝기 조절 산술연산의 처리 예제(영상2) 255 255 255 255 255 255 255 255 255 255
255 255 255 255 255 255 255 255 255 255 3장 - 화소값 기반 처리

21 영상의 밝기 조절 영상1 + 영상2 (clipping 처리) 12 255 212 255 199 255 24 255 199
185 255 54 255 175 255 232 255 183 255 3장 - 화소값 기반 처리

22 영상의 밝기 조절 영상1 - 영상2 (clipping 처리) 12 212 199 24 199 185 54 175 232 183
212 199 24 199 185 54 175 232 183 3장 - 화소값 기반 처리

23 영상의 밝기 조절 덧셈 처리한 예제 두개의 영상에 대해 덧셈 처리한 예제 특정 부분을 강조해주고자 할 경우에 사용
마스크 영상의 검은색 값이 0이므로 다른 영상의 색상을 그대로 나타냄 마스크 영상의 흰색 흰색으로 나타남 3장 - 화소값 기반 처리

24 영상의 밝기 조절 덧셈 처리한 예제 + = 3장 - 화소값 기반 처리

25 영상의 밝기 조절 두 영상간의 덧셈 3장 - 화소값 기반 처리

26 영상의 밝기 조절 뺄셈 연산자 각 픽셀에 특정값을 빼주는 처리 특징 식
상수 값을 빼주므로서 밝기 값이 감소함.(명암도를 어둡게 함) 식 앞의 식 화소에 다른 영상의 화소를 빼주는 경우 뒤의 식 화소에 특정 값을 빼주는 경우 3장 - 화소값 기반 처리

27 영상의 밝기 조절 입력영상 출력 영상 뺄셈 처리한 예제 -40 출력 픽셀의 색상 255 입력 픽셀의 색상 -40
입력 픽셀의 색상 3장 - 화소값 기반 처리

28 영상의 밝기 조절 뺄셈 연산의 예제 3장 - 화소값 기반 처리

29 영상의 밝기 조절 뺄셈 연산의 예제 - = 3장 - 화소값 기반 처리

30 영상의 밝기 조절 뺄셈 연산의 예제 - = 3장 - 화소값 기반 처리

31 영상의 밝기 조절 두 영상간의 뺄셈 3장 - 화소값 기반 처리

32 영상의 밝기 조절 블렌딩 처리 덧셈연산의 경우 두 영상의 선형 결합(linear convolution)을 통해 두개의 영상이 각각의 가중치에 따라 동시에 보이것이 가능함 가중치를 어떻게 주느냐에 따라 다양한 결과가 나올 수 있는데, 이를 블렌딩(blending)이라 함 블렌딩 연산자 3장 - 화소값 기반 처리

33 영상의 밝기 조절 블렌딩 처리 예제 3장 - 화소값 기반 처리

34 영상의 밝기 조절 두영상의 블렌딩 효과 3장 - 화소값 기반 처리

35 영상의 명암 대비 조절 영상의 명암 대비에 대한 개념 곱셈 처리 나눗셈 처리 밝기 조절과 조합 명암 대비를 넓게 펼쳐주는 역할
명암 대비를 좁게 만들어주는 역할 밝기 조절과 조합 3장 - 화소값 기반 처리

36 영상의 명암 대비 조절 명암 대비(contrast)
영상 내의 밝은 부분과 어두운 부분이 서로 영향을 미쳐서 상이함이 강조되어 지각되는 정도 이 정도는 영상 내 밝거나 어두운 명암값의 분포로 평가됨 명암 대비의 명칭 낮은 명암 대비 영상 내 대부분이 흐리거나 어둡거나 밝다. 즉 밝기값들이 어느 한쪽에 치우쳐 있음 높은 명암 대비 영상 내 어둡고, 밝은 부분이 다 포함된다. 즉 밝기값의 분포가 고르게 분포되어 있음 3장 - 화소값 기반 처리

37 영상의 명암 대비 조절 명암 대비를 높이려면…? 명암 대비를 낮추려면…? 동시 대비
2가지 색을 동시에 보는 경우에 일어나는 대비 효과를 의미함 계시 대비 시간적인 차를 두고 2가지 색을 차례로 볼때의 대비 효과를 의미함 명암 대비를 높이려면…? 곱셈 연산을 수행하기 밝은 부분을 더 밝게 어두운 부분을 조금 밝게 표현함 명암 대비를 낮추려면…? 나눗셈 연산을 수행하기 밝은 부분은 아주 어둡게, 어두운 부분은 조금 어둡게 표현함. 3장 - 화소값 기반 처리

38 영상의 명암 대비 조절 곱셈 및 나눗셈 연산자 각 픽셀에 특정값을 곱해주거나 나누어주는 처리 명암 대비 조절이 가능함 특징 식
상수 값을 곱해주는 경우 영상을 밝게 만들어줌 어두운 부분은 약간 밝게만 만들고 밝은 부분은 더욱 밝게 만들어 영상으로 보다 선명하게 만들어주는 효과 상수 값을 나누어주는 경우 영상을 어둡게 만들어줌 어두운 부분은 조금 어둡게 밝은 부분은 더욱 어둡게 만들어 영상의 대비가 아주 좁아짐 식 3장 - 화소값 기반 처리

39 영상의 명암 대비 조절 입력영상 출력 영상 곱셈 처리한 예제 x 1.2 255 출력 픽셀의 색상 255 입력 픽셀의 색상
255 3장 - 화소값 기반 처리 입력 픽셀의 색상

40 영상의 명암 대비 조절 입력영상 출력 영상 나눗셈 처리한 예제 / 1.2 출력 픽셀의 색상 255 입력 픽셀의 색상
입력 픽셀의 색상 출력 픽셀의 색상 255 3장 - 화소값 기반 처리

41 영상의 명암 대비 조절 곱셈 나눗셈의 예제 3장 - 화소값 기반 처리

42 영상의 명암 대비 조절 결과에 따른 히스토그램 3장 - 화소값 기반 처리

43 영상의 명암 대비 조절 곱셈의 결과 3장 - 화소값 기반 처리

44 영상의 명암 대비 조절 나눗셈의 결과 3장 - 화소값 기반 처리

45 히스토그램 히스토그램 의 개념 히스토그램 평활화 히스토그램 스트레칭 3장 - 화소값 기반 처리

46 히스토그램 처리 히스토그램 처리 영상의 밝기값에 대한 분포를 보여주는 그래프 영상분석을 위한 중요한 도구 히스토그램
영상의 밝기 구성 명암의 대비 등의 정보  영상 개선 및 화질 향상을 위해 사용됨 히스토그램 영상의 밝기값을 수평측으로 하고 수평축의 발기값에 대응되는 크기를 가진 픽셀수가 영상 안에 몇 개나 되는지를 나타내는 빈도수를 수직축으로 해서 만든 그래프 따라서 흑백영상의 경우 수평측은 0~255의 범위값을 가지며, 수직축의 값은 영상의 크기와 밝기의 분포에 따라 달라짐 3장 - 화소값 기반 처리

47 히스토그램 처리 작은 크기의 샘플영상에 대한 히스토그램 모든 색상의 히스토그램 값을 모두 더하면 얼마인가?
3장 - 화소값 기반 처리

48 히스토그램 처리 히스토그램 예제 3장 - 화소값 기반 처리

49 히스토그램 처리 밝기 분포가 다른 영상의 예 3장 - 화소값 기반 처리

50 히스토그램 처리 3장 - 화소값 기반 처리

51 히스토그램 용도 화질 향상 우주공간에서 촬영한 사진 화질 개선용도로 히스토그램 분석법을 사용
여러가지 잡영(image noise)의 영향으로 화질이 나쁨 화질 개선용도로 히스토그램 분석법을 사용 사람이 알아보기 좋은 선명한 화질의 영상으로 변화 사람의 눈이 밝기보다는 대비에 훨씬 민감하다는 특징을 이용 화질 개선 영상의 예제 3장 - 화소값 기반 처리

52 히스토그램 용도 물체 인식 공장 자동화용 영상처리 물체인식
자동화 카메라를 통해 획득된 영상에서 생산공정에 놓여있는 물건의 결함을 검사하거나 형상을 인식하기 위해 사용 잔동화 카메라의 경우 조명 제어가 가능하므로 영상 이치화를 통한 물체 분리에 사용됨 물체인식 히스토그램의 형태를 분석하여 이치화를 수행 이치화란(image Binarization) 픽셀의 밝기값이 0~255사이에 골고루 존재하는 영상을 영상 픽셀의 밝기값을 0 또는 255의 두 값으로 매핑하는 영상처리 3장 - 화소값 기반 처리

53 히스토그램 용도 영상 이치화 예제 이치화 물체 인식 결과 3장 - 화소값 기반 처리

54 히스토그램 용도 물체 인식 동전의 크기를 인식하여 동전을 분류하는 영상처리의 예제 이때 선결 되어야 할 작업
동전을 배경부분과 분리하는 작업이 요구됨 이치화를 사용 앞의 그림은 이치화 값을 80으로 주었을때 나타난 결과 80보다 큰 픽셀은 255로 매핑 80보다 작은 픽셀은 0으로 매핑 이런 이치화 값을 임계치(threshold value)라고 함 컴퓨터 비젼에서의 연구 분야 3장 - 화소값 기반 처리

55 히스토그램 평활화 히스토그램 평활화 (histogram equalization)
기존 영상의 명암 값 분포를 재분배하여 일정한 분포 를 가진 히스토그램을 생성 histogram histogram 평활화의 효과 255 255 입력 픽셀의 색상 입력 픽셀의 색상 3장 - 화소값 기반 처리

56 히스토그램 평활화 히스토그램 평활화의 세 단계 단계 2에서 구한 누적값을 정규화
입력영상의 히스토그램 생성 - 명암값 j 의 빈도수 hist[j] 를 계산 각 명암값 i 에 대하여 0부터 i 까지의 빈도수의 누적 값을 계산 단계 2에서 구한 누적값을 정규화 입력영상에서 픽셀 값 i를 정규화된 값 n[i]로 변환하여 결과 영상 생성 3장 - 화소값 기반 처리

57 히스토그램 평활화 예 원영상 히스토그램 3장 - 화소값 기반 처리

58 히스토그램 평활화 예 평활화된 영상 히스토그램 정규화 3장 - 화소값 기반 처리

59 히스토그램 평활화 적용 예 원영상 결과 영상 3장 - 화소값 기반 처리

60 히스토그램 평활화 영상이 어두운 영역에서 세밀한 부분을 가질때에 효과적 3장 - 화소값 기반 처리

61 히스토그램 평활화 3장 - 화소값 기반 처리

62 히스토그램 히스토그램 평활화 3장 - 화소값 기반 처리

63 히스토그램 스트레칭 히스토그램 스트레칭 명암 대비 효과를 제공함 명암 대비란
영상의 가장 어두운 부분과 밝은 부분의 차이를 나타냄 명암 대비가 낮은 경우 차이값이 크지 않아, 전체적으로 어둡거나 밝게 나타남 명암 대비가 높은 경우 차이값이 크게 나타나고 전체적으로 밝기값이 골고루 나타남 3장 - 화소값 기반 처리

64 히스토그램 스트레칭 낮은 명암 대비 높은 명암 대비 좋은 명암 대비 히스토그램이 일부분에 집중
히스토그램이 두개의 큰 마루를 가짐 좋은 명암 대비 균일한 화소값 분포를 가짐 특정한 마루나 골이 부각되지 않음 3장 - 화소값 기반 처리

65 히스토그램 스트레칭 히스토그램 연산의 비교 펼활화와 스트레칭 평활화 : 히스토그램을 늘리지만, 늘어나는 간격이 다름
스트레칭 : 히스토그램을 늘리기 효과, 늘어나는 간격이 같음 3장 - 화소값 기반 처리

66 히스토그램 스트레칭 히스토그램이 모든 범위의 화소 값을 포함하도록 영상을 확장 중앙에 집중된 히스토그램을 갖는 영상에 적합
min : 최저 화소값, max : 최고 화소값 3장 - 화소값 기반 처리

67 히스토그램 스트레칭 예 원영상 결과 영상 3장 - 화소값 기반 처리

68 히스토그램 히스토그램 스트레칭 3장 - 화소값 기반 처리

69 히스토그램 히스토그램 스트레칭 스트레칭의 문제점 해결 방법 엔드인 탐색 스트레칭 기법이 있음
Low, high 즉 범위 값을 임의로 지정하여 명암 대비 스트레칭을 수행함 3장 - 화소값 기반 처리

70 히스토그램 히스토그램 스트레칭(엔드인 탐색) 3장 - 화소값 기반 처리

71 히스토그램 메모 그외 히스토그램 관련 알고리즘 히스토그램 수축 히스토그램 슬라이딩 히스토그램 명세화
히스토그램 스트레칭 알고리즘과 반대 개념 범위를 지정하여 수축시킴으로서 명암 대비가 감소함 히스토그램 슬라이딩 단순히 히스토그램을 이동시킴 왼쪽으로 이동하면 명암도 레벨이 낮아져 어두운 영상이 생성됨 오른쪽으로 이동하면 명암도 레벨이 높아져 밝은 영상이 생성됨 히스토그램 명세화 원 영상에 우리가 원하는 히스토그램 데이터를 반영하면 새로운 결과 영상을 얻게 됨 3장 - 화소값 기반 처리

72 대수 함수 변환 로그 연산자(Logarithm Operator)
영상의 각 화소 점들에 각각 로그 변환을 취함으로써 영상의 밝기 값을 변화시키는 방법. 각각의 화소 점에 로그 변환을 하는 이유는 인간이 빛(명암도)을 인지하는 정도가 로그 함수를 따라 반응하는 것에 기반을 두고 있다. 로그 변환을 수행하면 명암도가 낮은 영역은 세분화되어 표현되고 높은 영역은 조밀해져서 영상이 전체적으로 밝아지는 효과를 가져온다. 3장 - 화소값 기반 처리

73 대수 함수 변환 로그 연산자 예제 3장 - 화소값 기반 처리

74 대수 함수 변환 로그 연산자 예제 3장 - 화소값 기반 처리

75 명암 변환 명암 변환에 대한 설명 널 변환 역 변환 감마 상관관계 변환 비트 플래너 슬라이싱 변환
비트 플래너 슬라이싱 변환을 이용한 워터마킹 3장 - 화소값 기반 처리

76 명암 변환 명암 변환(Intensity transformation)
미리 지정된 함수 f(x)를 바탕으로 이전 화소값을 새로운 화소값으로 바꿔주는 알고리즘 함수 f(x)가 어떻게 정의되는냐에 따라 영상의 질을 좌우함 함수 f(x)만 정의하면 구현은 매우 쉽다. x는 함수의 처리 전의 입력이고, f(x)는 처리 후의 출력 결과를 의미함 3장 - 화소값 기반 처리

77 명암 변환 널 변환 f(x) = x 아무런 변환이 없는 형태 원 영상과 같은 영상 구현 결과 Pp.269 참고 그림 3.38
255 f(x) : 출력영상 x : 입력 영상 3장 - 화소값 기반 처리

78 명암 변환 역 변환 Negative 연산자 가장 큰 칼라 큰 값에 영상의 포인트 값을 빼주는 연산 연산자 255
출력 픽셀의 색상 255 입력 픽셀의 색상 3장 - 화소값 기반 처리

79 명암 변환 역 변환 3장 - 화소값 기반 처리

80 명암 변환 감마 상관관계 변환 감마 조절 컴퓨터 그래픽 분야에서 많이 사용 출력 영상의 밝기 정도를 전반적으로 조절하는 것
적절하게 조절하지 않으면 영상은 너무 밝거나 너무 어두워 모니터에 출력해도 잘 볼 수 없음 영상을 제대로 재생하려면 감마 조절이 필요함 감마 상관관계 변환 함수 명암도 영상에 적용하기 위해 3장 - 화소값 기반 처리

81 명암 변환 감마 상관관계 함수 255 f(x) : 출력영상 x : 입력 영상 3장 - 화소값 기반 처리

82 명암 변환 감마 상관관계 변환 Gamma = 1/ gamma = 1/1.7 3장 - 화소값 기반 처리

83 명암 변환 비트 플래너 슬라이싱 변환 일반적으로 명암도 레벨은 0~255로 256가지 존재함
처리시간의 부담등으로 레벨을 줄이는 것이 가능함 2레벨, 4레벨, 8레벨, 16레벨 등이 있음 8개의 비트값을 가지고 있어서 전체 영상은 각 비트값으로 구성된 8개의 비트 플래인으로 구성됨 2레벨 2개의 컬러로 표현하는 방법 총 8가지 방법이 존재함 각 특정 비트 하나를 선정하여 그 비트가 0이냐 1이냐를 두고 검은색 및 흰색으로 mapping 하는 방법 3장 - 화소값 기반 처리

84 명암 변환 비트 플래너 슬라이싱 변환(0비트) 12 20 212 222 199 199 24 222 199 185 185 28 54 183 175 33 검은색 232 58 183 35 3장 - 화소값 기반 처리

85 명암 변환 비트 플래너 슬라이싱 변환(7비트) 12 20 212 222 199 199 24 222 199 185 185 28 54 183 175 33 검은색 232 58 183 35 3장 - 화소값 기반 처리

86 명암 변환 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장 - 화소값 기반 처리

87 명암 변환 비트 플래너 슬라이싱 변환 6비트 비트 4비트 비트 3장 - 화소값 기반 처리

88 이진 영상 변환 이진 영상 변환 영상의 화소 값이 임으로 정해진 임계치(Threshold) Th보다 작으면 화소들의 값은 검은색 값으로 바꾸고 큰 값이면 흰색으로 바꾸는 과정 Thresholding 기법의 하나 연산자(이치화 연산과 Thresholding 연산) 첫번째 식은 두가지 영역으로 표현되어 이치화라고 하지만, 두번째 식은 구현에 따라 여러가지 영역으로 표현하는 Thresholding 기법의 하나이다. 3장 - 화소값 기반 처리

89 이진 영상 변환 이치화와 Thresholding의 함수 표현 임계치 임계치 255 입력 픽셀의 색상 출력 픽셀의 색상 255
255 입력 픽셀의 색상 출력 픽셀의 색상 임계치 255 출력 픽셀의 색상 입력 픽셀의 색상 임계치 3장 - 화소값 기반 처리

90 이진 영상 변환 히스토그램 정보를 이용한 물체와 배경의 분리 임계치 임계치 임계치 3장 - 화소값 기반 처리

91 이진 영상 변환 히스토그램을 사용한 이치화 산과 계곡의 분리
동전 영상에서 물체(동전) 영역은 170의 밝기값 근방에 모여 있음 배경은 밝기값 50근처에 모여 있음 이들을 분리하기 위해 적절한 임계치는 100임 적절한 임계치 3장 - 화소값 기반 처리

92 이진 영상 변환 이진 변환(단일 경계값) 255 입력 픽셀의 색상 출력 픽셀의 색상 임계치 3장 - 화소값 기반 처리

93 이진 영상 변환 이진 변환 (threshold value : 128 (중간값)) 3장 - 화소값 기반 처리

94 이진 영상 변환 이진 변환(이중 경계값) 임계치(low) 임계치(high) 출력 픽셀의 색상 255 입력 픽셀의 색상
255 출력 픽셀의 색상 입력 픽셀의 색상 임계치(low) 임계치(high) 3장 - 화소값 기반 처리

95 이진 영상 변환 이진 변환(이중 경계값) 3장 - 화소값 기반 처리

96 이진 영상 변환 이진 변환 (히스토그램 분포 이용) otsu 알고리즘 (분산 최대법 알고리즘)
: 히스토그램을 어떤 경계값으로써 2개 나누었을 경우, 각 영역 사이의 분산이 최대로 되도록 경계값을 정하는 것 경계값 3장 - 화소값 기반 처리

97 이진 영상 변환 이진 변환 (히스토그램 분포 이용) 경계값 : 77 3장 - 화소값 기반 처리

98 이진 영상 변환 이진 변환 (보간적 경계값 설정 방법) 히스토그램으로 모든 화소값의 평균값 계산
평균값보다 더 낮은 화소들의 평균값 구하기 평균값보다 더 높은 화소들의 평균값 구하기 3장 - 화소값 기반 처리

99 이진 영상 변환 이진 변환 (보간적 경계값 설정 방법) 3장 - 화소값 기반 처리

100 논리 변환 논리 변환의 용도 논리 연산자 두 영상간의 상관 관계를 기반으로 객체 존재 파악, 특징 추출 등에 사용됨
산술 연산자와 마찬 가지로 영상간의 비트 연산처리 역시 가능 산술 연산자가 그레이레벨(gray-Level) 영상이나 칼라영상에서 사용될 수 있었던 반면, 0과 1만을 처리할 수 있는 논리 연산자는 일반적으로 바이너리 영상간에만 사용 논리 연산자에는 AND, OR, XOR, NOT 연산자 논리 변환의 용도 두 영상간의 상관 관계를 기반으로 객체 존재 파악, 특징 추출 등에 사용됨 3장 - 화소값 기반 처리

101 논리 변환 논리 연산자 3장 - 화소값 기반 처리

102 논리 변환 논리 연산자의 예제 3장 - 화소값 기반 처리

103 논리 변환 논리 연산자 예제 3장 - 화소값 기반 처리

104 구현하기 밝기 조절 (상수 덧셈 연산) 명암 대비 조절 덧셈 연산 클리핑 함수 두 영상간의 덧셈 상수 뺄셈 연산
밝기 조절 (상수 덧셈 연산) 덧셈 연산 클리핑 함수 두 영상간의 덧셈 상수 뺄셈 연산 두 영상간의 뺄셈 블렌딩 처리(두영상간의 덧셈) 명암 대비 조절 곱셈 연산 나눗셈 연산 3장 - 화소값 기반 처리

105 구현하기 히스토그램을 이용한 명암 대비 조절 함수를 이용한 픽셀 처리 히스토그램 그리기 히스토그램 평활화 히스토그램 스트레칭
대수 함수(로그 함수) 널 함수 역 함수 감마 함수 비트 플레인 처리 2레벨, 4레벨, 8레벨, 16레벨 3장 - 화소값 기반 처리

106 구현하기 이진 영상 변환 논리 연산 단일 경계값을 이용 이중 경계값을 이용 히스토그램을 이용 보간적 경계값 설정을 이용
이진 영상에서의 논리 연산 명암도 영상에서의 논리 연산 3장 - 화소값 기반 처리

107 BYTE. CPixel::GS_add_constant( BYTE
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장 - 화소값 기반 처리

108 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); return retVal; 차례로… 3장 - 화소값 기반 처리

109 // 두 영상간 덧셈을 한다. BYTE. CPixel::GS_add_image(BYTE. gray_image1, BYTE
// 두 영상간 덧셈을 한다. 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장 - 화소값 기반 처리

110 BYTE. CPixel::GS_subtract_constant( BYTE
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장 - 화소값 기반 처리

111 / 두 영상간 뺄셈을 한다. 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장 - 화소값 기반 처리

112 BYTE. CPixel::GS_blending_effect(BYTE. gray_image1, BYTE
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장 - 화소값 기반 처리

113 // 영상에 상수를 곱한다. BYTE. CPixel::GS_multiple_constant( BYTE
// 영상에 상수를 곱한다. 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 > ) { GS_errMsg("constant의 범위는 0.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장 - 화소값 기반 처리

114 // 영상을 상수로 나눈다. BYTE. CPixel::GS_divide_constant( BYTE
// 영상을 상수로 나눈다. 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 > ) { GS_errMsg("constant의 범위는 0.0 ~ 입니다."); 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장 - 화소값 기반 처리

115 // 명암도 영상의 histogram을 생성한다. BYTE. CHist::GS_imhist( int
// 명암도 영상의 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 ]++; } 차례로… 3장 - 화소값 기반 처리

116 tmp_hist_height = max_length; for(i=0; i<256; i++){
// 히스토그램에서 최대 빈도수를 찾는다. 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 { 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장 - 화소값 기반 처리

117 // 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장 - 화소값 기반 처리

118 // STEP 3 : 이웃화소 보간법을 이용하여 128 x 256에 맞게 축소한다. BYTE
// 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장 - 화소값 기반 처리

119 // 메모리 해제 free( histData ); cColor
// 메모리 해제 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장 - 화소값 기반 처리

120 // 히스토그램 평활화 BYTE. CHist::GS_imhisteq( BYTE
// 히스토그램 평활화 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장 - 화소값 기반 처리

121 // 히스토그램을 구한다. 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장 - 화소값 기반 처리

122 // 히스토그램 평활화 과정을 거쳐 새로운 영상을 얻는다
// 히스토그램 평활화 과정을 거쳐 새로운 영상을 얻는다. 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장 - 화소값 기반 처리

123 // 히스토그램 스트레칭 BYTE. CHist::GS_imhist_streching( BYTE
// 히스토그램 스트레칭 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장 - 화소값 기반 처리

124 // 히스토그램을 구한다. 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장 - 화소값 기반 처리

125 // 오른쪽에서 존재하는 index를 찾는다
// 오른쪽에서 존재하는 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_index-smallest_index); newHistData[i] = (int)(tmp2*max_level); 차례로… 3장 - 화소값 기반 처리

126 // 히스토그램 스트레칭 결과를 영상에 담는다
// 히스토그램 스트레칭 결과를 영상에 담는다. 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장 - 화소값 기반 처리

127 // 명암도 영상에 대해 대수함수를 수행한다. BYTE. CPixel::GS_logarithm( BYTE
// 명암도 영상에 대해 대수함수를 수행한다. 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 = / log(1+max_var); double pixel; 차례로… 3장 - 화소값 기반 처리

128 for(i=0; i<height; i++) { for(j=0; j<width; j++) pixel = constant * log( (int)gray_image[i][j] ); result_image[i][j] = (int)pixel; } return result_image; 차례로… 3장 - 화소값 기반 처리

129 // 명암도 영상에 대해 널 변환한다. BYTE. CPixel::GS_null_trans( BYTE
// 명암도 영상에 대해 널 변환한다. 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장 - 화소값 기반 처리

130 // 명암도 영상에 대해 역 변환한다. BYTE. CPixel::GS_inverse_trans( BYTE
// 명암도 영상에 대해 역 변환한다. 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] = gray_image[i][j]; } return result_image; 차례로… 3장 - 화소값 기반 처리

131 // 명암도 영상에 대해 감마 상관관계 변환한다. BYTE. CPixel::GS_gamma_trans( BYTE
// 명암도 영상에 대해 감마 상관관계 변환한다. 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 = * pow( (gray_image[i][j]/255.0), gamma ); result_image[i][j] = GS_clamping( var ); } return result_image; 차례로… 3장 - 화소값 기반 처리

132 // 비트 플래너 슬라이싱 변환, 1 bit만 추출(2 level 영상) BYTE
// 비트 플래너 슬라이싱 변환, 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장 - 화소값 기반 처리

133 result_image[i][j] = (BYTE)var; } return result_image;
차례로… 3장 - 화소값 기반 처리

134 // 비트 플래너 슬라이싱 변환, 2 bit만 추출(4 level 영상) BYTE
// 비트 플래너 슬라이싱 변환, 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장 - 화소값 기반 처리

135 // 비트 플래너 슬라이싱 변환, 8 bit만 추출(16 level 영상) BYTE
// 비트 플래너 슬라이싱 변환, 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장 - 화소값 기반 처리

136 // 단일 경계값을 이용한 이진 영상 변환 BYTE. CPixel::GS_gray2binary_unity( BYTE
// 단일 경계값을 이용한 이진 영상 변환 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장 - 화소값 기반 처리

137 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장 - 화소값 기반 처리

138 // 이중 경계값을 이용한 이진 영상 변환 BYTE. CPixel::GS_gray2binary_dual( BYTE
// 이중 경계값을 이용한 이진 영상 변환 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장 - 화소값 기반 처리

139 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장 - 화소값 기반 처리

140 // 히스토그램의 분포를 이용한 이진 영상 변환 BYTE. CPixel::GS_gray2binary_otsu( BYTE
// 히스토그램의 분포를 이용한 이진 영상 변환 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장 - 화소값 기반 처리

141 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++) { f[i] += j * histPData[j]; double F = f[255]; double t = 0.0; double *sigma = (double *)calloc( 256, sizeof(double) ); 차례로… 3장 - 화소값 기반 처리

142 for(i=0; i<256; i++) { t = histCData[i] - histCData[i]
for(i=0; i<256; i++) { t = histCData[i] - histCData[i]*histCData[i]; if(t == 0) t = ; sigma[i] = ((F*histCData[i] - f[i]) * (F * histCData[i] - f[i])) / t; } double maxSigma = ; 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장 - 화소값 기반 처리

143 // 보간적 경계값 설정을 이용한 이진 영상 변환 BYTE. CPixel::GS_gray2binary_iterate( BYTE
// 보간적 경계값 설정을 이용한 이진 영상 변환 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 ]++; } 차례로… 3장 - 화소값 기반 처리

144 for(i=0; i<256; i++) hist_sum += (histData[i]
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장 - 화소값 기반 처리

145 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장 - 화소값 기반 처리

146 // 이진 영상에서의 논리 연산 - 논리 연산자(logical operator) 사용 BYTE
// 이진 영상에서의 논리 연산 - 논리 연산자(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); 차례로… 3장 - 화소값 기반 처리

147 case 2 : // OR var = (var1 || var2); break; case 3 : // NOR var =
case 2 : // OR var = (var1 || var2); break; case 3 : // NOR var = !(var1 || var2); case 4 : // XOR var = (var1 != var2 ? 1 : 0); case 5 : // XNOR var = (var1 == var2 ? 1 : 0); } result_image[i][j] = (var == 0 ? 1 : 0); } // end for return result_image; 차례로… 3장 - 화소값 기반 처리

148 // 명암도 영상에서의 논리 연산 - 비트 연산자(bitwise operator) 사용 BYTE
// 명암도 영상에서의 논리 연산 - 비트 연산자(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); 차례로… 3장 - 화소값 기반 처리

149 case 2 : // OR var = (var1 | var2); break; case 3 : // NOR var = ~(var1 | var2); case 4 : // XOR var = var1 ^ var2; case 5 : // Difference var = var & (~var2); } // end switch result_image[i][j] = (BYTE)var; } // end for return result_image; } 차례로… 3장 - 화소값 기반 처리

150 레포트 -3- 제공된 클래스를 이용하여 구현하기 제공된 클래스
HIST.CPP, HIST.H PIXEL.CPP, PIXEL.H 제공된 클래스를 이용하여 3장의 메뉴를 만들고 다음의 처리를 메뉴에 추가하여 구현해보라. 명암 밝기 – 상수 덧셈, 상수 뺄셈 명암 대비 – 상수 곱셈, 상수 나눗셈 히스토그램 – 히스토그램 보기, 히스토그램 평활화, 히스토그램 스트레칭 명암 변환 함수 – 로그 함수, 널 함수, 역 함수, 감마 함수, 비트 플레인(2레벨, 8레벨, 16레벨) 이진 변환 – 단일 경계값, 이진 경계값, 히스토그램 방법 논리 함수 - 명암도 논리 연산 3장 - 화소값 기반 처리

151 레포트 -3- 제출일 제출시 주의 사항 이주 후 수업 전날 밤 12시까지 제목 : 레포트3_자신의학과학번이름
이름 : 자신의 이름 파일 첨부를 통해서 올려주세요. 파일 명 : 레포트3_자신의학과학번이름.ZIP 3장 - 화소값 기반 처리