archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
3.8 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/printscan/ui/uicommon/32bitdib.cpp

2796 lines
102 KiB
Raw Permalink Blame History

// 32BitDibWrapper.cpp: implementation of the C32BitDibWrapper class.
//
//////////////////////////////////////////////////////////////////////
#include "precomp.h"
#pragma hdrstop
#include "32BitDib.h"
// helper functions
// sum of RGB vals
inline ULONG Intensity(ULONG value)
{
return(value&0xff)+((value&0xff00)>>8)+((value&0xff0000)>>16);
}
// we should make a Difference Template to clean up this code
inline UCHAR Difference(UCHAR a, UCHAR b)
{
if (a>b) return(a-b);
else return(b-a);
}
inline ULONG Difference(ULONG a, ULONG b)
{
if (a>b) return(a-b);
else return(b-a);
}
inline LONG Difference(LONG a, LONG b)
{
if (a>b) return(a-b);
else return(b-a);
}
int inline MAX(int a, int b)
{
if (a>b) return(a);
return(b);
}
int inline MIN(int a, int b)
{
if (a<b) return(a);
return(b);
}
// shadows are gray... if you aint gray... you aint a shadow
// this function hasn't yet been optimized
inline ULONG DifferenceFromGray(ULONG value)
{
UCHAR g,b;//,r;
// r=(UCHAR)(value& 0x0000ff);
g=(UCHAR)((value& 0x00ff00)>>8);
b=(UCHAR)((value& 0xff0000)>>16);
// use this instead of the complete formula (uncomment the commented out code for the complete formula)
// allow yellow scanner backgrounds
return(ULONG)(Difference(b,g));//+Difference(r,g)+Difference(g,b));
}
// sets up a C32BitDibWrapper where each pixel (x,y) is the difference bettween the value of the pixel (x,y) on
// bitmap1 and the pixel (x,y) on bitmap2
int C32BitDibWrapper::CreateDifferenceBitmap(C32BitDibWrapper *pBitmap1, C32BitDibWrapper *pBitmap2) // constructs a new dib that is the difference of the two other dibs
{ // image - blur(image) = detect edges.
//
// Destroy the old bitmap
//
if (m_pBits)
{
delete[] m_pBits;
m_pBits = NULL;
}
m_nBitmapWidth=-1;
m_nBitmapHeight=-1;
//
// Validate arguments
//
if (pBitmap1==NULL || pBitmap2==NULL)
{
return(FALSE);
}
if (pBitmap1->m_nBitmapWidth != pBitmap2->m_nBitmapWidth)
{
return(FALSE);
}
if (pBitmap1->m_nBitmapHeight != pBitmap2->m_nBitmapHeight)
{
return(FALSE);
}
if (pBitmap1->m_pBits==NULL || pBitmap2->m_pBits==NULL)
{
return(FALSE);
}
//
// How many bytes do we need?
//
int nNumBytes = pBitmap1->m_nBitmapWidth * pBitmap1->m_nBitmapHeight * sizeof(ULONG);
//
// Allocate the bytes, return false if we weren't successful
//
m_pBits = new BYTE[nNumBytes];
if (m_pBits==NULL)
{
return(FALSE);
}
//
// Save the dimensions
//
m_nBitmapWidth=pBitmap1->m_nBitmapWidth;
m_nBitmapHeight=pBitmap1->m_nBitmapHeight;
//
// Compute the difference
//
for (int i=0;i<nNumBytes;i++)
{
m_pBits[i]=Difference(pBitmap1->m_pBits[i],pBitmap2->m_pBits[i]);
}
return(TRUE);
}
// creates a C32BitDibWrapper which is identical to the C32BitDibWrapper passed as *bitmap
C32BitDibWrapper::C32BitDibWrapper(C32BitDibWrapper *pBitmap) // copy constructor
: m_pBits(NULL),
m_nBitmapWidth(-1),
m_nBitmapHeight(-1)
{
if (pBitmap && pBitmap->IsValid())
{
int nNumWords=pBitmap->m_nBitmapWidth*pBitmap->m_nBitmapHeight;
ULONG* pBitmapCopy = new ULONG[nNumWords];
ULONG* pSourceBitmap = (ULONG*)pBitmap->m_pBits;
if (pBitmapCopy && pSourceBitmap)
{
CopyMemory( pBitmapCopy, pSourceBitmap, nNumWords*sizeof(ULONG) );
m_pBits=(BYTE *)pBitmapCopy;
m_nBitmapHeight=pBitmap->m_nBitmapHeight;
m_nBitmapWidth=pBitmap->m_nBitmapWidth;
}
}
}
// creates a blank dib wrapper w pixels wide and h pixels high
C32BitDibWrapper::C32BitDibWrapper(int w, int h)
: m_pBits(NULL),
m_nBitmapWidth(-1),
m_nBitmapHeight(-1)
{
int nNumWords=w*h;
ULONG *pBitmapCopy = new ULONG[nNumWords];
if (pBitmapCopy)
{
ZeroMemory(pBitmapCopy,nNumWords*sizeof(ULONG));
m_pBits=(BYTE*)pBitmapCopy;
m_nBitmapHeight=h;
m_nBitmapWidth=w;
}
}
// creates a C32BitDibWrapper given the bitmap refered to by pBitmap
C32BitDibWrapper::C32BitDibWrapper(BITMAP bm)
: m_pBits(NULL),
m_nBitmapWidth(-1),
m_nBitmapHeight(-1)
{
BYTE* pDibBits=(BYTE*)(bm.bmBits);
if (pDibBits!=NULL && bm.bmWidth>0 && bm.bmHeight>0 && bm.bmBitsPixel>0 && bm.bmBitsPixel<=32) // is it a valid bitmap?
{
int nDepth = bm.bmBitsPixel;
m_nBitmapWidth = bm.bmWidth;
m_nBitmapHeight = bm.bmHeight;
//
// convert to a 32 bit bitmap
//
m_pBits=ConvertBitmap(pDibBits,nDepth,32);
if (!m_pBits)
{
m_nBitmapWidth=-1;
m_nBitmapHeight=-1;
}
}
}
// constructor from a memory mapped file bitmap
C32BitDibWrapper::C32BitDibWrapper(BYTE* pDib)
: m_pBits(NULL),
m_nBitmapWidth(-1),
m_nBitmapHeight(-1)
{
if (pDib)
{
//
// get pointer to just the image bits:
//
PBITMAPINFO pBitmapInfo=(PBITMAPINFO)(pDib + sizeof(BITMAPFILEHEADER));
BYTE* pDibBits = NULL;
switch (pBitmapInfo->bmiHeader.biBitCount)
{
case 24:
pDibBits=pDib+GetBmiSize((PBITMAPINFO)(pDib + sizeof(BITMAPFILEHEADER)))+ sizeof(BITMAPFILEHEADER);
break;
case 8:
pDibBits=pDib+GetBmiSize((PBITMAPINFO)(pDib + sizeof(BITMAPFILEHEADER)))+ sizeof(BITMAPFILEHEADER)-256*4+4;
break;
case 1:
pDibBits=pDib+GetBmiSize((PBITMAPINFO)(pDib + sizeof(BITMAPFILEHEADER)))+ sizeof(BITMAPFILEHEADER)-4;
break;
}
if (pDibBits)
{
m_pBits=ConvertBitmap(pDibBits,pBitmapInfo->bmiHeader.biBitCount,32);// convert to a 32 bit bitmap
if (m_pBits)
{
m_nBitmapWidth=pBitmapInfo->bmiHeader.biWidth;
m_nBitmapHeight=pBitmapInfo->bmiHeader.biHeight;
}
}
}
}
// create an empty wrapper
// we later expect to fill the wrapper using CreateDifferenceBitmap
C32BitDibWrapper::C32BitDibWrapper(void)
: m_pBits(NULL),
m_nBitmapWidth(-1),
m_nBitmapHeight(-1)
{
}
C32BitDibWrapper::~C32BitDibWrapper(void)
{
Destroy();
}
void C32BitDibWrapper::Destroy(void)
{
if (m_pBits)
{
delete[] m_pBits;
m_pBits = NULL;
}
m_nBitmapWidth=-1;
m_nBitmapHeight=-1;
}
//
// helper function which converts between 32 bit and other less worthy formats
// 32 bit dibs are stored in the following format
// xxxxxxxxRRRRRRRRGGGGGGGGBBBBBBBB 8 blank bits followed by 8 bits for each RGB channel
//
// not optimized for speed
//
// if we are being handed a large number of 300 dpi bitmaps, this could become an important function to
// optimize... otherwise its fine in its current form
//
BYTE* C32BitDibWrapper::ConvertBitmap( BYTE* pSource, int bitsPerSource, int bitsPerDest )
{
BYTE* pDest = NULL;
long x, y, nSourceLocation=0, nTargetLocation=0;
int i, nDWordAlign;
//
// Compute the dword align space for each line
//
if (m_nBitmapWidth%4!=0)
nDWordAlign=4-(m_nBitmapWidth*3)%4;
else nDWordAlign=0;
//
// Convert from a 24 bit bitmap to a 32 bit bitmap
// Pretty straight forward except that we have to watch out for
// DWORD align stuff with 24 bit bitmaps
//
if (bitsPerSource==24 && bitsPerDest==32)
{
pDest = new BYTE[m_nBitmapWidth*m_nBitmapHeight*sizeof(ULONG)];
//
// with fancy bit twiddling, we can get things done with one operation per 32
// bit pixel instead of 3 without much trouble if this routine becomes a
// performance bottlekneck, we should modify this code
//
// loop through all pixels adding 8 bits of zeroed out data at the end of
// each pSource line. 00000000RRRRRRRRGGGGGGGGBBBBBBBB
//
if (pDest)
{
for (y=0;y<m_nBitmapHeight;y++)
{
for (x=0;x<m_nBitmapWidth;x++)
{
pDest[nTargetLocation++]=pSource[nSourceLocation++];
pDest[nTargetLocation++]=pSource[nSourceLocation++];
pDest[nTargetLocation++]=pSource[nSourceLocation++];
pDest[nTargetLocation++]=0;
}
nSourceLocation+=nDWordAlign; // skip nDWordAlign pixels... 24 bit bitmaps are DWORD alligned
}
}
return(pDest);
}
//
// Convert from an 8 bit bitmap to a 32 bit bitmap
//
else if (bitsPerSource==8 && bitsPerDest==32)
{
pDest = new BYTE[m_nBitmapWidth*m_nBitmapHeight*sizeof(ULONG)];
if (pDest)
{
for (y=0;y<m_nBitmapHeight;y++) // loop through all pixels (x,y)
{
for (x=0;x<m_nBitmapWidth;x++)
{
pDest[nTargetLocation++]=pSource[nSourceLocation];
pDest[nTargetLocation++]=pSource[nSourceLocation];
pDest[nTargetLocation++]=pSource[nSourceLocation];
pDest[nTargetLocation++]=0;
nSourceLocation++;
}
if (m_nBitmapWidth%4!=0)
{
//
// handle dword alignment issues for 8 bit dibs
//
nSourceLocation+=4-(m_nBitmapWidth)%4;
}
}
}
return(pDest);
}
//
// Convert from a 1 bit B&W bitmap to a 32 bit bitmap
//
if (bitsPerSource==1 && bitsPerDest==32)
{
BYTE mask[8];
BYTE convert[255];
BYTE nCurrent;
int nByte = 0,nBit = 0;
int nLineWidth;
//
// mask[i] = 2^i
//
for (i=0;i<8;i++)
{
mask[i]=1<<i;
}
//
// all values of convert other than convert[0] are set to 0
//
convert[0]=0;
for (i=1;i<256;i++)
{
convert[i]=255;
}
nLineWidth=((m_nBitmapWidth+31)/32)*4;
//
// loop through all bitmap pixels keeping track of
// byte which indicates the byte position of the pixel (x,y) in the pSource bitmap
// bit which indicates the bit position of the pixel (x,y) within the byte
// desLocation which represents the byte position of the 32 bit dib wrapper
//
// loop through all bitmap pixels keeping track of byte which indicates the
// byte position of the pixel (x,y) in the pSource bitmap bit which indicates
// the bit position of the pixel (x,y) within the byte desLocation which
// represents the byte position of the 32 bit dib wrapper
//
pDest = new BYTE[m_nBitmapWidth*m_nBitmapHeight*sizeof(ULONG)];
if (pDest)
{
for (y=0;y<m_nBitmapHeight;y++)
{
nBit=0;
nByte=y*nLineWidth;
for (x=0;x<m_nBitmapWidth;x++)
{
if (nBit==8)
{
nBit=0;
nByte++;
}
nCurrent=pSource[nByte]&mask[nBit];
nCurrent=convert[nCurrent];
pDest[nTargetLocation++]=static_cast<BYTE>(nCurrent);
pDest[nTargetLocation++]=static_cast<BYTE>(nCurrent);
//
// hack to prevent shadow detection for 1 nBit dibs.
// set the blue channel to 150 so that shadow detection doesn't kick in
//
pDest[nTargetLocation++]=nCurrent&150;
pDest[nTargetLocation++]=0;
nBit++;
}
}
}
return(pDest);
}
//
// Only used for debugging purposes
// Converts a 32 bit bitmap down to 24 bits so that we can quickly display it
//
if (bitsPerSource==32 && bitsPerDest==24) // pretty straight forward except that we have to watch out for DWORD align stuff with 24 bit bitmaps
{
pDest = new BYTE[(m_nBitmapWidth*3+nDWordAlign)*m_nBitmapHeight];
if (pDest)
{
for (y=0;y<m_nBitmapHeight;y++)
{
for (x=0;x<m_nBitmapWidth;x++)
{
pDest[nTargetLocation++]=pSource[nSourceLocation++];
pDest[nTargetLocation++]=pSource[nSourceLocation++];
pDest[nTargetLocation++]=pSource[nSourceLocation++];
//
// pSource is 32 bits... ignore the first 8 bits
//
nSourceLocation++;
}
//
// handle dword alignment issues for 24 bit dibs
//
for (i=0;i<nDWordAlign;i++)
{
pDest[nTargetLocation++]=255;
}
}
}
return(pDest);
}
return(pDest);
}
// blurs the bitmap both horizontally and vertically
int C32BitDibWrapper::Blur(void)
{
BYTE *pBits=pointerToBlur();
if (m_pBits)
{
delete[] m_pBits;
}
m_pBits = pBits;
return(TRUE);
}
// this function should only be used if the current dib wrapper is blank
int C32BitDibWrapper::CreateBlurBitmap(C32BitDibWrapper * pSource)
{
if (pSource!=NULL && pSource->m_pBits!=NULL)
{
Destroy();
m_pBits=pSource->pointerToBlur();
//
// the blurred bitmap will have the same dimensions as the pSource bitmap
//
m_nBitmapWidth=pSource->m_nBitmapWidth;
m_nBitmapHeight=pSource->m_nBitmapHeight;
return(TRUE);
}
else
{
return(FALSE);
}
}
// identical to the previous function, except that we use a horizontal blur instead of blur
int C32BitDibWrapper::CreateHorizontalBlurBitmap(C32BitDibWrapper * pSource)
{
if (pSource!=NULL && pSource->IsValid())
{
Destroy();
m_pBits=pSource->pointerToHorizontalBlur();
if (m_pBits)
{
m_nBitmapWidth=pSource->m_nBitmapWidth;
m_nBitmapHeight=pSource->m_nBitmapHeight;
}
return(TRUE);
}
else
{
return(FALSE);
}
}
int C32BitDibWrapper::CreateVerticalBlurBitmap(C32BitDibWrapper * pSource)
{
//
// Nuke the old bitmap
//
Destroy();
if (pSource!=NULL && pSource->IsValid())
{
m_pBits=pSource->pointerToVerticalBlur();
m_nBitmapWidth=pSource->m_nBitmapWidth;
m_nBitmapHeight=pSource->m_nBitmapHeight;
return(TRUE);
}
return(FALSE);
}
// blur the bitmap
BYTE* C32BitDibWrapper::pointerToBlur(void)
{
if (m_pBits!=NULL)
{
int x,y;
int position; // position in old bitmap
ULONG* pBlurredBitmap;
ULONG* pSource;
int numPixels;
numPixels=m_nBitmapWidth*m_nBitmapHeight; // calculate the total number of pixels in the bitmap
pSource = (ULONG *)m_pBits; // we want to deal with data in 32 bit chunks
pBlurredBitmap = new ULONG[numPixels]; // create an array to hold the blurred bitmap
if (pBlurredBitmap==NULL) return(NULL); // unable to alloc memory
// handle edge pixels
// we do not blur edge pixels
// if needed, edge pixels could be blurred here
// blur top and bottom edge pixels
for (x=0;x<m_nBitmapWidth;x++)
{
pBlurredBitmap[x] = pSource[x]; // top row
pBlurredBitmap[numPixels-x-1] = pSource[numPixels-x-1]; // bottom row
}
// vertical sides
for (position=m_nBitmapWidth;position+m_nBitmapWidth<numPixels;position+=m_nBitmapWidth)
{
pBlurredBitmap[position] = pSource[position]; // left edge
pBlurredBitmap[position+m_nBitmapWidth-1] = pSource[position+m_nBitmapWidth-1]; // right edge
}
// now blur the bitmap
// position indicates the location of the pixel (x,y) in the array
position=m_nBitmapWidth-1;
for (y=1;y<m_nBitmapHeight-1;y++) // loop through all pixels except for 1 pixel wide outside edge
{
position++;
for (x=1;x<m_nBitmapWidth-1;x++)
{
position++;
// we wish to take the average of the pixel directly below the pixel, the pixel directly below the pixel
// the pixel directly to the right of the pixel and the pixel directly to the left of the pixel
// we can do this 1 dword at a time and without any bit shifting by the following algorithm
// problem. we cannot simply add the values of all four pixels and then divide by four
// because or bit overflow from one RGB channel to another. to avoid this overflow, we start by
// eliminating the two low order bits in each of the 3 color channels
// we use the filter 0xfafafa to remove the 2 low order bits from each of the 3 color channels
// e.g. RRRRRRRRGGGGGGGGBBBBBBBB goes to RRRRRR00GGGGGG00BBBBBB00
// next shift each pixel over two bits so RRRRRR00GGGGGG00BBBBBB00 --> 00RRRRRR00GGGGGG00BBBBBB
// note: we save 3 bit shifts by adding all four filtered pixels and then bitshifting which comes out to the same thing
// we can now add the four pixel values without channels overflowing. the value we get is off by an error factor
// because we eliminated the two lowest bits from each value
// we compensate for this error factor by applying the filter 0x030303 which translates
// RRRRRRRRGGGGGGGGBBBBBBBB to 000000RR000000GG000000BB
// giving us the two lowest order bits for each pixel. we can then safely add the two lowest order
// bits for each pixel. we then divide the result by 4 and add it
// to the value we got by ignoring the two lowest order bits.
pBlurredBitmap[position] =
(((pSource[position-1]&16579836) + // 0xfafafa
(pSource[position+1]&16579836) +
(pSource[position-m_nBitmapWidth]&16579836) +
(pSource[position+m_nBitmapWidth]&16579836))>>2)+
// compensate for error factor:
((((pSource[position-1]&197379) + // 0x030303
(pSource[position+1]&197379) +
(pSource[position-m_nBitmapWidth]&197379) +
(pSource[position+m_nBitmapWidth]&197379))>>2)&197379);
}
position++;
}
return(BYTE *)pBlurredBitmap;
}
else
{
return(NULL);
}
}
//
// identical to pointerToBlur bitmap except that we only use the pixel to
// the left and the pixel to the right of the bitmap for detailed comments,
// see pointerToBlur
//
BYTE* C32BitDibWrapper::pointerToHorizontalBlur(void)
{
if (m_pBits!=NULL)
{
int x,y;
int position; // position in old bitmap
ULONG* pBlurredBitmap;
ULONG* pSource;
int numPixels;
numPixels=m_nBitmapWidth*m_nBitmapHeight;
pSource = (ULONG *)m_pBits;
pBlurredBitmap = new ULONG[numPixels];
if (pBlurredBitmap == NULL) return(NULL);
// handle edge pixels
// for edge pixels we simply copy the pixel into the pSource to the destination
for (x=0;x<m_nBitmapWidth;x++)
{
pBlurredBitmap[x] = pSource[x]; // top row
pBlurredBitmap[numPixels-x-1] = pSource[numPixels-x-1]; // bottom row
}
// vertical sides
for (position=m_nBitmapWidth;position+m_nBitmapWidth<numPixels;position+=m_nBitmapWidth)
{
pBlurredBitmap[position] = pSource[position]; // left edge
pBlurredBitmap[position+m_nBitmapWidth-1] = pSource[position+m_nBitmapWidth-1]; // right edge
}
// now blur the bitmap
position=m_nBitmapWidth-1;
for (y=1;y<m_nBitmapHeight-1;y++) // for all pixels, pSource[position] is the pixel at (x,y)
{
position++;
for (x=1;x<m_nBitmapWidth-1;x++)
{
position++;
pBlurredBitmap[position] =
(((pSource[position-1]&0xfefefe) +
(pSource[position+1]&0xfefefe))>>1)+
((((pSource[position-1]&0x010101) +
(pSource[position+1]&0x010101))>>1)&0x010101);
}
position++;
}
return(BYTE *)pBlurredBitmap;
}
else
{
return(NULL);
}
}
// blur vertically
// same exact method as pointerToHorizontalBlur
// useful for detecting vertical edges, etc.
BYTE* C32BitDibWrapper::pointerToVerticalBlur(void)
{
if (m_pBits)
{
int x,y;
int position; // position in old bitmap
ULONG* pBlurredBitmap;
ULONG* pSource;
int numPixels;
numPixels=m_nBitmapWidth*m_nBitmapHeight;
pSource = (ULONG *)m_pBits;
pBlurredBitmap = new ULONG[numPixels];
if (pBlurredBitmap == NULL) return(NULL);
// handle edge pixels
for (x=0;x<m_nBitmapWidth;x++)
{
pBlurredBitmap[x] = pSource[x]; // top row
pBlurredBitmap[numPixels-x-1] = pSource[numPixels-x-1]; // bottom row
}
// vertical sides
for (position=m_nBitmapWidth;position+m_nBitmapWidth<numPixels;position+=m_nBitmapWidth)
{
pBlurredBitmap[position] = pSource[position]; // left edge
pBlurredBitmap[position+m_nBitmapWidth-1] = pSource[position+m_nBitmapWidth-1]; // right edge
}
// now blur the bitmap
position=m_nBitmapWidth-1;
for (y=1;y<m_nBitmapHeight-1;y++) // pSource[position] is the pixel at (x,y)
{
position++;
for (x=1;x<m_nBitmapWidth-1;x++)
{
position++;
pBlurredBitmap[position] =
(((pSource[position-m_nBitmapWidth]&0xfefefe) +
(pSource[position+m_nBitmapWidth]&0xfefefe))>>1)+
((((pSource[position-m_nBitmapWidth]&0x010101) +
(pSource[position+m_nBitmapWidth]&0x010101))>>1)&0x010101);
}
position++;
}
return(BYTE *)pBlurredBitmap;
}
else
{
return(NULL);
}
}
// cuts the intensity of each pixel in half
// useful for certain graphics effects
int C32BitDibWrapper::HalfIntensity(void)
{
if (m_pBits)
{
int numPixels;
int i;
ULONG* pBitmapPixels;
pBitmapPixels=(ULONG*)m_pBits;
numPixels=m_nBitmapWidth*m_nBitmapHeight;
// loop through all pixels
for (i=0;i<numPixels;i++)
pBitmapPixels[i]=(pBitmapPixels[i]&0xfefefe)>>1; // half intensity by first eliminating the lowest order bit from each pixel and then shifting all pixels by 1
return(TRUE);
}
else
{
return(FALSE);
}
}
// used repeatedly if the user hands us a 300 dpi image, etc.
// HalfSize compacts a h x w bitmap down to a h/2 x w/2 bitmap
int C32BitDibWrapper::HalfSize(void)
{
if (m_pBits)
{
int x,y;
ULONG position; // position in old bitmap
ULONG halfposition; // position in half (1/4 area) sized bitmap
int oldWidth,oldHeight;
ULONG* pOldBitmap;
ULONG* pNewBitmap;
pOldBitmap=(ULONG *)m_pBits; // we speed things up by dealing with 32 bit chunks instead of 8 bit chunks
pNewBitmap = new ULONG[(m_nBitmapWidth/2)*(m_nBitmapHeight/2)]; // create an array to store a bitmap 1/4th the size of the origional bitmap
if (pNewBitmap == NULL) return(FALSE); // out of memory
position=0;
halfposition=0;
// loop through pixels 2 pixels at a time in each direction
// at all times we insure that pOldBitmap[position] is the pixel at (x,y)
// and pNewBitmap[halfposition] is the pixel at (x/2,y/2)
for (y=0;y<m_nBitmapHeight-1;y+=2)
{
position=m_nBitmapWidth*y;
for (x=0;x<m_nBitmapWidth-1;x+=2)
{
pNewBitmap[halfposition] = // we use the same algorithm for finding the average of four pixel values as used in pointerToBlur
// see pointerToBlur for a detailed explaination
(((pOldBitmap[position]&16579836) +
(pOldBitmap[position+1]&16579836) +
(pOldBitmap[position+m_nBitmapWidth]&16579836) +
(pOldBitmap[position+m_nBitmapWidth+1]&16579836))>>2)+
((((pOldBitmap[position]&197379) +
(pOldBitmap[position+1]&197379) +
(pOldBitmap[position+m_nBitmapWidth]&197379) +
(pOldBitmap[position+m_nBitmapWidth+1]&197379))>>2)&197379);
position+=2;
halfposition++;
}
}
delete[] m_pBits; // destroy the old bitmap array
m_nBitmapWidth=m_nBitmapWidth/2;
m_nBitmapHeight=m_nBitmapHeight/2;
m_pBits=(BYTE *)pNewBitmap;
return(TRUE);
}
else
{
return(FALSE);
}
}
// this function destorys regions where the edgeBitmapPixels
// edgeBitmap holds edge informat, start defines the maximum color value for a pixel to start a shadow elimination search
// maxPixel defines the maximum edge value allowed for a shadow pixel
// differenceFromGrey defines the maximum difference from grey for a shadow pixel
// enhanceEdges deals with edge enhancement
int C32BitDibWrapper::KillShadows(C32BitDibWrapper * edgeBitmap, ULONG start, ULONG maxPixel, ULONG differenceFromGrey, ULONG min_guaranteed_not_shadow, bool enhanceEdges)
{
if (IsValid() && edgeBitmap && edgeBitmap->m_pBits)
{
int x,y,position, searchPosition, newPosition;
ULONG searchEdge;
ULONG * pEdgePixels;
ULONG * pBitmapPixels;
ULONG maxEdge;
int numPixels=m_nBitmapWidth*m_nBitmapHeight;
int *pShadowStack = new int[MAXSTACK];
if (!pShadowStack)
{
//
// we probably ran out of memory. die gracefully.
//
return(FALSE);
}
int stackHeight = 0;
// we first mark all the border pixels so we don't go off the edge
// this is much faster than other ways of doing bounds checking
pEdgePixels=(ULONG *)edgeBitmap->m_pBits;
pBitmapPixels=(ULONG *)m_pBits;
for (x=0;x<m_nBitmapWidth;x++)
{
pEdgePixels[x] = BORDER_EDGE; // top row
pEdgePixels[numPixels-x-1] = BORDER_EDGE; // bottom row
}
// vertical sides
for (position=m_nBitmapWidth;position+m_nBitmapWidth<numPixels;position+=m_nBitmapWidth)
{
pEdgePixels[position] = BORDER_EDGE; // left edge
pEdgePixels[position+m_nBitmapWidth-1] = BORDER_EDGE; // right edge
}
position=m_nBitmapWidth;
maxEdge=maxPixel;
for (y=1;y<m_nBitmapHeight-1;y++)
{
position++; // because we start at y=1 instead of y=0
for (x=1;x<m_nBitmapWidth-1;x++)
{
if (pBitmapPixels[position]!=DEAD_PIXEL) // we ignore DEAD_PIXEL pixels completelly
{
// check for pixels to mark as not shadows
if (pEdgePixels[position]!=BORDER_EDGE
&& Intensity(pEdgePixels[position])>min_guaranteed_not_shadow
&& enhanceEdges) // we only mark pixels as NOT_SHADOW if we are in enhanceEdges mode
{
pBitmapPixels[position]=NOT_SHADOW;
}
else // maybe this is a shadow pixel...
if (pBitmapPixels[position]!=NOT_SHADOW
&& pBitmapPixels[position]!=DEAD_PIXEL
&& Intensity(pBitmapPixels[position])<=start
&& Intensity(pEdgePixels[position])<=maxEdge
&& pBitmapPixels[position]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[position])<=differenceFromGrey)
{ // pixel is a shadow pixel
stackHeight=1;
pShadowStack[0]=position;
pBitmapPixels[position]=ERASEDSHADOW; // when we have decided a pixel is a shadow pixel, set it to zero
// fighitng edges add extra complexity but potentially allow us greater accuracy
// the concept is to mark pixels which cannot possibly be shadow pixels as such
// fighting edges only come into effect if FIGHTING_EDGES is set to true and enhanceEdges is set to false
// for the current KillShadows pass
if (FIGHTING_EDGES)
if (!enhanceEdges
&& Intensity(pEdgePixels[position])<=FIGHTING_EDGE_MAX_EDGE
&& DifferenceFromGray(pBitmapPixels[position])<=FIGHTING_EDGES_DIFF_FROM_GREY
&& Intensity(pBitmapPixels[position])>=FIGHTING_EDGE_MIN_MARK_PIXEL
&& Intensity(pBitmapPixels[position])<=FIGHTING_EDGE_MAX_MARK_PIXEL
)
pBitmapPixels[position]=DEAD_PIXEL;
while (stackHeight>0)
{
searchPosition=pShadowStack[--stackHeight];
searchEdge=Intensity(pEdgePixels[searchPosition]); // key idea: we are on a search and destroy mission for smooth gradients
// make sure our current edge value is similar to our last edge value
newPosition=searchPosition-1;
if ((pBitmapPixels[newPosition]!=NOT_SHADOW)
&& pBitmapPixels[newPosition]!=DEAD_PIXEL
&& Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
if (FIGHTING_EDGES)
if (!enhanceEdges
&& Intensity(pEdgePixels[newPosition])<=FIGHTING_EDGE_MAX_EDGE
&& DifferenceFromGray(pBitmapPixels[position])<=FIGHTING_EDGES_DIFF_FROM_GREY
&&Intensity(pBitmapPixels[newPosition])>=FIGHTING_EDGE_MIN_MARK_PIXEL
)
pBitmapPixels[newPosition]=DEAD_PIXEL;
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition+1;
if (pBitmapPixels[newPosition]!=NOT_SHADOW
&& pBitmapPixels[newPosition]!=DEAD_PIXEL
&& Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
if (FIGHTING_EDGES)
if (!enhanceEdges
&& Intensity(pEdgePixels[newPosition])<=FIGHTING_EDGE_MAX_EDGE
&& DifferenceFromGray(pBitmapPixels[position])<=FIGHTING_EDGES_DIFF_FROM_GREY
&&Intensity(pBitmapPixels[position])<=FIGHTING_EDGE_MAX_MARK_PIXEL
&&Intensity(pBitmapPixels[position])>=FIGHTING_EDGE_MIN_MARK_PIXEL
)
pBitmapPixels[newPosition]=DEAD_PIXEL;
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition-m_nBitmapWidth;
if (pBitmapPixels[newPosition]!=NOT_SHADOW
&& pBitmapPixels[newPosition]!=DEAD_PIXEL
&& Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
if (FIGHTING_EDGES)
if (!enhanceEdges
&& Intensity(pEdgePixels[newPosition])<=FIGHTING_EDGE_MAX_EDGE
&& DifferenceFromGray(pBitmapPixels[position])<=FIGHTING_EDGES_DIFF_FROM_GREY
&&Intensity(pBitmapPixels[newPosition])>=FIGHTING_EDGE_MIN_MARK_PIXEL
&&Intensity(pBitmapPixels[position])>=FIGHTING_EDGE_MIN_MARK_PIXEL
)
pBitmapPixels[newPosition]=DEAD_PIXEL;
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition+m_nBitmapWidth;
if (pBitmapPixels[newPosition]!=NOT_SHADOW
&& pBitmapPixels[newPosition]!=DEAD_PIXEL
&& Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
if (FIGHTING_EDGES)
if (!enhanceEdges
&& Intensity(pEdgePixels[newPosition])<=FIGHTING_EDGE_MAX_EDGE
&&Intensity(pBitmapPixels[newPosition])>=FIGHTING_EDGE_MIN_MARK_PIXEL
&& DifferenceFromGray(pBitmapPixels[position])<=FIGHTING_EDGES_DIFF_FROM_GREY
&&Intensity(pBitmapPixels[position])>=FIGHTING_EDGE_MIN_MARK_PIXEL
)
pBitmapPixels[newPosition]=DEAD_PIXEL;
pShadowStack[stackHeight++]=newPosition;
}
}
}
}
position++;
}
position++;
}
delete[] pShadowStack;
return(TRUE);
}
else
{
return(FALSE);
}
}
// older simpler version... that includes comments:
/*int C32BitDibWrapper::KillShadows(C32BitDibWrapper * edgeBitmap, UINT start, UINT maxPixel, UINT differenceFromGrey)
{
int x,y,position, searchPosition, newPosition;
ULONG searchEdge;
ULONG * pEdgePixels;
ULONG * pBitmapPixels;
int * pShadowStack;
int stackHeight;
int numPixels;
UINT maxEdge;
numPixels=m_nBitmapWidth*m_nBitmapHeight;
pShadowStack = new int[MAXSTACK]; // we use a stack as part of a depth first search for potential shadow pixels next to a shadow pixel we have found
if (pShadowStack==NULL) return(FALSE); // we probably ran out of memory. die gracefully.
stackHeight=0;
// we first change all the border edge pixels to white so we don't go off the edge
// KillShadows avoids pixels with high shadow values so this should keep us from going off
// the edge of the bitmap... if maxPixel were set to 0xffffff, this would crash
// but in such a case, KillShadows would kill the whole bitmap.
// this is much faster than other ways of doing bounds checking
// we set all edge pixels to values such that we are gauranteed to reject them
pEdgePixels=(ULONG *)edgeBitmap->m_pBits;
pBitmapPixels=(ULONG *)m_pBits;
// horizontal sides
for (x=0;x<m_nBitmapWidth;x++)
{
pEdgePixels[x] = 0xffffff; // top row
pEdgePixels[numPixels-x-1] = 0xffffff; // bottom row
}
// vertical sides
for (position=m_nBitmapWidth;position+m_nBitmapWidth<numPixels;position+=m_nBitmapWidth)
{
pEdgePixels[position] = 0xffffff; // left edge
pEdgePixels[position+m_nBitmapWidth-1] = 0xffffff; // right edge
}
position=m_nBitmapWidth;
maxEdge=maxPixel;
for (y=1;y<m_nBitmapHeight-1;y++)
{
position++; // because we start at y=1 instead of y=0
for (x=1;x<m_nBitmapWidth-1;x++)
{
// we only start a shadow kill search if
if (Intensity(pBitmapPixels[position])<=start && Intensity(pEdgePixels[position])<=maxEdge && pBitmapPixels[position]!=ERASEDSHADOW && DifferenceFromGray(pBitmapPixels[position])<=differenceFromGrey)
{
// initialize the stack to do a DFS without recursion to find shadows
stackHeight=1; // we are going to place the current position on the stack
pShadowStack[0]=position;
pBitmapPixels[position]=ERASEDSHADOW; // when we have decided a pixel is a shadow pixel, set it to zero
while (stackHeight>0)
{
searchPosition=pShadowStack[--stackHeight];
searchEdge=Intensity(pEdgePixels[searchPosition]); // key idea: we are on a search and destroy mission for smooth gradients
// make sure our current edge value is similar to our last edge value
newPosition=searchPosition-1; // try the pixel to the left of the current pixel
if (Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey) // requirements for classifying a pixel as a shadow pixel if we have classified an adjacent pixel as a shadow pixel
{
pBitmapPixels[newPosition]=ERASEDSHADOW; // delete the pixel and mark it as an erased pixel so that our search doesn't go into an infinite loop
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition+1; // try the pixel to the right of the current pixel
if (Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition-m_nBitmapWidth; // try the pixel directly above the current pixel
if (Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
pShadowStack[stackHeight++]=newPosition;
}
newPosition=searchPosition+m_nBitmapWidth; // try the pixel directly below the current pixel
if (Intensity(pEdgePixels[newPosition])<=maxPixel
&& pBitmapPixels[newPosition]!=ERASEDSHADOW
&& DifferenceFromGray(pBitmapPixels[newPosition])<=differenceFromGrey)
{
pBitmapPixels[newPosition]=ERASEDSHADOW;
pShadowStack[stackHeight++]=newPosition;
}
}
}
position++;
}
position++;
}
if (pShadowStack!=NULL) delete pShadowStack;
return(TRUE);
}
*/
// finds clumps of pixels above the minimum image threshold
// pMap is an array which indicates which chunk each pixel in the bitmap is part of
// pMap values:
// 0 indicates that a pixel is not part of a chunk
// VERTICAL_EDGE indicates that a pixel is not part of a chunk and that the pixel is very close to the vertical edge of the image
// HORIZONTAL_EDGE is the same as vertical edge, just for horizontal edges
//
int C32BitDibWrapper::FindChunks(int * pMap) // return number of chunks... color the chunks on pMap
{
if (pMap && m_pBits)
{
int x,y,position, searchPosition;
ULONG * pBitmapPixels;
int * pChunkStack;
int stackHeight;
int numChunks;
int chunkSize;
int deltax, deltay;
int newPosition;
// prepare pMap
// indicate which pixels are edge pixels
// position represents the location of pixel (x,y)
// we indicate which pixels are edge pixels to prevent the search routines
// that follow from running off the edge of the bitmap
// to save time, the search routines will not keep track of x and y coordinates
// so it is neccessary to provide another and faster way of determining the bounds of the bitmap
position=0;
for (y=0;y<EDGEWIDTH;y++)
{
for (x=0;x<m_nBitmapWidth;x++)
pMap[position++]=VERTICAL_EDGE;
}
for (;y<m_nBitmapHeight-EDGEWIDTH;y++)
{
for (x=0;x<EDGEWIDTH;x++)
pMap[position++]=HORIZONTAL_EDGE;
for (;x<m_nBitmapWidth-EDGEWIDTH;x++) // for pixels that are not edge pixels, we set pMap to 0 to indicate
pMap[position++]=0; // that the pixel in question is ready to be set as part of a chunk
for (;x<m_nBitmapWidth;x++)
pMap[position++]=HORIZONTAL_EDGE;
}
for (;y<m_nBitmapHeight;y++)
{
for (x=0;x<m_nBitmapWidth;x++)
pMap[position++]=VERTICAL_EDGE;
}
// we are now ready to search for chunks
pChunkStack = NULL;
pChunkStack = new int[MAXSTACK];
if (pChunkStack == NULL) return(NULL);
stackHeight=0;
numChunks=0;
pBitmapPixels=(ULONG *)m_pBits; // its more convenient for this function to deal with pixels in 32 bit chunks instead of bytes .
// at all times we keep position set so that pBitmapPixels[position] represents the pixel at coordinates (x,y)
position=m_nBitmapWidth*EDGEWIDTH;
for (y=EDGEWIDTH;y<m_nBitmapHeight-EDGEWIDTH;y++) // check if we should start a floodfill search
// at each pixel (x,y) such that we are > EDGWIDTH from the edge
{
position+=EDGEWIDTH;
for (x=EDGEWIDTH;x<m_nBitmapWidth-EDGEWIDTH;x++)
{
// check if the pixel in question is not part of an existing chunk and that its intensity
// is greater than the minimum intensity required to be part of chunk
if (pMap[position]==0 && Intensity(pBitmapPixels[position])>MIN_CHUNK_INTENSITY)
{
// initialize stack used for doing a DFS of adjacent pixels
stackHeight=1;
pChunkStack[0]=position;
numChunks++;
chunkSize=0; // compute how many pixels are in the chunk. not used at the moment, but useful if we want
// to eliminate chunks which are too small at this stage instead of at some later point
pMap[position]=numChunks; // place this pixel in a chunk like it belongs
// continue searching for pixels while the stack is not empty
while (stackHeight>0)
{
searchPosition=pChunkStack[--stackHeight]; // pop the next pixel off the stack
chunkSize++; // increment the number of pixels in the chyunk by 1
// we check if we should add all pixels within EDGEWIDTH of the searchPosition pixel to the current chunk
// we then add any such pixels which are not edge pixels to the stack
for (deltay=-EDGEWIDTH*m_nBitmapWidth;deltay<=EDGEWIDTH*m_nBitmapWidth;deltay+=m_nBitmapWidth)
for (deltax=-EDGEWIDTH;deltax<=EDGEWIDTH;deltax++)
{
newPosition=searchPosition+deltay+deltax;
if (Intensity(pBitmapPixels[newPosition])>MIN_CHUNK_INTENSITY && pMap[newPosition]<=0)
{
if (pMap[newPosition]==0) // not an edge pixel
{
pChunkStack[stackHeight++]=newPosition;
pMap[newPosition]=numChunks; // mark the pixel as part of the chunk so that we do not go into an infinite loop
}
else // if a pixel is an edge pixel, we do not want to add that pixel to the stack
{
// (because of problems with scanners with black borders)
// furthermore... we only want to add an edge pixel if the current pixel is
// in a vertical or horizontal line with the edge pixel under consideration
// as this further minimizes problems related to black scanner edges
if (pMap[newPosition]==VERTICAL_EDGE)
{
if (deltax==0) // to minimize distortion due to black outside edge
pMap[newPosition]=numChunks;
}
else // HORIZONTAL_EDGE
{
if (deltay==0) // to minimize distortion due to black outside edge
pMap[newPosition]=numChunks;
}
}
}
}
}
}
position++;
}
position+=EDGEWIDTH;
}
delete[] pChunkStack;
return(numChunks);
}
else
{
return(0);
}
}
// for debugging purposes only
// displays where the chunks denoted by pMap are on the C32BitDibWrapper
// pMap must have the same dimensions as the current bitmap or this function will fail
void C32BitDibWrapper::ColorChunks(int *pMap)
{ // color in the bitmap given the region map... for debugging purposes;
if (m_pBits && pMap)
{
ULONG* pBitmapPixels;
ULONG mapColor;
int x,y;
int position;
position=0;
pBitmapPixels=(ULONG *)m_pBits;
// loop through all pixels
for (y=0;y<m_nBitmapHeight;y++)
for (x=0;x<m_nBitmapWidth;x++)
{
if (pMap[position]>0) // are we part of a region?
{
mapColor=(((ULONG)pMap[position])*431234894)&0xffffff; // a poor man's random number generator
// if we cared about speed... we should make a lookup table instead
// but this function is only for debugging purposes
pBitmapPixels[position]=((pBitmapPixels[position] & 0xfefefe)>>1)+((mapColor& 0xfefefe)>>1); // average with slight loss
}
if (pMap[position]<0) pBitmapPixels[position]=0xffffff; // color in vertical and horizontal edges
position++;
}
}
}
// designed mainly for debugging purposes... this is a painfully slow way to draw a 32 bit dib
// because of the slow conversion step from 32 bits back to 24 bits
int C32BitDibWrapper::Draw(HDC hdc, int x, int y)
{
if (hdc && m_pBits)
{
BITMAPINFO BitmapInfo;
SetBMI(&BitmapInfo,m_nBitmapWidth, m_nBitmapHeight, 24);
BYTE* pDibData = ConvertBitmap(m_pBits,32,24);
if (pDibData)
{
StretchDIBits(hdc,
x,y,m_nBitmapWidth,m_nBitmapHeight,
0,0,m_nBitmapWidth,m_nBitmapHeight,
pDibData,
&BitmapInfo,BI_RGB,SRCCOPY);
//
// destroy the temp 24 bit dib
//
delete[] pDibData;
return(TRUE);
}
}
return(FALSE);
}
// set pixel and get pixel are completelly unoptimized
// If you wish to make them faster, create a table of values storing y*m_nBitmapWidth for all values of y
// as GetPixel is used by the line drawing functions, this could result in a signifigant speed up as
// the line drawing functions are used for region collision detection
void inline C32BitDibWrapper::SetPixel(int x, int y, ULONG color)
{
if (m_pBits)
{
ULONG* pBitmapPixels=(ULONG*)m_pBits;
pBitmapPixels[y*m_nBitmapWidth+x]=color;
}
}
ULONG inline C32BitDibWrapper::GetPixel(int x, int y)
{
if (m_pBits)
{
ULONG* pBitmapPixels=(ULONG*)m_pBits;
return(pBitmapPixels[y*m_nBitmapWidth+x]);
}
return 0;
}
//
// calculates the total intensity along a line
//
// Line drawing code modified from VGA line drawing code from Michael
// Abrash's Graphics Programming Black Book
//
// this is the one function which I did not create from scratch so any bug
// questions should be directed to Michael Abrash =) why reinvent the wheel
// when Bresenham line drawing is kindof hard to beat. particularly in this
// case when we are using lines as tracers so we couldn't care less about if
// they are antialiased or otherwise made to look less jagged.
//
// t-jacobr
//
ULONG C32BitDibWrapper::Line(int X0, int Y0,int X1, int Y1)
{
if (m_pBits)
{
if (X0<0) X0=0;
if (Y0<0) Y0=0;
if (X1<0) X1=0;
if (Y1<0) Y1=0;
if (X0>=m_nBitmapWidth) X0=m_nBitmapWidth;
if (Y0>=m_nBitmapHeight) Y0=m_nBitmapHeight;
if (X1>=m_nBitmapWidth) X1=m_nBitmapWidth;
if (Y1>=m_nBitmapHeight) Y1=m_nBitmapHeight;
int DeltaX, DeltaY;
int Temp;
if (Y0>Y1)
{
Temp=Y0;
Y0=Y1;
Y1=Temp;
Temp = X0;
X0=X1;
X1=Temp;
}
DeltaX=X1-X0;
DeltaY=Y1-Y0;
if (DeltaX>0)
{
if (DeltaX>DeltaY)
{
return(Octant0(X0,Y0,DeltaX,DeltaY,1));
}
else
{
return(Octant1(X0,Y0,DeltaX,DeltaY,1));
}
}
else
{
DeltaX = -DeltaX;
if (DeltaX>DeltaY)
{
return(Octant0(X0,Y0,DeltaX,DeltaY,-1));
}
else
{
return(Octant1(X0,Y0,DeltaX,DeltaY,-1));
}
}
}
else
{
return(0); // invalid bitmap
}
}
// helper functions for line drawing
// these aint no normal nine drawing functions
// what we do is we calculate the total intensity of all of the above threshold pixels along the line
ULONG C32BitDibWrapper::Octant0(int X0, int Y0,int DeltaX,int DeltaY,int XDirection)
{
if (IsValid())
{
int DeltaYx2;
int DeltaYx2MinusDeltaXx2;
int ErrorTerm;
ULONG totalIntensity;
ULONG pixelIntensity;
totalIntensity=0;
DeltaYx2=DeltaY*2;
DeltaYx2MinusDeltaXx2=DeltaYx2 - (DeltaX*2);
ErrorTerm = DeltaYx2 - DeltaX;
// SetPixel(X0,Y0,0x0000ff);
while (2<DeltaX--) // skip the last pixel
{
if (ErrorTerm >=0)
{
Y0++;
ErrorTerm +=DeltaYx2MinusDeltaXx2;
}
else
{
ErrorTerm +=DeltaYx2;
}
X0+=XDirection;
//SetPixel(X0,Y0,0x0000ff);
pixelIntensity=Intensity(GetPixel(X0,Y0));
if (pixelIntensity>MIN_CHUNK_INTENSITY && pixelIntensity<COLLISION_DETECTION_HIGHPASS_VALUE) totalIntensity+=512;//pixelIntensity;
}
return(totalIntensity);
}
return 0;
}
ULONG C32BitDibWrapper::Octant1(int X0, int Y0, int DeltaX, int DeltaY, int XDirection)
{
if (IsValid())
{
int DeltaXx2;
int DeltaXx2MinusDeltaYx2;
int ErrorTerm;
ULONG totalIntensity;
ULONG pixelIntensity;
totalIntensity=0;
DeltaXx2 = DeltaX * 2;
DeltaXx2MinusDeltaYx2 = DeltaXx2 - (DeltaY*2);
ErrorTerm = DeltaXx2 - DeltaY;
//SetPixel(X0,Y0,0x0000ff);
while (2<DeltaY--)
{ // skip last pixel
if (ErrorTerm >=0)
{
X0 +=XDirection;
ErrorTerm +=DeltaXx2MinusDeltaYx2;
}
else
{
ErrorTerm +=DeltaXx2;
}
Y0++;
pixelIntensity=Intensity(GetPixel(X0,Y0));
if (pixelIntensity>MIN_CHUNK_INTENSITY && pixelIntensity<COLLISION_DETECTION_HIGHPASS_VALUE) totalIntensity+=512;//pixelIntensity;
}
return(totalIntensity);
}
return 0;
}
//
// Compensate for Background Color could be made more than 3 times as fast if needed by caculating each pixel
// using 1 cycle instead of 3.
void C32BitDibWrapper::CompensateForBackgroundColor(int r, int g, int b)
{
if (IsValid())
{
int nNumBits=m_nBitmapWidth*m_nBitmapHeight*4;
for (int position=0;position<nNumBits;position+=4)
{
if (r<m_pBits[position]) m_pBits[position]=m_pBits[position]-r;
else m_pBits[position]=0;
if (g<m_pBits[position+1]) m_pBits[position+1]=m_pBits[position+1]-g;
else m_pBits[position+1]=0;
if (b<m_pBits[position+2]) m_pBits[position+2]=m_pBits[position+2]-b;
else m_pBits[position+2]=0;
}
}
}
// invert the bitmap
void C32BitDibWrapper::Invert(void)
{
if (IsValid())
{
int numPixels;
int i;
ULONG* pBitmapPixels;
pBitmapPixels=(ULONG*)m_pBits; // operate in 32 bit chunks instead of 8 bit chunks
numPixels=m_nBitmapWidth*m_nBitmapHeight;
// loop through all pixels in the bitmap
for (i=0;i<numPixels;i++)
pBitmapPixels[i]^=0xffffff; // flipping all bits inverts the pixel
}
}
// note: we could get some wierd effects because despeckle edits the bitmap its examining
// but this shouldn't be a signifigant problem and often, the self referential aspect only acts to slightly increase accuracy
// this function is not the same as the standard photoshop despeckle filter.
// we only care about a small category of stray dots.
// stray dots which are surrounded by white pixels (or pixels which have been eliminated by remove shadow filters)
void C32BitDibWrapper::Despeckle(void)
{
if (IsValid())
{
ULONG* pBitmapPixels;
int numPixels;
int position;
int x,y;
pBitmapPixels=(ULONG*)m_pBits;
numPixels=m_nBitmapWidth*m_nBitmapHeight;
position=4*m_nBitmapWidth;
// loop through all pixels which are not border pixels
// pBitmapPixels[position] should be the pixel at (x,y) in all cases
for (y=4;y<m_nBitmapHeight-4;y++)
{
position+=4;
for (x=4;x<m_nBitmapWidth-4;x++)
{
DespecklePixel(pBitmapPixels, position,false);
position++;
}
position+=4;
}
}
}
// we may want to despeckle the edges of an image more often than the rest of the image
// as image edges are often trouble spots...
// because of this, we should recommend that users place images in the center of the scanner
// when doing region detection to increase accuracy.
// the concept we are applying is that when we have to make sacrifices we make sacrifices in areas where we hurt cases that would have been very very hard anyway.
void C32BitDibWrapper::EdgeDespeckle(void)
{
if (IsValid())
{
ULONG* pBitmapPixels;
int x,y,position;
pBitmapPixels=(ULONG*)m_pBits;
position=m_nBitmapWidth*4;
// top edge
// as always, at all times we insure that pBitmapPixels[position] is the pixel at (x,y)
for (y=4;y<DESPECKLE_BORDER_WIDTH+4;y++)
{
position+=4;
for (x=4;x<m_nBitmapWidth-4;x++)
{
DespecklePixel(pBitmapPixels, position,true);
position++;
}
position+=4;
}
// side edges
for (;y<m_nBitmapHeight-DESPECKLE_BORDER_WIDTH-4;y++)
{
position+=4;
for (x=4;x<DESPECKLE_BORDER_WIDTH+4;x++)
{
DespecklePixel(pBitmapPixels, position,true); // left edge
DespecklePixel(pBitmapPixels, position+m_nBitmapWidth-DESPECKLE_BORDER_WIDTH-8,true); // right edge
position++;
}
position+=m_nBitmapWidth-DESPECKLE_BORDER_WIDTH-4;
}
// bottom edge
for (;y<m_nBitmapHeight-4;y++)
{
position+=4;
for (x=4;x<m_nBitmapWidth-4;x++)
{
DespecklePixel(pBitmapPixels, position,true);
position++;
}
position+=4;
}
}
}
// given the pixel at position i, figure out if it meets any of the requirements for eliminating the pixel
// if it does, eliminate the pixel. edgePixel specifies if the pixel is an edgePixel (in which case we may want
// to apply more strict requirements).
void C32BitDibWrapper::DespecklePixel(ULONG* pBitmapPixels, int i, bool edgePixel)
{
if (IsValid())
{
if (Intensity(pBitmapPixels[i])>MIN_CHUNK_INTENSITY)
{
// deletes:
//
// xx
// xx
//
if (
Intensity(pBitmapPixels[i-1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
)
{
pBitmapPixels[i]=0;
pBitmapPixels[i+1]=0;
pBitmapPixels[i+m_nBitmapWidth]=0;
pBitmapPixels[i+1+m_nBitmapWidth]=0;
}
if (edgePixel==true)
{
// radius one speckle
// horizontal despeckle
if (Intensity(pBitmapPixels[i-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
// vertical despeckle
if (Intensity(pBitmapPixels[i-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
// radius two despeckle
if (Intensity(pBitmapPixels[i-2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+3])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
// vertical despeckle
if (Intensity(pBitmapPixels[i-m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*3])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
// despeckle to eliminate clumps like this:
// clump: ? ?
// x
// ? ?
if (Intensity(pBitmapPixels[i-1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1+m_nBitmapWidth])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
}
// to eliminate this clump:
// ?
// ?x?
// ?
//
if (Intensity(pBitmapPixels[i-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1])<MIN_CHUNK_INTENSITY)
pBitmapPixels[i]=0; // despeckle the speckle
// these functions are insanely slow... if they become a major speed bottlekneck, they can be made
// 10x faster
// radius one speckle 3 pixel search depth
// horizontal despeckle
if (
Intensity(pBitmapPixels[i-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-4])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+4])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-2+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-3+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-4+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+4+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+3+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-2-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-3-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-4-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+4-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+3-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+2-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+1-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
)
pBitmapPixels[i]=0; // despeckle the speckle
// vertical despeckle
if (
Intensity(pBitmapPixels[i-m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*3])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*4])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*4])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*2+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*3+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*3+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*4+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*4+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth+1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*2-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*2-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*3-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*3-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i-m_nBitmapWidth*4-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth*4-1])<MIN_CHUNK_INTENSITY
&& Intensity(pBitmapPixels[i+m_nBitmapWidth-1])<MIN_CHUNK_INTENSITY
)
pBitmapPixels[i]=0; // despeckle the speckle
}
}
}
// its easy to correct for if the user adjusted brightness contrast
// or worse... if the scanners gamma settings are off
// not unlikely if they have a really old or really cheap scanner
void C32BitDibWrapper::CorrectBrightness(void)
{
if (IsValid())
{
int r,g,b;
int position;
int nNumBits;
r=255;
g=255;
b=255;
nNumBits=m_nBitmapWidth*(m_nBitmapHeight-4)*4;
// find the minimum, r, g, and b values;
for (position=m_nBitmapWidth*4;position<nNumBits;position+=4)
{
if (r>m_pBits[position]) r=m_pBits[position];
if (g>m_pBits[position+1]) g=m_pBits[position+1];
if (b>m_pBits[position+2]) b=m_pBits[position+2];
}
if (r!=0 || g!=0 || b!=0) // if the r, g, or b vals are off, correct them
CompensateForBackgroundColor(r,g,b);
}
}
//
// stretch out the color spectrum if the darn user adjusted brightness so that no parts of the image are black anymore
// otherwise we can get embarassing failures if the user simply tweaks brightness and contrast too much
//
// stretches upwards... if you need to compensate downwards, call correctBrightness first
void C32BitDibWrapper::MaxContrast(UINT numPixelsRequired)
{
if (IsValid())
{
int position;
int nNumBits;
int max;
int i;
int temp;
BYTE pConversionTable[256];
ULONG pNum[256];
for (i=0;i<256;i++)
pNum[i]=0;
nNumBits=m_nBitmapWidth*m_nBitmapHeight*4;
// compute the number of pixels of each intensity level
for (position=0;position<nNumBits;position+=4)
{
pNum[m_pBits[position]]++;
pNum[m_pBits[position+1]]++;
pNum[m_pBits[position+2]]++;
}
max=1;
// find max intensity which has at least numPixelsRequired of that intensity
for (i=1;i<256;i++)
if (pNum[i]>numPixelsRequired) max=i;
// create conversion table
for (i=0;i<256;i++)
{
temp=(255*i)/max;
if (temp>255) temp=255; // high pass
pConversionTable[i]=(BYTE)temp;
}
// now apply the conversion table to all pixels in the image
for (position=0;position<nNumBits;position+=4)
{
m_pBits[position]=pConversionTable[m_pBits[position]];
m_pBits[position+1]=pConversionTable[m_pBits[position+1]];
m_pBits[position+2]=pConversionTable[m_pBits[position+2]];
}
}
}
/// we don't want to use intensity here
// because this is a function used for detecting text regions
// and text regions are more likely to have grey background than yellow backgrounds
// hence doing a chan by chan test is more effective
// IMPORTANT NOTE: this function is designed for use with a non-inverted bitmap unlike most of the other functions in this library
int C32BitDibWrapper::PixelsBelowThreshold(C32BitDibWrapper* pProccessedBitmap, C32BitDibWrapper * pEdgesBitmap, RECT region)
{
if (IsValid() && pProccessedBitmap && pEdgesBitmap && pProccessedBitmap->IsValid() && pEdgesBitmap->IsValid())
{
int x,y;
int position;
int numPixels;
ULONG* pBitmapPixels;
ULONG* pEdgePixels;
ULONG* pProccessedPixels; // bitmap with shadows removed, etc
// we assume that the edge bitmap has the same width and height as this bitmap to shave a couple of 1/1000ths of a second... and cause we are lazy
numPixels=0;
pBitmapPixels=(ULONG *)m_pBits;
pEdgePixels=(ULONG *)(pEdgesBitmap->m_pBits);
pProccessedPixels=(ULONG *)(pProccessedBitmap->m_pBits);
position=region.top*m_nBitmapWidth;
// search through all pixels in the region
// at all times, pBitmapPixels[position] is the pixel at point (x,y)
for (y=region.top;y<=region.bottom;y++)
{
position+=region.left;
for (x=region.left;x<=region.right;x++)
{
if ((
(pBitmapPixels[position]&0xff) > TEXT_REGION_BACKGROUND_THRESHOLD
&& (pBitmapPixels[position]&0xff00) > (TEXT_REGION_BACKGROUND_THRESHOLD<<8)
&& (pBitmapPixels[position]&0xff0000)> (TEXT_REGION_BACKGROUND_THRESHOLD<<16) // below threshold
&& Intensity(pEdgePixels[position]) > MIN_TEXT_REGION_BACKGROUND_EDGE) // does it have the requisite edge val?
|| (pProccessedPixels[position]==0
&& Intensity(pEdgePixels[position])>MIN_TEXT_REGION_BACKGROUND_EDGE_CLIPPED_PIXEL
&& (pBitmapPixels[position]&0xff) > CLIPPED_TEXT_REGION_BACKGROUND_THRESHOLD
&& (pBitmapPixels[position]&0xff00) > (CLIPPED_TEXT_REGION_BACKGROUND_THRESHOLD<<8)
&& (pBitmapPixels[position]&0xff0000)> (CLIPPED_TEXT_REGION_BACKGROUND_THRESHOLD<<16) // below threshold
)) // we coulda been a dead shadow pixel too.. this is risky because depending on the settings, we may have culled plenty of deserving pixels
{
// we hold pixels to much higher standards if they are clipped pixels... to avoid too much stray clipping
numPixels++;
}
position++;
}
position+=m_nBitmapWidth-region.right-1;
}
return(numPixels);
}
else
{
return(0); // invalid bitmap
}
}
// the name of the game here is whatever works
// this function may be ugly, but its the easiest way to get rid of
// black borders without hurting overly many innocent pixels
void C32BitDibWrapper::RemoveBlackBorder(int minBlackBorderPixel, C32BitDibWrapper * outputBitmap, C32BitDibWrapper * debugBitmap)
{
if (IsValid() && m_nBitmapWidth>100 && m_nBitmapHeight>100 && outputBitmap) // these tests are designed for reasonably large bitmaps
{
// bottom border
KillBlackBorder(minBlackBorderPixel,m_nBitmapWidth*m_nBitmapHeight-m_nBitmapWidth,m_nBitmapWidth,m_nBitmapHeight,1,-m_nBitmapWidth, outputBitmap, debugBitmap);
// top border
KillBlackBorder(minBlackBorderPixel,0,m_nBitmapWidth,m_nBitmapHeight,1,m_nBitmapWidth, outputBitmap, debugBitmap);
// left side
KillBlackBorder(minBlackBorderPixel,0,m_nBitmapHeight,m_nBitmapWidth, m_nBitmapWidth,1, outputBitmap, debugBitmap);
// right side
KillBlackBorder(minBlackBorderPixel,m_nBitmapWidth-1,m_nBitmapHeight,m_nBitmapWidth, m_nBitmapWidth,-1, outputBitmap, debugBitmap);
}
}
// this function encapsulates the single purpose algorithm used to
// remove particularly troublesome shadows from the sides of images
// this function is poorly tweaked and it iss very likely that we could either
// greatly improve the number of errors detected
// or the number of false errors that are unfairly zapped
// debugBitmap is edited to give a graphical representation of which shadows have been eliminated
// debugBitmap is only edited if the VISUAL_DEBUG flag is set
// as shown in RemoveBlackBorder, KillBlackBorder is called with different startPosition, width, height, dx, and dy values
// depending on whether we are working on the top border, the left border, the right border, or the bottom border.
// from the perspective of KillBlackBorder, it is working on eliminating shadows from a bitmap which is width pixels wide
// height pixels high and the location of pixel (0,0) is startPosition. Where to move one pixel in the x direction
// you increment startPosition by dx and to move one pixel in the y direction, you increment dy by 1.
void C32BitDibWrapper::KillBlackBorder(int minBlackBorderPixel, int startPosition, int width, int height, int dx, int dy, C32BitDibWrapper *pOutputBitmap, C32BitDibWrapper * pDebugBitmap)
{
if (IsValid() && pOutputBitmap && pOutputBitmap->IsValid() && width>100 && height>100)
{
int x,y,position, searchPosition, newPosition;
ULONG * pBitmapPixels;
int endPoint;
int r,g,b;
int dr,dg,db;
int i;
int sourceR,sourceG, sourceB;
int errors;
int step;
int* pShadowDepths;
int* pTempShadowDepths;
int longestBackgroundPixelString;
int borderPixels;
int nonBackgroundPixels;
int backgroundPixels;
BYTE* pBlurredBits = m_pBits;
ULONG* pDebugPixels;
BYTE* pOutputBits;
pOutputBits=pOutputBitmap->m_pBits;
pShadowDepths=new int[width]; // we keep an array of how many pixels we think the black border is for each scan line
if (pShadowDepths==NULL) return;
pTempShadowDepths=NULL;
pTempShadowDepths=new int[width];
if (pTempShadowDepths==NULL)
{
delete[] pShadowDepths;
return;
}
int numPixels=height*width; // total pixels in the image
pBitmapPixels=(ULONG *)(pOutputBitmap->m_pBits);
if (pBitmapPixels)
{
pDebugPixels=(ULONG *)(pDebugBitmap->m_pBits);
step=dy*4; // when dealing with data in 8 bit chunks instead of 32 bit chunks, we need to multiply the dy step by 4
// reset all vals to 0
for (i=0;i<width;i++)
{
pShadowDepths[i]=0;
pTempShadowDepths[i]=0;
}
position=startPosition*4;
for (x=0;x<width;x++) // loop through all pixels on the top row of the image
{
r=pBlurredBits[position];
g=pBlurredBits[position+1];
b=pBlurredBits[position+2];
if (r>minBlackBorderPixel&&g>minBlackBorderPixel&&b>minBlackBorderPixel) // if the pixel is dark enough
{
// start a kill shadows search
searchPosition=position+step;
errors=0;
borderPixels=0;
for (y=1;y<SHADOW_HEIGHT;y++) // we don't expect a shadow to be more than SHADOW_HEIGHT pixels high
{
dr=(int)pBlurredBits[searchPosition]-r;
dg=(int)pBlurredBits[searchPosition+1]-g;
db=(int)pBlurredBits[searchPosition+2]-b;
r=(int)pBlurredBits[searchPosition];
g=(int)pBlurredBits[searchPosition+1];
b=(int)pBlurredBits[searchPosition+2];
if (dr<MAX_BLACK_BORDER_DELTA && dg<MAX_BLACK_BORDER_DELTA &&db<MAX_BLACK_BORDER_DELTA)
// only requirement is the intensity in each pixel must be less than the intensity of the previous pixel
// a shadow should be darkest at the edge of the image, not hte other way round
{
borderPixels++;
if (borderPixels>5)
break; // if we have found five pixels which meet the borderPixel specs, break;
}
else
{
errors++;
if (errors>3)
break; // if we recieve more than 3 errors, break
}
searchPosition+=step;
}
endPoint=y+5; // because of edge enhancement, we set the shadow width to be a bit more than it actually is
searchPosition+=2*step; // skip a couple of pixels because we may have missed the last couple of pixels of the shadow
nonBackgroundPixels=0;
backgroundPixels=0;
for (;y<20;y++) // we expect the next few pixels to be background pixels
{
r=(int)pOutputBits[searchPosition];
g=(int)pOutputBits[searchPosition+1];
b=(int)pOutputBits[searchPosition+2];
sourceR=(int)pBlurredBits[searchPosition];
sourceG=(int)pBlurredBits[searchPosition+1];
sourceB=(int)pBlurredBits[searchPosition+2];
if (r < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION
&& g < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION
&& b < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION
// WARNING: commenting out the following 3 lines may greatly increases the number of innocent pixels that are deleted
&& sourceR < MAX_KILL_SHADOW_BACKGROUND_UNEDITED
&& sourceG < MAX_KILL_SHADOW_BACKGROUND_UNEDITED
&& sourceB < MAX_KILL_SHADOW_BACKGROUND_UNEDITED
)
backgroundPixels++;
else
{
nonBackgroundPixels++;
}
if ((nonBackgroundPixels)>(backgroundPixels+4))
{ // no way this is actually a shadow we are deleting
y=0;
break;
}
if (backgroundPixels>7) break;
searchPosition+=step;
}
// we only have a shadow if we get a number of dark pixels followed by a number light pixels
if (nonBackgroundPixels<3 && backgroundPixels>5 && borderPixels>errors && y!=0)
{
pShadowDepths[x]=MAX(pShadowDepths[x],endPoint);
}
}
// this is designed to kill a different kind of shadow, a light shadow far from any objects
// this code can be safely eliminated
//
r=pBlurredBits[position];
g=pBlurredBits[position+1];
b=pBlurredBits[position+2];
if (r>(minBlackBorderPixel/6)&&g>(minBlackBorderPixel/6)&&b>(minBlackBorderPixel/6))
{
searchPosition=position+step;
errors=0;
borderPixels=0;
for (y=1;y<11;y++)
{
dr=(int)pBlurredBits[searchPosition]-r;
dg=(int)pBlurredBits[searchPosition+1]-g;
db=(int)pBlurredBits[searchPosition+2]-b;
r=(int)pBlurredBits[searchPosition];
g=(int)pBlurredBits[searchPosition+1];
b=(int)pBlurredBits[searchPosition+2];
// much looser requirements for being a shadow
if (r>minBlackBorderPixel/7&&g>minBlackBorderPixel/7&&b>minBlackBorderPixel/7)
{
borderPixels++;
}
else
{
errors++;
}
searchPosition+=step;
}
endPoint=y-3;
searchPosition+=5*step;
nonBackgroundPixels=0;
backgroundPixels=0;
for (;y<35;y++)
{
r=(int)pOutputBits[searchPosition];
g=(int)pOutputBits[searchPosition+1];
b=(int)pOutputBits[searchPosition+2];
sourceR=(int)pBlurredBits[searchPosition];
sourceG=(int)pBlurredBits[searchPosition+1];
sourceB=(int)pBlurredBits[searchPosition+2];
// much stricter requirements for being a background pixel
// with these stricter requirements, we are almost guaranteed not to eliminate any
// valid pixels while searching for black borders
// the idea is balancing looser requirements in one area with stricter requirements in another
if (r < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION/29
&& g < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION/29
&& b < MAX_KILL_SHADOW_BACKGROUND_APROXIMATION/29
&& sourceR < MAX_KILL_SHADOW_BACKGROUND_UNEDITED/39
&& sourceG < MAX_KILL_SHADOW_BACKGROUND_UNEDITED/39
&& sourceB < MAX_KILL_SHADOW_BACKGROUND_UNEDITED/39
)
backgroundPixels++;
else
{
nonBackgroundPixels++;
break;
}
searchPosition+=step;
}
if (nonBackgroundPixels==0) // the pixel isn't a shadow pixel unless all of the backgroundPixels tested were background pixels
{
pShadowDepths[x]=MAX(pShadowDepths[x],endPoint); // update the shadowDepth for the pixel
// corners can be very problematic
// because this algorithm will by definition fail on any corner line
// so we cheat...
if (x<CORNER_WIDTH)
{
for (i=0;i<CORNER_WIDTH;i++)
{
pShadowDepths[i]=MAX(pShadowDepths[i],endPoint);
}
}
if (x+CORNER_WIDTH>width)
{
for (i=width-CORNER_WIDTH;i<width;i++)
{
pShadowDepths[i]=MAX(pShadowDepths[i],endPoint);
}
}
}
}
// this is designed to kill a different kind of shadow, a small light shadow close to objects
// this code can be safely eliminated
// it was mainly written simply to explore the problem space of border elimination
//
// if this code is saved beyond a couple of test runs, we will need to turn some of its constants into real constants
// it seems from prelim tests that this code may be preferable to the previous test function
{
searchPosition=position+step;
errors=0;
borderPixels=0;
nonBackgroundPixels=0;
backgroundPixels=0;
longestBackgroundPixelString=0;
endPoint=0;
// we don't bother with looking for a string of black pixels in this case
// which is probably more intelegent than the previous code blocks
// instead we simply look for long strings of background pixels
// while at the same time, terminating the search of we come across too many non-background pixels
for (y=0;y<16;y++)
{
r=(int)pOutputBits[searchPosition];
g=(int)pOutputBits[searchPosition+1];
b=(int)pOutputBits[searchPosition+2];
sourceR=(int)pBlurredBits[searchPosition];
sourceG=(int)pBlurredBits[searchPosition+1];
sourceB=(int)pBlurredBits[searchPosition+2];
if (r < 24
&& g < 24
&& b < 24
&& sourceR < 12
&& sourceG < 12
&& sourceB < 12
)
backgroundPixels++;
else
{
if (y>5) nonBackgroundPixels++;
if (backgroundPixels>longestBackgroundPixelString)
{
endPoint=y;
longestBackgroundPixelString=backgroundPixels;
}
backgroundPixels=0;
if (nonBackgroundPixels>1) break;
}
searchPosition+=step;
}
if (backgroundPixels>longestBackgroundPixelString) // was the longestBackgroundPixelString the last?
{
longestBackgroundPixelString=backgroundPixels;
endPoint=16;
}
if (longestBackgroundPixelString>6)
{
pShadowDepths[x]=MAX(pShadowDepths[x],endPoint-4);
// corners can be problematic
// because this algorithm will by definition fail on a black corner
// so we cheat...
if (x<CORNER_WIDTH)
{
for (i=0;i<CORNER_WIDTH;i++)
{
pShadowDepths[i]=MAX(pShadowDepths[i],endPoint);
}
}
if (x+CORNER_WIDTH>width)
{
for (i=width-CORNER_WIDTH;i<width;i++)
{
pShadowDepths[i]=MAX(pShadowDepths[i],endPoint);
}
}
}
}
position+=dx*4; // increment the position by 1 unit to go to the next row
}
for (x=0;x<width;x++)
{
pTempShadowDepths[x]=pShadowDepths[x];
}
if (SMOOTH_BORDER) // shadows don't just come out of nowhere, if row x has a depth 20 shadow, its likely that we made a mistake and pixel x-1 also has a depth 20 shadow
{
for (x=2;x<width-2;x++)
{
pTempShadowDepths[x]=MAX(pTempShadowDepths[x],pShadowDepths[x-1]);
pTempShadowDepths[x]=MAX(pTempShadowDepths[x],pShadowDepths[x+1]);
pTempShadowDepths[x]=MAX(pTempShadowDepths[x],pShadowDepths[x-2]);
pTempShadowDepths[x]=MAX(pTempShadowDepths[x],pShadowDepths[x+2]);
}
}
// now remove the black border
// we loop through all rows x and then eliminate the first pTempShadowDepths[x] pixels in that row
position=startPosition;
step=dy;
for (x=0;x<width;x++)
{
newPosition=position;
for (y=0;y<pTempShadowDepths[x];y++)
{
pBitmapPixels[newPosition]=DEAD_PIXEL; // set each shadow to be a dead pixel
// dead pixels are the only pixels not vulnerable to edge enhancements...
// important if we do any KillShadows edge enhancement passes after calling kill black border
if (VISUAL_DEBUG)
pDebugPixels[newPosition]=((pDebugPixels[newPosition] & 0xfefefe)>>1)+((DEBUGCOLOR& 0xfefefe)>>1);
newPosition+=step;
}
position+=dx;
}
}
// clean up our memory
delete[] pTempShadowDepths;
delete[] pShadowDepths;
}
}
// dib manipulation functions
// the following are dib wrapper functions stolen and then modified... from utils.cpp
// these functions are now obsolete and only used in region debug mode
// where we need to load bitmaps from files
/*******************************************************************************
*
* SetBMI
*
* DESCRIPTION:
* Setup bitmap info.
*
* PARAMETERS:
*
*******************************************************************************/
void SetBMI( PBITMAPINFO pbmi, LONG width, LONG height, LONG depth)
{
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biWidth = width;
pbmi->bmiHeader.biHeight = height;
pbmi->bmiHeader.biPlanes = 1;
pbmi->bmiHeader.biBitCount = (WORD) depth;
pbmi->bmiHeader.biCompression = BI_RGB;
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
pbmi->bmiHeader.biClrUsed = 0;
pbmi->bmiHeader.biClrImportant = 0;
}
/*******************************************************************************
*
* AllocDibFileFromBits
*
* DESCRIPTION:
* Given an unaligned bits buffer, allocate a buffer lager enough to hold the
* DWORD aligned DIB file and fill it in.
*
* PARAMETERS:
*
*******************************************************************************/
PBYTE AllocDibFileFromBits( PBYTE pBits, UINT width, UINT height, UINT depth)
{
PBYTE pdib;
UINT uiScanLineWidth, uiSrcScanLineWidth, cbDibSize;
int bitsSize;
// Align scanline to ULONG boundary
uiSrcScanLineWidth = (width * depth) / 8;
uiScanLineWidth = (uiSrcScanLineWidth + 3) & 0xfffffffc;
// DEBUG:
// uiSrcScanLineWidth=uiScanLineWidth;
// Calculate DIB size and allocate memory for the DIB.
bitsSize=height * uiScanLineWidth;
cbDibSize = bitsSize+sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO);
pdib = (PBYTE) LocalAlloc(LMEM_FIXED, cbDibSize);
if (pdib)
{
PBITMAPFILEHEADER pbmfh = (PBITMAPFILEHEADER)pdib;
PBITMAPINFO pbmi = (PBITMAPINFO)(pdib + sizeof(BITMAPFILEHEADER));
PBYTE pb = (PBYTE)pbmi+ sizeof(BITMAPINFO);
// Setup bitmap file header.
pbmfh->bfType = 'MB';
pbmfh->bfSize = cbDibSize;
pbmfh->bfOffBits = static_cast<DWORD>(pb - pdib);
// Setup bitmap info.
SetBMI(pbmi,width, height, depth);
// WIA_TRACE(("AllocDibFileFromBits, uiScanLineWidth: %d, pdib: 0x%08X, pbmi: 0x%08X, pbits: 0x%08X", uiScanLineWidth, pdib, pbmi, pb));
// Copy the bits.
pb-=3;
pBits-=3; // BUG FIX BECAUSE THE PERSON WHO WROTE THIS COULDN'T KEEP THEIR BITS STRAIGHT
memcpy(pb, pBits, bitsSize);
}
else
{
// WIA_ERROR(("AllocDibFileFromBits, LocalAlloc of %d bytes failed", cbDibSize));
}
return(pdib);
}
/*******************************************************************************
*
* DIBBufferToBMP
*
* DESCRIPTION:
* Make a BMP object from a DWORD aligned DIB file memory buffer
*
* PARAMETERS:
*
*******************************************************************************/
HBITMAP DIBBufferToBMP(HDC hDC, PBYTE pDib, BOOLEAN bFlip)
{
HBITMAP hBmp = NULL;
PBITMAPINFO pbmi = (BITMAPINFO*)(pDib);
PBYTE pBits = pDib + GetBmiSize(pbmi);
if (bFlip)
{
pbmi->bmiHeader.biHeight = -pbmi->bmiHeader.biHeight;
}
hBmp = CreateDIBitmap(hDC, &pbmi->bmiHeader, CBM_INIT, pBits, pbmi, DIB_RGB_COLORS);
if (!hBmp)
{
;//WIA_ERROR(("DIBBufferToBMP, CreateDIBitmap failed %d", GetLastError(void)));
}
return(hBmp);
}
/*******************************************************************************
*
* ReadDIBFile
*
* DESCRIPTION:
*
* PARAMETERS:
*
*******************************************************************************/
HRESULT ReadDIBFile(LPTSTR pszFileName, PBYTE *ppDib)
{
HRESULT hr = S_FALSE;
HANDLE hFile, hMap;
PBYTE pFile, pBits;
*ppDib = NULL;
hFile = CreateFile(pszFileName,
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
//WIA_ERROR(("ReadDIBFile, unable to open %s", pszFileName));
return(hr);
}
hMap = CreateFileMapping(hFile,
NULL,
PAGE_READWRITE,
0,
0,
NULL);
if (!hMap)
{
//WIA_ERROR(("ReadDIBFile, CreateFileMapping failed"));
goto close_hfile_exit;
}
pFile = (PBYTE)MapViewOfFileEx(hMap,
FILE_MAP_READ | FILE_MAP_WRITE,
0,
0,
0,
NULL);
if (pFile)
{
PBITMAPFILEHEADER pbmFile = (PBITMAPFILEHEADER)pFile;
PBITMAPINFO pbmi = (PBITMAPINFO)(pFile + sizeof(BITMAPFILEHEADER));
// validate bitmap
if (pbmFile->bfType == 'MB')
{
// Calculate color table size.
LONG bmiSize, ColorMapSize = 0;
if (pbmi->bmiHeader.biBitCount == 1)
{
ColorMapSize = 2 - 1;
}
else if (pbmi->bmiHeader.biBitCount == 4)
{
ColorMapSize = 16 - 1;
}
else if (pbmi->bmiHeader.biBitCount == 8)
{
ColorMapSize = 256 - 1;
}
bmiSize = sizeof(BITMAPINFO) + sizeof(RGBQUAD) * ColorMapSize;
pBits = pFile + sizeof(BITMAPFILEHEADER) + bmiSize;
*ppDib = AllocDibFileFromBits(pBits,
pbmi->bmiHeader.biWidth,
pbmi->bmiHeader.biHeight,
pbmi->bmiHeader.biBitCount);
if (*ppDib)
{
hr = S_OK;
}
}
else
{
//WIA_ERROR(("ReadDIBFile, %s is not a valid bitmap file", pszFileName));
}
}
else
{
//WIA_ERROR(("ReadDIBFile, MapViewOfFileEx failed"));
goto close_hmap_exit;
}
UnmapViewOfFile(pFile);
close_hmap_exit:
CloseHandle(hMap);
close_hfile_exit:
CloseHandle(hFile);
return(hr);
}
/*******************************************************************************
*
* GetBmiSize
*
* DESCRIPTION:
* Should never get biCompression == BI_RLE.
*
* PARAMETERS:
*
*******************************************************************************/
LONG GetBmiSize(PBITMAPINFO pbmi)
{
// determine the size of bitmapinfo
LONG lSize = pbmi->bmiHeader.biSize;
// no color table cases
if (
(pbmi->bmiHeader.biBitCount == 24) ||
((pbmi->bmiHeader.biBitCount == 32) &&
(pbmi->bmiHeader.biCompression == BI_RGB)))
{
// no colors unless stated
lSize += sizeof(RGBQUAD) * pbmi->bmiHeader.biClrUsed;
return(lSize);
}
// bitfields cases
if (((pbmi->bmiHeader.biBitCount == 32) &&
(pbmi->bmiHeader.biCompression == BI_BITFIELDS)) ||
(pbmi->bmiHeader.biBitCount == 16))
{
lSize += 3 * sizeof(RGBQUAD);
return(lSize);
}
// palette cases
if (pbmi->bmiHeader.biBitCount == 1)
{
LONG lPal = pbmi->bmiHeader.biClrUsed;
if ((lPal == 0) || (lPal > 2))
{
lPal = 2;
}
lSize += lPal * sizeof(RGBQUAD);
return(lSize);
}
// palette cases
if (pbmi->bmiHeader.biBitCount == 4)
{
LONG lPal = pbmi->bmiHeader.biClrUsed;
if ((lPal == 0) || (lPal > 16))
{
lPal = 16;
}
lSize += lPal * sizeof(RGBQUAD);
return(lSize);
}
// palette cases
if (pbmi->bmiHeader.biBitCount == 8)
{
LONG lPal = pbmi->bmiHeader.biClrUsed;
if ((lPal == 0) || (lPal > 256))
{
lPal = 256;
}
lSize += lPal * sizeof(RGBQUAD);
return(lSize);
}
// error
return(0);
}
INT GetColorTableSize (UINT uBitCount, UINT uCompression)
{
INT nSize;
switch (uBitCount)
{
case 32:
if (uCompression != BI_BITFIELDS)
{
nSize = 0;
break;
}
// fall through
case 16:
nSize = 3 * sizeof(DWORD);
break;
case 24:
nSize = 0;
break;
default:
nSize = ((UINT)1 << uBitCount) * sizeof(RGBQUAD);
break;
}
return(nSize);
}
DWORD CalcBitsSize (UINT uWidth, UINT uHeight, UINT uBitCount, UINT uPlanes, int nAlign)
{
int nAWidth,nHeight,nABits;
DWORD dwSize;
nABits = (nAlign << 3);
nAWidth = nABits-1;
//
// Determine the size of the bitmap based on the (nAlign) size. Convert
// this to size-in-bytes.
//
nHeight = uHeight * uPlanes;
dwSize = (DWORD)(((uWidth * uBitCount) + nAWidth) / nABits) * nHeight;
dwSize = dwSize * nAlign;
return(dwSize);
}
//
// Converts hBitmap to a DIB
//
HGLOBAL BitmapToDIB (HDC hdc, HBITMAP hBitmap)
{
BITMAP bm = {0};
HANDLE hDib;
PBYTE lpDib,lpBits;
DWORD dwLength;
DWORD dwBits;
UINT uColorTable;
INT iNeedMore;
BOOL bDone;
INT nBitCount;
//
// Get the size of the bitmap. These values are used to setup the memory
// requirements for the DIB.
//
if (GetObject(hBitmap,sizeof(BITMAP),reinterpret_cast<PVOID>(&bm)))
{
nBitCount = bm.bmBitsPixel * bm.bmPlanes;
uColorTable = GetColorTableSize((UINT)nBitCount, BI_RGB);
dwBits = CalcBitsSize(bm.bmWidth,bm.bmHeight,nBitCount,1,sizeof(DWORD));
do
{
bDone = TRUE;
dwLength = dwBits + sizeof(BITMAPINFOHEADER) + uColorTable;
// Create the DIB. First, to the size of the bitmap.
//
if (hDib = GlobalAlloc(GHND,dwLength))
{
if (lpDib = reinterpret_cast<PBYTE>(GlobalLock(hDib)))
{
((LPBITMAPINFOHEADER)lpDib)->biSize = sizeof(BITMAPINFOHEADER);
((LPBITMAPINFOHEADER)lpDib)->biWidth = (DWORD)bm.bmWidth;
((LPBITMAPINFOHEADER)lpDib)->biHeight = (DWORD)bm.bmHeight;
((LPBITMAPINFOHEADER)lpDib)->biPlanes = 1;
((LPBITMAPINFOHEADER)lpDib)->biBitCount = (WORD)nBitCount;
((LPBITMAPINFOHEADER)lpDib)->biCompression = 0;
((LPBITMAPINFOHEADER)lpDib)->biSizeImage = 0;
((LPBITMAPINFOHEADER)lpDib)->biXPelsPerMeter = 0;
((LPBITMAPINFOHEADER)lpDib)->biYPelsPerMeter = 0;
((LPBITMAPINFOHEADER)lpDib)->biClrUsed = 0;
((LPBITMAPINFOHEADER)lpDib)->biClrImportant = 0;
// Get the size of the bitmap.
// The biSizeImage contains the bytes
// necessary to store the DIB.
//
GetDIBits(hdc,hBitmap,0,bm.bmHeight,NULL,(LPBITMAPINFO)lpDib,DIB_RGB_COLORS);
iNeedMore = ((LPBITMAPINFOHEADER)lpDib)->biSizeImage - dwBits;
if (iNeedMore > 0)
{
dwBits = dwBits + (((iNeedMore + 3) / 4)*4);
bDone = FALSE;
}
else
{
lpBits = lpDib+sizeof(BITMAPINFOHEADER)+uColorTable;
GetDIBits(hdc,hBitmap,0,bm.bmHeight,lpBits,(LPBITMAPINFO)lpDib,DIB_RGB_COLORS);
GlobalUnlock(hDib);
return(hDib);
}
GlobalUnlock(hDib);
}
GlobalFree(hDib);
}
}
while (!bDone);
}
return(NULL);
}