2011년 5월 5일 목요일

CxImage 라이브러리의 기능, 함수들

[CxImage란?]

파일/메모리를 통해 이미지를 입/출력하는 기능, 이미지를 화면에 보여주는 기능. 이미지를

변환하거나 처리하는 기능등을 모두 갖고 있습니다.


[CxImage Setting & 사용]

CxImage.dll, CxImage.lib, xImage.h 파일을 다운받습니다..(인터넷검색 이용)

일반적으로 dll을 사용하듯이 CxImage.lib 를 Object/library Modules: 에 추가해 줍니다.

#include "xImage.h" 파일을 인클루드 해줍니다.

CxImage* m_pImage; // 이런식으로 인스턴스를 선언하시고

m_pImage = new CxImage;

m_pImage->Load(lpszPathName, CxImage::FindType(lpszPathName));

이런식으로 사용하시면 됩니다.

[CxImage 기능]

------------------------------------------------------------------------------------------

생성및 입출력

Load : 파일에서 이미지 읽기

Decode : 메모리 버퍼에서 이미지 읽기

LoadResource : 리소스에서 이미지 읽기

Save : 파일에 저장

Encode : 메모리버퍼에 이미지 저장

Create : 가로 세로 길이 픽셀당 비트등의 매개변수로 새로운 이미지만들기(메모리)

CreateFromHBITMAP : DDB로부터 이미지 생성

CreateFromHICON : 아이콘으로 부터 이미지 생성

CreateFromHANDLE : 글로벌 핸들(클립보드)에서 이미지 생성

Copy : 이미지 복사

CopyToHandle : 글로벌핸들(클립보드)에 이미지 복사

Transfer : 이미지를 복사하고 원본 이미지 해제

Destroy : 이미지를 메모리에서 해제

----------------------------------------------------------------------------------------------------

이미지 출력

Draw : 이미지를 DC에 출력, 확대, 축소, 반투명 기능 추가

Tile : 이미지를 Tile형태로 반복 출력

DrawText : 이미지에 텍스트 그려 넣기

------------------------------------------------------------------------------------------

이미지 관련 정보 획득

GetBits : 이미지의 픽셀 데이터가 저장된 포인터 반환

GetBpp : 픽셀당 비트수 반환

GetPalette : 팔레트 정보 반환

GetHeight , GetWidth : 이미지의 가로 세로 크기 반환

GetEffWidth : 이미지의 한줄을 저장하는데 소요되는 바이트 수 반환

GetPixelColor : x,y 좌표를 매개로 받아 그 점의 값을 RGB로 반환

GetPixelIndex : x,y 좌포의 픽셀값을 인덱스로 반환

GetPixelGray : x,y 좌표의 픽셀값의 밝기를 반환

IsInside : x,y좌표가 이미지 내부인지를 반환

IsValid : 이미지가 로딩된 상태면 true , 아니면 false 를 반환

------------------------------------------------------------------------------------------

이미지 관련 정보 설정

SetPallete

SetPixelColor

SetPixelIndex

SetPixelGray

-----------------------------------------------------------------------------------------

이미지 좌표변환

Mirror : 좌우 반전

Flip : 상하반전

Rotate : 임의의 각도로 회전

RotateLeft : 좌로 90도 회전

RotateRight : 우로 90도 회전

Rotate180 : 이미지를 180도 회전

Resample : 이미지 크기 조절

Crop : 이미지의 일부 영역 잘라내기

Expand : 이미지의 크기는 그대로 두고 영역만 확장

Thumbnail : 이미 보기를 위한 작은 이미지 생성

-------------------------------------------------------------------

이미지 픽셀값 조절

Negative : 이미지 픽셀값 반전

Light : 밝기와 콘트라스트 조절

Filter : 이미지에 필터를 적용

----------------------------------------------------------------------------------

이미지 칼라및 포멧 변환

Threshold : 이진 이미지로 변환

GrayScale : 흑백 이미지로 변환

IncreaseBpp : 픽셀당 비트수 증가

DecreaseBpp : 픽셀당 비트수 감소

[CxImage 함수들]

--------------------------------------------------------------------

1. CxPoint2

• 멤버 변수

+ float x, + float y

: 좌표 (x, y)

• 메소드

+ CxPoint2()

+ CxPoint2(IN float const x_, IN float const y_)

+ CxPoint2(IN CxPoint2 const &p)

: 생성자. 디폴트 좌표는 (0, 0)이다.

+ float Distance(IN CxPoint2 const p2)

: 현재 점과 점 p2 사이의 거리를 반환한다.

+ float Distance(IN float const x_, IN float const y_)

: 현재 점과 점 (x, y) 사이의 거리를 반환한다.



2. CxRect2

• 멤버 변수

+ CxPoint2 botLeft

: 좌하단 좌표

+ CxPoint2 topRight

: 우상단 좌표

• 메소드

+ CxRect2()

+ CxRect2(IN float const x1_, IN float const y1_, IN float const x2_, IN float const y2_)

+ CxRect2(IN CxPoint2 const &bl, IN CxPoint2 const &tr)

+ CxRect2(IN CxRect2 const &p)

: 생성자. 디폴트값은 없다.

+ float Surface() const

: 사각형의 면적을 반환한다. 방향에 따라 음수가 반활 될 수도 있다.

+ CxRect2 CrossSection(IN CxRect2 const &r2) const

: 현재 사각형과 사각형 r2가 겹치는 부분의 사각형을 반환한다. 없다면 CxRect2(0,0,0,0)을 반환.

+ CxPoint2 Center() const

: 사각형의 중심의 좌표를 반환한다.

+ float Width()

: 사각형의 가로의 길이를 반환한다.

+ float Height()

: 사각형의 세로의 길이를 반환한다.



3. CxFile

추상클래스로 CxIOFile, CxMemFile의 부모 클래스가 된다.



4. CxIOFile

파일 입출력을 위한 클래스이다.

• 멤버 변수

# FILE *m_fp

: 파일 포인터를 멤버 변수로 가진다. 디폴트값은 NULL이다.

# bool m_bCloseFile

: 이 클래스에서 항상 true.

• 메소드

+ CxIOFile(IN FILE* fp = NULL)

: 생성자. 파일 포인터를 인수로 넘겨받을 수 있다. 인수를 생략하면 파일 포인터는 NULL로 초기화 된다.

+ bool Open(IN const char *filename, IN const char *mode)

: 파일명과 열기 모드를 지정하여 파일을 연다. 한 번 Open()한 뒤 다시 Open()하려면 먼저 Close() 메소드를 수행하여야 한다.

+ bool Close()

: 파일이 열려있다면 파일을 닫는다.

+ size_t Read(IN OUT void *buffer, IN size_t size, IN size_t count)

: buffer는 파일로부터 입력받은 데이터가 저장될 버퍼의 시작 주소, size는 입력 단위체의 크기, count는 입력받은 단위체의 개수이다. 실제로 입력받은 단위체의 개수를 반환한다.

+ size_t Write(IN const void *buffer, IN size_t size, IN size_t count)

: buffer는 출력할 데이터의 시작 주소, size는 출력 단위체의 크기, count는 출력할 단위체의 개수이다. 실제로 출력한 단위체의 개수를 반환한다.

+ bool Seek(IN long offset, IN int origin)

: 파일포인터를 (origin +offset) 위치로 이동시킨다. 성공 여부를 반환한다.

+ long Tell()

: 현재 파일 포인터가 파일의 시작 위치로부터 몇 바이트 떨어져 있는지 반환한다. ( ftell() 사용 )

+ long Size()

: 파일의 크기를 반환한다.

+ bool Flush()

: 입출력 스트림을 비운다. 즉 파일의 읽기 쓰기 작업을 완료시킨다. ( fflush() 사용 )

+ bool Eof()

: 파일 포인터가 파일의 맨 끝에 있으면 true를 반환한다.

+ long Error()

: 파일을 읽을 수 있으면 0을 반환한다.

+ bool PutC(IN unsigned char c)

: 파일 포인터가 가리키고 있는 곳에 한 문자를 기록한다. 성공 여부가 리턴 된다. 파일 포인터가 1증가 한다.

+ long GetC()

: 파일 포인터가 가리키고 있는 곳의 한 문자를 읽어서 반환한다. 파일 포인터가 1증가 한다.



5. CxMemFile

메모리 상에서 파일 입출력의 형태를 구현한 것이다.

• 멤버 변수

# BYTE *m_pBuffer

: 데이터가 저장될 버퍼

# DWORD m_size

: 저장된 데이터의 크기.

# bool m_bFreeOnClose

: Close()호출시 메모리가 해제된다면 true. GetBuffer()를 호출하면 버퍼에 대한 제어를 메소드를 호출한 쪽으로 넘기므로 메모리 해제도 그 곳에서 해야 한다.

# long m_Position

: 파일 포인터의 역할.

# long m_Edge

: 버퍼의 크기.


• 메소드

+ CxMemFile(IN BYTE *pBuffer = NULL, IN DWORD size = 0)

: 생성자. 메모리를 미리 할당하여 인수로 넘겨 줄 수 있다. pBuffer를 넘겨주면서 size를 비워두어도 에러가 발생하지 않으므로 주의한다. ( 다형성을 이용하여 해결해도 된다 )

+ bool Close()

: 파일을 닫는다. 즉 메모리를 반환한다.

+ bool Open()

: 파일을 연다. 다시 열기 위해선 먼저 Close()를 사용하여야 한다.

+ BYTE* GetBuffer(IN bool bDetachBuffer = true)

: 버퍼의 포인터를 반환한다. bDatachBuffer의 값이 true이면 Close()메소드가 동작하지 않게 된다.

+ size_t Read(IN OUT void *buffer, IN size_t size, IN size_t count)

: buffer는 파일로부터 입력받은 데이터가 저장될 버퍼의 시작 주소, size는 입력 단위체의 크기, count는 입력받은 단위체의 개수이다. 실제로 입력받은 단위체의 개수를 반환한다.

+ size_t Write(IN const void *buffer, IN size_t size, IN size_t count)

: buffer는 출력할 데이터의 시작 주소, size는 출력 단위체의 크기, count는 출력할 단위체의 개수이다. 실제로 출력한 단위체의 개수를 반환한다. 출력할 내용이 버퍼의 경계를 벗어나면 메모리 재할당이 일어난다.

+ bool Seek(IN long offset, IN int origin)

: 파일포인터를 (origin +offset) 위치로 이동시킨다. 성공 여부를 반환한다.

+ long Tell()

: 현재 파일 포인터가 파일의 시작 위치로부터 몇 바이트 떨어져 있는지 반환한다.

+ long Size()

: 파일의 크기를 반환한다.

+ bool Flush()

: 아무런 동작도 하지 않는다. ( 메모리에서는 필요 없다 )

+ bool Eof()

: 파일 포인터가 파일의 맨 끝에 있으면 true를 반환한다.

+ long Error()

: 파일을 읽을 수 있으면 0을 반환한다.

+ bool PutC(IN unsigned char c)

: 파일 포인터가 가리키고 있는 곳에 한 문자를 기록한다. 성공 여부가 리턴 된다. 버퍼의 경계를 넘어서면 메모리 재할당이 이루어진다. 파일 포인터가 1증가 한다.

+ long GetC()

: 파일 포인터가 가리키고 있는 곳의 한 문자를 읽어서 반환한다. 파일 포인터가 1증가 한다.

+ void Alloc(IN DWORD dwNewLen)

: 최소 dwNewLen 바이트만큼의 메모리를 할당 한다. 이미 메모리가 할당 되어있다면 재할당이 일어 날 수 있다.

+ void Free()

: Close()를 호출한다.



6. CxImage

• 구조체

ꋺ rgb_color

* BYTE r, g, b : RGB 색상.

ꋺ tagCxImageInfo

* DWORD wEffWidth

: 4의 배수로 정렬된 한 스캔 라인의 길이.

* BYTE* pImage

: 이미지 데이터가 저장된 공간의 시작 주소

* CxImage* pGhost

: 현재 이미지가 고스트 이미지라면 본래의 이미지를 가리킨다.

* CxImage* pParent

: 현재 이미지가 레이어라면 부모가 되는 이미지를 가리킨다.

* DWORD dwType

: 처음 로드한 이미지의 포맷

* char szLastError[256]

: 마지막으로 발생한 에러

* long nProgress

: 이미지에 대한 처리의 진행률.

* long nEscape

: -1이면 이미지에 대한 처리가 강제로 종료된다.

* long nBkgndIndex

: 팔레트를 사용하는 이미지에서 투명색의 인덱스 번호. GIF, PNG, MNG에서 사용한다. -1이면 투명효과를 사용하지 않는다.

* RGBQUAD nBkgndColor

: 24비트 이미지의 투명색.

* BYTE nQuality

: JPG에서 이미지의 품질.

* BYTE nJpegScale

: JPG 이미지를 읽어 들일 때 확대/축소 비율

* long nFrame

: GIF, TIF에서 현재 이미지의 프레임 번호.

* long nNumFrames

: GIF, TIF에서 전체 프레임의 개수.

* DWORD dwFrameDelay

: GIF에서 현재 프레임의 딜레이.

* long xDPI

: PNG의 x축 해상도.

* long yDPI

: PNG의 y축 해상도.

* RECT rSelectionBox

: 선택 영역.

* BYTE nAlphaMax

: 불투명도 최대값.

* bool bAlphaPaletteEnabled

: 알파 팔레트 사용 여부.

* bool bEnabled

: 이미지의 출력 가능 여부.

* long xOffset

: 이미지가 화면에 출력될 때의 시작점의 x좌표.

* long yOffset

: 이미지가 화면에 출력될 때의 시작점의 y좌표.

* DWORD dwCodecOpt[CMAX_IMAGE_FORMATS]

: for GIF, TIF : 0=def.1=unc,2=fax3,3=fax4,4=pack,5=jpg

* RGBQUAD last_c

: GetNearestIndex()에서 사용. 마지막으로 처리된 픽셀의 색상 정보.

* BYTE last_c_index

: GetNearestIndex()에서 사용. 마지막으로 처리된 픽셀의 색상 인덱스.

* bool last_c_isvalid

: GetNearestIndex()에서 사용. 픽셀이 하나라도 처리되었다면 true.

* long nNumLayers

: 전체 레이어의 개수.

* DWORD dwFlags

: 0x??00000 = reserved, 0x00??0000 = blend mode, 0x0000???? = layer id - user flags

ꋺ tagCxTextInfo

* TCHAR text[4096]

: 출력될 문자열.

* LOGFONT lfont

: 글꼴 정보

* COLORREF. fcolor

: 전경색.

* long align

: 멀티라인 텍스트를 위한 정렬 방식. DT_CENTER, DT_RIGHT, DT_LEFT

* BYTE opaque

: 배경을 가지면 true.

* COLORREF bcolor

: 배경색.

* float b_opacity

: 불투명도. 0.0 ~ 1.0. 디폴트는 0.

* BYTE b_outline

: 배경의 외곽선.

* BYTE b_round

: 배경의 외곽선 두께.

• 멤버 변수

# void *pDib

: 이미지 비트맵 정보의 시작 주소. ( 헤더 + 이미지 데이터 + 팔레트 )

# BITMAPINFOHEADER head

: 비트맵 이미지의 헤더

# CXIMAGEINFO info

: CxImage의 헤더

# BYTE *pSelection

: 선택된 영역. 원래 이미지와 크기가 같은 마스크.

# BYTE *pAlpha

: 알파 채널

# CxImage **pLayers

: 레이어 리스트에 대한 포인터.

• 메소드

# void AddAveragingCont(IN RGBQUAD const &color, IN float const surf, OUT float &rr, OUT float &gg, OUT float &bb, OUT float &aa)

: GetAreaColorInterpolated()에서 사용 된다.

+ void AlphaClear()

: 알파 채널 이미지의 값을 모두 0으로 만든다.

+ bool AlphaCopy(IN CxImage &from)

: 기존의 이미지 from으로부터 알파 채널 이미지를 복사해 온다.

+ void AlphaCreate()

: 알파 채널 이미지가 없다면 255로 초기화된 새로운 알파 채널 이미지를 생성한다.

+ void AlphaDelete()

: 알파 채널 이미지를 지운다. 할당된 메모리를 해제 한다.

+ bool AlphaFlip()

: 알파 채널 이미지를 상하로 뒤집는다.

+ BYTE AlphaGet(IN const long x, IN const long y)

: 알파 채널 이미지에서 지정한 좌표의 알파값을 반환한다.

+ BYTE AlphaGetMax() const

: 지정되어 있는 알파값의 최대치를 가져온다.

+ BYTE* AlphaGetPointer(IN const long x = 0, IN const long y = 0)

: 알파 채널 이미지에서 지정한 좌표의 알파값에 대한 포인터를 가져온다.

+ void AlphaInvert()

: 알파 채널 이미지의 값을 반전시킨다.

+ bool AlphaIsValid()

: 이미지가 알파 채널 이미지를 가지고 있다면 true를 반환한다.

+ bool AlphaMirror()

: 알파 채널 이미지를 좌우로 뒤집는다.

+ void AlphaPaletteClear()

: 팔레트의 알파값을 모두 0으로 만든다.

+ void AlphaPaletteEnable(IN bool enable = true)

: 팔레트의 알파값에 대한 사용 여부를 지정.

+ bool AlphaPaletteIsEnabled()

: 팔레트의 알파값을 사용할 수 있다면 true를 반환한다.

+ bool AlphaPaletteIsValid()

: 팔레트 색상 중에서 불투명한 것이 하나라도 있으면 true를 반환 한다.

+ bool AlphaPaletteSplit(OUT CxImage *dest)

: 현재 이미지의 알파값을 8비트 그레이 스캐일 이미지로 내보낸다.

+ void AlphaSet(IN const long x, IN const long y, IN const BYTE level)

: 지정한 좌표의 알파값을 level로 만든다.

+ void AlphaSet(IN BYTE level)

: 알파 채널 이미지의 모든 알파값을 level로 채운다.

+ bool AlphaSet(IN CxImage &from)

: from 이미지로부터 알파 채널 이미지를 현재 이미지로 복사해 온다.

+ void AlphaSetMax(IN BYTE nAlphaMax)

: 알파값의 최대치를 지정한다.

+ bool AlphaSplit(OUT CxImage *dest)

: 현재 이미지의 알파 채널 이미지를 8비트 그레이 스캐일 이미지로 내보낸다.

+ void AlphaStrip()

: 알파 채널 이미지와 현재 이미지를 결합하여 하나의 24비트 이미지를 만든다. 현재 이미지가 24비트이미지가 아니었다면 24비트 이미지로 변환된다.

# void Bitfield2RGB(IN BYTE *src, IN WORD redmask, IN WORD greenmask, IN WORD bluemask, IN BYTE bpp)

: 16또는 32비트 이미지가 담긴 버퍼로부터 RGB이미지를 읽어온다.

+ void BlendPalette(IN COLORREF cr, IN long perc)

: 팔레트의 모든 색상에 cr색상을 perc %만큼 섞어준다.

+ void BlendPixelColor(IN long x, IN long y, IN RGBQUAD c, IN float blend, IN bool IN bSetAlpha = false)

: 지정한 위치의 색상에 c색상을 blend만큼 섞어준다.

blend : 섞는 비율. 유효 범위 : 0.0 ~ 1.0

bSetAlpha : true이면 c의 알파값도 지정한 위치에 넣어준다.

# BYTE BlindAlphaGet(IN const long x, IN const long y)

: 지정한 위치의 알파값을 가져온다. 디버그모드에서만 좌표의 유효성을 검사한다.

# RGBQUAD BlindGetPixelColor(IN const long x, IN const long y)

: 지정한 좌표의 색상값을 반환한다. 실패하면 투명색 또는 검정색을 반환한다. 디버그모드 에서만 좌표의 유효성을 검사한다.

# BYTE BlindGetPixelIndex(IN const long x, IN const long y)

: 지정한 좌표의 팔레트 인덱스 값을 반환한다. 디버그모드 에서만 좌표의 유효성을 검사한다.

# void* BlindGetPixelPointer(IN const long x, IN const long y)

: 지정한 좌표의 픽셀 포인터를 반환한다. 24비트 이미지에서만 사용할 수 있다.

+ long Blt(IN HDC pDC, IN long x=0, IN long y=0)

: 이미지를 출력한다. CXIMAGE_SUPPORT_WINCE가 정의되어 있어야 한다.

# void blur_line (IN float *ctable, IN float *cmatrix, IN int cmatrix_length, IN BYTE *cur_col, OUT BYTE *dest_col, IN int y, IN long bytes)

: UnsharpMask()에서 사용 된다.

+ bool CircleTransform(IN int type, IN long rmax = 0, IN float Koeff = 1.0f)

: 이미지를 원에 기초하여 변환한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

type : 변환의 종류

0 : normal FishEye.

1 : reverse FishEye

2 : 나선형

3 : 실린더 미러

4 : 욕실 유리 효과

rmax : 효과가 적용될 반지름. 0이면 이미지 전체에 적용.

Koeff : 값이 클수록 회전각이 작아진다. 값이 클수록 더 적게 회전.

+ void Clear(IN BYTE bval = 0)

: 이미지를 지정한 비트로 채운다. 팔레트 이미지라면 bval은 팔레트의 인덱스가 된다.

+ bool Colorize(IN BYTE hue, IN BYTE sat, IN float blend = 1.0f)

: 본래의 색조와 채도를 지정한 값으로 대체한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

blend : 0 ~ 1. 0이면 효과 없음. 1이면 최대 효과.

+ bool Combine(IN CxImage *r, IN CxImage *g, IN CxImage *b,CxImage* a, IN long colorspace = 0)

: 서로 다른 8비트 채널 이미지를 합쳐서 하나의 이미지를 만든다.

colorspace : 색공간. 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ

# int CompareColors(IN const void *elem1, IN const void *elem2)

: elem1의 명도에서 elem2의 명도를 뺀 값을 반환한다.

+ bool Contour()

: 인접한 픽셀과의 색상차를 더욱 크게 한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ void Copy(IN const CxImage &src, IN bool copypixels = true, IN bool copyselection = true, IN bool copyalpha = true)

: 기존의 이미지 src로부터 이미지를 복사해 온다.

copypixels : 이미지 데이터를 복사한다.

copyselection : 선택영역 정보를 복사한다.

copyalpha : 알파채널을 복사한다.

# void CopyInfo(IN const CxImage &src)

: 기존의 이미지 src로부터 이미지의 정보를(CXIMAGEINFO) 복사해온다.

+ HANDLE CopyToHandle()

: 현재 이미지를 클립보드로 복사한다.

+ void* Create(IN DWORD dwWidth, IN DWORD dwHeight, IN DWORD wBpp, IN DWORD imagetype = 0)

: 이미지를 초기화하거나 기존 이미지를 제거하고 새로운 이미지를 만든다. 이미지의 크기에 맞는 버퍼도 할당된다.

+ bool CreateFromArray(IN BYTE *pArray, IN DWORD dwWidth, IN DWORD dwHeight, IN DWORD dwBitsperpixel, IN DWORD dwBytesperline, IN bool bFlipImage)

: 메모리 버퍼에 저장된 이미지로부터 이미지를 생성한다.

bFlipImage : 이미지가 뒤집혀져 있다면 true를 넣어 준다.

+ bool CreateFromHANDLE(IN HANDLE hMem)

: 클립보드로부터 새로운 이미지를 생성한다. 클립보드 이미지의 포맷은 반드시 CF_DIB 이어야 한다. 즉, BITMAPINFO 구조체를 가지고 있어야 한다.

+ bool CreateFromHBITMAP(IN HBITMAP hbmp, IN HPALETTE hpal = 0)

: 비트맵 리소스를 이용하여 이미지를 생성한다. 팔레트를 지정하면 그 팔레트를 사용하는 이미지를 만들게 된다.

+ bool CreateFromHICON(IN HICON hico)

: 아이콘 리소스를 이용하여 이미지를 생성한다.

+ bool CreateFromMatrix(IN BYTE **ppMatrix, IN DWORD dwWidth, IN DWORD dwHeight, IN DWORD dwBitsperpixel, IN DWORD dwBytesperline, IN bool bFlipImage)

: 배열에 저장된 DDB이미지를 지정한 인수에 따라 DIB이미지로 변환하여 이미지를 생성한다.

dwBitsperpixel : 픽셀당 비트수. 1, 4, 8, 24, 32 중에서 한 가지가 가능하다.

dwBytesperline : 한 스캔라인당 바이트수

dwFlipImage : true이면 이미지를 뒤집어서 생성한다.

+ bool Crop(IN const RECT& rect, OUT CxImage *iDst = NULL)

: 현재 이미지에서 지정한 영역만큼을 자른 뒤 그 이미지를 현재 이미지로 대체한다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool Crop(IN long left, IN long top, IN long right, IN long bottom, OUT CxImage *iDst = NULL)

: 현재 이미지에서 지정한 영역만큼을 자른 뒤 그 이미지를 현재 이미지로 대체한다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool CropRotatedRectangle(IN long topx, IN long topy, IN long width, IN long height, IN float angle, OUT CxImage *iDst = NULL)

: 자르는 영역에 회전을 준다. 나머지는 Crop()과 동일한 기능을 수행한다.

topx : 위 쪽의 두 점 중 왼쪽 점의 x값

topy : 위 쪽의 두 점 중 왼쪽 점의 y값

width : 선택영역의 너비

height : 선택영역의 높이

angle : 사각형의 회전각. 라디안을 사용한다.

iDst : Crop()과 동일

+ CxImage(IN DWORD imagetype = 0)

: Startup()만을 호출한다.

+ CxImage(IN CxFile *stream, IN DWORD imagetype)

: CxFile 객체를 이용하여 이미지를 로드한다.

+ CxImage(IN BYTE *buffer, IN DWORD size, IN DWORD imagetype)

: 버퍼에서 이미지를 가져온다. 버퍼는 CxMemFile 객체를 이용하여 파일 형태로 취급된다.

+ CxImage(IN DWORD dwWidth, IN DWORD dwHeight, IN DWORD wBpp, IN DWORD imagetype = 0)

: 이미지의 크기와 화소당 비트수(1, 4, 8, 24)를 지정하여 생성한다.

+ CxImage(IN const CxImage &src, IN bool copypixels = true, IN bool copyselection = true, IN bool copyalpha = true)

: 기존 이미지에서 새로운 이미지를 생성한다.

copypixels : 비트맵정보를 복사한다.

copyselection : 선택 영역의 데이터를 복사한다.

copyalpha : 알파 채널을 복사한다.

+ CxImage(IN const TCHAR *filename, IN DWORD imagetype)

: 파일로부터 이미지를 로드한다.

+ CxImage(IN FILE *stream, IN DWORD imagetype)

: 파일 핸들을 이용하여 이미지를 로드한다.

+ bool Decode(IN BYTE *buffer, IN DWORD size, IN DWORD imagetype)

: 메모리 버퍼로부터 파일을 읽어 들인다. 버퍼를 CxMemFile 객체를 이용하여 파일로 취급한다.

+ bool Decode(IN CxFile *hFile, IN DWORD imagetype)

: CxFile객체로부터 이미지를 읽어 들인다. 실제로 이미지를 읽어 들이는 메소드이다.

+ bool Decode(IN FILE *hFile, IN DWORD imagetype)

: 파일 핸들을 이용하여 이미지를 로드 한다. CxIOFile 객체를 이용한다.

+ bool DecreaseBpp(IN DWORD nbit, IN bool errordiffusion, IN RGBQUAD *ppal = 0, IN DWORD clrimportant = 0)

: 픽셀당 비트수를 nbit로 감소시킨다.

errordiffusion : true이면 에러디퓨전 디더링을 이용하여 화질을 향상시킨다.

ppal : 최종 이미지에서 사용될 팔레트. 지정하지 않으면 표준 팔레트가 사용된다.

clrimportant : 최종 이미지의 biClrImportant 값을 지정. 디폴트값은 0이다.

+ bool Destroy()

: 고스트 이미지가 아니라면 현재 할당된 메모리를 모두 해제한다. 고스트 이미지는 실제 이미지 데이터를 가진 객체를 가리키고 있을 뿐이므로 메모리를 해제할 필요가 없다. 모든 메모리가 해제되었다면 true를 반환하고 고스트이미지라면 false를 반환한다.

# bool DFT(IN int dir, IN long m, IN double *x1, IN double *y1, IN double *x2, IN double *y2)

: 이산 퓨리에 변환. x와 y는 2^m 개의 점을 가진 복소수 배열.

dir : 1이면 정변환, -1이면 역변환.

+ bool Dilate(IN long Ksize = 2)

: 이미지의 밝은 영역을 확장한다. Ksize는 커널(마스크)의 사이즈. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Dither(IN long method = 0)

: 지정한 방식에 따라 이미지를 흑백으로 변환한다.

0 = Floyd-Steinberg

1 = Ordered-Dithering (4x4)

2 = Burkes

3 = Stucki

4 = Jarvis-Judice-Ninke

5 = Sierra

6 = Stevenson-Arce

7 = Bayer (4x4 ordered dithering)

+ long Draw(IN HDC hdc, IN const RECT& rect, IN RECT *pClipRect = NULL, IN bool bSmooth = false)

: hdc를 이용하여 이미지를 화면에 출력한다. pClipRect를 지정하면 화면의 해당영역에만 이미지가 출력된다. 알파 채널, 알파 팔레트, 투명색, 불투명도를 지원한다.

+ long Draw(IN HDC hdc, IN long x = 0, IN long y = 0, IN long cx = -1, IN long cy = -1, IN RECT* pClipRect = 0, IN bool bSmooth = false)

: hdc를 이용하여 이미지를 화면에 출력한다. pClipRect를 지정하면 화면의 해당영역에만 이미지가 출력된다. 알파 채널, 알파 팔레트, 투명색, 불투명도를 지원한다.

+ long Draw2(IN HDC hdc, IN long x = 0, IN long y = 0, IN long cx = -1, IN long cy = -1)

: hdc를 이용하여 이미지를 화면에 출력한다. pClipRect를 지정하면 화면의 해당영역에만 이미지가 출력된다. 투명색만 지원한다.

+ long Draw2(IN HDC hdc, IN const RECT &rect)

: hdc를 이용하여 이미지를 화면에 출력한다. pClipRect를 지정하면 화면의 해당영역에만 이미지가 출력된다. 투명색만 지원한다.

+ void DrawLine(IN int StartX, IN int EndX, IN int StartY, IN int EndY, IN COLORREF cr)

: 브레즌햄 알고리즘을 이용하여 이미지에 선을 그린다.

+ void DrawLine(IN int StartX, IN int EndX, IN int StartY, IN int EndY, IN RGBQUAD color, IN bool bSetAlpha = false)

: 브레즌햄 알고리즘을 이용하여 이미지에 선을 그린다.

+ long DrawString(IN HDC hdc, IN long x, IN long y, IN const TCHAR *text, IN RGBQUAD color, IN const TCHAR *font, IN long lSize = 0, IN long lWeight = 400, IN BYTE bItalic = 0, IN BYTE bUnderline = 0, IN bool bSetAlpha = false)

: 이미지에 문자열을 출력한다.

+ long DrawStringEx(IN HDC hdc, IN long x, IN long y, IN CXTEXTINFO *pTextType, IN bool bSetAlpha = false );

: 이미지에 문자열을 출력한다.

+ bool Edge(IN long Ksize = 2)

: 픽셀간의 색상차이를 강조한다. 경계선이 나타난다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ void Enable(IN bool enable = true)

: 이미지의 출력 가능/불가능을 지정한다.

+ bool Encode(OUT CxFile *hFile, IN CxImage **pImages, IN int pagecount, IN DWORD imagetype)

: 여러 장의 이미지를 TIFF나 GIF 포맷으로 디스크에 저장한다.

pImages : 이미지 리스트

pagecount : 이미지의 개수

+ bool Encode(OUT CxFile *hFile, IN DWORD imagetype)

: 이미지를 특정 포맷(imagetype)으로 디스크에 저장한다.

+ bool Encode(OUT FILE *hFile, IN CxImage **pImages, IN int pagecount, IN DWORD imagetype)

: 여러 장의 이미지를 TIFF나 GIF 포맷으로 디스크에 저장한다.

pImages : 이미지 리스트

pagecount : 이미지의 개수

+ bool Encode(OUT BYTE * &buffer, OUT long &size, IN DWORD imagetype)

: 이미지를 특정 포맷(imagetype)으로 메모리의 버퍼에 저장한다. buffer는 반드시 NULL 이어야 한다.

+ bool Encode(OUT FILE *hFile, IN DWORD imagetype)

: 이미지를 특정 포맷(imagetype)으로 디스크에 저장한다.

+ bool Encode2RGBA(OUT BYTE * &buffer, OUT long &size)

: 이미지를 RGBA 포맷으로 변환하여 버퍼로 내보낸다.

+ bool Encode2RGBA(OUT CxFile *hFile)

: 이미지를 RGBA 포맷으로 변환하여 파일로 내보낸다. 파일은 CxMemFile, CxIOFile 타입을 사용하여야 한다.

# bool EncodeSafeCheck(IN CxFile *hFile)

: 인코딩을 위한 준비가 되었는지 검사한다. 준비가 되지 않았다면 true를 반환한다.

+ bool Erode(IN long Ksize = 2)

: 이미지의 어두운 영역을 확장시킨다. 커널의 크기를 Ksize로 지정한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Expand(IN long newx, IN long newy, IN RGBQUAD canvascolor, OUT CxImage *iDst = 0)

: 캔버스의 크기를 확장시킨다. newx와 현재 이미지의 너비 차이만큼 좌우가 확장되고 newy와 현재 이미지의 높이 차이만큼 상하가 확장된다. 본래의 이미지는 확장된 캔버스의 중앙에 위치하게 된다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

newx : 현재 이미지의 너비 + 확장할 너비

newy : 현재 이미지의 높이 + 확장할 높이

canvascolor : 확장된 공간에 채워질 색상

+ bool Expand(long left, long top, long right, long bottom, RGBQUAD canvascolor, CxImage *iDst = 0)

: 캔버스의 크기를 확장시킨다. 상하좌우의 크기를 따로 지정할 수 있다. 새로 만들어진 영역의 색깔을 canvascolor로 지정할 수 있다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

# bool FFT(IN int dir, IN int m,double *x, IN double *y)

: 빠른 퓨리에 변환. x와 y는 2^m 개의 점을 가진 복소수 배열.

dir : 1이면 정변환, -1이면 역변환.

+ bool FFT2(CxImage *srcReal, CxImage *srcImag, CxImage *dstReal, CxImage *dstImag, long direction = 1, bool bForceFFT = true, bool bMagnitude = true)

:

+ bool Filter(IN long *kernel, IN long Ksize, IN long Kfactor, IN long Koffset)

: 2차원 선형 필터를 적용한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

kernel : 선형 필터의 마스크를 1차원 행렬로 가진다.

Ksize : 마스크의 크기. 정방행렬이므로 행의 개수와 같다.

Kfactor : 마스크의 각 요소의 절대갑의 합.

Koffset : 마스크된 결과에 더해질 차이값.

예) 라플라시안 경계선 추출 필터

long kernel[] = {-1,-1,-1,-1,8,-1,-1,-1,-1}; Ksize = 3; Kfactor = 0, Koffset = 0

+ bool Flip()

: 이미지를 상하로 뒤집는다.

+ void FreeMemory(IN void* memblock)

: 메모리를 해제한다.

+ bool Gamma(IN float gamma)

: 색상 균형을 조절한다.

gamma : 0.1 ~ 5.0

# int gen_convolve_matrix (IN float radius, IN float **cmatrix_p)

: 2-패스 가우시안 필터의 각 패스에 사용될 1차원 컨볼루션 매트릭스를 생성한다.

# float* gen_lookup_table (IN float *cmatrix, IN int cmatrix_length)

: cmatrix를 이용하여 LUT를 만든다. 만들어진 LUT의 시작 주소를 반환한다.

+ RGBQUAD GetAreaColorInterpolated(IN float const xc, IN float const yc, IN float const w, IN float const h, IN InterpolationMethod const inMethod, IN OverflowMethod const ofMethod = OM_BACKGROUND, IN RGBQUAD *const rplColor = 0);

: 지정한 영역에서 보간한 색상을 반환한다.

inMethod : 보간 방식

IM_NEAREST_NEIGHBOUR : 가장 가까운 픽셀의 값을 반환한다.

IM_BILINEAR : 이웃한 4개의 픽셀을 이용하여 보간.

IM_BICUBIC : 인접한 16개의 픽셀을 이용하여 보간.

IM_BICUBIC2 : 인접한 16개의 픽셀을 이용하여 보간.

IM_BSPLINE : 인접한 16개의 픽셀을 이용하여 보간.

IM_LANCZOS : 인접한 12*12픽셀을 이용하여 보간.

ofMethod : 좌표를 계산하는 방식

OF_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OF_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OF_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

OF_COLOR : rplColor이 정의 되었다면 rplColor을 반환하고 그렇지 않으면 투명한 흰색을 반환한다.

OF_BACKGROUND : 배경색을 반환한다.

OF_TRANSPARENT : 투명색을 반환한다.

rplColor : 입력 색상. 픽셀에 대한 계산이 수행되지 않았을 때 기본적으로 반환되는 색상이다.

+ BYTE* GetBits(IN DWORD row = 0)

: 이미지에서 지정한 행의 픽셀에 대한 포인터를 얻는다.

+ WORD GetBpp() const;

: 이미지의 비트 당 픽셀의 개수를 가져온다.

+ DWORD GetClrImportant() const;

: 팔레트의 색상 중 이미지를 표현하는데 필요한 색상의 수를 가져온다. SetClrImportant()로 지정된 값이 반환된다.

+ DWORD GetCodecOption(DWORD imagetype = 0);

: 이미지의 인코딩 옵션값을 가져온다.

+ BYTE GetColorType()

: 1 : 팔레트 컬러. 2 : RGB. 3 : RGBA

+ void* GetDIB() const

: 이미지가 저장된 영역의 시작 포인터를 반환.

+ DWORD GetEffWidth() const

: 이미지의 가로 너비를 반환한다.

+ long GetEscape() const

: 탈출 코드를 가져온다.

+ DWORD GetFlags() const

: SetFlags() 참조.

+ long GetFrame() const

: 현재 선택된 프레임의 번호를 가져온다.

+ DWORD GetFrameDelay() const

: GIF 포맷에서 현재 프레임의 딜레이를 가져온다. 밀리세컨드 단위이다.

+ DWORD GetHeight() const

: 이미지의 높이를 반환한다. 세로 픽셀의 개수.

+ BYTE GetJpegQuality() const

: Jpeg 이미지의 품질값을 가져온다.

+ BYTE GetJpegScale() const

: Jpeg 이미지의 스캐일값을 가져온다.

+ const char* GetLastError()

: 마지막으로 발생한 에러의 메시지 내용을 가져온다.

+ CxImage* GetLayer(IN long position)

: 지정한 위치의 레이어가 반환된다. position값이 0보다 작다면 마지막 레이어가 반환된다.

+ BYTE GetNearestIndex(IN RGBQUAD c)

: 팔레트에서 색상 c와 가장 가까운 색상의 인덱스값을 반환한다.

+ DWORD GetNumColors() const

: 이미지에서 사용되는 색상의 수를 가져온다. 0이면 24비트 이미지.

+ long GetNumFrames() const

: 파일에 포함된 이미지의 개수를 반환한다.

+ long GetNumLayers() const

: 객체에 직접적으로 할당되어 있는 레이어의 개수를 반환한다.

+ void GetOffset(IN long *x, IN long *y)

: 이미지의 오프셋 값을 반환한다. 오프셋은 이미지가 화면에 출력될 시작 좌표이다.

+ RGBQUAD* GetPalette() const

: 팔레트의 시작 주소를 반환한다. 실패하면 NULL을 반환한다.

+ bool GetPaletteColor(IN BYTE i, OUT BYTE *r, OUT BYTE *g, OUT BYTE *b)

: 지정한 인덱스의 색상값을 전달한다. 성공하면 true를 반환한다.

+ RGBQUAD GetPaletteColor(IN BYTE idx)

: 지정한 인덱스의 색상값을 반환한다. 실패하면 검정색을 반환한다.

+ DWORD GetPaletteSize()

: 팔레트의 크기를 반환한다. 바이트 단위이다.

+ CxImage* GetParent() const

: 객체가 레이어를 포함하고 있다면 그 레이어를 가지는 부모 레이어 이미지에 대한 포인터를 반환한다.

+ RGBQUAD GetPixelColor(IN long x, IN long y, IN bool bGetAlpha = true)

: 지정한 좌표의 색상값을 반환한다. 실패하면 투명색 또는 검정색을 반환한다.

+ RGBQUAD GetPixelColorInterpolated(IN float x, IN float y, IN InterpolationMethod const inMethod = IM_BILINEAR, IN OverflowMethod const ofMethod = OM_BACKGROUND, IN RGBQUAD *const rplColor = 0);

: 픽셀의 보간된 색상을 반환한다.

inMethod : 보간 방식

IM_NEAREST_NEIGHBOUR : 가장 가까운 픽셀의 값을 반환한다.

IM_BILINEAR : 이웃한 4개의 픽셀을 이용하여 보간.

IM_BICUBIC : 인접한 16개의 픽셀을 이용하여 보간.

IM_BICUBIC2 : 인접한 16개의 픽셀을 이용하여 보간.

IM_BSPLINE : 인접한 16개의 픽셀을 이용하여 보간.

IM_LANCZOS : 인접한 12*12픽셀을 이용하여 보간.

ofMethod : 좌표를 계산하는 방식

OF_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OF_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OF_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

OF_COLOR : rplColor이 정의 되었다면 rplColor을 반환하고 그렇지 않으면 투명한 흰색을 반환한다.

OF_BACKGROUND : 배경색을 반환한다.

OF_TRANSPARENT : 투명색을 반환한다.

rplColor : 입력 색상. 픽셀에 대한 계산이 수행되지 않았을 때 기본적으로 반환되는 색상이다.

+ RGBQUAD GetPixelColorWithOverflow(IN long x, IN long y, IN OverflowMethod const ofMethod = OM_BACKGROUND, IN RGBQUAD *const rplColor = 0);

: 픽셀의 좌표를 지정한 방식에 따라 다시 계산한다. 정수 좌표를 사용한다.

ofMethod : 좌표를 계산하는 방식

OF_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OF_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OF_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

OF_COLOR : rplColor이 정의 되었다면 rplColor을 반환하고 그렇지 않으면 투명한 흰색을 반환한다.

OF_BACKGROUND : 배경색을 반환한다.

OF_TRANSPARENT : 투명색을 반환한다.

rplColor : 입력 색상. 픽셀에 대한 계산이 수행되지 않았을 때 기본적으로 반환되는 색상이다.

+ BYTE GetPixelGray(IN long x, IN long y)

: 지정한 좌표의 색상을 그레이 스캐일로 변환하여 반환한다.

+ BYTE GetPixelIndex(IN long x, IN long y)

: 지정한 좌표의 팔레트 인덱스 값을 반환한다.

+ long GetProgress() const

: 느린 반복 등을 관리하기 위한 것.

+ long GetSize()

: 이미지의 크기를 반환한다.

+ RGBQUAD GetTransColor()

: 투명색을 가져온다.

+ long GetTransIndex() const

: 투명색의 인덱스를 가져온다. 없다면 -1이 반환된다.

+ DWORD GetType() const

: 현재 이미지의 포맷을 반환한다.

+ const TCHAR* GetVersion()

: CxImage의 버전을 반환한다.

+ const float GetVersionNumber()

: CxImage의 버전을 실수형으로 반환한다.

+ DWORD GetWidth() const

: 이미지의 너비를 반환한다. 가로 픽셀의 개수.

+ long GetXDPI() const

: TIFF, JPEG, PNG, BMP 포맷을 위한 수평 해상도를 가져온다.

+ long GetYDPI() const

: TIFF, JPEG, PNG, BMP 포맷을 위한 수직 해상도를 가져온다.

# void Ghost(IN CxImage *from)

: from의 head, info 정보는 복사해오고 나머지 정보는 포인터만 획득한다. info.pGhost 는 from을 가리키게 된다. 기존에 할당되어 있는 메모리를 해제하지는 않고 고스트 이미지를 만들기 때문에 사용에 주의를 기울여야 하겠다. public이 아니므로 외부에서는 접근할 수 없는 메소드이다.

+ bool GrayScale()

: 이미지를 8비트 그레이 스캐일 이미지로 변환한다.

+ long Histogram(IN long *red, IN long *green = 0, IN long *blue = 0, IN long *gray = 0, IN long colorspace = 0)

: 이미지 전체에서 색상의 각 요소들의 출현 빈도를 계산한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

colorspace : 색공간을 RGB로 변환한다.

0 : 디폴트. 변환 없음.

1 : HSL에서 RGB로 변환

2 : YUV에서 RGB로 변환

3 : YIQ에서 RGB로 변환

4 : XYZ에서 RGB로 변환

+ bool HistogramEqualize()

: 이미지에 히스토그램 평활화를 적용한다.

+ bool HistogramLog()

: 히스토그램에 로그를 취한다. 밝기 변화가 좀 더 급해진다.

+ bool HistogramNormalize()

: 휘도값에 따라 히스토그램에 스트레치를 적용한다.

+ bool HistogramRoot()

: 히스토그램에 루트를 취한다.

+ bool HistogramStretch(IN long method = 0)

: 히스토그램을 확장하여 범위가 0 ~ 255가 되게 한다.

method

0 = luminance. YUV 색공간에서 휘도(Y)성분을 사용.

1 = linked channels. 하나의 LUT를 사용.

2 = independent channels. 각 채널별로 독립적인 LUT를 사용.

+ RGBQUAD HSLtoRGB(IN RGBQUAD lHSLColor)

: HSL컬러공간에서 YUV컬러공간으로 변환한다.

+ RGBQUAD HSLtoRGB(IN COLORREF cHSLColor)

: HSL컬러공간에서 YUV컬러공간으로 변환한다.

+ void HuePalette(IN float correction = 1)

: 레인보우 팔레트를 생성한다.

# float HueToRGB(IN float n1, IN float n2, IN float hue)

: Huew 값을 RGB 색공간으로 변환한 값을 반환한다.

+ bool IncreaseBpp(DWORD nbit)

: 픽셀당 비트수를 nbit로 증가시킨다.

+ void InitTextInfo( OUT CXTEXTINFO *txt );

: txt를 초기화한다.

+ bool IsEnabled() const

: 이미지가 출력가능하면 true를 반환한다.

+ bool IsGrayScale()

: 이미지가 256컬러를 사용하고 선형 그레이 스캐일 팔레트를 가졌다면 true를 반환한다.

선형 그레이 스캐일 : 인덱스 번호와 색상의 값이 똑같다.

+ bool IsIndexed() const

: 이미지가 256컬러나 그 이하를 사용한다면 true를 반환한다.

+ bool IsInside(IN long x, IN long y)

: 지정한 좌표가 이미지 안에 있으면 true를 반환한다.

# bool IsPowerof2(IN long x)

: x가 2의 멱수이면 true를 반환한다.

+ bool IsSamePalette(IN CxImage &img, IN bool bCheckAlpha)

: img가 현재 이미지와 같은 팔레트를 가지는 지 비교한다. bCheckAlpha가 true이면 rgbReserved 필드의 값도 비교한다.

+ bool IsTransparent(long x, long y)

: 지정한 좌표의 색상이 투명색이면 true를 반환한다.

+ bool IsTransparent() const

: 이미지가 투명색을 사용한다면 true를 반환한다.

+ bool IsValid() const

: 이미지가 올바르게 초기화 되었는지 검사한다. 올바르다면 true를 반환한다.

+ bool Jitter(IN long radius)

: 이미지의 각 픽셀을 무작위로 이동시킨다. radius는 픽셀이 이동 가능한 최대 거리이다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ float KernelBessel(const float x)

+ float KernelBessel_J1(const float x)

+ float KernelBessel_Order1(float x)

+ float KernelBessel_P1(const float x)

+ float KernelBessel_Q1(const float x)

+ float KernelBlackman(const float x)

+ float KernelBox(const float x)

+ float KernelBSpline(const float x)

+ float KernelCatrom(const float x)

+ float KernelCubic(const float t)

+ float KernelGaussian(const float x)

+ float KernelGeneralizedCubic(const float t, const float a=-1)

+ float KernelHamming(const float x)

+ float KernelHermite(const float x)

+ float KernelLanczosSinc(const float t, const float r = 3)

+ float KernelLinear(const float t)

+ float KernelMitchell(const float x)

+ float KernelQuadratic(const float x)

+ float KernelSinc(const float x)

: 보간에 사용되는 커널들.

+ bool LayerCreate(IN long position = -1)

: 비어있는 새로운 레이어를 만든다. position값이 0보다 작으면 새로운 레이어를 가장 마지막 position에 위치시킨다.

+ bool LayerDelete(IN long position = -1)

: 지정한 position의 레이어를 지운다. position값이 0보다 작으면 마지막 위치의 레이이가 지워진다.

+ void LayerDeleteAll()

: 모든 레이어를 지운다.

+ bool Light(long brightness, long contrast = 0)

: 이미지의 명도와 대비를 변화시킨다.

brightness : -255 ~ 255. 음수이면 이미지를 어둡게 만든다.

contrast : -100 ~ 100.

+ bool Load(IN const TCHAR *filename, IN DWORD imagetype = 0)

: 파일로부터 이미지를 지정한 타입으로 로드 한다. 만약 타입을 지정하지 않거나 UNKNOWN으로 지정할 경우 자동으로 알맞은 형식의 타입을 찾는다. ( 모든 타입에 대해 한 번씩 시도해보는 방식 )

+ bool LoadResource(IN HRSRC hRes, IN DWORD imagetype, IN HMODULE hModule = NULL)

: 리소스로부터 이미지를 읽어 들인다.

hRes : FindResource()가 반환하는 리소스의 핸들

imagetype : 이미지 포맷. ENUM_CXIMAGE_FORMATS 참조.

hModule : 내부 리소스일 경우 디폴트 값 NULL을 사용하고 외부 리소스일 경우 LoadLibrary()가 반환하는 hinstance 이다.

+ bool Lut(IN BYTE *pLutR, IN BYTE *pLutG, IN BYTE *pLutB, IN BYTE *pLutA = 0)

: 각 채널에 대한 독립된 Lookup Table을 가진다. 원리는 Lut(IN BYTE *pLut)와 동일하다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Lut(IN BYTE *pLut)

: Lookup Table을 이미지에 적용시킨다. 이미지의 i번째 픽셀의 색상값이 100이라면 pLut의 100번째 값을 새로운 색상값으로 가지게 된다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

pLut : BYTE pLut[256];

+ HBITMAP MakeBitmap(HDC hdc = NULL)

: 이미지를 비트맵 형식으로 변환하여 HBITMAP 구조체를 반환한다.

+ float Mean()

: 이미지의 명도를 반환한다. 전체 픽셀을 그레이 스캐일로 변환한 뒤 픽셀값의 평균을 반환한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Median(IN long Ksize=3)

: 중앙값 필터. 주위 픽셀의 값을 크기 순으로 정렬하였을 때 중앙에 있는 값을 현재 픽셀의 값으로 한다. Ksize는 마스크의 크기이다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Mirror()

: 이미지를 좌우로 뒤집는다.

+ void Mix(IN CxImage &imgsrc2, IN ImageOpType op, IN long lXOffset = 0, IN long lYOffset = 0, IN bool bMixAlpha = false)

: 두 이미지를 섞는다.

imgsrc2 : 현재 이미지에 섞을 이미지

imageOpType : 섞는 방법

OpAdd : p + q

OpSub : p - q

OpAnd : p & q

OpXor : p ^ q

OpOr : p | q

OpMask : 검정색을(RGB(0,0,0)) 투명색으로 변환.

OpSrcCopy : 현재 이미지의 투명한 부분에 imgsrc2 이미지를 복사.

OpDstCopy : imgsrc2 이미지의 투명한 부분에 현재 이미지를 복사.

OpScreen : imgsrc2 이미지의 투명도에 따라 블렌딩 처리.

OpSrcBlend : 현재 이미지의 투명도에 따라 블렌딩 처리.

lXOffset , lYOffset : imgsrc2 이미지에서 섞게 될 부분의 좌상단 좌표

bMixAlpha : true이면 알파값도 섞는다.

+ void MixFrom(IN CxImage &imagesrc2, IN long lXOffset, IN long lYOffset)

: imagesrc2 이미지에서 투명하지 않은 픽셀을 현재 이미지에 찍는다.

lXOffset , lYOffset : imagesrc2 이미지에서 섞게 될 부분의 좌상단 좌표

+ bool Negative()

: 이미지의 색상을 반전시킨다. 선택영역이 있다면 선택영역의 색상만 반전된다.

+ bool Noise(IN long level)

: 이미지에 노이즈를 추가한다. level에 높은 값을 줄수록 노이즈가 심해진다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ CxImage& operator = (const CxImage& isrc)

: 대입 연산자 오버로딩.

+ void OverflowCoordinates(IN OUT long &x, IN OUT long &y, IN OverflowMethod const ofMethod)

: 픽셀의 좌표를 지정한 방식에 따라 다시 계산한다. 정수 좌표를 사용한다.

ofMethod : 좌표를 계산하는 방식

OM_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OM_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OM_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

+ void OverflowCoordinates(IN OUT float &x, IN OUT float &y, IN OverflowMethod const ofMethod)

: 픽셀의 좌표를 지정한 방식에 따라 다시 계산한다. 실수 좌표를 사용한다. 정수 좌표를 위한 OverflowCoordinates() 참조.

+ bool QIShrink(IN long newx, IN long newy, OUT CxImage *const iDst = NULL)

: 이미지의 너비를 newx로, 높이를 newy로 축소시킨다. 확대시키지는 못한다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool RedEyeRemove()

: 적목 현상 제거. 제거가 필요한 눈 부분을 선택 영역으로 지정 하여야 한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Repair(IN float radius = 0.25f, IN long niterations = 1, IN long colorspace = 0)

: 이미지에 번짐 효과를 적용한다.

radius : 보통 0.01 ~ 0.5

niterations : 적용 횟수. 번짐을 피하려면 (radius*niterations) < 1 이 되어야 한다.

colorspace : 색공간. 0 = RGB, 1 = HSL, 2 = YUV, 3 = YIQ, 4 = XYZ

# bool RepairChannel(IN CxImage *ch, IN float radius)

: 하나의 색 채널에 대해 RepairChannel()이 수행된다.

+ bool Resample(IN long newx, IN long newy, IN int mode = 1, OUT CxImage* iDst = NULL)

: 이미지의 크기를 변경한다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

mode : 0은 이중선형 보간법으로 속도가 느리고 1은 가장 근접한 픽셀을 선택하는 방식으로 속도가 빠르다. 2는 bicubic 스플라인 보간법으로 품질이 좋다.

+ bool Resample2(IN long newx, IN long newy, IN InterpolationMethod const inMethod = IM_BICUBIC2, IN OverflowMethod const ofMethod = OM_REPEAT, IN CxImage *const iDst = NULL, IN bool const disableAveraging = false)

: 이미지의 크기를 변경한다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

inMethod : 보간 방식

IM_NEAREST_NEIGHBOUR : 가장 가까운 픽셀의 값을 반환한다.

IM_BILINEAR : 이웃한 4개의 픽셀을 이용하여 보간.

IM_BICUBIC : 인접한 16개의 픽셀을 이용하여 보간.

IM_BICUBIC2 : 인접한 16개의 픽셀을 이용하여 보간.

IM_BSPLINE : 인접한 16개의 픽셀을 이용하여 보간.

IM_LANCZOS : 인접한 12*12픽셀을 이용하여 보간.

ofMethod : 좌표를 계산하는 방식

OF_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OF_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OF_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

OF_COLOR : rplColor이 정의 되었다면 rplColor을 반환하고 그렇지 않으면 투명한 흰색을 반환한다.

OF_BACKGROUND : 배경색을 반환한다.

OF_TRANSPARENT : 투명색을 반환한다.

+ COLORREF RGBQUADtoRGB (RGBQUAD c)

: RGBQUAD 타입 색상을 COLORREF 타입으로 변환한다.

# void RGBtoBGR(BYTE *buffer, int length)

: RGB색상에서 Red와 Blue의 위치를 서로 바꾼다.

buffer : 변환할 픽셀이 저장되어 있는 버퍼

length : 버퍼의 길이. 바이트 단위이다.

+ RGBQUAD RGBtoHSL(RGBQUAD lRGBColor)

: RGB컬러공간에서 HSL컬러공간으로 변환한다.

+ RGBQUAD RGBtoRGBQUAD(COLORREF cr)

: COLORREF 타입 색상을 RGBQUAD 타입으로 변환한다.

+ RGBQUAD RGBtoXYZ(RGBQUAD lRGBColor)

: RGB컬러공간에서 HSL컬러공간으로 변환한다.

+ RGBQUAD RGBtoYIQ(RGBQUAD lRGBColor)

: RGB컬러공간에서 XYZ컬러공간으로 변환한다.

+ RGBQUAD RGBtoYUV(RGBQUAD lRGBColor)

: RGB컬러공간에서 YUV컬러공간으로 변환한다.

+ bool Rotate(IN float angle, OUT CxImage *iDst = NULL)

: 이미지를 지정한 각도만큼 회전시킨다. 회전된 이미지가 모두 들어 갈 수 있는 크기로 이미지가 확장된다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool Rotate180(OUT CxImage *iDst = NULL)

: 이미지를 180도 회전시킨다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool Rotate2(IN float angle, IN CxImage *iDst = NULL, IN InterpolationMethod inMethod = IM_BILINEAR, IN OverflowMethod ofMethod = OM_BACKGROUND, IN RGBQUAD *replColor = 0, IN bool const optimizeRightAngles = true, IN bool const bKeepOriginalSize = false);

: 이미지를 지정한 각도만큼 회전시킨다. 회전된 이미지가 모두 들어 갈 수 있는 크기로 이미지가 확장된다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

inMethod : 보간 방식

IM_NEAREST_NEIGHBOUR : 가장 가까운 픽셀의 값을 반환한다.

IM_BILINEAR : 이웃한 4개의 픽셀을 이용하여 보간.

IM_BICUBIC : 인접한 16개의 픽셀을 이용하여 보간.

IM_BICUBIC2 : 인접한 16개의 픽셀을 이용하여 보간.

IM_BSPLINE : 인접한 16개의 픽셀을 이용하여 보간.

IM_LANCZOS : 인접한 12*12픽셀을 이용하여 보간.

ofMethod : 좌표를 계산하는 방식

OF_REAPET : 이미지의 경계를 벗어나면 클립 되어 경계선에 놓이게 된다.

OF_WRAP : 이미지의 크기를 단위크기로 한 상대 좌표에 놓이게 된다.

OF_MIRROR : 이미지의 경계선에 대하여 반사된 위치에 놓이게 된다.

OF_COLOR : rplColor이 정의 되었다면 rplColor을 반환하고 그렇지 않으면 투명한 흰색을 반환한다.

OF_BACKGROUND : 배경색을 반환한다.

OF_TRANSPARENT : 투명색을 반환한다.

replColor : 입력 색상. 픽셀에 대한 계산이 수행되지 않았을 때 기본적으로 반환되는 색상이다.

optimizeRightAngles : 90도, 180도, 270도 회전에는 더 빠른 회전 함수를 호출한다.

bKeepOriginalSize : true이면 이미지를 회전하여도 이미지의 본래 크기가 유지 된다.

+ bool RotateLeft(OUT CxImage *iDst)

: 이미지를 왼쪽으로 90도 회전시킨다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool RotateRight(OUT CxImage *iDst)

: 이미지를 오른쪽으로 90도 회전시킨다. 만약 iDst를 지정하면 현재 이미지를 대체하지 않고 iDst에 처리된 이미지를 전달한다.

+ bool Save(IN const TCHAR *filename, IN DWORD imagetype)

: 이미지를 지정한 포맷으로 디스크에 저장한다.

+ bool SelectionAddColor(IN RGBQUAD c)

: 지정한 색상의 픽셀을 선택영역에 포함시킨다.

+ bool SelectionAddEllipse(IN RECT r)

: 기존의 선택영역에 타원형의 영역을 더한다.

+ bool SelectionAddPixel(IN int x, IN int y)

: 지정한 좌표의 픽셀을 선택영역에 더한다.

+ bool SelectionAddPolygon(IN POINT *points, IN long npoints)

: 기존의 선택영역에 다각형의 영역을 더한다.

points : 다각형의 꼭지점 리스트.

npoints : 꼭지점의 개수.

+ bool SelectionAddRect(IN RECT r)

: 기존의 선택영역에 사각형의 영역을 더한다.

+ bool SelectionClear()

: 선택영역을 지운다.

+ bool SelectionCopy(IN CxImage &from)

: from 이미지로부터 선택영역을 복사해 온다.

+ bool SelectionCreate()

: 선택영역에 대한 정보를 담을 새로운 버퍼를 생성한다.

+ bool SelectionDelete()

: 선택영역에 대한 정보를 담고 있는 버퍼를 제거한다.

+ void SelectionGetBox(IN RECT &r)

: 선택영역을 모두 포함하는 가장 작은 사각형을 반환한다.

+ bool SelectionInvert()

: 선택영역을 반전시킨다.

+ bool SelectionIsInside(IN long x, IN long y)

: 지정한 좌표가 선택영역 안에 있으면 true를 반환한다.

+ bool SelectionIsValid()

: 선택영역을 위한 버퍼가 할당되어 있다면 true를 반환한다.

+ bool SelectionSplit(OUT CxImage *dest)

: 선택 영역을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SelectionToHRGN(OUT HRGN &region)

: 선택영역을 HRGN 타입으로 변환시킨다.

+ void SetClrImportant(IN DWORD ncolors = 0)

: 팔레트의 색상 중 이미지를 표현하는데 필요한 색상의 수를 지정한다. 인수의 값은 2^bpp보다 작은 값이어야 하며 0또는 생략하면 모든 색상을 필요로 한다는 의미가 된다.

+ bool SetCodecOption(IN DWORD opt, IN DWORD imagetype = 0)

: GIF, TIF, JPG에 대한 인코딩 옵션을 지정한다.

GIF : 0 = LZW (디폴트), 1 = none, 2 = RLE.

TIF : 0 = 자동 (디폴트), 또는 "tiff.h"에 정의되어 있는 것들. (COMPRESSION_NONE = 1, COMPRESSION_CCITTRLE = 2, ...)

JPG : enum CODEC_OPTION ( ENCODE_BASELINE = 0x01, ENCODE_PROGRESSIVE = 0x10, ...)에 정의되어 있는 값들 중 하나.

+ void SetEscape(long i)

: 느린 반복문 등이 수행되고 있을 때 i값을 -1로 주면 강제로 루틴을 빠져 나가게 한다.

+ void SetFlags(IN DWORD flags, IN bool bLockReservedFlags)

: 나중에 사용될 것을 생각해 만들어 둔 플래그.

flags

0x??00000 = 16비트 이미지, CMYK, 멀티 레이어를 위해 예약됨.

0x00??0000 = 블렌드 모드

0x0000???? = 레이어 id 또는 사용자 플래그

bLockReservedFlags : 예약된 플래그와 블렌드 모드를 보호한다.

+ void SetFrame(long nFrame)

: 다음에 읽어 들일 프레임의 번호를 지정한다. TIFF, GIF 이미지에서 사용한다.

+ void SetFrameDelay(DWORD d)SetFrame

: GIF 포맷에서 현재 프레임의 딜레이를 지정한다. 밀리세컨드 단위이다.

+ void SetGrayPalette()

: 팔레트를 그레이 스캐일로 지정한다.

+ void SetJpegQuality(BYTE q)

: JPEG 이미지의 화질을 지정한다. 범위는 0 ~ 100 이다.

+ void SetJpegScale(BYTE q)

: JPEG 이미지를 읽어 들일 때 확대/축소 비율을 지정한다. 가능한 숫자는 1, 2, 4, 8이다.

+ void SetOffset(long x,long y)

: 화면상에 이미지가 출력될 시작 위치.

+ void SetPalette(IN RGBQUAD *pPal, IN DWORD nColors = 256)

: 팔레트의 색상을 지정한다.

+ void SetPalette(IN rgb_color *rgb, IN DWORD nColors = 256)

: 팔레트의 색상을 지정한다.

+ void SetPalette(IN DWORD n, BYTE *r, BYTE *g, BYTE *b)

: 팔레트의 색상을 지정한다.

n : 색상의 수

r : red 값이 들어 있는 버퍼

g : green 값이 들어 있는 버퍼

b : blue 값이 들어 있는 버퍼

+ void SetPaletteColor(BYTE idx, COLORREF cr)

: 팔레트의 idx 번째 색상을 cr로 지정한다.

+ void SetPaletteColor(BYTE idx, RGBQUAD cr)

: 팔레트의 idx 번째 색상을 cr로 지정한다.

+ void SetPaletteColor(BYTE idx, BYTE r, BYTE g, BYTE b, BYTE alpha=0)

: 팔레트의 idx 번째 색상을 RGBQUAD(r, g, b, alpha)로 지정한다.

+ void SetPixelColor(IN long x, IN long y, IN RGBQUAD c, IN bool bSetAlpha = false)

: 색상 c를 픽셀 (x, y)의 색상으로 한다. bSetAlpha가 true라면 색상 c의 알파값을 24비트 픽셀 (x, y)의 알파값으로 한다.

+ void SetPixelColor(IN long x, IN long y, IN COLORREF cr)

: 색상 cr을 픽셀 (x, y)의 색상으로 한다.

+ void SetPixelIndex(IN long x, IN long y, IN BYTE i)

: i를 픽셀 (x, y)의 인덱스값으로 한다.

+ void SetProgress(long p)

: 프로그래스바의 상태를 강제로 변환시킨다.

+ void SetStdPalette()

: 팔레트를 표준 색상으로 채운다.

+ void SetTransColor(IN RGBQUAD rgb)

: 24비트 이미지에서 투명색을 지정한다. 투명효과를 사용하려면 반드시 SetTransIndex(0)를 먼저 호출하여야 한다. 투명효과를 없애려면 SetTransIndex(-1)을 호출하면 된다.

+ void SetTransIndex(IN long idx)

: 팔레트를 사용하는 BPP가 1, 4, 8인 이미지에서 투명색의 인덱스 번호를 지정한다. 투명효과를 없애려면 idx에 -1을 주면 된다.

+ void SetXDPI(IN long dpi)

: TIFF, JPEG, PNG, BMP 포맷을 위한 수평 해상도를 지정한다.

+ void SetYDPI(IN long dpi)

: TIFF, JPEG, PNG, BMP 포맷을 위한 수직 해상도를 지정한다.

+ bool ShiftRGB(IN long r, IN long g, IN long b)

: 이미지의 모든 픽셀에 지정한 픽셀값을 더한다. 값의 범위는 -255 ~ 255이다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

+ bool Skew(IN float xgain, IN float ygain, IN long xpivot=0, IN long ypivot=0, IN bool bEnableInterpolation = false)

: 이미지에 시어링을 적용한다. 선택영역이 있으면 해당 영역에만 처리가 적용된다.

xgain, ygain : 0 ~ 1. 왜곡 정도를 지정한다.

xpivot, ypivot : 왜곡의 중심을 지정한다.

bEnableInterpolation : bilinear 보간법의 적용 여부를 지정한다.

+ bool SplitCMYK(OUT CxImage *c, OUT CxImage *m, OUT CxImage *y, OUT CxImage *k)

: 이미지의 CMYK 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SplitHSL(OUT CxImage *h, OUT CxImage *s, OUT CxImage *l)

: 이미지의 HSL 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SplitRGB(OUT CxImage *r, OUT CxImage *g, OUT CxImage *b)

: 이미지의 RGB 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SplitXYZ(OUT CxImage *x, OUT CxImage *y, OUT CxImage *z)

: 이미지의 XYZ 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SplitYIQ(OUT CxImage *y, OUT CxImage *i, OUT CxImage *q)

: 이미지의 YIQ 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

+ bool SplitYUV(OUT CxImage *y, OUT CxImage *u, OUT CxImage *v)

: 이미지의 YUV 채널을 8비트 그레이 스캐일 이미지로 내보낸다.

# void Startup(IN DWORD imagetype = 0)

: 멤버 변수를 초기화 한다.

+ long Stretch(IN HDC hdc, IN const RECT &rect, IN DWORD dwRop = SRCCOPY)

: 이미지를 화면에 출력한다.

+ long Stretch(HDC hdc, long xoffset, long yoffset, long xsize, long ysize, DWORD dwRop = SRCCOPY)

: 이미지를 화면에 출력한다.

+ void SwapIndex(IN BYTE idx1, IN BYTE idx2)

: 이미지의 팔레트에서 idx1과 idx2 인덱스의 색상을 서로 교환하고 이미지에서도 모든 idx1과 idx2값을 서로 교환한다.

+ bool Threshold(IN BYTE level)

: 이미지를 흑백으로 변환한다. level 은 기준이 되는 명도값이다.

+ bool Thumbnail(IN long newx, IN long newy, IN RGBQUAD canvascolor, OUT CxImage* iDst = 0)

: 지정한 크기의 썸네일 이미지를 생성한다. canvascolor로 테두리의 색을 지정한다.

+ long Tile(IN HDC hdc, IN RECT *rc)

: 이미지를 바둑판식으로 출력한다. rc는 이미지를 출력할 영역.

+ bool Transfer(OUT CxImage &from)

: from이미지로부터 이미지를 가져온다. from이미지는 내용은 모두 지워진다.

+ bool UnsharpMask(IN float radius = 5.0, IN float amount = 0.5, IN int threshold = 0)

: 이미지를 선명하게 한다.

radius : 효과의 적용 범위.

amount : 선명함의 적용 정도.

+ RGBQUAD XYZtoRGB(IN RGBQUAD lXYZColor)

: XYZ컬러공간에서 RGB컬러공간으로 변환한다.

+ RGBQUAD YIQtoRGB(IN RGBQUAD lYIQColor)

: YIQ컬러공간에서 RGB컬러공간으로 변환한다.

+ RGBQUAD YUVtoRGB(IN RGBQUAD lYUVColor)

: YUV컬러공간에서 RGB컬러공간으로 변환한다.

댓글 없음:

댓글 쓰기

댓글 쓰기