히스토그램을 이용한 영상처리

#include <windows.h>
#include <io.h>        // 저수준 입출력을 위함
#include <fcntl.h>
#include "resource.h"
 
LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
void Image_Info(LPSTR ImageFile, HDC hdc);
void Print_Info(HDC hdc);
void Nomalization();
void Contrast();
void Equalization();
HINSTANCE g_hInst;
LPCTSTR lpszClass = TEXT("Histogram");
 
BYTE ***Image;
BYTE ***Contrast_Image;
BYTE ***Equalization_Image;
enum {RED, GRE, BLU, CEND};
int Histo[CEND][256];
int C_Histo[CEND][256];
int Sum_Histo[CEND][256];
int E_Histo[CEND][256];
int N_Histo[CEND][256];
 
HBITMAP Screen;
int flag=0;
/* 비트맵 파일 정보 저장 변수 */
 
BYTE bfType[2];    // 매직넘버(2byte, BM)
DWORD bfSize;      // 파일 전체 크기(4byte)
WORD Reserved1;    // 예약1(2byte)
WORD Reserved2;    // 예약2(2byte)
DWORD bfOffBits;    // 실질적인 데이터의 시작좌표 offset(4byte)  
 
/* 비트맵 이미지 정보 저장 변수 */
DWORD biSize;      // 헤더 크기(4byte, 최소 40bytes 이상)
int biWidth;    // 이미지 폭(4byte)
int biHeight;    // 이미지 높이(4byte)
WORD biPlanes;    // 현재 지원값 1(2byte)
WORD biBitCount;  // 비트수(2byte, 1,4,8,16,24,32)  
DWORD biCompression;  // 압축타입(4byte, BI_RGB(0))
DWORD biSizeImage;  // 이미지 크기(4byte)
DWORD biXPelsPerMeter;// 미터당 픽셀 수 X축(4byte)
DWORD biYPelsPerMeter;// 미터당 픽셀 수 Y축(4byte)
DWORD biClrUsed;    // 실질적으로 사용될 컬러맵의 엔트리수(4byte)
DWORD biClrImportant;  // 주로 사용되는 컬러수(4byte)
 
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance
           ,LPSTR lpszCmdParam, int nCmdShow)
{
  HWND hWnd;
  MSG Message;
  WNDCLASS WndClass;
  g_hInst = hInstance;
  
  WndClass.cbClsExtra = 0;
  WndClass.cbWndExtra = 0;
  WndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);  
  WndClass.hCursor = LoadCursor(NULL,IDC_ARROW);  
  WndClass.hIcon = LoadIcon(NULL,IDI_APPLICATION);  
  WndClass.hInstance = hInstance;
  WndClass.lpfnWndProc = WndProc;
  WndClass.lpszClassName = lpszClass;
  WndClass.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
  WndClass.style = CS_HREDRAW | CS_VREDRAW;
  RegisterClass(&WndClass);  
  
  
  hWnd = CreateWindow(lpszClass,lpszClass,WS_OVERLAPPEDWINDOW,
    10,10,1200,800,NULL,(HMENU)NULL,hInstance,NULL);
  ShowWindow(hWnd,nCmdShow);  
  
  while(GetMessage(&Message,NULL,0,0)){  
    TranslateMessage(&Message);  
    DispatchMessage(&Message);
  }
  return (int)Message.wParam;
}
 
LRESULT CALLBACK WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{
  HDC hdc;
  HDC MemDC;
  PAINTSTRUCT ps;
  HPEN MyPen;
  HPEN OldPen;
  HBITMAP OldBitmap;
 
  OPENFILENAME OFN;
  TCHAR fileName[255] = "";
  
  switch(iMessage){
  case WM_CREATE:
    return 0;
  
  case WM_COMMAND :
    switch(LOWORD(wParam))
    {
    case ID_FILE_MYOPEN :
      memset(&OFN, 0, sizeof(OPENFILENAME));
      OFN.lStructSize = sizeof(OPENFILENAME);
      OFN.hwndOwner = hWnd;
      OFN.lpstrFilter = TEXT("모든 BMP파일\0*.bmp\0");
      OFN.lpstrFile = fileName;
      OFN.nMaxFile = MAX_PATH;
      if(0 == GetOpenFileName(&OFN))
        return 0;
      hdc = GetDC(hWnd);
      Image_Info(OFN.lpstrFile, hdc);
      ReleaseDC(hWnd, hdc);
 
      InvalidateRect(hWnd,NULL,TRUE);
          
      break;
      
    case ID_FILE_EXIT :
      free(Image);
      DestroyWindow(hWnd);
      break;
    }
    return 0;
 
  case WM_PAINT:
    if(flag){
      hdc = BeginPaint(hWnd,&ps);
      MemDC   = CreateCompatibleDC(hdc);
      OldBitmap  = (HBITMAP)SelectObject(MemDC, Screen);
      BitBlt(hdc, 0, 0, 1200, 800, MemDC, 0, 0, SRCCOPY);
      
      MyPen = CreatePen(PS_SOLID,2,RGB(255,0,0));
      OldPen = (HPEN)SelectObject(hdc,MyPen);
 
      Rectangle(hdc,biWidth+20,30,biWidth+290,350);
      
      SelectObject(hdc, OldPen);
      DeleteObject(MyPen);
 
      /* 비트맵 정보 출력 */
      Print_Info(hdc);
 
      SelectObject(MemDC, OldBitmap);
      DeleteDC(MemDC);
      EndPaint(hWnd,&ps);
    }
    return 0;    
  case WM_DESTROY:
    free(Image);
    PostQuitMessage(0);  
    return 0;
  }
  return(DefWindowProc(hWnd,iMessage,wParam,lParam));
}
 
void Image_Info(LPSTR ImageFile,HDC hdc)
{
  int Imagefd;
  int iCnt;
  int jCnt;
  BYTE data[3];
  int offset = 0;
  BYTE dummy[3];
  HDC MemDC;
  HBITMAP   OldBitmap;
  
  /* 이미지 파일 open */  
  Imagefd=open(ImageFile,O_RDONLY);
 
  /* 색상 정보 읽어서 3차원 배열에 저장하기 */
  lseek(Imagefd,0,SEEK_SET);            // 파일 지시자 처음으로 이동
  read(Imagefd,&bfType,sizeof(WORD));        // 매직넘버
  read(Imagefd,&bfSize,sizeof(DWORD));      // 파일 전체 크기
 
  lseek(Imagefd,10,SEEK_SET);            // 2바이트 크기의 예약 정보 2개 건너 뜀
  read(Imagefd,&bfOffBits,sizeof(DWORD));      // 실질적인 데이터의 시작좌표 offset(4byte)
 
  read(Imagefd,&biSize,sizeof(DWORD));      // 헤더 크기
  read(Imagefd,&biWidth,sizeof(int));        // 이미지 폭
  read(Imagefd,&biHeight,sizeof(int));      // 이미지 높이
  read(Imagefd,&biPlanes,sizeof(WORD));      // 비트플레인 1(2byte)
  read(Imagefd,&biBitCount,sizeof(WORD));      // 비트수(2byte, 1,4,8,16,24,32)
  read(Imagefd,&biCompression,sizeof(DWORD));    // 압축타입(4byte, BI_RGB(0))
  read(Imagefd,&biSizeImage,sizeof(DWORD));    // 이미지 크기(4byte)
  read(Imagefd,&biXPelsPerMeter,sizeof(DWORD));  // 미터당 픽셀 수 X축(4byte)
  read(Imagefd,&biYPelsPerMeter,sizeof(DWORD));  // 미터당 픽셀 수 Y축(4byte)
  read(Imagefd,&biClrUsed,sizeof(DWORD));      // 실질적으로 사용될 컬러맵의 엔트리수(4byte)
  read(Imagefd,&biClrImportant,sizeof(DWORD));  // 주로 사용되는 컬러수(4byte)
  
  Screen  = CreateCompatibleBitmap(hdc, 1200, 800);
  MemDC   = CreateCompatibleDC(hdc);
  OldBitmap  = (HBITMAP)SelectObject(MemDC, Screen);
 
  /* 이미지 사이즈에 맞게 3차원 배열 동적할당 */
  Image = (BYTE***)malloc(biHeight*sizeof(BYTE**));
  Contrast_Image = (BYTE***)malloc(biHeight*sizeof(BYTE**));
  Equalization_Image = (BYTE***)malloc(biHeight*sizeof(BYTE**));
      
    for(iCnt=0;iCnt<biHeight;++iCnt){
        Image[iCnt] = (BYTE**)malloc(biWidth*sizeof(BYTE*));
    Contrast_Image[iCnt] = (BYTE**)malloc(biWidth*sizeof(BYTE*));
    Equalization_Image[iCnt] = (BYTE**)malloc(biWidth*sizeof(BYTE*));
    }    
  
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      Image[iCnt][jCnt] = (BYTE*)malloc(3*sizeof(BYTE));
      Contrast_Image[iCnt][jCnt] = (BYTE*)malloc(3*sizeof(BYTE));
      Equalization_Image[iCnt][jCnt] = (BYTE*)malloc(3*sizeof(BYTE));
    }
  }
 
  /* 히스토 그램 저장 배열 초기화 */
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      Histo[iCnt][jCnt] = 0;
    }
  }
  
  /* 색상 정보 읽어서 3차원 배열에 저장하기 */
  for(iCnt=0;iCnt<biHeight;++iCnt){          // 이미지 사이즈 만큼 루프
    for(jCnt=0;jCnt<biWidth;++jCnt){
      lseek(Imagefd,0,SEEK_CUR);            // 파일 지시자 현재위치로 이동
      read(Imagefd,data,3);          // 해당 픽셀의 색상값 읽기(색상은 BGR순)
      /* 색상 정보 읽기 */
      Image[iCnt][jCnt][0] = data[2];  // 해당 픽셀에서 R값 읽기
      Image[iCnt][jCnt][1] = data[1];  // 해당 픽셀에서 G값 읽기
      Image[iCnt][jCnt][2] = data[0];  // 해당 픽셀에서 B값 읽기
      /* 히스토 그램 카운트 */
      Histo[RED][data[2]]++;      // 해당 색상 카운트      
      Histo[GRE][data[1]]++;      // 해당 색상 카운트
      Histo[BLU][data[0]]++;      // 해당 색상 카운트
    }
    read(Imagefd,dummy,biWidth%4);    // 더미 정보 읽기 
                      // 이미지 폭을 4의 배수로 맞추기 위해 더미가 삽입되어 있음
  }
//  Nomalization();
  Contrast();
  Equalization();
  close(Imagefd);                  // 파일 close
 
  flag = 1;
 
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      SetPixel(MemDC,jCnt+10,iCnt+30,RGB(Image[biHeight-iCnt-1][jCnt][0],Image[biHeight-iCnt-1][jCnt][1],Image[biHeight-iCnt-1][jCnt][2]));
    }
  }
  /* 이진화 이미지 출력 */
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      SetPixel(MemDC,jCnt+10,iCnt+biHeight+70,RGB(Contrast_Image[biHeight-iCnt-1][jCnt][0],Contrast_Image[biHeight-iCnt-1][jCnt][1],Contrast_Image[biHeight-iCnt-1][jCnt][2]));
      SetPixel(MemDC,jCnt+biWidth+30,iCnt+biHeight+70,RGB(Equalization_Image[biHeight-iCnt-1][jCnt][0],Equalization_Image[biHeight-iCnt-1][jCnt][1],Equalization_Image[biHeight-iCnt-1][jCnt][2]));
    }
  }
  /* 히스토 그램 출력 */
  
  for(iCnt=0;iCnt<256;++iCnt){
    for(jCnt=0;jCnt<=N_Histo[RED][iCnt];++jCnt){
      SetPixel(MemDC,biWidth*2+70+iCnt,40+256-jCnt,RGB(255,0,0));
    }
    for(jCnt=0;jCnt<=N_Histo[GRE][iCnt];++jCnt){
      SetPixel(MemDC,biWidth*3+110+iCnt,40+256-jCnt,RGB(0,255,0));
    }
    for(jCnt=0;jCnt<=N_Histo[BLU][iCnt];++jCnt){
      SetPixel(MemDC,biWidth*2+70+iCnt,360+256-jCnt,RGB(0,0,255));
    }
  }
  SelectObject(MemDC, OldBitmap);
  DeleteDC(MemDC);
}
 
void Print_Info(HDC hdc)
{
  TCHAR str[128];
  
  SetTextColor(hdc, RGB(0,0,255));
 
  lstrcpy(str,TEXT("      ─━   원  영상   ━─     "));
  TextOut(hdc, 30,10,str,lstrlen(str));
  lstrcpy(str,TEXT("      ─━ 대비  영상 ━─     "));
  TextOut(hdc, 30,biHeight+40,str,lstrlen(str));
  lstrcpy(str,TEXT("      ─━ 평활화 영상 ━─     "));
  TextOut(hdc, biWidth+50,biHeight+40,str,lstrlen(str));
 
  lstrcpy(str,TEXT("   ─━ 비트맵 해더 정보 ━─  "));
  TextOut(hdc, biWidth+40,40,str,lstrlen(str));
  wsprintf(str,TEXT("[           매직넘버           ] = %c%c"),bfType[0],bfType[1]);
  TextOut(hdc, biWidth+40,60,str,lstrlen(str));
  wsprintf(str,TEXT("[      파일 전체 크기      ] = %d"),bfSize);
  TextOut(hdc, biWidth+40,80,str,lstrlen(str));
  wsprintf(str,TEXT("[  데이터 시작 오프셋  ] = %d"),bfOffBits);
  TextOut(hdc, biWidth+40,100,str,lstrlen(str));
  wsprintf(str,TEXT("[          헤더 크기           ] = %d"),biSize);
  TextOut(hdc, biWidth+40,120,str,lstrlen(str));
  wsprintf(str,TEXT("[           이미지 폭          ] = %d"),biWidth);
  TextOut(hdc, biWidth+40,140,str,lstrlen(str));
  wsprintf(str,TEXT("[        이미지 높이         ] = %d"),biHeight);
  TextOut(hdc, biWidth+40,160,str,lstrlen(str));
  wsprintf(str,TEXT("[      비트 플레인 수      ] = %d"),biPlanes);
  TextOut(hdc, biWidth+40,180,str,lstrlen(str));
  wsprintf(str,TEXT("[      비트맵 비트 수      ] = %d"),biBitCount);
  TextOut(hdc, biWidth+40,200,str,lstrlen(str));
  wsprintf(str,TEXT("[            압축 타입         ] = %d"),biCompression);
  TextOut(hdc, biWidth+40,220,str,lstrlen(str));
  wsprintf(str,TEXT("[         이미지 크기        ] = %d"),biSizeImage);
  TextOut(hdc, biWidth+40,240,str,lstrlen(str));
  wsprintf(str,TEXT("[   x축 미터당 픽셀수   ] = %d"),biXPelsPerMeter);
  TextOut(hdc, biWidth+40,260,str,lstrlen(str));
  wsprintf(str,TEXT("[   y축 미터당 픽셀수   ] = %d"),biYPelsPerMeter);
  TextOut(hdc, biWidth+40,280,str,lstrlen(str));
  wsprintf(str,TEXT("[  컬러맵의 엔트리 수  ] = %d"),biClrUsed);
  TextOut(hdc, biWidth+40,300,str,lstrlen(str));
  wsprintf(str,TEXT("[주로 사용되는 컬러수] = %d"),biClrImportant);
  TextOut(hdc, biWidth+40,320,str,lstrlen(str));
 
  lstrcpy(str,TEXT("      ─━ R색상 히스토 그램 ━─     "));
  TextOut(hdc, biWidth*2+70,10,str,lstrlen(str));
  lstrcpy(str,TEXT("      ─━ G색상 히스토 그램 ━─     "));
  TextOut(hdc, biWidth*3+110,10,str,lstrlen(str));
  lstrcpy(str,TEXT("      ─━ B색상 히스토 그램 ━─     "));
  TextOut(hdc, biWidth*2+70,biHeight+40,str,lstrlen(str));
}
 
/* 히스토 그램 정규화 */
void Nomalization()
{
  int max=0;
  int iCnt;
  int jCnt;
 
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      if(Histo[iCnt][jCnt] > max){
        max = Histo[iCnt][jCnt];
      }
    }
  }
 
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      N_Histo[iCnt][jCnt] = (256*Histo[iCnt][jCnt])/max;
    }
  }
}
 
// 대비
void Contrast()
{
  int iCnt;
  int jCnt;
  int kCnt;
  double Weight = 2;
 
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      for(kCnt=0;kCnt<CEND;++kCnt){
        if((128 + Weight*(Image[iCnt][jCnt][kCnt] - 128)) < 0){
          Contrast_Image[iCnt][jCnt][kCnt] = 0;
        }
        else if((128 + Weight*(Image[iCnt][jCnt][kCnt] - 128)) > 255){
          Contrast_Image[iCnt][jCnt][kCnt] = 255;
        }
        else{
          Contrast_Image[iCnt][jCnt][kCnt] = (BYTE)(128 + Weight*(Image[iCnt][jCnt][kCnt] - 128));
        }
      }
    }
  }
  /* 대비 영상 히스토그램 그리기 */
  /*  
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      for(kCnt=0;kCnt<CEND;++kCnt){
        N_Histo[kCnt][Contrast_Image[iCnt][jCnt][kCnt]]++;
      }
    }
  }
  */
  
}
 
// 평활화
void Equalization()
{
  int sum[3];
  int iCnt;
  int jCnt;
  int kCnt;
 
  /* 배열 초기화 */
  for(iCnt=0;iCnt<CEND;++iCnt){
    sum[iCnt] = 0;
  }
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      Sum_Histo[iCnt][jCnt] = 0;
    }
  }
 
  /* 누적 히스토그램 */
  for(iCnt=0;iCnt<256;++iCnt){
    sum[0] += Histo[0][iCnt];
    sum[1] += Histo[1][iCnt];
    sum[2] += Histo[2][iCnt];
 
    Sum_Histo[0][iCnt] = sum[0];
    Sum_Histo[1][iCnt] = sum[1];
    Sum_Histo[2][iCnt] = sum[2];
  }
 
  /* 평활화 */
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      E_Histo[iCnt][jCnt] = (BYTE)((float)255*Sum_Histo[iCnt][jCnt]/(biHeight*biWidth));    
    }
  }
  
  /* 평활화 거친 히스토그램을 영상으로 복원 */
  for(iCnt=0;iCnt<biHeight;++iCnt){
    for(jCnt=0;jCnt<biWidth;++jCnt){
      for(kCnt=0;kCnt<CEND;++kCnt){
        Equalization_Image[iCnt][jCnt][kCnt] 
          = E_Histo[kCnt][Image[iCnt][jCnt][kCnt]];
      }
    }
  }
 
  /* 평활화 히스토그램 그리기 */
  for(iCnt=0;iCnt<biHeight;++iCnt){          // 이미지 사이즈 만큼 루프
    for(jCnt=0;jCnt<biWidth;++jCnt){
      for(kCnt=0;kCnt<CEND;++kCnt){
        N_Histo[kCnt][Equalization_Image[iCnt][jCnt][kCnt]]++;  // 해당 색상 카운트      
      }
    }
  }
 
  /* 평활화 히스토그램 정규화 */
  int max=0;
  
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      if(N_Histo[iCnt][jCnt] > max){
        max = N_Histo[iCnt][jCnt];
      }
    }
  }
  
  for(iCnt=0;iCnt<CEND;++iCnt){
    for(jCnt=0;jCnt<256;++jCnt){
      N_Histo[iCnt][jCnt] = (256*N_Histo[iCnt][jCnt])/max;
    }
  }
}