imageprocview.cpp

用内存设备上下文实现图像选中区域 的判断

	}
	for(int i=0;i<=level;i++)
	{
		if(lum[i]>20)
		{
			*minLum=min(i,*minLum);
			*maxLum=max(i,*maxLum);
		}
	}

	for(th=0;th<=level;th++)
	{
		noudo1=noudo2=0;
		gasosu1=gasosu2=0;
		for(y=0;y<wDIBHeight;y++)
		{
			for(x=0;x<wDIBWidth;x++)
			{				
				if(inArray[y][x]<th)
				{
					gasosu1++;
					noudo1+=inArray[y][x];
				}
				if(inArray[y][x]>=th)
				{
					gasosu2++;
					noudo2+=inArray[y][x];
				}
			}
		}
		
		if(gasosu1>0)
			mean1=(float)noudo1/gasosu1;
		else
			mean1=0;
		if(gasosu2>0)
			mean2=(float)noudo2/gasosu2;
		else
			mean2=0;
		bunsan[th]=(float)gasosu1*gasosu2*(mean1-mean2)*(mean1-mean2);
	}
	bmax=bunsan[0];
	thresh=0;
	for(th=1;th<=level;th++)
	{
		if(bmax<bunsan[th])
		{
			bmax=bunsan[th];
			thresh=th;
		}
	}
	return thresh;
}



CDC* CImageProcView::PaintBegin(CDC *pDC)
{
	m_pMemDC=new CDC;
	m_pMemDC->CreateCompatibleDC(pDC);
	if(hdib==NULL)
		return NULL;
	LPBYTE lpDIB=(LPBYTE)GlobalLock(hdib);
	if(lpDIB==NULL)
		return NULL;
	GlobalUnlock(hdib);
	m_hBitmap=DIBToDIBSection(lpDIB);
	if(m_hBitmap==NULL)
		return NULL;
	m_pBitmap=new CBitmap;
	m_pBitmap->Attach(m_hBitmap);
	m_pPaletteTmp=m_pMemDC->SelectPalette(pPalette,TRUE);
	m_pMemDC->RealizePalette();
	m_pBitmapTmp=(CBitmap*)m_pMemDC->SelectObject(m_pBitmap);
	return m_pMemDC;
}

void CImageProcView::PaintEnd()
{
	HPALETTE hPal;
	m_pMemDC->SelectObject(m_pBitmapTmp);
	m_pMemDC->SelectPalette(m_pPaletteTmp,TRUE);
	delete m_pMemDC;
	
	if(!m_hBitmap)
		return;
	HDIB hDib=DIBSectionToDIB(m_hBitmap);
	if(!hDib)
		return;
	if(hdib!=NULL)
		GlobalFree(hdib);
	hdib=hDib;
	CImageProcDoc* pDoc=GetDocument();
	ASSERT_VALID(pDoc);
	pDoc->m_hdib=hdib;

	//if(pPalette!=NULL)
	//{
	//	delete pPalette;
	//	pPalette=NULL;
	//}	
	if(::CreateDIBPalette(hdib,&hPal)==NULL)	
		return;
	pPalette=CPalette::FromHandle(hPal);
	
	if(m_pBitmap!=NULL)
	{
		delete m_pBitmap;
		m_pBitmap=NULL;
		m_hBitmap=NULL;
	}
	LPBYTE lpDIB=(LPBYTE)GlobalLock(hdib);
	if(lpDIB==NULL)
		return;
	GlobalUnlock(hdib);
	m_hBitmap=DIBToDIBSection(lpDIB);
	if(m_hBitmap==NULL)
		return;
	m_pBitmap=new CBitmap;
	m_pBitmap->Attach(m_hBitmap);
}

CDC* CImageProcView::PaintBeginS(CDC *pDC)
{
	m_pMemDC=new CDC;
	m_pMemDC->CreateCompatibleDC(pDC);
	if(hdibS==NULL)
		return NULL;
	LPBYTE lpDIB=(LPBYTE)GlobalLock(hdibS);
	if(lpDIB==NULL)
		return NULL;
	GlobalUnlock(hdibS);
	m_hBitmapS=DIBToDIBSection(lpDIB);
	if(m_hBitmapS==NULL)
		return NULL;
	m_pBitmapS=new CBitmap;
	m_pBitmapS->Attach(m_hBitmapS);
	//m_pPaletteTmpS=m_pMemDC->SelectPalette(pPalette,TRUE);
	//m_pMemDC->RealizePalette();
	m_pBitmapTmp=(CBitmap*)m_pMemDC->SelectObject(m_pBitmapS);
	return m_pMemDC;
}

void CImageProcView::PaintEndS()
{
//	HPALETTE hPal;
	m_pMemDC->SelectObject(m_pBitmapTmp);
//	m_pMemDC->SelectPalette(m_pPaletteTmp,TRUE);
	delete m_pMemDC;
	
	if(!m_hBitmapS)
		return;
	HDIB hDib=DIBSectionToDIB(m_hBitmapS);
	if(!hDib)
		return;
	if(hdibS!=NULL)
		GlobalFree(hdibS);
	hdibS=hDib;
//	CImageProcDoc* pDoc=GetDocument();
//	ASSERT_VALID(pDoc);
//	pDoc->m_hdib=hdib;

	//if(pPalette!=NULL)
	//{
	//	delete pPalette;
	//	pPalette=NULL;
	//}	
//	if(::CreateDIBPalette(hdib,&hPal)==NULL)	
//		return;
//	pPalette=CPalette::FromHandle(hPal);
	
	if(m_pBitmapS!=NULL)
	{
		delete m_pBitmapS;
		m_pBitmapS=NULL;
		m_hBitmapS=NULL;
	}
	/*
	LPBYTE lpDIB=(LPBYTE)GlobalLock(hdibS);
	if(lpDIB==NULL)
		return;
	GlobalUnlock(hdibS);
	m_hBitmapS=DIBToDIBSection(lpDIB);
	if(m_hBitmapS==NULL)
		return;
	m_pBitmapS=new CBitmap;
	m_pBitmapS->Attach(m_hBitmap);
	*/
}





void CImageProcView::OnMouseMove(UINT nFlags, CPoint point) 
{
	CPoint refPoint=CImageProcView::GetScrollPosition();
	//point.x+=refPoint.x;
	//point.y+=refPoint.y;
	
	if(bSelectPoly)
	{
		if(GetCapture()!=this)
			return;
		CClientDC dc(this);
		CPen pen(PS_DOT,1,RGB(0,0,0));
		CPen *pOldPen=dc.SelectObject(&pen);
	
		dc.MoveTo(m_oldPointS);
		dc.LineTo(point);	
		dc.SelectObject(pOldPen);
		m_pointS[m_nPoints].x=point.x+refPoint.x;
		m_pointS[m_nPoints].y=point.y+refPoint.y;
		m_pointSL[m_nPoints].x=point.x;
		m_pointSL[m_nPoints].y=point.y;
		m_oldPointS=point;
		m_nPoints++;
	}
	CScrollView::OnMouseMove(nFlags, point);
}





















void CImageProcView::OnUpdateProcBina(CCmdUI* pCmdUI) 
{
	if(hdib==NULL)
		pCmdUI->Enable(FALSE);
	else
		pCmdUI->Enable(TRUE);
}
















void CImageProcView::RinkAft(BYTE inArray[1024][768],BYTE outArray[1024][768],const WORD wDIBWidth,const WORD wDIBHeight)
{
    int x,y,nr;
	for (y=0;y<wDIBHeight-1;y++)
	{
		for(x=0;x<wDIBWidth-1;x++)
		{
			if(inArray[y][x]==255)
				inArray[y][x]=0;
			else
				inArray[y][x]=1;
		}
	}

	for (y=0;y<wDIBHeight-1;y++)
	{
		for(x=0;x<wDIBWidth-1;x++)
			outArray[y][x]=inArray[y][x];
	}
	for (y=1;y<wDIBHeight-1;y++)
	{
		for(x=1;x<wDIBWidth-1;x++)
		{
			if(outArray[y][x]==0) continue;
			nr=inArray[y-1][x]*inArray[y][x-1]*inArray[y][x+1]
				*inArray[y+1][x];
			if(nr!=0)     outArray[y][x]=0;
		}
	}

	for (y=0;y<wDIBHeight-1;y++)
	{
		for(x=0;x<wDIBWidth-1;x++)
		{
		//	if(inArray[y][x]==0)
		//		inArray[y][x]=255;
		//	else
		//		inArray[y][x]=0;
			if(outArray[y][x]==1)
				outArray[y][x]=0;
			else
				outArray[y][x]=255;
		}
	}
}

void CImageProcView::OnThreshChanged()
{
	HPALETTE hPal;
	BeginWaitCursor();
	//HDIB hNewDib;
	DWORD dwDIBSize,dwImageSize;
	//BYTE iArray[256],oArray[256];
	if(!m_hdibPrebina)
	{
		EndWaitCursor();
		return;
	}
	LPBITMAPINFOHEADER lpDibPrebina=(LPBITMAPINFOHEADER)GlobalLock(m_hdibPrebina);
	if(!lpDibPrebina)
	{
		EndWaitCursor();
		return;
	}
	if(hdib!=NULL)
		GlobalFree(hdib);
	hdib=NULL;
	WORD wDIBWidth=(WORD)::DIBWidth((LPSTR)lpDibPrebina)+1;
	WORD wDIBHeight=(WORD)::DIBHeight((LPSTR)lpDibPrebina)+1;
	
	dwDIBSize=*(LPDWORD)lpDibPrebina +DIBNumColors((LPSTR)lpDibPrebina) *sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER);
	WORD wBytesPerLine =(WORD)BytesPerLine(lpDibPrebina);
	dwImageSize=wBytesPerLine*wDIBHeight;
	dwDIBSize+=dwImageSize;

	hdib=(HDIB)GlobalAlloc(GHND,dwDIBSize);
	if(!hdib)
	{
		EndWaitCursor();
		return;
	}

	LPBYTE lpBI=(LPBYTE)GlobalLock(hdib);
	memcpy(lpBI,lpDibPrebina,dwDIBSize);
	
	LPBYTE lpDIBBits=(LPBYTE)FindDIBBits((LPSTR)lpBI);	
//	LPBYTE lpDestDIBBits=FindDIBBits(lpDestImage);


	for(int i=0;i<wDIBHeight-1;i++)
	{
		for(int j=0;j<wDIBWidth-1;j++)
		{
			if(bSelectPoly)
			{
				LPBITMAPINFOHEADER lpBIS=(LPBITMAPINFOHEADER)GlobalLock(hdibS);
				if(!lpBIS)
				{
					return;
				}
				LPBYTE lpDIBBitsS=(LPBYTE)FindDIBBits((LPSTR)lpBIS);
				BYTE value;			
				LONG lOffsetS=PIXEL_OFFSET(i,j,wBytesPerLine);
				value=*(lpDIBBitsS+lOffsetS);
				if(value!=0)
					continue;
			}
			BYTE blue,green,red,newvalue;			
			LONG lOffset=PIXEL_OFFSET(i,j,wBytesPerLine);
			LONG lDestOffset=lOffset;// lpDestOffset for color fading
			blue=*(lpDIBBits+lOffset++);
			green=*(lpDIBBits+lOffset++);
			red=*(lpDIBBits+lOffset);

			newvalue=(BYTE)(0.30*red+0.59*green+0.11*blue);

			BYTE destvalue=(newvalue>m_thresh)?255:0;
		//	BYTE destvalue=(newvalue>thresh)?255:0;
			iArray[i][j]=destvalue;
			(BYTE)(*(lpDIBBits+lDestOffset++))=destvalue;			
			(BYTE)(*(lpDIBBits+lDestOffset++))=destvalue;
			(BYTE)(*(lpDIBBits+lDestOffset))=destvalue;			
		}
	}
	GlobalUnlock(hdib);
	CImageProcDoc* pDoc=GetDocument();
	ASSERT_VALID(pDoc);

	pDoc->m_hdib=hdib;
	if(::CreateDIBPalette(hdib,&hPal)==NULL)
	{
		MessageBox("Can not Create palette",NULL,MB_OK);
		Invalidate();
	}
	else
	{
		pPalette=CPalette::FromHandle(hPal);
		Invalidate();
	}
}






void CImageProcView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{
	// TODO: Add your specialized code here and/or call the base class
}























void CImageProcView::OnSelectPoly() 
{
	bSelectPoly=TRUE;

	DWORD dwDIBSize,dwImageSize;
	//BYTE iArray[256],oArray[256];
	if(!hdib)
	{
		return;
	}
	LPBITMAPINFOHEADER lpBI=(LPBITMAPINFOHEADER)GlobalLock(hdib);
	if(!lpBI)
	{
		return;
	}
	WORD wDIBWidth=(WORD)::DIBWidth((LPSTR)lpBI);
	WORD wDIBHeight=(WORD)::DIBHeight((LPSTR)lpBI);
	if(wDIBWidth>1024||wDIBHeight>768)
	{
		MessageBox("图像象素点过多，无法处理！","Warning",MB_OK|MB_ICONSTOP);
		GlobalUnlock(hdib);
		lpBI=NULL;
		return;
	}
	if(hdibS!=NULL)
	{
		GlobalFree(hdibS);
		hdibS=NULL;
	}
	
	dwDIBSize=*(LPDWORD)lpBI +DIBNumColors((LPSTR)lpBI) *sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER);
	WORD wBytesPerLine =(WORD)BytesPerLine(lpBI);
	dwImageSize=wBytesPerLine*wDIBHeight;
	dwDIBSize+=dwImageSize;

	hdibS=(HDIB)GlobalAlloc(GHND,dwDIBSize);
	if(!hdibS)
	{
		return;
	}

	LPBYTE lpPrebinaImage=(LPBYTE)GlobalLock(hdibS);
	memcpy(lpPrebinaImage,lpBI,dwDIBSize);
	
	LPBYTE lpDIBBits=(LPBYTE)FindDIBBits((LPSTR)lpPrebinaImage);	
//	LPBYTE lpDestDIBBits=FindDIBBits(lpDestImage);

	for(int i=0;i<wDIBHeight-1;i++)
	{
		for(int j=0;j<wDIBWidth-1;j++)
		{			
			LONG lOffset=PIXEL_OFFSET(i,j,wBytesPerLine);			
			(BYTE)(*(lpDIBBits+lOffset++))=255;
			(BYTE)(*(lpDIBBits+lOffset++))=255;
			(BYTE)(*(lpDIBBits+lOffset))=255;		
		}
	}

	HCURSOR hCursor = AfxGetApp()->LoadStandardCursor(IDC_CROSS);
	//::SetCursor(hCursor);
	::SetClassLong(GetSafeHwnd(),GCL_HCURSOR,(LONG)hCursor);

}

void CImageProcView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	if(bSelectPoly)
	{
		this->Invalidate();
		bSelectPoly=FALSE;
		m_nPoints=0;
		if(hdibS!=NULL)
		{
			GlobalFree(hdibS);
			hdibS=NULL;
		}
	}
	HCURSOR hCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
	//::SetCursor(hCursor);
	::SetClassLong(GetSafeHwnd(),GCL_HCURSOR,(LONG)hCursor);

	CScrollView::OnRButtonDown(nFlags, point);
}

void CImageProcView::OnUpdateSelectPoly(CCmdUI* pCmdUI) 
{
	if(hdib==NULL)
		pCmdUI->Enable(FALSE);
	else
		pCmdUI->Enable(TRUE);
}