dib.cpp

无线图象监控系统（用VC++编程）用数据库ACCESS存储图象

	CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);
    //LPBITMAPINFO bitmapifo=(LPBITMAPINFO)::GlobalLock((HGLOBAL)m_hDib);
	CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

BOOL bSuccess = pDC->StretchBlt( xDest, yDest, 
								nWidthDest, nHeightDest,
						        &MemDC, 
								xSrc, ySrc, 
								nWidthSrc, nHeightSrc, 
								dwRop);
//BOOL bSuccess =StretchDIBits(pDC->GetSafeHdc(),xDest, yDest, 
								//nWidthDest, nHeightDest,
	                              //xSrc, ySrc, 
								//nWidthSrc, nHeightSrc, 
                                 //GetBitsPtr(),bitmapifo,
								 //DIB_RGB_COLORS,SRCCOPY);

	MemDC.SelectObject(pOldBmp);
	pDC->SelectPalette(pOldPal, TRUE);

	return bSuccess;
}

BOOL CDib::Display(CDC * pDC, int x, int y, DWORD dwRop)
{
	CDC MemDC;
	MemDC.CreateCompatibleDC(pDC);

	CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

	CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

	BOOL bSuccess = pDC->BitBlt(x, y, 
								GetWidth(), GetHeight(),
								&MemDC, 
								0, 0, 
								dwRop);

	MemDC.SelectObject(pOldBmp);
	pDC->SelectPalette(pOldPal, TRUE);

	return bSuccess;
}

BOOL CDib::Display(CDC* pDC, CRect rcDest, CRect rcSrc, DWORD dwRop)
{
	CDC MemDC;
	MemDC.CreateCompatibleDC(pDC);

	CBitmap* pOldBmp = MemDC.SelectObject(m_pBitmap);

	CPalette* pOldPal = pDC->SelectPalette(m_pPalette, TRUE);
    pDC->RealizePalette();

	BOOL bSuccess = pDC->StretchBlt( rcDest.left, rcDest.top, 
								rcDest.Width(), rcDest.Height(),
						        &MemDC, 
								rcSrc.left, rcSrc.top, 
								rcSrc.Width(), rcSrc.Height(),
								dwRop);

	MemDC.SelectObject(pOldBmp);
	pDC->SelectPalette(pOldPal, TRUE);

	return bSuccess;
}

BOOL CDib::BuildBitmap()
{
	if (m_pBitmap != NULL)
	{
		delete m_pBitmap;
		m_pBitmap = NULL;
		m_hBitmap = NULL;
	}
	m_hBitmap = DIBToDIBSection(m_hDib);
	if (m_hBitmap == NULL)
		return FALSE;
	m_pBitmap = new CBitmap;
	m_pBitmap->Attach(m_hBitmap);

	return TRUE;
}

BOOL CDib::BuildPalette()
{
	if (m_pPalette != NULL)
	{
		delete m_pPalette;
		m_pPalette = NULL;
	}
	HPALETTE hPalette = CreateDIBPalette(m_hDib);
	if (hPalette == NULL)
		return FALSE;
	m_pPalette = new CPalette;
	m_pPalette->Attach(hPalette);

	return TRUE;
}

BOOL CDib::UpdateInternal()
{
	BuildPalette();
	return BuildBitmap();
}

CPalette* CDib::GetPalette()
{
	return m_pPalette;
}

CBitmap* CDib::GetBitmap()
{
	return m_pBitmap;
}

BOOL CDib::IsEmpty()
{
	if (m_hDib == NULL)
		return TRUE;

	if (! GlobalLock(m_hDib))
		return TRUE;

	GlobalUnlock(m_hDib);
	return FALSE;
}

DWORD CDib::GetCompression()
{
    LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
    if (!lpBI) 
	{
		GlobalUnlock(m_hDib);
        return 0; 
	}
 
	DWORD dwCompression = lpBI->biCompression;
	GlobalUnlock(m_hDib);

	return dwCompression;
}

WORD CDib::GetBitCount()
{
    LPBITMAPINFOHEADER lpBI = (LPBITMAPINFOHEADER)GlobalLock(m_hDib); 
    if (!lpBI) 
	{
		GlobalUnlock(m_hDib);
        return 0; 
	}
 
	WORD wBitCount = lpBI->biBitCount;
	GlobalUnlock(m_hDib);

	return wBitCount;
}

LONG CDib::GetWidth()
{
	// get DIB buffer pointer
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
	if (! lpDIB)
	{
		GlobalUnlock(m_hDib);
		return 0;
	}

	LONG lWidth = (LONG)DIBWidth(lpDIB);
	GlobalUnlock(m_hDib);

	return lWidth; 
}

LONG CDib::GetHeight()
{
	// get DIB buffer pointer
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
	if (! lpDIB)
	{
		GlobalUnlock(m_hDib);
		return 0;
	}

	LONG lHeight = (LONG)DIBHeight(lpDIB);
	GlobalUnlock(m_hDib);

	return lHeight; 
}

LONG CDib::GetWidthBytes()
{
	return WIDTHBYTES((GetWidth())*((DWORD)GetBitCount()));
}

COLORREF CDib::GetPixel(LONG x, LONG y)
{
	COLORREF cColor;
	switch (GetBitCount())
	{
		case 1 :	if (1<<(7-x%8) & 
						*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)))
						cColor = RGB(255,255,255);
					else
						cColor = RGB(0,0,0);
					break;
		case 4 :	
				{
					PALETTEENTRY PaletteColors[16];
					m_pPalette->GetPaletteEntries(0, 16, PaletteColors);
					int nIndex = (*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)) & 
								   (x%2 ? 0x0f : 0xf0)) >> (x%2 ? 0 : 4);
					cColor = RGB(PaletteColors[nIndex].peRed,
								 PaletteColors[nIndex].peGreen,
								 PaletteColors[nIndex].peBlue);
				}
					break;
		case 8 :	
				{
					PALETTEENTRY PaletteColors[256];
					m_pPalette->GetPaletteEntries(0, 256, PaletteColors);
					int nIndex = *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y));
					cColor = RGB(PaletteColors[nIndex].peRed,
								 PaletteColors[nIndex].peGreen,
								 PaletteColors[nIndex].peBlue);
				}
					break;
		default:	cColor = RGB(*(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)),
								 *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+1),
								 *(BYTE*)(GetBitsPtr()+GetPixelOffset(x, y)+2));
					break;
	}
	return cColor;
}

LONG CDib::GetPixelOffset(LONG x, LONG y)
{
	return (GetHeight()-y-1)*GetWidthBytes()+x/(8/GetBitCount());
}

LPBYTE CDib::GetBitsPtr()
{
    LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
    if (! lpDIB) 
	{
		GlobalUnlock(m_hDib);
		return NULL;
	}

	LPBYTE lpData = FindDIBBits(lpDIB);
	GlobalUnlock(m_hDib);

	return lpData;
}

HANDLE CDib::GetHandle()
{
	return m_hDib;
}

WORD CDib::GetColorNumber()
{
    LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib); 
    if (! lpBI) 
	{
		GlobalUnlock(m_hDib);
		return 0;
	}
 
	WORD wColors = DIBNumColors(lpBI);
	GlobalUnlock(m_hDib);

	return wColors;
}

WORD CDib::GetPaletteSize()
{
    LPBYTE lpBI = (LPBYTE)GlobalLock(m_hDib); 
    if (! lpBI) 
	{
		GlobalUnlock(m_hDib);
		return 0;
	}
 
	WORD wPalSize = PaletteSize(lpBI);
	GlobalUnlock(m_hDib);

	return wPalSize;
}

CDC* CDib::BeginPaint(CDC *pDC)
{
	m_pMemDC = new CDC;
	m_pMemDC->CreateCompatibleDC(pDC);
	m_pPaletteTmp = m_pMemDC->SelectPalette(m_pPalette, TRUE);
	m_pMemDC->RealizePalette();
	m_pBitmapTmp = (CBitmap *)m_pMemDC->SelectObject(m_pBitmap);
	return m_pMemDC;
}

void CDib::EndPaint()
{
	m_pMemDC->SelectObject(m_pBitmapTmp);
	m_pMemDC->SelectPalette(m_pPaletteTmp, TRUE);
	delete m_pMemDC;

	Create(m_hBitmap);
}

BOOL CDib::DisplayPalette(CDC* pDC, CRect rc)
{
	return ::DisplayPalette(pDC->GetSafeHdc(), &rc, (HPALETTE)m_pPalette->GetSafeHandle());
}

CDib * CDib::Clone()
{
	if (m_hDib == NULL)
		return NULL;

	HDIB hDIB = CopyHandle(m_hDib);
	if (hDIB == NULL)
		return NULL;

	CDib *pDib = new CDib;
	pDib->m_hDib = hDIB;
	pDib->BuildPalette();
	pDib->BuildBitmap();

	return pDib;
}


HDIB CDib::ChangeSize(int x)
{


 
 
 LONG lWidth =GetWidth()*x;
 LONG lHeight=GetHeight()*x;
 DWORD dwSize=sizeof(BITMAPINFOHEADER)+GetWidthBytes()*x*lHeight;
 HDIB hNewDIB = GlobalAlloc(GHND, dwSize);
 BYTE* pstrdib=(BYTE*)GlobalLock(hNewDIB);
 BITMAPINFOHEADER* newdibinfo=(BITMAPINFOHEADER*)pstrdib;
 memset(newdibinfo,0,sizeof(BITMAPINFOHEADER));
 newdibinfo->biSize=sizeof(BITMAPINFOHEADER);
 newdibinfo->biPlanes=1;	
 newdibinfo->biBitCount=24;
 newdibinfo->biHeight=lHeight;
 newdibinfo->biWidth=lWidth;
 BYTE* pstr=pstrdib+sizeof(BITMAPINFOHEADER);
 for(long j=0;j<lHeight;j++)
 { 
  for(long i=0;i<lWidth;i++)
 {  
    float m=(float)i/x;
    int mmod=i-floor(m)*x;

    float n=(float)j/x;
    int nmod=j-floor(n)*x;
 LONG   lwidthbyte=GetWidthBytes()*x;
 LONG offset=(lHeight-j-1)*lwidthbyte+i*3;
   if(mmod==0)
   {  
     if(nmod==0)
    {    
 	 
    *(pstr+offset)=GetRValue(GetPixel((LONG)m,(LONG)n));
    *(pstr+1+offset)=GetGValue(GetPixel((LONG)m,(LONG)n));
	*(pstr+2+offset)=GetBValue(GetPixel((LONG)m,(LONG)n));
  	//AfxMessageBox("xunaze1");
    }
          else
	  {
	   *(pstr+offset)=GetRValue(GetPixel((LONG)m,(LONG)floor(n)))+(GetRValue(GetPixel((LONG)m,(LONG)(floor(n)+1)))-GetRValue(GetPixel((LONG)m,(LONG)floor(n))))*(n-floor(n));
 	   *(pstr+offset+1)=GetGValue(GetPixel((LONG)m,(LONG)floor(n)))+(GetGValue(GetPixel((LONG)m,(LONG)(floor(n)+1)))-GetGValue(GetPixel((LONG)m,(LONG)floor(n))))*(n-floor(n));
       *(pstr+2+offset)=GetBValue(GetPixel((LONG)m,(LONG)floor(n)))+(GetBValue(GetPixel((LONG)m,(LONG)(floor(n)+1)))-GetBValue(GetPixel((LONG)m,(LONG)floor(n))))*(n-floor(n));
     //AfxMessageBox("xunaze2");
 	  }
    }
      else
 	 {
 	 if(nmod==0)
 	 {
     *(pstr+offset)=GetRValue(GetPixel((LONG)floor(m),(LONG)n))+(GetRValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetRValue(GetPixel((LONG)floor(m)+1,(LONG)n)))*(m-floor(m));
 	 *(pstr+1+offset)=GetGValue(GetPixel((LONG)floor(m),(LONG)n))+(GetGValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetGValue(GetPixel((LONG)floor(m)+1,(LONG)n)))*(m-floor(m));
	 *(pstr+2+offset)=GetBValue(GetPixel((LONG)floor(m),(LONG)n))+(GetBValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetBValue(GetPixel((LONG)floor(m)+1,(LONG)n)))*(m-floor(m));
 //AfxMessageBox("xunaze3");
 	 }
 	     else
 		 {BYTE up0=GetRValue(GetPixel((LONG)floor(m),(LONG)floor(n)))+(GetRValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetRValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n))))*(n-floor(n));
           BYTE down0=GetRValue(GetPixel((LONG)floor(m),(LONG)floor(n)+1))+(GetRValue(GetPixel((LONG)(floor(m)+1),(LONG)n+1))-GetRValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n)+1)))*(n-floor(n));
 		   *(pstr+offset)=up0+(down0-up0)*(n-floor(n));
            BYTE up1=GetGValue(GetPixel((LONG)floor(m),(LONG)floor(n)))+(GetGValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetGValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n))))*(n-floor(n));
            BYTE down1=GetGValue(GetPixel((LONG)floor(m),(LONG)floor(n)+1))+(GetGValue(GetPixel((LONG)(floor(m)+1),(LONG)n+1))-GetGValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n)+1)))*(n-floor(n));
 		   *(pstr+1+offset)=up1+(down1-up1)*(n-floor(n));
 		  BYTE up3=GetBValue(GetPixel((LONG)floor(m),(LONG)floor(n)))+(GetBValue(GetPixel((LONG)(floor(m)+1),(LONG)n))-GetBValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n))))*(n-floor(n));
            BYTE down3=GetBValue(GetPixel((LONG)floor(m),(LONG)floor(n)+1))+(GetBValue(GetPixel((LONG)(floor(m)+1),(LONG)n+1))-GetBValue(GetPixel((LONG)floor(m)+1,(LONG)floor(n)+1)))*(n-floor(n));
 		   *(pstr+2+offset)=up3+(down3-up3)*(n-floor(n));
           //AfxMessageBox("xunaze4");

 		 } 
	 }
 
 }
if (j>=lHeight-5)
 AfxMessageBox("xunhuan");
 }  
     
     GlobalUnlock(hNewDIB);
AfxMessageBox("xunhuan222"); 
 	 return hNewDIB;
 }

//DEL BYTE CDib::GETR(LONG x, LONG y)

BOOL CDib::Attach(HDIB hDib)
{
if (hDib == NULL)
		return FALSE;
	
	Destroy();
	m_hDib = hDib;
	return UpdateInternal();
}

BOOL CDib::ConvertFormat(WORD wBitCount)
{
	if (IsEmpty())
		return FALSE;

	if (GetBitCount() == wBitCount)
		return TRUE;

	HDIB hNewDib = ConvertDIBFormat(m_hDib, wBitCount, NULL); 
	if (! hNewDib)
		return FALSE;

	Destroy();
	m_hDib = hNewDib;
	return UpdateInternal();
}

BOOL CDib::	ChangeImageSize(int nWidth, int nHeight)
{
	HDIB hNewDib = ChangeDIBSize(m_hDib, nWidth, nHeight);
	if (! hNewDib)
		return FALSE;

	// set to m_hDib
	Destroy();
	m_hDib = hNewDib;

	// return
	return UpdateInternal();
}


BOOL CDib::abssub(CDib *m_dib)
{
LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
    if (! lpDIB) 
	{
		GlobalUnlock(m_hDib);
		return NULL;
	}

	LPBYTE lpData = FindDIBBits(lpDIB);
	GlobalUnlock(m_hDib);
	LPBYTE lpbkData=m_dib->GetBitsPtr();
  long len=m_dib->GetHeight()*m_dib->GetWidthBytes();
    for(long i=0; i<len;i++)
	{int pj=(int)*(lpData+i);
	 int pi=(int)*(lpbkData+i);
	 *(lpData+i)=(BYTE)(abs(pi-pj));
	}
return UpdateInternal();

}

/*函数名称ShadowDelSub(CDib* m_dib)*/
//消除阴影差值图像图像分割程序
BOOL CDib::ShadowDelSub(CDib* m_dib)
{
	LONG len=GetWidth()*GetHeight();
LONG lWidth=GetWidth();
LONG lHeight=GetHeight();
   if(m_dib->GetBitCount()==24 && GetBitCount()==24)
   {//对于彩色图像进行HSI色度空间转换
	BYTE* IC=new BYTE[len];
	double* SC=new double[len];
	double* HC=new double[len];
    BYTE* IB=new BYTE[len];
	double* SB=new double[len];
	double* HB=new double[len];
LPBYTE lpDIB = (LPBYTE)GlobalLock(m_hDib); 
   if (! lpDIB) 
	{
	GlobalUnlock(m_hDib);
	return NULL;
	}
	LPBYTE lpData = GetBitsPtr();
	BYTE kss=lpData[20];
    LPBYTE lpbkData=m_dib->GetBitsPtr();
    GlobalUnlock(m_hDib);
	for(int i=0;i<len;i++)
	{double bc=(double)(*(lpData+i*3));
	 double bb=(double)(*(lpbkData+i*3));
	 double gc=(double)(*(lpData+i*3+1));
	 double gb=(double)(*(lpbkData+i*3+1));
	 double rc=(double)(*(lpData+i*3+2));
	 double rb=(double)(*(lpbkData+i*3+2));
	 //IC[i]=(BYTE)(rc*0.299+gc*0.587+bc*0.114)/3;
	 //IB[i]=(BYTE)(rb*0.299+gb*0.587+bb*0.114)/3;
	 IC[i]=max(max(rc,gc),bc);
	 IB[i]=max(max(rb,gb),bb);
	 //SC[i]=1-3*min(min(rc,gc),bc)/(rc+bc+gc);
	 //SB[i]=1-3*min(min(rb,gb),bb)/(rb+bb+gb);
	 SC[i]=(max(max(rc,gc),bc)-min(min(rc,gc),bc))/max(max(rc,gc),bc);
	 SB[i]=(max(max(rb,gb),bb)-min(min(rb,gb),bb))/max(max(rb,gb),bb);

	if(SC[i]!=0)
	{
	double cos=((rc-gc)+(rc-bc))/(2*sqrt((rc-gc)*(rc-gc)+(rc-bc)*(gc-bc)));
    
	 HC[i]=(bc<=gc)?acos(cos):(2*3.1415926-acos(cos));
	}
	else
		HC[i]=0;
	if(SB[i]!=0)
	{
   double cos=((rb-gb)+(rb-bb))/(2*sqrt((rb-gb)*(rb-gb)+(rb-bb)*(gb-bb)));
	 HB[i]=(bb<=gb)?acos(cos):(2*3.1415926-acos(cos));
	}
	else
		HB[i]=0;
	 /*SC[i]=-0.148*rc+(-0.269)*gc+0.437*bc;
     SB[i]=-0.148*rb+(-0.269)*gb+0.437*bb;
	 HC[i]=0.615*rc+(-0.515)*gc+(-0.1)*bc;
     HB[i]=0.615*rb+(-0.515)*gb+(-0.1)*bb;*/