cximage_cximage源代码 - CSDN
精华内容
参与话题
  • CxImage 6.00 完整版

    2020-07-30 23:31:44
    CxImage是一个优秀的图像操作类库,CodeProject网站打开比较费劲,可以在这里下载。
  • cximage函数总结

    千次阅读 2019-07-01 14:00:39
    1、加载图片Load():bool Load(const TCHAR* filename, uint32_t imagetype=0); 参数1:图片名字 参数2:图片格式(下面列举) 以下是所有类型枚举: --------------------------------------------------------------...

    1、加载图片Load():bool Load(const TCHAR* filename, uint32_t imagetype=0);

    参数1:图片名字
    参数2:图片格式(下面列举)
    
    以下是所有类型枚举:
    ----------------------------------------------------------------------------------
    enum ENUM_CXIMAGE_FORMATS{
    CXIMAGE_FORMAT_UNKNOWN = 0,
    #if CXIMAGE_SUPPORT_BMP
    CXIMAGE_FORMAT_BMP = 1,
    #endif
    #if CXIMAGE_SUPPORT_GIF
    CXIMAGE_FORMAT_GIF = 2,
    #endif
    #if CXIMAGE_SUPPORT_JPG
    CXIMAGE_FORMAT_JPG = 3,
    #endif
    #if CXIMAGE_SUPPORT_PNG
    CXIMAGE_FORMAT_PNG = 4,
    #endif
    #if CXIMAGE_SUPPORT_ICO
    CXIMAGE_FORMAT_ICO = 5,
    #endif
    #if CXIMAGE_SUPPORT_TIF
    CXIMAGE_FORMAT_TIF = 6,
    #endif
    #if CXIMAGE_SUPPORT_TGA
    CXIMAGE_FORMAT_TGA = 7,
    #endif
    #if CXIMAGE_SUPPORT_PCX
    CXIMAGE_FORMAT_PCX = 8,
    #endif
    #if CXIMAGE_SUPPORT_WBMP
    CXIMAGE_FORMAT_WBMP = 9,
    #endif
    #if CXIMAGE_SUPPORT_WMF
    CXIMAGE_FORMAT_WMF = 10,
    #endif
    #if CXIMAGE_SUPPORT_JP2
    CXIMAGE_FORMAT_JP2 = 11,
    #endif
    #if CXIMAGE_SUPPORT_JPC
    CXIMAGE_FORMAT_JPC = 12,
    #endif
    #if CXIMAGE_SUPPORT_PGX
    CXIMAGE_FORMAT_PGX = 13,
    #endif
    #if CXIMAGE_SUPPORT_PNM
    CXIMAGE_FORMAT_PNM = 14,
    #endif
    #if CXIMAGE_SUPPORT_RAS
    CXIMAGE_FORMAT_RAS = 15,
    #endif
    #if CXIMAGE_SUPPORT_JBG
    CXIMAGE_FORMAT_JBG = 16,
    #endif
    #if CXIMAGE_SUPPORT_MNG
    CXIMAGE_FORMAT_MNG = 17,
    #endif
    #if CXIMAGE_SUPPORT_SKA
    CXIMAGE_FORMAT_SKA = 18,
    #endif
    #if CXIMAGE_SUPPORT_RAW
    CXIMAGE_FORMAT_RAW = 19,
    #endif
    #if CXIMAGE_SUPPORT_PSD
    CXIMAGE_FORMAT_PSD = 20,
    #endif
    CMAX_IMAGE_FORMATS = CXIMAGE_SUPPORT_BMP + CXIMAGE_SUPPORT_GIF + CXIMAGE_SUPPORT_JPG +
    					 CXIMAGE_SUPPORT_PNG + CXIMAGE_SUPPORT_MNG + CXIMAGE_SUPPORT_ICO +
    					 CXIMAGE_SUPPORT_TIF + CXIMAGE_SUPPORT_TGA + CXIMAGE_SUPPORT_PCX +
    					 CXIMAGE_SUPPORT_WBMP+ CXIMAGE_SUPPORT_WMF +
    					 CXIMAGE_SUPPORT_JBG + CXIMAGE_SUPPORT_JP2 + CXIMAGE_SUPPORT_JPC +
    					 CXIMAGE_SUPPORT_PGX + CXIMAGE_SUPPORT_PNM + CXIMAGE_SUPPORT_RAS +
    					 CXIMAGE_SUPPORT_SKA + CXIMAGE_SUPPORT_RAW + CXIMAGE_SUPPORT_PSD + 1
    -------------------------------------------------------------------------------------------------------------
    

    2、保存图片:bool Save(const TCHAR* filename, uint32_t imagetype);

    参数以及格式与加载图片一模一样,可参考上面。

    3、得到图形大小:long GetSize();

    4、得到图形高度和宽度:

    DWORD CxImage::GetHeight();
    DWORD CxImage::GetWidth();
    

    5、得到文件类型:DWORD CxImage::GetType() const;

    6、得到最后一个错误:char* CxImage::GetLastError();

    7、在界面中绘制出来

    long CxImage::Draw(HDC hdc, const RECT& rect, RECT* pClipRect=NULL)
    
    参数:
    HDC 绘图设备,
    rect 绘图的区域,确定绘图的左上角和右下角坐标。
    pClipRect,裁剪区域,一般可以和绘图区域一样大小
    

    8、图片处理,提高图片质量

    bool Filter(int32_t* kernel, int32_t Ksize, int32_t Kfactor, int32_t Koffset);
    

    9、copy图片:

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

    10、自定义图片大小(缩放):

    Resample(int32_t newx, int32_t newy, int32_t mode = 1, CxImage* iDst = NULL);
    

    11、调整图片饱和度:

    bool Saturate(const int32_t saturation, const int32_t colorspace = 1);
    

    12、图像灰度化:

    bool GrayScale();
    

    13、图片上下翻转:

    bool Flip(bool bFlipSelection = false, bool bFlipAlpha = true);
    

    14、图片左右翻转:

    bool Mirror(bool bMirrorSelection = false, bool bMirrorAlpha = true);
    

    15、图片颜色取反(255-原值):

    bool Negative();
    

    16、图片二值化;

    	bool Threshold(uint8_t level);
    	bool Threshold(CxImage* pThresholdMask);
    

    17、converts the image to B&W using the desired method ;

    bool Dither(int32_t method = 0);
    

    18、自适应阈值:

    bool AdaptiveThreshold(int32_t method = 0, int32_t nBoxSize = 64, CxImage* pContrastMask = 0, int32_t nBias = 0, float fGlobalLocalBalance = 0.5f);
    

    19、膨胀:

    bool Dilate(int32_t Ksize=2);
    

    20、腐蚀:

    bool Erode(int32_t Ksize=2);
    

    21、IsValid检查图片是否正确初始化:

    bool IsValid() const;
    

    22、light图像亮度和对比度调整:

    bool Light(int32_t brightness, int32_t contrast = 0);
    

    23、设置像素颜色值

    void	SetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha = false);
    void	SetPixelColor(int32_t x,int32_t y,COLORREF cr);
    

    几个函数的实现:

    WORD CxImage::GetBpp() const return: 1, 4, 8, 24. 每像素所占得字节数
    {
    return head.biBitCount;
    }
    
    
    DWORD CxImage::GetEffWidth() const return DWORD aligned width of the image. 每行所站的字节数
    
    {
    return info.dwEffWidth;
    }
    
    
    DWORD CxImage::GetNumColors() const return 2, 16, 256; 0 for RGB images.  
    {
    return head.biClrUsed;
    }
    
    
    DWORD CxImage::GetWidth() const   获得图像的宽
    {
    return head.biWidth;
    }
    
    
    DWORD CxImage::GetHeight() const   获得图像的高
    {
    return head.biHeight;
    }
    
    
    void* CxImage::GetDIB() const return internal hDib object 指向DIB对象,即是指向图像
    {
    return pDib;
    }
    
    
    long CxImage::GetSize()return the size in bytes of the internal pDib object返回在内部pDib对象的字节大小   就是信息头,调色板,位图数据的大小。
    {
    return head.biSize + head.biSizeImage + GetPaletteSize();
    }
    
    bool CxImage ::Light (long brightness , long contrast )
    {
           if (! pDib) return false;
           float c=(100 + contrast)/100.0f;
           brightness+=128;
    
           BYTE cTable[256]; //<nipper>
           for ( int i=0; i<256; i++) {
                 cTable[ i] = ( BYTE) max(0, min(255,( int)(( i-128)* c + brightness + 0.5f)));
          }
          return Lut( cTable);
    }
    

    想了解更多自己看下面原文:

    /*
     * File:	ximage.h
     * Purpose:	General Purpose Image Class 
     */
    /*
      --------------------------------------------------------------------------------
    
    	COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
    
    	CxImage version 7.0.2 07/Feb/2011
    
    	CxImage : Copyright (C) 2001 - 2010, Davide Pizzolato
    
    	Original CImage and CImageIterator implementation are:
    	Copyright (C) 1995, Alejandro Aguilar Sierra (asierra(at)servidor(dot)unam(dot)mx)
    
    	Covered code is provided under this license on an "as is" basis, without warranty
    	of any kind, either expressed or implied, including, without limitation, warranties
    	that the covered code is free of defects, merchantable, fit for a particular purpose
    	or non-infringing. The entire risk as to the quality and performance of the covered
    	code is with you. Should any covered code prove defective in any respect, you (not
    	the initial developer or any other contributor) assume the cost of any necessary
    	servicing, repair or correction. This disclaimer of warranty constitutes an essential
    	part of this license. No use of any covered code is authorized hereunder except under
    	this disclaimer.
    
    	Permission is hereby granted to use, copy, modify, and distribute this
    	source code, or portions hereof, for any purpose, including commercial applications,
    	freely and without fee, subject to the following restrictions: 
    
    	1. The origin of this software must not be misrepresented; you must not
    	claim that you wrote the original software. If you use this software
    	in a product, an acknowledgment in the product documentation would be
    	appreciated but is not required.
    
    	2. Altered source versions must be plainly marked as such, and must not be
    	misrepresented as being the original software.
    
    	3. This notice may not be removed or altered from any source distribution.
    
      --------------------------------------------------------------------------------
    
    	Other information about CxImage, and the latest version, can be found at the
    	CxImage home page: http://www.xdp.it/cximage/
    
      --------------------------------------------------------------------------------
     */
    #if !defined(__CXIMAGE_H)
    #define __CXIMAGE_H
    
    #if _MSC_VER > 1000
    #pragma once
    #endif 
    
    #ifdef _LINUX
      #define _XOPEN_SOURCE
      #include <unistd.h>
      #include <arpa/inet.h>
    #endif
    
    /
    #include "xfile.h"
    #include "xiofile.h"
    #include "xmemfile.h"
    #include "ximadef.h"	//<vho> adjust some #define
    
    /* see "ximacfg.h" for CxImage configuration options */
    
    /
    // CxImage formats enumerator
    enum ENUM_CXIMAGE_FORMATS{
    CXIMAGE_FORMAT_UNKNOWN = 0,
    #if CXIMAGE_SUPPORT_BMP
    CXIMAGE_FORMAT_BMP = 1,
    #endif
    #if CXIMAGE_SUPPORT_GIF
    CXIMAGE_FORMAT_GIF = 2,
    #endif
    #if CXIMAGE_SUPPORT_JPG
    CXIMAGE_FORMAT_JPG = 3,
    #endif
    #if CXIMAGE_SUPPORT_PNG
    CXIMAGE_FORMAT_PNG = 4,
    #endif
    #if CXIMAGE_SUPPORT_ICO
    CXIMAGE_FORMAT_ICO = 5,
    #endif
    #if CXIMAGE_SUPPORT_TIF
    CXIMAGE_FORMAT_TIF = 6,
    #endif
    #if CXIMAGE_SUPPORT_TGA
    CXIMAGE_FORMAT_TGA = 7,
    #endif
    #if CXIMAGE_SUPPORT_PCX
    CXIMAGE_FORMAT_PCX = 8,
    #endif
    #if CXIMAGE_SUPPORT_WBMP
    CXIMAGE_FORMAT_WBMP = 9,
    #endif
    #if CXIMAGE_SUPPORT_WMF
    CXIMAGE_FORMAT_WMF = 10,
    #endif
    #if CXIMAGE_SUPPORT_JP2
    CXIMAGE_FORMAT_JP2 = 11,
    #endif
    #if CXIMAGE_SUPPORT_JPC
    CXIMAGE_FORMAT_JPC = 12,
    #endif
    #if CXIMAGE_SUPPORT_PGX
    CXIMAGE_FORMAT_PGX = 13,
    #endif
    #if CXIMAGE_SUPPORT_PNM
    CXIMAGE_FORMAT_PNM = 14,
    #endif
    #if CXIMAGE_SUPPORT_RAS
    CXIMAGE_FORMAT_RAS = 15,
    #endif
    #if CXIMAGE_SUPPORT_JBG
    CXIMAGE_FORMAT_JBG = 16,
    #endif
    #if CXIMAGE_SUPPORT_MNG
    CXIMAGE_FORMAT_MNG = 17,
    #endif
    #if CXIMAGE_SUPPORT_SKA
    CXIMAGE_FORMAT_SKA = 18,
    #endif
    #if CXIMAGE_SUPPORT_RAW
    CXIMAGE_FORMAT_RAW = 19,
    #endif
    #if CXIMAGE_SUPPORT_PSD
    CXIMAGE_FORMAT_PSD = 20,
    #endif
    CMAX_IMAGE_FORMATS = CXIMAGE_SUPPORT_BMP + CXIMAGE_SUPPORT_GIF + CXIMAGE_SUPPORT_JPG +
    					 CXIMAGE_SUPPORT_PNG + CXIMAGE_SUPPORT_MNG + CXIMAGE_SUPPORT_ICO +
    					 CXIMAGE_SUPPORT_TIF + CXIMAGE_SUPPORT_TGA + CXIMAGE_SUPPORT_PCX +
    					 CXIMAGE_SUPPORT_WBMP+ CXIMAGE_SUPPORT_WMF +
    					 CXIMAGE_SUPPORT_JBG + CXIMAGE_SUPPORT_JP2 + CXIMAGE_SUPPORT_JPC +
    					 CXIMAGE_SUPPORT_PGX + CXIMAGE_SUPPORT_PNM + CXIMAGE_SUPPORT_RAS +
    					 CXIMAGE_SUPPORT_SKA + CXIMAGE_SUPPORT_RAW + CXIMAGE_SUPPORT_PSD + 1
    };
    
    #if CXIMAGE_SUPPORT_EXIF
    
    #define MAX_COMMENT 255
    #define MAX_SECTIONS 20
    
    typedef struct tag_ExifInfo {
    	char  Version      [5];
        char  CameraMake   [32];
        char  CameraModel  [40];
        char  DateTime     [20];
        int32_t   Height, Width;
        int32_t   Orientation;
        int32_t   IsColor;
        int32_t   Process;
        int32_t   FlashUsed;
        float FocalLength;
        float ExposureTime;
        float ApertureFNumber;
        float Distance;
        float CCDWidth;
        float ExposureBias;
        int32_t   Whitebalance;
        int32_t   MeteringMode;
        int32_t   ExposureProgram;
        int32_t   ISOequivalent;
        int32_t   CompressionLevel;
    	float FocalplaneXRes;
    	float FocalplaneYRes;
    	float FocalplaneUnits;
    	float Xresolution;
    	float Yresolution;
    	float ResolutionUnit;
    	float Brightness;
        char  Comments[MAX_COMMENT+1];
    
        uint8_t * ThumbnailPointer;  /* Pointer at the thumbnail */
        unsigned ThumbnailSize;     /* Size of thumbnail. */
    
    	bool  IsExif;
    } EXIFINFO;
    
    #endif //CXIMAGE_SUPPORT_EXIF
    
    /
    // CxImage class
    /
    class DLL_EXP CxImage
    {
    //extensible information collector
    typedef struct tagCxImageInfo {
    	uint32_t	dwEffWidth;			///< uint32_t aligned scan line width
    	uint8_t*	pImage;				///< THE IMAGE BITS
    	CxImage* pGhost;			///< if this is a ghost, pGhost points to the body
    	CxImage* pParent;			///< if this is a layer, pParent points to the body
    	uint32_t	dwType;				///< original image format
    	char	szLastError[256];	///< debugging
    	int32_t	nProgress;			///< monitor
    	int32_t	nEscape;			///< escape
    	int32_t	nBkgndIndex;		///< used for GIF, PNG, MNG
    	RGBQUAD nBkgndColor;		///< used for RGB transparency
    	float	fQuality;			///< used for JPEG, JPEG2000 (0.0f ... 100.0f)
    	uint8_t	nJpegScale;			///< used for JPEG [ignacio]
    	int32_t	nFrame;				///< used for TIF, GIF, MNG : actual frame
    	int32_t	nNumFrames;			///< used for TIF, GIF, MNG : total number of frames
    	uint32_t	dwFrameDelay;		///< used for GIF, MNG
    	int32_t	xDPI;				///< horizontal resolution
    	int32_t	yDPI;				///< vertical resolution
    	RECT	rSelectionBox;		///< bounding rectangle
    	uint8_t	nAlphaMax;			///< max opacity (fade)
    	bool	bAlphaPaletteEnabled; ///< true if alpha values in the palette are enabled.
    	bool	bEnabled;			///< enables the painting functions
    	int32_t	xOffset;
    	int32_t	yOffset;
    	uint32_t	dwCodecOpt[CMAX_IMAGE_FORMATS];	///< for GIF, TIF : 0=def.1=unc,2=fax3,3=fax4,4=pack,5=jpg
    	RGBQUAD last_c;				///< for GetNearestIndex optimization
    	uint8_t	last_c_index;
    	bool	last_c_isvalid;
    	int32_t	nNumLayers;
    	uint32_t	dwFlags;			///< 0x??00000 = reserved, 0x00??0000 = blend mode, 0x0000???? = layer id - user flags
    	uint8_t	dispmeth;
    	bool	bGetAllFrames;
    	bool	bLittleEndianHost;
    
    #if CXIMAGE_SUPPORT_EXIF
    	EXIFINFO ExifInfo;
    #endif
    
    } CXIMAGEINFO;
    
    public:
    	//public structures
    struct rgb_color { uint8_t r,g,b; };
    
    #if CXIMAGE_SUPPORT_WINDOWS
    // <VATI> text placement data
    // members must be initialized with the InitTextInfo(&this) function.
    typedef struct tagCxTextInfo
    {
    #if defined (_WIN32_WCE)
    	TCHAR    text[256];  ///< text for windows CE
    #else
    	TCHAR    text[4096]; ///< text (char -> TCHAR for UNICODE [Cesar M])
    #endif
    	LOGFONT  lfont;      ///< font and codepage data
        COLORREF fcolor;     ///< foreground color
        int32_t     align;      ///< DT_CENTER, DT_RIGHT, DT_LEFT aligment for multiline text
        uint8_t     smooth;     ///< text smoothing option. Default is false.
        uint8_t     opaque;     ///< text has background or hasn't. Default is true.
    						 ///< data for background (ignored if .opaque==FALSE) 
        COLORREF bcolor;     ///< background color
        float    b_opacity;  ///< opacity value for background between 0.0-1.0 Default is 0. (opaque)
        uint8_t     b_outline;  ///< outline width for background (zero: no outline)
        uint8_t     b_round;    ///< rounding radius for background rectangle. % of the height, between 0-50. Default is 10.
                             ///< (backgr. always has a frame: width = 3 pixel + 10% of height by default.)
    } CXTEXTINFO;
    #endif
    
    public:
    /** \addtogroup Constructors */ //@{
    	CxImage(uint32_t imagetype = 0);
    	CxImage(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype = 0);
    	CxImage(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
    #if CXIMAGE_SUPPORT_DECODE
    	CxImage(const TCHAR * filename, uint32_t imagetype);	// For UNICODE support: char -> TCHAR
    	CxImage(FILE * stream, uint32_t imagetype);
    	CxImage(CxFile * stream, uint32_t imagetype);
    	CxImage(uint8_t * buffer, uint32_t size, uint32_t imagetype);
    #endif
    	virtual ~CxImage() { DestroyFrames(); Destroy(); };
    	CxImage& operator = (const CxImage&);
    //@}
    
    /** \addtogroup Initialization */ //@{
    	void*	Create(uint32_t dwWidth, uint32_t dwHeight, uint32_t wBpp, uint32_t imagetype = 0);
    	bool	Destroy();
    	bool	DestroyFrames();
    	void	Clear(uint8_t bval=0);
    	void	Copy(const CxImage &src, bool copypixels = true, bool copyselection = true, bool copyalpha = true);
    	bool	Transfer(CxImage &from, bool bTransferFrames = true);
    	bool	CreateFromArray(uint8_t* pArray,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage);
    	bool	CreateFromMatrix(uint8_t** ppMatrix,uint32_t dwWidth,uint32_t dwHeight,uint32_t dwBitsperpixel, uint32_t dwBytesperline, bool bFlipImage);
    	void	FreeMemory(void* memblock);
    
    	uint32_t Dump(uint8_t * dst);
    	uint32_t UnDump(const uint8_t * src);
    	uint32_t DumpSize();
    
    //@}
    
    /** \addtogroup Attributes */ //@{
    	int32_t	GetSize();
    	uint8_t*	GetBits(uint32_t row = 0);
    	uint8_t	GetColorType();
    	void*	GetDIB() const;
    	uint32_t	GetHeight() const;
    	uint32_t	GetWidth() const;
    	uint32_t	GetEffWidth() const;
    	uint32_t	GetNumColors() const;
    	uint16_t	GetBpp() const;
    	uint32_t	GetType() const;
    	const char*	GetLastError();
    	static const TCHAR* GetVersion();
    	static const float GetVersionNumber();
    
    	uint32_t	GetFrameDelay() const;
    	void	SetFrameDelay(uint32_t d);
    
    	void	GetOffset(int32_t *x,int32_t *y);
    	void	SetOffset(int32_t x,int32_t y);
    
    	uint8_t	GetJpegQuality() const;
    	void	SetJpegQuality(uint8_t q);
    	float	GetJpegQualityF() const;
    	void	SetJpegQualityF(float q);
    
    	uint8_t	GetJpegScale() const;
    	void	SetJpegScale(uint8_t q);
    
    #if CXIMAGE_SUPPORT_EXIF
    	EXIFINFO *GetExifInfo() {return &info.ExifInfo;};
    	bool  GetExifThumbnail(const TCHAR *filename, const TCHAR *outname, int32_t imageType);
      #if CXIMAGE_SUPPORT_TRANSFORMATION
    	bool  RotateExif(int32_t orientation = 0);
      #endif
    #endif
    
    	int32_t	GetXDPI() const;
    	int32_t	GetYDPI() const;
    	void	SetXDPI(int32_t dpi);
    	void	SetYDPI(int32_t dpi);
    
    	uint32_t	GetClrImportant() const;
    	void	SetClrImportant(uint32_t ncolors = 0);
    
    	int32_t	GetProgress() const;
    	int32_t	GetEscape() const;
    	void	SetProgress(int32_t p);
    	void	SetEscape(int32_t i);
    
    	int32_t	GetTransIndex() const;
    	RGBQUAD	GetTransColor();
    	void	SetTransIndex(int32_t idx);
    	void	SetTransColor(RGBQUAD rgb);
    	bool	IsTransparent() const;
    
    	uint32_t	GetCodecOption(uint32_t imagetype = 0);
    	bool	SetCodecOption(uint32_t opt, uint32_t imagetype = 0);
    
    	uint32_t	GetFlags() const;
    	void	SetFlags(uint32_t flags, bool bLockReservedFlags = true);
    
    	uint8_t	GetDisposalMethod() const;
    	void	SetDisposalMethod(uint8_t dm);
    
    	bool	SetType(uint32_t type);
    
    	static uint32_t GetNumTypes();
    	static uint32_t GetTypeIdFromName(const TCHAR* ext);
    	static uint32_t GetTypeIdFromIndex(const uint32_t index);
    	static uint32_t GetTypeIndexFromId(const uint32_t id);
    
    	bool	GetRetreiveAllFrames() const;
    	void	SetRetreiveAllFrames(bool flag);
    	CxImage * GetFrame(int32_t nFrame) const;
    
    	//void*	GetUserData() const {return info.pUserData;}
    	//void	SetUserData(void* pUserData) {info.pUserData = pUserData;}
    //@}
    
    /** \addtogroup Palette
     * These functions have no effects on RGB images and in this case the returned value is always 0.
     * @{ */
    	bool	IsGrayScale();
    	bool	IsIndexed() const;
    	bool	IsSamePalette(CxImage &img, bool bCheckAlpha = true);
    	uint32_t	GetPaletteSize();
    	RGBQUAD* GetPalette() const;
    	RGBQUAD GetPaletteColor(uint8_t idx);
    	bool	GetPaletteColor(uint8_t i, uint8_t* r, uint8_t* g, uint8_t* b);
    	uint8_t	GetNearestIndex(RGBQUAD c);
    	void	BlendPalette(COLORREF cr,int32_t perc);
    	void	SetGrayPalette();
    	void	SetPalette(uint32_t n, uint8_t *r, uint8_t *g, uint8_t *b);
    	void	SetPalette(RGBQUAD* pPal,uint32_t nColors=256);
    	void	SetPalette(rgb_color *rgb,uint32_t nColors=256);
    	void	SetPaletteColor(uint8_t idx, uint8_t r, uint8_t g, uint8_t b, uint8_t alpha=0);
    	void	SetPaletteColor(uint8_t idx, RGBQUAD c);
    	void	SetPaletteColor(uint8_t idx, COLORREF cr);
    	void	SwapIndex(uint8_t idx1, uint8_t idx2);
    	void	SwapRGB2BGR();
    	void	SetStdPalette();
    //@}
    
    /** \addtogroup Pixel */ //@{
    	bool	IsInside(int32_t x, int32_t y);
    	bool	IsTransparent(int32_t x,int32_t y);
    	bool	GetTransparentMask(CxImage* iDst = 0);
    	RGBQUAD GetPixelColor(int32_t x,int32_t y, bool bGetAlpha = true);
    	uint8_t	GetPixelIndex(int32_t x,int32_t y);
    	uint8_t	GetPixelGray(int32_t x, int32_t y);
    	void	SetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha = false);
    	void	SetPixelColor(int32_t x,int32_t y,COLORREF cr);
    	void	SetPixelIndex(int32_t x,int32_t y,uint8_t i);
    	void	DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, RGBQUAD color, bool bSetAlpha=false);
    	void	DrawLine(int32_t StartX, int32_t EndX, int32_t StartY, int32_t EndY, COLORREF cr);
    	void	BlendPixelColor(int32_t x,int32_t y,RGBQUAD c, float blend, bool bSetAlpha = false);
    	bool	SetRectColor(int32_t left, int32_t top, int32_t right, int32_t bottom, RGBQUAD color, bool bSetAlpha = false);
    	bool	SetRectColor(RECT& rect, RGBQUAD color, bool bSetAlpha = false);
    //@}
    
    protected:
    /** \addtogroup Protected */ //@{
    	uint8_t BlindGetPixelIndex(const int32_t x,const int32_t y);
    	RGBQUAD BlindGetPixelColor(const int32_t x,const int32_t y, bool bGetAlpha = true);
    	void *BlindGetPixelPointer(const int32_t x,const  int32_t y);
    	void BlindSetPixelColor(int32_t x,int32_t y,RGBQUAD c, bool bSetAlpha = false);
    	void BlindSetPixelIndex(int32_t x,int32_t y,uint8_t i);
    //@}
    
    public:
    
    #if CXIMAGE_SUPPORT_INTERPOLATION
    /** \addtogroup Interpolation */ //@{
    	//overflow methods:
    	enum OverflowMethod {
    		OM_COLOR=1,
    		OM_BACKGROUND=2,
    		OM_TRANSPARENT=3,
    		OM_WRAP=4,
    		OM_REPEAT=5,
    		OM_MIRROR=6
    	};
    	void OverflowCoordinates(float &x, float &y, OverflowMethod const ofMethod);
    	void OverflowCoordinates(int32_t  &x, int32_t &y, OverflowMethod const ofMethod);
    	RGBQUAD GetPixelColorWithOverflow(int32_t x, int32_t y, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
    	//interpolation methods:
    	enum InterpolationMethod {
    		IM_NEAREST_NEIGHBOUR=1,
    		IM_BILINEAR		=2,
    		IM_BSPLINE		=3,
    		IM_BICUBIC		=4,
    		IM_BICUBIC2		=5,
    		IM_LANCZOS		=6,
    		IM_BOX			=7,
    		IM_HERMITE		=8,
    		IM_HAMMING		=9,
    		IM_SINC			=10,
    		IM_BLACKMAN		=11,
    		IM_BESSEL		=12,
    		IM_GAUSSIAN		=13,
    		IM_QUADRATIC	=14,
    		IM_MITCHELL		=15,
    		IM_CATROM		=16,
    		IM_HANNING		=17,
    		IM_POWER		=18
    	};
    	RGBQUAD GetPixelColorInterpolated(float x,float y, InterpolationMethod const inMethod=IM_BILINEAR, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
    	RGBQUAD GetAreaColorInterpolated(float const xc, float const yc, float const w, float const h, InterpolationMethod const inMethod, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);
    //@}
    
    protected:
    /** \addtogroup Protected */ //@{
    	void  AddAveragingCont(RGBQUAD const &color, float const surf, float &rr, float &gg, float &bb, float &aa);
    //@}
    
    /** \addtogroup Kernels */ //@{
    public:
    	static float KernelBSpline(const float x);
    	static float KernelLinear(const float t);
    	static float KernelCubic(const float t);
    	static float KernelGeneralizedCubic(const float t, const float a=-1);
    	static float KernelLanczosSinc(const float t, const float r = 3);
    	static float KernelBox(const float x);
    	static float KernelHermite(const float x);
    	static float KernelHamming(const float x);
    	static float KernelSinc(const float x);
    	static float KernelBlackman(const float x);
    	static float KernelBessel_J1(const float x);
    	static float KernelBessel_P1(const float x);
    	static float KernelBessel_Q1(const float x);
    	static float KernelBessel_Order1(float x);
    	static float KernelBessel(const float x);
    	static float KernelGaussian(const float x);
    	static float KernelQuadratic(const float x);
    	static float KernelMitchell(const float x);
    	static float KernelCatrom(const float x);
    	static float KernelHanning(const float x);
    	static float KernelPower(const float x, const float a = 2);
    //@}
    #endif //CXIMAGE_SUPPORT_INTERPOLATION
    	
    /** \addtogroup Painting */ //@{
    #if CXIMAGE_SUPPORT_WINDOWS
    	int32_t	Blt(HDC pDC, int32_t x=0, int32_t y=0);
    	HBITMAP Draw2HBITMAP(HDC hdc, int32_t x, int32_t y, int32_t cx, int32_t cy, RECT* pClipRect, bool bSmooth);
    	HBITMAP MakeBitmap(HDC hdc = NULL, bool bTransparency = false);
    	HICON   MakeIcon(HDC hdc = NULL, bool bTransparency = false);
    	HANDLE	CopyToHandle();
    	bool	CreateFromHANDLE(HANDLE hMem);		//Windows objects (clipboard)
    	bool	CreateFromHBITMAP(HBITMAP hbmp, HPALETTE hpal=0, bool bTransparency = false);	//Windows resource
    	bool	CreateFromHICON(HICON hico, bool bTransparency = false);
    	int32_t	Draw(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1, RECT* pClipRect = 0, bool bSmooth = false, bool bFlipY = false);
    	int32_t	Draw(HDC hdc, const RECT& rect, RECT* pClipRect=NULL, bool bSmooth = false, bool bFlipY = false);
    	int32_t	Stretch(HDC hdc, int32_t xoffset, int32_t yoffset, int32_t xsize, int32_t ysize, uint32_t dwRop = SRCCOPY);
    	int32_t	Stretch(HDC hdc, const RECT& rect, uint32_t dwRop = SRCCOPY);
    	int32_t	Tile(HDC hdc, RECT *rc);
    	int32_t	Draw2(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1);
    	int32_t	Draw2(HDC hdc, const RECT& rect);
    	//int32_t	DrawString(HDC hdc, int32_t x, int32_t y, const char* text, RGBQUAD color, const char* font, int32_t lSize=0, int32_t lWeight=400, uint8_t bItalic=0, uint8_t bUnderline=0, bool bSetAlpha=false);
    	int32_t	DrawString(HDC hdc, int32_t x, int32_t y, const TCHAR* text, RGBQUAD color, const TCHAR* font, int32_t lSize=0, int32_t lWeight=400, uint8_t bItalic=0, uint8_t bUnderline=0, bool bSetAlpha=false);
    	// <VATI> extensions
    	int32_t    DrawStringEx(HDC hdc, int32_t x, int32_t y, CXTEXTINFO *pTextType, bool bSetAlpha=false );
    	void    InitTextInfo( CXTEXTINFO *txt );
    protected:
    	bool IsHBITMAPAlphaValid( HBITMAP hbmp );
    public:
    #endif //CXIMAGE_SUPPORT_WINDOWS
    //@}
    
    	// file operations
    #if CXIMAGE_SUPPORT_DECODE
    /** \addtogroup Decode */ //@{
    #ifdef WIN32
    	//bool Load(LPCWSTR filename, uint32_t imagetype=0);
    	bool LoadResource(HRSRC hRes, uint32_t imagetype, HMODULE hModule=NULL);
    #endif
    	// For UNICODE support: char -> TCHAR
    	bool Load(const TCHAR* filename, uint32_t imagetype=0);
    	//bool Load(const char * filename, uint32_t imagetype=0);
    	bool Decode(FILE * hFile, uint32_t imagetype);
    	bool Decode(CxFile * hFile, uint32_t imagetype);
    	bool Decode(uint8_t * buffer, uint32_t size, uint32_t imagetype);
    
    	bool CheckFormat(CxFile * hFile, uint32_t imagetype = 0);
    	bool CheckFormat(uint8_t * buffer, uint32_t size, uint32_t imagetype = 0);
    //@}
    #endif //CXIMAGE_SUPPORT_DECODE
    
    #if CXIMAGE_SUPPORT_ENCODE
    protected:
    /** \addtogroup Protected */ //@{
    	bool EncodeSafeCheck(CxFile *hFile);
    //@}
    
    public:
    /** \addtogroup Encode */ //@{
    #ifdef WIN32
    	//bool Save(LPCWSTR filename, uint32_t imagetype=0);
    #endif
    	// For UNICODE support: char -> TCHAR
    	bool Save(const TCHAR* filename, uint32_t imagetype);
    	//bool Save(const char * filename, uint32_t imagetype=0);
    	bool Encode(FILE * hFile, uint32_t imagetype);
    	bool Encode(CxFile * hFile, uint32_t imagetype);
    	bool Encode(CxFile * hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype);
    	bool Encode(FILE *hFile, CxImage ** pImages, int32_t pagecount, uint32_t imagetype);
    	bool Encode(uint8_t * &buffer, int32_t &size, uint32_t imagetype);
    
    	bool Encode2RGBA(CxFile *hFile, bool bFlipY = false);
    	bool Encode2RGBA(uint8_t * &buffer, int32_t &size, bool bFlipY = false);
    //@}
    #endif //CXIMAGE_SUPPORT_ENCODE
    
    /** \addtogroup Attributes */ //@{
    	//misc.
    	bool IsValid() const;
    	bool IsEnabled() const;
    	void Enable(bool enable=true);
    
    	// frame operations
    	int32_t GetNumFrames() const;
    	int32_t GetFrame() const;
    	void SetFrame(int32_t nFrame);
    //@}
    
    #if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
    /** \addtogroup BasicTransformations */ //@{
    	bool GrayScale();
    	bool Flip(bool bFlipSelection = false, bool bFlipAlpha = true);
    	bool Mirror(bool bMirrorSelection = false, bool bMirrorAlpha = true);
    	bool Negative();
    	bool RotateLeft(CxImage* iDst = NULL);
    	bool RotateRight(CxImage* iDst = NULL);
    	bool IncreaseBpp(uint32_t nbit);
    //@}
    #endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS
    
    #if CXIMAGE_SUPPORT_TRANSFORMATION
    /** \addtogroup Transformations */ //@{
    	// image operations
    	bool Rotate(float angle, CxImage* iDst = NULL);
    	bool Rotate2(float angle, CxImage *iDst = NULL, InterpolationMethod inMethod=IM_BILINEAR,
                    OverflowMethod ofMethod=OM_BACKGROUND, RGBQUAD *replColor=0,
                    bool const optimizeRightAngles=true, bool const bKeepOriginalSize=false);
    	bool Rotate180(CxImage* iDst = NULL);
    	bool Resample(int32_t newx, int32_t newy, int32_t mode = 1, CxImage* iDst = NULL);
    	bool Resample2(int32_t newx, int32_t newy, InterpolationMethod const inMethod=IM_BICUBIC2,
    				OverflowMethod const ofMethod=OM_REPEAT, CxImage* const iDst = NULL,
    				bool const disableAveraging=false);
    	bool DecreaseBpp(uint32_t nbit, bool errordiffusion, RGBQUAD* ppal = 0, uint32_t clrimportant = 0);
    	bool Dither(int32_t method = 0);
    	bool Crop(int32_t left, int32_t top, int32_t right, int32_t bottom, CxImage* iDst = NULL);
    	bool Crop(const RECT& rect, CxImage* iDst = NULL);
    	bool CropRotatedRectangle( int32_t topx, int32_t topy, int32_t width, int32_t height, float angle, CxImage* iDst = NULL);
    	bool Skew(float xgain, float ygain, int32_t xpivot=0, int32_t ypivot=0, bool bEnableInterpolation = false);
    	bool Expand(int32_t left, int32_t top, int32_t right, int32_t bottom, RGBQUAD canvascolor, CxImage* iDst = 0);
    	bool Expand(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst = 0);
    	bool Thumbnail(int32_t newx, int32_t newy, RGBQUAD canvascolor, CxImage* iDst = 0);
    	bool CircleTransform(int32_t type,int32_t rmax=0,float Koeff=1.0f);
    	bool QIShrink(int32_t newx, int32_t newy, CxImage* const iDst = NULL, bool bChangeBpp = false);
    
    //@}
    #endif //CXIMAGE_SUPPORT_TRANSFORMATION
    
    #if CXIMAGE_SUPPORT_DSP
    /** \addtogroup DSP */ //@{
    	bool Contour();
    	bool HistogramStretch(int32_t method = 0, double threshold = 0);
    	bool HistogramEqualize();
    	bool HistogramNormalize();
    	bool HistogramRoot();
    	bool HistogramLog();
    	int32_t Histogram(int32_t* red, int32_t* green = 0, int32_t* blue = 0, int32_t* gray = 0, int32_t colorspace = 0);
    	bool Jitter(int32_t radius=2);
    	bool Repair(float radius = 0.25f, int32_t niterations = 1, int32_t colorspace = 0);
    	bool Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, int32_t colorspace = 0);
    	bool FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag, int32_t direction = 1, bool bForceFFT = true, bool bMagnitude = true);
    	bool Noise(int32_t level);
    	bool Median(int32_t Ksize=3);
    	bool Gamma(float gamma);
    	bool GammaRGB(float gammaR, float gammaG, float gammaB);
    	bool ShiftRGB(int32_t r, int32_t g, int32_t b);
    	bool Threshold(uint8_t level);
    	bool Threshold(CxImage* pThresholdMask);
    	bool Threshold2(uint8_t level, bool bDirection, RGBQUAD nBkgndColor, bool bSetAlpha = false);
    	bool Colorize(uint8_t hue, uint8_t sat, float blend = 1.0f);
    	bool Light(int32_t brightness, int32_t contrast = 0);
    	float Mean();
    	bool Filter(int32_t* kernel, int32_t Ksize, int32_t Kfactor, int32_t Koffset);
    	bool Erode(int32_t Ksize=2);
    	bool Dilate(int32_t Ksize=2);
    	bool Edge(int32_t Ksize=2);
    	void HuePalette(float correction=1);
    	enum ImageOpType { OpAdd, OpAnd, OpXor, OpOr, OpMask, OpSrcCopy, OpDstCopy, OpSub, OpSrcBlend, OpScreen, OpAvg, OpBlendAlpha };
    	void Mix(CxImage & imgsrc2, ImageOpType op, int32_t lXOffset = 0, int32_t lYOffset = 0, bool bMixAlpha = false);
    	void MixFrom(CxImage & imagesrc2, int32_t lXOffset, int32_t lYOffset);
    	bool UnsharpMask(float radius = 5.0f, float amount = 0.5f, int32_t threshold = 0);
    	bool Lut(uint8_t* pLut);
    	bool Lut(uint8_t* pLutR, uint8_t* pLutG, uint8_t* pLutB, uint8_t* pLutA = 0);
    	bool GaussianBlur(float radius = 1.0f, CxImage* iDst = 0);
    	bool TextBlur(uint8_t threshold = 100, uint8_t decay = 2, uint8_t max_depth = 5, bool bBlurHorizontal = true, bool bBlurVertical = true, CxImage* iDst = 0);
    	bool SelectiveBlur(float radius = 1.0f, uint8_t threshold = 25, CxImage* iDst = 0);
    	bool Solarize(uint8_t level = 128, bool bLinkedChannels = true);
    	bool FloodFill(const int32_t xStart, const int32_t yStart, const RGBQUAD cFillColor, const uint8_t tolerance = 0,
    					uint8_t nOpacity = 255, const bool bSelectFilledArea = false, const uint8_t nSelectionLevel = 255);
    	bool Saturate(const int32_t saturation, const int32_t colorspace = 1);
    	bool ConvertColorSpace(const int32_t dstColorSpace, const int32_t srcColorSpace);
    	int32_t  OptimalThreshold(int32_t method = 0, RECT * pBox = 0, CxImage* pContrastMask = 0);
    	bool AdaptiveThreshold(int32_t method = 0, int32_t nBoxSize = 64, CxImage* pContrastMask = 0, int32_t nBias = 0, float fGlobalLocalBalance = 0.5f);
    	bool RedEyeRemove(float strength = 0.8f);
    	bool Trace(RGBQUAD color_target, RGBQUAD color_trace);
    
    //@}
    
    protected:
    /** \addtogroup Protected */ //@{
    	bool IsPowerof2(int32_t x);
    	bool FFT(int32_t dir,int32_t m,double *x,double *y);
    	bool DFT(int32_t dir,int32_t m,double *x1,double *y1,double *x2,double *y2);
    	bool RepairChannel(CxImage *ch, float radius);
    	// <nipper>
    	int32_t gen_convolve_matrix (float radius, float **cmatrix_p);
    	float* gen_lookup_table (float *cmatrix, int32_t cmatrix_length);
    	void blur_line (float *ctable, float *cmatrix, int32_t cmatrix_length, uint8_t* cur_col, uint8_t* dest_col, int32_t y, int32_t bytes);
    	void blur_text (uint8_t threshold, uint8_t decay, uint8_t max_depth, CxImage* iSrc, CxImage* iDst, uint8_t bytes);
    //@}
    
    public:
    /** \addtogroup ColorSpace */ //@{
    	bool SplitRGB(CxImage* r,CxImage* g,CxImage* b);
    	bool SplitYUV(CxImage* y,CxImage* u,CxImage* v);
    	bool SplitHSL(CxImage* h,CxImage* s,CxImage* l);
    	bool SplitYIQ(CxImage* y,CxImage* i,CxImage* q);
    	bool SplitXYZ(CxImage* x,CxImage* y,CxImage* z);
    	bool SplitCMYK(CxImage* c,CxImage* m,CxImage* y,CxImage* k);
    	static RGBQUAD HSLtoRGB(COLORREF cHSLColor);
    	static RGBQUAD RGBtoHSL(RGBQUAD lRGBColor);
    	static RGBQUAD HSLtoRGB(RGBQUAD lHSLColor);
    	static RGBQUAD YUVtoRGB(RGBQUAD lYUVColor);
    	static RGBQUAD RGBtoYUV(RGBQUAD lRGBColor);
    	static RGBQUAD YIQtoRGB(RGBQUAD lYIQColor);
    	static RGBQUAD RGBtoYIQ(RGBQUAD lRGBColor);
    	static RGBQUAD XYZtoRGB(RGBQUAD lXYZColor);
    	static RGBQUAD RGBtoXYZ(RGBQUAD lRGBColor);
    #endif //CXIMAGE_SUPPORT_DSP
    	static RGBQUAD RGBtoRGBQUAD(COLORREF cr);
    	static COLORREF RGBQUADtoRGB (RGBQUAD c);
    //@}
    
    /** \addtogroup Selection */ //@{
    	bool SelectionIsValid();
    #if CXIMAGE_SUPPORT_SELECTION
    	bool SelectionClear(uint8_t level = 0);
    	bool SelectionCreate();
    	bool SelectionDelete();
    	bool SelectionInvert();
    	bool SelectionMirror();
    	bool SelectionFlip();
    	bool SelectionAddRect(RECT r, uint8_t level = 255);
    	bool SelectionAddEllipse(RECT r, uint8_t level = 255);
    	bool SelectionAddPolygon(POINT *points, int32_t npoints, uint8_t level = 255);
    	bool SelectionAddColor(RGBQUAD c, uint8_t level = 255);
    	bool SelectionAddPixel(int32_t x, int32_t y, uint8_t level = 255);
    	bool SelectionCopy(CxImage &from);
    	bool SelectionIsInside(int32_t x, int32_t y);
    	void SelectionGetBox(RECT& r);
    	bool SelectionToHRGN(HRGN& region);
    	bool SelectionSplit(CxImage *dest);
    	uint8_t SelectionGet(const int32_t x,const int32_t y);
    	bool SelectionSet(CxImage &from);
    	void SelectionRebuildBox();
    	uint8_t* SelectionGetPointer(const int32_t x = 0,const int32_t y = 0);
    //@}
    
    protected:
    /** \addtogroup Protected */ //@{
    	bool BlindSelectionIsInside(int32_t x, int32_t y);
    	uint8_t BlindSelectionGet(const int32_t x,const int32_t y);
    	void SelectionSet(const int32_t x,const int32_t y,const uint8_t level);
    
    public:
    
    #endif //CXIMAGE_SUPPORT_SELECTION
    //@}
    
    #if CXIMAGE_SUPPORT_ALPHA
    /** \addtogroup Alpha */ //@{
    	void AlphaClear();
    	bool AlphaCreate();
    	void AlphaDelete();
    	void AlphaInvert();
    	bool AlphaMirror();
    	bool AlphaFlip();
    	bool AlphaCopy(CxImage &from);
    	bool AlphaSplit(CxImage *dest);
    	void AlphaStrip();
    	void AlphaSet(uint8_t level);
    	bool AlphaSet(CxImage &from);
    	void AlphaSet(const int32_t x,const int32_t y,const uint8_t level);
    	uint8_t AlphaGet(const int32_t x,const int32_t y);
    	uint8_t AlphaGetMax() const;
    	void AlphaSetMax(uint8_t nAlphaMax);
    	bool AlphaIsValid();
    	uint8_t* AlphaGetPointer(const int32_t x = 0,const int32_t y = 0);
    	bool AlphaFromTransparency();
    
    	void AlphaPaletteClear();
    	void AlphaPaletteEnable(bool enable=true);
    	bool AlphaPaletteIsEnabled();
    	bool AlphaPaletteIsValid();
    	bool AlphaPaletteSplit(CxImage *dest);
    //@}
    
    protected:
    /** \addtogroup Protected */ //@{
    	uint8_t BlindAlphaGet(const int32_t x,const int32_t y);
    //@}
    #endif //CXIMAGE_SUPPORT_ALPHA
    
    public:
    #if CXIMAGE_SUPPORT_LAYERS
    /** \addtogroup Layers */ //@{
    	bool LayerCreate(int32_t position = -1);
    	bool LayerDelete(int32_t position = -1);
    	void LayerDeleteAll();
    	CxImage* GetLayer(int32_t position);
    	CxImage* GetParent() const;
    	int32_t GetNumLayers() const;
    	int32_t LayerDrawAll(HDC hdc, int32_t x=0, int32_t y=0, int32_t cx = -1, int32_t cy = -1, RECT* pClipRect = 0, bool bSmooth = false);
    	int32_t LayerDrawAll(HDC hdc, const RECT& rect, RECT* pClipRect=NULL, bool bSmooth = false);
    //@}
    #endif //CXIMAGE_SUPPORT_LAYERS
    
    protected:
    /** \addtogroup Protected */ //@{
    	void Startup(uint32_t imagetype = 0);
    	void CopyInfo(const CxImage &src);
    	void Ghost(const CxImage *src);
    	void RGBtoBGR(uint8_t *buffer, int32_t length);
    	static float HueToRGB(float n1,float n2, float hue);
    	void Bitfield2RGB(uint8_t *src, uint32_t redmask, uint32_t greenmask, uint32_t bluemask, uint8_t bpp);
    	static int32_t CompareColors(const void *elem1, const void *elem2);
    	int16_t m_ntohs(const int16_t word);
    	int32_t m_ntohl(const int32_t dword);
    	void bihtoh(BITMAPINFOHEADER* bih);
    
    	void*				pDib; //contains the header, the palette, the pixels
        BITMAPINFOHEADER    head; //standard header
    	CXIMAGEINFO			info; //extended information
    	uint8_t*			pSelection;	//selected region
    	uint8_t*			pAlpha; //alpha channel
    	CxImage**			ppLayers; //generic layers
    	CxImage**			ppFrames;
    //@}
    };
    
    
    #endif // !defined(__CXIMAGE_H)
    
    
    展开全文
  • 包括了个人Cximage最新源代码和demo程序,以及个人收集的一些cximage使用入门和注意事项的说明文档。 CxImage类库是一 个优秀的图像操作类库。它可以快捷地存取、显示、转换各种图像。虽然有那么多优秀的图形库,如...
  • CxImage开源库介绍

    2015-04-01 10:38:39
    CxImage是一个可以用于MFC 的C++图像处理类库类,它可以打开,保存,显示,转换各种常见格式的图像文件,比如BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式的文件。可以实现BMP<->JPG...

    CxImage是一个可以用于MFC 的C++图像处理类库类,它可以打开,保存,显示,转换各种常见格式的图像文件,比如BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式的文件。可以实现BMP<->JPG,PNG <>TIFF格式等等的互相转换。

    CxImage不仅可以实现图像文件的类型转换,还可以实现在内存图像数据的类型转换,并且使用很方便。除了文件格式的相互转换,它还提供了很多很多图像后处理的功能,比如图像模糊,锐化等等,功能非常强大和实用。

    示例: 如何转换一种格式到另外一种格式

    [cpp] view plaincopy
    CxImage image;
    // bmp -> jpg
    image.Load( ” image.bmp ” , CXIMAGE_FORMAT_BMP);
    if (image.IsValid()){
    if ( ! image.IsGrayScale()) image.IncreaseBpp( 24 );
    image.SetJpegQuality( 80 );
    image.Save( ” image.jpg ” ,CXIMAGE_FORMAT_JPG);
    }
    // png -> tif
    image.Load( ” image.png ” , CXIMAGE_FORMAT_PNG);
    if (image.IsValid()){
    image.Save( ” image.tif ” ,CXIMAGE_FORMAT_TIF);
    }

    如何从资源中加载图像

    [cpp] view plaincopy
    // Load the resource IDR_PNG1 from the PNG resource type
    CxImage * newImage = new CxImage();
    newImage -> LoadResource(FindResource(NULL,MAKEINTRESOURCE(IDR_PNG1),
    ” PNG ” ),CXIMAGE_FORMAT_PNG);
    或者
    // Load the resource IDR_JPG1 from DLL
    CxImage * newImage = new CxImage();
    HINSTANCE hdll = LoadLibrary( ” imagelib.dll ” );
    if (hdll){
    HRSRC hres = FindResource(hdll,MAKEINTRESOURCE(IDR_JPG1), ” JPG ” );
    newImage -> LoadResource(hres,CXIMAGE_FORMAT_JPG,hdll);
    FreeLibrary(hdll);
    }
    或者
    // Load a bitmap resource;
    HBITMAP bitmap = ::LoadBitmap(AfxGetInstanceHandle(),
    MAKEINTRESOURCE(IDB_BITMAP1)));
    CxImage * newImage = new CxImage();
    newImage -> CreateFromHBITMAP(bitmap);

    如何解码内存中的图像

    [cpp] view plaincopy
    CxImage image((BYTE * )buffer,size,image_type);
    或者
    CxMemFile memfile((BYTE * )buffer,size);
    CxImage image( & memfile,image_type);
    或者
    CxMemFile memfile((BYTE * )buffer,size);
    CxImage * image = new CxImage();
    image -> Decode( & memfile,type);

    如何对内存中的图像编码

    [cpp] view plaincopy
    long size = 0 ;
    BYTE * buffer = 0 ;
    image.Encode(buffer,size,image_type);

    image.FreeMemory(buffer);
    或者
    CxMemFile memfile;
    memfile.Open();
    image.Encode( & memfile,image_type);
    BYTE * buffer = memfile.GetBuffer();
    long size = memfile.Size();

    image.FreeMemory(buffer);

    如何创建一副多页的TIFF

    [cpp] view plaincopy
    CxImage * pimage[ 3 ];
    pimage[ 0 ] =& image1;
    pimage[ 1 ] =& image2;
    pimage[ 2 ] =& image3;
    FILE * hFile;
    hFile = fopen( ” multipage.tif ” , ” w+b ” );
    CxImageTIF multiimage;
    multiimage.Encode(hFile,pimage, 3 );
    fclose(hFile);
    或者
    FILE * hFile;
    hFile = fopen( ” c://multi.tif ” , ” w+b ” );
    CxImageTIF image;
    image.Load( ” c://1.tif ” ,CXIMAGE_FORMAT_TIF);
    image.Encode(hFile, true );
    image.Load( ” c://2.bmp ” ,CXIMAGE_FORMAT_BMP);
    image.Encode(hFile, true );
    image.Load( ” c://3.png ” ,CXIMAGE_FORMAT_PNG);
    image.Encode(hFile);
    fclose(hFile);

    如何复制和粘贴图像

    [cpp] view plaincopy
    // 复制(copy)
    HANDLE hDIB = image -> CopyToHandle();
    if (::OpenClipboard(AfxGetApp() -> m_pMainWnd -> GetSafeHwnd())) {
    if (::EmptyClipboard()) {
    if (::SetClipboardData(CF_DIB,hDIB) == NULL ) {
    AfxMessageBox( ” Unable to set Clipboard data ” );
    } } }
    CloseClipboard();
    // 粘贴(paste)
    HANDLE hBitmap = NULL;
    CxImage * newima = new CxImage();
    if (OpenClipboard()) hBitmap = GetClipboardData(CF_DIB);
    if (hBitmap) newima -> CreateFromHANDLE(hBitmap);
    CloseClipboard();

    如何在图片框控件(Picture Box)中显示图像

    [cpp] view plaincopy
    HBITMAP m_bitmap = NULL;
    CxImage image( ” myfile.png ” , CXIMAGE_FORMAT_PNG);

    CDC * hdc = m_picture.GetDC();
    HBITMAP m_bitmap = image.MakeBitmap(hdc -> m_hDC);
    HBITMAP hOldBmp = m_picture.SetBitmap(m_bitmap);
    if (hOldBmp) DeleteObject(hOldBmp);
    if (hdc -> m_hDC) m_picture.ReleaseDC(hdc);

    if (m_bitmap) DeleteObject(m_bitmap);

    Cimage合并图片就是这么简单:

    [cpp] view plaincopy
    CxImage t_img1,t_img2,t_img3;

      int t_h1,t_w1,t_h2,t_w2,t_h3,t_w3,t_bpp;   
    
      t_img1.Load("F://1.jpg");   
    
      t_img2.Load("F://2.jpg");   
    
      t_h1=t_img1.GetHeight();   
    
      t_w1=t_img1.GetWidth();   
    
      t_h2=t_img2.GetHeight();   
    
      t_w2=t_img2.GetWidth();   
    
      t_h3=t_h1;   
    
      t_w3=t_w1+t_w2;   
    
      t_bpp=t_img1.GetBpp();   
    
      t_img3.Create(t_w3,t_h3,t_bpp);   
    
      t_img3.MixFrom(t_img1,0,0);   
    
      t_img3.MixFrom(t_img2,t_w1,0);   
    
      t_img3.Save("f://3.jpg",CXIMAGE_FORMAT_JPG);   
    

    译后序:

    关于图像处理库,我相信大家有一个共同的疑问:这么多图像处理库,我该如何选择?在CSDN的blog中有这样一段文字,比较透彻地回答了这个问题,感谢作者的透彻解释:

    “CxImage类库是一个优秀的图像操作类库。它可以快捷地存取、显示、转换各种图像。有的读者可能说,有那么多优秀的图形库,如OpenIL,FreeImage, PaintLib等等,它们可谓是功能强大,齐全,没必要用其它的类库。但我要说,这些类库基本上没有免费的,使用这些类库,你要被这样那样的许可协议所束缚。

    在这点上,CxImage类库是完全免费的。另外,在使用上述类库时,你会遇到重重麻烦。因为它们大部分是平台无关的,且用C语言写成,有的还夹杂着基本的C++ wrapper和成堆德编译选项的声明需要你去处理。而CxImage类库在这方面做得很好。还有让我最看好的,就是作者完全公开了源代码。相对于那些封装好的图形库和GDI+来说,这一点使我们可以进一步学习各种编解码技术,而不再浮于各种技术的表面。”

    展开全文
  • CxImage的使用

    万次阅读 2011-07-04 18:57:15
    原文地址:http://www.codeproject.com/KB/graphics/cximage.aspx1.简介及许可CxImage 是一个免费的C++类,可以简单而快速的加载、保存、显示,转换BMP, JPEG, GIF, PNG, TIFF, MN
     

    原文地址:http://www.codeproject.com/KB/graphics/cximage.aspx

     

    1.简介及许可

    CxImage 是一个免费的C++类,可以简单而快速的加载、保存、显示,转换BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式图像。CxImage是开源的,和zlib的许可协议一致,你可以在任何想使用的地方使用它。

    2.移植性

    该类和项目在多个编译器下进行过测试,从vc6.0至vs2008,borland c++3至6,部分的wxDev c++ 和MinGw。

    所有库都提供了UNICODE和非UNICODE配置。

    3.CxImage结构

     

    一个CxImage对象基本是一个bitmap,另外增加一些成员变量保存有用的信息。

     

    class CxImage

      {

      ...

      protected:

      void* pDib;            //contains the header, the palette, the pixels

      BITMAPINFOHEADER head; //standard header

      CXIMAGEINFO info;       //extended information

      BYTE* pSelection;        //selected region

      BYTE* pAlpha;           //alpha channel

      CxImage** pLayers;    //generic layers

      }

    CxImage::head 是一个位图头,CxImage::pDib 是通常的位图。CxImage::info 是一个存储在不同格式之间的许多共享信息,在所有成员函数中使用。

    typedef struct tagCxImageInfo {

        DWORD   dwEffWidth;       //DWORD aligned scan line width

        BYTE*   pImage;           //THE IMAGE BITS

        void*   pGhost;           //if this is a ghost, pGhost point to the body

        DWORD   dwType;           //original image format

        char    szLastError[256]; //debugging

        long    nProgress;        //monitor

        long    nEscape;          //escape

        long    nBkgndIndex;      //used for GIF, PNG, MNG

        RGBQUAD nBkgndColor;      //used for RGB transparency

        BYTE    nQuality;         //used for JPEG

        long    nFrame;           //used for TIF, GIF, MNG : actual frame

        long    nNumFrames;       //used for TIF, GIF, MNG : total number of

                                  //frames

        DWORD   dwFrameDelay;     //used for GIF, MNG

        long    xDPI;             //horizontal resolution

        long    yDPI;             //vertical resolution

        RECT    rSelectionBox;    //bounding rectangle

        BYTE    nAlphaMax;        //max opacity (fade)

        bool    bAlphaPaletteEnabled;  //true if alpha values in the palette are

                                  // enabled.

        bool    bEnabled;         //enables the painting functions

        long    xOffset;

        long    yOffset;

        DWORD   dwEncodeOption;   //for GIF, TIF : 0=def.1=unc,2=fax3,3=fax4,

                                  // 4=pack,5=jpg

        RGBQUAD last_c;           //for GetNearestIndex optimization

        BYTE    last_c_index;

        bool    last_c_isvalid;

        long    nNumLayers;

        DWORD   dwFlags;

    } CXIMAGEINFO;

     

    CxImage对象还是多层的集合。每层的缓冲只在必要的时候才被分配。

    CxImage::pDib是背景图,CxImage::pAlpha 是透明层,CxImage::pSelection 是选择层,用于创建图像处理的感兴趣的区域。在这三层外,你还可以定义,然后存储在CxImage::pLayers中。CxImage::ppFrames为动态图像(gif)保留.

    4.支持的格式和选项:

    整个库是非常大的,在主要的头文件ximcfg.h中你将找到一些开放或禁止一些特定的图形格式或特征的开关,每个JPG、PNG、TIFF库将使最终的应用程序增加大约100K的容量,cximage会影响50K的容量大小,所以你应当只支持和链接你的应用程序真正需要的格式。

     

    5.如何使用cximage

    工作区CxImagelib.dsw展示了建立一个应用程序所需要的库,在连接最终的应用程序之前你必须编译所有的库。在这个工作区中你将发现建立不同的库和应用程序的工程。

             CxImage: cximage.lib                 -static library

    CxImageCrtDll: cximagecrt.dll    -DLL not using mfc

    CxImageMfcDll: cximage.dll       -DLL using mfc

    Demo: demo.exe                        -program linked with cximage.lib and C Libraries

    DemoDll: demodll.exe                    -program linked with cximagecrt.dll

    j2k,jasper,jbig,jpeg,png,tiff,zlib:    -static C Libraries

     

    在你的项目中使用CxImage,必须作如下设置

    在你的程序中添加#include ”ximage.h”

    使用CxImage写一个图像处理的新函数也很容易,下面描述怎样添加CxImage::Jitter

    函数:首先声明该函数bool Jitter(long radius=2),在文件ximage.h的CXIMAGE_SUPPORT_DSP的部分公有函数的任何区域,然后如下代码进行定义

     

    bool CxImage::Jitter(long radius)

    {

        // check if the image is valid, this should be always the first line in

        // the function

        if (!pDib) return false;

       

        // local variables

        long nx,ny;

       

        // temporary image to store the partial results of the algorithm

        CxImage tmp(*this,pSelection!=0,true,true);

       

        // limit the effects of the functions only in the smallest rectangle that

        // holds the selected region (defined with the Selection...() functions ),

        // this will speed up the loops.

        long xmin,xmax,ymin,ymax;

        if (pSelection){

            xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;

            ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;

        } else {

            xmin = ymin = 0;

            xmax = head.biWidth; ymax=head.biHeight;

        }

       

        // main loop : scan the image in vertical direction

        for(long y=ymin; y <ymax; y++){

       

            // monitor the progress of the loops

            info.nProgress = (long)(100*y/head.biHeight);

       

            // let the application a way to exit quickly

            if (info.nEscape) break;

       

            // main loop : scan the image in horizontal direction

            for(long x=xmin; x<xmax; x++){

       

            // if the feature is enabled, process only the pixels inside the

            // selected region

    #if CXIMAGE_SUPPORT_SELECTION

                if (SelectionIsInside(x,y))

    #endif //CXIMAGE_SUPPORT_SELECTION

                {

                    // main algorithm

                    nx=x+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));

                    ny=y+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));

                    if (!IsInside(nx,ny)) {

                        nx=x;

                        ny=y;

                    }

     

                    // save the result in the temporary image.

                    // if you can, use PixelColor only for 24 bpp images,

                    // and PixelIndex for 8, 4 and 1 bpp images : it's faster

                    if (head.biClrUsed==0){

                        tmp.SetPixelColor(x,y,GetPixelColor(nx,ny));

                    } else {

                        tmp.SetPixelIndex(x,y,GetPixelIndex(nx,ny));

                    }

     

                    // if the feature is enabled, process also the pixels

                    // in the alpha layer

    #if CXIMAGE_SUPPORT_ALPHA

                    tmp.AlphaSet(x,y,AlphaGet(nx,ny));

    #endif //CXIMAGE_SUPPORT_ALPHA

     

                }

            }

        }

     

        // save the result and exit

        Transfer(tmp);

        return true;

    }

    应用实例

    格式转换

    Code:

    CxImage  image;

    // bmp -> jpg

    image.Load("image.bmp", CXIMAGE_FORMAT_BMP);

    if (image.IsValid()){

        if(!image.IsGrayScale()) image.IncreaseBpp(24);

        image.SetJpegQuality(99);

        image.Save("image.jpg",CXIMAGE_FORMAT_JPG);

    }

    // png -> tif

    image.Load("image.png", CXIMAGE_FORMAT_PNG);

    if (image.IsValid()){

        image.Save("image.tif",CXIMAGE_FORMAT_TIF);

    }

    加载图像资源

     

    Code:

    //Load the resource IDR_PNG1 from the PNG resource type

    CxImage* newImage = new CxImage();

    newImage->LoadResource(FindResource(NULL,MAKEINTRESOURCE(IDR_PNG1),

                           "PNG"),CXIMAGE_FORMAT_PNG);

    or

    Code:

    //Load the resource IDR_JPG1 from DLL

    CxImage* newImage = new CxImage();

    HINSTANCE hdll=LoadLibrary("imagelib.dll");

    if (hdll){

        HRSRC hres=FindResource(hdll,MAKEINTRESOURCE(IDR_JPG1),"JPG");

        newImage->LoadResource(hres,CXIMAGE_FORMAT_JPG,hdll);

        FreeLibrary(hdll);

    }

     

    or

     

    Code:

    //Load a bitmap resource;

    HBITMAP bitmap = ::LoadBitmap(AfxGetInstanceHandle(),

                                  MAKEINTRESOURCE(IDB_BITMAP1)));

    CxImage *newImage = new CxImage();

    newImage->CreateFromHBITMAP(bitmap);

     

     

    解码内存中的图像

    Code:

    CxImage image((BYTE*)buffer,size,image_type);

    or

    Code:

    CxMemFile memfile((BYTE*)buffer,size);

    CxImage image(&memfile,image_type);

     

    or

     

    Code:

    CxMemFile memfile((BYTE*)buffer,size);

    CxImage* image = new CxImage();

    image->Decode(&memfile,type);

     

    编码内存中的图像

    Code:

    long size=0;

    BYTE* buffer=0;

    image.Encode(buffer,size,image_type);

    ...

    free(buffer);

     

    or

     

    Code:

    CxMemFile memfile;

    memfile.Open();

    image.Encode(&memfile,image_type);

    BYTE* buffer = memfile.GetBuffer();

    long size = memfile.Size();

    ...

    free(buffer);

     

    创建一个多页的TIFF

     

    Code:

    CxImage *pimage[3];

    pimage[0]=&image1;

    pimage[1]=&image2;

    pimage[2]=&image3;

     

    FILE* hFile;

    hFile = fopen("multipage.tif","w+b");

     

    CxImageTIF multiimage;

    multiimage.Encode(hFile,pimage,3);

     

    fclose(hFile);

    or

     

    Code:

    FILE* hFile;

    hFile = fopen("c:\\multi.tif","w+b");

     

    CxImageTIF image;

    image.Load("c:\\1.tif",CXIMAGE_FORMAT_TIF);

    image.Encode(hFile,true);

    image.Load("c:\\2.bmp",CXIMAGE_FORMAT_BMP);

    image.Encode(hFile,true);

    image.Load("c:\\3.png",CXIMAGE_FORMAT_PNG);

    image.Encode(hFile);

     

    fclose(hFile);

     

    拷贝粘贴图像

    Code:

    //copy

    HANDLE hDIB = image->CopyToHandle();

    if (::OpenClipboard(AfxGetApp()->m_pMainWnd->GetSafeHwnd())) {

        if(::EmptyClipboard()) {

            if (::SetClipboardData(CF_DIB,hDIB) == NULL ) {

                AfxMessageBox( "Unable to set Clipboard data" );

    }    }    }

    CloseClipboard();

     

    //paste

    HANDLE hBitmap=NULL;

    CxImage *newima = new CxImage();

    if (OpenClipboard()) hBitmap=GetClipboardData(CF_DIB);

    if (hBitmap) newima->CreateFromHANDLE(hBitmap);

    CloseClipboard();

     

    在picture框中显示图像文件

     

    Code:

    HBITMAP m_bitmap = NULL;

    CxImage image("myfile.png", CXIMAGE_FORMAT_PNG);

    ...

    m_bitmap = image.MakeBitmap(m_picture.GetDC()->m_hDC);

    m_picture.SetBitmap(m_bitmap);

    ...

    if (m_bitmap) DeleteObject(m_bitmap);

     

     

    展开全文
  • CxImage图像库的使用

    千次阅读 2012-02-14 10:58:45
    CxImage图像库 CxImage下载地址:http://www.codeproject.com/KB/graphics/cximage/cximage600_full.zip 作者:Davide Pizzolato   CxImage简介  CxImage是一个可以简便而快速地打开、保存、显示和转换...

    CxImage图像库

    CxImage下载地址:http://www.codeproject.com/KB/graphics/cximage/cximage600_full.zip

    作者:Davide Pizzolato

     

    CxImage简介

          CxImage是一个可以简便而快速地打开、保存、显示和转换图像文件的 C++类库,它可以用于MFC,可以打开,保存,显示,转换各种常见格式的图像文件,比如BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式的文件。可以实现BMP<->JPG,PNG <->TIFF格式等等的互相转换。CxImage不仅可以实现图像文件的类型转换,还可以实现在内存图像数据的类型转换,并且使用很方便。除了文件格式的相互转换,它还提供了很多很多图像后处理的功能,比如图像模糊,锐化等等,功能非常强大和实用。另外,CxImage是开源的,并在zlib许可下发布,“如果你在你的产品中使用了这些源代码,虽然致谢不是必须的,但是却会得到众人的欣赏。”简单地说,你可以随意地使用这些代码,只要你不说它是你自己的就行了。

          CxImage中的x,大约代表了丰富的图像格式支持和丰富的图像处理功能,可以说CxImage是图像处理的十全大补汤。

     


    用CxImage实现的图像处理程序

          开发环境:VC6, C++, Windows, MFC, Visual Studio, VS6, Dev

          文件格式和链接的库:CxImage支持如下这些库的最新版本:
       Zlib (1.2.3), Jasper ( 1.900.1), LibMNG (1.0.10), LibPNG (1.2.24). LibTIFF 3.8.2
    j2k库(现在被称为openjpeg)和相关的类CxImageJ2K已经从项目中删除。JPEG2000格式的文件由Jasper和CximageJAS来支持。

     

          Cximage 6.00提供了一个新的类CximageRAW和新的库LibDCR,用于读取来自数码相机的RAW图像。常见的文件扩展名有:RAW, CRW, NEF, CR2, DNG, ORF, ARW, ERF, 3FR, DCR, X3F, MEF, RAF, MRW, PEF, SR2。

          CximageRAW提供了对图像的基本解码功能,它唯一的可选参数可以由SetCodecOption进行设置,以对插值质量进行可控制。可选的选项有(DECODE_QUALITY_LIN=0, DECODE_QUALITY_VNG=1, DECODE_QUALITY_PPG=2, DECODE_QUALITY_AHD=3).

          CximagePNG:现在可以读取所有PNG_COLOR_TYPE_类型。但是,每个通道含有超过8位像素深度的PNG文件,会被转换到8位,这是CxImage的一个主要限制。
          CxImageGIF:现在能够更好地支持对动态GIF图像的读取,通过SetRetreiveAllFrames设置属性,可以同时对图像中的所有帧进行解码。在CxImage的示例项目中,展示了如何实现这一选项,并展示了如何播放一副GIF动画。

          CxImageBMP: 支持对32位图像的读写(支持Alpha通道)

          CxImageICO: 支持对Vista PNG图标的读写;添加对多页图标的支持。

          CxImageMNG: 支持对MNG Alpha图层的读取。
          CxImageSKA: 新的用于支持SKA图像格式的类,这种图像通常用在视频租赁软件中。

          CxImageJPG: 为JPEG图像格式的二次采样提供了 新的选项。ENCODE_SUBSAMPLE_422,ENCODE_SUBSAMPLE_444),默认情况下是 高采样率的4:1:1 。当然,也可以被设置成中等的4:2:2或者低等的4:4:4。

    下图展示了不同采样率下,在压缩图像中所产生的不同数量的伪影。在压缩有着明显轮廓的图像的时候,采用4:4:4的采样率有助于减少轮廓的伪影。

     

    可移植性

          所有的类和项目都通过了不同编译器的测试,包括从VC++6 到VC++2008的微软系列编译器,Borland C++ Builder 3和6,同时部分地支持wxDev-C++和MinGW。

          所有的库都支持UNICODE 和非UNICODE两个版本。(感谢Eric Jesover)

          对于第一次使用的用户,你可以使用一个轻量级的版本(cximage600_lite)。这个版本去除了C库,但是添加了一个简单的示例项目。
          所有控制台示例(/demo2)和CxImageCrtDll项目可以在VC++Express2005和 Microsoft Platform SDK环境下编译通过。如果你在编译链接的时候,遇到像"unresolved external..."(无法找到外部符号…)这样的错误,请检查是否所有C库都被编译了。或者手动地添加gdi32.lib 和user32.lib为项目的依赖库。

          同时,CxImage也可以在Pocket PC 2003上工作。在CxImage中,为VC++ 2005编译器提供了一个可以工作的版本和相应的实例(cximage600_ce)。对于旧式的嵌入式VC编译器,最主要的限制是无法支持对异常的处理。为了解决这个问题,相应的异常处理语句try,throw和catch已经被定义在ximadef.h中的三个宏取代,同时还定义了CXIMAGE_SUPPORT_EXCEPTION_HANDLING。通过这样的方法,取消对异常处理的支持,可以成功编译链接整个库。虽然这个解决办法不是那么优雅,但是当异常处理被取消的时候,对代码的影响是最小的。同时,当异常处理被启用的时候,同样不会造成源代码的修改与变动。

          对于平台之间little-endian和big-endian的兼容性,对于内建支持的图像文件格式(bmp, ico, tga, pcx, gif, ska),由ntohs和ntohl控制。

     

          示例 
          大多数新的特性可以在CxImage的主要示例程序中尝试和体验。这个示例程序只是一个测试平台,虽然它提供很多有用的特性,但是它实在不是一个严谨的应用程序。

          ·CQuantizer : 这个类被DecreaseBpp菜单项所使用。在以前的版本中,这里有一个取整的错误,在某些情况下,白色(255,255,255)会被转换成(254,254,254)。在新的版本中,这个问题已经被修复了。
          ·Copy/Paste : 现在,新的粘贴功能支持元文件图像(例如,从Office应用程序中复制而来的图像)。这个示例内部使用了自定义的剪切板格式以测试Dump/Undump方法。Copy只工作在当前选区,但是你可以通过CxImage/Remove Selection 复制整幅图像。
          ·FloodFill : (/View/Tools/Flood Fill) 通过一个浮动的对话框,你可以测试色彩填充的颜色,偏差,透明度和是否选择。当透明度为0并且选择区域功能启用的时候,这个功能就变现为"魔法棒",用于根据颜色选区某个区域。
          ·Graph data extraction : (/Filters/graph data extraction) 这个示例演示了如何从图像(从扫描仪获取或者从互联网下载所得)中提取数字信息。转换后的数据被粘贴到剪切板,同时可以被保存成文本文件或者Excel表格文件。

    数据提取对话框


    数据提取结果


          ·RedEyeRemove : (/Filters/Non Linear/Remove Red Eye) 去除红眼的功能在照片处理中经常用到。你 必须在红眼周围选择一个区域,然后去除红眼的功能就会对红色通道进行过滤,从而去掉照片中的红眼。红眼的选区是一个矩形区域,同时可以包括部分的虹膜(眼黑),过滤器会在以选区中点为中心的圆心区域工作,不会影响到选中的眼黑部分。

     

     

          ·SelectiveBlur / UnsharpMask : 这些非线性的滤镜可以增加图像的质量。SelectiveBlur可以去除二次噪声(比如JPEG图像中的伪影或者是数码相机的噪声),从而展示图像中的更多细节。而UnsharpMask可以增强图像的细节,但是却不会添加噪声。

          ·Custom linear filters : (/Filters/Linear/Custom) 一个用于测试新的滤镜功能核心的图像用户界面。

          ·Histogram : (/Colors/Histogram/...) 为了测试HistogramStretch(直方图),这个示例中提供了很多菜单项,通过不同的方法(0 = luminance, 1 = linked channels , 2 = independent channels)来测试直方图功能。对于有噪声的图像,阈值(threshold)这个参数增强了算法的健壮性。半饱和度(Half Saturation)和全饱和度(Full Saturation)可以测试转换颜色空间(ConvertColorSpace),直方图(Histogram)和饱和度(Saturate)在YUV颜色空间对直方图的拉伸效果。

     


          ·Thresholding : ( /Colors/Threshold... and /Colors/Adaptive Threshold). 透明度阈值(OptimalThreshold)是一个新的用于查找二进制图像透明度阈值的新方法。可选的算法有:

      1 = 最大类间方差 (Otsu);
      2 = 基特勒和伊尔林格沃斯(Kittler & Illingworth);
      3 = 最大熵(maximum entropy);
      4 = 位差(potential difference);
      0 = 平均所有方法 (默认情况下,这也是示例程序中所使用的方法);

          "保留低于阈值的颜色"(preserve colors less than the threshold)的选项,将测试Threshold2方法。这对于过滤带有噪声背景的彩色图像很有用。经过处理,我们将得到一幅带有一致背景的彩色图像(噪声被去除)。AdaptiveThreshold是对方法OptimalThreshold的一个应用,它将创建很多阈值模板。AdaptiveThreshold对于有着不一致的灯光照射效果的图像,非常有用。对于这类图像,我们不能简单地在整幅图像中使用某个单一的阈值。但是,如果我们的参数设置得不对,我们将得到一个非常差劲的处理结果。


          ·Add shadow : (/Filters/Add Shadow...) 这个菜单项的功能演示了如何将CxImage的多个小功能(选择(selections),高斯模糊( GaussianBlur),混合( Mix))组合使用,以达到常见的图像处理效果。

     


          ·Text smoothing : DrawStringEx 实现了一个新的选项CXTEXTINFO::smooth。我们可以通过文本工具(位于/View/Tools/Text),选中抗锯齿("antialias")选项对这个功能进行测试。

          类似的效果也同样可以利用TextBlur (/Filters/Non Linear/Text Blur)进行后处理获得。这是一个非线性的过滤器,它只对角或圆形的边缘起作用,从而不会影响到纵向或横向的线。下图展示了不同平滑方法的实际效果:

     

     

     

    CxImage库的结构

          在整个库的继承树中,CxImage位于所有其他模块的顶部。这不是一个完全的符合OOP的方式,但是至少从最初的版本一直到现在,它都工作得很好。现在想要改变整个结构,已经太晚了。但是,你总是可以使用这些继承类来操作相应格式的图像,例如你可以使用CxImageTIF来保存多页的TIFF文件。这样显得非常直观。

     

          连接所有模块和C库的是CxFile。这是一个虚类,它提供了标准的方法,用于访问硬盘或者内存的文件数据。 


    CxImage的继承树

          一个CxImage对象基本上对应于一幅位图,同时添加了一些额外的成员变量用于存储一些有用的信息。

    01.class CxImage  
    02. {  
    03. ...  
    04. protected:  
    05. void* pDib;            // 包含文件头,调色板和像素数据   
    06. BITMAPINFOHEADER head; // 标准文件头   
    07. CXIMAGEINFO info;      // 扩展信息   
    08. BYTE* pSelection;      // 选区   
    09. BYTE* pAlpha;          // alpha通道   
    10. CxImage** ppLayers;    // 普通层   
    11. CxImage** ppFrames;    // 动画帧   
    12. }  

          CxImage::head 是位图文件的文件头,而CxImage::pDib就是一个普通的位图(就像你在CxImageBMP::Encode中看到的一样)。  
          CxImage::info 是一个方便的信息容器。这些信息被不同的文件格式所共享,同时供所有成员函数访问。

     

    01.typedef struct  tagCxImageInfo {  
    02.    DWORD   dwEffWidth;       //双字节对齐宽度   
    03.    BYTE*   pImage;           //图像数据   
    04.    void*   pGhost;           //如果这是一个备份(ghost),则pGhost指向它的原始对象    
    05.    DWORD   dwType;           //原始图像格式   
    06.    char    szLastError[256]; //调试信息,最后的错误信息   
    07.    long    nProgress;        //进度   
    08.    long    nEscape;          //取消   
    09.    long    nBkgndIndex;      //GIF, PNG, MNG使用   
    10.    RGBQUAD nBkgndColor;      //RGB透明使用   
    11.    BYTE    nQuality;         //JPEG使用   
    12.    long    nFrame;           //TIF, GIF, MNG使用,表示当前活动帧   
    13.    long    nNumFrames;       //TIF, GIF, MNG使用,表示总帧数                           
    14.    DWORD   dwFrameDelay;     //GIF, MNG使用,表示帧的延迟   
    15.    long    xDPI;             //水平分辨率     
    16.    long    yDPI;             //垂直分辨率     
    17.    RECT    rSelectionBox;    //对象的外包围框   
    18.    BYTE    nAlphaMax;        //最大透明度   
    19.    bool    bAlphaPaletteEnabled;  //如果调色板中的alpha值是启用的,则这个变量为true    
    20.    bool    bEnabled;         //启用绘制函数   
    21.    long    xOffset;  
    22.    long    yOffset;  
    23.    DWORD   dwEncodeOption;   //GIF, TIF使用:0=def.1=unc,2=fax3,3=fax4, 4=pack,5=jpg   
    24.    RGBQUAD last_c;           //用于优化GetNearestIndex   
    25.    BYTE    last_c_index;  
    26.    bool    last_c_isvalid;  
    27.    long    nNumLayers;  
    28.    DWORD   dwFlags;  
    29.} CXIMAGEINFO;  

     
          CxImage对象同样是图层的集合,每个图层的缓冲区只在需要的时候申请。
          CxImage::pDib是背景图像。 CxImage::pAlpha是透明层。CxImage::pSelection是选区层,用于创建要对图像的感兴趣区域进行处理的选择区域。在这三个特殊层之上,你可以添加通用的其他层,这些层都保存在CxImage::ppLayers中。通用层也是完整的CxImage对象,所以你可以创建复杂的嵌套层。CxImage::ppFrames 为动态图像(GIF)所预留。

          CxImage类成员和操作
          CxImage使用Doxygen 产生文档,但是由于一些历史的原因,很多不太通用的功能还没有文档。类成员的参考资料,发布历史以及许可信息都可以在这里(here )找到。

     

          支持的格式和选项
          整个CxImage库非常大,在主要的头文件ximcfg.h中,你可以找到很多编译选项开关,用于启用或者禁用某些特定的图像格式或者功能。每个JPG, PNG和 TIFF库将使得应用程序增加大约100KB的大小,同时,CxImage将使得应用程序增加大约50KB的大小。所以,为了减小你的应用程序的体积,你应该支持和链接你的应用程序确实需要的格式。

     

    格式
    定义#define
    需要的库
    尺寸 [KB]
    BMP
    GIF
    ICO
    TGA
    PCX
    WBMP
    WMF
    SKA
    CXIMAGE_SUPPORT_BMP
    CXIMAGE_SUPPORT_GIF
    CXIMAGE_SUPPORT_ICO
    CXIMAGE_SUPPORT_TGA
    CXIMAGE_SUPPORT_PCX
    CXIMAGE_SUPPORT_WBMP
    CXIMAGE_SUPPORT_WMF
    CXIMAGE_SUPPORT_SKA

    内建

    24
    JPEG
    CXIMAGE_SUPPORT_JPG

    jpeg

    88
    PNG
    CXIMAGE_SUPPORT_PNG

    png, zlib

    104
    MNG
    CXIMAGE_SUPPORT_MNG

    mng, zlib, jpeg

    148
    TIFF
    CXIMAGE_SUPPORT_TIF

    tiff, zlib, jpeg

    124
    JBIG
    CXIMAGE_SUPPORT_JBG

    jbig

    28
    PNM,PPM,PGM
    RAS
    CXIMAGE_SUPPORT_PNM
    CXIMAGE_SUPPORT_RAS

    jasper

    176
    JPEG-2000
    CXIMAGE_SUPPORT_JP2
    CXIMAGE_SUPPORT_JPC
    CXIMAGE_SUPPORT_PGX

    jasper

    176
    RAW
    CXIMAGE_SUPPORT_RAW
    libdcr
    132

     

    选项
    定义#define
    尺寸[KB]
    CxImage核心
    所有开关关闭
    20
    几何变换
    (geometric transformations)
    CXIMAGE_SUPPORT_TRANSFORMATION
    16
    图像处理
    (image processing)
    CXIMAGE_SUPPORT_DSP
    24
    绘制和特殊的窗口函数
    (drawing and windows specific functions)
    CXIMAGE_SUPPORT_WINDOWS
    12
    透明
    (transparency)
    CXIMAGE_SUPPORT_ALPHA
    4
    选择
    (selections)
    CXIMAGE_SUPPORT_SELECTION
    4
    多层支持
    (multiple layers)
    CXIMAGE_SUPPORT_LAYERS
    < 4
    图像格式转换
    (graphic formats conversion)
    CXIMAGE_SUPPORT_DECODE
    CXIMAGE_SUPPORT_ENCODE
    < 4
    插值函数
    (interpolation functions)
    CXIMAGE_SUPPORT_INTERPOLATION
    < 4
    异常处理
    (exception handling)
    CXIMAGE_SUPPORT_EXCEPTION_HANDLING
    < 4

     

     

          在你的项目中使用CxImage
          如下图所示,CxImgLib.dsw工作空间展示了构建一个包含绝大多数功能和支持大多数图像格式的应用程序(demo.exe)所需要的所有库。你必须先编译所有的库,然后才可以链接你最终的应用程序。 

          CxImgLib.dsw工作空间
          在相同的工作空间中,你可以找到用于构建不同库和应用程序的项目:

      ·CxImage : cximage.lib - 静态库
      ·CxImageCrtDll : cximagecrt.dll - DLL,不使用MFC
      ·CxImageMfcDll : cximage.dll - DLL,使用MFC
      ·Demo : 示例程序demo.exe,跟cximage.lib和C库链接。
      ·DemoDll : demodll.exe - 跟cximagecrt.dll链接
      ·libdcr,jasper,jbig,jpeg,png,tiff,zlib : 静态的C库

          构建这些项目需要几分钟时间,当所有项目构建完成后,你可以选择demo项目并执行应用程序。

          要想在你自己的项目中使用CxImage,你必须编辑下面这些项目设置设置(针对Visual C++ 6.0):
     
      Project Settings(项目设置)

    01.Project Settings  
    02. |- C/C++  
    03. |   |- Code Generation  
    04. |   |   |- Use run-time library : Multithreaded DLL (must be the same for   
    05. |   |   |  all the linked libraries)  
    06. |   |   |- Struct member alignment : must be the same for all the linked   
    07. |   |   |  libraries  
    08. |   |- Precompiled headers : not using precompiled headers  
    09. |   |- Preprocessor  
    10. |       |- Additional Include Directories:  ../cximage  
    11. |- Link  
    12.    |- General  
    13.        |- Object/library modules: ../png/Debug/png.lib    
    14.                                   ../raw/Debug/libdcr.lib  
    15.                                   ../jpeg/Debug/jpeg.lib   
    16.                                   ../zlib/Debug/zlib.lib   
    17.                                   ../tiff/Debug/tiff.lib  
    18.                                   ../jasper/Debug/jasper.lib  
    19.                                   ../cximage/Debug/cximage.lib  ...  

     

          在你的源代码中,你必须引入CxImage的头文件ximage.h。在你的代码中添加如下语句:#include "ximage.h"。
          注意,不要混合debug和release模块,每个配置必须使用各自相应的库文件。

     

          在CxImage中添加自定义的函数
          为CxImage添加一个新的图像处理函数并不困难。在这里,我将以CxImage::Jitter为例子,描述如何为CxImage添加自定义的函数。虽然这个函数很简单, 但是它却展示了使用CxImage时所需要注意的方方面面。

          首先,我们需要声明这个函数:

    bool Jitter(long radius=2)  

          在ximage.h头文件的CXIMAGE_SUPPORT_DSP部分,你可以在public区域的任何部分声明这个函数。

          现在,我们开始定义这个函数:

    01.bool CxImage::Jitter(long radius)  
    02.{  
    03.    // 检查图像是否合法,这应当是这个函数的第一行   
    04.    if (!pDib) return false;  
    05.      
    06.    // 局部变量   
    07.    long nx,ny;  
    08.      
    09.    // 临时图像,用于存储算法的部分结果   
    10.    CxImage tmp(*this,pSelection!=0,true,true);  
    11.      
    12.    // 限制函数仅仅作用在选区(通过Selection...()函数定义)的最小区域   
    13.    // 这将加快整个循环的速度,提高算法效率   
    14.    long xmin,xmax,ymin,ymax;  
    15.    if (pSelection){  
    16.        xmin = info.rSelectionBox.left; xmax = info.rSelectionBox.right;  
    17.        ymin = info.rSelectionBox.bottom; ymax = info.rSelectionBox.top;  
    18.    } else {  
    19.        xmin = ymin = 0;  
    20.        xmax = head.biWidth; ymax=head.biHeight;  
    21.    }  
    22.      
    23.    // 主循环 : 垂直方向扫描图像   
    24.    for(long y=ymin; y <ymax; y++){  
    25.      
    26.        // 监视循环的进度   
    27.        info.nProgress = (long)(100*y/head.biHeight);  
    28.      
    29.        // 检查应用程序是否已经退出   
    30.        if (info.nEscape) break;  
    31.      
    32.        // 主循环 : 水平方向扫描图像   
    33.        for(long x=xmin; x<xmax; x++){  
    34.      
    35.        // 如果选区功能启用了,则仅仅处理选区内部的像素  
    36.#if CXIMAGE_SUPPORT_SELECTION   
    37.            if (SelectionIsInside(x,y))  
    38.#endif //CXIMAGE_SUPPORT_SELECTION   
    39.            {  
    40.                // 主算法   
    41.                nx=x+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));  
    42.                ny=y+(long)((rand()/(float)RAND_MAX - 0.5)*(radius*2));  
    43.                if (!IsInside(nx,ny)) {  
    44.                    nx=x;  
    45.                    ny=y;  
    46.                }  
    47.  
    48.                // 保存结果到临时图像中.   
    49.                // 如果可以,24位图像请使用PixelColor,   
    50.                // 而8,4和1位图像请使用PixelIndex,这样可以加快速度。   
    51.                if (head.biClrUsed==0){  
    52.                    tmp.SetPixelColor(x,y,GetPixelColor(nx,ny));  
    53.                } else {  
    54.                    tmp.SetPixelIndex(x,y,GetPixelIndex(nx,ny));  
    55.                }  
    56.  
    57.                // 如果启用了透明度功能,则处理透明图层中的像素   
    58.#if CXIMAGE_SUPPORT_ALPHA   
    59.                tmp.AlphaSet(x,y,AlphaGet(nx,ny));  
    60.#endif //CXIMAGE_SUPPORT_ALPHA   
    61.  
    62.            }  
    63.        }  
    64.    }  
    65.  
    66.    // 保存结果并退出   
    67.    Transfer(tmp);  
    68.    return true;  
    69.}  
    示例:

    如何转换一种格式到另外一种格式

    01.CxImage  image;  
    02.// bmp -> jpg   
    03.image.Load("image.bmp", CXIMAGE_FORMAT_BMP);  
    04.if (image.IsValid()){  
    05.    if(!image.IsGrayScale()) image.IncreaseBpp(24);  
    06.    image.SetJpegQuality(80);  
    07.    image.Save("image.jpg",CXIMAGE_FORMAT_JPG);  
    08.}  
    09.// png -> tif   
    10.image.Load("image.png", CXIMAGE_FORMAT_PNG);  
    11.if (image.IsValid()){  
    12.    image.Save("image.tif",CXIMAGE_FORMAT_TIF);  
    13.}  


     

    如何从资源中加载图像

    01.//Load the resource IDR_PNG1 from the PNG resource type   
    02.CxImage* newImage = new CxImage();  
    03.newImage->LoadResource(FindResource(NULL,MAKEINTRESOURCE(IDR_PNG1),  
    04.                       "PNG"),CXIMAGE_FORMAT_PNG);  
    05.  
    06.//Load the resource IDR_JPG1 from DLL   
    07.CxImage* newImage = new CxImage();  
    08.HINSTANCE hdll=LoadLibrary("imagelib.dll");  
    09.if (hdll){  
    10.    HRSRC hres=FindResource(hdll,MAKEINTRESOURCE(IDR_JPG1),"JPG");  
    11.    newImage->LoadResource(hres,CXIMAGE_FORMAT_JPG,hdll);  
    12.    FreeLibrary(hdll);  
    13.}  
    14.  
    15.//Load a bitmap resource;   
    16.HBITMAP bitmap = ::LoadBitmap(AfxGetInstanceHandle(),  
    17.                           MAKEINTRESOURCE(IDB_BITMAP1)));  
    18.CxImage *newImage = new CxImage();  
    19.newImage->CreateFromHBITMAP(bitmap)


     

          如何解码内存中的图像

    01.CxImage image((BYTE*)buffer,size,image_type);  
    02.  
    03.CxMemFile memfile((BYTE*)buffer,size);  
    04.CxImage image(&memfile,image_type);  
    05.  
    06.CxMemFile memfile((BYTE*)buffer,size);  
    07.CxImage* image = new CxImage();  
    08.image->Decode(&memfile,type);  


     

    如何对内存中的图像编码

    01.long size=0;  
    02.BYTE* buffer=0;  
    03.image.Encode(buffer,size,image_type);  
    04....  
    05.image.FreeMemory(buffer);  
    06.  
    07.CxMemFile memfile;  
    08.memfile.Open();  
    09.image.Encode(&memfile,image_type);  
    10.BYTE* buffer = memfile.GetBuffer();  
    11.long size = memfile.Size();  
    12....  
    13.image.FreeMemory(buffer);  


     

    如何创建一副多页的TIFF

    01.CxImage *pimage[3];  
    02.pimage[0]=&image1;  
    03.pimage[1]=&image2;  
    04.pimage[2]=&image3;  
    05.FILE* hFile;  
    06.hFile = fopen("multipage.tif","w+b");  
    07.CxImageTIF multiimage;  
    08.multiimage.Encode(hFile,pimage,3);  
    09.fclose(hFile);  
    10.  
    11.FILE* hFile;  
    12.hFile = fopen("c://multi.tif","w+b");  
    13.CxImageTIF image;  
    14.image.Load("c://1.tif",CXIMAGE_FORMAT_TIF);  
    15.image.Encode(hFile,true);  
    16.image.Load("c://2.bmp",CXIMAGE_FORMAT_BMP);  
    17.image.Encode(hFile,true);  
    18.image.Load("c://3.png",CXIMAGE_FORMAT_PNG);  
    19.image.Encode(hFile);  
    20.fclose(hFile);  


     

    如何复制和粘贴图像

    01.//复制(copy)   
    02.HANDLE hDIB = image->CopyToHandle();  
    03.if (::OpenClipboard(AfxGetApp()->m_pMainWnd->GetSafeHwnd())) {  
    04.    if(::EmptyClipboard()) {  
    05.        if (::SetClipboardData(CF_DIB,hDIB) == NULL ) {  
    06.            AfxMessageBox( "Unable to set Clipboard data" );  
    07.}    }    }  
    08.CloseClipboard();  
    09.  
    10.//粘贴(paste)   
    11.HANDLE hBitmap=NULL;  
    12.CxImage *newima = new CxImage();  
    13.if (OpenClipboard()) hBitmap=GetClipboardData(CF_DIB);  
    14.if (hBitmap) newima->CreateFromHANDLE(hBitmap);  
    15.CloseClipboard();  


     

    如何在图片框控件(Picture Box)中显示图像

    01.HBITMAP m_bitmap = NULL;  
    02.CxImage image("myfile.png", CXIMAGE_FORMAT_PNG);  
    03....  
    04.CDC* hdc = m_picture.GetDC();  
    05.HBITMAP m_bitmap = image.MakeBitmap(hdc->m_hDC);  
    06.HBITMAP hOldBmp = m_picture.SetBitmap(m_bitmap);  
    07.if (hOldBmp) DeleteObject(hOldBmp);  
    08.if (hdc->m_hDC) m_picture.ReleaseDC(hdc);  
    09....  
    10.if (m_bitmap) DeleteObject(m_bitmap);  


     

    译后序:

          关于图像处理库,我相信大家有一个共同的疑问:这么多图像处理库,我该如何选择?在CSDN的blog中有这样一段文字,比较透彻地回答了这个问题,感谢作者的透彻解释:

          "CxImage类库是一 个优秀的图像操作类库。它可以快捷地存取、显示、转换各种图像。有的读者可能说,有那么多优秀的图形库,如OpenIL,FreeImage, PaintLib等等,它们可谓是功能强大,齐全,没必要用其它的类库。但我要说,这些类库基本上没有免费的,使用这些类库,你要被这样那样的许可协议所 束缚。

          在这点上,CxImage类库是完全免费的。另外,在使用上述类库时,你会遇到重重麻烦。因为它们大部分是平台无关的,且用C语言写成,有的还夹杂 着基本的C++ wrapper和成堆德编译选项的声明需要你去处理。而CxImage类库在这方面做得很好。还有让我最看好的,就是作者完全公开了源代码。相对于那些封 装好的图形库和GDI+来说,这一点使我们可以进一步学习各种编解码技术,而不再浮于各种技术的表面。"

    展开全文
  • CxImage的使用及基本用法

    千次阅读 2012-06-25 12:19:09
    基本定义:CxImage类库是一个优秀的图像操作类库。它可以快捷地存取、显示、转换各种图像。 下载地址:http://www.codeproject.com/KB/graphics/cximage.aspx 配置环境: 1、拷贝CxImage到项目目录  a、编译...
  • CxImage入门教程,图文并茂

    千次阅读 2014-11-16 11:16:16
    CxImage是C++实现的功能强大的、能处理多种文件格式的图像管理类。它能够简单快速的实现图像的导入、保存、显示和变换。同时又具有平台无关,免费开源,支持多种图片格式几何操作、图像处理、图像格式转换等优点。...
  • cximage配置环境与实例

    2019-07-01 09:24:49
    对于像cximage这样的第三方库,我们一般都会包含头文件(*.h),静态库文件(*.lib)和动态库文件(*.dll)。 1. 文件位置:为了提高程序的可移植性,将第三库放在解决方案(*.sln)或者工程(*.vcxproj)文件所在的文件夹下。...
  • cximage

    2017-10-25 09:44:47
    CxImage是一个可以用于MFC 的C++图像处理类库类,它可以打开,保存,显示,转换各种常见格式的图像文件,比如BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式的文件。可以实
  • CxImage

    2016-11-11 16:18:53
    Hi,蜜蜡,又是我听歌宝听歌专员gongluck。 今天,继之前的GDI、GDI+两个实例之后,我有利用功能强大...从网上下载好CxImage工程的源码并编译好后,把cximage文件夹下的所有头文件和工程的所有静态链接库文件(.lib)拷
  • CxImage类库是一 个优秀的图像操作类库。它可以快捷地存取、显示、转换各种图像。有的读者可能说,有那么多优秀的图形库,如OpenIL,FreeImage, PaintLib等等,它们可谓是功能强大,齐全,没必要用其它的类库。但我要...
  • 在项目中使用CxImage

    千次阅读 2014-04-11 18:08:47
    1.准备工作 (1)首先编译cximage702_full,注意解决方案平台是什么!...(3)在x64编译成功后,在cximage702_full目录下的x64文件夹的子文件夹Debug中会有 cximage.lib,jpeg.lib,png.lib,zlib.lib
  • cximage +png图处理上。

    千次阅读 热门讨论 2013-01-16 08:20:49
    使用cximage这个类,还需要你去下载一个cximage的demo。里面要用到这几个文件呀! 找到这几个文件之后把他复制到你的工程中,进行配置,这样你就可以用cximage这个类了。 第一步,打开的工程,点projects——se
  • VC++ 图像处理类库CxImage源代码,CxImage是一个可以用于MFC 的C++类,可以打开,保存,显示,转换各种格式的图像文件,比如BMP, JPEG, GIF, PNG, TIFF, MNG, ICO, PCX, TGA, WMF, WBMP, JBG, J2K 等格式的文件。...
  • CxImage显示图片例程

    热门讨论 2020-07-27 23:33:46
    CxImage显示图片例程。适合CxImage初学者!高手就不适合了!
  • 交叉编译-4:CxImage开源库在VS2013的编译和使用

    千次阅读 热门讨论 2019-11-26 14:15:20
    一、cximage600_full在VS2013编译和使用 1、编译 (1)下载后解压缩,直接打开根目录下的 CxImgLib.dsw文件。版本转换完成之后,在编译之前先将每个工程属性的字符集由原先的使用Unicode字符集改为使用多字节字符...
  • CxImage是C++实现的功能强大的、能处理多种文件格式的图像管理类。它可以简单高速的实现图像的导入、保存、显示和变换。同一时候又具有平台无关,免费开源,支持多种图片格式几何操作、图像处理、图像格式转换等长处...
  • CxImage使用方法经验

    千次阅读 2013-04-29 22:39:15
    CxImage使用方法经验CxImage是不错的图像处理类,下载下来后,发现太复杂,详细说明的文档也没有,个人总结经验如下:(一)安装使用前要先打开CxImgLib.dsw,进行编辑成LIB库文件。随后的使用方法如下:一、最复杂...
  • CxImage的编译及简单使用举例

    万次阅读 2019-03-24 15:36:19
    1、 从http://sourceforge.net/projects/cximage/下载最新的CxImage 702源码; 2、 解压缩后,以管理员身份打开CxImageFull_vc10.sln工程,在编译之前先将每个工程属性的Character Set由原先的Use Unicode ...
1 2 3 4 5 ... 20
收藏数 3,198
精华内容 1,279
热门标签
关键字:

cximage