웨잇포림 님이 쓰신 글 :
: 안녕하세요.
:
: 이미지(사진)를 원이나 타원형으로 나오게 하고 싶은데 방법을 못 찾겠습니다.
:
: 빌더에 포함되어 있는 TImage 컨트롤은 사각형으로 밖에 안되더군요.
:
: 타원형으로 나오게 할 수 있는 방법이 없을까요?
:
: 감사합니다.

Region 키워드로 검색해 보세요. 아래는 제가 작업했던 소스중 일부 입니다. 참고하세요.^^

//---------------------------------------------------------------------------

#include "PreComplieHeader.h"

#include "BitmapRgn.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)


//---------------------------------------------------------------------------
__fastcall TBitmapRegin::TBitmapRegin(int DefaultRect)
{
    m_RegionData = NULL;
    DefaultRectCount = DefaultRect;
    TransparentPixel = new char[4];
}
//---------------------------------------------------------------------------
__fastcall TBitmapRegin::~TBitmapRegin()
{
    delete []TransparentPixel;
    if(m_RegionData != NULL){
        delete []m_RegionData;
        m_RegionData = NULL;
    }
}
//---------------------------------------------------------------------------
bool __fastcall TBitmapRegin::IsTransparent(int X)
{
    //typedef TRGBTriple * PTPixels24;
    //PTPixels24 T

    switch(PixelFormat){
        case pf8bit :
            return !memcmp(Pixels, TransparentPixel, 1);
        case pf16bit:
            return !memcmp(Pixels, TransparentPixel, 2);
        case pf24bit:
            /*
            if(
                abs(((TRGBTriple *)Pixels)[X].rgbtRed - PRGBTriple(TransparentPixel)->rgbtRed) < 10 &&
                abs(((TRGBTriple *)Pixels)[X].rgbtGreen - PRGBTriple(TransparentPixel)->rgbtGreen) < 10 &&
                abs(((TRGBTriple *)Pixels)[X].rgbtBlue - PRGBTriple(TransparentPixel)->rgbtBlue) < 10 )
                return true;
            return false;
            */

            if(
                ((TRGBTriple *)Pixels)[X].rgbtRed == PRGBTriple(TransparentPixel)->rgbtRed &&
                ((TRGBTriple *)Pixels)[X].rgbtGreen == PRGBTriple(TransparentPixel)->rgbtGreen &&
                ((TRGBTriple *)Pixels)[X].rgbtBlue == PRGBTriple(TransparentPixel)->rgbtBlue )
                return true;
            return false;
           

        case pf32bit:
            return !memcmp(Pixels, TransparentPixel, 4);
            //Result := TPixels32( Pixels^ )[ X ] = PCardinal( TransparentPixel )^;
    }
    return false;
}
//---------------------------------------------------------------------------
void __fastcall TBitmapRegin::AddRect(bool LastCol)
{
    if((RegionBufferSize / sizeof(TRect)) == m_iRectCount){
        RegionBufferSize += sizeof( TRect ) * DefaultRectCount;
        m_RegionData = (PRgnData)realloc(m_RegionData, sizeof(TRgnDataHeader) + RegionBufferSize + 3);
    }

    if(LastCol) X++;

    ((TRect *)m_RegionData->Buffer)[ m_iRectCount ].Left = NewRectLeft;
    ((TRect *)m_RegionData->Buffer)[ m_iRectCount ].Top = Y;
    ((TRect *)m_RegionData->Buffer)[ m_iRectCount ].Right = X;
    ((TRect *)m_RegionData->Buffer)[ m_iRectCount ].Bottom = Y + 1;

    m_iRectCount++;
    NewRectLeft = -1;
}
//---------------------------------------------------------------------------

HRGN __fastcall TBitmapRegin::CreateBitmapRgn(Graphics::TBitmap *Bitmap)
{
    PixelFormat = Bitmap->PixelFormat;
    Pixels = Bitmap->ScanLine[0];

    switch(PixelFormat){
        case pf8bit  : memcpy(TransparentPixel, Pixels, 1); break;
        case pf16bit : memcpy(TransparentPixel, Pixels, 2); break;
        case pf24bit : memcpy(TransparentPixel, Pixels, 3); break;
        case pf32bit : memcpy(TransparentPixel, Pixels, 4); break;
    }

    m_iRectCount = 0;
    RegionBufferSize = sizeof(TRect) * DefaultRectCount;
    m_RegionData = (PRgnData)new char[sizeof(TRgnDataHeader) + RegionBufferSize + 3];

    try {
        for(Y = 0; Y < Bitmap->Height;Y++){
            Pixels = Bitmap->ScanLine[Y];
            NewRectLeft = -1;
            for(X = 0; X < Bitmap->Width; X++){
                if(IsTransparent(X)){
                    if(NewRectLeft >= 0) AddRect();
                }
                else {
                    if(NewRectLeft == -1) NewRectLeft = X;
                    if((X == Bitmap->Width - 1) && (NewRectLeft >= 0) ) AddRect(true);
                }
            }
        }

        m_RegionData->rdh.dwSize = sizeof(TRgnDataHeader);
        m_RegionData->rdh.iType = RDH_RECTANGLES;
        m_RegionData->rdh.nCount = m_iRectCount;
        m_RegionData->rdh.nRgnSize = m_iRectCount * sizeof( TRect );

        return ExtCreateRegion(NULL, m_RegionData->rdh.dwSize + m_RegionData->rdh.nRgnSize, m_RegionData);
    }
    __finally {
        delete []m_RegionData;
        m_RegionData = NULL;
    }
}
//---------------------------------------------------------------------------




//---------------------------------------------------------------------------

#ifndef BitmapRgnH
#define BitmapRgnH
//---------------------------------------------------------------------------

//#include <vcl.h>
//#include <Graphics.hpp>

class TBitmapRegin
{

public:

    __fastcall TBitmapRegin(int DefaultRect = 50);
    __fastcall ~TBitmapRegin();

    HRGN __fastcall CreateBitmapRgn(Graphics::TBitmap *Bitmap);

private:

    int DefaultRectCount;

    TPixelFormat PixelFormat;
    void *Pixels;
    void *TransparentPixel;
    int  RegionBufferSize;
    int  m_iRectCount, NewRectLeft;
    int  X, Y;
    PRgnData m_RegionData;

    bool __fastcall IsTransparent(int X);
    void __fastcall AddRect(bool LastCol = false);

};


#endif