mfc-imageProcessing 을 훑어보자~!

 

mfc 로 프로젝트를 생성하면 다음과 같은 소스파일이 생성된다.

• ImageProcessing.cpp
• ImageProcessingDoc.cpp
• ImageProcessingView.cpp
• FileView.cpp
• MainFrm.cpp …

이중에서 가장 중요한 소스는 위부터 3개다. 위 3개에 나머지 소스가 종속되어있다고 보면 된다.

ImagaProcessing.cpp 은 전체적인 흐름을 담당하고 ImageProcessingDoc.cpp 은 메뉴, 문서 등을 담당하며 ImageProcessingView.cpp 은 이미지가 보이는 화면을 담당한다.

먼저 ImageProcessingView.h를 보자 ImageProcessingView.cpp 에서 정의할 클래스의 변수, 메서드를 볼 수 있다.

 

class CImageProcessingView : public CView { ... }

class 선언으로 class를 만들 수 있다. ‘:’ 는 CView를 상속받는다는 의미다.

class CImageProcessingView : public CView
{
protected:
    CImageProcessingView();
    DECLARE_DYNCREATE(CImageProcessingView);

private:
    ...

public:
    ...
}

protected, private, public 등의 접근 제한자로 상황에 알맞은 변수, 함수를 선언할 수 있다.

질문 : protected 안에 CImageProcessingView()는 무엇일까??

CImageProcessingView::CImageProcessingView()
{
    m_ImgWidth = 0;
    m_ImgHeight = 0;
    m_Image = nullptr;
}

CImageProcessingView::~CImageProcessingView()
{
    if(m_Image)
        delete[] m_Image;
}

클래스와 이름이 같고 함수의 반환형이 표시되지 않은 함수는 생성자이다. 생성자 앞에 ~ 표시가 있으면 소멸자이다.

void CImageProcessingView::OnDraw(CDC* pDC)
{
    CImageProcessingDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    if(!pDoc)
        return;

    // TODO: 여기에 원시 데이터에 대한 그리기 코드를 추가합니다.
    if(m_Image)
    {
        CDC MemDC;
        BITMAP bmpInfo;

        // 화면 DC와 호환되는 메모리 DC를 생성
        MemDC.CreateCompatibleDC(pDC);

        // 비트맵 리소스 로딩
        CBitmap cBitmap;
        cBitmap.CreateBitmap(m_ImgWidth, m_ImgHeight, 1, 32, m_Image);
        CBitmap* pOldBmp = NULL;

        // 로딩된 비트맵 정보 확인
        cBitmap.GetBitmap(&bmpInfo);
        // 정보 출력
        printf("view image width %d, height %d\n",bmpInfo.bmWidth,bmpInfo.bmHeight);

        // 메모리 DC에 선택
        pOldBmp = MemDC.SelectObject(&cBitmap);

        // 메모리 DC에 들어 있는 비트맵을 화면 DC로 복사하여 출력
        pDC->BitBlt(0,0,bmpInfo.bmWidth, bmpInfo.bmHeihgt, &MemDC, 0, 0, SRCCOPY);
    }
}

위의 코드는 화면에 그리기 위한 필요코드이다.

이미지 파일을 불러와 화면에 띄우는 과정은 다음과 같다.

• Doc 에서 View의 함수에 접근하여 띄운다.
• Doc 에서 넘겨받은 정보로 이미지 정보를 셋팅한다.
• 화면에 이미지를 그린다.

화면에 그림을 그리기 위해 데이터를 셋팅하는 로직을 봐보자.

// 먼저 ImageProcessingView.h 에 함수를 선언한다.
public:
    void SetDrawImage(unsigned char* image, const int width, const int height, const int byte);

// 이미지 배열, 사이즈, 한 픽셀에 몇 바이트인지 받는다.
// ImageProcessingView.cpp 에 함수를 정의한다.
void CImageProcessingView::SetDrawImage(unsigned char* image, const int width, const int height, const int byte)
{
    if(byte <= 0) return;

    // 이미지의 사이즈로 그림을 그린다.
    m_ImageWidth = width;
    m_ImageHeight = height;

    // 이미 그려진 이미지가 있다면 지운다.
    if(m_Image)
        delete[] m_Image;

    // 이미지를 그리기 위한 새로운 메모리를 할당한다.
    // mfc 는 1픽셀당 4바이트가 있으므로 다음과 같이 할당.
    m_Image = new unsigned char[width * height * 4];

    // 그리려는 이미지의 픽셀당 바이트 수에 따라
    // 알맞게 할당해준다.
    if(byte > 1)
    {
        // image는 width*height 만큼의 픽셀이고
        // 1픽셀은 byte 만큼을 가진다.
        for(int i=0; i<width*height; i++)
        {
            m_Image[i*4+0] = image[i*byte+0];
            m_Image[i*4+1] = image[i*byte+1];
            m_Image[i*4+2] = image[i*byte+2];
        }
    }
    else
    {
        // 흑백 image는 1픽셀에 1byte이다.
        for(int i=0; i< width*height; i++)
        {
            m_Image[i*4+0] = image[i];
            m_Image[i*4+1] = image[i];
            m_Image[i*4+2] = image[i];
        }
    }
}

Doc에서 파일을 읽어와 image 정보 셋팅 함수에 인자를 전달하는 함수를 살펴보자

bool CImageProcessingView::ReadImageFile(CString filename,
    unsigned char*& output, int& width, int& height, int& byte)
{
    // CBitmap 구조체가 하는 일은 무엇?
    // LoadImage() 가 하는 역할은 무엇?
    CBitmap Bitmap;
    Bitmap.m_hObject = 
        (HBITMAP)::LoadImage(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
    
    if(!Bitmap.m_hObject) return false;

    // BITMAP 구조체가 하는 일은 무엇?
    BITMAP bm;
    Bitmap.GetBitmap(&bm);

    // DWORD 구조체의 역할은 무엇?
    DWORD dwCount = bm.bmWidthBytes*bm.bmHeight;

    // 메모리 할당
    output = new unsigend char[dwCount];

    //GetBitmapBits() 가 하는 역할은? output 공간에 dwCount 만큼 bitmap을 생성
    DWORD dwRead = Bitmap.GetBitmapBits(dwCount, output);

    // output의 그림을 컴퓨터 화면에 띄우기 위해 세팅한다.
    // bmBitsPixel / 8 이유는? byte 가 아니라 bit로 표시돼서.
    SetDrawImage(output, bm.bmWidth, bm.bmHeight, bm.bmBitsPixel/8);

    // 밖으로 빼낼 정보를 세팅한다.
    width = bm.bmWidth;
    height = bm.bmHeight;
    byte = bm.bmBitsPixel / 8;
}

지금까지 이미지를 띄우는 윈도우를 만들어서 화면에 띄우기 위한 셋팅을 살펴보았다. 이제 윈도우에서 파일을 열어서 해당 사진을 화면에 뿌려주는 기능을 구현해보자. 먼저 클래스 및 구조체를 헤더파일에 정의하자.

# include "ImageProc.h" // 여기에 있는 함수를 사용할 것.
# include <vector> // vector 를 사용하여 배열을 선언할 것.

// 배열에 저장할 IMAGE 구조체를 정의한다.
struct IMAGE
{
    unsigned char* image;
    int width;
    int height;
    int pixel_byte;

    IMAGE(void)
    {
        image= nullptr;
        width = 0;
        height = 0;
        pixel_byre = 0;
    }

    IMAGE(unsigned char* _image, int _width, int _height, int _pixel_byte)
    {
        image= _image;
        width = _width;
        height = _height;
        pixel_byre = _pixel_byte;
    }
}

class CImageProcessingDoc : public CDocument
{
    protected:
        CImageProcessingDoc();
        DECLARE_DYNCREATE(CImageProcessingDoc)
    
    private:
        vector<IMAGE> m_Images; // IMAGE를 담을 배열을 선언한다.
        int cur_index; // 현재 인덱스를 저장할 변수를 선언한다.

    // 재정의
    public:
        virtual BOOL OnNewDocument();
        virtual void Serialize(CArchive& ar); 
        ...

    public:
        virtual ~CImageProcessingDoc();
        ...
    
    // 이벤트처리기 선언
    public:
        afx_msg void OnFileOpen();
    
}
// 파일 열기에 아래의 이벤트를 달아준다.
void CImageProcessingDoc::onFileOpen()
{
  char szFilter[] = "Image (*.BMP, *.JPG, *.PNG) | *.BMP;*.JPG;*.PNG | All Files(*.*)|*.*||";

  // fileOpen dialog 를 띄운다.
  CFileDialog dlg(TRUE, NULL, NULL, OFN_HIDERANDONLY, szFilter);

  if(IDOK == dlg.DoModal())
  {   
      // 파일의 경로를 읽어오기
      CString strPathName = dlg.GetPathName();

      // Doc 에서 View의 포인터 얻어오기
      CImageProcessingView* pView = (CImageProcessingView*)((CMainFrame*)
      (AfxGetApp()->m_pMainWnd)) -> GetActiveView();

      unsigned char* image = nullptr;
      int width=0, height=0, byte=0;

      if(pView->ReadImageFile(strPathName, image, width, height, byte))
      {
          printf("open success\n");

          // open 이 성공적으로 되면..
          // image를 배열에 저장한다.

          IMAGE image_info = IMAGE(image, width, height, byte);
          m_Images.push_back(image_info);

          // index는 배열의 사이즈 -1 로 구했다. 
          cur_index = static_cast<int>(m_Images.size() -1 );

          // View pointer를 얻는다.
          CImageProcessingView* pView = (CImageProcessingView*)((CMainFrame*)(AfxGetApp()->m_pMainWnd))->GetActiveView();

          // 화면상에 현재 불러온 이미지를 그려준다.
          pView->SetDrawImage(image, m_Images[cur_index].width, m_Images[cur_index].height);
          // update를 해줘야 다시 그려준다.
          pView->OnInitialUpdate();
      }
      else
          printf("open fail\n");

	}
}