openCore/imageProcessor.hpp

Go to the documentation of this file.

/*
  Copyright (c) 2007
  imageProcessor.hpp
  Author David McCombs -- www.w3sys.com  
  for making proofs and such
*/

#ifndef IMAGEPROCESSOR_HPP
#define IMAGEPROCESSOR_HPP

// #define DO_OPEN_LOGGING

#include "openLogger.h"
#include <map>
#include <vector>
#include <string>
#include <sstream>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <Magick++.h>
#include "ocString.h"
#include "ocFileSys.h"

class textAnnotation 
{
public:  
  string text;
  string color;
  string background;
  string fontFaceName;
  double pointSize;  
  int width;
  int height;
  int posX;
  int posY;
  textAnnotation()
  :text("default"),color("#000070"),background("#ffffff"),fontFaceName("@VeraMono.ttf"),
        pointSize(10.0),width(200),height(10),posX(0),posY(0)
  {
  }
  
  // Copy contructor
  textAnnotation(string text,string color,string background,string fontFaceName,
                 double pointSize, int width, int height, int posX, int posY )
  :text(text),color(color),background(background),fontFaceName(fontFaceName),
   pointSize(pointSize),width(width),height(height),posX(posX),posY(posY)
  {
  }
  // Copy operator required by some containers
  textAnnotation & operator = ( textAnnotation & that )  
  {
    this->text=that.text;
    this->color=that.color;
    this->background=that.background;
    this->fontFaceName=that.fontFaceName;
    this->pointSize=that.pointSize;
    this->width=that.width;
    this->height=that.height;
    this->posX=that.posX;
    this->posY=that.posY;
    return *this;
  }
  ~textAnnotation(){;}
  
};

typedef vector <textAnnotation> textAnnotations;

using namespace Magick;
class imageProcessor 
{
private:
  string m_imageBase;
  string m_imageDir;
  string m_proofDir;

  
  
  // Quality and Filter Type
  FilterTypes filter;
  unsigned int quality;

public:

  // constructor  
  imageProcessor()
    :m_imageBase("./")
    ,filter(LanczosFilter),quality(75)
  {
     m_imageDir = "images";
     m_proofDir = "proofs";
  }
  virtual ~imageProcessor(){;}


  
  bool isFile( ocString candidate ) // is it an image really
  {
    bool bret;
    bret = candidate.regExMatch("[A-Z,a-z,0-9]*\x2e[bmpnjpgtif,BMPNJPGTIF]*");    
    return bret;
  }
  
  void  imageProcess(string imageName, string session, textAnnotations annotations )
  {
    // DBG
    cout << "Image Processing "<< m_imageBase << endl;


    if( isFile(imageName) ) // make sure it's a file
    {
      // DBG
      cout << endl << "  Processing :  " <<  imageName << endl;
      makeProof(imageName,session,annotations);
    }

  }
  // gets
  string imageDir( void )
  {
    return m_imageDir;
  }
  string imageBase( void )
  {
    return m_imageBase;
  }
  string proofDir( void )
  {
    return m_proofDir;
  }
  // sets
  void imageDir( string inDir )
  {
    m_imageDir = inDir;
  }
  void imageBase( string inDir )
  {
    m_imageBase = inDir;
  } 
  void proofDir( string inDir )
  {
    m_proofDir = inDir;
  }
  Image * makeAnnot( string text, int width, int height, string font, string bg , string clr, double pSize )
  {

    Image * my_image = new Image( Geometry(width,height), Color(bg));
    my_image->strokeColor( Color(clr) );
    my_image->fillColor( Color(clr) );
    my_image->font(font);
    my_image->fontPointsize ( pSize );
    my_image->annotate( text, CenterGravity );
    return my_image;
  }
  void makeProof( string & imgEntry, string session, textAnnotations annotations )
  {
    if (imgEntry.length())
    {
      string imgProof = m_imageBase;
      string imgPath = m_imageBase;
      imgPath += m_imageDir;
      imgProof += m_proofDir;
      imgPath +="/";
      imgProof +="/";
      imgPath += imgEntry;
      imgProof += session + "." + imgEntry;
      cout << endl << " imgPath " <<   imgPath << " to  imgProof " << imgProof << endl;
      try
      {
        Image image;
        // read the image in
        image.read(imgPath);

        // write text orders in text retcangle
        // Look for fonts in /usr/share/fonts/default/TrueType/
        for( textAnnotations::iterator pos=annotations.begin(); pos != annotations.end(); pos++ )
        {
          textAnnotation ta = *pos;
          // list<Drawable> text_to_draw; use @ sign for true type fonts - put them in the local path to find them
          Image * pImg = makeAnnot( ta.text, ta.width, ta.height, 
                                    // "NewCenturySchlbk-Bold" "@VeraMono.ttf" 
                                    ta.fontFaceName, ta.background, ta.color, ta.pointSize );
          image.composite( *pImg, ta.posX, ta.posY, OverCompositeOp );
          delete pImg;
        }
        // write the image out
        image.write(imgProof);
        
        
         
        // write the small image out
        // image.write(imgProof);
      }
      catch( Exception &error_ )
      {
        cout << "Error Imagineering - Exception caught: " << error_.what() << endl;
      }
    }
  }
};
#endif

#ifdef IN_T2_TESTHARNESS
/*
  This defines the image processor unit test case using T2, 
  It also serves as an usage example. 
  Compile T2.cpp with these link flags:
      -lMagick++ -lMagick -ltiff -ljpeg -lpng -luuid 
*/
  cout << "Unit testing imageProcessor..." << endl;
  textAnnotations txtAnnots;
  
  //                                  text,              color   , bkgrnd  , fontFaceName,  ptSz,wdth,hght,posX,posY
  txtAnnots.push_back(textAnnotation("Text To Add",     "#ffffff","#000000","@VeraMono.ttf", 25, 230, 40, 10, 140 ));
  
  txtAnnots.push_back(textAnnotation("read small print","#000000","#892034","@VeraMono.ttf", 10, 230, 12, 10, 5 ));
  // overridable defaults of baseDir=./ imageDir=images proofDir=proofs
  imageProcessor processor; 
  processor.imageBase("/home/customlogomats/development/web/customlogomats/");
  processor.imageProcess("051303-JP.gif", "123AA43EE98");
  
#endif

---