IntegralImage.cpp

#include "IntegralImage.hh"

using namespace std;
using namespace BIAS;

template<class StorageType>
IntegralImage<StorageType>::IntegralImage(){
  width_ = 0;
  height_ = 0;
  channels_ = 0;
  intImg_ = NULL;
}

template<class StorageType>
IntegralImage<StorageType>::IntegralImage(const Image<StorageType> &im){
  width_ = 0;
  height_ = 0;
  channels_ = 0;
  intImg_ = NULL;
  GenerateFrom(im);
}

template<class StorageType>
IntegralImage<StorageType>::~IntegralImage(){
  if (intImg_ != NULL) delete[] intImg_;
}

template<class StorageType>
void IntegralImage<StorageType>::GenerateFrom(const ImageBase &im){

  // Initialize the array if necessary
  if (intImg_ != NULL){
    if (width_ != (int)im.GetWidth() || height_ != (int)im.GetHeight()){
      delete[] intImg_;
      intImg_ = new double[im.GetWidth()*im.GetHeight()];
    }
  } else {
     intImg_ = new double[im.GetWidth()*im.GetHeight()];
  }

  // Get image properties
  width_ = im.GetWidth();
  height_ = im.GetHeight();
  channels_ = im.GetChannelCount();


  const StorageType** idaIn = (const StorageType**) im.GetImageDataArray();

  // Start with upper left entry
  intImg_[0] = (double)idaIn[0][0];

  // Generate the first row by adding each entry to its predecessor
   for (unsigned int x=1; (int)x < width_; x++)
     intImg_[x] = (double)idaIn[0][x*channels_]+intImg_[x-1];

   // Generate the first column by adding each entry to its predecessor
   for (unsigned int y=1; (int)y < height_; y++)
     intImg_[y*width_] = (double)idaIn[y][0]+intImg_[(y-1)*width_];

   // Fill out the rest of the image by adding the upper predecessor and
   // the left predecessor minus the upper left predecessor
   for (unsigned int y=1; (int)y < height_; y++)
     for (unsigned int x=1; (int)x < width_; x++)
       intImg_[y*width_+x] = (double)idaIn[y][x*channels_]+intImg_[(y-1)*width_+x]
                                      +intImg_[y*width_+(x-1)] - intImg_[(y-1)*width_+(x-1)];

}

template<class StorageType>
double IntegralImage<StorageType>::GetDOM(int x, int y, int halfLevelSize){

  // If the blob is out of bounds, return 0
  if (halfLevelSize <= 0 || x - halfLevelSize*2 < 0 || y - halfLevelSize*2 < 0 || x + halfLevelSize*2 +1 >= (int)width_ || y + halfLevelSize*2 +1>= (int)height_)
    return 0.0;

  // Calculate the sum of the inner pixels via integral image:
  double innerValueSum = GetAreaSum(x-halfLevelSize,y-halfLevelSize,x+halfLevelSize+1,y+halfLevelSize+1);
  // Calculate the sum of pixel values of the doubled square via integral image:
  double completeValueSum = GetAreaSum(x-(halfLevelSize*2),y-(halfLevelSize*2),x+(halfLevelSize*2)+1,y+(halfLevelSize*2)+1);\
  // outer sum is the big sum minus the  inner sum
  double outerValueSum = completeValueSum - innerValueSum;
  // Calculate number of pixels:
  double numOfInnerElements = (halfLevelSize*2+1)*(halfLevelSize*2+1);
  double numOfOuterElements = (halfLevelSize*4+1)*(halfLevelSize*4+1) - numOfInnerElements;
  // DOM is average inner minus average outer pixel value
  return (innerValueSum/numOfInnerElements) - (outerValueSum/numOfOuterElements);
}



#define INSTANCE_IntImage(type)\
template class BIASUtils_EXPORT IntegralImage<type>;

// create instances
namespace BIAS{
INSTANCE_IntImage(unsigned char)
INSTANCE_IntImage(float)
#ifdef BUILD_IMAGE_INT
INSTANCE_IntImage(int)
#endif
#ifdef BUILD_IMAGE_CHAR
INSTANCE_IntImage(char)
#endif
#ifdef BUILD_IMAGE_SHORT
INSTANCE_IntImage(short)
#endif
#if defined(BUILD_IMAGE_USHORT)
INSTANCE_IntImage(unsigned short)
#endif
#ifdef BUILD_IMAGE_DOUBLE
INSTANCE_IntImage(double)
#endif
#ifdef BUILD_IMAGE_UINT
INSTANCE_IntImage(unsigned int)
#endif
}