ImageStone

Introduction

ImageStone is a powerful C++ class library for image manipulation. It is written in pure C++ and is easy to port. 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 most important class is FCObjImage. Learn how to use it.

... load/save image file under any OS

// for Windows : ImageStone uses GDI+ to load/save image,
//               Jpg/Png/Gif/Bmp/Tga/Tif be supported
// for Linux : Only Bmp/Tga are supported, but you can set
//             FreeImage handler to support more.
FCObjImage   img ;
img.Load ("test.jpg") ;
if (!img.IsValidImage())
{
   assert(false) ;
   return false ;
}

// print image's information : width, height, bit per pixel
printf ("image's width : %d",  img.Width()) ;
printf ("image's height : %d", img.Height()) ;
printf ("image's bpp : %d",    img.ColorBits()) ;

// Load/Save function determine image's format by file's ext name
// save image as jpeg file, its quality set 90 (ranges from 1 to 99)
img.Save ("save.jpg", 90) ;
img.Save ("save.png") ;
img.Save ("save.tif") ;

// Another way to set quality
FCImageProperty   prop ;
prop.SetPropertyValue (IMAGE_TAG_JPEG_QUALITY, "90") ;
img.Save ("save.jpg", prop) ;

... 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 demonstrates how to determine the image's format by
// the 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 points to a DIB stream
FCObjImage   img ;
img.LoadDIBStream (p, n) ;

delete[] p ;

... load image from a 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 to load/save image
// for 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 a jpeg's EXIF information

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

// get camera's ISO speed
std::string   m = prop.QueryPropertyValue (IMAGE_TAG_EXIF_ISOSpeed) ;
// get camera's 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 keep image's aspect
FCWin32::DrawImageAspect (img, hdc, rcOnDC) ;

// Stretch region of 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 on 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 effects;
// 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 implements 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 created a text image. Additionaly,
// we can add some affect to 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 with 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.


Downloads

Comments

  • questions

    Posted by qiuhe on 06/18/2012 05:57pm

    I tested the demo, it's not so good for the gray image. I tried to open an 8-gray bmp image, it showed"invalid format".And I tried 16-gray tiff image,it also showed that message. Can you give me some help?

    Reply
  • X86 and V4I?

    Posted by visharad on 04/18/2008 07:31am

    Does it work on X86 and V4I?

    Reply
  • Great!

    Posted by Large on 09/19/2006 02:15pm

    Nice work! This class rocks for handling any types of picture, without the need of libraries! Thnx for the great work!

    Reply
  • Nice Job

    Posted by Synetech on 09/15/2006 10:12am

    Thanks a lot for this.  I'm currently using CxImage, but I'll definitely have to take yours for a spin.  I like that you included a good manual.

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Best-in-Class organizations execute on a strategy that supports the multi-channel nature of customer requests. These leading organizations do not just open up their service infrastructures to accommodate new channels, but also empower their teams to deliver an effective and consistent experience regardless of the channel selected by the customer. This document will highlight the key business capabilities that support a Best-in-Class customer engagement strategy.

  • Live Event Date: September 17, 2014 @ 1:00 p.m. ET / 10:00 a.m. PT Another day, another end-of-support deadline. You've heard enough about the hazards of not migrating to Windows Server 2008 or 2012. What you may not know is that there's plenty in it for you and your business, like increased automation and performance, time-saving technical features, and a lower total cost of ownership. Check out this upcoming eSeminar and join Rich Holmes, Pomeroy's practice director of virtualization, as he discusses the …

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds