?? ip.cpp
字號:
r[3] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
b[4] = *(lpDIBits + lOffset++);
g[4] = *(lpDIBits + lOffset++);
r[4] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
b[5] = *(lpDIBits + lOffset++);
g[5] = *(lpDIBits + lOffset++);
r[5] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
b[6] = *(lpDIBits + lOffset++);
g[6] = *(lpDIBits + lOffset++);
r[6] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
b[7] = *(lpDIBits + lOffset++);
g[7] = *(lpDIBits + lOffset++);
r[7] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
b[8] = *(lpDIBits + lOffset++);
g[8] = *(lpDIBits + lOffset++);
r[8] = *(lpDIBits + lOffset);
*red = *green = *blue = 0;
for (int k=0; k<8; ++k)
{
*red += lpKernel->Element[k]*r[k];
*green += lpKernel->Element[k]*g[k];
*blue += lpKernel->Element[k]*b[k];
}
if (lpKernel->Divisor != 1)
{
*red /= lpKernel->Divisor;
*green /= lpKernel->Divisor;
*blue /= lpKernel->Divisor;
}
// getoff opposite
*red = abs(*red);
*green = abs(*green);
*blue = abs(*blue);
}
// local function: perform median filter to DIB
void DoMedianFilterDIB(int *red, int *green, int *blue, int i, int j,
WORD wBytesPerLine, LPBYTE lpDIBits)
{
BYTE b[9], g[9], r[9];
LONG lOffset;
lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
b[0] = *(lpDIBits + lOffset++);
g[0] = *(lpDIBits + lOffset++);
r[0] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
b[1] = *(lpDIBits + lOffset++);
g[1] = *(lpDIBits + lOffset++);
r[1] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
b[2] = *(lpDIBits + lOffset++);
g[2] = *(lpDIBits + lOffset++);
r[2] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
b[3] = *(lpDIBits + lOffset++);
g[3] = *(lpDIBits + lOffset++);
r[3] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
b[4] = *(lpDIBits + lOffset++);
g[4] = *(lpDIBits + lOffset++);
r[4] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
b[5] = *(lpDIBits + lOffset++);
g[5] = *(lpDIBits + lOffset++);
r[5] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
b[6] = *(lpDIBits + lOffset++);
g[6] = *(lpDIBits + lOffset++);
r[6] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
b[7] = *(lpDIBits + lOffset++);
g[7] = *(lpDIBits + lOffset++);
r[7] = *(lpDIBits + lOffset);
lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
b[8] = *(lpDIBits + lOffset++);
g[8] = *(lpDIBits + lOffset++);
r[8] = *(lpDIBits + lOffset);
qsort(r, 9, 1, compare);
qsort(g, 9, 1, compare);
qsort(b, 9, 1, compare);
*red = r[0];
*green = g[0];
*blue = b[0];
}
// function used to sort in the call of qsort
int compare(const void *e1, const void *e2)
{
if (*(BYTE *)e1 < *(BYTE *)e2)
return -1;
if (*(BYTE *)e1 > *(BYTE *)e2)
return 1;
return 0;
}
/*************************************************************************
*
* ReverseDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function reverse DIB
*
************************************************************************/
BOOL ReverseDIB(HDIB hDib)
{
WaitCursorBegin();
HDIB hNewDib = NULL;
// only support 256 grayscale image
WORD wBitCount = DIBBitCount(hDib);
if (wBitCount != 8)
{
WaitCursorEnd();
return FALSE;
}
// the maxium pixel value
int nMaxValue = 256;
// source pixel data
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
if (! lpSrcDIB)
{
WaitCursorBegin();
return FALSE;
}
// new DIB attributes
LPSTR lpPtr;
LONG lHeight = DIBHeight(lpSrcDIB);
LONG lWidth = DIBWidth(lpSrcDIB);
DWORD dwBufferSize = GlobalSize(lpSrcDIB);
int nLineBytes = BytesPerLine(lpSrcDIB);
// convolute...
for (long i=0; i<lHeight; i++)
for (long j=0; j<lWidth; j++)
{
lpPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-i*nLineBytes)+j;
*lpPtr = nMaxValue - *lpPtr;
}
// cleanup
GlobalUnlock(hDib);
WaitCursorEnd();
return TRUE;
}
/*************************************************************************
*
* ErosionDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
* BOOL bHori - erosion direction
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function do erosion with the specified direction
*
************************************************************************/
BOOL ErosionDIB(HDIB hDib, BOOL bHori)
{
// start wait cursor
WaitCursorBegin();
// Old DIB buffer
if (hDib == NULL)
{
WaitCursorEnd();
return FALSE;
}
// only support 256 color image
WORD wBitCount = DIBBitCount(hDib);
if (wBitCount != 8)
{
WaitCursorEnd();
return FALSE;
}
// new DIB
HDIB hNewDIB = CopyHandle(hDib);
if (! hNewDIB)
{
WaitCursorEnd();
return FALSE;
}
// source dib buffer
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
if (! lpSrcDIB)
{
WaitCursorBegin();
return FALSE;
}
// New DIB buffer
LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
if (! lpbmi)
{
WaitCursorBegin();
return FALSE;
}
// start erosion...
LPSTR lpPtr;
LPSTR lpTempPtr;
LONG x,y;
BYTE num, num0;
int i;
LONG lHeight = DIBHeight(lpSrcDIB);
LONG lWidth = DIBWidth(lpSrcDIB);
DWORD dwBufferSize = GlobalSize(lpSrcDIB);
int nLineBytes = BytesPerLine(lpSrcDIB);
if(bHori)
{
for (y=0; y<lHeight; y++)
{
lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
for (x=1; x<lWidth-1; x++)
{
num0 = num = 0 ;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num > num0)
num0 = num;
}
*lpTempPtr=(unsigned char)num0;
/*
num=(unsigned char)*lpPtr;
if (num==0)
{
*lpTempPtr=(unsigned char)0;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num==255)
{
*lpTempPtr=(unsigned char)255;
break;
}
}
}
else
*lpTempPtr=(unsigned char)255;
*/
lpPtr++;
lpTempPtr++;
}
}
}
else // Vertical
{
for (y=1; y<lHeight-1; y++)
{
lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
for (x=0; x<lWidth; x++)
{
num0 = num = 0 ;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num > num0)
num0 = num;
}
*lpTempPtr=(unsigned char)num0;
/*
num=(unsigned char)*lpPtr;
if (num==0)
{
*lpTempPtr=(unsigned char)0;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
if(num==255)
{
*lpTempPtr=(unsigned char)255;
break;
}
}
}
else
*lpTempPtr=(unsigned char)255;
*/
lpPtr++;
lpTempPtr++;
}
}
}
// cleanup
GlobalUnlock(hDib);
GlobalUnlock(hNewDIB);
GlobalFree(hNewDIB);
WaitCursorEnd();
return TRUE;
}
/*************************************************************************
*
* DilationDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
* BOOL bHori - dilation direction
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function do dilation with the specified direction
*
************************************************************************/
BOOL DilationDIB(HDIB hDib, BOOL bHori)
{
// start wait cursor
WaitCursorBegin();
// Old DIB buffer
if (hDib == NULL)
{
WaitCursorEnd();
return FALSE;
}
// only support 256 color image
WORD wBitCount = DIBBitCount(hDib);
if (wBitCount != 8)
{
WaitCursorEnd();
return FALSE;
}
// new DIB
HDIB hNewDIB = CopyHandle(hDib);
if (! hNewDIB)
{
WaitCursorEnd();
return FALSE;
}
// source dib buffer
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
if (! lpSrcDIB)
{
WaitCursorBegin();
return FALSE;
}
// New DIB buffer
LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
if (! lpbmi)
{
WaitCursorBegin();
return FALSE;
}
// start erosion...
LPSTR lpPtr;
LPSTR lpTempPtr;
LONG x,y;
BYTE num, num0;
int i;
LONG lHeight = DIBHeight(lpSrcDIB);
LONG lWidth = DIBWidth(lpSrcDIB);
DWORD dwBufferSize = GlobalSize(lpSrcDIB);
int nLineBytes = BytesPerLine(lpSrcDIB);
if(bHori)
{
for(y=0;y<lHeight;y++)
{
lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
for(x=1;x<lWidth-1;x++)
{
num0 = num = 255;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num < num0)
num0 = num;
}
*lpTempPtr=(unsigned char)num0;
/*
num=(unsigned char)*lpPtr;
if (num==255)
{
*lpTempPtr=(unsigned char)255;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num==0)
{
*lpTempPtr=(unsigned char)0;
break;
}
}
}
else
*lpTempPtr=(unsigned char)0;
*/
lpPtr++;
lpTempPtr++;
}
}
}
else
{
for(y=1;y<lHeight-1;y++)
{
lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
for(x=0;x<lWidth;x++)
{
num0 = num = 255;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+i-1);
if(num < num0)
num0 = num;
}
*lpTempPtr=(unsigned char)num0;
/*
num=(unsigned char)*lpPtr;
if (num==255)
{
*lpTempPtr=(unsigned char)255;
for(i=0;i<3;i++)
{
num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
if(num==0)
{
*lpTempPtr=(unsigned char)0;
break;
}
}
}
else
*lpTempPtr=(unsigned char)0;
*/
lpPtr++;
lpTempPtr++;
}
}
}
// cleanup
GlobalUnlock(hDib);
GlobalUnlock(hNewDIB);
GlobalFree(hNewDIB);
WaitCursorEnd();
return TRUE;
}
/*************************************************************************
*
* MorphOpenDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
* BOOL bHori - open direction
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function do open with the specified direction
*
************************************************************************/
BOOL MorphOpenDIB(HDIB hDib, BOOL bHori)
{
// Step 1: erosion
if (! ErosionDIB(hDib, bHori))
return FALSE;
// Step 2: dilation
if (! DilationDIB(hDib, bHori))
return FALSE;
return TRUE;
}
/*************************************************************************
*
* MorphCloseDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
* BOOL bHori - close direction
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function do close with the specified direction
*
************************************************************************/
BOOL MorphCloseDIB(HDIB hDib, BOOL bHori)
{
// Step 1: dilation
if (! DilationDIB(hDib, bHori))
return FALSE;
// Step 2: erosion
if (! ErosionDIB(hDib, bHori))
return FALSE;
return TRUE;
}
/*************************************************************************
*
* ContourDIB()
*
* Parameters:
*
* HDIB hDib - objective DIB handle
* BOOL bHori - open direction
*
* Return Value:
*
* BOOL - True is success, else False
*
* Description:
*
* This function contour DIB with the specified direction
*
************************************************************************/
BOOL ContourDIB(HDIB hDib, BOOL bHori)
{
// start wait cursor
WaitCursorBegin();
// Old DIB buffer
if (hDib == NULL)
{
WaitCursorEnd();
return FALSE;
}
// only support 256 color image
WORD wBitCount = DIBBitCount(hDib);
if (wBitCount != 8)
{
WaitCursorEnd();
return FALSE;
}
// new DIB
HDIB hNewDIB = CopyHandle(hDib);
if (! hNewDIB)
{
WaitCursorEnd();
return FALSE;
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -