Visible to Intel only — GUID: GUID-C2D75DB6-B16D-408F-BA59-BD0A9F074AC7
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;
};
Parent topic: Image Processing