topic Quote:Fiona Z. (Intel) wrote: in Intel® Integrated Performance Primitives

Some confusion about converting IPL 1bit funciton to IPP

sun_c_ — Wed, 14 Sep 2016 06:06:04 GMT

My company still used old IPL (IPL_DEPTH_1U functions) , and let me change IPL 1bit function to IPP for build x64 software.

After used ippiBinToGray_1u8u_C1R------>ipp functions------>ippiGrayToBin_8u1u_C1R, I find the result are different with IPL.

So, I do a test and find some difference. I find old IPL 1 bit functions,gray to bin, convert 8 byte to 1 byte with the older"high bit to low bit",

as opposed to IPP's ippiGrayToBin_8u1u.

The test code is:

/////////////////////////////////////////////////////////code begin////////////////////////////////////////////////////////////////////

Ipp8u bitonalImage[8] = { 0 }; // for a 32x2 image
bitonalImage[0] = 1;     // 00000001 high bit->low bit;
bitonalImage[1] = 2;    // 00000010
bitonalImage[2] = 4;    // 00000100
bitonalImage[3] = 8;    // 00001000
bitonalImage[4] = 16; // 00010000
bitonalImage[5] = 32; // 00100000
bitonalImage[6] = 64; // 01000000
bitonalImage[7] = 128; // 10000000

Ipp8u grayImageIPP[64] = { 0 };

ippiBinToGray_1u8u_C1R(bitonalImage, 4, 0, grayImageIPP, 32, { 32, 2 }, 0, 255);

Ipp8u bitonalImageIPP[8] = { 0 };

ippiGrayToBin_8u1u_C1R(grayImageIPP, 32, bitonalImageIPP, 4, 0, { 32, 2 }, 1);

IplImage *srcImage = iplCreateImageHeader(
  1,      // number of channels
  0,      // no alpha channel
  IPL_DEPTH_8U,   // data of byte type
  "Gray",     // color model
  "Gray",     // color order
  IPL_DATA_ORDER_PIXEL, // channel arrangement
  IPL_ORIGIN_TL,   // top left orientation
  IPL_ALIGN_DWORD,  // 4 bytes align
  32,    // image width
  2,    // image height
  NULL,     // no ROI
  NULL,     // no mask ROI
  NULL,     // no image ID
  NULL);     // not tiled

if (NULL == srcImage)
return 0;

srcImage->imageData = (char *)grayImageIPP;

Ipp8u bitonalImageIPL[8] = { 0 };
IplImage *dstImage = iplCreateImageHeader(
  1,      // number of channels
  0,      // no alpha channel
  IPL_DEPTH_1U,   // data of byte type
  "Gray",     // color model
  "Gray",     // color order
  IPL_DATA_ORDER_PIXEL, // channel arrangement
  IPL_ORIGIN_TL,   // top left orientation
  IPL_ALIGN_DWORD,  // 4 bytes align
  32,    // image width
  2,    // image height
  NULL,     // no ROI
  NULL,     // no mask ROI
  NULL,     // no image ID
  NULL);     // not tiled

if (NULL == dstImage)
return 0;

dstImage->imageData = (char *)bitonalImageIPL;
iplThreshold(srcImage, dstImage, 1);

iplDeallocate(srcImage, IPL_IMAGE_HEADER);
iplDeallocate(dstImage, IPL_IMAGE_HEADER);

/////////////////////////////////////////////////////code end////////////////////////////////////////////////////////////////

The result of bitonalImageIPP is:

bitonalImage[0] = 1;   // 00000001 high bit->low bit;
bitonalImage[1] = 2;   // 00000010
bitonalImage[2] = 4;   // 00000100
bitonalImage[3] = 8;   // 00001000
bitonalImage[4] = 16; // 00010000
bitonalImage[5] = 32; // 00100000
bitonalImage[6] = 64; // 01000000
bitonalImage[7] = 128; // 10000000
As the same with the bitonalImage.

The result of bitonalImageIPL is:

bitonalImageIPL[0] = 128; // 10000000 high bit------>low bit
bitonalImageIPL[1] = 64; // 01000000
bitonalImageIPL[2] = 32; // 00100000
bitonalImageIPL[3] = 16; // 00010000
bitonalImageIPL[4] = 8;   // 00001000
bitonalImageIPL[5] = 4;   // 00000100
bitonalImageIPL[6] = 2;   // 00000010
bitonalImageIPL[7] = 1;   // 00000001

Are all IPL 1 bit functions having these difference?

I convered IPL 1bit funciton

sun_c_ — Sun, 18 Sep 2016 08:18:10 GMT

I convered IPL 1bit funciton to IPP successful.

All th IPL 1 bit funcitions(Intel® Image Processing Library 2.5 [IPL2.5W-B9] ) have that difference.

Hi sun,

Zhen_Z_Intel — Sun, 18 Sep 2016 08:46:53 GMT

Hi sun,

Here's an example of mapping IPL function to IPP functions, you could refer to take a try. I am afraid the functionality of using iplThreshold is not equals to IPP function ippiGrayToBin_8u1u_C1R. The iplThreshold function could be implemented by ippiSet_8u_C1R, ippiThreshold_LTVal_8u_C1R and ippiThreshold_GTVal_8u_C1IR.

Please learn more info from: https://software.intel.com/sites/default/files/m/6/7/d/1/6/876-ipl-ipp.pdf
I also attached sample code to you that you could access in download center for IPP 5.3.4 version.

Best regards,
Fiona

Quote:Fiona Z. (Intel) wrote:

sun_c_ — Mon, 19 Sep 2016 02:52:00 GMT

Fiona Z. (Intel) wrote:

Hi sun,

Here's an example of mapping IPL function to IPP functions, you could refer to take a try. I am afraid the functionality of using iplThreshold is not equals to IPP function ippiGrayToBin_8u1u_C1R. The iplThreshold function could be implemented by ippiSet_8u_C1R, ippiThreshold_LTVal_8u_C1R and ippiThreshold_GTVal_8u_C1IR.

Please learn more info from: https://software.intel.com/sites/default/files/m/6/7/d/1/6/876-ipl-ipp.pdf
I also attached sample code to you that you could access in download center for IPP 5.3.4 version.

Best regards,
Fiona

Hi,Fiona.

I have seen the ipl-ipp.pdf and souce of IPL implements by IPP 5.3.4 in image processing sample.seems it does not support 1 bit function.

Part of souce code of IPLImage:

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

depth = (iplImage->depth&IPL_DEPTH_MASK);     /* absolute depth value    */
      /* +sag */
      if( 1 == depth ) depth = 8;
      /* -sag */

alignBit = (align<<3)-1;
maskBit = ~alignBit;

      if( IPL_DATA_ORDER_PIXEL == dataOrder ) {
         iplImage->widthStep = ((width*depth*nChannels+alignBit)&maskBit)>>3; // For IPL_DEPTH_1U Image the depth should be 1, not 8
         iplImage->imageSize = iplImage->widthStep*height;
      } else {
         iplImage->widthStep = ((width*depth+alignBit)&maskBit)>>3;
         iplImage->imageSize = iplImage->widthStep*height*nChannels;
      }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

In my case, I use iplThreshold (8bit gray Image(src),1bit image(dst),1), In the process 8bit src to 1 bit dst, it must have GraytoBin funciton, so I use ippiGrayToBin_8u1u_C1R instead.

While ,I use ippiThreshold_LTVal_8u_C1R and ippiThreshold_GTVal_8u_C1IR first and then use ippiGrayToBin_8u1u_C1R.The result are the same.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ipp8u bitonalImage[8] = { 0 }; // for a 32x2 image
bitonalImage[0] = 1;   // 00000001 high bit->low bit;
bitonalImage[1] = 2;   // 00000010
bitonalImage[2] = 4;   // 00000100
bitonalImage[3] = 8;   // 00001000
bitonalImage[4] = 16; // 00010000
bitonalImage[5] = 32; // 00100000
bitonalImage[6] = 64; // 01000000
bitonalImage[7] = 128; // 10000000

Ipp8u grayImageIPP[64] = { 0 };
Ipp8u grayImageIPPTemp[64] = { 0 };

ippiBinToGray_1u8u_C1R(bitonalImage, 4, 0, grayImageIPP, 32, { 32, 2 }, 0, 255);

Ipp8u bitonalImageIPP[8] = { 0 };

Ipp8u thresholdLT = (Ipp8u)1, thresholdGT = 0;
Ipp8u valueLT = 0, valueGT = (Ipp8u)IPP_MAX_8U;
ippiThreshold_LTVal_8u_C1R(grayImageIPP, 32, grayImageIPPTemp, 32, {32,2},
thresholdLT, valueLT);
ippiThreshold_GTVal_8u_C1IR(grayImageIPPTemp, 32, {32,2}, thresholdGT, valueGT);

ippiGrayToBin_8u1u_C1R(grayImageIPPTemp, 32, bitonalImageIPP, 4, 0, { 32, 2 }, 1);

The result of bitonalImageIPP is:

No difference.

Hi sun,

Zhen_Z_Intel — Tue, 20 Sep 2016 03:39:55 GMT

Hi sun,

We do not support for 1u type, I am afraid some Convert & Scale function could not binarize image. You probable need to use ippiReduceBits function. But in any case image step parameter in IPP is always measured in bytes, not in pixels nor elements.

{...
	ippiBinToGray_1u8u_C1R(bitonalImage, 4, 0, grayImageIPP, 32, { 32, 2 }, 0, 255);
	...
	ippiReduceBits_8u1u_C1R(grayImageIPP, 32, bitonalImageIPP, 4, 0, {32,2}, 0, 0, ippDitherNone, 1, 0);
	for(int i=0;i<sizeof(bitonalImageIPP);i++)
	{
		std::bitset<8> x(bitonalImageIPP);
		std::cout<<"bitonalImageIPP["<<i<<"]="<<x<<"\n";
	}
...}

Best regards,
Fiona

Quote:Fiona Z. (Intel) wrote:

sun_c_ — Tue, 20 Sep 2016 05:25:00 GMT

Fiona Z. (Intel) wrote:

Hi sun,

We do not support for 1u type, I am afraid some Convert & Scale function could not binarize image. You probable need to use ippiReduceBits function. But in any case image step parameter in IPP is always measured in bytes, not in pixels nor elements.
{...
	ippiBinToGray_1u8u_C1R(bitonalImage, 4, 0, grayImageIPP, 32, { 32, 2 }, 0, 255);
	...
	ippiReduceBits_8u1u_C1R(grayImageIPP, 32, bitonalImageIPP, 4, 0, {32,2}, 0, 0, ippDitherNone, 1, 0);
	for(int i=0;i<sizeof(bitonalImageIPP);i++)
	{
		std::bitset<8> x(bitonalImageIPP);
		std::cout<<"bitonalImageIPP["<<i<<"]="<<x<<"\n";
	}
...}
Best regards,
Fiona

Thanks, ippiReduceBits_8u1u_C1R is OK, will check the diffirernce with ippiGrayToBin_8u1u_C1R