[Intel] 엣지 AI SW 아카데미 38일차 (부산상공회의소 인력개발원)

일정: 2023.12.20(수)

 

수업 내용: 

 

 - Image Processing

 

목표: 

Visaul Studio 2013 를 활용한 MFC 사용법, 영상 처리에 대해서 알 수 있다.

 

1. Visual Studio 2013 프로젝트 생성방법

Visual Studio 2013 프로젝트 생성방법

 

2. OnOpenDocument 함수를 이용한 파일(영상) 입력

OnOpenDocument 함수를 이용한 파일(영상) 입력

 

3. OnSaveDocument 함수를 이용한 파일 출력

 

OnSaveDocument 함수를 이용한 파일 출력

 

4. MFC를 이용한 영상 축소

MFC를 이용한 영상 축소

 

5. MFC를 이용한 영상 확대

MFC를 이용한 영상 확대

 

6. MFC를 이용한 영상 양자화 [Quantization

MFC를 이용한 영상 양자화 [Quantization

 

//CImageProcessingDoc 클래스에서, OnOpenDocument 함수
BOOL CImageProcessingDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
if (!CDocument::OnOpenDocument(lpszPathName))
return FALSE;
// TODO:
return TRUE;
}

//소스파일 ImageProcessingDoc.cpp 의 144line 에서, OnOpenDocument 함수 재정의
BOOL CImageProcessingDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
	if (!CDocument::OnOpenDocument(lpszPathName))
    	return FALSE;
    
    CFile File; // 파일 객체 선언
    
    File.Open(lpszPathName, CFile::modeRead | CFile::typeBinary); 
    // 파일 열기 대화상자에서 선택한 파일을 지정하고 읽기 모드 선택
    
    // 이 책에서는 영상의 크기 256*256, 512*512, 640*480만을 사용한다.
    if (File.GetLength() == 256 * 256){ // RAW 파일의 크기 결정
    	m_height = 256; m_width = 256;
    }
    else if (File.GetLength() == 512 * 512){ // RAW 파일의 크기 결정
    	m_height = 512; m_width = 512;
    }
    else if (File.GetLength() == 640 * 480){ // RAW 파일의 크기 결정
    	m_height = 480; m_width = 640;
    }
    else{
        AfxMessageBox(_T("Not Support Image Size"));
        return 0;
    }
    m_size = m_width * m_height; // 영상의 크기 계산
    m_InputImage = new unsigned char[m_size]; // 입력 영상의 크기에 맞는 메모리 할당
    
    for (int i = 0; i<m_size; i++)
    	m_InputImage[i] = 255; // 초기화
    
    File.Read(m_InputImage, m_size); // 입력 영상 파일 읽기
    File.Close(); // 파일 닫기
    
    return TRUE;
}

//CImageProcessingView 클래스로 이동, OnDraw 함수를 재정의하여 영상 데이터를 출력
void CImageProcessingView::OnDraw(CDC* pDC)
{
    CImageProcessingDoc* pDoc = GetDocument(); // 도큐먼트 클래스 참조
    ASSERT_VALID(pDoc); // debugging 내용을 assert_valid에 저장하고 assert_valid 호출
    
    int i, j;
    unsigned char R, G, B;
    
    for(i=0 ; i<pDoc->m_height ; i++){
    	for(j=0 ; j<pDoc->m_width ; j++){
    		R = G = B = pDoc->m_InputImage[i*pDoc->m_width+j];
    		pDC->SetPixel(j+5, i+5, RGB(R, G, B));
    	}
    }
}

//OnSaveDocument 함수를 재정의
	: [클래스 마법사] 에서 OnSaveDocument
{
    CFile File; // 파일 객체 선언
    CFileDialog SaveDlg(FALSE, TEXT("raw"), NULL, OFN_HIDEREADONLY);
    // raw 파일을 다른 이름으로 저장하기를 위한 대화상자 객체 선언
    if(SaveDlg.DoModal() == IDOK){
        // DoModal 멤버 함수에서 저장하기 수행. IDOK 확인 또는 OK 버튼을 클릭했을 때 처리
        File.Open(SaveDlg.GetPathName(), CFile::modeCreate | CFile::modeWrite); // 파일 열기
        File.Write(m_InputImage, m_size); // 파일 쓰기
        File.Close(); // 파일 닫기
    }
    return TRUE;
}

// 다운 샘플링이 발생하도록 프로그램 작성(1)
	: 소스파일 ImageProcessingDoc.cpp 의 207 line 에서 OnDownSampling 함수 작성
void CImageProcessingDoc::OnDownSampling()
{
    int i, j;
    CDownSampleDlg dlg;
    if(dlg.DoModal() == IDOK) // 대화상자의 활성화 여부
    {
        m_Re_height = m_height / dlg.m_DownSampleRate; // 축소 영상의 세로 길이를 계산
        m_Re_width = m_width / dlg.m_DownSampleRate; // 축소 영상의 가로 길이를 계산
        m_Re_size = m_Re_height * m_Re_width; // 축소 영상의 크기를 계산
        
        m_OutputImage = new unsigned char [m_Re_size]; // 축소 영상을 위한 메모리 할당
        
        for(i=0 ; i<m_Re_height ; i++){ // 축소 영상을 생성
            for(j=0 ; j<m_Re_width ; j++){
                m_OutputImage[i*m_Re_width + j]
                	= m_InputImage[(i*dlg.m_DownSampleRate*m_width)+dlg.m_DownSampleRate*j];
            }
        }
    }
}

// 다운 샘플링이 발생하도록 프로그램 작성(3)
	: 클래스 뷰 CImageProcessingView 에서 OnDownSampling 함수 작성

void CImageProcessingView::OnDownSampling()
{
    CImageProcessingDoc* pDoc = GetDocument(); // Doc 클래스 참조
    ASSERT_VALID(pDoc);
    
    pDoc->OnDownSampling(); // Doc 클래스에 OnDownSampling 함수 호출
    
    Invalidate(TRUE); // 화면 갱신
}

// 처리된 결과를 화면에 표시하기 위해 OnDraw 함수를 재정의
	: 클래스 뷰 CImageProcessingView 에서 OnDraw 함수 재정의 작성
void CImageProcessingView::OnDraw(CDC* pDC)
{
    CImageProcessingDoc* pDoc = GetDocument(); // Doc 클래스 참조
    ASSERT_VALID(pDoc);
    
    int i, j;
    unsigned char R, G, B;
    
    for(i = 0 ; i<pDoc->m_height ; i++){ // 입력 영상 출력
    	for(j = 0 ; j<pDoc->m_width ; j++){
            R = pDoc->m_InputImage[i*pDoc->m_width+j];
            G = B = R;
    		pDC->SetPixel(j+5, i+5, RGB(R, G, B));
    	}
    }
    
    for(i = 0 ; i<pDoc->m_Re_height ; i++){ // 축소된 영상 출력
    	for(j = 0 ; j<pDoc->m_Re_width ; j++){
            R = pDoc->m_OutputImage[i*pDoc->m_Re_width+j];
            G = B = R;
            pDC->SetPixel(j+pDoc->m_width+10, i+5, RGB(R, G, B));
    	}
    }
}


// 업 샘플링이 발생하도록 프로그램 작성(5)
	: 소스파일 ImageProcessingDoc.cpp 의 227 line 에서 OnUpSampling 함수 작성

void CImageProcessingDoc::OnUpSampling()
{
    int i, j;
    
    CUpSampleDlg dlg;
    if(dlg.DoModal() == IDOK){ // DoModal 대화상자의 활성화 여부
        m_Re_height = m_height * dlg.m_UpSampleRate; // 확대 영상의 세로 길이 계산
        m_Re_width = m_width * dlg.m_UpSampleRate; // 확대 영상의 가로 길이 계산
        m_Re_size = m_Re_height * m_Re_width; // 확대 영상의 크기 계산
        m_OutputImage = new unsigned char[m_Re_size]; // 확대 영상을 위한 메모리 할당
    
        for(i=0 ; i<m_Re_size ; i++)
            m_OutputImage[i] = 0; // 초기화

        for(i=0 ; i<m_height ; i++){
            for(j=0 ; j<m_width ; j++){
                m_OutputImage[i*dlg.m_UpSampleRate*m_Re_width +
                dlg.m_UpSampleRate*j]= m_InputImage[i*m_width + j];
            } // 재배치하여 영상 확대
    	}
    }
}

// 업 샘플링이 발생하도록 프로그램 작성(6)
	: CImageProcessingView 클래스에 OnUpSampling 함수 확인 (화면에 출력하기 위해)

void CImageProcessingView::OnUpSampling()
{
    CImageProcessingDoc* pDoc = GetDocument(); // Doc 클래스 참조
    ASSERT_VALID(pDoc);

	pDoc->OnUpSampling(); // Doc 클래스에 OnUpSampling 함수 호출
    
    Invalidate(TRUE); // 화면 갱신
}

// 양자화 프로그램 작성(5)
	: 소스파일 ImageProcessingDoc.cpp 의 254 line 에서 OnQuantization 함수 작성

void CImageProcessingDoc::OnQuantization()
{
    CQuantizationDlg dlg;
    if(dlg.DoModal() == IDOK) // 양자화 비트 수를 결정하는 대화상자의 활성화 여부
    {
        int i, j, value, LEVEL;
        double HIGH, *TEMP;
        
        m_Re_height = m_height;
        m_Re_width = m_width;
        m_Re_size = m_Re_height * m_Re_width;
        m_OutputImage = new unsigned char[m_Re_size]; // 양자화 처리된 영상을 출력하기 위한 메모리 할당
        TEMP = new double [m_size]; // 입력 영상 크기(m_size)와 동일한 메모리 할당
        LEVEL=256; // 입력 영상의 양자화 단계(28=256)
        HIGH=256.;
        
        value = (int)pow(2, double(dlg.m_QuantBit)); // 양자화 단계 결정(예 : 24=16)
        for(i=0 ; i<m_size ; i++){
            for(j=0 ; j<value ; j++){
                if(m_InputImage[i] >=(LEVEL/value)*j &&
                	m_InputImage[i]<(LEVEL/value)*(j+1)){
                		TEMP[i]=(double)(HIGH/value)*j; // 양자화 수행
                	} 
            } }
        for(i=0 ; i<m_size ; i++){
        	m_OutputImage[i] = (unsigned char)TEMP[i]; // 결과 영상 생성
    	} }
}

// 양자화 프로그램 작성(7)
: CImageProcessingView 클래스에 OnQuantization 함수 작성 (화면으로 출력)

void CImageProcessingView::OnQuantization()
{
    CImageProcessingDoc* pDoc = GetDocument(); // Doc 클래스 참조
    ASSERT_VALID(pDoc);

	pDoc->OnQuantization(); // Doc 클래스에 OnQuantization 함수 호출
    
    Invalidate(TRUE); // 화면 갱신
}