luckydongbin

常用用图像处理算法（二）

文件中引用文件及函数如下：

1）dibapi.h

/********************************************************************************
* DIBAPI.H
*
* Header file for Device-Independent Bitmap (DIB) API. Provides
* function prototypes and constants for DIB functions
********************************************************************************/

#ifndef __DIBAPI1_H_
#define __DIBAPI1_H_
//////////////////////////////////////////////////////////

/* Handle to a DIB */
#define HDIB HANDLE

// Dib Header Marker - used in writing DIBs to files
#define DIB_HEADER_MARKER ((WORD) ('M' << 8) | 'B')

/* DIB constants */
#define PALVERSION 0x300

/* Gray Method */
#define MEAN_GRAY   0
#define MAXIMUM_GRAY  1
#define WEIGHT_GRAY   2
#define OTHER_GRAY   3

/* DIB Macros*/
// WIDTHBYTES performs DWORD-aligning of DIB scanlines. The "bits"
// parameter is the bit count for the scanline (biWidth * biBitCount),
// and this macro returns the number of DWORD-aligned bytes needed
// to hold those bits.
#define MYWIDTHBYTES(bits)    (((bits) + 31) / 32 * 4)
#define IS_WIN30_DIB(lpbi) ((*(LPDWORD)(lpbi)) == sizeof(BITMAPINFOHEADER))
#define RECTWIDTH(lpRect)   ((lpRect)->right - (lpRect)->left)
#define RECTHEIGHT(lpRect) ((lpRect)->bottom - (lpRect)->top)
#define WaitCursorBegin() HCURSOR hcURSOR = SetCursor(LoadCursor(NULL, IDC_WAIT))
#define WaitCursorEnd()  SetCursor(hcURSOR)
#define BOUND(x, mn, mx) ((x) < (mn) ? (mn) : ((x) > (mx) ? (mx) : (x)))

// Structure use internally
typedef struct _NODE
{
BOOL bIsLeaf;               // TRUE if node has no children
UINT nPixelCount;           // Number of pixels represented by this leaf
UINT nRedSum;               // Sum of red components
UINT nGreenSum;             // Sum of green components
UINT nBlueSum;              // Sum of blue components
struct _NODE* pChild[8];    // Pointers to child nodes
struct _NODE* pNext;        // Pointer to next reducible node
} NODE;

/* function prototypes */
// DIB initialization
HANDLE LoadImgHandle(char* szImgFileName, char *strExt, int &nFileType) ;
BOOL SaveDIB (HDIB, LPCTSTR);
void DestroyDIB(HDIB hDib);

// DIB attributes
DWORD BytesPerLine(LPBYTE lpDIB);
DWORD DIBlockSize(LPBYTE lpDIB);
DWORD DIBHeight (LPBYTE lpDIB);
DWORD DIBWidth (LPBYTE lpDIB);
WORD DIBNumColors (LPBYTE lpDIB);
WORD DIBBitCount (LPBYTE lpDIB);
LPBYTE FindDIBBits (LPBYTE lpDIB);
WORD PaletteSize (LPBYTE lpDIB);

// DIB palette
HPALETTE CreateDIBPalette(LPBYTE lpDIB);
HPALETTE CreateDIBPalette(HDIB hDIB) ;

BOOL DisplayPalette(HDC hDC, LPRECT lpRect, HPALETTE hPal);
HPALETTE CopyPalette(HPALETTE hPalSrc);
HPALETTE GetSystemPalette(void);
HPALETTE CreateOctreePalette(HDIB hDIB, UINT nMaxColors, UINT nColorBits);
HPALETTE CreateOctreePalette(LPBYTE lpDIB, UINT nMaxColors, UINT nColorBits);
HPALETTE BuildOctreePalette(HANDLE hImage, UINT nMaxColors, UINT nColorBits);
//Relative functions with CreateOctreePalette
void AddColor (NODE**, BYTE, BYTE, BYTE, UINT, UINT, UINT*, NODE**);
NODE* CreateNode (UINT, UINT, UINT*, NODE**);
void ReduceTree (UINT, UINT*, NODE**);
void DeleteTree (NODE**);
void GetPaletteColors (NODE*, PALETTEENTRY*, UINT*);
int GetRightShiftCount (DWORD);
int GetLeftShiftCount (DWORD);
//Relative functions with CreateOctreePalette

//DIB operations
HDIB ConvertDIBFormat(LPBYTE lpSrcDIB, UINT nWidth, UINT nHeight, UINT nbpp, BOOL bStretch, HPALETTE hPalSrc);
HDIB ConvertDIBFormat(HDIB hDIB, UINT nWidth, UINT nHeight, UINT nbpp, BOOL bStretch, HPALETTE hPalSrc);
HDIB ConvertDIBFormat(LPBYTE lpSrcDIB, UINT nbpp, HPALETTE hPalSrc);
HDIB ConvertDIBFormat(HDIB hDIB, UINT nbpp, HPALETTE hPalSrc);
//
BOOL CopyColorTable( LPBITMAPINFO lpTarget, LPBITMAPINFO lpSource, HPALETTE hPalSrc );
HBITMAP DIBToDIBSection(LPBYTE lpDIB);
HBITMAP DIBToDIBSection(HDIB hDIB);
HBITMAP DIBToBitmap(HDIB hDIB, HPALETTE hPal) ;
HDIB ChangeDIBFormat(HDIB hDIB, WORD wBitCount, DWORD dwCompression) ;
HDIB ChangeBitmapFormat (HBITMAP hbm, WORD biBits, DWORD biCompression, HPALETTE hpal);
bool GrayEqualize(HDIB hDib);
bool GrayStretchDIB(int nMethod, HDIB hDib,BYTE bX1,BYTE bY1,BYTE bX2,BYTE bY2);
bool EliminateDirtDIB(int nMethod, HDIB hDib, CRect rect);
bool EliminateDirtDIB(int nMethod, HDIB hDib, int nCircleX, int nCircleY, int nRadius);
void SaveTo8bit_BMP(const BYTE* pbInputMat, int Width, int Height, const char* szFileName, int nGrayLevel);
HDIB ChangeDIBSize(HDIB hDIB, int nWidth, int nHeight);

int PalEntriesOnDevice (HDC hDC);
HPALETTE CreateIdentifyPalette(HPALETTE hPalSrc);
BOOL MapDIBColorsToPalette(HDIB hDIB, HPALETTE hPalette);
LONG GetPixelOffsetValue(HDIB hDib,LONG y, LONG x);
HDIB CropDIB(HDIB hDIB, LPRECT lpRect);
HDIB ColorQuantizeDIB(HDIB hDIB, UINT nColorBits, UINT nMaxColors);
HPALETTE ConvertToGrayscale(HDIB hDib, int nMethod, double fRedWeight, double fGreenWeight, double fBlueWeight);
BOOL SaveBMPFile(LPCSTR lpFileName, BITMAPINFO *pBmpInfo, BYTE *pImageBuffer);
bool GetGrayHist(const BYTE * pbImg, const int nImgWid, const int nImgHei, int *pnHist );
bool GetCumulativeHist(const int *pnHist , int nLength, long *pnCuHist);
//

//////////////////////////////////////////////////////////
#endif //__DIBAPI_H_

2)dibapi.cpp

//**********************************************************************
//
// AIBAPI.CPP
//
// Source file for Device-Independent Bitmap (DIB) API.
//
//**********************************************************************

#define STRICT // enable strict type checking

#include "stdafx.h"
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <direct.h>
#include <stdlib.h>
#include <assert.h>
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
//#include <afxcoll.h>
#include <afxtempl.h>

#include "dibapi.h"

void DestroyDIB(HDIB hDib)
{
GlobalFree(hDib);
}

BOOL SaveDIB(HDIB hDib, LPCTSTR lpFileName)
{
    BITMAPFILEHEADER    bmfHdr;     // Header for Bitmap file
    LPBITMAPINFOHEADER lpBI;       // Pointer to DIB info structure
    HANDLE              fh;         // file handle for opened file
    DWORD               dwDIBSize;
    DWORD               dwWritten;

    if (!hDib)
        return FALSE;

    fh = CreateFile(lpFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);

    if (fh == INVALID_HANDLE_VALUE)
        return FALSE;

    // Get a pointer to the DIB memory, the first of which contains
    // a BITMAPINFO structure

    lpBI = (LPBITMAPINFOHEADER)GlobalLock(hDib);
    if (!lpBI)
    {
        CloseHandle(fh);
        return FALSE;
    }

    // Check to see if we're dealing with an OS/2 DIB. If so, don't
    // save it because our functions aren't written to deal with these
    // DIBs.

    if (lpBI->biSize != sizeof(BITMAPINFOHEADER))
    {
        GlobalUnlock(hDib);
        CloseHandle(fh);
        return FALSE;
    }

    // Fill in the fields of the file header

    // Fill in file type (first 2 bytes must be "BM" for a bitmap)

    bmfHdr.bfType = DIB_HEADER_MARKER; // "BM"

    // Calculating the size of the DIB is a bit tricky (if we want to
    // do it right). The easiest way to do this is to call GlobalSize()
    // on our global handle, but since the size of our global memory may have
    // been padded a few bytes, we may end up writing out a few too
    // many bytes to the file (which may cause problems with some apps,
    // like HC 3.0).
    //
    // So, instead let's calculate the size manually.
    //
    // To do this, find size of header plus size of color table. Since the
    // first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains
    // the size of the structure, let's use this.

    // Partial Calculation

    dwDIBSize = *(LPDWORD)lpBI + PaletteSize((LPBYTE)lpBI);

    // Now calculate the size of the image

    // It's an RLE bitmap, we can't calculate size, so trust the biSizeImage
    // field

    if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
        dwDIBSize += lpBI->biSizeImage;
    else
    {
        DWORD dwBmBitsSize; // Size of Bitmap Bits only

        // It's not RLE, so size is Width (DWORD aligned) * Height

        dwBmBitsSize = MYWIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) *
                lpBI->biHeight;

        dwDIBSize += dwBmBitsSize;

        // Now, since we have calculated the correct size, why don't we
        // fill in the biSizeImage field (this will fix any .BMP files which
        // have this field incorrect).

        lpBI->biSizeImage = dwBmBitsSize;
    }

    // Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER)

    bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
    bmfHdr.bfReserved1 = 0;
    bmfHdr.bfReserved2 = 0;

    // Now, calculate the offset the actual bitmap bits will be in
    // the file -- It's the Bitmap file header plus the DIB header,
    // plus the size of the color table.
    //bfOffBits specifies the offset, in bytes, from the beginning of the BITMAPFILEHEADER structure to the bitmap bits.

bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize +
            PaletteSize((LPBYTE)lpBI);

    // Write the file header

    WriteFile(fh, (LPBYTE)&bmfHdr, sizeof(BITMAPFILEHEADER), &dwWritten, NULL);

    // Write the DIB header and the bits -- use local version of
    // MyWrite, so we can write more than 32767 bytes of data

    WriteFile(fh, (LPBYTE)lpBI, dwDIBSize, &dwWritten, NULL);

    GlobalUnlock(hDib);
    CloseHandle(fh);

    if (dwWritten == 0)
        return FALSE; // oops, something happened in the write
    else
        return TRUE; // Success code
}

/*************************************************************************
*
* FindDIBBits()
*
* Parameter:
*
* LPBYTE lpDIB      - pointer to packed-DIB memory block
*
* Return Value:
*
* LPBYTE            - pointer to the DIB bits
*
* Description:
*
* This function calculates the address of the DIB's bits and returns a
* pointer to the DIB bits.
*
************************************************************************/
LPBYTE FindDIBBits(LPBYTE lpDIB)
{
ASSERT(lpDIB);
return (lpDIB + *(LPDWORD)lpDIB + PaletteSize(lpDIB));
}

/*************************************************************************
*
* DIBWidth()
*
* Parameter:
*
* LPBYTE lpDIB      - pointer to packed-DIB memory block
*
* Return Value:
*
* DWORD            - width of the DIB
*
* Description:
*
* This function gets the width of the DIB from the BITMAPINFOHEADER
* width field if it is a Windows 3.0-style DIB or from the BITMAPCOREHEADER
* width field if it is an OS/2-style DIB.
*
************************************************************************/
DWORD DIBWidth(LPBYTE lpDIB)
{
    LPBITMAPINFOHEADER   lpbmi; // pointer to a Win 3.0-style DIB
    LPBITMAPCOREHEADER   lpbmc; // pointer to an OS/2-style DIB

    // point to the header (whether Win 3.0 and OS/2)

    lpbmi = (LPBITMAPINFOHEADER)lpDIB;
    lpbmc = (LPBITMAPCOREHEADER)lpDIB;

    // return the DIB width if it is a Win 3.0 DIB

    if (lpbmi->biSize == sizeof(BITMAPINFOHEADER))
        return lpbmi->biWidth;
    else // it is an OS/2 DIB, so return its width
        return (DWORD)lpbmc->bcWidth;
}

/*************************************************************************
*
* DIBHeight()
*
* Parameter:
*
* LPBYTE lpDIB      - pointer to packed-DIB memory block
*
* Return Value:
*
* DWORD            - height of the DIB
*
* Description:
*
* This function gets the height of the DIB from the BITMAPINFOHEADER
* height field if it is a Windows 3.0-style DIB or from the BITMAPCOREHEADER
* height field if it is an OS/2-style DIB.
*
************************************************************************/
DWORD DIBHeight(LPBYTE lpDIB)
{
   LPBITMAPINFOHEADER   lpbmi; // pointer to a Win 3.0-style DIB
   LPBITMAPCOREHEADER   lpbmc; // pointer to an OS/2-style DIB

   // point to the header (whether OS/2 or Win 3.0

   lpbmi = (LPBITMAPINFOHEADER)lpDIB;
   lpbmc = (LPBITMAPCOREHEADER)lpDIB;

    // return the DIB height if it is a Win 3.0 DIB
    if (lpbmi->biSize == sizeof(BITMAPINFOHEADER))
        return lpbmi->biHeight;
    else // it is an OS/2 DIB, so return its height
        return (DWORD)lpbmc->bcHeight;
}

/*************************************************************************
*
* PaletteSize()
*
* Parameter:
*
* LPBYTE lpDIB      - pointer to packed-DIB memory block
*
* Return Value:
*
* WORD             - size of the color palette of the DIB
*
* Description:
*
* This function gets the size required to store the DIB's palette by
* multiplying the number of colors by the size of an RGBQUAD (for a
* Windows 3.0-style DIB) or by the size of an RGBTRIPLE (for an OS/2-
* style DIB).
*
************************************************************************/
WORD PaletteSize(LPBYTE lpDIB)
{
    // calculate the size required by the palette
    if (IS_WIN30_DIB (lpDIB))
        return (DIBNumColors(lpDIB) * sizeof(RGBQUAD));
    else
        return (DIBNumColors(lpDIB) * sizeof(RGBTRIPLE));
}
WORD PaletteSize(HDIB hDIB)
{
LPBYTE lpDIB = (LPBYTE)GlobalLock(hDIB);
WORD wSize = PaletteSize(lpDIB);
GlobalUnlock(hDIB);
return wSize;
}

/*************************************************************************
*
* DIBNumColors()
*
* Parameter:
*
* LPBYTE lpDIB      - pointer to packed-DIB memory block
*
* Return Value:
*
* WORD             - number of colors in the color table
*
* Description:
*
* This function calculates the number of colors in the DIB's color table
* by finding the bits per pixel for the DIB (whether Win3.0 or OS/2-style
* DIB). If bits per pixel is 1: colors=2, if 4: colors=16, if 8: colors=256,
* if 24, no colors in color table.
*
************************************************************************/
WORD DIBNumColors(LPBYTE lpDIB)
{
    WORD wBitCount; // DIB bit count

    // If this is a Windows-style DIB, the number of colors in the
    // color table can be less than the number of bits per pixel
    // allows for (i.e. lpbi->biClrUsed can be set to some value).
    // If this is the case, return the appropriate value.


    if (IS_WIN30_DIB(lpDIB))
    {
        DWORD dwClrUsed;

        dwClrUsed = ((LPBITMAPINFOHEADER)lpDIB)->biClrUsed;
        if (dwClrUsed)

        return (WORD)dwClrUsed;
    }

    // Calculate the number of colors in the color table based on
    // the number of bits per pixel for the DIB.

    if (IS_WIN30_DIB(lpDIB))
        wBitCount = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount;
    else
        wBitCount = ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount;

    // return number of colors based on bits per pixel

    switch (wBitCount)
    {
        case 1:
            return 2;

        case 4:
            return 16;

        case 8:
            return 256;

        default:
            return 0;
    }
}

WORD DIBBitCount(LPBYTE lpDIB)
{
if (IS_WIN30_DIB(lpDIB))
        return ((LPBITMAPINFOHEADER)lpDIB)->biBitCount;
    else
        return ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount;
}

/****************************************************************************
*
*     FUNCTION: BytesPerLine
*
*     PURPOSE: Calculates the number of bytes in one scan line.
*
*    功能：计算DIB位图每条扫描线的字节数
*
*     PARAMS:   LPBYTE lpDIB - pointer to the BITMAPINFOHEADER
                              that begins the CF_DIB block
*
*  参数：指向BITMAPINFOHEADER 结构的指针
*
*     RETURNS: DWORD - number of bytes in one scan line (DWORD aligned)
*
\****************************************************************************/
DWORD BytesPerLine(LPBYTE lpDIB)
{
    return MYWIDTHBYTES(((LPBITMAPINFOHEADER)lpDIB)->biWidth * ((LPBITMAPINFOHEADER)lpDIB)->biPlanes * ((LPBITMAPINFOHEADER)lpDIB)->biBitCount);
}

/****************************************************************************
*
*     FUNCTION: DIBlockSize
*
*     PURPOSE: Calculates the number of bytes in one scan line.
*
*     PARAMS:   LPBYTE lpDIB - pointer to the BITMAPINFOHEADER
                              that begins the CF_DIB block
*
*     RETURNS: DWORD - DIB block size
*
\****************************************************************************/
DWORD DIBlockSize(LPBYTE lpDIB)
{
if (((LPBITMAPINFOHEADER)lpDIB)->biSizeImage == 0)
  ((LPBITMAPINFOHEADER)lpDIB)->biSizeImage = BytesPerLine(lpDIB) * ((LPBITMAPINFOHEADER)lpDIB)->biHeight;
return ((LPBITMAPINFOHEADER)lpDIB)->biSize + PaletteSize(lpDIB) + ((LPBITMAPINFOHEADER)lpDIB)->biSizeImage;
}

/*************************************************************************
*
* DisplayPalette ()
*
* Parameter:
*
* HDC hDC          - handle of device context to display palette
* LPRECT lpRect      - rect range to show palette
* HPALETTE hPal     - handle of palette to display
*
* Return Value:
*
* BOOL            - TRUE, if success, else FALSE
*
* Description:
*
* This function displays palette on the specified rectangle in a device context
*
************************************************************************/
BOOL DisplayPalette(HDC hDC, LPRECT lpRect, HPALETTE hPal)
{
if (! hPal)
  return FALSE;

int nEntries;
PALETTEENTRY pe[256];
nEntries = GetPaletteEntries(hPal, 0, 256, pe);
int nSqr = (int)sqrt((double)nEntries);

int nWidth = (lpRect->right-lpRect->left)/nSqr;
int nHeight = (lpRect->bottom-lpRect->top)/nSqr;
lpRect->right = lpRect->left + nWidth*nSqr;
lpRect->bottom = lpRect->top + nHeight*nSqr;

HPALETTE hOldPal = (HPALETTE)SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);

HBRUSH hBrush, hOldBrush;
int x, y;
for (int i=0; i<nEntries; ++i)
{
  x = i%nSqr;
  y = i/nSqr;
  hBrush = CreateSolidBrush(RGB(pe[i].peRed, pe[i].peGreen, pe[i].peBlue));
  hOldBrush = (HBRUSH)SelectObject(hDC, hBrush);
  Rectangle(hDC,
         lpRect->left + x*nWidth,
      lpRect->top + y*nHeight,
      lpRect->left + (x+1)*nWidth,
      lpRect->top + (y+1) *nHeight);
  SelectObject(hDC, hOldBrush);
  DeleteObject(hBrush);
}

SelectPalette(hDC, hOldPal, FALSE);

return TRUE;
}

/*************************************************************************
*
* CopyPalette ()
*
* Parameter:
*
* HPALETTE hPalSrc    - source palette handle
*
* Return Value:
*
* HPALETTE          - destination palette handle
*
* Description:
*
* This function copys the source palette to a new palette handle
*
************************************************************************/
HPALETTE CopyPalette(HPALETTE hPalSrc)
{
    PLOGPALETTE     plogPal;
    int             iNumEntries=0;
    HPALETTE        hPal;
HANDLE   h;

iNumEntries = GetPaletteEntries(hPalSrc, 0, iNumEntries, NULL);
if (iNumEntries == 0)
return (HPALETTE) NULL;

h = GlobalAlloc(GHND, sizeof(DWORD) + sizeof(PALETTEENTRY)*iNumEntries);
if (! h)
        return (HPALETTE) NULL;
plogPal = (PLOGPALETTE)GlobalLock(h);
    if (! plogPal)
        return (HPALETTE) NULL;

    plogPal->palVersion = 0x300;
    plogPal->palNumEntries = (WORD) iNumEntries;
    GetPaletteEntries(hPalSrc, 0, iNumEntries, plogPal->palPalEntry);
    hPal = CreatePalette(plogPal);

GlobalUnlock(h);
GlobalFree(h);

    return hPal;
}

/*************************************************************************
*
* PalEntriesOnDevice()
*
* Parameter:
*
* HDC hDC          - device context
*
* Return Value:
*
* int              - number of palette entries on device
*
* Description:
*
* This function gets the number of palette entries on the specified device
*
************************************************************************/
int PalEntriesOnDevice(HDC hDC)
{
    int nColors; // number of colors

    // Find out the number of colors on this device.

    nColors = (1 << (GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES)));

    assert(nColors);
    return nColors;
}

/*************************************************************************
*
* GetSystemPalette()
*
* Parameters:
*
* None
*
* Return Value:
*
* HPALETTE         - handle to a copy of the current system palette
*
* Description:
*
* This function returns a handle to a palette which represents the system
* palette. The system RGB values are copied into our logical palette using
* the GetSystemPaletteEntries function.
*
************************************************************************/
HPALETTE GetSystemPalette(void)
{
    HDC hDC;                // handle to a DC
    static HPALETTE hPal = NULL;   // handle to a palette
    HANDLE hLogPal;         // handle to a logical palette
    LPLOGPALETTE lpLogPal; // pointer to a logical palette
    int nColors;            // number of colors

    // Find out how many palette entries we want.

    hDC = GetDC(NULL);

    if (!hDC)
        return NULL;

    nColors = PalEntriesOnDevice(hDC);   // Number of palette entries

    // Allocate room for the palette and lock it.

    hLogPal = GlobalAlloc(GHND, sizeof(LOGPALETTE) + nColors *
            sizeof(PALETTEENTRY));

    // if we didn't get a logical palette, return NULL

    if (!hLogPal)
        return NULL;

    // get a pointer to the logical palette

    lpLogPal = (LPLOGPALETTE)GlobalLock(hLogPal);

    // set some important fields

    lpLogPal->palVersion = PALVERSION;
    lpLogPal->palNumEntries = WORD(nColors);

    // Copy the current system palette into our logical palette

    GetSystemPaletteEntries(hDC, 0, nColors,
            (LPPALETTEENTRY)(lpLogPal->palPalEntry));

    // Go ahead and create the palette. Once it's created,
    // we no longer need the LOGPALETTE, so free it.

    hPal = CreatePalette(lpLogPal);

    // clean up

    GlobalUnlock(hLogPal);
    GlobalFree(hLogPal);
    ReleaseDC(NULL, hDC);

    return hPal;
}

/*************************************************************************
*
* CreateIdentifyPalette ()
*
* Parameter:
*
* HPALETTE hPalSrc    - source palette handle
*
* Return Value:
*
* HPALETTE          - destination identify palette handle
*
* Description:
*
* This function creates an identify palette from the source palette handle
*
************************************************************************/
HPALETTE CreateIdentifyPalette(HPALETTE hPalSrc)
{
    BOOL bResult = FALSE;
    int i, iSysColors, iPalEntries;
    HPALETTE hPalette, hpalOld;

if (! hPalSrc)
return NULL;

// create a new palette equal to input
hPalette = CopyPalette(hPalSrc);

    // Get a screen DC to work with
    HDC hdcScreen = GetDC(NULL);
    ASSERT(hdcScreen);

    // Make sure we are on a palettized device
    if (!(GetDeviceCaps(hdcScreen, RASTERCAPS) & RC_PALETTE))
{
        TRACE("Not a palettized device");
        goto abort;
    }

    // Get the number of system colors and the number of palette entries
    // Note that on a palletized device the number of colors is the
    // number of guaranteed colors. I.e. the number of reserved system colors
    iSysColors = GetDeviceCaps(hdcScreen, NUMCOLORS);
    iPalEntries = GetDeviceCaps(hdcScreen, SIZEPALETTE);

// if there are more than 256 colors we are wasting our time
if (iSysColors > 256) goto abort;

    // Now we force the palette manager to reset its tables so that
    // the next palette to be realized will get its colors in the order they are
    // in the logical palette. This is done by changing the number of
    // reserved colors.
    SetSystemPaletteUse(hdcScreen, SYSPAL_NOSTATIC);
    SetSystemPaletteUse(hdcScreen, SYSPAL_STATIC);

    // Select our palette into the screen DC and realize it so that
    // its colors will be entered into the free slots in the physical palette
    hpalOld = ::SelectPalette(hdcScreen,
                              hPalette, // our hpal
                              FALSE);
    ::RealizePalette(hdcScreen);
    // Now replace the old palette (but don't realize it)
    ::SelectPalette(hdcScreen, hpalOld, FALSE);

    // The physical palette now has our colors set in place and its own
    // reserved colors at either end. We can grab the lot now
    PALETTEENTRY pe[256];
    GetSystemPaletteEntries(hdcScreen,
                            0,
                            iPalEntries,
                            pe);

    // Set the PC_NOCOLLAPSE flag for each of our colors so that GDI
    // won't merge them together. Be careful not to set PC_NOCOLLAPSE for the
    // sys color entries or we'll get multpile copies of these colors in
    // the palette when we realize it.
    for (i = 0; i < iSysColors/2; i++) {
        pe[i].peFlags = 0;
    }
    for (; i < iPalEntries-iSysColors/2; i++) {
        pe[i].peFlags = PC_NOCOLLAPSE;
    }
    for (; i < iPalEntries; i++) {
        pe[i].peFlags = 0;
    }

// Resize the palette in case it was smaller
ResizePalette(hPalette, iPalEntries);

    // Update the palette entries with what is now in the physical palette
    SetPaletteEntries(hPalette, 0, iPalEntries, pe);
    bResult = TRUE;

abort:
    ::ReleaseDC(NULL, hdcScreen);
    return bResult ? hPalette : NULL;
}
/*************************************************************************
*
* CopyHandle()
*
* Parameters:
*
* HANDLE h         - source handle
*
* Return Value:
*
* HANDLE           - duplicated handle
*
* Description:
*
* Copy memory handle to another
************************************************************************/
HANDLE CopyHandle(HANDLE h)
{
if (h == NULL)
  return NULL;

SIZE_T dwLen = ::GlobalSize((HGLOBAL)h);
HANDLE hCopy = ::GlobalAlloc(GHND, dwLen);
if (hCopy == NULL)
return NULL;

void* lpCopy = ::GlobalLock((HGLOBAL) hCopy);
void* lp = ::GlobalLock((HGLOBAL) h);
::CopyMemory(lpCopy, lp, dwLen);
::GlobalUnlock(hCopy);
::GlobalUnlock(h);

return hCopy;
}

LONG GetPixelOffsetValue(HDIB hDib,LONG y, LONG x)
{
WaitCursorBegin();

LPBYTE lpDIB,lpDIBBits;
DWORD lHeight;
lpDIB = (LPBYTE) GlobalLock( hDib );

lpDIBBits = FindDIBBits( lpDIB );
lHeight = DIBHeight( lpDIB );
LONG lLineBytes = BytesPerLine(lpDIB);

GlobalUnlock( hDib );
WaitCursorEnd();

return *(lpDIBBits + (lHeight-y-1)*lLineBytes+x);
}

HDIB CropDIB(HDIB hDIB, LPRECT lpRect)
{
    LPBITMAPINFO lpbmi = NULL;
    LPBYTE       lpSourceBits, lpTargetBits, lpResult;
    HDC    hDC = NULL, hSourceDC, hTargetDC;
    HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
    DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize;
int    nWidth, nHeight;
HDIB   hNewDIB;
DWORD   dwSize;

WaitCursorBegin();

// Get DIB pointer
if (! hDIB)
{
  WaitCursorEnd();
  return NULL;
}
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB);
if (! lpSrcDIB)
{
  WaitCursorEnd();
  return NULL;
}

    // Allocate and fill out a BITMAPINFO struct for the new DIB
    dwTargetHeaderSize = sizeof( BITMAPINFOHEADER ) + PaletteSize(lpSrcDIB);
    lpbmi = (LPBITMAPINFO)malloc( dwTargetHeaderSize );
memcpy(lpbmi, lpSrcDIB, dwTargetHeaderSize);
nWidth = RECTWIDTH(lpRect);
nHeight = RECTHEIGHT(lpRect);
    lpbmi->bmiHeader.biWidth = nWidth;
    lpbmi->bmiHeader.biHeight = nHeight;

    // Gonna use DIBSections and BitBlt() to do the conversion, so make 'em
hDC = GetDC( NULL );
    hTargetBitmap = CreateDIBSection( hDC, lpbmi, DIB_RGB_COLORS, (VOID **)&lpTargetBits, NULL, 0 );
    hSourceBitmap = CreateDIBSection( hDC, lpSrcDIB, DIB_RGB_COLORS, (VOID **)&lpSourceBits, NULL, 0 );
    hSourceDC = CreateCompatibleDC( hDC );
    hTargetDC = CreateCompatibleDC( hDC );

    // Flip the bits on the source DIBSection to match the source DIB
    dwSourceBitsSize = lpSrcDIB->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader));
    dwTargetBitsSize = lpbmi->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpbmi->bmiHeader));
    memcpy( lpSourceBits, FindDIBBits((LPBYTE)lpSrcDIB), dwSourceBitsSize );
    lpbmi->bmiHeader.biSizeImage = dwTargetBitsSize;

    // Select DIBSections into DCs
    hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
    hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// put old bitmap in new bitmap
    BitBlt(hTargetDC, 0, 0, nWidth, nHeight, hSourceDC, lpRect->left, lpRect->top, SRCCOPY);

    // Clean up and delete the DCs
    SelectObject( hSourceDC, hOldSourceBitmap );
    SelectObject( hTargetDC, hOldTargetBitmap );
    DeleteDC( hSourceDC );
    DeleteDC( hTargetDC );
    ReleaseDC( NULL, hDC );

    // Flush the GDI batch, so we can play with the bits
    GdiFlush();

    // Allocate enough memory for the new CF_DIB, and copy bits
dwSize = dwTargetHeaderSize + dwTargetBitsSize;
hNewDIB = GlobalAlloc(GHND, dwSize);
    lpResult = (LPBYTE)GlobalLock(hNewDIB);//malloc( dwTargetHeaderSize + dwTargetBitsSize );
    memcpy( lpResult, lpbmi, dwTargetHeaderSize );
    memcpy( FindDIBBits( (LPBYTE)lpResult ), lpTargetBits, dwTargetBitsSize );

    // final cleanup
    DeleteObject( hTargetBitmap );
    DeleteObject( hSourceBitmap );
    free( lpbmi );
GlobalUnlock(hDIB);
GlobalUnlock(hNewDIB);
WaitCursorEnd();

    return hNewDIB;
}

//对原来图像进行灰度化
BOOL SaveBMPFile(LPCSTR lpFileName, BITMAPINFO *pBmpInfo, BYTE *pImageBuffer)
{
BOOL bRVal    = TRUE;
DWORD dwBytesRead  = 0;
DWORD dwSize   = 0;
BITMAPFILEHEADER bfh = {0};
int nTable    = 0;
DWORD dwImageSize  = 0;

if (pBmpInfo->bmiHeader.biBitCount > 8) {
nTable = 0;
}
else{
nTable = 256;
}

dwImageSize = MYWIDTHBYTES(pBmpInfo->bmiHeader.biWidth * pBmpInfo->bmiHeader.biBitCount) *
pBmpInfo->bmiHeader.biHeight;

if (dwImageSize <= 0) {
  bRVal = FALSE;
}
else{
  bfh.bfType  = (WORD)'M' << 8 | 'B';
  bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + nTable * sizeof(RGBQUAD);
  bfh.bfSize  = bfh.bfOffBits + dwImageSize;

  HANDLE hFile = ::CreateFile(lpFileName,
   GENERIC_WRITE ,
   0,
   NULL,
   CREATE_ALWAYS,
   FILE_ATTRIBUTE_NORMAL,
   NULL
   );
  if (hFile == INVALID_HANDLE_VALUE) {
   bRVal = FALSE;
  }
  else{
   dwSize = sizeof(BITMAPFILEHEADER);
   ::WriteFile(hFile, &bfh, dwSize, &dwBytesRead, NULL );

dwSize = sizeof(BITMAPINFOHEADER) + nTable * sizeof(RGBQUAD);
::WriteFile(hFile, pBmpInfo, dwSize, &dwBytesRead, NULL );

dwSize = dwImageSize;
WriteFile(hFile, pImageBuffer, dwSize, &dwBytesRead, NULL );

CloseHandle(hFile);
}
}

return bRVal;
}

// Add 2007-05-09
HANDLE LoadImgHandle(char* szImgFileName, char *strExt, int &nFileType)
{

typedef HANDLE (WINAPI * PGETDIBPROC)(HWND, char *, HANDLE);
PGETDIBPROC lpFun;
HANDLE hDib;

HINSTANCE hConvertLib = LoadLibrary("Convert.dll");
ASSERT(hConvertLib != NULL);

if(strcmp(strExt,".bmp") == 0)
{
  lpFun = (PGETDIBPROC)GetProcAddress(hConvertLib, "Bmp2HDIB");
  nFileType = 1;
}
else if(strcmp(strExt,".jpg") == 0)
{
  lpFun = (PGETDIBPROC)GetProcAddress(hConvertLib, "Jpg2HDIB");
  nFileType = 2;
}
else if(strcmp(strExt,".tif") == 0)
{
  lpFun = (PGETDIBPROC)GetProcAddress(hConvertLib, "Tiff2HDIB");
  nFileType = 3;
}
else
{
  if(hConvertLib)
  {
   FreeLibrary(hConvertLib);
  }
  nFileType = -1;
  return NULL;
}
ASSERT(lpFun != NULL);

freopen("nul", "w", stdout);

hDib = (*lpFun) ( NULL, szImgFileName, NULL);

freopen("con", "w", stdout);

if(hConvertLib)
{
FreeLibrary(hConvertLib);
}

return hDib;
}

HPALETTE ConvertToGrayscale(HDIB hDib, int nMethod,
double fRedWeight, double fGreenWeight, double fBlueWeight)
{
if (hDib == NULL)
return NULL;

BITMAPINFO* lpbi = (BITMAPINFO *)GlobalLock(hDib);
if (! lpbi)
return NULL;

WaitCursorBegin();

// get color number
WORD wNumColors = DIBNumColors((LPBYTE)lpbi);
if (wNumColors == 0)  // There is no palette
{
  GlobalUnlock(hDib);
  // reduce colors to 256
  HDIB hNewDib = ColorQuantizeDIB(hDib, 8, 256);
  LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  if (! lpDIB)
  {
   WaitCursorEnd();
   return NULL;
  }
  DWORD dwSize = DIBlockSize(lpDIB);
  hDib = GlobalReAlloc(hDib, dwSize, 0);
  lpbi = (BITMAPINFO *)GlobalLock(hDib);
  CopyMemory((LPBYTE)lpbi, (LPBYTE)lpDIB, dwSize);
  GlobalUnlock(hNewDib);
  GlobalFree(hNewDib);
}

wNumColors = DIBNumColors((LPBYTE)lpbi);
BYTE GrayValue = 0;
WORD i;
switch (nMethod)
{
case MAXIMUM_GRAY:
  for (i=0; i<wNumColors; i++)
  {
   GrayValue = max(max(lpbi->bmiColors[i].rgbRed,
    lpbi->bmiColors[i].rgbGreen),
    lpbi->bmiColors[i].rgbBlue);
   lpbi->bmiColors[i].rgbRed   =
    lpbi->bmiColors[i].rgbGreen =
    lpbi->bmiColors[i].rgbBlue = GrayValue;

  }
  break;
case MEAN_GRAY:
  for (i=0; i<wNumColors; i++)
  {
   GrayValue = min(255,
    (lpbi->bmiColors[i].rgbRed +
    lpbi->bmiColors[i].rgbGreen +
    lpbi->bmiColors[i].rgbBlue)/3);
   lpbi->bmiColors[i].rgbRed   =
    lpbi->bmiColors[i].rgbGreen =
    lpbi->bmiColors[i].rgbBlue = GrayValue;
  }
  break;
case WEIGHT_GRAY:
  for (i=0; i<wNumColors; i++)
  {
   GrayValue = min(255,
    (BYTE)(lpbi->bmiColors[i].rgbRed*fRedWeight +
    lpbi->bmiColors[i].rgbGreen*fGreenWeight +
    lpbi->bmiColors[i].rgbBlue*fBlueWeight));
   lpbi->bmiColors[i].rgbRed   =
    lpbi->bmiColors[i].rgbGreen =
    lpbi->bmiColors[i].rgbBlue = GrayValue;
  }
  break;
case OTHER_GRAY: //该法旨在通过有选择的灰度化。
  for ( i = 0; i<wNumColors; i++)
  {
   BYTE b,g,r;
   r = lpbi->bmiColors[i].rgbRed;
   g = lpbi->bmiColors[i].rgbGreen;
   b = lpbi->bmiColors[i].rgbBlue;
   double h,s;
   h = 180.0/3.1415926*acos((2*r-g-b)/2.0/sqrt(pow(float(r-g),2)+(r-b)*(g-b)));
   s = 1 - 3.0/(r+g+b)*min((r,g),(r,b));
   if( b >(r+g))//为蓝色降低蓝色比例
    GrayValue = 0;
   else
    GrayValue = min(255,
    (BYTE)(lpbi->bmiColors[i].rgbRed*0.5 +
    lpbi->bmiColors[i].rgbGreen*0.4 +
    lpbi->bmiColors[i].rgbBlue*0.1));

   lpbi->bmiColors[i].rgbRed   =
    lpbi->bmiColors[i].rgbGreen =
    lpbi->bmiColors[i].rgbBlue = GrayValue;
  }
  break;
}
GlobalUnlock(hDib);
WaitCursorEnd();

return CreateDIBPalette(hDib);
}
HDIB ColorQuantizeDIB(HDIB hDIB, UINT nColorBits, UINT nMaxColors)
{
HPALETTE hPal = NULL;

WaitCursorBegin();

// color quantization palette
LPBYTE lpDIB = (LPBYTE)GlobalLock(hDIB);

hPal = CreateOctreePalette(lpDIB, nMaxColors, nColorBits);

GlobalUnlock(hDIB);

// convert DIB to new format
HDIB hNewDIB = ConvertDIBFormat(hDIB, nColorBits, hPal);

WaitCursorEnd();

return hNewDIB;
}

/*************************************************************************
*
* CreateDIBPalette()
*
* Parameter:
*
* LPBYTE lpbi       - specifies the DIB
*
* Return Value:
*
* HPALETTE         - specifies the palette
*
* Description:
*
* This function creates a palette from a DIB by allocating memory for the
* logical palette, reading and storing the colors from the DIB's color table
* into the logical palette, creating a palette from this logical palette,
* and then returning the palette's handle. This allows the DIB to be
* displayed using the best possible colors (important for DIBs with 256 or
* more colors).
*
************************************************************************/
HPALETTE CreateDIBPalette(LPBYTE lpbi)
{
LPLOGPALETTE        lpPal;          // pointer to a logical palette
HANDLE              hLogPal;        // handle to a logical palette
HPALETTE            hPal = NULL;    // handle to a palette
int                 i, wNumColors; // loop index, number of colors in color table
LPBITMAPINFO        lpbmi;          // pointer to BITMAPINFO structure (Win3.0)
LPBITMAPCOREINFO    lpbmc;          // pointer to BITMAPCOREINFO structure (OS/2)
BOOL                bWinStyleDIB;   // Win3.0 DIB?

// if handle to DIB is invalid, return NULL

if (! lpbi)
return NULL;

// get pointer to BITMAPINFO (Win 3.0)

lpbmi = (LPBITMAPINFO)lpbi;

// get pointer to BITMAPCOREINFO (OS/2 1.x)

lpbmc = (LPBITMAPCOREINFO)lpbi;

// get the number of colors in the DIB

wNumColors = DIBNumColors(lpbi);

// is this a Win 3.0 DIB?

bWinStyleDIB = IS_WIN30_DIB(lpbi);
if (wNumColors)
{
// allocate memory block for logical palette

hLogPal = GlobalAlloc(GHND, sizeof(LOGPALETTE) +
sizeof(PALETTEENTRY) * wNumColors);

// if not enough memory, clean up and return NULL

if (!hLogPal)
return NULL;

// lock memory block and get pointer to it

lpPal = (LPLOGPALETTE)GlobalLock(hLogPal);

// set version and number of palette entries

lpPal->palVersion = PALVERSION;
lpPal->palNumEntries = wNumColors;

// store RGB triples (if Win 3.0 DIB) or RGB quads (if OS/2 DIB)
// into palette

  for (i = 0; i < wNumColors; i++)
  {
   if (bWinStyleDIB)
   {
    lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
    lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
    lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
    lpPal->palPalEntry[i].peFlags = 0;
   }
   else
   {
    lpPal->palPalEntry[i].peRed = lpbmc->bmciColors[i].rgbtRed;
    lpPal->palPalEntry[i].peGreen = lpbmc->bmciColors[i].rgbtGreen;
    lpPal->palPalEntry[i].peBlue = lpbmc->bmciColors[i].rgbtBlue;
    lpPal->palPalEntry[i].peFlags = 0;
   }
  }

// create the palette and get handle to it

hPal = CreatePalette(lpPal);

// if error getting handle to palette, clean up and return NULL

  if (!hPal)
  {
   GlobalUnlock(hLogPal);
   GlobalFree(hLogPal);
   return NULL;
  }
}

// return handle to DIB's palette
return hPal;
}

/*************************************************************************
*
* CreateDIBPalette()
*
* Parameter:
*
* HDIB hDIB        - specifies the DIB
*
* Return Value:
*
* HPALETTE         - specifies the palette
*
* Description:
*
* This function creates a palette from a DIB by allocating memory for the
* logical palette, reading and storing the colors from the DIB's color table
* into the logical palette, creating a palette from this logical palette,
* and then returning the palette's handle. This allows the DIB to be
* displayed using the best possible colors (important for DIBs with 256 or
* more colors).
*
************************************************************************/
HPALETTE CreateDIBPalette(HDIB hDIB)
{
HPALETTE           hPal = NULL;    // handle to a palette
LPBYTE               lpbi;           // pointer to packed-DIB

// if handle to DIB is invalid, return NULL

if (!hDIB)
return NULL;

// lock DIB memory block and get a pointer to it

lpbi = (LPBYTE)GlobalLock(hDIB);

hPal = CreateDIBPalette(lpbi);

// Unlock hDIB
GlobalUnlock(hDIB);

// return handle to DIB's palette
return hPal;
}

HPALETTE CreateOctreePalette(HDIB hDIB, UINT nMaxColors, UINT nColorBits)
{
HANDLE hImage;

hImage = DIBToDIBSection(hDIB);
if (! hImage)
return NULL;
return BuildOctreePalette(hImage, nMaxColors, nColorBits);
}

HPALETTE CreateOctreePalette(LPBYTE lpDIB, UINT nMaxColors, UINT nColorBits)
{
HANDLE hImage;

hImage = DIBToDIBSection(lpDIB);
if (! hImage)
return NULL;
return BuildOctreePalette(hImage, nMaxColors, nColorBits);
}

HPALETTE BuildOctreePalette(HANDLE hImage, UINT nMaxColors, UINT nColorBits)
{
DIBSECTION ds;
int i, j, nPad;
BYTE* pbBits;
WORD* pwBits;
DWORD* pdwBits;
DWORD rmask, gmask, bmask;
int rright, gright, bright;
int rleft, gleft, bleft;
BYTE r, g, b;
WORD wColor;
DWORD dwColor, dwSize;
LOGPALETTE* plp;
HPALETTE hPalette;
NODE* pTree;
UINT nLeafCount, nIndex;
NODE* pReducibleNodes[9];
HDC hdc;
BYTE* pBuffer;
BITMAPINFO bmi;

// Initialize octree variables
pTree = NULL;
nLeafCount = 0;
if (nColorBits > 8) // Just in case
return NULL;
for (i=0; i<=(int) nColorBits; i++)
pReducibleNodes[i] = NULL;

// Scan the DIB and build the octree
GetObject (hImage, sizeof (ds), &ds);
nPad = ds.dsBm.bmWidthBytes - (((ds.dsBmih.biWidth *
ds.dsBmih.biBitCount) + 7) / 8);

switch (ds.dsBmih.biBitCount) {

case 1: // 1-bit DIB
case 4: // 4-bit DIB
case 8: // 8-bit DIB
  //
  // The strategy here is to use ::GetDIBits to convert the
  // image into a 24-bit DIB one scan line at a time. A pleasant
  // side effect of using ::GetDIBits in this manner is that RLE-
  // encoded 4-bit and 8-bit DIBs will be uncompressed.        //
  hdc = GetDC (NULL);
  pBuffer = new BYTE[ds.dsBmih.biWidth * 3];
  ZeroMemory (&bmi, sizeof (bmi));
  bmi.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth = ds.dsBmih.biWidth;
  bmi.bmiHeader.biHeight = ds.dsBmih.biHeight;
  bmi.bmiHeader.biPlanes = 1;
  bmi.bmiHeader.biBitCount = 24;
  bmi.bmiHeader.biCompression = BI_RGB;
  for (i=0; i<ds.dsBmih.biHeight; i++)
  {
   GetDIBits (hdc, (HBITMAP) hImage, i, 1, pBuffer, &bmi,
    DIB_RGB_COLORS);
   pbBits = pBuffer;
   for (j=0; j<ds.dsBmih.biWidth; j++)
   {
    b = *pbBits++;
    g = *pbBits++;
    r = *pbBits++;
    AddColor (&pTree, r, g, b, nColorBits, 0, &nLeafCount,
     pReducibleNodes);
    while (nLeafCount > nMaxColors)
     ReduceTree (nColorBits, &nLeafCount, pReducibleNodes);
   }
  }
  delete pBuffer;
  ReleaseDC (NULL, hdc);
  break;

case 16: // One case for 16-bit DIBs
  if (ds.dsBmih.biCompression == BI_BITFIELDS) {
   rmask = ds.dsBitfields[0];
   gmask = ds.dsBitfields[1];
   bmask = ds.dsBitfields[2];
  }
  else {
   rmask = 0x7C00;
   gmask = 0x03E0;
   bmask = 0x001F;
  }

  rright = GetRightShiftCount (rmask);
  gright = GetRightShiftCount (gmask);
  bright = GetRightShiftCount (bmask);

  rleft = GetLeftShiftCount (rmask);
  gleft = GetLeftShiftCount (gmask);
  bleft = GetLeftShiftCount (bmask);

  pwBits = (WORD*) ds.dsBm.bmBits;
  for (i=0; i<ds.dsBmih.biHeight; i++) {
   for (j=0; j<ds.dsBmih.biWidth; j++) {
    wColor = *pwBits++;
    b = (BYTE) (((wColor & (WORD) bmask) >> bright) << bleft);
    g = (BYTE) (((wColor & (WORD) gmask) >> gright) << gleft);
    r = (BYTE) (((wColor & (WORD) rmask) >> rright) << rleft);
    AddColor (&pTree, r, g, b, nColorBits, 0, &nLeafCount,
     pReducibleNodes);
    while (nLeafCount > nMaxColors)
     ReduceTree (nColorBits, &nLeafCount, pReducibleNodes);
   }
   pwBits = (WORD*) (((BYTE*) pwBits) + nPad);
  }
  break;

case 24: // Another for 24-bit DIBs
  pbBits = (BYTE*) ds.dsBm.bmBits;
  for (i=0; i<ds.dsBmih.biHeight; i++) {
   for (j=0; j<ds.dsBmih.biWidth; j++) {
    b = *pbBits++;
    g = *pbBits++;
    r = *pbBits++;
    AddColor (&pTree, r, g, b, nColorBits, 0, &nLeafCount,
     pReducibleNodes);
    while (nLeafCount > nMaxColors)
     ReduceTree (nColorBits, &nLeafCount, pReducibleNodes);
   }
   pbBits += nPad;
  }
  break;

case 32: // And another for 32-bit DIBs
  if (ds.dsBmih.biCompression == BI_BITFIELDS) {
   rmask = ds.dsBitfields[0];
   gmask = ds.dsBitfields[1];
   bmask = ds.dsBitfields[2];
  }
  else {
   rmask = 0x00FF0000;
   gmask = 0x0000FF00;
   bmask = 0x000000FF;
  }

  rright = GetRightShiftCount (rmask);
  gright = GetRightShiftCount (gmask);
  bright = GetRightShiftCount (bmask);

  pdwBits = (DWORD*) ds.dsBm.bmBits;
  for (i=0; i<ds.dsBmih.biHeight; i++) {
   for (j=0; j<ds.dsBmih.biWidth; j++) {
    dwColor = *pdwBits++;
    b = (BYTE) ((dwColor & bmask) >> bright);
    g = (BYTE) ((dwColor & gmask) >> gright);
    r = (BYTE) ((dwColor & rmask) >> rright);
    AddColor (&pTree, r, g, b, nColorBits, 0, &nLeafCount,
     pReducibleNodes);
    while (nLeafCount > nMaxColors)
     ReduceTree (nColorBits, &nLeafCount, pReducibleNodes);
   }
   pdwBits = (DWORD*) (((BYTE*) pdwBits) + nPad);
  }
  break;

default: // DIB must be 16, 24, or 32-bit!
return NULL;
}

if (nLeafCount > nMaxColors) { // Sanity check
DeleteTree (&pTree);
return NULL;
}

// Create a logical palette from the colors in the octree
dwSize = sizeof (LOGPALETTE) + ((nLeafCount - 1) * sizeof (PALETTEENTRY));
if ((plp = (LOGPALETTE*) HeapAlloc (GetProcessHeap (), 0,
  dwSize)) == NULL) {
   DeleteTree (&pTree);
   return NULL;
}

plp->palVersion = 0x300;
plp->palNumEntries = (WORD) nLeafCount;
nIndex = 0;
GetPaletteColors (pTree, plp->palPalEntry, &nIndex);
hPalette = CreatePalette (plp);

HeapFree (GetProcessHeap (), 0, plp);
DeleteTree (&pTree);
return hPalette;
}

void AddColor (NODE** ppNode, BYTE r, BYTE g, BYTE b, UINT nColorBits,
UINT nLevel, UINT* pLeafCount, NODE** pReducibleNodes)
{
int nIndex, shift;
static BYTE mask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };

// If the node doesn't exist, create it
if (*ppNode == NULL)
*ppNode = CreateNode (nLevel, nColorBits, pLeafCount,
pReducibleNodes);

// Update color information if it's a leaf node
if ((*ppNode)->bIsLeaf) {
  (*ppNode)->nPixelCount++;
  (*ppNode)->nRedSum += r;
  (*ppNode)->nGreenSum += g;
  (*ppNode)->nBlueSum += b;
}

// Recurse a level deeper if the node is not a leaf
else {
  shift = 7 - nLevel;
  nIndex = (((r & mask[nLevel]) >> shift) << 2) |
   (((g & mask[nLevel]) >> shift) << 1) |
   ((b & mask[nLevel]) >> shift);
  AddColor (&((*ppNode)->pChild[nIndex]), r, g, b, nColorBits,
   nLevel + 1, pLeafCount, pReducibleNodes);
}
}

NODE* CreateNode (UINT nLevel, UINT nColorBits, UINT* pLeafCount,
NODE** pReducibleNodes)
{
NODE* pNode;

if ((pNode = (NODE*) HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
sizeof (NODE))) == NULL)
return NULL;

pNode->bIsLeaf = (nLevel == nColorBits) ? TRUE : FALSE;
if (pNode->bIsLeaf)
  (*pLeafCount)++;
else { // Add the node to the reducible list for this level
  pNode->pNext = pReducibleNodes[nLevel];
  pReducibleNodes[nLevel] = pNode;
}
return pNode;
}

void ReduceTree (UINT nColorBits, UINT* pLeafCount, NODE** pReducibleNodes)
{
int i;
NODE* pNode;
UINT nRedSum, nGreenSum, nBlueSum, nChildren;

// Find the deepest level containing at least one reducible node
for (i=nColorBits - 1; (i>0) && (pReducibleNodes[i] == NULL); i--);

// Reduce the node most recently added to the list at level i
pNode = pReducibleNodes[i];
pReducibleNodes[i] = pNode->pNext;

nRedSum = nGreenSum = nBlueSum = nChildren = 0;
for (i=0; i<8; i++) {
  if (pNode->pChild[i] != NULL) {
   nRedSum += pNode->pChild[i]->nRedSum;
   nGreenSum += pNode->pChild[i]->nGreenSum;
   nBlueSum += pNode->pChild[i]->nBlueSum;
   pNode->nPixelCount += pNode->pChild[i]->nPixelCount;
   HeapFree (GetProcessHeap (), 0, pNode->pChild[i]);
   pNode->pChild[i] = NULL;
   nChildren++;
  }
}

pNode->bIsLeaf = TRUE;
pNode->nRedSum = nRedSum;
pNode->nGreenSum = nGreenSum;
pNode->nBlueSum = nBlueSum;
*pLeafCount -= (nChildren - 1);
}

void DeleteTree (NODE** ppNode)
{
int i;

for (i=0; i<8; i++) {
if ((*ppNode)->pChild[i] != NULL)
DeleteTree (&((*ppNode)->pChild[i]));
}
HeapFree (GetProcessHeap (), 0, *ppNode);
*ppNode = NULL;
}

void GetPaletteColors (NODE* pTree, PALETTEENTRY* pPalEntries, UINT* pIndex)
{
int i;

if (pTree->bIsLeaf) {
  pPalEntries[*pIndex].peRed =
   (BYTE) ((pTree->nRedSum) / (pTree->nPixelCount));
  pPalEntries[*pIndex].peGreen =
   (BYTE) ((pTree->nGreenSum) / (pTree->nPixelCount));
  pPalEntries[*pIndex].peBlue =
   (BYTE) ((pTree->nBlueSum) / (pTree->nPixelCount));
  (*pIndex)++;
}
else {
  for (i=0; i<8; i++) {
   if (pTree->pChild[i] != NULL)
    GetPaletteColors (pTree->pChild[i], pPalEntries, pIndex);
  }
}
}

int GetRightShiftCount (DWORD dwVal)
{
int i;

for (i=0; i<sizeof (DWORD) * 8; i++) {
  if (dwVal & 1)
   return i;
  dwVal >>= 1;
}
return -1;
}

int GetLeftShiftCount (DWORD dwVal)
{
int nCount, i;

nCount = 0;
for (i=0; i<sizeof (DWORD) * 8; i++) {
  if (dwVal & 1)
   nCount++;
  dwVal >>= 1;
}
return (8 - nCount);
}

/*************************************************************************
*
* ChangeDIBFormat()
*
* Parameter:
*
* HDIB             - handle to packed-DIB in memory
*
*     -DIB内存块句柄
*
* WORD             - desired bits per pixel
*     -希望的每像素位数
*
* DWORD            - desired compression format
*     -希望的压缩格式
*
* Return Value:
*
* HDIB             - handle to the new DIB if successful, else NULL
*     -新的位图句柄
*
* Description:
*
* This function will convert the bits per pixel and/or the compression
* format of the specified DIB. Note: If the conversion was unsuccessful,
* we return NULL. The original DIB is left alone. Don't use code like the
* following:
*
*    hMyDIB = ChangeDIBFormat(hMyDIB, 8, BI_RLE4);
*
* The conversion will fail, but hMyDIB will now be NULL and the original
* DIB will now hang around in memory. We could have returned the old
* DIB, but we wanted to allow the programmer to check whether this
* conversion succeeded or failed.
* 注意：本函数将DIB转化为指定格式DDB，源位图将不被修改，不要象下例一样调用
*   hMyDIB = ChangeDIBFormat(hMyDIB,8,BI_RLE4)
*   否则转化将失败，hMyDIB将为NULL，而源位图所站的内存将不被释放。
*
*
************************************************************************/
HDIB ChangeDIBFormat(HDIB hDIB, WORD wBitCount, DWORD dwCompression)
{
HBITMAP            hBitmap;         // Handle to bitmap
HDIB               hNewDIB = NULL; // Handle to new DIB
HPALETTE           hPal;   // Handle to palette

// Check for a valid DIB handle

if (!hDIB)
return NULL;

// Save the old DIB's palette

hPal = CreateDIBPalette(hDIB);
if (hPal == NULL)
hPal = (HPALETTE)GetStockObject(DEFAULT_PALETTE);

// Convert old DIB to a bitmap

hBitmap = DIBToBitmap(hDIB, hPal);
if (!hBitmap)
{
DeleteObject(hPal);
return NULL;
}

// Change bitmap format

hNewDIB = ChangeBitmapFormat(hBitmap, wBitCount, dwCompression, hPal);

// Clean up and return

DeleteObject(hBitmap);
DeleteObject(hPal);

return hNewDIB;
}

/****************************************************************************
*
*     FUNCTION: ConvertDIBFormat
*
*     PURPOSE: Creates a new DIB of the requested format, copies the source
*               image to the new DIB.
*
*  功能：用指定的格式来创建DIB，将源图像拷贝到新DIB中
*
*     PARAMS:   LPBITMAPINFO lpSrcDIB - the source CF_DIB
*               UINT         nWidth   - width for new DIB
*               UINT         nHeight - height for new DIB
*               UINT         nbpp     - bpp for new DIB
*               BOOL         bStretch - TRUE to stretch source to dest
*                                       FALSE to take upper left of image
*      TRUE:伸缩源位图到目标位图，FALSE:按原图像大小进行显示，起点为左上角
HPALETTE hPalSrc - Palette used to set new DIB
*    DWORD   dwSize   - return the size of new DIB pointer
*
*     RETURNS: HDIB - Handle of CF_DIB memory block with new image
*               NULL on failure
*
\****************************************************************************/
HDIB ConvertDIBFormat(LPBYTE lpDIB, UINT nWidth, UINT nHeight, UINT nbpp, BOOL bStretch, HPALETTE hPalSrc)
{
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)lpDIB;
LPBITMAPINFO lpbmi = NULL;
LPBYTE       lpSourceBits, lpTargetBits, lpResult;
HDC    hDC = NULL, hSourceDC, hTargetDC;
HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize, dwColorNum;
HDIB   hDib;

// Allocate and fill out a BITMAPINFO struct for the new DIB
if (nbpp <= 8)
  dwColorNum = 1 << nbpp;
else
  dwColorNum = 0;
dwTargetHeaderSize = sizeof( BITMAPINFO ) + ( dwColorNum * sizeof( RGBQUAD ) );
lpbmi = (LPBITMAPINFO)malloc( dwTargetHeaderSize );
lpbmi->bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
lpbmi->bmiHeader.biWidth = nWidth;
lpbmi->bmiHeader.biHeight = nHeight;
lpbmi->bmiHeader.biPlanes = 1;
lpbmi->bmiHeader.biBitCount = nbpp;
lpbmi->bmiHeader.biCompression = BI_RGB;
lpbmi->bmiHeader.biSizeImage = 0;
lpbmi->bmiHeader.biXPelsPerMeter = 0;
lpbmi->bmiHeader.biYPelsPerMeter = 0;
lpbmi->bmiHeader.biClrUsed = 0;
lpbmi->bmiHeader.biClrImportant = 0;
// Fill in the color table
if( ! CopyColorTable( lpbmi, (LPBITMAPINFO)lpSrcDIB, hPalSrc ) )
{
  free( lpbmi );
  return NULL;
}

// Gonna use DIBSections and BitBlt() to do the conversion, so make 'em
hDC = GetDC( NULL );
hTargetBitmap = CreateDIBSection( hDC, lpbmi, DIB_RGB_COLORS, (VOID **)&lpTargetBits, NULL, 0 );
hSourceBitmap = CreateDIBSection( hDC, lpSrcDIB, DIB_RGB_COLORS, (VOID **)&lpSourceBits, NULL, 0 );
hSourceDC = CreateCompatibleDC( hDC );
hTargetDC = CreateCompatibleDC( hDC );

// Flip the bits on the source DIBSection to match the source DIB
dwSourceBitsSize = lpSrcDIB->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader));
dwTargetBitsSize = lpbmi->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpbmi->bmiHeader));
memcpy( lpSourceBits, FindDIBBits((LPBYTE)lpSrcDIB), dwSourceBitsSize );
lpbmi->bmiHeader.biSizeImage = dwTargetBitsSize;

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// Set the color tables for the DIBSections
if( lpSrcDIB->bmiHeader.biBitCount <= 8 )
SetDIBColorTable( hSourceDC, 0, 1 << lpSrcDIB->bmiHeader.biBitCount, lpSrcDIB->bmiColors );
if( lpbmi->bmiHeader.biBitCount <= 8 )
SetDIBColorTable( hTargetDC, 0, 1 << lpbmi->bmiHeader.biBitCount, lpbmi->bmiColors );

// If we are asking for a straight copy, do it
if( (lpSrcDIB->bmiHeader.biWidth==lpbmi->bmiHeader.biWidth) && (lpSrcDIB->bmiHeader.biHeight==lpbmi->bmiHeader.biHeight) )
{
  BitBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, SRCCOPY );
}
else
{
  // else, should we stretch it?
  if( bStretch )
  {
   SetStretchBltMode( hTargetDC, COLORONCOLOR );
   StretchBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, lpSrcDIB->bmiHeader.biWidth, lpSrcDIB->bmiHeader.biHeight, SRCCOPY );
  }
  else
  {
   // or just take the upper left corner of the source
   BitBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, SRCCOPY );
  }
}

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
SelectObject( hTargetDC, hOldTargetBitmap );
DeleteDC( hSourceDC );
DeleteDC( hTargetDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

// Allocate enough memory for the new CF_DIB, and copy bits
hDib = GlobalAlloc(GHND, dwTargetHeaderSize + dwTargetBitsSize );
lpResult = (LPBYTE)GlobalLock(hDib);
memcpy( lpResult, lpbmi, dwTargetHeaderSize );
memcpy( FindDIBBits( (LPBYTE)lpResult ), lpTargetBits, dwTargetBitsSize );

// final cleanup
DeleteObject( hTargetBitmap );
DeleteObject( hSourceBitmap );
free( lpbmi );
GlobalUnlock(hDib);

return hDib;
}
/* End ConvertDIBFormat() 1***************************************************/

/****************************************************************************
*
*     FUNCTION: ConvertDIBFormat
*
*     PURPOSE: Creates a new DIB of the requested format, copies the source
*               image to the new DIB.
*
*     PARAMS:   HDIB   hDIB     - the source CF_DIB
*               UINT         nWidth   - width for new DIB
*               UINT         nHeight - height for new DIB
*               UINT         nbpp     - bpp for new DIB
*               BOOL         bStretch - TRUE to stretch source to dest
*                                       FALSE to take upper left of image
*    HPALETTE hPalSrc - Palette used to set new DIB
*
*     RETURNS: HDIB - new CF_DIB handle
*
\****************************************************************************/
HDIB ConvertDIBFormat(HDIB hDIB, UINT nWidth, UINT nHeight, UINT nbpp, BOOL bStretch, HPALETTE hPalSrc)
{
LPBITMAPINFO lpbmi = NULL;
LPBYTE       lpSourceBits, lpTargetBits, lpResult;
HDC    hDC = NULL, hSourceDC, hTargetDC;
HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize, dwColorNum;
HDIB   hNewDIB;
DWORD   dwSize;

// Get DIB pointer
if (! hDIB)
return NULL;
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB);
if (! lpSrcDIB)
return NULL;

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
SelectObject( hTargetDC, hOldTargetBitmap );
DeleteDC( hSourceDC );
DeleteDC( hTargetDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

// Allocate enough memory for the new CF_DIB, and copy bits
dwSize = dwTargetHeaderSize + dwTargetBitsSize;
hNewDIB = GlobalAlloc(GHND, dwSize);
lpResult = (LPBYTE)GlobalLock(hNewDIB);//malloc( dwTargetHeaderSize + dwTargetBitsSize );
memcpy( lpResult, lpbmi, dwTargetHeaderSize );
memcpy( FindDIBBits( (LPBYTE)lpResult ), lpTargetBits, dwTargetBitsSize );

// final cleanup
DeleteObject( hTargetBitmap );
DeleteObject( hSourceBitmap );
free( lpbmi );
GlobalUnlock(hDIB);
GlobalUnlock(hNewDIB);

return hNewDIB;
}
/* End ConvertDIBFormat() 2***************************************************/

/****************************************************************************
*
*     FUNCTION: ConvertDIBFormat
*
*     PURPOSE: Creates a new DIB of the requested format, copies the source
*               image to the new DIB.
*
*     PARAMS:   LPBYTE   lpDIB    - the source CF_DIB
*               UINT         nbpp     - bpp for new DIB
*    HPALETTE hPalSrc - Palette used to set new DIB
*
*     RETURNS: HDIB - new CF_DIB handle
*
\****************************************************************************/
HDIB ConvertDIBFormat(LPBYTE lpDIB, UINT nbpp, HPALETTE hPalSrc)
{
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)lpDIB;
LPBITMAPINFO lpbmi = NULL;
LPBYTE       lpSourceBits, lpTargetBits, lpResult;
HDC    hDC = NULL, hSourceDC, hTargetDC;
HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize, dwColorNum;
HDIB   hNewDIB;
DWORD   dwSize;
int    nWidth, nHeight;

nWidth = lpSrcDIB->bmiHeader.biWidth;
nHeight = lpSrcDIB->bmiHeader.biHeight;

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// We are asking for a straight copy, do it
BitBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, SRCCOPY );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
SelectObject( hTargetDC, hOldTargetBitmap );
DeleteDC( hSourceDC );
DeleteDC( hTargetDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

// final cleanup
DeleteObject( hTargetBitmap );
DeleteObject( hSourceBitmap );
free( lpbmi );
GlobalUnlock(hNewDIB);

return hNewDIB;
}
/* End ConvertDIBFormat() 3***************************************************/

/****************************************************************************
*
*     FUNCTION: ConvertDIBFormat
*
*     PURPOSE: Creates a new DIB of the requested format, copies the source
*               image to the new DIB.
*
*     PARAMS:   HDIB   hDIB     - the source CF_DIB
*               UINT         nbpp     - bpp for new DIB
*    HPALETTE hPalSrc - Palette used to set new DIB
*
*     RETURNS: HDIB - new CF_DIB handle
*
\****************************************************************************/
HDIB ConvertDIBFormat(HDIB hDIB, UINT nbpp, HPALETTE hPalSrc)
{
LPBITMAPINFO lpbmi = NULL;
LPBYTE       lpSourceBits, lpTargetBits, lpResult;
HDC    hDC = NULL, hSourceDC, hTargetDC;
HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize, dwColorNum;
HANDLE   hNewDIB;
DWORD   dwSize;
int    nWidth, nHeight;

// Get DIB pointer
if (! hDIB)
return NULL;
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB);
if (! lpSrcDIB)
return NULL;
nWidth = lpSrcDIB->bmiHeader.biWidth;
nHeight = lpSrcDIB->bmiHeader.biHeight;

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// We are asking for a straight copy, do it
BitBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, SRCCOPY );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
SelectObject( hTargetDC, hOldTargetBitmap );
DeleteDC( hSourceDC );
DeleteDC( hTargetDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

// final cleanup
DeleteObject( hTargetBitmap );
DeleteObject( hSourceBitmap );
free( lpbmi );
GlobalUnlock(hDIB);
GlobalUnlock(hNewDIB);

return hNewDIB;
}
/* End ConvertDIBFormat() 4***************************************************/

/****************************************************************************
*
*     FUNCTION: CopyColorTable
*
*     PURPOSE: Copies the color table from one CF_DIB to another.
*
*  功能：用于格式转换时颜色表的拷贝，保证不丢失颜色，如果DIB从高颜色分辨率到
*     低颜色分辨率的转化时，用此函数进行量化，并调用创建相应调色板函数CreateOctreePalette
*
*     PARAMS:   LPBITMAPINFO lpTarget - pointer to target DIB
*               LPBITMAPINFO lpSource - pointer to source DIB
*
*     RETURNS: BOOL - TRUE for success, FALSE for failure
*
\****************************************************************************/
BOOL CopyColorTable( LPBITMAPINFO lpTarget, LPBITMAPINFO lpSource, HPALETTE hPalSrc )
{
// What we do depends on the target's color depth
switch( lpTarget->bmiHeader.biBitCount )
{
  // 8bpp - need 256 entry color table
case 8:
  if (hPalSrc)
  { // Palette is provided, use it
   PALETTEENTRY    pe[256];
   UINT            i;

   GetPaletteEntries( hPalSrc, 0, 256, pe );
   for(i=0;i<256;i++)
   {
    lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
    lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
    lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
    lpTarget->bmiColors[i].rgbReserved = 0;
   }
  }
  else
  { // no palette povided
   if( lpSource->bmiHeader.biBitCount == 8 )
   { // Source is 8bpp too, copy color table
    memcpy( lpTarget->bmiColors, lpSource->bmiColors, 256*sizeof(RGBQUAD) );
   }
   else
   { // Source is != 8bpp, use Octree algorithm to create palette
    HPALETTE        hPal;
    HDC            hDC = GetDC( NULL );
    PALETTEENTRY    pe[256];
    UINT            i;

    hPal = CreateOctreePalette((LPBYTE)lpSource, 236, 8);
    if (! hPal) // use halftone palette
     hPal = CreateHalftonePalette( hDC );
    ReleaseDC( NULL, hDC );

    GetPaletteEntries( hPal, 0, 256, pe );
    DeleteObject( hPal );
    for(i=0;i<256;i++)
    {
     lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
     lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
     lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
     lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
    }
   }
  }
  break; // end 8bpp

  // 4bpp - need 16 entry color table
case 4:
  if (hPalSrc)
  { // Palette is provided, use it
   PALETTEENTRY    pe[16];
   UINT            i;

   GetPaletteEntries( hPalSrc, 0, 16, pe );
   for(i=0;i<16;i++)
   {
    lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
    lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
    lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
    lpTarget->bmiColors[i].rgbReserved = 0;
   }
  }
  else
  { // No palette is provided
   if( lpSource->bmiHeader.biBitCount == 4 )
   { // Source is 4bpp too, copy color table
    memcpy( lpTarget->bmiColors, lpSource->bmiColors, 16*sizeof(RGBQUAD) );
   }
   else
   { // Source is != 4bpp, use system palette
    HPALETTE        hPal;
    PALETTEENTRY    pe[256];
    UINT            i;

    hPal = (HPALETTE)GetStockObject( DEFAULT_PALETTE );
    GetPaletteEntries( hPal, 0, 16, pe );
    for(i=0;i<16;i++)
    {
     lpTarget->bmiColors[i].rgbRed = pe[i].peRed;
     lpTarget->bmiColors[i].rgbGreen = pe[i].peGreen;
     lpTarget->bmiColors[i].rgbBlue = pe[i].peBlue;
     lpTarget->bmiColors[i].rgbReserved = pe[i].peFlags;
    }
   }
  }
  break; // end 4bpp

  // 1bpp - need 2 entry mono color table
case 1:
  lpTarget->bmiColors[0].rgbRed = 0;
  lpTarget->bmiColors[0].rgbGreen = 0;
  lpTarget->bmiColors[0].rgbBlue = 0;
  lpTarget->bmiColors[0].rgbReserved = 0;
  lpTarget->bmiColors[1].rgbRed = 255;
  lpTarget->bmiColors[1].rgbGreen = 255;
  lpTarget->bmiColors[1].rgbBlue = 255;
  lpTarget->bmiColors[1].rgbReserved = 0;
  break; // end 1bpp

// no color table for the > 8bpp modes
case 32:
case 24:
case 16:
default:
break;
}
return TRUE;
}
/* End CopyColorTable() *****************************************************/

/****************************************************************************
*
*     FUNCTION: DIBToDIBSection
*
*  功能：根据DIB创建DIBSection
*
*     PURPOSE: Create DIBSECTION from DIB
*
*     PARAMS:   LPBYTE lpDIB - pointer to DIB data buffer
*
*  参数：DIB数据缓冲区地址
*
*     RETURNS: HBITMAP - handle of DIBSECTION, or NULL for failure
*
\****************************************************************************/
HBITMAP DIBToDIBSection(LPBYTE lpDIB)
{
LPBYTE       lpSourceBits;
HDC    hDC = NULL, hSourceDC;
HBITMAP      hSourceBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize;

LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)lpDIB;
if (! lpSrcDIB)
return NULL;

// Gonna use DIBSections and BitBlt() to do the conversion, so make 'em
hDC = GetDC( NULL );
hSourceBitmap = CreateDIBSection( hDC, lpSrcDIB, DIB_RGB_COLORS, (VOID **)&lpSourceBits, NULL, 0 );
hSourceDC = CreateCompatibleDC( hDC );

// Flip(变址浮点运算) the bits on the source DIBSection to match the source DIB
dwSourceBitsSize = lpSrcDIB->bmiHeader.biHeight * BytesPerLine((LPBYTE)&(lpSrcDIB->bmiHeader));
memcpy( lpSourceBits, FindDIBBits((LPBYTE)lpSrcDIB), dwSourceBitsSize );

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );

// Set the color tables for the DIBSections
if( lpSrcDIB->bmiHeader.biBitCount <= 8 )
SetDIBColorTable( hSourceDC, 0, 1 << lpSrcDIB->bmiHeader.biBitCount, lpSrcDIB->bmiColors );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
DeleteDC( hSourceDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

return hSourceBitmap;
}

// Create DIBSECTION from DIB
HBITMAP DIBToDIBSection(HDIB hDIB)
{
HBITMAP hSourceBitmap;

// Get DIB pointer
if (! hDIB)
return NULL;
LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
if (! lpSrcDIB)
return NULL;

hSourceBitmap = DIBToDIBSection(lpSrcDIB);

// final cleanup
GlobalUnlock(hDIB);

return hSourceBitmap;
}

/****************************************************************************
*
*     FUNCTION: DIBSectionToDIB
*
*     PURPOSE: Create DIB from DIBSECTION
*
*     PARAMS:   HBITMAP - handle of DIBSECTION, or NULL for failure
*
*     RETURNS: HBITMAP hBitmap - DIB handle
*
\****************************************************************************/
HDIB DIBSectionToDIB(HBITMAP hBitmap)
{
HDC    hDC = NULL, hSourceDC;
HBITMAP   hOldSourceBitmap;
HANDLE   hNewDIB;
LPBITMAPINFO lpbmi = NULL;
DWORD   dwSize;
DIBSECTION   ds;
DWORD   dwColorNum;

// get DIB info
GetObject(hBitmap, sizeof(DIBSECTION), &ds);
dwColorNum = ds.dsBmih.biClrUsed;
if (dwColorNum == 0 && ds.dsBmih.biBitCount <= 8)
dwColorNum = 1 << ds.dsBmih.biBitCount;

// Allocate and fill out a BITMAPINFO struct for the new DIB
dwSize = sizeof(BITMAPINFOHEADER) + (dwColorNum * sizeof(RGBQUAD)) + ds.dsBmih.biSizeImage;
hNewDIB = GlobalAlloc(GHND, dwSize);
if (! hNewDIB)
return NULL;
lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
if (! lpbmi)
return NULL;
lpbmi->bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
lpbmi->bmiHeader.biWidth = ds.dsBm.bmWidth;
lpbmi->bmiHeader.biHeight = ds.dsBm.bmHeight;
lpbmi->bmiHeader.biPlanes = 1;
lpbmi->bmiHeader.biBitCount = ds.dsBmih.biBitCount;
lpbmi->bmiHeader.biCompression = ds.dsBmih.biCompression;
lpbmi->bmiHeader.biSizeImage = ds.dsBmih.biSizeImage;
lpbmi->bmiHeader.biXPelsPerMeter = ds.dsBmih.biXPelsPerMeter;
lpbmi->bmiHeader.biYPelsPerMeter = ds.dsBmih.biYPelsPerMeter;
lpbmi->bmiHeader.biClrUsed = ds.dsBmih.biClrUsed;
lpbmi->bmiHeader.biClrImportant = ds.dsBmih.biClrImportant;

// get DC for operation
hDC = GetDC( NULL );

// get DIB bits
if (! GetDIBits(hDC,
  hBitmap,
  0L,
  (DWORD)ds.dsBm.bmHeight,
  (LPBYTE)lpbmi + (WORD)lpbmi->bmiHeader.biSize + (dwColorNum*sizeof(RGBQUAD)),
  (LPBITMAPINFO)lpbmi,
  (DWORD)DIB_RGB_COLORS))
{
  GlobalUnlock(hNewDIB);
  ReleaseDC(NULL,hDC);
  return NULL;
}

// memory DC
hSourceDC = CreateCompatibleDC( hDC );
// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hBitmap );

// Fill in the color table from DIBSection
if( lpbmi->bmiHeader.biBitCount <= 8 )
GetDIBColorTable( hSourceDC, 0, 1 << lpbmi->bmiHeader.biBitCount, lpbmi->bmiColors );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
DeleteDC( hSourceDC );
ReleaseDC( NULL, hDC );
GlobalUnlock(hNewDIB);

return hNewDIB;
}

/*************************************************************************
*
* DIBToBitmap()
*
* Parameters:
*
* HDIB hDIB        - specifies the DIB to convert
*
* HPALETTE hPal    - specifies the palette to use with the bitmap
*
* Return Value:
*
* HBITMAP          - identifies the device-dependent bitmap
*
* Description:
*
* This function creates a bitmap from a DIB using the specified palette.
* If no palette is specified, default is used.
*
* NOTE:
*
* The bitmap returned from this funciton is always a bitmap compatible
* with the screen (e.g. same bits/pixel and color planes) rather than
* a bitmap with the same attributes as the DIB. This behavior is by
* design, and occurs because this function calls CreateDIBitmap to
* do its work, and CreateDIBitmap always creates a bitmap compatible
* with the hDC parameter passed in (because it in turn calls
* CreateCompatibleBitmap).
*
* So for instance, if your DIB is a monochrome(单色) DIB and you call this
* function, you will not get back a monochrome HBITMAP -- you will
* get an HBITMAP compatible with the screen DC, but with only 2
* colors used in the bitmap.
*
* If your application requires a monochrome HBITMAP returned for a
* monochrome DIB, use the function SetDIBits().
*
* Also, the DIBpassed in to the function is not destroyed on exit. This
* must be done later, once it is no longer needed.
*
************************************************************************/
HBITMAP DIBToBitmap(HDIB hDIB, HPALETTE hPal)
{
LPBYTE       lpDIBHdr, lpDIBBits; // pointer to DIB header, pointer to DIB bits
HBITMAP     hBitmap;            // handle to device-dependent bitmap
HDC         hDC;                    // handle to DC
HPALETTE    hOldPal = NULL;    // handle to a palette

// if invalid handle, return NULL

if (!hDIB)
return NULL;

// lock memory block and get a pointer to it

lpDIBHdr = (LPBYTE)GlobalLock(hDIB);

// get a pointer to the DIB bits

lpDIBBits = FindDIBBits(lpDIBHdr);

// get a DC

hDC = GetDC(NULL);
if (!hDC)
{
  // clean up and return NULL
  GlobalUnlock(hDIB);
  return NULL;
}

// select and realize palette

if (hPal)
{
hOldPal = SelectPalette(hDC, hPal, FALSE);
RealizePalette(hDC);
}

// create bitmap from DIB info and bits
hBitmap = CreateDIBitmap(hDC,
  (LPBITMAPINFOHEADER)lpDIBHdr,
  CBM_INIT,
  lpDIBBits,
  (LPBITMAPINFO)lpDIBHdr,
  DIB_RGB_COLORS);
//The CreateDIBitmap function creates a compatible bitmap (DDB) from
//a DIB and, optionally, sets the bitmap bits.

// restore previous palette
if (hOldPal)
SelectPalette(hDC, hOldPal, FALSE);

// clean up
ReleaseDC(NULL, hDC);
GlobalUnlock(hDIB);

// return handle to the bitmap
return hBitmap;
}

/*************************************************************************
*
* ChangeBitmapFormat()
*
* Parameter:
*
* HBITMAP          - handle to a bitmap
*
* WORD             - desired bits per pixel
*
* DWORD            - desired compression format
*
* HPALETTE         - handle to palette
*
* Return Value:
*
* HDIB             - handle to the new DIB if successful, else NULL
*
* Description:
*
* This function will convert a bitmap to the specified bits per pixel
* and compression format. The bitmap and it's palette will remain
* after calling this function.
*
************************************************************************/
HDIB ChangeBitmapFormat (HBITMAP hbm, WORD biBits, DWORD biCompression, HPALETTE hpal)
{
BITMAP               bm;
BITMAPINFOHEADER     bi;
LPBITMAPINFOHEADER   lpbi;
DWORD                dwLen;
HANDLE               hdib;
HANDLE               h;
HDC                  hdc;

if (!hbm)
return NULL;

if (hpal == NULL)
hpal = (HPALETTE)GetStockObject(DEFAULT_PALETTE);

GetObject(hbm,sizeof(bm),(LPBYTE)&bm);

if (biBits == 0)
{
biBits = bm.bmPlanes * bm.bmBitsPixel;

  // make sure bits per pixel is valid
  if (biBits <= 1)
   biBits = 1;
  else if (biBits <= 4)
   biBits = 4;
  else if (biBits <= 8)
   biBits = 8;
  else // if greater than 8-bit, force to 24-bit
   biBits = 24;
}

bi.biSize               = sizeof(BITMAPINFOHEADER);
bi.biWidth              = bm.bmWidth;
bi.biHeight             = bm.bmHeight;
bi.biPlanes             = 1;
bi.biBitCount           = biBits;
bi.biCompression        = biCompression;
bi.biSizeImage          = 0;
bi.biXPelsPerMeter      = 0;
bi.biYPelsPerMeter      = 0;
bi.biClrUsed            = 0;
bi.biClrImportant       = 0;

dwLen = bi.biSize + PaletteSize((LPBYTE)&bi);

hdc = GetDC(NULL);
HPALETTE hpalT = SelectPalette(hdc,hpal,FALSE);
RealizePalette(hdc);

hdib = GlobalAlloc(GHND,dwLen);

if (!hdib)
{
  SelectPalette(hdc,hpalT,FALSE);
  ReleaseDC(NULL,hdc);
  return NULL;
}

lpbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);

*lpbi = bi;

/* call GetDIBits with a NULL lpBits param, so it will calculate the
* biSizeImage field for us
*/
GetDIBits(hdc, hbm, 0L, (DWORD)bi.biHeight,
(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);

bi = *lpbi;
GlobalUnlock(hdib);

/* If the driver did not fill in the biSizeImage field, make one up */
if (bi.biSizeImage == 0)
{
bi.biSizeImage = MYWIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight;

if (biCompression != BI_RGB)
bi.biSizeImage = (bi.biSizeImage * 3) / 2;
}

/* realloc the buffer big enough to hold all the bits */
dwLen = bi.biSize + PaletteSize((LPBYTE)&bi) + bi.biSizeImage;
if (h = GlobalReAlloc(hdib,dwLen,0))
  hdib = h;
else
{
  GlobalFree(hdib);
  hdib = NULL;

  SelectPalette(hdc,hpalT,FALSE);
  ReleaseDC(NULL,hdc);
  return hdib;
}

/* call GetDIBits with a NON-NULL lpBits param, and actualy get the
* bits this time
*/
lpbi = (LPBITMAPINFOHEADER)GlobalLock(hdib);

if (! GetDIBits(hdc,
  hbm,
  0L,
  (DWORD)bi.biHeight,
  (LPBYTE)lpbi + (WORD)lpbi->biSize + PaletteSize((LPBYTE)lpbi),
  (LPBITMAPINFO)lpbi,
  (DWORD)DIB_RGB_COLORS))
{
  GlobalUnlock(hdib);
  hdib = NULL;
  SelectPalette(hdc,hpalT,FALSE);
  ReleaseDC(NULL,hdc);
  return NULL;
}
bi = *lpbi;

GlobalUnlock(hdib);
SelectPalette(hdc,hpalT,FALSE);
ReleaseDC(NULL,hdc);
return hdib;
}

bool GrayEqualize(HDIB hDib)
{

int nHeight, nWidth, i, j, k;

// 指向源图像的指针
LPBYTE lpSrc = NULL;
WaitCursorBegin();

// 灰度映射表
int bGray[256];
long long bConvert[256],bHist[256];
memset(bGray, 0 , 256* sizeof(int));
memset(bHist, 0 , 256* sizeof(long));
memset(bConvert, 0 , 256* sizeof(long));

LPBYTE lpDIB = (LPBYTE) GlobalLock( hDib );
int nNumColors = DIBBitCount(lpDIB);
if( nNumColors != 8 )
return false;

LPBYTE lpDIBBits = FindDIBBits( lpDIB );
nHeight = DIBHeight( lpDIB );
nWidth = DIBWidth( lpDIB );

// 计算图像每行的字节数
LONG lLineBytes = BytesPerLine( lpDIB );
lpSrc = lpDIBBits;
for (i = 0, k = 0; i < nHeight; ++i, k += lLineBytes )
{
  lpSrc = lpDIBBits + k;
  for ( j = 0; j < nWidth; ++j, ++lpSrc )
  {
   bGray[*(lpSrc)]++;
  }
}
bHist[0] = bGray[0];
long long *pHist = bHist;
int *pGray = bGray;
long long *pConver = bConvert;
int nTotal = nHeight * nWidth;
*pConver ++ = (long) (*pHist * 255)/nTotal;
pHist++;
pGray++;
for ( i = 1; i <= 255; i++, pHist++, pGray++ , pConver ++)
{
  *pHist = *pGray + *(pHist-1); //形成累积直方图
  *pConver =((long long ) (*pHist) )*255 / nTotal ;
}

for ( i = 0, k = 0; i < nHeight; i++, k+= lLineBytes )
{
  lpSrc = lpDIBBits + k;
  for ( j = 0; j < nWidth; j++, lpSrc ++ )
  {
   *lpSrc = bConvert[*lpSrc];   //更新原始位图数据
  }
}
GlobalUnlock( hDib );
WaitCursorEnd();
return true;
}

bool GrayStretchDIB(int nMethod, HDIB hDib,BYTE bX1 = 0,BYTE bY1 = 0 ,BYTE bX2 = 255, BYTE bY2 = 255 )
{
WaitCursorBegin();

LPBYTE lpDIB,lpDIBBits;
DWORD lHeight,lWidth;

// 指向源图像的指针
unsigned char* lpSrc;

// 循环变量
LONG i = 0;
// LONG j;

// 灰度映射表
BYTE bMap[256];

// 图像每行的字节数
LONG lLineBytes;

lpDIB = (LPBYTE) GlobalLock( hDib );

lpDIBBits = FindDIBBits( lpDIB );
lHeight = DIBHeight( lpDIB );
lWidth = DIBWidth( lpDIB );
// 计算图像每行的字节数

lLineBytes = BytesPerLine( lpDIB);
if( nMethod == 0 ) //自动计算X1, Y1; X2,Y2;
{
  int nHist[256];
  if( !GetGrayHist(lpDIBBits, lWidth, lHeight, nHist))
   return false;
  long nCumulHist[256];
  if( !GetCumulativeHist(nHist, 256, nCumulHist))
   return false;
  for( i = 0; i < 256; ++i )
  {
   if( nCumulHist[i] > lWidth * lHeight / 10 )
   {
    bX1 = i;
    break;
   }
  }
  for( i = 255; i > bX1; --i )
  {
   if(nCumulHist[i] < lHeight * lWidth * 9 / 10)
   {
    bX2 = i;
    break;
   }
  }
}

// 计算灰度映射表
memset(bMap, 0 , bX1 * sizeof(BYTE));
float fTmp = 0;
if( bX1 > 0 )
{
  fTmp = float(bY1)/int(bX1);
  for (i = 0; i <= bX1; i++)
  {
   // 线性变换
    bMap[i] = (BYTE) (i * fTmp);
  }
}
if( bX2 == bX1 )//判断bX1是否等于bX2（防止分母为0）
{
  memset(bMap+ i, bY1, (bX2 - bX1 + 1) *sizeof(BYTE));
}
else
{
  fTmp = float(bY2 - bY1) / int(bX2- bX1);
  for (; i <= bX2; i++)
  {
   // 线性变换
   bMap[i] = bY1 + (BYTE) ( (i - bX1) / fTmp);
  }
}
fTmp = float ( 255- bY2 ) / int(255- bX2);

if (bX2 == 255 )
{
  memset(bMap + i, 255, (255-i +1) *sizeof(BYTE));
}
else
{
  for (; i < 256; i++)
  {
   // 线性变换
   bMap[i] = bY2 + (BYTE) (fTmp * (i - bX2));
  }
}

// 每行
for(DWORD i1 = 0, k = 0; i1 < lHeight; i1++, k+= lLineBytes )
{
  lpSrc = lpDIBBits + k;
  // 每列
  for(DWORD j1 = 0; j1 < lWidth; j1++, lpSrc++)
  {
   // 计算新的灰度值
   *lpSrc = bMap[*lpSrc];
  }
}
GlobalUnlock( hDib );
WaitCursorEnd();
// 返回
return TRUE;
}

bool GetGrayHist(const BYTE * pbImg, const int nImgWid, const int nImgHei, int *pnHist )
{
if( pbImg == NULL || pnHist == NULL || nImgWid < 1 || nImgHei < 1 )
return false;
int i, j, k, nBytePerLine;
const BYTE * lptmpBits = pbImg;
memset(pnHist, 0, 256 * sizeof(int));

nBytePerLine = MYWIDTHBYTES(nImgWid << 3);
for ( i = 0, k = 0; i < nImgHei; i++, k += nBytePerLine ) //ImageSize should be greater.
{
  lptmpBits = pbImg + k;
  for ( j = 0; j < nImgWid; j++ )
  {
   pnHist[*lptmpBits ]++;
   lptmpBits++;
  }
}

return true;
}
bool GetCumulativeHist(const int *pnHist, int nLength, long *pnCuHist)
{
if( pnHist == NULL || pnCuHist == NULL || nLength < 1 )
return false;

memset( pnCuHist, 0, nLength * sizeof(long) );

const int *pnIn = pnHist;
long * pnOut = pnCuHist;

*pnOut ++ = *pnIn ++;
for( int i = 1; i < 256; i++, pnOut++, pnIn++ )
{
*pnOut = *pnIn + *(pnOut - 1);
}
return true;
}
// nMethod: 0：去污，原来白色的变为黑色，原来黑色的变成白色
// nMethod: 1 ：磨白，把选中的区域变成白色
// nMethod 2：填充，把选中的区域变成黑色
bool EliminateDirtDIB(int nMethod, HDIB hDib, CRect rect)
{
WaitCursorBegin();
LPBYTE lpDIB,lpDIBBits;
lpDIB = lpDIBBits = NULL;
lpDIB = (LPBYTE) GlobalLock( hDib );

DWORD lHeight, lWidth;
lpDIBBits = FindDIBBits( lpDIB );
lHeight = DIBHeight( lpDIB );
lWidth = DIBWidth( lpDIB );

// 计算图像每行的字节数
LONG lLineBytes = BytesPerLine( lpDIB);

// 指向源图像的指针
unsigned char* lpSrc = lpDIBBits;
BYTE btmp = 0;
int i, j, k, nSum = 0;
if( nMethod == 0 )
{
  for( i = lHeight - rect.bottom, k = i * lLineBytes; i < lHeight - rect.top; i++, k += lLineBytes )
  {
   lpSrc = lpDIBBits + k + rect.left/8;
   for( j = rect.left/8; j < rect.right/8; j++, lpSrc++ )
   {
    if( *lpSrc == 255 )
     nSum++;
   }
  }
  if( nSum < rect.Width() * rect.Height() / 2 )
   btmp = 255;
}
else if(nMethod == 1)
{
  btmp = 255;
}
else
{
  btmp = 0;
}

for( i = lHeight - rect.bottom, k = i * lLineBytes; i < lHeight - rect.top; i++, k += lLineBytes )
{
  lpSrc = lpDIBBits + k + rect.left/8;
  for( int j = rect.left/8; j < rect.right/8; j++, lpSrc++ )
  {
   *lpSrc = btmp;
  }
}
GlobalUnlock( hDib );
WaitCursorEnd();
return true;
}
// nMethod: 0：去污，原来白色的变为黑色，原来黑色的变成白色
// nMethod:1 ：磨白，把选中的区域变成白色
// nMethod 2：填充，把选中的区域变成黑色
bool EliminateDirtDIB(int nMethod, HDIB hDib, int nCircleX, int nCircleY, int nRadius )
{
WaitCursorBegin();

LPBYTE lpDIB,lpDIBBits;
lpDIB = lpDIBBits = NULL;
lpDIB = (LPBYTE) GlobalLock( hDib );

DWORD lHeight, lWidth;
lpDIBBits = FindDIBBits( lpDIB );
lHeight = DIBHeight( lpDIB );
lWidth = DIBWidth( lpDIB );

// 计算图像每行的字节数
LONG lLineBytes = BytesPerLine( lpDIB);

// 指向源图像的指针
unsigned char* lpSrc = lpDIBBits;
int nLeft, nRight, nTop, nBottom, nX2, nY2, nC2;

BYTE btmp = 0;
nLeft = nCircleX - nRadius > 0 ? nCircleX - nRadius : 0;
nRight = nCircleX + nRadius < lWidth ? nCircleX + nRadius : lWidth - 1;
nTop = lHeight - 1 - nCircleY - nRadius > 0 ? lHeight - 1 - nCircleY - nRadius : 0;
nBottom = lHeight - 1 - nCircleY + nRadius < lHeight ? lHeight - 1 - nCircleY + nRadius : lHeight - 1;
nC2 = nRadius * nRadius;
int i, j, k, nSum = 0;
if( nMethod == 0 )
{
  for( i = nTop, k = i * lLineBytes; i < nBottom; i++, k += lLineBytes )
  {
   lpSrc = lpDIBBits + k + nLeft/8;
   nY2 = (lHeight - 1 - nCircleY - i) * (lHeight - 1 - nCircleY - i);
   for( j = nLeft/8; j < nRight/8; j++, lpSrc++ )
   {
    nX2 =( j * 8 - nCircleX ) * ( j * 8 - nCircleX);
    if( nX2 + nY2 < nC2 && *lpSrc == 255 )
    {
     nSum++;
    }
   }
  }
  if(nSum < 3.14 * nRadius * nRadius/2 )
   btmp = 255;
}
else if( nMethod == 1 )
{
  btmp = 255;
}
else
{
  btmp = 0;
}

for( i = nTop, k = i * lLineBytes; i < nBottom; i++, k += lLineBytes )
{
  lpSrc = lpDIBBits + k + nLeft/8;
  nY2 = (lHeight - 1 - nCircleY - i) * (lHeight - 1 - nCircleY - i);
  for( j = nLeft/8; j < nRight/8; j++, lpSrc++ )
  {
   nX2 =( j * 8 - nCircleX ) * ( j * 8 - nCircleX);
   if( nX2 + nY2 < nC2 )
   {
    *lpSrc = btmp;
   }
  }
}

GlobalUnlock( hDib );
WaitCursorEnd();
return true;
}

//saving bi-bitmap to file, only for debug
void SaveTo8bit_BMP(const BYTE* pbInputMat, int Width, int Height, const char* szFileName, int nGrayLevel)
{
const BYTE* pbInput = pbInputMat;

int nNewWidth = (Width + 3) / 4 * 4;
long imageSize = nNewWidth * Height;

BYTE* TmpImg = new BYTE[imageSize];
memset(TmpImg, 255, imageSize * sizeof(BYTE));

if (nGrayLevel == 2)
{

  for (int i = 0; i < Height; ++i)
  {
   for (int j = 0; j < Width/8; ++j)
   {
    TmpImg[(Height-i-1)*nNewWidth + j] = 255 - pbInput[i*Width+j]*255;
   }
  }
}
else if (nGrayLevel == 8)
{
  for (int i = 0; i < Height; ++i)
  {
   for (int j = 0; j < Width; ++j)
   {
    TmpImg[i*nNewWidth + j] = pbInput[i*nNewWidth+j];
   }
  }
}
else
{
  return;
}

BYTE pbHead[1078];
memset(pbHead, 0, 1078 * sizeof(BYTE));

//设置各字段值
pbHead[0] = 0x42; //0x4d42
pbHead[1] = 0x4D;

DWORD nSize = imageSize + 1078;
memcpy(pbHead + 2, &nSize, sizeof(DWORD));//size

pbHead[10] = 0x36; //offset
pbHead[11] = 0x04;
pbHead[12] = 0;
pbHead[13] = 0;

pbHead[14] = 0x28;

LONG nxSize = nNewWidth;
memcpy(pbHead + 18, &nxSize, sizeof(LONG));//WIDTH

nxSize = Height;
memcpy(pbHead + 22, &nxSize, sizeof(LONG));//HEIGHT

pbHead[26] = 0x1;

pbHead[28] = 0x8;

memcpy(pbHead + 34, &nSize, sizeof(DWORD));
//pbHead[47] = 0x1;

for (int i = 0 ; i < 256 ; i++)
{
  pbHead[54 + i * 4] = i;
  pbHead[54 + i * 4 + 1] = i;
  pbHead[54 + i * 4 + 2] = i;
  pbHead[54 + i * 4 + 3] = 0;
}

FILE* mFile = fopen(szFileName, ("wb"));
if (!mFile)
{
  delete[] TmpImg;
  return;
}
LPBITMAPFILEHEADER ph = (LPBITMAPFILEHEADER)pbHead;
LPBITMAPINFOHEADER pinfo = (LPBITMAPINFOHEADER) (pbHead + 14);
fwrite(pbHead, sizeof(BYTE), 1078, mFile);
fwrite(TmpImg, sizeof(BYTE), imageSize, mFile);
fclose(mFile);

delete[] TmpImg;
}
HDIB ChangeDIBSize(HDIB hDIB, int nWidth, int nHeight)
{
LPBITMAPINFO lpbmi = NULL;
LPBYTE       lpSourceBits, lpTargetBits, lpResult;
HDC    hDC = NULL, hSourceDC, hTargetDC;
HBITMAP      hSourceBitmap, hTargetBitmap, hOldTargetBitmap, hOldSourceBitmap;
DWORD        dwSourceBitsSize, dwTargetBitsSize, dwTargetHeaderSize;
HDIB   hNewDIB;
DWORD   dwSize;

WaitCursorBegin();

// Get DIB pointer
if (! hDIB)
{
  WaitCursorEnd();
  return NULL;
}
LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDIB);
if (! lpSrcDIB)
{
  WaitCursorEnd();
  return NULL;
}

// Select DIBSections into DCs
hOldSourceBitmap = (HBITMAP)SelectObject( hSourceDC, hSourceBitmap );
hOldTargetBitmap = (HBITMAP)SelectObject( hTargetDC, hTargetBitmap );

// put old bitmap in new bitmap
SetStretchBltMode( hTargetDC, COLORONCOLOR );
StretchBlt( hTargetDC, 0, 0, lpbmi->bmiHeader.biWidth, lpbmi->bmiHeader.biHeight, hSourceDC, 0, 0, lpSrcDIB->bmiHeader.biWidth, lpSrcDIB->bmiHeader.biHeight, SRCCOPY );

// Clean up and delete the DCs
SelectObject( hSourceDC, hOldSourceBitmap );
SelectObject( hTargetDC, hOldTargetBitmap );
DeleteDC( hSourceDC );
DeleteDC( hTargetDC );
ReleaseDC( NULL, hDC );

// Flush the GDI batch, so we can play with the bits
GdiFlush();

// final cleanup
DeleteObject( hTargetBitmap );
DeleteObject( hSourceBitmap );
free( lpbmi );
GlobalUnlock(hDIB);
GlobalUnlock(hNewDIB);
WaitCursorEnd();

return hNewDIB;
}

3）CompConnect.h

#pragma once
#ifndef COMPCONNECT_H
#define COMPCONNECT_H

const UINT COMP_NUM = 1024; //允许连通体的个数

//提取连通体为黑色区域
const BYTE CC_START = 255;
const BYTE CC_CUR = 0;

struct component
{
CRect bound;
int count;
component *cnext;
component()
{
  count=0;
  cnext=NULL;
}
};
struct Line
{
int StartY;
int EndY;
int StartX;
int EndX;
int LenghthX;
int LenghthY;
int TotalSize;
//Line *Next;
//float Type_Flag;
component *cp;
//Block *pBlkStart;
//float AveComH;
Line()
{
  StartX =0;
  EndX =0;
  StartY = 0;
  EndY = 0;
  LenghthX = 0;
  LenghthY = 0;
  TotalSize = 0;
  cp = NULL;

}
~Line()
{
  component *temp;
  while(cp!=NULL)
  {
   temp = cp;
   cp = cp->cnext;

delete temp;
}
}

};

#endif

4)ImgCov.h 用于将jpg、tif等格式的文件转换成DIB格式

#ifndef IMGCONV_H
#define IMGCONV_H

extern "C"
{

#ifdef GENERATE_DLL
#define DLL_EXPORT __declspec(dllexport)
#else // #ifdef GENERATE_DLL
#define DLL_EXPORT
#endif // #ifdef GENERATE_DLL

/* Format Description                             Qt's support
* BMP     Windows Bitmap                          Read/Write
* GIF     Graphic Interchange Format (optional)   Read
* JPG     Joint Photographic Experts Group        Read/Write
* JPEG    Joint Photographic Experts Group        Read/Write
* PNG     Portable Network Graphics               Read/Write
* PBM     Portable Bitmap                         Read
* PGM     Portable Graymap                        Read
* PPM     Portable Pixmap                         Read/Write
* TIFF    Tagged Image File Format                Read/write
* XBM     X11 Bitmap                              Read/Write
* XPM     X11 Pixmap                              Read/Write
* note: this lib's support is exactly same as Qt's.
*/

enum ImageType
{
    imgBMP = 0,
    imgGIF = 1,
    imgJPG = 2,
    imgJPEG = 3,
    imgPNG = 4,
    imgPBM = 5,
    imgPGM = 6,
    imgPPM = 7,
    imgTIFF = 8,
    imgXBM = 9,
    imgXPM = 10,
    imgMax = 10,
};

// ppDestData and pDestDataLen are for outputs;
// when succeeded, *ppDestData is new-ed inside the function, and should be delete-ed by caller calling ImageDelete.
bool DLL_EXPORT ImageConvert(const unsigned char * pSrcData, int nSrcDataLen, ImageType itSrcImageType,
unsigned char * * ppDestData, int * pnDestDataLen, ImageType itDestImageType);

bool DLL_EXPORT ImageDelete(unsigned char * * ppImageData);

}
#endif // #ifndef IMGCONV_H

你可能感兴趣的:(常用用图像处理算法（二）)

情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
爬山后遗症璃绛
爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
本周第二次约练 2cfbdfe28a51
中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
2022-07-08 保利学府里李楚怡1307022
——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
直抒《紫罗兰永恒花园外传》雷姆的黑色童话
没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
如果做到轻松在股市赚钱？只要坚持这三个原则。履霜之人
大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
特殊的拜年飘雪的天堂
文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
398顺境，逆境戴骁勇
2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
想明白这个问题，你才能写下去文自拾
春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
其二十八尾喵
你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
libyuv之linux编译 jaronho Linux linux 运维服务器
文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
ARM中断处理过程落汤老狗嵌入式linux
一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
如何成为段子手欣雅阅读
我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
主题升华随机抽总结木棉咕噜
昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
这个世界为何对女性这么苛刻遇见知见
图片发自App当今社会的女性，简直用金刚侠来形容都不为过。虽然早已过了男尊女卑的时代，但是这个世界并没有平等的对待女性。新时代的女性标准：上得了厅堂，下得了厨房，杀得了木马，翻得了围墙，开得起好车，买得起新房，斗得过二奶，打得过流氓，生得了孩子，养得了家庭。这个社会对女性有太多的不公平，既要求女性经济独立，又要求女性贤良淑德。所有的女性的在成长过程中没有任何一项是因为你是女性而给你开绿灯的。图片发
日常演播练习0822 开阳春天
日常演播练习0822一、绕口令练习司小四和史小世，四月十四日十四时四十上集市，司小四买了四十四斤四两西红柿，史小世买了十四斤四两细蚕丝。司小四要拿四十四斤四两西红柿换史小世十四斤四两细蚕丝。史小世十四斤四两细蚕丝不换司小四四十四斤四两西红柿。司小四说我四十四斤四两西红柿可以增加营养防近视，史小世说我十四斤四两细蚕丝可以织绸织缎又抽丝。二、文本练习狗熊是动物街有名的美食家，它吃得多所以长得胖，它能吃
apache 安装linux windows 墙头上一根草 apache inux windows
linux安装Apache 有两种方式一种是手动安装通过二进制的文件进行安装，另外一种就是通过yum 安装，此中安装方式，需要物理机联网。以下分别介绍两种的安装方式通过二进制文件安装Apache需要的软件有apr,apr-util,pcre 1，安装 apr 下载地址：htt
fill_parent、wrap_content和match_parent的区别 Cb123456 match_parent fill_parent
fill_parent、wrap_content和match_parent的区别: 1）fill_parent 设置一个构件的布局为fill_parent将强制性地使构件扩展，以填充布局单元内尽可能多的空间。这跟Windows控件的dockstyle属性大体一致。设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。 2） wrap_conte
网页自适应设计天子之骄 html css 响应式设计页面自适应
网页自适应设计网页对浏览器窗口的自适应支持变得越来越重要了。自适应响应设计更是异常火爆。再加上移动端的崛起，更是如日中天。以前为了适应不同屏幕分布率和浏览器窗口的扩大和缩小，需要设计几套css样式，用js脚本判断窗口大小，选择加载。结构臃肿，加载负担较大。现笔者经过一定时间的学习，有所心得，故分享于此，加强交流，共同进步。同时希望对大家有所
[sql server] 分组取最大最小常用sql 一炮送你回车库 SQL Server
--分组取最大最小常用sql--测试环境if OBJECT_ID('tb') is not null drop table tb;gocreate table tb( col1 int, col2 int, Fcount int)insert into tbselect 11,20,1 union allselect 11,22,1 union allselect 1
ImageIO写图片输出到硬盘 3213213333332132 java image
package awt; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imagei
自己的String动态数组宝剑锋梅花香 java 动态数组数组
数组还是好说，学过一两门编程语言的就知道，需要注意的是数组声明时需要把大小给它定下来，比如声明一个字符串类型的数组：String str[]=new String[10]; 但是问题就来了，每次都是大小确定的数组，我需要数组大小不固定随时变化怎么办呢？动态数组就这样应运而生，龙哥给我们讲的是自己用代码写动态数组，并非用的ArrayList 看看字符
pinyin4j工具类 darkranger .net
pinyin4j工具类Java工具类 2010-04-24 00:47:00 阅读69 评论0 字号：大中小引入pinyin4j-2.5.0.jar包: pinyin4j是一个功能强悍的汉语拼音工具包，主要是从汉语获取各种格式和需求的拼音，功能强悍，下面看看如何使用pinyin4j。本人以前用AscII编码提取工具，效果不理想，现在用pinyin4j简单实现了一个。功能还不是很完美，
StarUML学习笔记----基本概念 aijuans UML建模
介绍StarUML的基本概念，这些都是有效运用StarUML?所需要的。包括对模型、视图、图、项目、单元、方法、框架、模型块及其差异以及UML轮廓。模型、视与图（Model, View and Diagram） &
Activiti最终总结 avords Activiti id 工作流
1、流程定义ID：ProcessDefinitionId，当定义一个流程就会产生。 2、流程实例ID：ProcessInstanceId，当开始一个具体的流程时就会产生，也就是不同的流程实例ID可能有相同的流程定义ID。 3、TaskId，每一个userTask都会有一个Id这个是存在于流程实例上的。 4、TaskDefinitionKey和（ActivityImpl activityId
从省市区多重级联想到的，react和jquery的差别 bee1314 jquery UI react
在我们的前端项目里经常会用到级联的select，比如省市区这样。通常这种级联大多是动态的。比如先加载了省，点击省加载市，点击市加载区。然后数据通常ajax返回。如果没有数据则说明到了叶子节点。针对这种场景，如果我们使用jquery来实现，要考虑很多的问题，数据部分，以及大量的dom操作。比如这个页面上显示了某个区，这时候我切换省，要把市重新初始化数据，然后区域的部分要从页面
Eclipse快捷键大全 bijian1013 java eclipse 快捷键
Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)Alt+↑ 当前行和上面一行交互位置(同上)Alt+← 前一个编辑的页面Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)Alt+En
js 笔记函数征客丶 JavaScript
一、函数的使用 1.1、定义函数变量 var vName = funcation(params){ } 1.2、函数的调用函数变量的调用： vName(params); 函数定义时自发调用：(function(params){})(params); 1.3、函数中变量赋值 var a = 'a'; var ff
【Scala四】分析Spark源代码总结的Scala语法二 bit1129 scala
1. Some操作在下面的代码中，使用了Some操作：if (self.partitioner == Some(partitioner))，那么Some(partitioner)表示什么含义？首先partitioner是方法combineByKey传入的变量， Some的文档说明： /** Class `Some[A]` represents existin
java 匿名内部类 BlueSkator java匿名内部类
组合优先于继承 Java的匿名类，就是提供了一个快捷方便的手段，令继承关系可以方便地变成组合关系继承只有一个时候才能用，当你要求子类的实例可以替代父类实例的位置时才可以用继承。在Java中内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相
盗版win装在MAC有害发热，苹果的东西不值得买，win应该不用 ljy325 游戏 apple windows XP OS
Mac mini 型号: MC270CH-A RMB:5,688 Apple 对windows的产品支持不好,有以下问题: 1.装完了xp,发现机身很热虽然没有运行任何程序！貌似显卡跑游戏发热一样，按照那样的发热量,那部机子损耗很大,使用寿命受到严重的影响! 2.反观安装了Mac os的展示机，发热量很小，运行了1天温度也没有那么高 &nbs
读《研磨设计模式》-代码笔记-生成器模式-Builder bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /** * 生成器模式的意图在于将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示（GoF） * 个人理解： * 构建一个复杂的对象，对于创建者（Builder）来说，一是要有数据来源(rawData)，二是要返回构
JIRA与SVN插件安装 chenyu19891124 SVN jira
JIRA安装好后提交代码并要显示在JIRA上，这得需要用SVN的插件才能看见开发人员提交的代码。 1.下载svn与jira插件安装包，解压后在安装包(atlassian-jira-subversion-plugin-0.10.1) 2.解压出来的包里下的lib文件夹下的jar拷贝到(C:\Program Files\Atlassian\JIRA 4.3.4\atlassian-jira\WEB
常用数学思想方法 comsci 工作
对于搞工程和技术的朋友来讲，在工作中常常遇到一些实际问题，而采用常规的思维方式无法很好的解决这些问题，那么这个时候我们就需要用数学语言和数学工具，而使用数学工具的前提却是用数学思想的方法来描述问题。。下面转帖几种常用的数学思想方法，仅供学习和参考函数思想　　把某一数学问题用函数表示出来，并且利用函数探究这个问题的一般规律。这是最基本、最常用的数学方法
pl/sql集合类型 daizj oracle 集合 type pl/sql
--集合类型 /* 单行单列的数据，使用标量变量单行多列数据，使用记录单列多行数据，使用集合（。。。） *集合：类似于数组也就是。pl/sql集合类型包括索引表（pl/sql table）、嵌套表（Nested Table）、变长数组（VARRAY）等 */ /* --集合方法 &n
[Ofbiz]ofbiz初用 dinguangx 电商 ofbiz
从github下载最新的ofbiz（截止2015-7-13），从源码进行ofbiz的试用 1. 加载测试库 ofbiz内置derby，通过下面的命令初始化测试库 ./ant load-demo (与load-seed有一些区别) 2. 启动内置tomcat ./ant start 或 ./startofbiz.sh 或 java -jar ofbiz.jar &
结构体中最后一个元素是长度为0的数组 dcj3sjt126com c gcc
在Linux源代码中，有很多的结构体最后都定义了一个元素个数为0个的数组，如/usr/include/linux/if_pppox.h中有这样一个结构体： struct pppoe_tag { __u16 tag_type; __u16 tag_len; &n
Linux cp 实现强行覆盖 dcj3sjt126com linux
发现在Fedora 10 /ubutun 里面用cp -fr src dest，即使加了-f也是不能强行覆盖的，这时怎么回事的呢？一两个文件还好说，就输几个yes吧，但是要是n多文件怎么办，那还不输死人呢？下面提供三种解决办法。方法一我们输入alias命令，看看系统给cp起了一个什么别名。 [root@localhost ~]# aliasalias cp=’cp -i’a
Memcached(一)、HelloWorld frank1234 memcached
一、简介高性能的架构离不开缓存，分布式缓存中的佼佼者当属memcached，它通过客户端将不同的key hash到不同的memcached服务器中，而获取的时候也到相同的服务器中获取，由于不需要做集群同步，也就省去了集群间同步的开销和延迟，所以它相对于ehcache等缓存来说能更好的支持分布式应用，具有更强的横向伸缩能力。二、客户端选择一个memcached客户端，我这里用的是memc
Search in Rotated Sorted Array II hcx2013 search
Follow up for "Search in Rotated Sorted Array":What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given ta
Spring4新特性——更好的Java泛型操作API jinnianshilongnian spring4 generic type
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
CentOS安装JDK liuxingguome centos
1、行卸载原来的： [root@localhost opt]# rpm -qa | grep java tzdata-java-2014g-1.el6.noarch java-1.7.0-openjdk-1.7.0.65-2.5.1.2.el6_5.x86_64 java-1.6.0-openjdk-1.6.0.0-11.1.13.4.el6.x86_64 [root@localhost
二分搜索专题2-在有序二维数组中搜索一个元素 OpenMind 二维数组算法二分搜索
1,设二维数组p的每行每列都按照下标递增的顺序递增。用数学语言描述如下：p满足 (1),对任意的x1，x2，y，如果x1<x2,则p(x1,y)<p(x2,y); (2),对任意的x，y1,y2, 如果y1<y2,则p(x,y1)<p(x,y2); 2,问题：给定满足1的数组p和一个整数k，求是否存在x0,y0使得p(x0,y0)=k? 3,算法分析： (
java 随机数 Math与Random SaraWon java Math Random
今天需要在程序中产生随机数，知道有两种方法可以使用，但是使用Math和Random的区别还不是特别清楚，看到一篇文章是关于的，觉得写的还挺不错的，原文地址是 http://www.oschina.net/question/157182_45274?sort=default&p=1#answers 产生1到10之间的随机数的两种实现方式： //Math Math.roun
oracle创建表空间 tugn oracle
create temporary tablespace TXSJ_TEMP tempfile 'E:\Oracle\oradata\TXSJ_TEMP.dbf' size 32m autoextend on next 32m maxsize 2048m extent m
使用Java8实现自己的个性化搜索引擎 yangshangchuan java superword 搜索引擎 java8 全文检索
需要对249本软件著作实现句子级别全文检索，这些著作均为PDF文件，不使用现有的框架如lucene，自己实现的方法如下： 1、从PDF文件中提取文本，这里的重点是如何最大可能地还原文本。提取之后的文本，一个句子一行保存为文本文件。 2、将所有文本文件合并为一个单一的文本文件，这样，每一个句子就有一个唯一行号。 3、对每一行文本进行分词，建立倒排表，倒排表的格式为：词=包含该词的总行数N=行号