A couple of weeks ago, I wrote about how to interface Integrated Performance Primitives (IPP) with Magick++. While IPP offers excellent performance advantages, it does not come with the easiest programming model. Fortunately, it is easy enough to create a C++ wrapper on top of IPP and provide an easier to use programming interface.
In this article, I will show a simple example of creating a wrapper class using IPP and Magick++. The example I am going to show can be used to calculate the 2-dimensional FFT spectrum of a gray-scale image. This framework can be easily extended to include other algorithms that can be applied to an image using IPP.
Before I show the implementation details, let me first show how easy it is to use the class. The code snippet below shows how to read in an image file, apply 2D FFT with and without a Hamming window and save the results into image files.
IPPGrayImage *img, *img1;
img = new IPPGrayImage();
img->LoadFromFile(IMAGE_FILE);
img1 = img->Clone();
img1 = img1->FFT(true);
img1->SaveToFile(IMAGE_HOME + "/test_fftmag.jpg");
img1 = img->Clone();
img1 = img->ApplyHammingWindow();
img1->SaveToFile(IMAGE_HOME + "/test_hamming.jpg");
img1 = img1->FFT(true);
img1->SaveToFile(IMAGE_HOME + "/test_fftmag_hamming.jpg");
And for the following IMAGE_FILE,
Here are the results for FFT spectrum with and without hamming window:
The header file for the class is as follows:
#ifndef IPPGRAYIMAGE_H
#define IPPGRAYIMAGE_H
#include <Magick++/Image.h>
#include <Magick++.h>
#include <ipp.h>
using namespace std;
using namespace Magick;
namespace KDW
{
class IPPGrayImage
{
public:
unsigned int PIXEL_SIZE;
IPPGrayImage();
IPPGrayImage(const unsigned int width, const unsigned int height);
IPPGrayImage(Ipp32f *imgBuffer, const unsigned int width, const unsigned int height);
IPPGrayImage(const IPPGrayImage& other);
virtual ~IPPGrayImage();
IPPGrayImage& operator=(const IPPGrayImage& other);
void LoadFromFile(string fileName);
void SaveToFile();
void SaveToFile(string fileName);
inline float GetPixel(unsigned int col, unsigned int row) {return _imgBuffer[row * _width + col];}
inline void SetPixel(unsigned int col, unsigned int row, float clr) {_imgBuffer[row * _width + col] = clr;}
unsigned int GetWidth() { return _width;}
unsigned int GetHeight() { return _height;}
Ipp32f* GetImageBuffer() { return _imgBuffer;}
Image* GetImage() { return _img;}
IPPGrayImage* Clone();
IPPGrayImage* ApplyHammingWindow();
IPPGrayImage* FFT(bool fftShift = false);
protected:
private:
unsigned int _width;
unsigned int _height;
Image* _img;
Pixels* _view;
PixelPacket* _pixels;
Ipp32f* _imgBuffer;
string _fileName;
void Init();
};
}
#endif // IPPGRAYIMAGE_H
And here’s the implementation for the class:
#include <assert.h>
#include <math.h>
#include "IPPGrayImage.h"
namespace KDW
{
/** @brief Constructor()
* Initialize image buffer.
*/
IPPGrayImage::IPPGrayImage()
{
Init();
}
/** @brief Constructor(width, height)
* Initialize an image size of width x height.
*/
IPPGrayImage::IPPGrayImage(const unsigned int width, const unsigned int height)
{
Init();
_width = width;
_height = height;
int stepByte = 0;
_imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);
}
/** @brief Constructor(imgBuffer, width, height)
* Initilize from an Ipp32f buffer (width x height)
*/
IPPGrayImage::IPPGrayImage(Ipp32f *imgBuffer, const unsigned int width, const unsigned int height)
{
Init();
_width = width;
_height = height;
_imgBuffer = imgBuffer;
}
/** @brief Copy Constructor
*/
IPPGrayImage::IPPGrayImage(const IPPGrayImage& other)
{
_width = other._width;
_height = other._height;
int stepByte = 0;
_imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);
for (unsigned int row = 0; row < _height ; row++)
{
for (unsigned int column = 0; column < _width ; column++)
{
_imgBuffer[column + row * _width] =other._imgBuffer[column + row * _width];
}
}
if (other._pixels == NULL) _pixels = NULL;
}
/** @brief Overload =
*/
IPPGrayImage& IPPGrayImage::operator=(const IPPGrayImage& rhs)
{
if (this == &rhs) return *this; // handle self assignment
return *this;
}
/**
* @brief Destructor
*/
IPPGrayImage::~IPPGrayImage()
{
ippFree(_imgBuffer);
delete _img;
delete _view;
}
/**
* @brief Common initialization code
*/
void IPPGrayImage::Init()
{
PIXEL_SIZE = sizeof(Ipp32f);
_pixels = NULL;
_imgBuffer = NULL;
_img = NULL;
}
/** @brief Load an image from file
*/
void IPPGrayImage::LoadFromFile(string fileName)
{
_img = new Image(fileName);
Geometry g = _img->size();
_width = g.width();
_height= g.height();
_view = new Pixels(*_img);
_pixels = _view->get(0,0, _width, _height);
int stepByte = 0;
_imgBuffer = ippiMalloc_32f_C1(_width, _height, &stepByte);
for (unsigned int row = 0; row < _height ; row++)
{
for (unsigned int column = 0; column < _width ; column++)
{
PixelPacket *p = &_pixels[column + row * _width];
Color c = Color(p->red, p->green, p->blue);
_imgBuffer[column + row * _width] = c.intensity();
}
}
}
/** @brief Save the current image buffer to file
*/
void IPPGrayImage::SaveToFile()
{
SaveToFile("");
}
/** @brief SaveToFile(fileName)
* Saves the current image buffer to a file (by file name).
*/
void IPPGrayImage::SaveToFile(string fileName)
{
if (_img != NULL && _pixels != NULL)
{
for (unsigned int y = 0; y< _height ; y++)
{
for (unsigned int x = 0; x < _width; x++)
{
float clr = (float) _imgBuffer[x + y * _width];
_pixels[x+ y * _width] = Color(clr, clr, clr);
}
}
_view->sync();
_img->syncPixels();
if (fileName == "")
{
_img->write(_fileName);
}
else
{
_img->write(fileName);
}
}
else
{
Image img(Geometry(_width, _height),"white");
for (unsigned int y = 0; y< _height ; y++)
{
for (unsigned int x = 0; x < _width; x++)
{
Color c;
float clr = (float) _imgBuffer[x + y * _width];
img.pixelColor(x,y, Color(clr, clr, clr));
}
}
img.write(fileName);
}
}
/** @brief Clone
* Duplicate the current image to another IPPGrayImage object.
* @return an IPPGrayImage pointer to the cloned image
*/
IPPGrayImage* IPPGrayImage::Clone()
{
IPPGrayImage *newImg;
newImg = new IPPGrayImage(_width, _height);
int stepByte = 0;
newImg->_imgBuffer = ippiMalloc_32f_C1(_width,_height, &stepByte);
for (unsigned int y = 0 ; y < _height ; y++)
{
for (unsigned int x = 0 ; x < _width ; x++)
{
newImg->_imgBuffer[x + y * _width] = _imgBuffer[x + y * _width];
}
}
return newImg;
}
/** @brief Apply Hamming window to the image
* @return an IPPGrayImage pointer to the processed image
*/
IPPGrayImage* IPPGrayImage::ApplyHammingWindow()
{
IPPGrayImage *newImg;
newImg = new IPPGrayImage(_width , _height);
IppiSize srcImgSize = {_width, _height};
IppStatus sts;
int stepByte;
Ipp32f *imgCache = ippiMalloc_32f_C1(_width , _height , &stepByte);
sts = ippiWinHamming_32f_C1R(_imgBuffer, _width * PIXEL_SIZE, imgCache, _width * PIXEL_SIZE, srcImgSize);
assert(sts ==ippStsNoErr);
for (unsigned int y = 0; y< _height; y++)
{
for (unsigned int x = 0; x < _width; x++)
{
newImg->_imgBuffer[x+ y * _width] = imgCache[x + y * _width];
}
}
return newImg;
}
/** @brief Perform FFT on the image and returns the magnitude component
* @param fftShift: if it is true, the the result is with
* zero-frequency component shifted to center of spectrum
* @return the magnitude FFT component
*/
IPPGrayImage* IPPGrayImage::FFT(bool fftShift)
{
IPPGrayImage *newImg;
IppiFFTSpec_R_32f *spec;
IppStatus sts;
unsigned int n = (int) (logf((float) _width) / logf(2.0f));
unsigned int m = (int) (logf((float) _height) / logf(2.0f));
unsigned int N = pow(2, n);
unsigned int M = pow(2, m);
if (N < _width)
{
n = n + 1;
N = pow(2, n);
}
if (M < _height)
{
m = m + 1;
M = pow(2, m);
}
int stepByte;
Ipp32f *src = ippiMalloc_32f_C1(M , N , &stepByte);
Ipp32f *dst = ippiMalloc_32f_C1(M , N , &stepByte);
Ipp32f *mag = ippiMalloc_32f_C1(M , N , &stepByte);
IppiSize srcImgSize = {_width, _height};
IppiSize dstImgSize = {N, M};
sts = ippiCopyConstBorder_32f_C1R(
_imgBuffer, _width * PIXEL_SIZE, srcImgSize,
src, N * PIXEL_SIZE, dstImgSize,
0,0,0);
assert(sts ==ippStsNoErr);
sts = ippiFFTInitAlloc_R_32f(&spec, n , m, IPP_FFT_DIV_BY_SQRTN, ippAlgHintAccurate);
assert(sts ==ippStsNoErr);
sts = ippiFFTFwd_RToPack_32f_C1R(src, N*PIXEL_SIZE, dst, N*PIXEL_SIZE, spec, 0);
assert(sts ==ippStsNoErr);
sts = ippiMagnitudePack_32f_C1R(dst, N*PIXEL_SIZE, mag, N*PIXEL_SIZE, dstImgSize);
assert (sts ==ippStsNoErr);
newImg = new IPPGrayImage(N , M);
if (fftShift)
{
#pragma omp sections
{
#pragma omp section
{
for (unsigned int y = 0 ; y < M/2; y++)
{
for (unsigned int x = 0 ; x < N/2; x++)
{
newImg->_imgBuffer[x+ y *N] = mag[x + N/2 + (y + M/2) * N];
}
}
}
#pragma omp section
{
for (unsigned int y = 0 ; y < M/2; y++)
{
for (unsigned int x = N/2 ; x < N; x++)
{
newImg->_imgBuffer[x+ y *N] = mag[x - N/2 + (y + M/2) * N];
}
}
}
#pragma omp section
{
for (unsigned int y = M/2 ; y < M; y++)
{
for (unsigned int x = 0 ; x < N/2; x++)
{
newImg->_imgBuffer[x+ y *N] = mag[x + N/2 + (y - M/2) * N];
}
}
}
#pragma omp section
{
for (unsigned int y = M/2 ; y < M; y++)
{
for (unsigned int x = N/2 ; x < N; x++)
{
newImg->_imgBuffer[x+ y *N] = mag[x - N/2 + (y - M/2) * N];
}
}
}
}
}
else
{
for (unsigned int y = 0; y< M; y++)
{
for (unsigned int x = 0; x <N; x++)
{
newImg->_imgBuffer[x+ y * N] = mag[x + y * N];
}
}
}
return newImg;
}
}
The above example showed only the FFT function, but virtually all IPP image routines can be accommodated using the wrapper image class above. Intel IPP utilizes many different data types (e.g. Ipp8u, Ipp16s, Ipp32f etc.), but to provide most of the flexibility and compatibility I chose to use only the 32 bit floating data type. For specific implementations, other data types can be used as well.
