비트맵 - Win32

CreateCompatibleDC()
DeleteDC()

DDB만이 메모리 DC에 선택될 수 있다.

DDB로 변경

LoadBitmap()

DeleteObject()

LoadImage()

LoadIcon, LoadCurosr, LoadBitmap 16비트 함수의 모든 기능을 통합해서 가지는 함수이며 몇가지 추가적인 기능을 더 가지고 있다. 이미지를 DIB 색션으로 읽을 수 있으며 파일 형태의 이미지를 읽을 수 있는 능력이 있으며 투명 처리, 크기 선택 등의 옵션이 적용된다. 32비트 프로그램에서는 가급적이면 이 함수로 이미지를 읽는 것이 좋다.
이 함수를 사용하면 DIB 파일을 읽어와 화면으로 출력할 수 있다.
이미지를 프린터로 출력할 때나 표준 크기가 아닌 아이콘을 읽을 때는 LoadIcon, LoadBitmap 대신 반드시 이 함수를 사용해야 한다.

IMAGE_BITMAP
IMAGE_ICON
IMAGE_CURSOR

LR_DEFAULTCOLOR
LR_LOADFROMFILE
LR_SHARED

DeleteObject()
DestroyIcon()
DestroyCursor()

ImageList_LoadBitmap()

ImageList_Destroy()
ImageList_Draw()

CreateDIBitmap()
CreateDIBSection()

CreateBitmap()
CreateBitmapIndirect()
CreateCompatibleBitmap()
DeleteObject()
GetObject()

    int iMainWidth;
    int iMainHeight;
        BITMAP bitmap;

        hBitmap = LoadBitmap(g_Inst, MAKEINTRESOURCE(IDB_BMT_DLGBACK));
        GetObject(hBitmap, sizeof(BITMAP), &bitmap);
        iMainWidth = bitmap.bmWidth;
        iMainHeight = bitmap.bmHeight;

SetDIBits()
GetDIBits()

BitBlt()
PatBlt()
StreachBlt()
SetStretchBltMode()

HALFTONE
COLORONCOLOR
BLACKONWHITE
WHITEONBLACK

TransparentBlt()

SetDIBitsToDevice()
StretchDIBits()

copies the color data for a rectangle of pixels in a DIB, JPEG, or PNG image to the specified destination rectangle
DIB를 DDB로 변환한 후 출력

DrawDibOpen()
DrawDibDraw()
DrawDibClose()
SetWorldTransform() // NT?

WM_QUERYNEWPALETTE
WM_PALETTECHANGED

저장하기

void DDB2DIB(HBITMAP hbit,LPCTSTR Path)
{
    BITMAPFILEHEADER fh;
    BITMAPINFOHEADER ih;
    BITMAP bit;
    BITMAPINFO *pih;
    int PalSize;
    HANDLE hFile;
    DWORD dwWritten,Size;
    HDC hdc;

    // 전체 화면에 대한 DC를 구한다.
    hdc=GetDC(NULL);

    // 비트맵 정보로부터 정보 구조체를 초기화한다.
    GetObject(hbit,sizeof(BITMAP),&bit);
    ih.biSize=sizeof(BITMAPINFOHEADER);
    ih.biWidth=bit.bmWidth;
    ih.biHeight=bit.bmHeight;
    ih.biPlanes=1;
    ih.biBitCount=bit.bmPlanes*bit.bmBitsPixel;
    ih.biCompression=BI_RGB;
    ih.biSizeImage=0;
    ih.biXPelsPerMeter=0;
    ih.biYPelsPerMeter=0;
    ih.biClrUsed=0;
    ih.biClrImportant=0;

    // 정보 구조체 + 팔레트 크기만큼 메모리를 할당하고 이 버퍼에
    // 정보 구조체를 복사한다.
    PalSize=(ih.biBitCount > 8 ? 0:1 << ih.biBitCount)*sizeof(RGBQUAD);
    pih=(BITMAPINFO *)malloc(ih.biSize+PalSize);
    pih->bmiHeader=ih;

    // 비트맵의 크기를 구한다.
    GetDIBits(hdc,hbit,0,bit.bmHeight,NULL,pih,DIB_RGB_COLORS);
    ih=pih->bmiHeader;

    // 비트맵 크기가 구해지지 않았을 경우 수작업으로 직접 계산한다.
    if (ih.biSizeImage == 0) {
        ih.biSizeImage=((((ih.biWidth*ih.biBitCount)+31) & ~31) >> 3) * ih.biHeight;
    }

    // 래스터 데이터를 읽기위해 메모를 재할당한다.
    Size=ih.biSize+PalSize+ih.biSizeImage;
    pih=(BITMAPINFO *)realloc(pih,Size);

    // 래스터 데이터를 읽어들인다.
    GetDIBits(hdc,hbit,0,bit.bmHeight,(PBYTE)pih+ih.biSize+PalSize,pih,DIB_RGB_COLORS);

    // 파일 헤더를 만든다.
    fh.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+PalSize;
    fh.bfReserved1=0;
    fh.bfReserved2=0;
    fh.bfSize=Size+sizeof(BITMAPFILEHEADER);
    fh.bfType=0x4d42;

    // 파일을 생성하고 파일 헤더와 정보 구조체, 팔레트, 래스터 데이터를 출력한다.
    hFile=CreateFile(Path,GENERIC_WRITE,0,NULL,
        CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    WriteFile(hFile,&fh,sizeof(fh),&dwWritten,NULL);
    WriteFile(hFile,pih,Size,&dwWritten,NULL);

    free(pih);
    ReleaseDC(NULL,hdc);
    CloseHandle(hFile);
}

외부 비트맵 파일 로딩

HANDLE handle = ::LoadImage( AfxGetInstanceHandle(),
                      lpszFileName,
                      IMAGE_BITMAP,
                      0, 0,
                      LR_LOADMAP3DCOLORS | LR_LOADFROMFILE );
 
if ( !handle )    // There were some problems during loading the image
      return FALSE;

BITMAPFILEHEADER *fh=NULL;
BITMAPINFOHEADER *ih;
int bx,by;
BYTE *pRaster;
// {{
HPALETTE hPal;
// }}
void LoadDIB(LPCTSTR Path)
{
    HANDLE hFile;
    DWORD FileSize, dwRead;
    int nCol,i;
    LOGPALETTE *pPal;
    RGBQUAD *pRgb;

    hFile=CreateFile(Path,GENERIC_READ,0,NULL,
        OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
    if (hFile==INVALID_HANDLE_VALUE) {
        return;
    }

    FileSize=GetFileSize(hFile,NULL);

    if (fh)
        free(fh);
    fh=(BITMAPFILEHEADER *)malloc(FileSize);
    ReadFile(hFile,fh,FileSize,&dwRead,NULL);
    CloseHandle(hFile);

    pRaster=(PBYTE)fh+fh->bfOffBits;
    ih=(BITMAPINFOHEADER *)((PBYTE)fh+sizeof(BITMAPFILEHEADER));
    bx=ih->biWidth;
    by=ih->biHeight;
// {{
    // 팔레트가 이미 정의되어 있으면 해제한다.
    if (hPal) {
        DeleteObject(hPal);
    }

    // 비트맵의 색상수를 구한다.
    nCol=(ih->biBitCount==24 ? 0:1 << ih->biBitCount);
    // 트루컬러인 경우는 팔레트가 없다.
    if (nCol != 256) {
        hPal=NULL;
    } else {
        // 비트맵의 색상 테이블 포인터를 구한다.
        pRgb=(RGBQUAD *)((PBYTE)ih+sizeof(ih));

        // 팔레트 생성을 위한 메모리를 할당한다.
        pPal=(LOGPALETTE *)malloc(sizeof(LOGPALETTE)+nCol*sizeof(PALETTEENTRY));
        pPal->palNumEntries=nCol;
        pPal->palVersion=0x300;

        // 비트맵의 색상 정보를 팔레트로 읽어들인다.
        for (i=0;i<nCol;i++) {
            pPal->palPalEntry[i].peRed=pRgb[i].rgbRed;
            pPal->palPalEntry[i].peGreen=pRgb[i].rgbGreen;
            pPal->palPalEntry[i].peBlue=pRgb[i].rgbBlue;
            pPal->palPalEntry[i].peFlags=0;
        }

        // 팔레트를 생성한다.
        hPal=CreatePalette(pPal);
        free(pPal);
    }
// }}
}

BOOL CDIBConvert::OpenBitmap(char *pszFile, HANDLE* phDIB)
{
CFile file;

if( !file.Open( pszFile, CFile::modeRead) )
return FALSE;

BITMAPFILEHEADER bmfHeader;
long nFileLen;
nFileLen = file.GetLength();

// Read file header
if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
return FALSE; // File type should be ''BM''

if (bmfHeader.bfType != ((WORD) (''M'' << 8) | ''B''))
return FALSE;

HGLOBAL hDIB = ::GlobalAlloc(GMEM_FIXED, nFileLen);

if (hDIB == 0)
return FALSE; // Read the remainder of the bitmap file.

if (file.ReadHuge((LPSTR)hDIB, nFileLen - sizeof(BITMAPFILEHEADER)) !=
nFileLen - sizeof(BITMAPFILEHEADER) )
{
::GlobalFree(hDIB);
return FALSE;
}

*phDIB = hDIB;
return TRUE;
}

렌더링하기

BITMAPFILEHEADER *fh=NULL;
BITMAPINFOHEADER *ih;
int bx,by;
BYTE *pRaster;
// {{
HPALETTE hPal;
// }}
...

LRESULT CALLBACK WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{
    HDC hdc;
    PAINTSTRUCT ps;
    ...
    switch (iMessage) {
    ...
    case WM_PAINT:
        hdc=BeginPaint(hWnd, &ps);
        if (fh) {
// {{
            // 팔레트가 정의되어 있으면 선택해 준다.
            if (hPal && (GetDeviceCaps(hdc,RASTERCAPS) & RC_PALETTE)) {
                SelectPalette(hdc,hPal,FALSE);
                RealizePalette(hdc);
            }
// }}
            SetDIBitsToDevice(hdc,0,0,bx,by,0,0,0,by,pRaster,
                (BITMAPINFO *)ih,DIB_RGB_COLORS);
        }
        EndPaint(hWnd, &ps);
        return 0;
// {{
    case WM_QUERYNEWPALETTE:
        if (hPal==NULL)
            return FALSE;
        hdc=GetDC(hWnd);
        SelectPalette(hdc,hPal,FALSE);
        RealizePalette(hdc);
        ReleaseDC(hWnd,hdc);
        InvalidateRect(hWnd,NULL,TRUE);
        return TRUE;
    case WM_PALETTECHANGED:
        if ((hPal==NULL) && ((HWND)wParam==hWnd))
            break;
        hdc=GetDC(hWnd);
        SelectPalette(hdc,hPal,FALSE);
        RealizePalette(hdc);
        UpdateColors(hdc);
        ReleaseDC(hWnd,hdc);
        return TRUE;
// }}
    }

    return(DefWindowProc(hWnd,iMessage,wParam,lParam));
}

void DrawBitmap(HDC hdc, int x, int y, HBITMAP hBit)
{
    HDC MemDC;
    HBITMAP OldBitmap;
    int bx ,by;
    BITMAP bit;

    MemDC = CreateCompatibleDC(hdc);
    OldBitmap = (HBITMAP)SelectObject(MemDC, hBit);

    GetObject(hBit, sizeof(BITMAP), &bit);
    bx = bit.bmWidth;
    by = bit.bmHeight;

    BitBlt(hdc, x, y, bx, by, MemDC, 0, 0, SRCCOPY);

    SelectObject(MemDC, OldBitmap);
    DeleteDC(MemDC);
}
/*

The DrawBitmap() function can be used with both a DDB and a DIB section. This function does take into account that the destination device context might have a map mode other than MM_TEXT. This might not work always or the effect may not be what you want.


// DrawBitmap - Draws a bitmap (DDB & DIB section) onto a device
// pDC - Pointer to a device context
// hBitmap - Handle of the bitmap
// hPal - Handle of a logical palette associated with the bitmap
// xDest - x-coordinate of the upper-left corner of the destination rect
// yDest - y-coordinate of the upper-left corner of the destination rect
void DrawBitmap( CDC *pDC, HBITMAP hBitmap, HPALETTE hPal, int xDest, int yDest )
{
// Get logical coordinates
BITMAP bm;
::GetObject( hBitmap, sizeof( bm ), &bm );
CPoint size( bm.bmWidth, bm.bmHeight );
pDC->DPtoLP(&size);

CPoint org(0,0);
pDC->DPtoLP(&org);

// Create a memory DC compatible with the destination DC
CDC memDC;
memDC.CreateCompatibleDC( pDC );
memDC.SetMapMode( pDC->GetMapMode() );

//memDC.SelectObject( &bitmap );
HBITMAP hBmOld = (HBITMAP)::SelectObject( memDC.m_hDC, hBitmap );


// Select and realize the palette
if( hPal && pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
{
SelectPalette( pDC->GetSafeHdc(), hPal, FALSE );
pDC->RealizePalette();
}
pDC->BitBlt(xDest, yDest, size.x, size.y, &memDC, org.x, org.y, SRCCOPY);

::SelectObject( memDC.m_hDC, hBmOld );
}

*/

// DrawDIB - Draws a DIB onto a device
// pDC - Pointer to a device context
// hDIB - Handle of the device-independent bitmap
// pPal - Pointer to a palette associated with the DIB
// xDest - x-coordinate of the upper-left corner of the destination rect
// yDest - y-coordinate of the upper-left corner of the destination rect
void DrawDIB( CDC* pDC, HGLOBAL hDIB, CPalette *pPal, int xDest, int yDest )
{
LPVOID lpDIBBits; // Pointer to DIB bits
BOOL bSuccess=FALSE; // Success/fail flag

BITMAPINFO &bmInfo = *(LPBITMAPINFO)hDIB ;
int nColors = bmInfo.bmiHeader.biClrUsed ? bmInfo.bmiHeader.biClrUsed :
1 << bmInfo.bmiHeader.biBitCount;

// Compute the address of the bitmap bits
if( bmInfo.bmiHeader.biBitCount > 8 )
lpDIBBits = (LPVOID)((LPDWORD)(bmInfo.bmiColors +
bmInfo.bmiHeader.biClrUsed) +
((bmInfo.bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0));
else
lpDIBBits = (LPVOID)(bmInfo.bmiColors + nColors);

// Select and realize the palette if one supplied and if device supports it
if( pPal && (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE) )
{
pDC->SelectPalette(pPal, FALSE);
pDC->RealizePalette();
}

::SetDIBitsToDevice(pDC->m_hDC, // hDC
xDest, // DestX
yDest, // DestY
bmInfo.bmiHeader.biWidth, // nDestWidth
bmInfo.bmiHeader.biHeight, // nDestHeight
0, // SrcX
0, // SrcY
0, // nStartScan
bmInfo.bmiHeader.biHeight, // nNumScans
lpDIBBits, // lpBits
(LPBITMAPINFO)hDIB, // lpBitsInfo
DIB_RGB_COLORS); // wUsage
}

GDI+

Image -> GdiplusBase

.GetWidth()
.GetHeight()

Graphics

.DrawImage()
.SetInterpolationMode()

InterpolationModeNearestNeighbor
InterpolationModeHighQualityBilinear

void CBitmapView::OnDraw(CDC* pDC)
{
    CLineDrawingDoc* pDoc = GetDocument();
    ASSERT_VALID(pDoc);
    // TODO: add draw code for native data here
    Graphics graphics(pDC->m_hDC);

    // Fish.jpg 파일 읽기
    Image image(L"Fish.jpg");
    int width = image.GetWidth();
    int height = image.GetHeight();

    // 화면에 출력
    graphics.DrawImage(&image, 10, 10, width, height);

    // 확대 출력
    graphics.SetInterpolationMode(InterpolationModeNearestNeighbor);
    graphics.DrawImage(&image, 10, 150, width*2, width*2);

    graphics.SetInterpolationMode(InterpolationModeHighQualityBilinear);
    graphics.DrawImage(&image, 220, 150, width*2, width*2);

    // 찌그려뜨려 출력
    Point points[] = {Point(250, 20), Point(150, 100), Point(300, 50)};
    graphics.DrawImage(&image, points, 3);
}

CreateEnhMetaFile()
CloseEnhMetaFile()
GetEnhMetaFile()
DeleteEnhMetaFile()
PlayEnhMetaFile()

참조 사이트:

http://mumbi.net/234?srchid=BR1http%3A%2F%2Fmumbi.net%2F234

http://semtle.kumoh.ac.kr/board7/540380
http://www.codeguru.com/Cpp/G-M/bitmap/article.php/c1765
http://support.microsoft.com/kb/80080
http://k.daum.net/qna/view.html?qid=0Co7h
http://jjjryu.tistory.com/entry/%EC%BB%B4%ED%93%A8%ED%84%B0-%ED%99%94%EB%A9%B4-%EC%BA%A1%EC%B3%90-Win32
http://jjjryu.tistory.com/entry/%EB%A6%AC%EC%86%8C%EC%8A%A4-Win32
http://jjjryu.tistory.com/entry/%EC%9D%B4%EB%AF%B8%EC%A7%80-%EB%A6%AC%EC%8A%A4%ED%8A%B8-Win32
http://www.winapi.co.kr/reference/Function/LoadImage.htm
http://www.codeguru.com/cpp/g-m/bitmap/specialeffects/article.php/c1743/