demodoc.cpp

来自「君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图」· C++ 代码 · 共 1,895 行 · 第 1/5 页

}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::OnUpdateEditRedo(CCmdUI* pCmdUI) 
{
	if(image==0 || hThread) pCmdUI->Enable(0);
	else pCmdUI->Enable((m_UndoLevel<(MAX_UNDO_LEVELS))&&
				   (imageUndo[m_UndoLevel]!=0));
}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::OnEditUndo() 
{
	m_UndoLevel--;
	CxImage* tmp = image;
	image=imageUndo[m_UndoLevel];
	imageUndo[m_UndoLevel]=tmp;

	UpdateAllViews(0,WM_USER_NEWIMAGE);
	UpdateStatusBar();
}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::OnEditRedo() 
{
	CxImage* tmp = image;
	image=imageUndo[m_UndoLevel];
	imageUndo[m_UndoLevel]=tmp;
	m_UndoLevel++;

	UpdateAllViews(0,WM_USER_NEWIMAGE);
	UpdateStatusBar();
}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::SubmitUndo()
{
	if (m_UndoLevel>=MAX_UNDO_LEVELS){	// Max Undo reached
		delete imageUndo[0];			// discard the early undo
		for(int i=1;i<MAX_UNDO_LEVELS;i++){
			imageUndo[i-1]=imageUndo[i]; //shift the history
		}
		imageUndo[MAX_UNDO_LEVELS-1]=0;	// clear the undo slot
		m_UndoLevel=MAX_UNDO_LEVELS-1;  // reposition at last level
	}
	// we must clear the "redo" history when a new action is performed
	for (int i=m_UndoLevel;i<MAX_UNDO_LEVELS;i++){
		if (imageUndo[i]){
			delete imageUndo[i];
			imageUndo[i]=0;
		}
	}
	// save the actual image in the undo history
	if (image->IsValid()){
		imageUndo[m_UndoLevel] = new CxImage();
		imageUndo[m_UndoLevel]->Copy(*image);
		m_UndoLevel++;
	}
}
//////////////////////////////////////////////////////////////////////////////
void /*unsigned long _stdcall*/ RunProgressThread(void *lpParam)
{
	CDemoDoc *pDoc = (CDemoDoc *)lpParam;
	long n;
	POSITION pos;
	CView *pView;
	while((n=pDoc->image->GetProgress())<100){
		Sleep(333);
		if(pDoc->image->GetEscape()) break;
		pos = pDoc->GetFirstViewPosition();
		pView = pDoc->GetNextView(pos);
		if (pView) SendMessage(pView->m_hWnd, WM_USER_PROGRESS,n,0);
	}
	pos = pDoc->GetFirstViewPosition();
	pView = pDoc->GetNextView(pos);
	if (pView) SendMessage(pView->m_hWnd, WM_USER_PROGRESS,100,0);
	Sleep(111);
	pos = pDoc->GetFirstViewPosition();
	pView = pDoc->GetNextView(pos);
	if (pView) SendMessage(pView->m_hWnd, WM_USER_NEWIMAGE,0,0);
	pDoc->hProgress = 0;
	_endthread();
	return;
}
//////////////////////////////////////////////////////////////////////////////
void /*unsigned long _stdcall*/ RunCxImageThread(void *lpParam)
{
	CDemoDoc *pDoc = (CDemoDoc *)lpParam;
	if (pDoc==NULL) return;
	if (pDoc->image==NULL) return;

	 //prepare for elaboration
	pDoc->image->SetProgress(0);
	pDoc->image->SetEscape(0);

	pDoc->SubmitUndo();
	
	// auxilary thread for progress bar
	pDoc->hProgress = (HANDLE)_beginthread(RunProgressThread,0,pDoc);

	pDoc->Stopwatch(0);

	switch (pDoc->m_MenuCommand)
	{
//	case ID_FILE_OPEN:
//		pDoc->image->ReadFile(*(CString*)pDoc->m_fp[0],(int)pDoc->m_fp[1]);
//		break;
	case ID_CXIMAGE_FLIP:
		pDoc->image->Flip();
		break;
	case ID_CXIMAGE_MIRROR:
		pDoc->image->Mirror();
		break;
	case ID_CXIMAGE_NEGATIVE:
		pDoc->image->Negative();
		break;
	case ID_CXIMAGE_GRAYSCALE:
		pDoc->image->GrayScale();
		break;
	case ID_CXIMAGE_DITHER:
		pDoc->image->Dither((long)pDoc->m_fp[0]);
		break;
	case ID_CXIMAGE_THRESHOLD:
		pDoc->image->Threshold((BYTE)pDoc->m_fp[0]);
		break;
	case ID_CXIMAGE_COLORIZE:
		if ((BYTE)pDoc->m_fp[0]){
			pDoc->image->Colorize((BYTE)pDoc->m_fp[1],(BYTE)pDoc->m_fp[2],(BYTE)pDoc->m_fp[3]/100.0f);
		} else {
			pDoc->image->ShiftRGB((long)pDoc->m_fp[1],(long)pDoc->m_fp[2],(long)pDoc->m_fp[3]);
		}
		break;
	case ID_CXIMAGE_LIGHTEN:
		pDoc->image->Light(20);
		break;
	case ID_CXIMAGE_DARKEN:
		pDoc->image->Light(-20);
		break;
	case ID_CXIMAGE_CONTRAST:
		pDoc->image->Light((long)pDoc->m_fp[0],25);
		break;
	case ID_CXIMAGE_LESSCONTRAST:
		pDoc->image->Light((long)pDoc->m_fp[0],-25);
		break;
	case ID_CXIMAGE_DILATE:
		pDoc->image->Dilate();
		break;
	case ID_CXIMAGE_ERODE:
		pDoc->image->Erode();
		break;
	case ID_CXIMAGE_CONTOUR:
		pDoc->image->Contour();
		break;
	case ID_CXIMAGE_ADDNOISE:
		pDoc->image->Noise(50);
		break;
	case ID_CXIMAGE_JITTER:
		pDoc->image->Jitter();
		break;
	case ID_FILTERS_NONLINEAR_EDGE:
		pDoc->image->Edge();
		break;
	case ID_CXIMAGE_CIRCLETRANSFORM_CYLINDER:
		pDoc->image->CircleTransform(3,0,100);
		break;
	case ID_CXIMAGE_CIRCLETRANSFORM_PINCH:
		pDoc->image->CircleTransform(1,0,100);
		break;
	case ID_CXIMAGE_CIRCLETRANSFORM_PUNCH:
		pDoc->image->CircleTransform(0,0,100);
		break;
	case ID_CXIMAGE_CIRCLETRANSFORM_SWIRL:
		pDoc->image->CircleTransform(2,0,100);
		break;
	case ID_CXIMAGE_CIRCLETRANSFORM_BATHROOM:
		pDoc->image->CircleTransform(4);
		break;
	case ID_CXIMAGE_EMBOSS:
		{
		long kernel[]={0,0,-1,0,0,0,1,0,0};
		pDoc->image->Filter(kernel,3,0,127);
		break;
		}
	case ID_CXIMAGE_BLUR:
		{
		long kernel[]={1,1,1,1,1,1,1,1,1};
		pDoc->image->Filter(kernel,3,9,0);
		break;
		}
	case ID_CXIMAGE_GAUSSIAN3X3:
		{
		long kernel[]={1,2,1,2,4,2,1,2,1};
		pDoc->image->Filter(kernel,3,16,0);
		break;
		}
	case ID_CXIMAGE_GAUSSIAN5X5:
		{
		long kernel[]={0,1,2,1,0,1,3,4,3,1,2,4,8,4,2,1,3,4,3,1,0,1,2,1,0};
		pDoc->image->Filter(kernel,5,52,0);
		break;
		}
	case ID_CXIMAGE_SOFTEN:
		{
		long kernel[]={1,1,1,1,8,1,1,1,1};
		pDoc->image->Filter(kernel,3,16,0);
		break;
		}
	case ID_CXIMAGE_SHARPEN:
		{
		long kernel[]={-1,-1,-1,-1,15,-1,-1,-1,-1};
		pDoc->image->Filter(kernel,3,7,0);
		break;
		}
	case ID_CXIMAGE_EDGE:
		{
		long kernel[]={-1,-1,-1,-1,8,-1,-1,-1,-1};
		pDoc->image->Filter(kernel,3,-1,255);
		break;
		}
	case ID_CXIMAGE_MEDIAN:
		pDoc->image->Median(3);
		break;
	case ID_CXIMAGE_GAMMA:
		pDoc->image->Gamma((long)pDoc->m_fp[0]/1000.0f);
		break;
	case ID_CXIMAGE_HISTOGRAM_LOG:
		pDoc->image->HistogramLog();
		break;
	case ID_CXIMAGE_HISTOGRAM_ROOT:
		pDoc->image->HistogramRoot();
		break; 
	case ID_CXIMAGE_HISTOGRAM_EQUALIZE:
		pDoc->image->HistogramEqualize();
		break;
	case ID_CXIMAGE_HISTOGRAM_NORMALIZE:
		pDoc->image->HistogramNormalize();
		break;
	case ID_CXIMAGE_HISTOGRAM_STRETCH:
		pDoc->image->HistogramStretch();
		break;
	case ID_CXIMAGE_HISTOGRAM_STRETCH1:
		pDoc->image->HistogramStretch(1);
		break;
	case ID_CXIMAGE_HISTOGRAM_STRETCH2:
		pDoc->image->HistogramStretch(2);
		break;
	case ID_CXIMAGE_SKEW:
		pDoc->image->Skew((long)pDoc->m_fp[0]/1000.0f,(long)pDoc->m_fp[1]/1000.0f,
							(long)pDoc->m_fp[2],(long)pDoc->m_fp[3],(long)pDoc->m_fp[4]!=0);
		break;
	case ID_CXIMAGE_ROTATE:
		//pDoc->image->Rotate((float)(long)pDoc->m_fp[0]/1000);
		//***bd*** more rotation options
		CxImage::InterpolationMethod intm;
		CxImage::OverflowMethod overm;
		switch ((int)(pDoc->m_fp[1])) {
		case 0: intm=CxImage::IM_NEAREST_NEIGHBOUR; break;
		case 1: intm=CxImage::IM_BILINEAR; break;
		case 2: intm=CxImage::IM_BICUBIC; break;
		case 3: intm=CxImage::IM_BICUBIC2; break;
		case 4: intm=CxImage::IM_BSPLINE; break;
		case 5: intm=CxImage::IM_LANCZOS; break;
		case 6: intm=CxImage::IM_HERMITE; break;
		default: throw(0);
		}//switch
		switch ((int)(pDoc->m_fp[2])) {
		case 0: overm=CxImage::OM_BACKGROUND; break;
		case 1: overm=CxImage::OM_BACKGROUND; break;
		case 2: overm=CxImage::OM_BACKGROUND; break;
		case 3: overm=CxImage::OM_WRAP; break;
		case 4: overm=CxImage::OM_REPEAT; break;
		case 5: overm=CxImage::OM_MIRROR; break;
		case 6: overm=CxImage::OM_TRANSPARENT; break;
		}//switch
		switch ((int)(pDoc->m_fp[2])) {
		case 0: {
			RGBQUAD bkg = pDoc->image->GetPixelColor(0,0);
			pDoc->image->Rotate2((long)pDoc->m_fp[0]/1000.0f, 0, intm, overm, &bkg,true,pDoc->m_fp[3]!=0);
			break; }
		case 1: {
			RGBQUAD bkg = {0,0,0,0};
			pDoc->image->Rotate2((long)pDoc->m_fp[0]/1000.0f, 0, intm, overm, &bkg,true,pDoc->m_fp[3]!=0);
			break; }
		default:
			pDoc->image->Rotate2((long)pDoc->m_fp[0]/1000.0f, 0, intm, overm, 0,true,pDoc->m_fp[3]!=0);
		}
		break;
	case ID_CXIMAGE_ROTATEL:
		pDoc->image->RotateLeft();
		break;
	case ID_CXIMAGE_ROTATER:
		pDoc->image->RotateRight();
		break;
	case ID_CXIMAGE_RESAMPLE:
		//***bd*** more resample options
		CxImage::InterpolationMethod rintm;
		switch ((long)(pDoc->m_fp[2])) {
		case 0: rintm=CxImage::IM_NEAREST_NEIGHBOUR; break;
		case 1: rintm=CxImage::IM_BILINEAR; break;
		case 2: rintm=CxImage::IM_BILINEAR; break;
		case 3: rintm=CxImage::IM_BICUBIC; break;
		case 4: rintm=CxImage::IM_BICUBIC2; break;
		case 5: rintm=CxImage::IM_BSPLINE; break;
		case 6: rintm=CxImage::IM_LANCZOS; break;
		case 7: rintm=CxImage::IM_HERMITE; break;
		default: throw(0);
		}//switch
		switch ((long)(pDoc->m_fp[2])) {
		case 0:
			pDoc->image->Resample((long)pDoc->m_fp[0],(long)pDoc->m_fp[1],1);
			break;
		case 1:
			pDoc->image->Resample((long)pDoc->m_fp[0],(long)pDoc->m_fp[1],0);
			break;
		default:
			pDoc->image->Resample2((long)pDoc->m_fp[0],(long)pDoc->m_fp[1],rintm,CxImage::OM_REPEAT);
		}
		break;
	case ID_CXIMAGE_INCREASEBPP:
		pDoc->image->IncreaseBpp((long)pDoc->m_fp[0]);
		break;
	case ID_CXIMAGE_DECREASEBPP:
		{
			long bit=(long)pDoc->m_fp[0];
			long method=(long)pDoc->m_fp[1];
			bool errordiffusion=((long)pDoc->m_fp[2])!=0;
			long colors=(long)pDoc->m_fp[3];

			//pDoc->image->IncreaseBpp(24);

			RGBQUAD* ppal = NULL;
			if (method==1){
				switch (bit){
				/*case 1:
					{
						CQuantizer q(2,8);
						q.ProcessImage(pDoc->image->GetDIB());
						ppal=(RGBQUAD*)calloc(2*sizeof(RGBQUAD),1);
						q.SetColorTable(ppal);
						break;
					}*/
				case 4:
					{
						CQuantizer q(colors,8);
						q.ProcessImage(pDoc->image->GetDIB());
						ppal=(RGBQUAD*)calloc(16*sizeof(RGBQUAD),1);
						q.SetColorTable(ppal);
						break;
					}
				case 8:
					{
						CQuantizer q(colors,(colors>16?7:8));
						q.ProcessImage(pDoc->image->GetDIB());
						ppal=(RGBQUAD*)calloc(256*sizeof(RGBQUAD),1);
						q.SetColorTable(ppal);
					}
				}
				pDoc->image->DecreaseBpp(bit,errordiffusion,ppal,colors);
			} else pDoc->image->DecreaseBpp(bit,errordiffusion,0);

			if (!pDoc->image->AlphaPaletteIsValid()) pDoc->image->AlphaPaletteEnable(0);

			if (ppal) free(ppal);
			break;
		}
	}

	pDoc->Stopwatch(1);

	pDoc->image->SetProgress(100);

	pDoc->hThread=0;
	_endthread();
	return ;
}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::OnCximageFlip() 
{
	m_MenuCommand=ID_CXIMAGE_FLIP;
	hThread=(HANDLE)_beginthread(RunCxImageThread,0,this);
}
//////////////////////////////////////////////////////////////////////////////
void CDemoDoc::OnCximageMirror()