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

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.