#include “cv.h”
#include “highgui.h”
#include “ipp.h”
#include
#include

char name[] = “lena.jpg”;
void openWindow_8u( Ipp8u *img, IppiSize *size, int nChannels,char *name, int wait );
void closeWindow_8u( char *name );

int main()
{
IppStatus sts;
Ipp8u *ipprgb = NULL;
Ipp8u *ippgray = NULL;
Ipp8u *ippedge = NULL;
Ipp8u *buffer = NULL;
Ipp16s *dx, *dy;

IppiSize imgsize,roi;

Ipp32f low=8.0f, high =12.0f;
int size, size1;
IplImage *img = NULL;

int wait=0;
img = cvLoadImage( name, -1 );
imgsize.width = img->width;
imgsize.height = img->height;
roi.width = img->width;
roi.height = img->height;

ipprgb = ippsMalloc_8u( imgsize.width * imgsize.height * 3 );
ippgray = ippsMalloc_8u( imgsize.width * imgsize.height );
ippiCopy_8u_C3R((Ipp8u *) img->imageData, imgsize.width * 3, ipprgb, imgsize.width * 3, imgsize );
ippiRGBToGray_8u_C3C1R ( ipprgb, imgsize.width*3, ippgray, imgsize.width, imgsize );

double t = (double)cvGetTickCount();

sts = ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size);
sts = ippiFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1);
if(size<size1)size=size1;
ippiCannyGetSize(roi,&size1);
if (sizewidth;
sizeCv.height = size->height;
cvImg = cvCreateImage( sizeCv, IPL_DEPTH_8U, nChannels );
tmp = ippsMalloc_8u( size->width * size->height * nChannels );
ippiCopy_8u_C3R( img, size->width * nChannels,
tmp, size->width * nChannels, *size );
cvSetData( cvImg, (void *) tmp, sizeCv.width * nChannels );
cvNamedWindow( name, 1 );
cvShowImage( name, cvImg );
cvWaitKey( wait );
cvReleaseImage( &cvImg );
}
void closeWindow_8u( char *name )
{
cvDestroyWindow( name );
}

// size of our images
IppiSize imgsize,roi;

Ipp32f low=30.0f, high =100.0f;
int size, size1, srcStep, dxStep, dyStep, dstStep;
// pointers to our result images
Ipp8u *ippxyz = NULL, *ipphls = NULL, *ippluv = NULL;
IplImage* img = NULL; // new IplImage structure img

int i = 0, j = 0, wait=0;
img = cvLoadImage( name, -1 ); // load a BMP ipprgb image into img
imgsize.width = img->width; // size of IPP images is the same
imgsize.height = img->height; // as read image img
roi.width = img->width; // *********************
roi.height = img->height; // *********************
// memory allocation for rgb
ipprgb = ippsMalloc_8u( imgsize.width * imgsize.height * 3 );

// the pointer of our OpenCV data is our IPP image pointer
ippiCopy_8u_C3R((Ipp8u *) img->imageData, imgsize.width * 3, ipprgb, imgsize.width * 3, imgsize );

sts = ippiFilterSobelNegVertGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size);//*********************
sts = ippiFilterSobelHorizGetBufferSize_8u16s_C1R(roi, ippMskSize3x3, &size1);//***********************
if(size<size1)size=size1;//**********
ippiCannyGetSize(roi,&size1);//**************
if (size<size1) size=size1;//******************
buffer = ippsMalloc_8u(size);//*******************
dx = ippsMalloc_16s(size);//******
dy = ippsMalloc_16s(size);//********
dst = ippsMalloc_8u(size);//********
sts = ippiFilterSobelNegVertBorder_8u16s_C1R (ipprgb, (imgsize.width*3+2), dx, (imgsize.width+2)*2 ,roi, ippMskSize3x3, ippBorderRepl, 0, buffer);
sts = ippiFilterSobelHorizBorder_8u16s_C1R(ipprgb, (imgsize.width*3+2 ), dy, (imgsize.width+2 )*2 ,roi, ippMskSize3x3, ippBorderRepl, 0, buffer);
sts = ippiCanny_16s8u_C1R(dx,(imgsize.width+2)*2 , dy, (imgsize.width+2)*2 , dst, (imgsize.width), roi, low, high, buffer);
ippsFree(buffer);

openWindow_8u( dst, &roi, 1, "dest", 0 ); // display xyz image
openWindow_8u( ipprgb, &imgsize, 3, "rgb", 0 ); // display rgb image

cvWaitKey( wait ); // wait for key (==0) or wait milliseconds

closeWindow_8u( "dest" ); // close luv image
closeWindow_8u( "rgb" ); // close rgb image
ippsFree( ipprgb ); // memory release with IPP
ippsFree( dst ); // memory release with IPP
cvReleaseImage( &img ); // memory release with OpenCV
return( 0 );
}

thanks for help!

regards.

I think your reading and writing from IPP has an error.
While converting from a standard image file, you should use

imgCache[column + row * stepByte/sizeof(Ipp8u)] = (char) i;
instead of
imgCache[column + row * width] = (char) i;

The stebByte is a number of bytes between the horizontal lines (as allocated by ippiMalloc_8u_C1).
This number may or may not be equal to the width.(even though you specify height and width).

For the Ipp8u type, size(Ipp8u)=1, so the stepByte/sizeof(Ipp8u) is slightly redundant.

In my problem I used Ipp32f type so I had to use stepByte/sizeof(Ipp32f).
I used ippiMalloc_32f_C1(width,height, &stepByte); to allocate memory.
It turned out that stepByte/sizeof(Ipp32f) is slightly longer than actually image width.

I wonder why? Perhaps ippiMalloc allocates aligned memory for faster memory access, which
can be slightly larger than actual image. If anybody can comment on this, I’d appreciate!

Then when performing any operation,e.g. Sobel filter, you should use stepByte as a length
between lines, instead of width.

Any comments appreciated, thanks