본문 바로가기
영상처리

영상처리 소스 정리

김찬태풍 2020. 8. 7. 16:17

전역 변수

unsigned char ** m_InputImageR = NULL;
unsigned char ** m_InputImageG = NULL;
unsigned char ** m_InputImageB = NULL;
unsigned char ** m_OutputImageR = NULL;
unsigned char ** m_OutputImageG = NULL;
unsigned char ** m_OutputImageB = NULL;
int m_height;
int m_width;
int m_Re_height;
int m_Re_width;
int m_old_height;
int m_old_width;
int m_old_Re_height;
int m_old_Re_width;

 

2차원 동적 배열 할당

unsigned char** malloc2D(int h, int w)
{
	// TODO: 여기에 구현 코드 추가.
	unsigned char** p;
	p = (unsigned char**)malloc(h * sizeof(unsigned char*));
	for (int i = 0; i < h; i++)
		p[i] = (unsigned char*)malloc(w * sizeof(unsigned char));
	return p;
}

 

입력 이미지 초기화

void freeInputImage(int h)
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR != NULL) {
		for (int i = 0; i < h; i++)
			free(m_InputImageR[i]);
		free(m_InputImageR);
	}
	m_InputImageR = NULL;

	if (m_InputImageG != NULL) {
		for (int i = 0; i < h; i++)
			free(m_InputImageG[i]);
		free(m_InputImageG);
	}
	m_InputImageG = NULL;

	if (m_InputImageB != NULL) {
		for (int i = 0; i < h; i++)
			free(m_InputImageB[i]);
		free(m_InputImageB);
	}
	m_InputImageB = NULL;
}

 

 

출력 이미지 초기화

void freeOutputImage(int h)
{
	// TODO: 여기에 구현 코드 추가.
	if (m_OutputImageR != NULL) {
		for (int i = 0; i < h; i++)
			free(m_OutputImageR[i]);
		free(m_OutputImageR);
	}
	m_OutputImageR = NULL;

	if (m_OutputImageG != NULL) {
		for (int i = 0; i < h; i++)
			free(m_OutputImageG[i]);
		free(m_OutputImageG);
	}
	m_OutputImageG = NULL;

	if (m_OutputImageB != NULL) {
		for (int i = 0; i < h; i++)
			free(m_OutputImageB[i]);
		free(m_OutputImageB);
	}
	m_OutputImageB = NULL;
}

 

 

이미지 오픈(on MFC)

BOOL CMFCApplication1Doc::OnOpenDocument(LPCTSTR lpszPathName)
{
	if (!CDocument::OnOpenDocument(lpszPathName))
		return FALSE;

	// TODO:  여기에 특수화된 작성 코드를 추가합니다.
	// Color 이미지 처리 클래스
	CImage  m_bitmap;
	m_bitmap.Load(lpszPathName);

	// 기존 메모리 해제
	freeInputImage(m_old_height);
	// 중요! 입력 영상 크기 결정
	m_height = m_bitmap.GetHeight();
	m_width = m_bitmap.GetWidth();
	m_old_height = m_height;
	m_old_width = m_width;

	// 메모리 할당
	m_InputImageR = malloc2D(m_height, m_width);
	m_InputImageG = malloc2D(m_height, m_width);
	m_InputImageB = malloc2D(m_height, m_width);

	// 칼라 이미지 --> 메모리
	COLORREF pixel;

	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			pixel = m_bitmap.GetPixel(i, k);
			m_InputImageR[k][i] = (unsigned char)GetRValue(pixel);
			m_InputImageG[k][i] = (unsigned char)GetGValue(pixel);
			m_InputImageB[k][i] = (unsigned char)GetBValue(pixel);
		}

	return TRUE;
}

종료 시(on MFC)

void OnCloseDocument()
{
	// TODO: 여기에 특수화된 코드를 추가 및/또는 기본 클래스를 호출합니다.
	freeInputImage(m_height);
	freeOutputImage(m_Re_height);

	CDocument::OnCloseDocument();
}

 

동일 영상 알고리즘

void OnEqualColor()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[i][k];
			m_OutputImageG[i][k] = m_InputImageG[i][k];
			m_OutputImageB[i][k] = m_InputImageB[i][k];
		}
	}
}

반전연산알고리즘

void OnNegativeImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			m_OutputImageR[i][k] = 255 - m_InputImageR[i][k];
			m_OutputImageG[i][k] = 255 - m_InputImageG[i][k];
			m_OutputImageB[i][k] = 255 - m_InputImageB[i][k];
		}
	}
}

더하기연산 알고리즘

void OnAddImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int s = dlg.m_value;
	int aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = s + m_InputImageR[i][k];
			aG = s + m_InputImageG[i][k];
			aB = s + m_InputImageB[i][k];
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

빼기연산 알고리즘

void OnSubImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int s = dlg.m_value;
	int aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = s - m_InputImageR[i][k];
			aG = s - m_InputImageG[i][k];
			aB = s - m_InputImageB[i][k];
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

곱하기 연산 알고리즘

void OnMulImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int s = dlg.m_value;
	int aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = s * m_InputImageR[i][k];
			aG = s * m_InputImageG[i][k];
			aB = s * m_InputImageB[i][k];
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

나누기 연산 알고리즘

void OnDivImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int s = dlg.m_value;
	int aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = s / m_InputImageR[i][k];
			aG = s / m_InputImageG[i][k];
			aB = s / m_InputImageB[i][k];
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

감마 연산 알고리즘

void OnGammaImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	double s = dlg.m_value;
	double aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = pow(m_InputImageR[i][k], 1 / s);
			aG = pow(m_InputImageG[i][k], 1 / s);
			aB = pow(m_InputImageB[i][k], 1 / s);
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			else m_OutputImageR[i][k] = aR;
			else m_OutputImageG[i][k] = aG;
			else m_OutputImageB[i][k] = aB;
		}
	}
}

명암 대비 스트레치(늘리기) 알고리즘

void OnStretchImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	double s = dlg.m_value;
	double aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = ((m_InputImageR[i][k] - 128) * s) + 128;
			aG = ((m_InputImageG[i][k] - 128) * s) + 128;
			aB = ((m_InputImageB[i][k] - 128) * s) + 128;
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

명암 대비 압축 알고리즘

void OnCompressImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	double s = dlg.m_value;
	double aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			aR = ((m_InputImageR[i][k] - 128) * s) + 128;
			aG = ((m_InputImageG[i][k] - 128) * s) + 128;
			aB = ((m_InputImageB[i][k] - 128) * s) + 128;
            
			if (aR > 255) aR = 255;
			else if (aR < 0) aR = 0;
			if (aG > 255) aG = 255;
			else if (aG < 0) aG = 0;
			if (aB > 255) aB = 255;
			else if (aB < 0) aB = 0;
            
			m_OutputImageR[i][k] = aR;
			m_OutputImageG[i][k] = aG;
			m_OutputImageB[i][k] = aB;
		}
	}
}

포스터라이징 변환

void OnPosterizing()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int s = 255 / dlg.m_value;
	int aR, aG, aB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0, cnt; k < m_width; k++) {
			cnt = 0;
			aR = m_InputImageR[i][k];
			for (; s * cnt < aR; cnt++);
			if (s * cnt > 255)	m_OutputImageR[i][k] = 255;
			else if (s * cnt < 0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = cnt * s;
		}
	}
	for (int i = 0; i < m_height; i++) {
		for (int k = 0, cnt; k < m_width; k++) {
			cnt = 0;
			aG = m_InputImageG[i][k];
			for (; s * cnt < aG; cnt++);
			if (s * cnt > 255)	m_OutputImageG[i][k] = 255;
			else if (s * cnt < 0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = cnt * s;
		}
	}
	for (int i = 0; i < m_height; i++) {
		for (int k = 0, cnt; k < m_width; k++) {
			cnt = 0;
			aB = m_InputImageB[i][k];
			for (; s * cnt < aB; cnt++);
			if (s * cnt > 255)	m_OutputImageB[i][k] = 255;
			else if (s * cnt < 0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = cnt * s;
		}
	}
}

이진화 변환

void OnBinaryImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int avr;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			avr = (m_InputImageR[i][k] + m_InputImageG[i][k] + m_InputImageB[i][k]) / 3.0;
			if (avr > 128) m_OutputImageR[i][k] = 255;
			else if (avr <= 128) m_OutputImageR[i][k] = 0;
			if (avr > 128) m_OutputImageG[i][k] = 255;
			else if (avr <= 128) m_OutputImageG[i][k] = 0;
			if (avr > 128) m_OutputImageB[i][k] = 255;
			else if (avr <= 128) m_OutputImageB[i][k] = 0;
		}
	}
}

범위 강조 변환

void OnStreTranImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CTWOQ dlg;
	if (dlg.DoModal() != IDOK) return;

	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int high = dlg.m_value1;
	int low = dlg.m_value2;
	int avr;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			avr = (m_InputImageR[i][k] + m_InputImageG[i][k] + m_InputImageB[i][k]) / 3.0;
			if (low <= avr && avr <= high) {
				m_OutputImageR[i][k] = 255;
				m_OutputImageG[i][k] = 255;
				m_OutputImageB[i][k] = 255;
			}
			else {
				m_OutputImageR[i][k] = m_InputImageR[i][k];
				m_OutputImageG[i][k] = m_InputImageG[i][k];
				m_OutputImageB[i][k] = m_InputImageB[i][k];
			}

		}
	}
}

확대(백워딩)

void OnZoomInBack()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	int val = dlg.m_value;
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height * val;
	m_old_Re_height = m_Re_width = m_width * val;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[i/val][k/val];
			m_OutputImageG[i][k] = m_InputImageG[i/val][k/val];
			m_OutputImageB[i][k] = m_InputImageB[i/val][k/val];
		}
	}
}

확대(선형 보간법)

void Recur(int s, int x, int y)
{
	int hs = s / 2;

	m_OutputImageR[y][x + hs] = (m_OutputImageR[y][x] + m_OutputImageR[y][x + s]) / 2;
	m_OutputImageR[y + hs][x] = (m_OutputImageR[y][x] + m_OutputImageR[y + s][x]) / 2;
	m_OutputImageR[y + hs][x + hs] = (m_OutputImageR[y][x] + m_OutputImageR[y + s][x + s]) / 2;
	m_OutputImageR[y + hs][x + s] = (m_OutputImageR[y][x + s] + m_OutputImageR[y + s][x + s]) / 2;
	m_OutputImageR[y + s][x + hs] = (m_OutputImageR[y + s][x] + m_OutputImageR[y + s][x + s]) / 2;

	m_OutputImageG[y][x + hs] = (m_OutputImageG[y][x] + m_OutputImageG[y][x + s]) / 2;
	m_OutputImageG[y + hs][x] = (m_OutputImageG[y][x] + m_OutputImageG[y + s][x]) / 2;
	m_OutputImageG[y + hs][x + hs] = (m_OutputImageG[y][x] + m_OutputImageG[y + s][x + s]) / 2;
	m_OutputImageG[y + hs][x + s] = (m_OutputImageG[y][x + s] + m_OutputImageG[y + s][x + s]) / 2;
	m_OutputImageG[y + s][x + hs] = (m_OutputImageG[y + s][x] + m_OutputImageG[y + s][x + s]) / 2;

	m_OutputImageB[y][x + hs] = (m_OutputImageB[y][x] + m_OutputImageB[y][x + s]) / 2;
	m_OutputImageB[y + hs][x] = (m_OutputImageB[y][x] + m_OutputImageB[y + s][x]) / 2;
	m_OutputImageB[y + hs][x + hs] = (m_OutputImageB[y][x] + m_OutputImageB[y + s][x + s]) / 2;
	m_OutputImageB[y + hs][x + s] = (m_OutputImageB[y][x + s] + m_OutputImageB[y + s][x + s]) / 2;
	m_OutputImageB[y + s][x + hs] = (m_OutputImageB[y + s][x] + m_OutputImageB[y + s][x + s]) / 2;

	if (hs > 1) {
		Recur(hs, x, y);
		Recur(hs, x + hs, y);
		Recur(hs, x, y + hs);
		Recur(hs, x + hs, y + hs);
	}
}

void OnLinear()
{
	if (m_InputImageR == NULL)
		return;
	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;
	int scale = dlg.m_value;

	freeOutputImage(m_old_Re_height);
	m_old_Re_height = m_Re_height = m_height * scale;
	m_old_Re_height = m_Re_width = m_width * scale;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	for(int i=0;i<m_height;i++)
		for (int k = 0; k < m_width; k++) {
			m_OutputImageR[i*scale][k*scale] = m_InputImageR[i][k];
			m_OutputImageG[i*scale][k*scale] = m_InputImageG[i][k];
			m_OutputImageB[i*scale][k*scale] = m_InputImageB[i][k];
		}
	int x, y;
	for (int i = 0; i < m_height-1; i++)
		for (int k = 0; k < m_width-1; k++) {
			x = k * scale; y = i * scale;
			Recur(scale, x, y);
		}

}

축소

void OnZoomOut()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;

	double val = dlg.m_value;
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height / val;
	m_old_Re_height = m_Re_width = m_width / val;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[i * (int)val][k * (int)val];
			m_OutputImageG[i][k] = m_InputImageG[i * (int)val][k * (int)val];
			m_OutputImageB[i][k] = m_InputImageB[i * (int)val][k * (int)val];
		}
	}
}

회전(백워딩,중심점,크기 보정)

void OnCnbnzRotate()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;
	CONEQ dlg;
	if (dlg.DoModal() != IDOK) return;
	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	double value = dlg.m_value;
	double rad = value * 3.141592 / 180.0;
	double w = m_height * abs(cos(90.0 * 3.141592 / 180.0 - rad)) + m_width * abs(cos(rad));
	double h = m_height * abs(cos(rad)) + m_width * abs(cos(90.0 * 3.141592 / 180.0 - rad));
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = (int)h;
	m_old_Re_width = m_Re_width = (int)w;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int dx, dy, hy = m_height-1;
	int ocx = m_width / 2.0;
	int ocy = m_height / 2.0;
	int cx = w / 2.0;
	int cy = h / 2.0;
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			dx = ((k - cx) * cos(rad)) - ((i - cy) * sin(rad)) + ocx;
			dy = ((k - cx) * sin(rad)) + ((i - cy) * cos(rad)) + ocy;
			if ((0<=dx && dx < m_width) && (0 <= dy && dy < m_height)) {
				m_OutputImageR[i][k] = m_InputImageR[dy][dx];
				m_OutputImageG[i][k] = m_InputImageG[dy][dx];
				m_OutputImageB[i][k] = m_InputImageB[dy][dx];
			}
			
		}
	}
}

히스토그램 스트레치

void OnHistogram()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	int R, G, B, o;
	int minR, maxR, minG, maxG, minB, maxB;
	minR = m_InputImageR[0][0], maxR = m_InputImageR[0][0];
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (m_InputImageR[i][k] > maxR) maxR = m_InputImageR[i][k];
			if (m_InputImageR[i][k] < minR) minR = m_InputImageR[i][k];
		}
	minG = m_InputImageG[0][0], maxG = m_InputImageG[0][0];
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (m_InputImageG[i][k] > maxG) maxG = m_InputImageG[i][k];
			if (m_InputImageG[i][k] < minG) minG = m_InputImageG[i][k];
		}
	minB = m_InputImageB[0][0], maxB = m_InputImageB[0][0];
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (m_InputImageB[i][k] > maxB) maxB = m_InputImageB[i][k];
			if (m_InputImageB[i][k] < minB) minB = m_InputImageB[i][k];
		}
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			R = (m_InputImageR[i][k] - minR) / (double)(maxR - minR) * 255;
			G = (m_InputImageG[i][k] - minG) / (double)(maxG - minG) * 255;
			B = (m_InputImageB[i][k] - minB) / (double)(maxB - minB) * 255;
			if (R > 255) m_OutputImageR[i][k] = 255;
			else if (R < 0) m_OutputImageR[i][k] = 0;
			else if (0 <= R && R < 256) m_OutputImageR[i][k] = R;

			if (G > 255) m_OutputImageG[i][k] = 255;
			else if (G < 0) m_OutputImageG[i][k] = 0;
			else if (0 <= G && G < 256) m_OutputImageG[i][k] = G;

			if (B > 255) m_OutputImageB[i][k] = 255;
			else if (B < 0) m_OutputImageB[i][k] = 0;
			else if (0 <= B && B < 256) m_OutputImageB[i][k] = B;
		}
	}
}

히스토그램 엔드인탐색

void OnEndInSearch()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	CTWOQ dlg;
	if (dlg.DoModal() != IDOK) return;

	int min = dlg.m_value2, max = dlg.m_value1;

	int R, G, B;
	int AR, AG, AB;
	double avr;
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			R = m_InputImageR[i][k];
			G = m_InputImageG[i][k];
			B = m_InputImageB[i][k];
			avr = (R + G + B) / 3.0;
			
			R = ((m_InputImageR[i][k] - avr) - min) / (double)(max - min) * 255;
			G = ((m_InputImageG[i][k]  - avr)- min) / (double)(max - min) * 255;
			B = ((m_InputImageB[i][k] - avr) - min) / (double)(max - min) * 255;
			avr = (avr - min) / (double)(max - min) * 255;
			/*
			AR = (avr - min) / (double)(max - min) * 255;
			AG = (avr - min) / (double)(max - min) * 255;
			AB = (avr - min) / (double)(max - min) * 255;*/
			R += avr;	G += avr; B += avr;
			
			if (R > max) m_OutputImageR[i][k] = 255;
			else if (R < min) m_OutputImageR[i][k] = 0;
			else if (min <= R && R < max) m_OutputImageR[i][k] = R;

			if (G > max) m_OutputImageG[i][k] = 255;
			else if (G < min) m_OutputImageG[i][k] = 0;
			else if (min <= G && G < max) m_OutputImageG[i][k] = G;

			if (B > max) m_OutputImageB[i][k] = 255;
			else if (B < min) m_OutputImageB[i][k] = 0;
			else if (min <= B && B < max) m_OutputImageB[i][k] = B;
		}
	}
}

평활화

void RGBtoHSV(int R, int G, int B, double* H, double* S, double* V)
{
	// TODO: 여기에 구현 코드 추가.
//R, G and B input range = 0 ÷ 255
//H, S and V output range = 0 ÷ 1.0

	double var_R = (R / 255.0);
	double var_G = (G / 255.0);
	double var_B = (B / 255.0);

	double var_Min = min(min(var_R, var_G), var_B);    //Min. value of RGB
	double var_Max = max(max(var_R, var_G), var_B);    //Max. value of RGB
	double del_Max = var_Max - var_Min;             //Delta RGB value

	*V = var_Max;

	if (del_Max == 0)                     //This is a gray, no chroma...
	{
		*H = 0;
		*S = 0;
	}
	else                                    //Chromatic data...
	{
		*S = del_Max / var_Max;

		double del_R = (((var_Max - var_R) / 6.0) + (del_Max / 2.0)) / del_Max;
		double del_G = (((var_Max - var_G) / 6.0) + (del_Max / 2.0)) / del_Max;
		double del_B = (((var_Max - var_B) / 6.0) + (del_Max / 2.0)) / del_Max;

		if (var_R == var_Max) *H = del_B - del_G;
		else if (var_G == var_Max) *H = (1 / 3.0) + del_R - del_B;
		else if (var_B == var_Max) *H = (2 / 3.0) + del_G - del_R;

		if (*H < 0.0) *H += 1;
		if (*H > 1.0) *H -= 1;
	}
}

void HSVtoRGB(unsigned char* R, unsigned char* G,unsigned char* B,
				double H, double S, double V)
{
	// TODO: 여기에 구현 코드 추가.
	//H, S and V input range = 0 ÷ 1.0
	//R, G and B output range = 0 ÷ 255
	if (S == 0)
	{
		*R = V * 255;
		*G = V * 255;
		*B = V * 255;
	}
	else
	{
		double var_h = H * 6;
		if (var_h == 6) var_h = 0;      //H must be < 1
		int var_i = int(var_h);             //Or ... var_i = floor( var_h )
		double var_1 = V * (1 - S);
		double var_2 = V * (1 - S * (var_h - var_i));
		double var_3 = V * (1 - S * (1 - (var_h - var_i)));

		double var_r, var_g, var_b;
		if (var_i == 0) { var_r = V; var_g = var_3; var_b = var_1; }
		else if (var_i == 1) { var_r = var_2; var_g = V; var_b = var_1; }
		else if (var_i == 2) { var_r = var_1; var_g = V; var_b = var_3; }
		else if (var_i == 3) { var_r = var_1; var_g = var_2; var_b = V; }
		else if (var_i == 4) { var_r = var_3; var_g = var_1; var_b = V; }
		else { var_r = V; var_g = var_1; var_b = var_2; }

		//var_r *= 255;
		*R = var_r * 255.0;
		*G = var_g * 255.0;
		*B = var_b * 255.0;
	}
}

double** malloc2D_double(int h, int w)
{
	// TODO: 여기에 구현 코드 추가.
	double** p;
	p = (double**)malloc(h * sizeof(double*));
	for (int i = 0; i < h; i++)
		p[i] = (double*)malloc(w * sizeof(double));
	return p;
}

void OnEqualized()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	double** TempImageH = malloc2D_double(m_Re_height, m_Re_width);
	double** TempImageS = malloc2D_double(m_Re_height, m_Re_width);
	double** TempImageV = malloc2D_double(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			double* pH, * pS, * pV;
			int R, G, B;
			pH = &TempImageH[i][k];
			pS = &TempImageS[i][k];
			pV = &TempImageV[i][k];
			R = m_InputImageR[i][k];
			G = m_InputImageG[i][k];
			B = m_InputImageB[i][k];

			RGBtoHSV(R, G, B, pH, pS, pV);
		}

	int sumV[256] = { 0, }, cntV[256] = { 0, };
	//int sumS[256] = { 0, }, cntS[256] = { 0, };
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			cntV[(int)(TempImageV[i][k] * 255.0)]++;
			//cntS[(int)(TempImageS[i][k] * 255.0)]++;
		}
	int sV = 0;
	//int sS = 0;
	double nV[256] = { 0.0, };
	//double nS[256] = { 0.0, };
	for (int i = 0; i < 256; i++) {
		sV += cntV[i]; //sS += cntS[i];
		sumV[i] = sV; //sumS[i] = sS;
	}
	for (int i = 0; i < 256; i++) {
		nV[i] = (double)sumV[i] * (1.0 / sumV[255]) * 255.0;
		//nS[i] = (double)sumS[i] * (1.0 / sumS[255]) * 255.0;
	}
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			TempImageV[i][k] = nV[(int)(TempImageV[i][k] * 255)] / 255.0;
			//TempImageS[i][k] = nS[(int)(TempImageS[i][k] * 255)] / 255.0;
		}

	unsigned char* pR, * pG, * pB;
	double H, S, V;
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_height; k++) {
			H = TempImageH[i][k];
			S = TempImageS[i][k];
			V = TempImageV[i][k];
			pR = &m_OutputImageR[i][k];
			pG = &m_OutputImageG[i][k];
			pB = &m_OutputImageB[i][k];
			HSVtoRGB(pR, pG, pB, H, S, V);
		}
        
	for (int i = 0; i < m_Re_height; i++) {
		free(TempImageH[i]);
		free(TempImageS[i]);
		free(TempImageV[i]);
	}
	TempImageH = NULL;
	TempImageS = NULL;
	TempImageV = NULL;
}

엠보싱

void freeTemp(double** p, int h)
{
	// TODO: 여기에 구현 코드 추가.
	if (p != NULL) {
		for (int i = 0; i < h; i++)
			free(p[i]);
		free(p);
	}
	p = NULL;
}

void OnEmbossing()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {-1.0,0.0,0.0},
							{ 0.0,0.0,0.0},
							{ 0.0,0.0,1.0} };
	//임시 입출메모리 확보
	double** tmpInput, ** tmpOutput;
	tmpInput = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutput = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++)
			tmpInput[i + 1][k + 1] = (double)m_InputImageR[i][k];

	double S;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			S = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					S += tmpInput[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutput[i][k] = S;
		}
	}
	//마스크 총합이 0이면 127을 더하기.
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++)
			tmpOutput[i][k] += 127.0;
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutput[i][k] > 255.0) m_OutputImageR[i][k] = 255;
			else if (tmpOutput[i][k] < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)tmpOutput[i][k];
		}

	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++)
			tmpInput[i + 1][k + 1] = (double)m_InputImageG[i][k];

	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			S = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					S += tmpInput[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutput[i][k] = S;
		}
	}
	//마스크 총합이 0이면 127을 더하기.
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++)
			tmpOutput[i][k] += 127.0;
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutput[i][k] > 255.0) m_OutputImageG[i][k] = 255;
			else if (tmpOutput[i][k] < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)tmpOutput[i][k];
		}

	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++)
			tmpInput[i + 1][k + 1] = (double)m_InputImageB[i][k];

	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			S = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					S += tmpInput[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutput[i][k] = S;
		}
	}
	//마스크 총합이 0이면 127을 더하기.
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++)
			tmpOutput[i][k] += 127.0;
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutput[i][k] > 255.0) m_OutputImageB[i][k] = 255;
			else if (tmpOutput[i][k] < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)tmpOutput[i][k];
		}

	freeTemp(tmpInput, m_height + 2);
	freeTemp(tmpOutput, m_height);
}

블러

void OnBlur()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {1.0 / 9.0,1.0 / 9.0,1.0 / 9.0},
							{ 1.0 / 9.0,1.0 / 9.0,1.0 / 9.0},
							{ 1.0 / 9.0,1.0 / 9.0,1.0 / 9.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputR[i][k] > 255.0) m_OutputImageR[i][k] = 255;
			else if (tmpOutputR[i][k] < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)tmpOutputR[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputG[i][k] > 255.0) m_OutputImageG[i][k] = 255;
			else if (tmpOutputG[i][k] < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)tmpOutputG[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputB[i][k] > 255.0) m_OutputImageB[i][k] = 255;
			else if (tmpOutputB[i][k] < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)tmpOutputB[i][k];
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

가우시안 스무딩 필터

void OnSmoothing()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {1.0 / 16.0,1.0 / 8.0,1.0 / 16.0},
							{ 1.0 / 8.0,1.0 / 4.0,1.0 / 8.0},
							{ 1.0 / 16.0,1.0 / 8.0,1.0 / 16.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputR[i][k] > 255.0) m_OutputImageR[i][k] = 255;
			else if (tmpOutputR[i][k] < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)tmpOutputR[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputG[i][k] > 255.0) m_OutputImageG[i][k] = 255;
			else if (tmpOutputG[i][k] < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)tmpOutputG[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputB[i][k] > 255.0) m_OutputImageB[i][k] = 255;
			else if (tmpOutputB[i][k] < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)tmpOutputB[i][k];
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

샤프닝

void OnSharpning()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {0.0,-1.0,0.0},
							{ -1.0,5.0,-1.0},
							{0.0,-1.0,0.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputR[i][k] > 255.0) m_OutputImageR[i][k] = 255;
			else if (tmpOutputR[i][k] < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)tmpOutputR[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputG[i][k] > 255.0) m_OutputImageG[i][k] = 255;
			else if (tmpOutputG[i][k] < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)tmpOutputG[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputB[i][k] > 255.0) m_OutputImageB[i][k] = 255;
			else if (tmpOutputB[i][k] < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)tmpOutputB[i][k];
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

고주파 통과 필터

void OnHpf()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {-1.0 / 9.0,-1.0 / 9.0,-1.0 / 9.0},
							{ -1.0 / 9.0,8.0 / 9.0,-1.0 / 9.0},
							{-1.0 / 9.0,-1.0 / 9.0,-1.0 / 9.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputR[i][k] > 255.0) m_OutputImageR[i][k] = 255;
			else if (tmpOutputR[i][k] < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)tmpOutputR[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputG[i][k] > 255.0) m_OutputImageG[i][k] = 255;
			else if (tmpOutputG[i][k] < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)tmpOutputG[i][k];
		}
		for (int k = 0; k < m_Re_width; k++) {
			if (tmpOutputB[i][k] > 255.0) m_OutputImageB[i][k] = 255;
			else if (tmpOutputB[i][k] < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)tmpOutputB[i][k];
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

언샤프닝(원본-저주파 통과 이미지)

void OnLpf()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {1.0 / 9.0,1.0 / 9.0,1.0 / 9.0},
							{ 1.0 / 9.0,1.0 / 9.0,1.0 / 9.0},
							{ 1.0 / 9.0,1.0 / 9.0,1.0 / 9.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			SR = m_InputImageR[i][k] - tmpOutputR[i][k];
			if (SR > 255.0) m_OutputImageR[i][k] = 255;
			else if (SR < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)SR;
		}
		for (int k = 0; k < m_Re_width; k++) {
			SG = m_InputImageR[i][k] - tmpOutputR[i][k];
			if (SG > 255.0) m_OutputImageG[i][k] = 255;
			else if (SG < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)SG;
		}
		for (int k = 0; k < m_Re_width; k++) {
			SB = m_InputImageR[i][k] - tmpOutputR[i][k];
			if (SB > 255.0) m_OutputImageB[i][k] = 255;
			else if (SB < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)SB;
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

이미지 이동 엣지검출

void OnShift()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {0.0,-1.0,0.0},
							{0.0,1.0,0.0},
							{0.0,0.0,0.0} };
	//임시 입출메모리 확보
	double** tmpInputR, ** tmpOutputR, ** tmpInputG, ** tmpOutputG, ** tmpInputB, ** tmpOutputB;
	tmpInputR = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputG = malloc2D_double(m_height + 2, m_width + 2);
	tmpInputB = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutputR = malloc2D_double(m_height, m_width);
	tmpOutputG = malloc2D_double(m_height, m_width);
	tmpOutputB = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInputR[i + 1][k + 1] = (double)m_InputImageR[i][k];
			tmpInputG[i + 1][k + 1] = (double)m_InputImageG[i][k];
			tmpInputB[i + 1][k + 1] = (double)m_InputImageB[i][k];
		}
	double SR, SG, SB;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			SR = 0.0, SG = 0.0, SB = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					SR += tmpInputR[i + m][k + n] * mask[m][n];
					SG += tmpInputG[i + m][k + n] * mask[m][n];
					SB += tmpInputB[i + m][k + n] * mask[m][n];
				}
			}
			tmpOutputR[i][k] = SR;
			tmpOutputG[i][k] = SG;
			tmpOutputB[i][k] = SB;
		}
	}
	//임시 output -->진짜 output
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			SR = tmpOutputR[i][k];
			if (SR > 255.0) m_OutputImageR[i][k] = 255;
			else if (SR < 0.0) m_OutputImageR[i][k] = 0;
			else m_OutputImageR[i][k] = (int)SR;
		}
		for (int k = 0; k < m_Re_width; k++) {
			SG = tmpOutputR[i][k];
			if (SG > 255.0) m_OutputImageG[i][k] = 255;
			else if (SG < 0.0) m_OutputImageG[i][k] = 0;
			else m_OutputImageG[i][k] = (int)SG;
		}
		for (int k = 0; k < m_Re_width; k++) {
			SB = tmpOutputR[i][k];
			if (SB > 255.0) m_OutputImageB[i][k] = 255;
			else if (SB < 0.0) m_OutputImageB[i][k] = 0;
			else m_OutputImageB[i][k] = (int)SB;
		}
	}
	freeTemp(tmpInputR, m_height + 2);
	freeTemp(tmpOutputR, m_height);
	freeTemp(tmpInputG, m_height + 2);
	freeTemp(tmpOutputG, m_height);
	freeTemp(tmpInputB, m_height + 2);
	freeTemp(tmpOutputB, m_height);

}

유사연산자 엣지검출

void OnHomogenOperator()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);
	// **** 진짜 영상 처리 알고리즘 ***
	//마스크
	double mask[3][3] = { {1.0,1.0,1.0},
							{1.0,1.0,1.0},
							{1.0,1.0,1.0} };
	//임시 입출메모리 확보
	double** tmpInput, ** tmpOutput;
	tmpInput = malloc2D_double(m_height + 2, m_width + 2);
	tmpOutput = malloc2D_double(m_height, m_width);
	//input->tempinput
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++) {
			tmpInput[i + 1][k + 1] = (m_InputImageR[i][k] + m_InputImageG[i][k] + m_InputImageB[i][k]) / 3.0;
		}
	double S, dif;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			dif = 0.0;
			for (int m = 0; m < 3; m++) {
				for (int n = 0; n < 3; n++) {
					S = tmpInput[i + 1][k + 1] - tmpInput[i + m][k + n];
					if (S > dif)	dif = S;
				}
			}
			tmpOutput[i][k] = dif;
		}
	}
	double t;
	for (int i = 0; i < m_Re_height; i++) {
		for (int k = 0; k < m_Re_width; k++) {
			t = tmpOutput[i][k];
			if (t > 255.0) t = 255.0;
			if (t < 0.0) t = 0.0;
			m_OutputImageR[i][k] = (unsigned char)m_InputImageR[i][k] * (t / 255);
			m_OutputImageG[i][k] = (unsigned char)m_InputImageG[i][k] * (t / 255);
			m_OutputImageB[i][k] = (unsigned char)m_InputImageB[i][k] * (t / 255);
		}
	}

}

평균값 이진화

void OnAverageBinary()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	long sum = 0;
	for (int i = 0; i < m_height; i++)
		for (int k = 0; k < m_width; k++)
			sum += m_InputImageR[i][k] + m_InputImageG[i][k] + m_InputImageB[i][k];
	int avr = (double)sum / (double)(m_height * m_width) / 3.0;
	int a;
	for (int i = 0; i < m_height; i++) {
		for (int k = 0; k < m_width; k++) {
			a = (m_InputImageR[i][k] + m_InputImageG[i][k] + m_InputImageB[i][k]) / 3.0;
			if (avr > a) {
				m_OutputImageR[i][k] = 0;
				m_OutputImageG[i][k] = 0;
				m_OutputImageB[i][k] = 0;
			}
			else {
				m_OutputImageR[i][k] = 255;
				m_OutputImageG[i][k] = 255;
				m_OutputImageB[i][k] = 255;
			}
		}
	}
}

이미지 이동

void OnMoveImage()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	CTWOQ dlg;
	if (dlg.DoModal() != IDOK) return;

	int x = (int)dlg.m_value1;
	int y = (int)dlg.m_value2;
	for(int i=0;i<m_Re_height;i++)
		for (int k = 0; k < m_Re_width; k++) {
			if ((0 <= x + k && x + k < m_Re_height) &&
				(0 <= y + i && y + i < m_Re_width)) {
				m_OutputImageR[i + y][k + x] = m_InputImageR[i][k];
				m_OutputImageG[i + y][k + x] = m_InputImageG[i][k];
				m_OutputImageB[i + y][k + x] = m_InputImageB[i][k];
			}
		}
}

이미지 좌우반전

void OnMirrorLr()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[i][m_Re_width - k - 1];
			m_OutputImageG[i][k] = m_InputImageG[i][m_Re_width - k - 1];
			m_OutputImageB[i][k] = m_InputImageB[i][m_Re_width - k - 1];
			
		}
}

이미지 상하반전

void OnMirrorUd()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[m_Re_height -1 -i][k];
			m_OutputImageG[i][k] = m_InputImageG[m_Re_height - 1 - i][k];
			m_OutputImageB[i][k] = m_InputImageB[m_Re_height - 1 - i][k];

		}
}

이미지 상하좌우반전

void OnMirror()
{
	// TODO: 여기에 구현 코드 추가.
	if (m_InputImageR == NULL)
		return;

	// *중요* 출력영상의 크기 결정 --> 알고리즘에 따름..
	freeOutputImage(m_old_Re_height);

	m_old_Re_height = m_Re_height = m_height;
	m_old_Re_height = m_Re_width = m_width;

	// 출력 이미지 메모리 할당
	m_OutputImageR = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageG = malloc2D(m_Re_height, m_Re_width);
	m_OutputImageB = malloc2D(m_Re_height, m_Re_width);

	// **** 진짜 영상 처리 알고리즘 ***
	for (int i = 0; i < m_Re_height; i++)
		for (int k = 0; k < m_Re_width; k++) {
			m_OutputImageR[i][k] = m_InputImageR[m_Re_height - 1 - i][m_Re_width - k - 1];
			m_OutputImageG[i][k] = m_InputImageG[m_Re_height - 1 - i][m_Re_width - k - 1];
			m_OutputImageB[i][k] = m_InputImageB[m_Re_height - 1 - i][m_Re_width - k - 1];

		}
}

'영상처리' 카테고리의 다른 글

컬러 모델  (0) 2021.06.20
디지털 영상처리 입문  (0) 2021.06.20
opencv 와 영상처리 동영상  (0) 2020.09.09
파이썬 영상처리 요약본  (0) 2020.08.30
영상처리 mfc 전체 코드  (0) 2020.08.07

'영상처리' Related Articles

티스토리툴바