- low-level process: both inputs and outputs are images
eg. image preprocessing to reduce noise, contrast enhancement, image sharpening
- mid-level process: inputs generally are images, but its outputs are attributes like edges, contours, identity of objects
eg. segmentation, description of the objects, classification (recognition)
- higher-level process: recognized objects performs the cognitive functions associated with vision
"modern digital computer"
with the introduction by John von Neumann of two key concepts: (1) a memory (2) conditional branching, which are the foundation of a CPU
+
mass storage & display systems
=> digital image processing
> the birth of digital image processing
- space probe
Work on using computer techniques for improving images from a space probe began at the Jet Propulsion Laboratory (Pasadena, California) in 1964 when pictures of the moon transmitted by Ranger 7 were processed by a computer to correct various types of image distortion inherent in the on-board television camera.
- medical diagnosis
Tomography consists of algorithms that use the sensed data to construct an image that represents a "slice" through the object. Motion of the object in a direction perpendicular to the ring of detectors produces a set of such slices, which constitute a three-dimensional rendition of the inside of the object. Tomography was invented independently by Sir Godfrey N. Hounsfield and Professor Allan M. Cormack, who shared the 1979 Nobel Prize in Medicine for their invention.
1절 - 디지털 이미지 프로세싱을 정의하고, 상관 분야인 이미지 분석(Image Analysis)과 컴퓨터 비젼(Computer Vision)과의 영역 구분에 대해 논한다.
디지털 이미지 + 디지털 컴퓨터 => 디지털 이미지 프로세싱
이미지 프로세싱 -> 이미지 분석 -> 컴퓨터 비젼
2절 - 디지털 이미지의 발전 단계를 예시를 통해 짚고, 컴퓨터의 탄생과 현대적 의미의 디지털 컴퓨터에 대한 규정을 소개한다. 디지털 이미지 프로세싱의 발전 역사는 1960년대의 우주 탐사와 의료 진단에서 시작되었다. 이후 (1) 인간의 해석(human interpretation)을 돕는 수단으로서는 생물학, 지리학, 고고학, 고에너지 플라즈마와 전자 현미경 분야의 실험 물리학, 천문학, 핵의학, 법률 집행, 방위 산업 등에서 (2) 기계의 인식(machine perception)을 구현하는 수단으로서는 자동 문자 인식, 제품 조립과 검사 공정을 위한 산업 기계, 군사 정찰, 지문 자동 처리, X선과 혈액 샘플 검사, 기상 예보와 환경 평가를 위한 항공 또는 위성 사진 처리 등에서 광범위하게 응용하고 있다.
3절 - 현재 이미지를 얻는 원천은 주로 전자기 스펙트럼이다. 전자기파는 (1) 다양한 파장의 사인파의 진행이나 (2) 질량 없이 광속으로 움직이는 입자들의 흐름으로 생각할 수 있다. 감마선, X선, 자외선, 가시광/적외선, 마이크로파, 라디오파의 응용 실례들을 예시한다. 다른 원천으로는 음향, 초음파, 전자 빔이 있다.
4절 - 디지털 이미지 프로세싱의 각 단계들을 간략 소개한다. image acquisition, image enhancement, image restoration, color image processing, wavelets (-> image data compression / pyramidal representation), compression, morphological processing, segmentation, (boundary/regional) representation & description (feature selection), recognition
5절 - 이미지 프로세싱 시스템은 센싱, 하드웨어, 범용 컴퓨터, 소프트웨어, 대용량 저장소(short-term/on-line/archival), 프레임 버퍼(줌/스크롤/팬 기능), 이미지 디스플레이(컬러 모니터), 하드카피 장치(레이저 프린터, 필름 카메라, 열감지 장치, 잉크젯 기구, 디지털 매체 등), 네트워킹으로 구성된다.
코드에서 CV_THRESH_OTSU는 CV_THRESH_BINARY | CV_THRESH_OTSU 와 같은 효과.
CV_THRESH_OTSU는 함수의 인자 "threshold"의 초기값과 무관하게 입력 영상에 대해 내부적으로 threshold 값을 구하고 이에 따라 선택된 픽셀들에 max_value 값을 준다.
Rafael Grompone von Gioi, Jérémie Jakubowicz, Jean-Michel Morel, Gregory Randall, LSD: A Fast Line Segment Detector with a False Detection Control, IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 32, no. 4, pp. 722-732, Apr. 2010. doi:10.1109/TPAMI.2008.300
1) 1차 DoG filter 만들기: x방향과 y방향의 local maxima를 찾는다.
swPark_2000rti.pdf 440쪽:
"To find the edge of the grid, a first-order Derivative of Gaussian
(DoG) filter with a kernel h = [-1, -7, -15, 0, 15, 7, 1] is used."
/* Test: feature point extraction in implementing virtual studio
: using Gaussin gradient filter, first-order Derivative of Gaussian (DoG) filter
with a kernel h = [-1, -7, -15, 0, 15, 7, 1]
ref. swPark_2000rti.pdf:440p
2010, lym
camera: Logitech QuickCam Pro 4000
*/
// + non maximum suppression
#include <OpenCV/OpenCV.h>
#include <iostream>s
using namespace std;
// non-maximum suppression (NMS)
void NonMaximumSuppression ( IplImage* image, int kernel, int threshold )
{
for ( int y = 0; y < image->height; y++ )
{
cout << "y = " << y << endl;
for ( int x = 0; x < image->width; x++ )
{
if( x == image->width - 1 ) {
x = x;
}
float intensity = CV_IMAGE_ELEM( image, float, y, x );
if ( intensity > threshold ) {
float neighbor;
int flag = 0;
for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
{
if ( y+ky < 0 || y+ky >= image->height ) { // border check
continue;
}
for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
{
if ( x+kx < 0 || x+kx >= image->width ) { // border check
continue;
}
neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
if ( intensity < neighbor ) {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
flag = 1;
break;
}
}
if ( 1 == flag ) {
break;
}
}
}
else {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
}
}
}
}
int main()
{
IplImage* iplInput = 0; // input image
IplImage* iplGray = 0; // grey image converted from input image
IplImage *iplTemp = 0; // converted image from input image with a change of bit depth
// IplImage* iplDoG = 0; // filtered image by DoG
IplImage* iplDoGx = 0; // filtered image by DoG in x-direction
IplImage* iplDoGy = 0; // filtered image by DoG in y-direction
// initialize capture from a camera
CvCapture* capture = cvCaptureFromCAM(0); // capture from video device #0
int count = 0; // number of grabbed frames
while(1) {
// get video frames from the camera
if ( !cvGrabFrame(capture) ) {
printf("Could not grab a frame\n\7");
exit(0);
}
else {
cvGrabFrame( capture ); // capture a frame
iplInput = cvRetrieveFrame(capture); // retrieve the caputred frame
if(iplInput) {
if(0 == count) {
// create an image header and allocate the image data
/* iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplDoGx = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplDoGy = cvCreateImage(cvGetSize(iplInput), 8, 1);
*/
iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplTemp = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
iplDoGx = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
iplDoGy = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
}
// convert the input color image to gray one
cvCvtColor(iplInput, iplGray, CV_BGR2GRAY); // convert an image from one color space to another
// convert one array to another with optional linear transformation
cvConvert(iplGray, iplTemp);
// increase the frame number
count++;
}
cvShowImage( "input", iplInput );
// convolve an image with the kernel
// void cvFilter2D(const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1)
cvFilter2D( iplTemp, iplDoGx, &DoGx ); // convolve an image with the DoG kernel in x-direction
cvFilter2D( iplTemp, iplDoGy, DoGy ); // convolve an image with the DoG kernel in y-direction
// ref. http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvabs#cvAbsDiffS
cvAbs(iplDoGx, iplDoGx);
cvAbs(iplDoGy, iplDoGy);
Try #1.
-1) 필터링의 결과 이미지의 bit depth를 "8"이 아니라 "IPL_DEPTH_32F"로 바꾼 다음, 음수로 나온 gradient 값을 양수로 바꾸어 준다.
그런데, 입력 영상을 담을 메모리를 별도로 생성하지 않고, 다음과 같이 비디오 프레임 캡처 시 만들어 주므로 인위적으로 설정해 줄 수 없다.
shift – Value added to the scaled source array elements
-2) Non Maximum Suppression (NMS)
이웃 화소들의 세기값을 비교하여 해당 픽셀이 최대값이 아니면 "0"으로 하여 지워 준다
/* Test: feature point extraction in implementing virtual studio
: using Gaussin gradient filter, first-order Derivative of Gaussian (DoG) filter
with a kernel h = [-1, -7, -15, 0, 15, 7, 1]
ref. swPark_2000rti.pdf:440p
2010, lym
camera: Logitech QuickCam Pro 4000
*/
#include <OpenCV/OpenCV.h>
#include <iostream>s
using namespace std;
// non-maximum suppression (NMS)
void NonMaximumSuppression ( IplImage* image, int kernel, int threshold )
{
for ( int y = 0; y < image->height; y++ )
{
cout << "y = " << y << endl;
for ( int x = 0; x < image->width; x++ )
{
if( x == image->width - 1 ) {
x = x;
}
float intensity = CV_IMAGE_ELEM( image, float, y, x );
if ( intensity > threshold ) {
float neighbor;
int flag = 0;
for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
{
if ( y+ky < 0 || y+ky >= image->height ) { // border check
continue;
}
for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
{
if ( x+kx < 0 || x+kx >= image->width ) { // border check
continue;
}
neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
if ( intensity < neighbor ) {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
flag = 1;
break;
}
}
if ( 1 == flag ) {
break;
}
}
}
else {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
}
}
}
}
int main()
{
IplImage* iplInput = 0; // input image
IplImage* iplGray = 0; // grey image converted from input image
IplImage *iplTemp = 0; // converted image from input image with a change of bit depth
// IplImage* iplDoG = 0; // filtered image by DoG
IplImage* iplDoGx = 0; // filtered image by DoG in x-direction
IplImage* iplDoGy = 0; // filtered image by DoG in y-direction
// initialize capture from a camera
CvCapture* capture = cvCaptureFromCAM(0); // capture from video device #0
int count = 0; // number of grabbed frames
while(1) {
// get video frames from the camera
if ( !cvGrabFrame(capture) ) {
printf("Could not grab a frame\n\7");
exit(0);
}
else {
cvGrabFrame( capture ); // capture a frame
iplInput = cvRetrieveFrame(capture); // retrieve the caputred frame
if(iplInput) {
if(0 == count) {
// create an image header and allocate the image data
/* iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplDoGx = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplDoGy = cvCreateImage(cvGetSize(iplInput), 8, 1);
*/
iplGray = cvCreateImage(cvGetSize(iplInput), 8, 1);
iplTemp = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
iplDoGx = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
iplDoGy = cvCreateImage(cvGetSize(iplInput), IPL_DEPTH_32F, 1);
}
// convert the input color image to gray one
cvCvtColor(iplInput, iplGray, CV_BGR2GRAY); // convert an image from one color space to another
// convert one array to another with optional linear transformation
cvConvert(iplGray, iplTemp);
// increase the frame number
count++;
}
cvShowImage( "input", iplInput );
// convolve an image with the kernel
// void cvFilter2D(const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1)
cvFilter2D( iplTemp, iplDoGx, &DoGx ); // convolve an image with the DoG kernel in x-direction
cvFilter2D( iplTemp, iplDoGy, DoGy ); // convolve an image with the DoG kernel in y-direction
// ref. http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvabs#cvAbsDiffS
cvAbs(iplDoGx, iplDoGx);
cvAbs(iplDoGy, iplDoGy);
/* Test: feature point extraction in implementing virtual studio
: using Gaussin gradient filter, first-order Derivative of Gaussian (DoG) filter
with a kernel h = [-1, -7, -15, 0, 15, 7, 1]
ref. swPark_2000rti.pdf:440p
camera: Logitech QuickCam Pro 4000
2010, lym & kyu
*/
// + non maximum suppression
#include <OpenCV/OpenCV.h>
#include <iostream>
using namespace std;
// non-maximum suppression (NMS)
void nonMaximumSuppression ( IplImage* image, int kernel, int threshold )
{
for ( int y = 0; y < image->height; y++ )
{
// cout << "y = " << y << endl;
for ( int x = 0; x < image->width; x++ )
{
float intensity = CV_IMAGE_ELEM( image, float, y, x );
if ( intensity > threshold ) {
float neighbor;
int flag = 0;
for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
{
if ( y+ky < 0 || y+ky >= image->height ) { // border check
continue;
}
for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
{
if ( x+kx < 0 || x+kx >= image->width ) { // border check
continue;
}
neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
if ( intensity < neighbor ) {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
flag = 1;
break;
}
}
if ( 1 == flag ) {
break;
}
}
}
else {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
}
}
}
}
// non-maximum suppression (NMS)
void nonMaximumSuppression2 ( IplImage* image, IplImage* image2, int kernel)
{
float neighbor, neighbor2;
for ( int y = 0; y < image->height; y++ )
{
// cout << "y = " << y << endl;
for ( int x = 0; x < image->width; x++ )
{
float intensity = CV_IMAGE_ELEM( image, float, y, x );
// if ( intensity > threshold ) {
if (intensity > 0) {
int flag = 0;
for ( int ky = -kernel; ky <= kernel; ky++ ) // in y-direction
{
if ( y+ky < 0 || y+ky >= image->height ) { // border check
continue;
}
for ( int kx = -kernel; kx <= kernel; kx++ ) // in x-direction
{
if ( x+kx < 0 || x+kx >= image->width ) { // border check
continue;
}
neighbor = CV_IMAGE_ELEM( image, float, y+ky, x+kx );
neighbor2 = CV_IMAGE_ELEM( image2, float, y+ky, x+kx );
// if ( intensity < neighbor ) {
if ( intensity < neighbor || intensity < neighbor2) {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
flag = 1;
break;
}
}
if ( 1 == flag ) {
break;
}
}
}
else {
CV_IMAGE_ELEM( image, float, y, x ) = 0.0;
}
}
}
}
// in the gradient direction
void selectEdges( IplImage* image1, IplImage* image2 )
{
for ( int y = 0; y < image1->height; y++ )
{
// cout << "y = " << y << endl;
for ( int x = 0; x < image1->width; x++ )
{
if( x == image1->width - 1 ) {
x = x;
}
float intensity1 = CV_IMAGE_ELEM( image1, float, y, x );
if ( intensity1 > 0.0 ) { // if the pixel is a edge point surviving NMS
float intensity2 = CV_IMAGE_ELEM( image2, float, y, x );
// compare it with the gradient value in the other direction
if ( intensity1 < intensity2 ) {
CV_IMAGE_ELEM( image1, float, y, x ) = 0.0;
}
}
}
}
}
int main()
{
IplImage* iplInput = 0; // input image
IplImage* iplGray = 0; // grey image converted from input image
IplImage *iplTemp = 0; // converted image from input image with a change of bit depth
// IplImage* iplDoG = 0; // filtered image by DoG
IplImage* iplDoGx = 0, *iplDoGxClone; // filtered image by DoG in x-direction
IplImage* iplDoGy = 0, *iplDoGyClone; // filtered image by DoG in y-direction
// initialize capture from a camera
CvCapture* capture = cvCaptureFromCAM(0); // capture from video device #0
int count = 0; // number of grabbed frames
while(1) {
// get video frames from the camera
// if (0) {
if ( !cvGrabFrame(capture) ) {
printf("Could not grab a frame\n\7");
exit(0);
}
else {
cvGrabFrame( capture ); // capture a frame
iplInput = cvRetrieveFrame(capture); // retrieve the caputred frame
// iplInput = cvLoadImage("P:/input.bmp"); // retrieve the caputred frame
}
// convert the input color image to gray one
cvCvtColor(iplInput, iplGray, CV_BGR2GRAY); // convert an image from one color space to another
// convert one array to another with optional linear transformation
cvConvert(iplGray, iplTemp);
// increase the frame number
count++;
}
cvShowImage( "input", iplInput );
// convolve an image with the kernel
// void cvFilter2D(const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1)
cvFilter2D( iplTemp, iplDoGx, &DoGx ); // convolve an image with the DoG kernel in x-direction
cvFilter2D( iplTemp, iplDoGy, DoGy ); // convolve an image with the DoG kernel in y-direction
// ref. http://opencv.willowgarage.com/documentation/operations_on_arrays.html?highlight=cvabs#cvAbsDiffS
cvAbs(iplDoGx, iplDoGx); cvAbs(iplDoGy, iplDoGy);
Albedo http://en.wikipedia.org/wiki/Albedo
In general, the albedo depends on the direction and directional distribution of incoming radiation. Exceptions are Lambertian surfaces, which scatter radiation in all directions in a cosine function, so their albedo does not depend on the incoming distribution.
typedef struct _IplImage
{
int nSize; /* sizeof(IplImage) */
int ID; /* version (=0)*/
int nChannels; /* Most of OpenCV functions support 1,2,3 or 4 channels */
int alphaChannel; /* Ignored by OpenCV */
int depth; /* Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,
IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported. */
char colorModel[4]; /* Ignored by OpenCV */
char channelSeq[4]; /* ditto */
int dataOrder; /* 0 - interleaved color channels, 1 - separate color channels.
cvCreateImage can only create interleaved images */
int origin; /* 0 - top-left origin,
1 - bottom-left origin (Windows bitmaps style). */
int align; /* Alignment of image rows (4 or 8).
OpenCV ignores it and uses widthStep instead. */
int width; /* Image width in pixels. */
int height; /* Image height in pixels. */
struct _IplROI *roi; /* Image ROI. If NULL, the whole image is selected. */
struct _IplImage *maskROI; /* Must be NULL. */
void *imageId; /* " " */
struct _IplTileInfo *tileInfo; /* " " */
int imageSize; /* Image data size in bytes
(==image->height*image->widthStep
in case of interleaved data)*/
char *imageData; /* Pointer to aligned image data. */
int widthStep; /* Size of aligned image row in bytes. */
int BorderMode[4]; /* Ignored by OpenCV. */
int BorderConst[4]; /* Ditto. */
char *imageDataOrigin; /* Pointer to very origin of image data
(not necessarily aligned) -
needed for correct deallocation */
}
IplImage;
The domain of a given function is the set of "input" values for which the function is defined.
The range of a function is the set of all "output" values produced by that function.
Quality of a digital image
1. spatial resolution
2. spectral resolution
3. radiometric resolution
4. time resolution
Images f(x,y)
: deterministic functions / realizations of stochastic processes
linear system theory
integral transforms
discrete mathematics
theory of stochastic processes
A 'well-behaved' image function f(x,y) is integrable, has an invertible Fourier transform, etc.
2.2 Image digitization
sampled - a matrix with M rows and N columns
quantization - K interval (an integer value)
Image quantization assigns to each continuous sample an integer value - the continuous range of the image function f(x,y) is split into K intervals.
2.2.1 Sampling
Shannon's theorem (->3.2.5)
http://en.wikipedia.org/wiki/Shannon%27s_theorem
In information theory, the noisy-channel coding theorem establishes that however contaminated with noise interference a communication channel may be, it is possible to communicate digital data (information) nearly error-free up to a given maximum rate through the channel. This surprising result, sometimes called the fundamental theorem of information theory, or just Shannon's theorem, was first presented by Claude Shannon in 1948.The Shannon limit or Shannon capacity of a communications channel is the theoretical maximum information transfer rate of the channel, for a particular noise level.
The pixel captured by a real digitization device has finite size, since the sampling function is not a collection of ideal Dirac impulses but a collection of limited impulses.
-> 3.2.5
2.2.2 Quantization
Quantization is the transition between continuous values of the image function (brightness) and its digital equivalent.
The number of brightness of displays normally provide a range of at least 100 intensity levels.
average local brightness => gray-scale transformation techniques
(-> 5.1.2)
2.3 Digital image properties
17p 2.3.1 Metric and topological properties of digital images
region
: a connected set (in a set theory)
: a set of pixels in which there is a path between any pair of its pixels, all of whose pixels also belong to the set
: a set of pixels in which each pair of pixels is contiguous
object (image data interpretation: segmentation)
hole
: points which do not belong to the object and are surrounded by the object
background
The relation 'to be contiguous' decomposes an image into individual regions.
19p
contiguity paradox
paradoxes of crossing lines
connectivity problems
V. Kovalevsky
University of Applied Sciences Berlin http://www.kovalevsky.de/; kovalev@tfh-berlin.de
Abstract. The paper presents some algorithms in digital geometry based on the
topology of cell complexes. The paper contains an axiomatic justification of the
necessity of using cell complexes in digital geometry. Algorithms for solving
the following problems are presented: tracing of curves and surfaces,
recognition of digital straight line segments (DSS), segmentation of digital
curves into longest DSS, recognition of digital plane segments, computing the
curvature of digital curves, filling of interiors of n-dimensional regions
(n=2,3,4), labeling of components (n=2,3), computing of skeletons (n=2, 3).
> applications of the distance transformation
discrete geometry
path planning and obstacle avoidance in mobile robotics
finding the closest feature in the image
skeletonization (mathematical morphology methods)
21p
edge
: a local property of a pixel and its immediate neighborhood
The edge tells us how fast the image intensity varies in a small neighborhood of a pixel.
The gradient of the image function is used to compute edges.
The edge direction is perpendicular to the gradient direction which points in the direction of the fastest image function growth.
crack edge
22p
border (boundary)
: the set of pixels within the region that have one or more neighbors outside
: inner/outer
The border is a global concept related to a region, while edge expresses local properties of an image function.
23p
convex
: If any two points within a region are connected by a straight line segment, and the whole line lies within the region, then this region is convex.
convex hull
: the smallest convex region containing the input region
deficit of convexity - lakes & bays
topology
topological invariant = topological invariant http://en.wikipedia.org/wiki/Topological_property
a property of a topological space which is invariant under homeomorphisms. That is, a property of spaces is a topological property if whenever a space X possesses that property every space homeomorphic to X possesses that property. Informally, a topological property is a property of the space that can be expressed using open sets.
homeomorphism = topological isomorphism http://en.wikipedia.org/wiki/Homeomorphism
the mappings which preserve all the topological properties of a given space. Two spaces with a homeomorphism between them are called homeomorphic, and from a topological viewpoint they are the same.
rubber sheet transform:
Stretching does not change contiguity of the object parts and does not change the number of holes in regions.
brightness histogram
: the freqency of the brightness value in the image
The histogram is usually the only global information about the image which is available.
> applications of histogram
finding optimal illumination conditions for capturing an image
gray-scale transformations
image segmentation to objects and background
A change of the object position on a constant background does not affect the histogram.
> local smoothing of the histogram
(1) local averaging of neighboring histogram elements + boundary adjustment
(2) Gaussian blurring: 1-d simplification of the 2-d Gaussian blur
25p
2.3.3 Entropy
information entropy : the amount of uncertainty about an event associated with a given probability distribution
As the level of disorder rises, entropy increases and events are less predictable.
The uncertainty for such set of outcomes is defined by
since the probability of each event is 1 / n, we can write
The average uncertainty , with being the average operator, is obtained by
gray-level histogram -> probability density p(x_k) -> entropy
Shannon's source coding theorem shows that, in the limit, the average length of the shortest possible representation to encode the messages in a given alphabet is their entropy divided by the logarithm of the number of symbols in the target alphabet.
C.E. Shannon, "A Mathematical Theory of Communication",
parameter optimization
correlation between images
resolution of small or proximate objects in the image
measures of image similarity (retrieval from image databases)
사진을 찍으면 edges만을 살려 크로키 느낌을 주는 앱
nobuyukiOtsu_1979smc.pdf
outcomes is defined by
, with 
being the average operator, is obtained by
