API Quick Reference Guide

  • 2020
  • 09/30/2019
  • Public Content
Contents

Basic Classes

IwiSize

Stores the width and height of a rectangle.
class IwiSize: public ::IwiSize { public: // Default constructor. Sets values to zero IwiSize(); // One value template constructor. Sets size to the same value. Useful for simple initialization, e.g.: size = 0 template<typename T> IwiSize( T size // Size of a square rectangle ); // Constructor. Sets size to specified values IwiSize( IwSize _width, // Width of a rectangle IwSize _height // Height of a rectangle ); // Constructor from the IppiSize structure IwiSize( IppiSize size // IppiSize structure ); // Constructor from the C IwiSize structure IwiSize( ::IwiSize size // C IwiSize structure ); // Constructor from the IppiRect structure IwiSize( IppiRect rect // IppiRect structure ); // Constructor from the IwiRoi structure IwiSize( IwiRoi rect // IwiRoi structure ); // Sets size to specified values void Set( IwSize _width, // Width of a rectangle IwSize _height // Height of a rectangle ); // Retrns size of an area covered by IwiSize inline IwSize Area() const; // IwiSize to IppiSize cast operator inline operator IppiSize() const; };

IwiPoint

Stores the geometric position of a point.
class IwiPoint: public ::IwiPoint { public: // Default constructor. Sets values to zero IwiPoint(); // One value template constructor. Sets position to the same value. Useful for simple initialization, e.g.: point = 0 template<typename T> IwiPoint( T point // Position of point ); // Constructor. Sets position to specified values IwiPoint( IwSize _x, // X coordinate of a point IwSize _y // Y coordinate of a point ); // Constructor from the IppiPoint structure IwiPoint( IppiPoint point // IppiPoint structure ); // Constructor from the IppiPointL structure IwiPoint( IppiPointL point // IppiPointL structure ); // Constructor from the IppiRect structure IwiPoint( IppiRect rect // IppiRect structure ); // Constructor from the C IwiRoi structure IwiPoint( ::IwiRoi rect // C IwiRoi structure ); // Sets position to specified values void Set( IwSize _x, // X coordinate of point IwSize _y // Y coordinate of point ); // IwiPoint to IppiPoint cast operator inline operator IppiPoint() const; };

IwiRect

Stores the geometric position and size of a rectangle.
class IwiRoi: public ::IwiRoi { public: // Default constructor. Sets values to zero IwiRoi(); // One value template constructor. Sets position to zero and size to the same value. Useful for simple initialization, e.g.: rect = 0 template<typename T> IwiRoi( T size // Size of a rectangle ); // Constructor. Sets a rectangle to specified values IwiRoi( IwSize _x, // X coordinate of a rectangle IwSize _y, // Y coordinate of rectangle IwSize _width, // Width of a rectangle IwSize _height // Height of a rectangle ); // Constructor from the IppiSize structure. Sets position to 0 and size to the IppiSize value IwiRoi( IppiSize size ); // Constructor from C IwiSize structure. Sets position to 0 and size to the IwiSize value IwiRoi( ::IwiSize size ); // Constructor from the IwiSize class. Sets position to 0 and size to the IwiSize value IwiRoi( IwiSize size ); // Constructor from the IppiRect class IwiRoi( IppiRect rect ); // Constructor from the C IwiRoi structure IwiRoi( ::IwiRoi rect ); // Sets rectangle to specified values void Set( IwSize _x, // X coordinate of a rectangle IwSize _y, // Y coordinate of a rectangle IwSize _width, // Width of a rectangle IwSize _height // Height of a rectangle ); // Returns size of an area covered by IwiRoi inline IwSize Area() const; // IwiRoi to the IwiPoint cast operator inline operator IwiPoint() const; // IwiRoi to the IwiSize cast operator inline operator IwiSize() const; // IwiRoi to the IppiPoint cast operator inline operator IppiPoint() const; // IwiRoi to the IppiSize cast operator inline operator IppiSize() const; // IwiRoi to the IppiPointL cast operator inline operator IppiPointL() const; // IwiRoi to the C IwiSize cast operator inline operator ::IwiSize() const; };

IwiBorderType

Stores the border extrapolation type and the border value for a constant border.
class IwiBorderType { public: // Default constructor IwiBorderType(); // Default constructor with the border type IwiBorderType(::IwiBorderType borderType); // Constructor for borders combination IwiBorderType(int borderType); // Default constructor with border type and value IwiBorderType(::IwiBorderType borderType, IwValueFloat value); // Sets new border type without affecting flags inline void SetType(IwiBorderType type); // Sets new border flags without affecting the type inline void SetFlags(int flags); // Returns border flags without type inline int StripType() const; // Returns border type without flags inline IwiBorderType StripFlags() const; // IwiBorderType to ::IwiBorderType cast operator inline operator ::IwiBorderType() const; // IwiBorderType to ::IwiBorderType* cast operator inline operator ::IwiBorderType*(); // IwiBorderType to Ipp64f* cast operator inline operator Ipp64f* () const; // Compares border type bool operator==(const ::IwiBorderType& rhs) const; bool operator!=(const ::IwiBorderType& rhs) const; bool operator!() const; // Computes logical OR for border type. This affects only flags part of the variable inline IwiBorderType& operator|=(const int &rhs); inline IwiBorderType operator|(const int &rhs) const; inline IwiBorderType& operator|=(const IwiBorderType &rhs); inline IwiBorderType operator|(const IwiBorderType &rhs) const; inline IwiBorderType& operator|=(const IppiBorderType &rhs); inline IwiBorderType operator|(const IppiBorderType &rhs) const; // Computes logical AND for border type. This affects only flags part of the variable inline IwiBorderType& operator&=(const int &rhs); inline IwiBorderType operator&(const int &rhs) const; inline IwiBorderType& operator&=(const IwiBorderType &rhs); inline IwiBorderType operator&(const IwiBorderType &rhs) const; inline IwiBorderType& operator&=(const IppiBorderType &rhs); inline IwiBorderType operator&(const IppiBorderType &rhs) const; ::IwiBorderType m_type; IwValueFloat m_value; };

IwiBorderSize

Stores border size data.
class IwiBorderSize: public ::IwiBorderSize { public: // Default constructor. Sets values to zero IwiBorderSize(); // One value template constructor. Sets border to the same value. Useful for simple initialization, e.g.: border = 0 template<typename T> IwiBorderSize( T border // Position of point ); // Constructor. Sets border to the specified values IwiBorderSize( IwSize _left, // Size of border to the left IwSize _top, // Size of border to the top IwSize _right, // Size of border to the right IwSize _bottom // Size of border to the bottom ); // Constructor from the C IwiBorderSize structure IwiBorderSize( ::IwiBorderSize border // IwiBorderSize structure ); // Constructor from the IppiBorderSize structure IwiBorderSize( IppiBorderSize border // IwiBorderSize structure ); // Constructor from the image ROI IwiBorderSize( IwiSize imageSize, // Size of the image IwiRoi imageRoi // Image ROI ); // Constructor from the mask size enumerator IwiBorderSize( IppiMaskSize mask // Processing mask size enumerator ); // Constructor from the kernel size IwiBorderSize( IwiSize kernel // Processing kernel size ); // Sets border to the specified values void Set( IwSize _left, // Size of border to the left IwSize _top, // Size of border to the top IwSize _right, // Size of border to the right IwSize _bottom // Size of border to the bottom ); // Sets border from the image ROI void Set( IwiSize imageSize, // Size of the image IwiRoi imageRoi // Image ROI ); // Returns true if all borders are zero bool Empty() const; // Returns border size which contains maximum values of two borders static IwiBorderSize Max(IwiBorderSize lhs, const IwiBorderSize &rhs); // Returns border size which contains minimum values of two borders static IwiBorderSize Min(IwiBorderSize lhs, const IwiBorderSize &rhs); // Adds constant to the border inline IwiBorderSize& operator+=(const int &rhs); inline IwiBorderSize operator+(const int &rhs) const; // Subtracts constant from the border inline IwiBorderSize& operator-=(const int &rhs); inline IwiBorderSize operator-(const int &rhs) const; // Multiplies the border by the constant inline IwiBorderSize& operator*=(const double &rhs); inline IwiBorderSize operator*(const double &rhs) const; // Divides the border by the constant inline IwiBorderSize& operator/=(const double &rhs); inline IwiBorderSize operator/(const double &rhs) const; // Adds border to the border inline IwiBorderSize& operator+=(const IwiBorderSize &rhs); inline IwiBorderSize operator+(const IwiBorderSize &rhs) const; // Subtracts border from the border inline IwiBorderSize& operator-=(const IwiBorderSize &rhs); inline IwiBorderSize operator-(const IwiBorderSize &rhs) const; };

iwiMaskToSize

Convert IppiMaskSize enumerator to actual IwiSize size.
IW_DECL_CPP(IwiSize) iwiMaskToSize( IppiMaskSize mask // Kernel or mask size enumerator )

iwiSizeToBorderSize

Convert kernel or mask size to border size.
IW_DECL_CPP(IwiBorderSize) iwiSizeToBorderSize( IwiSize kernelSize // Size of kernel as from iwiMaskToSize() or arbitrary )

IwiImage

Base class for IW image processing functions to store input and output data.
class IwiImage: public ::IwiImage { public: // Default constructor. Sets values to zero IwiImage(); // Copy constructor for a C++ object. Performs lazy copy of an internal image IwiImage( const IwiImage &image // Source image ); // Copy constructor for a C object. Initializes image structure with external buffer IwiImage( const ::IwiImage &image // Source image ); // Constructor with initialization. Initializes image structure with external buffer IwiImage( IwiSize size, // Image size, in pixels IppDataType dataType, // Image pixel type int channels, // Number of image channels IwiBorderSize inMemBorder = IwiBorderSize(), // Size of border around image or NULL if there is no border void *pBuffer = NULL, // Pointer to the external buffer image buffer IwSize step = 0 // Distance, in bytes, between the starting points of consecutive lines in the external buffer ); // Default destructor ~IwiImage(); // Copy operator for C++ object. Performs lazy copy of an internal image IwiImage& operator=(const IwiImage &image); // Copy operator for C object. Initializes image structure with external buffer IwiImage& operator=(const ::IwiImage &image); // Initializes image structure with external buffer // Returns: // ippStsNoErr no errors IppStatus Init( IwiSize size, // Image size, in pixels IppDataType dataType, // Image pixel type int channels, // Number of image channels IwiBorderSize inMemBorder = IwiBorderSize(), // Size of border around image or NULL if there is no border void *pBuffer = NULL, // Pointer to the external buffer image buffer IwSize step = 0 // Distance, in bytes, between the starting points of consecutive lines in the external buffer ); // Initializes image structure with external read-only buffer // Returns: // ippStsNoErr no errors IppStatus Init( IwiSize size, // Image size, in pixels IppDataType dataType, // Image pixel type int channels, // Number of image channels IwiBorderSize inMemBorder, // Size of border around image or NULL if there is no border const void *pBuffer, // Pointer to the external buffer image buffer IwSize step // Distance, in bytes, between the starting points of consecutive lines in the external buffer ); // Initializes image structure and allocates image data // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // Returns: // ippStsNoErr no errors IppStatus Alloc( IwiSize size, // Image size, in pixels IppDataType dataType, // Image pixel type int channels, // Number of image channels IwiBorderSize inMemBorder = IwiBorderSize() // Size of border around image or NULL if there is no border ); // Releases image data if it was allocated by IwiImage::Alloc // Returns: // ippStsNoErr no errors IppStatus Release(); // Returns pointer to the specified pixel position in the image buffer // Returns: // Pointer to the image data inline void* ptr( IwSize y = 0, // y shift, as rows IwSize x = 0, // x shift, as columns int ch = 0 // channels shift ) const; // Returns pointer to the specified pixel position in the read-only image buffer // Returns: // Pointer to the image data inline const void* ptrConst( IwSize y = 0, // y shift, as rows IwSize x = 0, // x shift, as columns int ch = 0 // channels shift ) const; // Applies ROI to the current image by adjusting size and starting point of the image. Can be applied recursively. // This function saturates ROIs which step outside of the image border. // If ROI has no intersection with the image then resulted image size will be 0x0 // Throws: // ippStsNullPtrErr unexpected NULL pointer // Returns: // ippStsNoErr no errors IppStatus RoiSet( ipp::IwiRoi roi // Roi rectangle of the required sub-image ); // Returns sub-image with size and starting point of the specified ROI // Returns: // IwiImage object of sub-image IwiImage GetRoiImage( ipp::IwiRoi roi // Roi rectangle of the required sub-image ) const; // Add border size to current inMem image border, making image size smaller. Resulted image cannot be smaller than 1x1 pixels // Throws: // ippStsSizeErr ROI size is illegal // ippStsNullPtrErr unexpected NULL pointer // Returns: // ippStsNoErr no errors inline IwiImage& operator+=(const IwiBorderSize &rhs); inline IwiImage operator+(const IwiBorderSize &rhs) const; // Subtracts border size from current inMem image border, making image size bigger. Resulted border cannot be lesser than 0 // Throws: // ippStsOutOfRangeErr ROI is out of image // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator-=(const IwiBorderSize &rhs); inline IwiImage operator-(const IwiBorderSize &rhs) const; // Set border size to current inMem image border, adjusting image size. Resulted image cannot be smaller than 1x1 pixels. // Throws: // ippStsSizeErr ROI size is illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator=(const IwiBorderSize &rhs); // Returns true if image has an assigned buffer inline bool Exists() const; // Returns true if image doesn't have an assigned buffer or its dimensions have zero size inline bool Empty() const; // Compares image structures and returns true if structure parameters are compatible, e.g. copy operation can be performed without reallocation bool Similar(const ipp::IwiImage& rhs) const; /**///////////////////////////////////////////////////////////////////////////// // Arithmetic operators ///////////////////////////////////////////////////////////////////////////// */ // Adds one image to another // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator+=(const IwiImage &rhs); // Adds constant to the image // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator+=(const IwValueFloat &rhs); // Subtracts one image from another // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator-=(const IwiImage &rhs); // Subtracts constant from the image // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator-=(const IwValueFloat &rhs); // Multiplies one image by another // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator*=(const IwiImage &rhs); // Multiplies the image by the constant // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator*=(const IwValueFloat &rhs); // Divides one image by another // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator/=(const IwiImage &rhs); // Divides the image by the constant // Throws: // ippStsDataTypeErr data type is illegal // ippStsNumChannelsErr channels value is illegal // ippStsSizeErr size fields values are illegal // ippStsNullPtrErr unexpected NULL pointer inline IwiImage& operator/=(const IwValueFloat &rhs); private: int *m_pRefCounter; // Shared reference counter for allocated memory };

IwiImageArray

IwiImageArray holds an array of IwiImages for processing.
class IwiImageArray { public: // Default constructor IwiImageArray( const IwiImage &image1 = IwiImage(), const IwiImage &image2 = IwiImage(), const IwiImage &image3 = IwiImage(), const IwiImage &image4 = IwiImage() ) { imArray[0] = image1; imArray[1] = image2; imArray[2] = image3; imArray[3] = image4; } // Copy operator for single IwiImage object const IwiImageArray& operator=(const IwiImage &image) { imArray[0] = image; return *this; } IwiImage imArray[4]; };

IwiRoi

Basic Tiling API
class IwiTile: public ::IwiTile { public: // Default constructor. IwiTile(); // Constructor with initialization. IwiTile( const ::IwiRoi &tileRoi // [in] Tile offset and size ); // Basic tiling initializer for the IwiTile structure. // Use this method to set up single function tiling or tiling for pipelines with border-less functions. // For functions which operate with different sizes for source and destination images use destination size as a base // for tile parameters. void SetRoi( const ::IwiRoi &tileRoi // [in] Tile offset and size ); // Assignment operator from C IwiRoi structure. IwiTile& operator=( const ::IwiRoi &tileRoi // [in] Tile offset and size ); /* ///////////////////////////////////////////////////////////////////////////// // Manual tiling control ///////////////////////////////////////////////////////////////////////////// */ // Returns border with proper ippBorderInMem flags for current tile position, image size and border size // Returns: // ippBorderInMem flags static IwiBorderType GetTileBorder( IwiRoi roi, // Tile position and size ::IwiBorderType border, // Border type IwiBorderSize borderSize, // Border size IwiSize srcImageSize // Source image size ); // Returns minimal acceptable tile size for the current border size and type // Returns: // Minimal tile size static IwiSize GetMinTileSize( ::IwiBorderType border, // Border type IwiBorderSize borderSize // Border size ); // Function corrects ROI position and size to prevent overlapping between filtering function border and image border in // case of border reconstruction. If image already has a right or a bottom border in memory and border type flags // ippBorderInMemRight or ippBorderInMemBottom were specified accordingly then no correction is required. // // C API descriptions has more details. // Returns: // Corrected ROI static IwiRoi CorrectBordersOverlap( IwiRoi tile, // [in] Tile position and size to be checked and corrected ::IwiBorderType border, // [in] Border type IwiBorderSize borderSize, // [in] Border size IwiSize srcImageSize // [in] Source image size ); };
Pipeline Tiling API
class IwiTilePipeline: public IwiTile { public: // Default constructor. IwiTilePipeline(); // Constructor with initialization for the root node. // Throws: // ippStsBadArgErr incorrect arg/param of the function // ippStsNullPtrErr unexpected NULL pointer IwiTilePipeline( IwiSize tileSizeMax, // [in] Maximum tile size for intermediate buffers size calculation IwiSize dstImageSize, // [in] Destination image size for current operation const IwiBorderType &borderType = IwiBorderType(), // [in] Border type for the current operation const IwiBorderSize &borderSize = IwiBorderSize(), // [in] Border size for the current operation const IwiTileTransform &transformStruct = IwiTileNoTransform() // [in] Initialized transform structure if operation performs geometric transformation ); // Constructor with initialization for the child node. // Throws: // ippStsBadArgErr incorrect arg/param of the function // ippStsNullPtrErr unexpected NULL pointer IwiTilePipeline( IwiTilePipeline &parent, // [in] IwiTile structure of previous operation const IwiBorderType &borderType = IwiBorderType(), // [in] Border type for the current operation const IwiBorderSize &borderSize = IwiBorderSize(), // [in] Border size for the current operation const IwiTileTransform &transformStruct = IwiTileNoTransform() // [in] Initialized transform structure if operation performs geometric transformation ) : IwiTile(); // Default destructor ~IwiTilePipeline(); // Pipeline tiling root node initializer for IwiTile structure. // This initializer should be used first and for IwiTile structure of the final operation. // Throws: // ippStsBadArgErr incorrect arg/param of the function // ippStsNullPtrErr unexpected NULL pointer // Returns: // ippStsNoErr no errors IppStatus Init( IwiSize tileSizeMax, // [in] Maximum tile size for intermediate buffers size calculation IwiSize dstImageSize, // [in] Destination image size for current operation const IwiBorderType &borderType = IwiBorderType(), // [in] Border type for the current operation const IwiBorderSize &borderSize = IwiBorderSize(), // [in] Border size for the current operation const IwiTileTransform &transform = IwiTileNoTransform() // [in] Initialized transform structure if operation performs geometric transformation ); // Pipeline tiling child node initializer for IwiTile structure. // This initializer should be called for any operation preceding the last operation in reverse order. // Throws: // ippStsBadArgErr incorrect arg/param of the function // ippStsNullPtrErr unexpected NULL pointer // Returns: // ippStsNoErr no errors IppStatus InitChild( IwiTilePipeline &parent, // [in] IwiTile structure of previous operation const IwiBorderType &borderType = IwiBorderType(), // [in] Border type for the current operation const IwiBorderSize &borderSize = IwiBorderSize(), // [in] Border size for the current operation const IwiTileTransform &transform = IwiTileNoTransform() // [in] Initialized transform structure if operation performs geometric transformation ); // Sets current tile rectangle for the pipeline to process // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // ippStsNullPtrErr unexpected NULL pointer // Returns: // ippStsNoErr no errors IppStatus SetTile( IwiRoi tileRoi // [in] Tile offset and size ); // Pipeline tiling intermediate buffer size getter // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // Returns: // Destination buffer size required by the current pipeline operation IwiSize GetDstBufferSize(); // Calculates actual border parameter with InMem flags for the current tile absolute and relative offsets and sizes // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // Returns: // Border with InMem flags actual for the current tile IwiBorderType GetTileBorder( ::IwiBorderType border // [in] Extrapolation algorithm for out of image pixels ); // This function builds border for the current tile source buffer. // This allows to feed function with InMem borders only thus reducing possiblity of borders conflicts on image boundary. // By default this function is not applied to the first image in the pipeline, only to intermediate buffers, but // it can be used manually to construct border for it too. // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // Returns: // ippStsNoErr no errors IppStatus BuildBorder( IwiImage &srcImage, // [in,out] Pointer to the source image for which to build border IwiBorderType &border // [in,out] Extrapolation algorithm for out of image pixels. Updated InMem flags will be returned here ); // Checks for image and buffer boundaries for the source buffer and limits tile rectangle // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // Returns: // Source ROI bounded to the buffer size IwiRoi GetBoundedSrcRoi(); // Checks for image and buffer boundaries for the destination buffer and limits tile rectangle // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // Returns: // Destination ROI bounded to the buffer size IwiRoi GetBoundedDstRoi(); // Returns minimal acceptable tile size for current pipeline // Throws: // ippStsContextMatchErr internal structure is not initialized or of invalid type // ippStsErr tile calculation error // Returns: // Minimal tile size allowed by the pipeline IwiSize GetMinTileSize(); private: // Disabled copy operator IwiTilePipeline& operator=(const IwiTilePipeline &); IwiTileTransform *pTransform; };

Product and Performance Information

1

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

Notice revision #20110804