testdoc.cpp

I used MFC. that code is not perfect and have some problem. But its function is Ok. You just fix

// TestDoc.cpp : implementation of the CTestDoc class
//

#include "stdafx.h"
#include "Test.h"

#include "TestDoc.h"
#include <math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CTestDoc

IMPLEMENT_DYNCREATE(CTestDoc, CDocument)

BEGIN_MESSAGE_MAP(CTestDoc, CDocument)
	//{{AFX_MSG_MAP(CTestDoc)
		// NOTE - the ClassWizard will add and remove mapping macros here.
		//    DO NOT EDIT what you see in these blocks of generated code!
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTestDoc construction/destruction

CTestDoc::CTestDoc()
{
	// TODO: add one-time construction code here

}

CTestDoc::~CTestDoc()
{
}

BOOL CTestDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)

	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////
// CTestDoc serialization

void CTestDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
		ar.Write(m_ResultImg, 256*256);
	}
	else
	{
		// TODO: add loading code here
		CFile* fp = ar.GetFile();
		if(fp->GetLength() !=256*256)
		{
			AfxMessageBox("256*256 康惑捞 酒凑聪促.");
			return;
		}
		ar.Read(m_OpenImg, fp->GetLength());
	}
}

/////////////////////////////////////////////////////////////////////////////
// CTestDoc diagnostics

#ifdef _DEBUG
void CTestDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CTestDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTestDoc commands




void CTestDoc::OnSumConstant()
{
	int data=0;
	for(int x=0; x<256; x++)
	{
		for(int y=0; y<256; y++)
		{
			data=m_OpenImg[x][y]+75;

			if(data>255)
			{
				m_ResultImg[x][y]=255;
			}
			else
			{
				m_ResultImg[x][y]=data;
			}
		}
	}
}




void CTestDoc::OnOnSubstractConstant()
{
	int data=0;
	for(int x=0; x<256; x++)
	{
		for(int y=0; y<256; y++)
		{
			data=m_OpenImg[x][y]-75;

			if(data<0)
			{
				m_ResultImg[x][y]=0;
			}
			else
			{
				m_ResultImg[x][y]=data;
			}
		}
	}
}

void CTestDoc::OnOnMultipleConstant()
{
int data=0;
	for(int x=0; x<256; x++)
	{
		for(int y=0; y<256; y++)
		{
			data=m_OpenImg[x][y]*3;

			if(data>255)
			{
				m_ResultImg[x][y]=255;
			}
			else
			{
				m_ResultImg[x][y]=data;
			}
		}
	}
}


void CTestDoc::OnDivideConstant()
{
	int data=0;
	for(int x=0; x<256; x++)
	{
		for(int y=0; y<256; y++)
		{
			data=m_OpenImg[x][y]/3;

			if(data<0)
			{
				m_ResultImg[x][y]=0;
			}
			else
			{
				m_ResultImg[x][y]=data;
			}
		}
	}
}

void CTestDoc::ImageLoad()
{
	AfxMessageBox("Select First Image");

	CFileDialog dlg(TRUE);
	if(dlg.DoModal()==IDOK) {
		CFile file;
		file.Open(dlg.GetFileName(), CFile::modeRead);
		file.Read(m_BufferImage1, 256*256);
		file.Close();
	}
	
	AfxMessageBox("Select Second Image");
	CFileDialog dlg2(TRUE);
	if(dlg2.DoModal()==IDOK) {
		CFile file;
		file.Open(dlg2.GetFileName(), CFile::modeRead);
		file.Read(m_BufferImage2, 256*256);
		file.Close();
	}

}


void CTestDoc::SumImage()
{
	int data=0;

	CTestDoc::ImageLoad();

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			data = m_BufferImage1[x][y] + m_BufferImage2[x][y];

			if(data>255) {
				m_ResultImg[x][y] = 255;
				//Wrap operating
				m_OpenImg[x][y] = data%256;
			}
			else {

				m_ResultImg[x][y] = data;
				//Wrap operating
				m_OpenImg[x][y] = data;
			} 
			//Wrap operating
		//	m_OpenImg[x][y] = data;
		}
	}
}

void CTestDoc::SubstractImage()
{
	int data=0;

	CTestDoc::ImageLoad();

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			data = m_BufferImage1[x][y] - m_BufferImage2[x][y];
			//Saturation operating
			if(data < 0) {
				m_ResultImg[x][y] = 0;
				//Wrap operating
				m_OpenImg[x][y] = -(data%256);
			}
			else {
				m_ResultImg[x][y] = data;
				//Wrap operating
				m_OpenImg[x][y] = data;
			} 
			//Wrap operating
		//	m_OpenImg[x][y] = data;
		}
	}
}

void CTestDoc::MutipleImage()
{
	int data=0;

	CTestDoc::ImageLoad();

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			data = m_BufferImage1[x][y] * m_BufferImage2[x][y];
			//Saturation operating
			if(data > 255) {
				m_ResultImg[x][y] = 255;
				//Wrap operating
				m_OpenImg[x][y] = data%256;
			}
			else {
				m_ResultImg[x][y] = data;
				//Wrap operating
				m_OpenImg[x][y] = data;
			} 
			//Wrap operating
		//	m_OpenImg[x][y] = data;
		}
	}
}

void CTestDoc::DivideImage()
{
	int data1 = 0, data2 = 0;

	CTestDoc::ImageLoad();

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			//Saturation operating
			if( m_BufferImage2[x][y] == 0) {
				data1 = m_BufferImage1[x][y];
			}
			else
				data1 = m_BufferImage1[x][y] / m_BufferImage2[x][y];

			if ( m_BufferImage1[x][y] == 0){
				//Wrap operating
				data2 = m_BufferImage2[x][y];
			} 
			else
				data2 = m_BufferImage2[x][y] / m_BufferImage1[x][y];


			m_ResultImg[x][y] = data1;
			m_OpenImg[x][y] = data2;
		
		}
	}
}

void CTestDoc::ReverseImage()
{

int data=0;

	CTestDoc::ImageLoad();

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			data = 255 - m_BufferImage1[x][y] * m_BufferImage1[x][y] ; 
			//Saturation operating
			if(data > 255) {
				m_ResultImg[x][y] = 255;
				//Wrap operating
				m_OpenImg[x][y] = data%256;
			}
			else if (data < 0) {
				m_ResultImg[x][y] = 0;
				//Wrap operating
				m_OpenImg[x][y] = data%256;
			} 
			else {
				m_ResultImg[x][y] = data;
				//Wrap operating
				m_OpenImg[x][y] = data;
			}
		}
	}

}

void CTestDoc::ComplementImage()
{	
	int data = 0;

	for(int x=0; x<256; x++) {
		for(int y=0; y<256; y++) {
			data = m_OpenImg[x][y];
			m_ResultImg[x][y] = -data;
		}
	}

}

void CTestDoc::Zoomin()
{
//犬措

	int i =0, j = 0, y = 0, x = 0, sum=0;

	for (y=0; y<256; y++) {
		for(x=0; x<256; x++) {

			i=y*scale_y;
			j=x*scale_x;

			m_scaleImg[i][j]=m_OpenImg[y][x];
		}
	}
	//乞闭蔼阑 捞侩茄 焊埃过

	//林函 4侨伎狼 乞闭蔼

	x = 0;
	y = 0;

	for(i=1; i<512; i+=2) {
		for(j=1; j<512; j+=2) {
			
			sum+=m_scaleImg[y][x];	
			sum+=m_scaleImg[y][x+2];	
			sum+=m_scaleImg[y+2][x];	
			sum+=m_scaleImg[y+2][x+2];	
			sum=sum/4;
			m_scaleImg[i][j] = sum;
			sum = 0;
			x+=2;
		}
		x=0;
		y+=2;
	}


	//谅滴 2侨伎狼 乞闭蔼
	y=0;
	x=0;

	for(i=1; i<512; i+=2) {
		for(j=1; j<512; j+=2) {
			
			sum+=m_scaleImg[y][x];	
			sum+=m_scaleImg[y][x+2];	
		
			sum=sum/2;
			m_scaleImg[i][j] = sum;
			sum = 0;
			x+=2;
		}
		x=0;
		y+=2;
	}

	//惑窍 2侨伎狼 乞闭蔼

	for(i=1; i<512; i+=2) {
		for(j=1; j<512; j+=2) {
			
			sum+=m_scaleImg[y][x];	
			sum+=m_scaleImg[y+2][x];	
		
			sum=sum/2;
			m_scaleImg[i][j] = sum;
			sum = 0;
			x+=2;
		}
		x=0;
		y+=2;
	}


}

void CTestDoc::Zoomout()
{
	int i =0, j = 0, y = 0, x = 0;

	for (y=0; y<256; y++) {
		for(x=0; x<256; x++) {

			i = y * scale_y2;
			j = x * scale_x2;

			m_scaleImg2[i][j]=m_OpenImg[y][x];
		}
	}

}

void CTestDoc::Rotate()
{
	double i =0, j = 0, m = 0, n = 0, x2 = 0, y2 = 0;
	int y =0, x = 0, left = 0, right = 0;
	double theta = 0, pi = 3.1415926535;

	theta = pi / 4;
	for (y = 0; y < 256; y++) {
		for (x=0; x<256; x++) {
			i = -1*((y-128)*sin(theta))+128;
			j = (x-128)*cos(theta);
			x2 = (i+j);
			if(x2>255) x2 = 255;
			if(x2<0) x2 = 0;
			m = ((x-128)*sin(theta))+128;
			n = (y-128)*cos(theta);
			y2=(m+n);
			if(y2>255) y2=255;
			if(y2<0) y2=0;
			m_ResultImg[(int)y2][(int)x2]=m_OpenImg[y][x];
		}
	}
	//乞闭蔼阑 捞侩茄 焊埃过
	for(y=1; y<255; y++) {
		for(x=0; x<255;x++) {
			left=m_ResultImg[y][x-1];
			right=m_ResultImg[y][x+1];
			if(left!=0 && right!=0 && m_ResultImg[y][x] ==0) {
				m_ResultImg[y][x] = (left+right)/2;
			}
		}
	}


}

void CTestDoc::Flip()
{
	int x2=0;
	for(int y =0; y <256; y++) {
		for (int x = 0; x<255; x++) {
			x2 = (255-x);
			m_ResultImg[y][x2] = m_OpenImg[y][x];
		}
	}

}

void CTestDoc::Mirr()
{
	int y2=0;
	for(int y =0; y <256; y++) {
		for (int x = 0; x<255; x++) {
			y2 = (255-y);
			m_ResultImg[y2][x] = m_OpenImg[y][x];
		}
	}
}