Intel IPP Integration Wrappers Developer Guide and Reference

ID 751823
Date 1/18/2023
Public
Document Table of 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;
};

Convert IppiMaskSize enumerator to actual IwiSize size.

IW_DECL_CPP(IwiSize) iwiMaskToSize(
    IppiMaskSize mask    // Kernel or mask size enumerator
)

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 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;
};