dibdoc.cpp

这是一款蛮COOL的图像处理系统

// DIBDoc.cpp : implementation of the CDIBDoc class
//

#include "stdafx.h"
#include "QuickImage.h"

#include "DIBDoc.h"
#include "DlgHistogram.h"
#include "raw.h"
#include "imports\jpegfile.h"
#include "mainfrm.h"
#include "ConvoluteDlg.h"
#include "ImgProcess.h"
#include "imports\gifapi.h"
#include "Global.h"

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

/////////////////////////////////////////////////////////////////////////////
// CDIBDoc
extern CString g_strCurrentDir;

IMPLEMENT_DYNCREATE(CDIBDoc, CDocument)

BEGIN_MESSAGE_MAP(CDIBDoc, CDocument)
	//{{AFX_MSG_MAP(CDIBDoc)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_REALIZEPAL, OnRealizePal)
	ON_COMMAND_RANGE(ID_IMAGE_HISTOGRAM, ID_IMAGE_THIN, OnImageProcess)
	ON_UPDATE_COMMAND_UI_RANGE(ID_IMAGE_HISTOGRAM, ID_IMAGE_THIN, OnUpdateImageProcess)

END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDIBDoc construction/destruction

CDIBDoc::CDIBDoc()
{
	m_hDIB = NULL;
	m_palDIB = NULL;
	m_sizeDoc = CSize(1,1);     // dummy value to make CScrollView happy

//	m_hRightDIB = NULL;
//	*m_strRightFile = '\0';
}

CDIBDoc::~CDIBDoc()
{
	if (m_hDIB != NULL)
	{
		::GlobalFree((HGLOBAL) m_hDIB);
		m_hDIB = NULL;
	}
	if (m_palDIB != NULL)
	{
		delete m_palDIB;
		m_palDIB = NULL;
	}
/*	if (m_hRightDIB != NULL)
	{
		::GlobalFree((HGLOBAL) m_hRightDIB);
	}*/
}

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

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

	return TRUE;
}

void CDIBDoc::InitDIBData()
{
	if (m_palDIB != NULL)
	{
		delete m_palDIB;
		m_palDIB = NULL;
	}
	if (m_hDIB == NULL)
	{
		return;
	}
	// Set up document size
	LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) m_hDIB);
	if (::DIBWidth(lpDIB) > INT_MAX ||abs(::DIBHeight(lpDIB)) > INT_MAX)
	{
		::GlobalUnlock((HGLOBAL) m_hDIB);
		::GlobalFree((HGLOBAL) m_hDIB);
		m_hDIB = NULL;
		CString strMsg;
		strMsg.LoadString(IDS_DIB_TOO_BIG);
		MessageBox(NULL, strMsg, NULL, MB_ICONINFORMATION | MB_OK);
		return;
	}
	m_sizeDoc = CSize((int) ::DIBWidth(lpDIB), (int) abs(::DIBHeight(lpDIB)));
	::GlobalUnlock((HGLOBAL) m_hDIB);
	// Create copy of palette
	if(::DIBBitCount(lpDIB) < 24)
	{
		m_palDIB = new CPalette;
		if (m_palDIB == NULL)
		{
			// we must be really low on memory
			::GlobalFree((HGLOBAL) m_hDIB);
			m_hDIB = NULL;
			return;
		}
		if (::CreateDIBPalette(m_hDIB, m_palDIB) == NULL)
		{
			// DIB may not have a palette
			delete m_palDIB;
			m_palDIB = NULL;
			return;
		}
	}
}

void CDIBDoc::ReplaceHDIB(HDIB hDIB)
{
	if (m_hDIB != NULL)
	{
		::GlobalFree((HGLOBAL) m_hDIB);
	}
	m_hDIB = hDIB;
}


/////////////////////////////////////////////////////////////////////////////
// CDIBDoc serialization

void CDIBDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: add storing code here
	}
	else
	{
		// TODO: add loading code here
	}
}

/////////////////////////////////////////////////////////////////////////////
// CDIBDoc diagnostics

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

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

/////////////////////////////////////////////////////////////////////////////
// CDIBDoc commands
BOOL CDIBDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
	BeginWaitCursor();

	CMultiDocTemplate * pDocTemplate = ((CQuickImageApp*)AfxGetApp())->m_pImageTemplate;
	
	POSITION pos = pDocTemplate->GetFirstDocPosition();
	CDIBDoc* pDoc = (CDIBDoc*)pDocTemplate->GetNextDoc(pos);
	if(NULL != pDoc && pDoc != this)
	{
		if(pDoc->IsModified())
		{
			CString strMsg = _T("Save change to") + pDoc->GetTitle() + _T("?");
			if(AfxMessageBox(strMsg, MB_ICONWARNING | MB_YESNO) == IDYES)
			{
				pDoc->SaveModified();//>OnSaveDocument(pDoc->GetPathName());
			}
		}
		pDoc->OnCloseDocument();
	}

	char *pExt=strrchr(lpszPathName,'.');
	char cExt[4];
	strcpy(cExt,++pExt);
	_strlwr(cExt);
	DeleteContents();
	
	if (strcmp(cExt,"raw")==0)
	{
		CRaw raw;
		if(!raw.ReadFromFile(lpszPathName))
		{
			return FALSE;
		}
		m_hDIB = raw.Show();
	}
	else if(strcmp(cExt,"bmp")==0
		|| strcmp(cExt,"dib")==0
		|| strcmp(cExt,"ddb")==0)
	{
		CFile file;
		CFileException fe;
		if (!file.Open(lpszPathName, CFile::modeRead | CFile::shareDenyWrite, &fe))
		{
			fe.ReportError();
			return NULL;
		}
		// replace calls to Serialize with ReadDIBFile function
		TRY
		{
			m_hDIB = ::ReadDIBFile(file);
		}
		CATCH (CFileException, eLoad)
		{
			file.Abort(); // will not throw an exception
			eLoad->ReportError();
			m_hDIB = NULL;
			return NULL;
		}
		END_CATCH
		if (m_hDIB == NULL)
		{
			// may not be DIB format
			CString strMsg;
			strMsg.LoadString(IDS_CANNOT_LOAD_DIB);
			MessageBox(NULL, strMsg, NULL, MB_ICONINFORMATION | MB_OK);
			return NULL;
		}
	}
	else if(strcmp(cExt,"jpg")==0 || strcmp(cExt,"jpeg")==0)
	{
		UINT height,width;
		BYTE *pData = NULL;
		pData = JpegFile::JpegFileToRGB(lpszPathName, &width, &height);
		if(NULL == pData)return NULL;
		JpegFile::BGRFromRGB(pData, width, height);
		JpegFile::VertFlipBuf(pData, width * 3, height);
		
		UINT widthDW;
		BYTE *pDIB = JpegFile::MakeDwordAlignedBuf(pData, width, height, &widthDW);
		
		delete []pData;
		if(NULL == pDIB)
		{
			char strErr[100];
			sprintf(strErr, "Error: %d", GetLastError());
			MessageBox(AfxGetMainWnd()->GetSafeHwnd(), strErr, "Read File Error",
				MB_OK|MB_ICONERROR);
		}
		m_hDIB = ::ShowJPEG(width, height, pDIB);
		delete []pDIB;
	}
	else if(strcmp(cExt, "gif") == 0)
	{
		m_hDIB = ReadGIF(lpszPathName);
	}
	else if(strcmp(cExt,"pcx") == 0)
	{
		m_hDIB = ::ReadPCX256(lpszPathName);
	}
	else
	{
		//		CString strMsg;
		//		strMsg.Format("%s\n不是图像文件!", lpszPathName);
		AfxMessageBox("不识别的文件格式!");
		return FALSE;
	}
	
	if(NULL != m_hDIB)
	{
		InitDIBData();
	}
	else
	{
		return FALSE;
	}
	SetPathName(lpszPathName);
	SetModifiedFlag(FALSE);
	EndWaitCursor();

//	if(g_strCurrentDir.IsEmpty())
	{
		CString strCurDir = GetPathName();
		char *pTitle = strrchr(strCurDir, '\\');
		pTitle[1] = '\0';
		CGlobal::ChangeDirectory(strCurDir);
	}
	return TRUE;
}

BOOL CDIBDoc::OnSaveDocument(LPCTSTR lpszPathName) 
{
	char *pExt=strrchr(lpszPathName,'.');
	char cExt[4];
	strcpy(cExt,++pExt);
	_strlwr(cExt);
	BeginWaitCursor();
	BOOL bSuccess = FALSE;
//	CTime t_Start = CTime::GetCurrentTime();
	
	if(strcmp(cExt,"bmp")==0
		|| strcmp(cExt,"dib")==0
		|| strcmp(cExt,"ddb")==0)
	{
		CFile file;
		CFileException fe;
		if (!file.Open(lpszPathName, CFile::modeCreate |
			CFile::modeReadWrite | CFile::shareExclusive, &fe))
		{
			ReportSaveLoadException(lpszPathName, &fe,
				TRUE, AFX_IDP_INVALID_FILENAME);
			return FALSE;
		}
		// replace calls to Serialize with SaveDIB function
		TRY
		{
			bSuccess = ::SaveDIB(m_hDIB, file);
			file.Close();
		}
		CATCH (CException, eSave)
		{
			file.Abort(); // will not throw an exception
			EndWaitCursor();
			ReportSaveLoadException(lpszPathName, eSave,
				TRUE, AFX_IDP_FAILED_TO_SAVE_DOC);
		}
		END_CATCH
	}
	else if (strcmp(cExt,"raw")==0)
	{
		bSuccess = CRaw::SaveRaw(lpszPathName, m_hDIB);
	}
	else if(strcmp(cExt,"pcx") == 0)
	{
		LPSTR	lpDIB;
		LPSTR    lpDIBBits;
		lpDIB = (LPSTR) ::GlobalLock(m_hDIB);
		lpDIBBits = ::FindDIBBits(lpDIB);
		
		// 判断是否是8-bpp位图（这里为了方便，只处理8-bpp位图的行程编码）
		if (::DIBNumColors(lpDIB) != 256)
		{
			// 提示用户
			AfxMessageBox("目前只支持256色位图的行程编码！", MB_ICONINFORMATION | MB_OK);
			::GlobalUnlock(m_hDIB);
			return FALSE;
		}
		bSuccess = ::DIBToPCX256(lpDIB, lpszPathName);
		GlobalUnlock(m_hDIB);
	}
	else
	{
//		ASSERT(FALSE);
	}

	SetPathName(lpszPathName);
	SetModifiedFlag(FALSE);
//	CTimeSpan t_Span = CTime::GetCurrentTime() - t_Start;
//	((CMainFrame*)AfxGetMainWnd())->SetStatusText(
//		t_Span.Format("Elapsed time- %H : %M : %S"));
	EndWaitCursor();
	
	return bSuccess;
	return CDocument::OnSaveDocument(lpszPathName);
}

void CDIBDoc::OnRealizePal(WPARAM wParam, LPARAM lParam)
{
//	ASSERT(wParam != NULL);

	if (NULL == m_hDIB)
		return;  // must be a new document

	if (m_palDIB != NULL)
	{
		CWnd* pAppFrame = AfxGetApp()->m_pMainWnd;

		CClientDC appDC(pAppFrame);
		// All views but one should be a background palette.
		// wParam contains a handle to the active view, so the SelectPalette
		// bForceBackground flag is FALSE only if wParam == m_hWnd (this view)
		CPalette* oldPalette = appDC.SelectPalette(m_palDIB, FALSE);

		if (oldPalette != NULL)
		{
			UINT nColorsChanged = appDC.RealizePalette();
			if (nColorsChanged > 0)
				UpdateAllViews(NULL);
			appDC.SelectPalette(oldPalette, TRUE);
		}
		else
		{
			TRACE0("\tSelectPalette failed!\n");
		}
	}
}

void CDIBDoc::OnImageProcess(UINT uID)
{
	CTime t_Start = CTime::GetCurrentTime();

	if(ID_IMAGE_HISTOGRAM == uID)
	{
		CDlgHistogram dlg(m_hDIB);
		dlg.DoModal();	
	}
	else if(ID_IMAGE_HISTOGRAM_EQUAL == uID)
	{
		HDIB hDIB = CImage::HistoEqualize(m_hDIB);
		if(NULL != hDIB)
		{
			ReplaceHDIB(hDIB);
			InitDIBData();
			SetModifiedFlag();
			UpdateAllViews(NULL);
		}	
	}
	else if(ID_IMAGE_MEDIANFILTER == uID)
	{
		if (CImgProcess::MedianFilterDIB(m_hDIB))
		{
			InitDIBData();
			SetModifiedFlag(TRUE);
	//		OnRealizePal((WPARAM)0,0);  // realize the new palette
			UpdateAllViews(NULL);
		}
	}
	else if(ID_IMAGE_SMOTH_LF1 == uID)
	{
		CConvoluteDlg FD(1, 10, 3);
		if (FD.DoModal() == IDOK)