iprocesspview.cpp

VC＋＋ using in image processing

void CIProcessPView::Zoom(int n)                   
{
  	struct	IMAGEPARAMENT P;

	GetImageParament(pImg[0],&P);              
	if (m_nSize>0)
	{
		if (P.nWidth*m_nSize>2500) 
		{
			m_nSize--;
			return;
		}
  	}
	else
	{
		if (P.nWidth/(-m_nSize)<50) 
		{
			m_nSize++;
			return;
		}
  	}

	if (n==1) {
		m_nSize++;                               
		if (m_nSize==-1)
			m_nSize=1;
	}
	else {
		m_nSize--;                               
		if (m_nSize==0)
			m_nSize=-2;
	}

	if (ImageType(pImg[0])<2)
		LowTypeToIndex(pImg[2],pImg[0]);
	else
		ImageCopy(pImg[2],pImg[0]);
 
	if (m_nSize>0)
 		ZoomIn(pImg[1],pImg[2],m_nSize);
 	else
  		ZoomOut(pImg[1],pImg[2],-m_nSize);

	OnClearWindow();                               
	WorkCanvusToWindow();                      
}

void CIProcessPView::OnZoomIn()                     
{
	Zoom(1);
}

void CIProcessPView::OnZoomOut()                     
{
	Zoom(2);
}

void CIProcessPView::OnImageScale()
{
  	struct	IMAGEPARAMENT P;

	GetImageParament(pImg[1],&P);              
	if ((P.nWidth>2500)||(P.nHeight>2500)) return;

	ImageCopy(pImg[2],pImg[1]);
 	ImageScale(pImg[1],pImg[2],m_fTheta);
 	OnClearWindow();                               
	WorkCanvusToWindow();                      
}

void CIProcessPView::OnImageRotate()
{
	ImageCopy(pImg[2],pImg[1]);
 	ImageRotate(pImg[1],pImg[2],m_fAlpha);
 	OnClearWindow();                               
	WorkCanvusToWindow();                      
}

void CIProcessPView::OnIndexImage()
{
	CString	str1;
 
	if (ImageType(pImg[0])>=3) return;        
	LowTypeToIndex(pImg[0],pImg[0]);                

	str1.Format(" 的索引图像"); 
	WriteTitle(pImg[1],m_FileName,str1);                 
 	ImageCopy(pImg[1],pImg[0]);                              
   	WorkCanvusToWindow();                      
	m_nSize=1;
}

void RectParament(int x1,int y1,int x2,int y2,POINT *pLT,POINT *pRB)
{
	pLT->x=x1;		pRB->x=x2;
	if (x1>x2)
	{
		pLT->x=x2;		pRB->x=x1;
	}
	pLT->y=y1;		pRB->y=y2;
	if (y1>y2)
	{
		pLT->y=y2;		pRB->y=y1;
	}
}

void CIProcessPView::OnAreaSelect()
{
   	OnRefresh();
	if (!pImg[3]->IsNull()) 
		pImg[3]->Destroy();
	m_nFlag=ID_AREA_SELECT;
	m_nFArea=0;
}

void CIProcessPView::OnLButtonDown(UINT nFlags, CPoint point)
{
 	if ((m_nFlag==ID_AREA_SELECT)&&(m_nFArea==0))
	{
		m_iFirstX  = m_iSecondX = point.x;
		m_iFirstY  = m_iSecondY = point.y;
		m_nFArea=1;
	}
 	else if (m_nFArea==2)
	{
		if ((point.x<m_iFirstX)||(point.y<m_iFirstY)||
			(point.x>m_iSecondX)||(point.y>m_iSecondY)) return;

 		if (m_nFlag==ID_AREA_WANDER)
		{
			m_iPrevX1 = m_iFirstX;
			m_iPrevY1 = m_iFirstY;
			m_iPrevX2 = point.x;
			m_iPrevY2 = point.y;
 	    }
 		else if (m_nFlag==ID_AREA_MOVE)
		{
			m_iPrevX1 = m_iFirstX;
			m_iPrevY1 = m_iFirstY;
			m_iPrevX2 = m_iPrevX1-point.x;
			m_iPrevY2 = m_iPrevY1-point.y;
 	    }
 		m_nFArea=3;
 	}
 	CWnd::OnLButtonDown(nFlags, point);
}

void CIProcessPView::OnLButtonUp(UINT nFlags, CPoint point)
{
	CClientDC	dc(this);
	POINT		pt1,pt2;
	CPen		penYellow(PS_SOLID,1,RGB(255,255,0)),*pOldPen;

	if ((m_nFlag==ID_AREA_SELECT)&&(m_nFArea==1))
	{
		RectParament(m_iFirstX,m_iFirstY,point.x,point.y,&pt1,&pt2);
		m_iFirstX  = pt1.x;
		m_iFirstY  = pt1.y;
		m_iSecondX = pt2.x;
		m_iSecondY = pt2.y;
 		m_nFArea=2;
		m_nFlag=0;
	}
 	else if (m_nFArea==3)
	{
 		if ((m_nFlag==ID_AREA_WANDER)||(m_nFlag==ID_AREA_MOVE))
		{
 			pOldPen = dc.SelectObject(&penYellow);
 			dc.MoveTo(m_iFirstX, m_iFirstY);
			dc.LineTo(m_iSecondX,m_iFirstY);
			dc.LineTo(m_iSecondX,m_iSecondY);
			dc.LineTo(m_iFirstX, m_iSecondY);
			dc.LineTo(m_iFirstX, m_iFirstY);
 			dc.SelectObject(pOldPen);
			penYellow.DeleteObject();

			m_nFArea=2;
 	    }
 	}
	if (m_nFlag==ID_PIXEL_VALUE)
 		DisplayValue(point.x,point.y,1);         
 	CWnd::OnLButtonUp(nFlags, point);
}

void CIProcessPView::OnMouseMove(UINT nFlags, CPoint point)
{
	CClientDC	dc(this);
 	struct		IMAGEPARAMENT P;
	int			x,y,Dx,Dy;
	POINT		pt1,pt2;
  	HDC			hMemDC;
	CPen		penYellow(PS_SOLID,1,RGB(255,255,0)),*pOldPen;
 
	GetImageParament(&WorkCanvus,&P);
 	if ((m_nFlag==ID_AREA_SELECT)&&(m_nFArea==1))
	{
   		hMemDC=WorkCanvus.GetDC();
   		SaveCanvus.BitBlt(hMemDC,0,m_iFirstY,P.nWidth,1,0,m_iFirstY,SRCCOPY);
 		SaveCanvus.BitBlt(hMemDC,0,m_iSecondY,P.nWidth,1,0,m_iSecondY,SRCCOPY);
 		SaveCanvus.BitBlt(hMemDC,m_iFirstX,0,1,P.nHeight,m_iFirstX,0,SRCCOPY);
 		SaveCanvus.BitBlt(hMemDC,m_iSecondX,0,1,P.nHeight,m_iSecondX,0,SRCCOPY);
 		WorkCanvus.ReleaseDC();
		m_iSecondX = point.x;
		m_iSecondY = point.y;

		RectParament(m_iFirstX,m_iFirstY,point.x,point.y,&pt1,&pt2);
		if (P.nBitCount>8)
			DrawBox(&WorkCanvus,pt1.x,pt1.y,pt2.x-pt1.x+1,pt2.y-pt1.y+1,1,0xffff00);
  		WorkCanvusToWindow(); 
		if (P.nBitCount==8) {
 			pOldPen = dc.SelectObject(&penYellow);
			dc.MoveTo(pt1.x,pt1.y);
			dc.LineTo(pt2.x,pt1.y);
			dc.LineTo(pt2.x,pt2.y);
			dc.LineTo(pt1.x,pt2.y);
			dc.LineTo(pt1.x,pt1.y);
			dc.SelectObject(pOldPen);
			penYellow.DeleteObject();
		}
	}
 	if (m_nFArea==3)
	{
 		RectParament(m_iFirstX,m_iFirstY,m_iSecondX,m_iSecondY,&pt1,&pt2);
		Dx=pt2.x-pt1.x+1;
		Dy=pt2.y-pt1.y+1;
 		if (m_nFlag==ID_AREA_WANDER)
		{
			x=m_iPrevX1+(m_iPrevX2-point.x);
			y=m_iPrevY1+(m_iPrevY2-point.y);
			if (x<0) x=0;
			if (y<0) y=0;
			if (x>P.nWidth-Dx) x=P.nWidth-Dx;
			if (y>P.nHeight-Dy) y=P.nHeight-Dy;
 
			SaveCanvus.BitBlt(dc,pt1.x,pt1.y,Dx,Dy,x,y,SRCCOPY);

 			pOldPen = dc.SelectObject(&penYellow);
			dc.MoveTo(m_iFirstX, m_iFirstY);
			dc.LineTo(m_iSecondX,m_iFirstY);
			dc.LineTo(m_iSecondX,m_iSecondY);
			dc.LineTo(m_iFirstX, m_iSecondY);
			dc.LineTo(m_iFirstX, m_iFirstY);
 			dc.SelectObject(pOldPen);
			penYellow.DeleteObject();
 	    }
 		else if (m_nFlag==ID_AREA_MOVE)
		{
  			hMemDC=WorkCanvus.GetDC();
 			SaveCanvus.BitBlt(hMemDC,m_iPrevX1,m_iPrevY1,Dx,Dy,
				                   m_iPrevX1,m_iPrevY1,SRCCOPY);
 			m_iPrevX1 = m_iPrevX2+point.x;
			m_iPrevY1 = m_iPrevY2+point.y;
  			SaveCanvus.BitBlt(hMemDC,m_iPrevX1,m_iPrevY1,Dx,Dy,
				                   m_iFirstX,m_iFirstY,SRCCOPY);
			WorkCanvus.ReleaseDC();
   			WorkCanvusToWindow();
		}
  	}
	if (m_nFlag==ID_PIXEL_VALUE)
 		DisplayValue(point.x,point.y,2);         
	CWnd::OnMouseMove(nFlags, point);
}

void CIProcessPView::OnAreaCut()
{
 	POINT		pt1,pt2;
 
	if (m_nFArea==2)
	{
		OnRefresh();
		OnAreaCopy();
  		RectParament(m_iFirstX,m_iFirstY,m_iSecondX,m_iSecondY,&pt1,&pt2);
		RectFillValue(&WorkCanvus,pt1.x,pt1.y,pt2.x-pt1.x+1,pt2.y-pt1.y+1,0xffffff);
 		WorkCanvusToWindow();
	}
}

void CIProcessPView::OnBitmapCopy()
{
	CClientDC	dc(this);
	POINT		pt1,pt2;
	int			i,j,m,n,Dx,Dy;

	if (m_nFArea==2)
	{
		OnRefresh();
  		RectParament(m_iFirstX,m_iFirstY,m_iSecondX,m_iSecondY,&pt1,&pt2);
		Dx=pt2.x-pt1.x+1;
		Dy=pt2.y-pt1.y+1;

 		m=1024/Dx+1;
		n=650/Dy+1;
		for (i=0;i<n;i++)
		{
  			for (j=0;j<m;j++)
				SaveCanvus.BitBlt(dc,j*Dx,i*Dy,Dx,Dy,pt1.x,pt1.y,SRCCOPY);
		}
 	}
}

void CIProcessPView::OnAreaBrowse()
{
 	CClientDC	dc(this);
	POINT		pt1,pt2;
 	int			Dx,Dy;
	CPen		penYellow(PS_SOLID,1,RGB(255,255,0)),*pOldPen;
 
	OnRefresh();

	RectParament(m_iFirstX,m_iFirstY,m_iSecondX,m_iSecondY,&pt1,&pt2);
	Dx=pt2.x-pt1.x+1;
	Dy=pt2.y-pt1.y+1;
 	SaveCanvus.BitBlt(dc,pt1.x,pt1.y,Dx,Dy,pt1.x,pt1.y,SRCCOPY);

 	pOldPen =dc.SelectObject(&penYellow);
	dc.MoveTo(m_iFirstX, m_iFirstY);
	dc.LineTo(m_iSecondX,m_iFirstY);
	dc.LineTo(m_iSecondX,m_iSecondY);
	dc.LineTo(m_iFirstX, m_iSecondY);
	dc.LineTo(m_iFirstX, m_iFirstY);
	dc.SelectObject(pOldPen);
	penYellow.DeleteObject();

	m_nFlag=ID_AREA_WANDER;
	m_iPrevX1=m_iPrevY1=0;
}

void CIProcessPView::OnAreaMove()
{
	CClientDC	dc(this);
	CPen		penYellow(PS_SOLID,1,RGB(255,255,0)),*pOldPen;
 
	OnRefresh();
 	pOldPen =dc.SelectObject(&penYellow);
	dc.MoveTo(m_iFirstX, m_iFirstY);
	dc.LineTo(m_iSecondX,m_iFirstY);
	dc.LineTo(m_iSecondX,m_iSecondY);
	dc.LineTo(m_iFirstX, m_iSecondY);
	dc.LineTo(m_iFirstX, m_iFirstY);
	dc.SelectObject(pOldPen);
	penYellow.DeleteObject();

	m_nFlag=ID_AREA_MOVE;
	m_iPrevX1=m_iPrevY1=0;
}

void CIProcessPView::OnPixelValue()                  
{
	CClientDC	dc(this);
  	struct		IMAGEPARAMENT P;
 	RGBQUAD		ColorTab[256];
  	char	*textbuf[]={"在图像上用鼠标选择所需像素",
	                    "按鼠标左键冻结当前像素数据",
	                    "        (数据用十六进制表示)",
	                    "       图像调色板",
	                    "真彩色图像无调色板"};
  
	OnRefresh();
 
 	dc.SelectStockObject(WHITE_PEN);
	dc.SelectStockObject(WHITE_BRUSH);
	dc.Rectangle(520,0,1023,639);

	if (SaveCanvus.GetBPP()<=8) 
	{
		GetImageParament(&SaveCanvus,&P);
		GetAllPalette(&SaveCanvus,ColorTab);
  		DisplayPalette(ColorTab,P.nNumColors,604,50,10,10);
		dc.TextOut(610,20,textbuf[3]);
	}
	else 
		dc.TextOut(590,50,textbuf[4]);

	for (int i=0;i<3;i++)
		dc.TextOut(560,235+i*30,textbuf[i]);

	m_nFlag=ID_PIXEL_VALUE;                      
}

void CIProcessPView::DisplayValue(int x,int y,int n)       
{
	CClientDC	dc(this);
 	DWORD		k,v,xs,ys;
	DWORD		i,tab[6];
	RGBQUAD		ColorTab[256];
	char		*textbuf[]={"Value","Red","Green","Blue","Color"};
	CString		str;
   	struct		IMAGEPARAMENT P;
	CBrush		NewBrush,*pOldBrush;
  
	if (!InImage(&SaveCanvus,x,y))  return;
  	GetImageParament(pImg[1],&P);            
    
 	v=GetPixelValue(pImg[1],x,y);            
    if (n==2) xs=560;		
	else      xs=720;
	ys=340;
 	if (P.nBitCount<=8)                               
	{
  		pImg[1]->GetColorTable(0,P.nNumColors,ColorTab);    
		memcpy(&k,&ColorTab[v],4);               
	}
	else  k=v;

 	for (i=0;i<5;i++)
	{
		dc.TextOut(xs,ys+80+25*i,textbuf[i]);
	}
	tab[0]= v;                                   
	tab[1]=(k & 0xff0000) >> 16;                 
	tab[2]=(k & 0xff00) >> 8;                    
	tab[3]=(k & 0xff);                           
	tab[4]=pImg[1]->GetPixel(x,y);

  	NewBrush.CreateSolidBrush(RGB(tab[1],tab[2],tab[3]));
    pOldBrush = dc.SelectObject(&NewBrush);
    dc.Rectangle(xs+8,ys,xs+8+60,ys+60);
    dc.SelectObject(pOldBrush);
 
	for (i=0;i<5;i++)
	{
		if ((P.nBitCount>8)&&(i==0)||(i==4))
			str.Format("%06X    ",tab[i]);
		else
			str.Format("%X    ",tab[i]);
		dc.TextOut(xs+64,ys+80+25*i,str);
	}
}

void CIProcessPView::DisplayPalette(RGBQUAD *ColorTab,int nNumColors,int x,int y,int w,int h)
{                                                       
 	struct		IMAGEPARAMENT P;
	CImage		Img;
  	int			i,j;
	CClientDC	dc(this);

  	Img.Create(16*w+1,16*h+1,8,0);
 
 	SetAllPalette(&Img,ColorTab);

	if (nNumColors<20) 
	{
		SetPalette(&Img,20,192,192,192);
		RectFillValue(&Img,0,0,16*w+1,16*h+1,20);               
	}
	else 
		RectFillValue(&Img,0,0,16*w+1,16*h+1,7); 
	for (i=0;i<16;i++)
	{
		for (j=0;j<16;j++)
			if (i*16+j<nNumColors)
				RectFillValue(&Img,j*w+1,i*h+1,w-1,h-1,i*16+j);  
	}

 	GetImageParament(&Img,&P);
 	Img.BitBlt(dc,x,y,P.nWidth,P.nHeight,0,0,SRCCOPY);
	Img.Destroy();
}

void CIProcessPView::OnAreaCopy()
{
	CClientDC	dc(this);
	POINT		pt1,pt2;
	int			Dx,Dy;
	RGBQUAD		ColorTab[256];
	HDC			hMemDC;

	if (m_nFArea==2)
	{
		RectParament(m_iFirstX,m_iFirstY,m_iSecondX,m_iSecondY,&pt1,&pt2);
		Dx=pt2.x-pt1.x+1;
		Dy=pt2.y-pt1.y+1;

		if (!pImg[3]->IsNull()) 
			pImg[3]->Destroy();
		pImg[3]->Create(Dx,Dy,SaveCanvus.GetBPP(),0);

		if (SaveCanvus.GetBPP()==8) {
			GetAllPalette(&SaveCanvus,ColorTab);
			SetAllPalette(pImg[3],ColorTab);
		}

 		hMemDC = pImg[3]->GetDC();
		SaveCanvus.BitBlt(hMemDC,0,0,Dx,Dy,pt1.x,pt1.y,SRCCOPY);
		pImg[3]->ReleaseDC();
   	}
}

void CIProcessPView::OnAreaPaste()
{
	CClientDC	dc(this);
	struct		IMAGEPARAMENT  P;	
	int			x,y,k;
 
 	GetImageParament(pImg[3],&P);
	k=WorkCanvus.GetWidth();
	x=k+30;
	y=30;
	pImg[3]->BitBlt(dc,x,y,P.nWidth,P.nHeight,0,0,SRCCOPY);
}

void CIProcessPView::OnDefaultPalette()
{
   	int		i,j,x,y,w,h,m,n,r,g,b;
	CDC		*pDC;
	CString	str;
 
	if (!SaveCanvus.IsNull()) 
		SaveCanvus.Destroy();
 	SaveCanvus.Create(800,600,8,0);
	SetDefaultPalette(&SaveCanvus);

	RectFillValue(&SaveCanvus,0,0,800,600,15); 
	DrawBox(&SaveCanvus,0,0,800,600,1,0);
	x=112;
	y=40;
	w=36;
	h=34;
	RectFillValue(&SaveCanvus,x-1,y-1,16*w+1,16*h+1,7); 
	for (i=0;i<16;i++)
	{
		for (j=0;j<16;j++)
 			RectFillValue(&SaveCanvus,x+j*w,y+i*h,w-1,h-1,i*16+j);
	}

	pDC= CDC::FromHandle(SaveCanvus.GetDC());
	for(i=0;i<16;i++)
	{
		str.Format("%X",i);
		pDC->TextOut(x+14+i*w,y-25,str);
		str.Format("%02X",i*16);
		pDC->TextOut(x-35,y+i*h+8,str);
	}

	m=724;		
	n=435;
	i=0x2f;
	DrawBox(&SaveCanvus,m-1,n-54,38,36,1,7);
	RectFillValue(&SaveCanvus,m,n-53,36,34,i);
	GetPalette(&SaveCanvus,i,&r,&g,&b);      
	str.Format("I     %02X",i);
	pDC->TextOut(m,n,str);
	str.Format("R   %02X",r);
	pDC->TextOut(m,n+40,str);
	str.Format("G   %02X",g);
	pDC->TextOut(m,n+65,str);
	str.Format("B   %02X",b);
	pDC->TextOut(m,n+90,str);

	SaveCanvus.ReleaseDC();

	ImageCopy(pImg[1],pImg[0]); 
	m_FileName = "VGA 默认调色板";
	Invalidate();
}