ImageStone

• Download full source with examples - 252.7 Kb
• Download CHM document - 499.7 Kb
• Download executable example - 008 - 284.9 Kb

Introduction

ImageStone is a powerful C++ class library for image manipulation. It is written in pure C++ and is easily to portable. Its features include load/save (supports BMP, GIF, JPG, PNG, TIF, ICO, TGA, PCX, PSD...), display, histogram, undo/redo, and image transformation with over 100 predefined effects.

License

ImageStone is free. You can use the code however you want (free or commercial), as long as you don't claim it as your own. (If you use it in your product, I hope I could be notified.)

Using ImageStone

It's extremely easy, all you need to do is add #include "ImageStone.h" at the beginning of your source code. If you are using ImageStone in a MFC project, just add this include line at the end of the StdAfx.h file.

The most basic and the most important class is FCObjImage, let's learn how to use it.

... load image from memory under any OS

// Load image into memory

char   * p = 0 ;
int    n = 0 ;
FCOXOHelper::LoadFileToBuffer ("test.jpg", p, n) ;

FCObjImage   img ;
img.Load (p, n, IMG_JPG) ;

delete[] p ;

// this line demonstrate how to determine image's format by file's ext name

IMAGE_TYPE  t = 
    FCObjImage::GetImageHandleFactory()->QueryImageFileType("test.jpg");

... load image from DIB stream under any OS

// Load image into memory

char   * p = 0 ;
int    n = 0 ;
FCOXOHelper::LoadFileToBuffer ("test.bmp", p, n) ;
p += sizeof(BITMAPFILEHEADER) ;

// now p point to a DIB stream

FCObjImage   img ;
img.LoadDIBStream (p, n) ;

delete[] p ;

... load image from resource under Windows

// Load image from local exe file

FCObjImage   img ;
FCWin32::LoadImageRes (img, MAKEINTRESOURCE(nID), TEXT("JPG"), IMG_JPG) ;

// Load image from DLL's resource

HMODULE   hDll = LoadLibrary (TEXT("ResDll.dll")) ;
FCWin32::LoadImageRes (img, MAKEINTRESOURCE(nID), TEXT("JPG"), IMG_JPG, hDll) ;

// Load image from standard BITMAP resource

FCWin32::LoadImageBitmapRes (img, MAKEINTRESOURCE(nID)) ;

... load/save image via FreeImage library

// change to FreeImage library load/save image

// more detail refer to example 005

FCObjImage::SetImageHandleFactory (new FCImageHandleFactory_FreeImage) ;
img.Load ("test.jpg") ;

// change to GDI+ load/save image

FCObjImage::SetImageHandleFactory (new FCImageHandleFactory_Gdiplus) ;
img.Load ("test.jpg") ;

... combine ImageHandleFactory

// use FreeImage to load/save PSD/PCX image

class CMyImageFactory : public FCImageHandleFactory
{
protected:
    virtual FCImageHandleBase* CreateImageHandle (IMAGE_TYPE imgType)
    {
        switch (imgType)
        {
            case IMG_BMP : return new FCImageHandle_Bmp ;
            case IMG_TGA : return new FCImageHandle_Tga ;
            case IMG_JPG : return new FCImageHandle_Gdiplus ;
            case IMG_GIF : return new FCImageHandle_Gdiplus ;
            case IMG_TIF : return new FCImageHandle_Gdiplus ;
            case IMG_PNG : return new FCImageHandle_Gdiplus ;
            case IMG_PCX : return new FCImageHandle_FreeImage ;
            case IMG_PSD : return new FCImageHandle_FreeImage ;
        }
        return 0 ;
    }
    // protected avoid user delete object.

    virtual ~CMyImageFactory() {}
};

// use our custom factory to read/write image

FCObjImage::SetImageHandleFactory (new CMyImageFactory) ;
FCObjImage   img ;
img.Load ("test.jpg") ;

... load multi-frame GIF

FCObjMultiFrame   img ;
img.Load ("test.gif") ;
img.GetFrame(0)->Save ("001.jpg") ;
img.GetFrame(1)->Save ("001.jpg") ;
...

... Load jpeg's EXIF information

FCObjImage        img ;
FCImageProperty   prop ;
img.Load ("test.jpg", ∝) ;

// get camera ISO speed

std::string   m = prop.QueryPropertyValue (IMAGE_TAG_EXIF_ISOSpeed) ;
// get camera equip model

std::string   n = prop.QueryPropertyValue (IMAGE_TAG_EquipModel) ;

... draw image object under Windows

FCObjImage   img ;
// capture current screen

RECT         rc = {0, 0, GetSystemMetrics(SM_CXSCREEN), 
                         GetSystemMetrics(SM_CYSCREEN)} ;
FCWin32::CaptureScreen (img, rc) ;

// Draw image (no stretch) where top-left at (0,0) of hdc

FCWin32::DrawImage (img, hdc, 0, 0) ;

// Stretch image on region of hdc

RECT     rcOnDC = {100, 100, 200, 200} ;
FCWin32::DrawImage (img, hdc, rcOnDC) ;

// Stretch image on central of hdc's region and keeping image's aspect

FCWin32::DrawImageAspect (img, hdc, rcOnDC) ;

// Stretch regionof image on region of hdc

RECT     rcImg = {20, 20, 50, 50} ;
FCWin32::DrawImage (img, hdc, rcOnDC, rcImg) ;

... copy/paste image to/from clipboard

FCObjImage   img ;
img.Load ("test.jpg") ;

// copy image to clipboard

FCWin32::CopyToClipboard (img) ;

// get image in clipboard

FCWin32::GetClipboardImage (img) ;

... convert between GDI HBITMAP and FCObjImage

// create HBITMAP from FCObjImage object

FCObjImage   img ;
img.Load ("test.jpg") ;
HBITMAP   h = FCWin32::CreateDDBHandle (img) ;

// create FCObjImage object from HBITMAP

FCWin32::CreateImageFromDDB (h, img) ;

... convert between GDI+ Bitmap and FCObjImage

// create GDI+ Bitmap from FCObjImage object

FCObjImage   img ;
img.Load ("test.jpg") ;
Gdiplus::Bitmap   * pBmp = FCWin32::GDIPlus_CreateBitmap(img) ;
delete pBmp ;

// create FCObjImage object from GDI+ Bitmap

FCWin32::GDIPlus_LoadBitmap (*pBmp, img) ;

... process image

FCObjImage   img ;
img.Load ("test.jpg") ;

// resize (smooth) image

img.Stretch (nWidth, nHeight) ;
img.Stretch_Smooth (nWidth, nHeight) ;

// Use SinglePixelProcessProc interface to process

// image, there are over 100 pre-implemented effect,

// please refer to class derived from FCInterface_PixelProcess

FCPixelRotate   aCmd (37) ;
img.SinglePixelProcessProc (aCmd) ;

FCPixelBrightness   aCmd (150) ; // 150%

img.SinglePixelProcessProc (aCmd) ;

FCPixelMosaic   aCmd(5) ;
img.SinglePixelProcessProc (aCmd) ;

FCPixelOilPaint   aCmd (3) ;
img.SinglePixelProcessProc (aCmd) ;

... custom image processing

// our processor : change pixel's RGB value 

class CMyPixelProcessor : public FCSinglePixelProcessBase
{
public:
    CMyPixelProcessor (int nR, int nG, int nB) : m_R(nR), m_G(nG), m_B(nB) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) + m_B) ;
        PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) + m_G) ;
        PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) + m_R) ;
    }
    int   m_R, m_G, m_B ;
};

// this class has the same function to upper

// class, but implement other class

class CMyImageProcessor : public FCPixelWholeImageBase
{
public:
    CMyPixelProcessor (int nR, int nG, int nB) : m_R(nR), m_G(nG), m_B(nB) {}
private:
    virtual void ProcessWholeImage (FCObjImage* pImg, 
                                    FCObjProgress* pProgress)
    {
        for (int y=0 ; y < pImg->Height() ; y++)
        {
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                BYTE   * p = pImg->GetBits(x,y) ;
                PCL_B(p) = FClamp0255 (PCL_B(p) + m_B) ;
                PCL_G(p) = FClamp0255 (PCL_G(p) + m_G) ;
                PCL_R(p) = FClamp0255 (PCL_R(p) + m_R) ;
            }
            if (pProgress)
                pProgress->SetProgress (100 * y / pImg->Height()) ;
        }
    }
    int   m_R, m_G, m_B ;
};

// use our custom processor

FCObjImage   img ;
img.Load ("test.jpg") ;

CMyPixelProcessor   aCmd (20, 20, 20) ;
img.SinglePixelProcessProc (aCmd) ;

CMyImageProcessor   aCmd (20, 20, 20) ;
img.SinglePixelProcessProc (aCmd) ;

... add text on image

FCObjImage   img ;
img.Load ("c:\\test.jpg") ;

// now we create text layer

FCObjTextLayer   imgT ;
PACK_TextLayer   tp ;
tp.m_bAddShadow = false ;
tp.m_bAntiAliased = true ;
tp.m_bBold = true ;
tp.m_bItalic = true ;
tp.m_crFont = PCL_RGBA(0,0,255) ;
tp.m_nFontSize = 128 ;
tp.m_strFace = "Arial" ;
tp.m_strText = "Hello" ;
FCWin32::CreateTextLayer_GDIPlus (imgT, tp) ;

// now we have create text image, additional

// we can add some affect on it, such as gradient color

POINT                 pt1={0,0}, pt2={0,50} ;
FCPixelGradientLine   aCmd (pt1, pt2, PCL_RGBA(0,0,255), 
                            FCColor::crWhite()) ;
imgT.SinglePixelProcessProc (aCmd) ;

// blend text layer on image

RECT   rc = {0, 0, imgT.Width(), imgT.Height()} ;
img.AlphaBlend (imgT, rc, rc, 100) ;

History

• 2007 - 03 - 11, V4.0
  + Add FCPixelFillGradientFrame.
  + Add FCPixelLensFlare / FCPixelTileReflection / FCPixelSoftGlow effect.
  * Modify example.
  * Improve FCObjImage::AlphaBlend.
  * Modify FCPixelBlinds.
  * Modify brightness/contrast/hue/saturation/emboss.
  * Rewrite gauss blur processor.
  - Remove FCPixelDeinterlace.
  - Remove FCPixelAddRandomNoise.
  - Remove FCPixelFill3DSolidFrame.
  - Remove FCImageHandleFactory_IJL15 and FCImageHandle_IPicture.
  
  
• 2006 - 10 - 25, V3.0
  * Improve FCImageHandle_Gdiplus class to load multi-frame gif/tiff image and load jpeg's EXIF information.
  * Improve FCImageHandle_FreeImage class to save gif with transparency color.
  * Change FCPixelHueSaturation's hue arithmetic.
  * Change FCPixelColorTone's arithmetic, more look like old photo.
  * Change inner FCImageHandleBase interface, it's never mind for user.
  * Substitute std::fstream by ANSI C file function, because of a bug in VC2005.
  + Add FCImageProperty to store image's property, function FCObjImage::Load and FCObjImage::Save support it.
  + Add example 010 : Load jpeg's EXIF information via GDI+.
  - Remove FCObjImage::GetNextFrameDelay and FCObjImage::SetNextFrameDelay, you can get them from FCImageProperty.
  
  
• 2006 - 09 - 07, V2.0
  + More mature.
  
  
• 2006 - 03 - 11, V1.0
  + Initial version.

Author and Contact

Contact information of the author, Fu Li:

• Homepage: www.crazy-bit.com