NAME
ilImage - base class for the ImageVision Library toolkit
INHERITS FROM
ilLink
HEADER FILE
#include <il/ilImage.h>
CLASS DESCRIPTION
ilImage is the base class for the ImageVision Library (IL) toolkit. All
IL image objects are derived from ilImage either directly or indirectly.
The ilImage base class abstracts the general concept of an image by
defining variables and functions common to all images. It defines image
parameters (e.g. size, data type), and provides access functions to query
and set them. It also provides functions to access image data. ilImage is
derived from ilLink so that images can be chained together, which allows
the output of one image operation to become the input to another.
ilImage thus defines a common Application Program Interface (API). This
means that, for example, image data can be obtained from any image object
by calling getTile().
Using ilImage
ilImage is intended to be used as a base class for deriving new types of
images. Because most of the image data access virtuals return the status
ilUNSUPPORTED, it is not useful to directly construct an ilImage object.
However, a pointer to an ilImage can be declared to reference an image of
unknown derivation.
The ilImage class provides protected and public member functions. The
protected functions provide convenient services to derived classes,
(particularly for initializing and resetting an image's attributes) while
the public functions form the API.
Querying and Setting Image Attributes
The size of an image in the x, y, z and c dimensions can be retrieved
using the function, getSize(). In a typical 2-D image, z is 1 and the
number of channels (c) per pixel is 3 (red, green and blue, for example).
The image size is stored in a data object called iflSize. The size of the
image can be set using the function, setSize().
The data type of the pixel channels can be retrieved using the function,
getDataType(). It returns an enumerated type called iflDataType, which
has members iflChar, iflUChar, iflFloat, and so forth. The data type can
be set by passing an iflDataType to the member function, setDataType().
The pixel channel order can be queried and set using getOrder() and
setOrder(), respectively. This information is indicated with the
enumerated type, iflOrder. iflOrder has members iflInterleaved,
iflSequential and iflSeparate, which indicate how the pixel components
are stored.
The orientation of an image can be queried and set using getOrientation()
and setOrientation() respectively. The orientation of an image is
specified using the enumerated type, iflOrientation. An orientation of
iflLowerLeftOrigin, for example, means that the origin of the image is
displayed in the lower left corner of the window.
The color model of an image can be queried and set using getColorModel()
and setColorModel() functions, respectively. The color model can be one
of the enumerated iflColorModel types.
A color map can also be associated with an ilImage. The color map can be
queried and set using the getColormap() and setColormap() functions,
respectively. The color map is defined by using an iflColormap object.
In general, for each image attribute there are access functions to set or
get the associated member variables in class ilImage.
Accessing Image Data
Image data can be accessed as pixels or as a rectangular region of
arbitrary size called a tile. Both 2-D and 3-D tile access functions are
provided.
The virtual access functions present a queued request model, which allows
an application to issue non-blocking requests for image I/O and later
inquire the status and/or wait for the operation to complete. The queued
model also provides derived classes with the "hooks" needed to
automatically distribute operations across multiple processors. These
queued functions are distinguished by the prefix 'q' on the function
name. For convenience, there are access functions which do wait for
their operation to complete, hiding the details of the queued model.
There are several different functions to read image data, all based on
qGetSubTile3D(). Similarly, there are several different functions to
write image data based on qSetSubTile3D(). Two fast-paths called
qCopyTileCfg() and qCopyTile3D() are available for copying a tile from
another ilImage.
When calling the base functions listed above, the caller must specify the
origin (x, y, z) and size (nx, ny, nz) of the desired tile. For 2-D
operations, z is set to 0 and nz is set to 1. For pixel operations, nx,
ny and nz are set to 1. An object called iflConfig, is used to specify
the configuration (that is, data type, order, number of channels and so
forth) of the desired tile. If required, the image data is converted to
a specified configuration while getting a tile, or converted from a
specified configuration to that of the image while setting a tile.
Chaining Images
Images can be chained together, allowing the output from one image
operation to become the input to another image operation without an
intermediate buffer. Each image can have multiple parents (inputs) and
multiple children (outputs). In addition to the functions inherited from
ilLink, several functions such as setInput(), addInput() and
removeInput() are also provided to manage the input list. Inputs are
usually added to an image in its constructor, although the input list can
be manipulated after the image has been created.
The power of chaining is fully realized with image operators (see the
ilOpImg man page), which can be chained together to perform complex image
processing operations. Chaining also allows a single image to be an
input to multiple output operators.
Deriving New Classes from ilImage
Most new image classes should derive from ilMemCacheImg, ilOpImg,
ilPolyadicImg, or a derivative (see the relevant man page). Some special
cases may require deriving directly from ilImage.
When a new class is derived from ilImage, it should redefine some of the
inherited virtual functions. It must define at least one of
qGetSubTile3D() and qSetSubTile3D(). The virtual function qCopyTileCfg()
should also be defined to provide a fast-path for copying a tile of image
data from one ilImage to another; the standard version stages the copy
through a temporary buffer, halving the potential performance.
qGetSubTile3D() Retrieves the specified tile of data in the given
configuration from the image's input source.
qSetSubTile3D() Stores the specified tile of data in the given
configuration to the image's output destination.
qCopyTileCfg() Copies the specified tile of data from another
ilImage to this image.
qFillTile3D() Fills a tile of the image with a constant pixel
value. qFillTileRGB() Also fills a tile, with the
fill value specified as a red, green, blue
triplet.
In derived classes of ilImage, image attributes can be set using any of
the access functions after the creation of the image. When image
attributes are changed, some parameters that depend on these attributes
may have to be recomputed, typically in a reset operation. ilImage uses
the ilLink flags and functions to manage and query the attributes' states
and provides a default implementation for the ilLink virtual function,
reset(). If a derived class must be notified when the image attributes
change, it will need to re-define the reset() virtual; for proper
operation, the derived reset must call the base class reset. Operator
images (derived from ilOpImg) cannot re-define reset; they can define a
new resetOp() instead. For more information on operator images and
resetOp, see the man page for ilOpImg.
CLASS MEMBER FUNCTION SUMMARY
Constructor
ilImage()
ilImage(iflSize &sz)
Manipulating image inputs
int getNumInputs()
void setNumInputs(int num) protected
ilStatus setInput(ilImage* inimg, int idx = 0)
ilStatus addInput(ilImage* inimg)
ilImage* getInput(int idx = 0)
ilStatus removeInput(int idx = 0)
ilImage* getDirectInput(int idx = 0)
Storing and retrieving 3D image data
ilStatus getSubTile3D(int x, int y, int z, int nx, int ny,
int nz, void* data, int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL)
virtual ilStatus qGetSubTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, void*& data,
int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL)
ilStatus setSubTile3D(int x, int y, int z, int nx, int ny,
int nz, const void* data, int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL)
virtual ilStatus qSetSubTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz,
const void* data, int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL)
ilStatus copyTileCfg(int x, int y, int z, int nx, int ny,
int nz, ilImage* other, int ox, int oy, int oz,
const ilConfig* config=NULL)
virtual ilStatus qCopyTileCfg(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz,
ilImage* other, int ox, int oy, int oz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL)
ilStatus fillTile3D(int x, int y, int z, int nx, int ny, int nz,
const void* data, const ilConfig* config=NULL,
const iflTile2Dint* fillMask=NULL)
virtual ilStatus qFillTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz,
const void* data, const ilConfig* config=NULL,
const iflTile3Dint* fillMask=NULL,
ilMpManager** pMgr=NULL)
ilStatus fillTileRGB(int x, int y, int z, int nx, int ny, int nz,
float red, float green, float blue,
const iflTile3Dint* fillMask=NULL,
iflOrientation orientation=iflOrientation(0));
virtual ilStatus qFillTileRGB(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz,
float red, float green, float blue,
const iflTile3Dint* fillMask=NULL,
iflOrientation orientation=iflOrientation(0),
ilMpManager** pMgr=NULL)
ilStatus copyTile3D(int x, int y, int z, int nx, int ny, int nz,
ilImage* other, int ox, int oy, int oz,
int* chanList=NULL)
ilStatus copy(ilImage* from)
ilStatus getTile3D(int x, int y, int z, int nx, int ny,
int nz, void* data, const ilConfig* config=NULL)
ilStatus qGetTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, void*& data,
const ilConfig* config=NULL, ilMpManager** pMgr=NULL)
ilStatus setTile3D(int x, int y, int z, int nx, int ny, int nz,
const void* data, const ilConfig* config=NULL)
ilStatus getPixel3D(int x, int y, int z, iflPixel& pix)
ilStatus setPixel3D(int x, int y, int z, iflPixel& pix)
Storing and retrieving 2-D image data
ilStatus getTile(int x, int y, int nx, int ny, void* data,
const ilConfig* config=NULL)
ilStatus setTile(int x, int y, int nx, int ny, const void* data,
const ilConfig* config=NULL)
ilStatus getSubTile(int x, int y, int nx, int ny, void* data,
int dx, int dy, int dnx, int dny,
const ilConfig* config=NULL)
ilStatus setSubTile(int x, int y, int nx, int ny, const void* data,
int dx, int dy, int dnx, int dny,
const ilConfig* config=NULL)
ilStatus copyTile(int x, int y, int nx, int ny, ilImage* other,
int ox, int oy, int* chanList=NULL)
ilStatus fillTile(int x, int y, int nx, int ny, const void* data,
const ilConfig* config=NULL, const iflTile2Dint* fillMask=NULL)
ilStatus getPixel(int x, int y, iflPixel& pix)
ilStatus setPixel(int x, int y, iflPixel& pix)
Data access support
ilStatus clipTile(int &x, int &y, int &z, int &nx, int &ny, int &nz,
int includeBorder=FALSE)
ilStatus clipTile(iflTile3Dint& t, int includeBorder=FALSE)
ilStatus clipTile(float &x, float &y, float &z,
float &nx, float &ny,
float &nz, int includeBorder=FALSE)
ilStatus clipTile(iflTile3Dfloat& t, int includeBorder=FALSE)
ilStatus configureRetainedCache(const iflTile3Dint& tile,
int c = 0, int nc = -1,
int* chans = NULL, float minCacheBudget = .05,
float maxCacheBudget = 1,
size_t* retainedFileSize = NULL)
ilImageTile* getInputTileRequirement(const iflTile3Dint& tile,
int c, int nc,
int* chans, int& pageSetCount)
void setTileRequirementFunction(ilTileRequirementFuncPtr func) protected
void getStrides(int& xs, int& ys, int& zs, int& cs, int nx=0,
int ny=0, int nz=0, int nc=0, iflOrder ord=iflOrder(0))
int outOfBound(int x, int y) protected
int outOfBound(int x, int y, int z) protected
Querying about image properties
void getDimensions(iflSize& size)
int getXsize()
int getYsize()
int getZsize()
int getCsize()
int getNumChans()
int getWidth()
int getHeight()
void getSize(iflSize& size)
const iflSize& getSize() protected
iflDataType getDataType()
iflOrder getOrder()
iflOrientation getOrientation()
void getConfig(ilConfig* cfg)
iflColorModel getColorModel()
iflCompression getCompression()
const iflPixel& pixel getFill()
const void* getFillData()
double getFillValue(int c=0)
ilStatus getColormap(iflColormap& cmap)
const iflColormap* getColormap()
int getMaxColormapLevels()
size_t getPageSize()
size_t getPageSize(int& nx, int& ny)
size_t getPageSize(int& nx, int& ny, int& nz, int& nc)
size_t getPageSize(iflSize& pageSize)
size_t getPageSize(iflSize& pageSize, iflOrientation ori)
size_t getPageDimensions()
int getPageSizeX()
int getPageSizeY()
int getPageSizeZ()
int getPageSizeC()
int getPageSizePix()
int getPageSizeVal()
int isPartialPage(int x, int y, int z, int c) protected
int isValidPage(int x, int y, int z, int c) protected
virtual int hasPages()
void getPageDelta(int& nx, int& ny, int& nz, int& nc)
void getPageDelta(iflXYZCint& delta)
void getPageBorder(iflXYZint& border)
const iflXYZint& getPageBorder()
int getPageBorderX()
int getPageBorderY()
int getPageBorderZ()
void getPageCounts(int& nx, int& ny, int& nz, int& nc)
void getPageIndices(int x, int y, int z, int c, int& ix,
int& iy, int& iz, int& ic)
ilStatus getPageOrigin(int x, int y, int z, int c,
int& px, int& py, int& pz, int& pc)
ilStatus getPageOrigin(const iflXYZCint& pos, iflXYZCint& org)
int getPageOriginX(int x)
int getPageOriginY(int y)
int getPageOriginZ(int z)
int getPageOriginC(int c)
int getPriority()
int hasPageBorder()
int isIntegral()
int isSigned()
int isWritable()
Setting image properties
ilStatus setColorModel(iflColorModel c)
void initColorModel(int noAlpha=FALSE) protected
ilStatus setOrientation(iflOrientation spc)
ilStatus setDataType(iflDataType dtype)
ilStatus setCompression(iflCompression c)
ilStatus setFill(const iflPixel& pixel)
ilStatus setFillValue(double val, int c=0)
ilStatus setFillRGB(float red, float green, float blue)
ilStatus setSize(const iflSize& size)
ilStatus setSize(int nx, int ny)
ilStatus setXsize(int nx)
ilStatus setYsize(int ny)
ilStatus setZsize(int nc)
ilStatus setCsize(int nc)
ilStatus setNumChans(int nc)
ilStatus setOrder(iflOrder order)
void initPageSize(const iflSize& pageSize) protected
ilStatus setPageSize(const iflSize& pageSize)
ilStatus setPageSize(int nx, int ny, int nz, int nc)
ilStatus setPageSize(int nx, int ny)
ilStatus setPageSizeZ(int nz)
ilStatus setPageSizeC(int nc)
ilStatus setPageBorder(const iflXYZint& border)
ilStatus setPageBorder(int nx, int ny, int nz=0)
ilStatus setColormap(const iflColormap& cmap)
void setMaxColormapLevels(int maxLevels)
void setPriority(int pri)
void setWritable(int enable=TRUE) protected
int inherit(int typeMask=0, int orderMask=0, int allowDiffColorModels=FALSE)protected
void checkValidType(int typeMask, int wantSigned=FALSE) protected
void checkValidOrder(int orderMask) protected
Querying about minimum and maximum pixel
double getMinValue()
double getMaxValue()
Setting minimum and maximum pixel values
void initMinMax(int force=FALSE) protected
ilStatus setMinValue(double val)
ilStatus setMaxValue(double val)
Managing the Image's state
virtual void reset() protected
ilLockedTile* lockTile3D(int x, int y, int z,
int nx, int ny, int nz,
const ilConfig* config=NULL,
int mode=ilLMread)
ilLockedTile* lockTile(int x, int y, int nx, int ny,
const ilConfig* config=NULL, int mode=ilLMread)
ilStatus lockPageSet(ilLockRequest* set, int mode=ilLMread,
int count=1)
virtual ilStatus qLockPageSet(ilMpNode* parent, ilLockRequest* set,
int mode=ilLMread, int count=1,
ilMpManager** pMgr=NULL,
ilCallback* perPageCb=NULL)
virtual void unlockPageSet(ilLockRequest* set, int count=1)
ilPage* lockPage(int x, int y, int z, int c, ilStatus& status,
int mode=ilLMread)
void unlockPage(ilPage* page)
ilLockRequest* getLockTileSet(int& count, const iflTile3Dint& tile,
const ilConfig* config=NULL,
int includeBorder=FALSE)
Orientation support
void mapTile(iflOrientation fromOri, iflTile2Dint& tile,
iflOrientation workOri=iflOrientation(0))
void mapTile(iflOrientation fromOri, iflTile2Dfloat& tile,
iflOrientation workOri=iflOrientation(0))
void mapTile(iflOrientation fromOri, iflTile2Dint &tile, iflFlip &flip,
int &transXY, iflOrientation workOri=iflOrientation(0))
void mapXY(iflOrientation fromOri, int& x, int& y,
iflOrientation workOri=iflOrientation(0))
void mapXY(iflOrientation fromOri, float& x, float& y,
iflOrientation workOri=iflOrientation(0))
void mapXYSign(iflOrientation fromOri, float& x, float& y,
iflOrientation workOri=iflOrientation(0))
void mapSize(iflOrientation fromOri, int& x, int& y,
iflOrientation workOri=iflOrientation(0))
iflOrientation mapOrientation(int flipX, int flipY, int transXY=FALSE)
iflOrientation mapFlipTrans(iflOrientation fromOrientation,
iflFlip& flip, int& transXY,
iflOrientation workOrientation=iflOrientation(0));
void getSize(iflSize& size, iflOrientation workOri)
int isMirrorOrientation(iflOrientation otherOri,
iflOrientation workOri=iflOrientation(0))
Mapping to or from source image
ilStatus mapToSource(float& x, float& y, float& z,
float u, float v, float w)
ilStatus mapToSource(float& x, float& y, float u, float v)
ilStatus mapToSource(iflXYfloat& src, const iflXYfloat& self)
ilStatus mapFromSource(float& u, float& v, float& w,
float x, float y, float z)
ilStatus mapFromSource(float& u, float& v, float x, float y)
ilStatus mapFromSource(iflXYfloat& self, const iflXYfloat& src)
virtual ilStatus mapToInput(float& x, float& y, float& z,
float u, float v, float w, int idx=0)
ilStatus mapToInput(float& x, float& y, float u, float v, int idx=0)
ilStatus mapToInput(iflXYfloat& xy, const iflXYfloat& uv, int idx=0)
ilStatus void mapFromInput(float& u, float& v, float& w,
float x, float y, float z, int idx=0)
ilStatus mapFromInput(float& u, float& v, float x, float y, int idx=0)
ilStatus mapFromInput(iflXYfloat& uv, const iflXYfloat& xy, int idx=0)
Color conversion support
ilColorImg* getColorImg(iflColorModel cm)
int isColorImg()
int getCopyConverter(ilImage*& other, const ilConfig* cfg) protected
void checkColorModel() protected
double getScaleMin()
double getScaleMax()
ilStatus setScaleMinMax(double min, double max)
ilStatus setScaleType(iflDataType type=iflDataType(0))
void initScaleMinMax(int force=FALSE)
Hardware Acceleration
void setHwEnable(ilHwAccelEnable enable)
ilHwAccelEnable getHwEnable()
virtual ilHwOp* hwDefine() protected
virtual ilHwPass* hwGetPass(const ilHwTarget& target, int force=FALSE)
ilHwPassTable* getHwPassTable() protected
ilHwOp* getHwOp() protected
void setDisplayCacheEnable(int en=TRUE) protected
int getDisplayCacheEnable()
Miscellaneous
void* allocFillData(float red, float green, float blue)
void freeFillData(void* data)
FUNCTION DESCRIPTIONS
ilImage()
ilImage()
ilImage(iflSize &sz)
Two constructors are provided for ilImage. The default constructor
takes no parameters and is used by default for derived classes. The
second constructor takes a reference to an iflSize object, sz, which
is used to initialize the size of the image.
An iflSize object contains integer members to hold the number of
pixels in the x, y and z dimensions as well as the number of
channels per pixel c (see also setSize()). Both constructors
initialize most image attributes to 0 or NULL. The ilLink altered
flag is set to ilIPgeneric and the ilLink allowed flag is set to
(ilIPgeneric|ilIPminPixel|ilIPmaxPixel|ilIPfill) (see the ilLink man
page and the enumerated type ilImgParam in il/ilImages.h). No
compression is assumed. Status is set to ilOKAY.
allocFillData()
void* allocFillData(float red, float green, float blue)
This function allocates a pixel and sets it to correspond to the
given red, green, and blue pixel components. The returned value
points to the allocated pixel, which should be free'd with
freeFillData().
addInput()
ilStatus addInput(ilImage* inimg)
Adds the image pointed to by inimg to the end of the input (parent)
list. See setInput().
checkColorModel()
void checkColorModel() protected
Checks the current color model against the number of channels. If
there is a mismatch, the number of channels (size.c) is adjusted to
match the color model. However, if the number of channels has been
set, then status is set to ilBADCOLFMT.
checkValidOrder()
void checkValidOrder(int orderMask) protected
Select a data order for this image that is one of the intersection
of the orders specified in orderMask and the allowed orders for this
image (see ilLink::setAllowed()).
This method is called by inherit() and should only be called within an
image's reset() method.
checkValidType()
void checkValidType(int typeMask, int wantSigned=FALSE) protected
Select a data type for this image that is one of the intersection of
the types specified in typeMask and the allowed data types for this
image (see ilLink::setAllowed()). If wantSigned is TRUE, then a
signed data type is selected if one is allowed. (See
iflDataClosestType() for details on the selection process.)
This method is called by inherit() and should only be called within an
image's reset() method.
clipTile()
ilStatus clipTile(int &x, int &y, int &z, int &nx, int &ny, int &nz,
int includeBorder=FALSE)
ilStatus clipTile(iflTile3Dint& t, int includeBorder=FALSE)
ilStatus clipTile(float &x, float &y, float &z,
float &nx, float &ny,
float &nz, int includeBorder=FALSE)
ilStatus clipTile(iflTile3Dfloat& t, int includeBorder=FALSE)
Clips the given tile parameters to the image bounds. The tile
boundaries might be passed as parameters to getTile3D() or
setTile3D(), for example. The tile may be specified as six int
parameters, or as an iflTile3Dint. Alternative versions allow the
parameters to be passed as float. If includeBorder is TRUE, then
the clip bounds are increased to include the size of the page
border, if any (see setPageBorder()). If any of the parameters
needed to be clipped to fit the image, this function returns
ilDATACLIPPED; otherwise, it returns ilOKAY.
configureRetainedCache()
ilStatus configureRetainedCache(const iflTile3Dint& tile,
int c = 0, int nc = -1,
int* chans = NULL, float minCacheBudget = .05,
float maxCacheBudget = 1,
size_t* retainedFileSize = NULL)
Convenience method that calls ilConfigureRetainedCache() with a
single ilImageTile that specifies the tile for this image denoted in
the arguments tile, c, nc, and chans. The remaining arguments are
passed directly to ilConfigureRetainedCache(). The value returned
by ilConfigureRetainedCache() is returned.
copy()
ilStatus copy(ilImage* from)
Copies data from the image specified by from. If the two images are
of different sizes, only the origin-aligned intersecting portion is
copied. See also copyTile3D().
copyTile()
ilStatus copyTile(int x, int y, int nx, int ny, ilImage* other,
int ox, int oy, int* chanList=NULL)
ilStatus copyTile3D(int x, int y, int z, int nx, int ny, int nz,
ilImage* other, int ox, int oy, int oz,
int* chanList=NULL)
ilStatus copyTileCfg(int x, int y, int z, int nx, int ny, int nz,
ilImage* other, int ox, int oy, int oz,
const ilConfig* config=NULL)
These functions queue a copyTile request with qCopyTileCfg() and
wait for it to complete. The tile at x, y, z of size nx, ny, nz is
copied to this image from other image at ox, oy, oz. The 2D
version, copyTile() calls the corresponding 3D routine with z set to
zero and nz and oz set to one.
copyTileCfg() takes an ilConfig argument, config, which is used to
reconfigure the pixel data type, order, channels and orientation as
well as offsetting into the channel dimension. The other two copy
routines accept a channel list, which is used to construct an
ilConfig object with all other taken from "this" image. The channel
list in config specifies a channel mapping between the "other" and
"this" image. The number of entries in the list should always match
the number of channels in "this" image. A -1 means no data is
written for that channel.
See also qCopyTileCfg() and getConfig().
fillTile()
ilStatus fillTile(int x, int y, int nx, int ny, const void* data,
const ilConfig* config=NULL,
const iflTile2Dint* fillMask=NULL)
ilStatus fillTile3D(int x, int y, int z, int nx, int ny, int nz,
const void* data, const ilConfig* config=NULL,
const iflTile2Dint* fillMask=NULL)
ilStatus fillTileRGB(int x, int y, int z, int nx, int ny, int nz,
float red, float green, float blue,
const iflTile3Dint* fillMask=NULL,
iflOrientation orientation=iflOrientation(0));
These functions queue a fill tile request with qFillTile3D() or
qFillTileRGB() and wait for it to complete. The tile at position
(x,y,z) of size nx, ny, nz will be filled with a constant pixel
value. fillTile() sets z to zero and nz to one.
config describes the configuration (See the ilConfig man page) of
the fill value data; if NULL, it is assumed to have the same
configuration as the image. For example, to fill a tile of an RGB
image with white, data should hold the values (255, 255, 255).
fillTileRGB() is provided as a convenience method for RGB images;
the red, green, and blue pixel components are passed directly as
floats.
The parameter, fillMask, can be used to prevent filling a portion of
the tile. If fillMask is not NULL, only the portion outside of
fillMask is filled. If config is not NULL and it specifies a valid
orientation, then fillMask is mapped from that orientation to that
of the image; otherwise fillMask is assumed to have the same
orientation as that of the image. fillTileRGB() takes a mask
orientation as a parameter which defaults to the same orientation as
the image.
See also the ilCacheImg man page.
freeFillData()
void freeFillData(void* data)
This function free's a pixel allocated with allocFillData().
getDimensions()
void getDimensions(iflSize& size)
Returns the size of the image in the ilLowerLeftOrigin orientation.
getDirectInput()
ilImage* getDirectInput(int idx = 0)
Return the direct input at index idx, ignoring whether or not it is
enabled. (See getInput() and ilLink::getDirectParent().)
getDisplayCacheEnable()
int getDisplayCacheEnable()
Returns the current setting for the display cache enable. See
setDisplayCacheEnable.
getColorImg()
ilColorImg* getColorImg(iflColorModel cm)
Returns a pointer to an ilColorImg that is a child of "this" image
and has the color model specified by cm. The new color converter
inherits most attributes, except for the color model and the number
of channels, from "this" image.
getColormap()
ilStatus getColormap(iflColormap &cmap)
const iflColormap* getColormap()
These functions return the image's colormap. The first version
deposits the image's color map in the iflColormap object pointed to
by cmap and returns a status value. The status value is either the
image's status or ilNULLOBJ, if the colormap is NULL. If ilOKAY is
not returned, then the argument is unchanged. The second version
returns a pointer to this image object's colormap, which may be
NULL.
getColorModel()
iflColorModel getColorModel()
Returns the color model of the image. iflColorModel is an enumerated
type with the following members:
iflRGB red, green, blue
iflRGBA red, green, blue, alpha
iflRGBPalette RGB color mapped to a look-up table
iflHSV hue, saturation, value
iflCMY cyan, magenta, yellow
iflCMYK cyan, magenta, yellow, black
iflNegative inverted luminance (min is white, max is black)
iflLuminance luminance
iflLuminanceAlpha
luminance, alpha
iflBGR swapped RGB, for images generated by SGI
iflABGR swapped RGBA, for images generated by SGI
iflMultiSpectral
multiple channels of sensor-specific data
The color model is used to interpret the meaning of the channels
that make up a pixel. See also setColorModel().
getCompression()
iflCompression getCompression()
Returns the image compression parameter as the enumerated type,
iflCompression. This parameter reflects the type of compression
used in the image data. See also setCompression().
getConfig()
void getConfig(ilConfig* cfg)
Returns the image's configuration in the ilConfig object pointed to
by cfg. The ilConfig class (see il/ilConfig.h) contains eight
elements: an iflDataType that defines the data type of the image's
pixels, an iflOrder that describes how that data is ordered, an int
that sets how many data channels there are, an array of ints that
determines the order of the channels, an iflOrientation, and three
zoom factors for the three dimensions. See also getDataType(),
getOrder(), getNumChans() and getOrientation().
getOrientation()
iflOrientation getOrientation()
Returns the image orientation parameter as the enumerated type,
iflOrientation. This parameter determines, for example, whether the
image origin is the upper left corner or the lower left corner. See
also setOrientation().
getCopyConverter()
int getCopyConverter(ilImage*& other, const ilConfig* cfg) protected
If the other image has a different color model than this image, a
color converter operator is chained onto other and TRUE is returned
(the new operator is returned via other). If the color models are
compatible, OR if the cfg specifies a channel list or channel
offset, then no operator is chained and FALSE is returned. When cfg
specifies a channel list or offset, it is assumed that no color
conversion should be performed.
getCsize()
int getCsize()
int getNumChans()
Returns the number of channels in the image. For example an RGB
image is a 3 channel image.
getDataType()
iflDataType getDataType()
Returns the data type of the image's pixels. The iflDataType value
returned can be one of the following: iflBit, iflChar, iflUChar,
iflShort, iflUShort, iflLong, iflULong, iflFloat, or iflDouble. See
also getConfig().
getFill()
const iflPixel& pixel getFill()
Returns a reference to the image's fill pixel value. See also
setFill().
getFillData()
const void* getFillData()
This function calls the getData() method of the image's fill pixel
and returns the result.
getFillValue()
double getFillValue(int c=0)
Returns the image fill value of channel c. See also getFill().
getHeight()
int getHeight()
Returns the height of img. See also getWidth() and getYsize().
getHwEnable()
ilHwAccelEnable getHwEnable()
This function returns the value of the hardware acceleration enable
flag as set by setHwEnable().
getHwOp()
ilHwOp *getHwOp() protected
This function returns a pointer to the ilHwOp private member
variable; it is provided to allow access by derived classes.
Currently, user-defined hardware acceleration is unsupported. For
more information on hardware acceleration, see ilHwDefs.h and the
Programmer's Guide.
getHwPassTable()
ilHwPassTable* getHwPassTable() protected
This function returns a pointer to the ilHwPassTable for this image;
it is provided to allow access to this table by derived classes.
Currently, user-defined hardware acceleration is unsupported. For
more information on hardware acceleration, see ilHwDefs.h and the
Programmer's Guide.
getInput()
ilImage* getInput(int idx = 0)
Returns a pointer to the ilImage at index idx in the parent list.
NULL is returned if there is no image at the specified index. The
default index is 0.
getInputTileRequirement()
ilImageTile* getInputTileRequirement(const iflTile3Dint& tile,
int c, int nc,
int* chans, int& pageSetCount)
This method is used by the global function
ilConfigureRetainedCache() to determine the input data requirement
to evaluate a given output tile. The method really ought to be a
virtual, so that derived classes can easily override its behavior,
but it cannot be done this way and still maintain binary
compatibility with IL 3.1.1. Therefore, a derived class can
override the behavior of this method only by calling the method
setTileRequirementFunction() to establish a new behavior.
The default implementation returns an array of ilImageTile's, one
for each of the image's inputs, with tile coordinates identical to
the passed tile coordinates. Derived classes, such as ilMonadicImg
and ilPolyadicImg, override the default behavior to take input
offsets into account. ilWarpImg overrides the default behavior to
incorporate the effect of the warp. As an example of overriding the
default behavior, here is ilPolyadicImg's version:
ilImageTile*
ilPolyadicImg::getInputTileRequirement(const iflTile& tile, int c, int nc,
int* chans, int& inputTileCount)
{
if (resetCheck()) { inputTileCount = 0; return NULL; }
int count = getNumParents();
ilImageTile* inputTiles = new ilImageTile [count];
int activeCount = 0;
ilLinkParentIter iter(this);
ilLink* link;
while (link = iter.next()) {
if (link->derivesFrom(iflClassID(ilImage))) {
ilImage* img = (ilImage*)link;
iflTile offTile = tile;
int idx = iter.currIndex();
if (idx >= 0) {
int x, y, z;
getOffset(x, y, z, idx);
offTile.x -= x;
offTile.y -= y;
offTile.z -= z;
}
inputTiles[activeCount++].init(img, offTile, c, nc, chans);
}
else if (link->derivesFrom(iflClassID(ilImgStat)))
activeCount += ((ilImgStat*)link)
->getInputTileRequirement(inputTiles[activeCount]);
}
inputTileCount = activeCount;
if (activeCount == 0) { delete inputTiles; inputTiles = NULL; }
return inputTiles;
}
getLockTileSet()
ilLockRequest* getLockTileSet(int& count, const iflTile3Dint& tile,
const ilConfig* config=NULL,
int includeBorder=FALSE)
This function generates an array of ilLockRequests corresponding to
the specified "tile" in the image. These requests can then be
passed to lockPageSet() and unlockPageSet() to lock the pages
comprising the tile. If includeBorder is TRUE then all pages that
intersect the tile comprise the set. Otherwise, the smallest set of
pages that cover the tile comprises the set. This distinction is
relevant only if the image has non-zero page borders. Generally,
you should set includeBorder to TRUE if you are generating the set
for writing, and FALSE if you are generating the set for reading.
The number of generated lock requests is returned in the reference
parameter "count". The returned ilLockRequest set is in new()'ed
memory. It is the responsibility of the caller to delete the set
when no longer in use.
getMaxColormapLevels()
int getMaxColormapLevels()
This function returns the maximum color map level attribute set with
setMaxColormapLevels().
getMaxValue()
double getMaxValue()
Returns the maximum allowable value for this image object.
getMinValue()
double getMinValue()
Returns the minimum allowable value for this image object.
getNumInputs()
int getNumInputs()
Returns the number of images in this image's input (parent) list.
getOrder()
iflOrder getOrder()
Returns the pixel channel order of this image. The enumerated type,
iflOrder, has members iflInterleaved, iflSequential, or iflSeparate
to indicate how the pixel data is ordered.
For iflInterleaved, all pixel channels are stored adjacently. For
an RGB color image, this would be RGBRGBRGB, and so forth. For
iflSequential, each pixel channel is stored as a separate line. For
an RGB color image, this is a line of Red, followed by a line of
Green, followed by a line of Blue for one line of RGB pixels. For
iflSeparate, each channel is stored in a separate page. See the
ImageVision Library Programming Guide for more details.
getPageBorder()
void getPageBorder(iflXYZint& border)
const iflXYZint& getPageBorder()
int getPageBorderX()
int getPageBorderY()
int getPageBorderZ()
Returns the page border size in an iflXYZint structure.
The alternative methods provide access to the per-coordinate page
border values.
getPageCounts()
void getPageCounts(int& nx, int& ny, int& nz, int& nc)
Returns the number of pages required to cover the entire image
extent in each of the x, y, z, and c dimensions
getPageDelta()
void getPageDelta(iflXYZCint& delta)
void getPageDelta(int &nx, int &ny, int &nz, int &nc)
Returns the effective page size with page borders removed. It is
computed by subtracting twice the page border size from the current
page size.
getPageIndices()
void getPageIndices(int x, int y, int z, int c, int& ix,
int& iy, int& iz, int& ic)
Return the indices of the image page containing the point (x, y, z,
c).
getPageOrigin()
ilStatus getPageOrigin(int x, int y, int z, int c,
int& px, int& py, int& pz, int& pc)
ilStatus getPageOrigin(const iflXYZCint& pos, iflXYZCint& org)
int getPageOriginX(int x)
int getPageOriginY(int y)
int getPageOriginZ(int z)
int getPageOriginC(int c)
This method returns the origin of the page that contains the point
passed in as x, y, z, and c. The coordinates of the page are
returned in px, py, pc, and pz. The returned page coordinates may
correspond to a page that does not actually reside within the image
bounds if the passed pixel coordinates are also outside the image
bounds. If the image has page borders, then it is possible that
more than one page contains the point. In this case, the page with
the greatest coordinate values is returned.
If the image's status is not ilOKAY, then that status is returned
and the page coordinates values are not set. Otherwise, ilOKAY is
returned.
Alternative methods are provided to compute each of the page
coordinates independently.
getPageSize()
size_t getPageSize()
size_t getPageSize(int& nx, int& ny)
size_t getPageSize(int& nx, int& ny, int& nz, int& nc)
size_t getPageSize(iflSize& pageSize)
size_t getPageSize(iflSize& pageSize, iflOrientation ori)
size_t getPageDimensions(iflSize& pageSize)
Returns the image page size in bytes. This takes into account the
number of channels per pixel and the channel data type. The second
and third versions also return the page size in the x, y, z, c
dimensions in nx, ny, nz and nc. The fourth version returns the
page size in an iflSize structure, possibly transformed into the
orientation specified in ori. The x and y page size will be
transposed as needed, based on the orientation. See also the
ilCacheImg man page.
The getPageDimensions method returns the page size in a standard
(non-transposed) orientation. This is useful if you are interested
in the "width" or "height" of a page, independent of the data
orientation.
getPageSizeX() getPageSizeY() getPageSizeZ() getPageSizeC()
int getPageSizeX()
int getPageSizeY()
int getPageSizeZ()
int getPageSizeC()
Returns the image's page size in the x-, y-, z-, c-dimensions,
respectively.
getPageSizePix()
int getPageSizePix()
Returns the image page size in pixels. See also getPageSize().
getPageSizeVal()
int getPageSizeVal()
Returns the image page size in terms of discrete values. This takes
into account the number of channels per pixel that is, it returns
getPageSizePix() * number of channels in the page). See also
getPageSize().
getPixel()
ilStatus getPixel(int x, int y, iflPixel& pix)
This function is the 2-D version of getPixel3D(). It calls
getPixel3D() with z set to 0. See also getPixel3D().
getPixel3D()
ilStatus getPixel3D(int x, int y, int z, iflPixel& pix)
Gets the iflPixel at the point specified by x, y, and z and returns
it in pix. An iflPixel specifies the channel data type, the number
of channels per pixel and a pointer to the pixel data. This
function calls getSubTile3D() with the tile size nx, ny, nz set to
1. Returns ilOKAY upon successful completion. See also getPixel(),
getSubTile3D() and setPixel3D().
getPriority()
int getPriority()
This function gets the current cache priority of this image. See
setPriority() for more details.
getScaleMax()
double getScaleMax()
Returns the maximum value used for scaling during color conversion
and display. By default the maximum scale value tracks the maximum
value of the image. However, it may be set with setScaleMinMax().
getScaleMin()
double getScaleMin()
Returns the minimum value used for scaling during color conversion
and display. By default the minimum scale value tracks the minimum
value of the image. However, it may be set with setScaleMinMax().
getSize()
void getSize(iflSize& size)
void getSize(iflSize& size, iflOrientation workOri)
const iflSize& getSize()
The first version returns the image size in the iflSize object
referenced by size. An iflSize has integer member variables x, y,
z, and c to hold each dimension of the image. The second version
first maps the image's size to the orientation indicated by workOri.
If the indicated orientation is transposed relative to the image's
orientation, then the x and y sizes are swapped in the returned
size. See also getXSize(), getYSize(), getZSize() and getCSize().
The third version returns a reference to the actual size attribute
of this image object.
getStrides()
void getStrides(int& xs, int& ys, int& zs, int& cs,
int nx=0, int ny=0, int nz=0, int nc=0,
iflOrder ord=iflOrder(0))
Returns by reference the x stride (xs), y stride (ys), z stride
(zs), channel stride (cs) and number of channels (nc). The buffer
strides are used to step through a data buffer of size nx by ny that
contains pixels with channel order ord. The default order is
numiflOrders and causes the current data order to be used.
The x stride is used to step from one pixel to the next in the same
row. The y stride is used to step to the next pixel in the same
column. For 3D images, the z stride is used to step to the next
pixel along the z axis at the same xy location. A multiplier n can
be used to move n pixels in a desired direction within the data
buffer.
The channel stride is used to step to the next channel of the same
pixel.
getTile()
ilStatus getTile(int x, int y, int nx, int ny,
void* data, const ilConfig* config=NULL)
ilStatus getTile3D(int x, int y, int z, int nx, int ny, int nz,
void* data, const ilConfig* config=NULL)
ilStatus getSubTile(int x, int y, int nx, int ny, void* data,
int dx, int dy, int dnx, int dny,
const ilConfig* config=NULL)
ilStatus getSubTile3D(int x, int y, int z, int nx, int ny, int nz,
void* data, int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL)
These functions queue a tile read request with qGetSubTile3D() and
wait for it to complete. The source tile origin is specified by x,
y, z, and the tile size is specified by nx, ny, nz.
The 2D versions, getTile() and getSubTile(), call the corresponding
3D routine with z set to zero and nz set to one.
getTile() and getTile3D() assume that the destination buffer has the
same offset and size as the request; getSubTile() and getSubTile3D()
allow the destination buffer to have a different position and size,
specified by dx, dy, dnx, and dny (and dz and dnz for the 3D
version.)
Optionally, an ilConfig object pointed to by config can be used to
specify the desired data type, order, number of channels and channel
order. config is NULL by default, meaning that no conversion is
performed on the input data.
See also qGetTile3D(), qGetSubTile3D() and getConfig().
getWidth()
int getWidth()
Returns the width of img. See also getHeight() and getXsize().
getXsize()
int getXsize()
Returns the size of the image in the x-dimension, measured in
pixels.
Note that by definition in the IL, the x-dimension is always the
fastest varying dimension in image memory order. I.e. the scanline
dimension. In non-transposed orientations, scanlines are oriented
horizontally with respect to the image. Thus, for non-transposed
orientations getXsize() returns the width of the image. In
transposed orientations the scanlines are oriented vertically with
respect to the image and getXsize() returns the height of the image.
Transposed orientations are: iflLeftUpperOrigin,
iflRightUpperOrigin, iflRightLowerOrigin and iflLeftLowerOrigin.
See also getHeight(), getWidth(), getSize(), getYsize() and
getZsize().
getYsize()
int getYsize()
Returns the size of the image in the y-dimension, measured in
pixels. See also getHeight(), getWidth(), getSize(), getXsize() and
getZsize().
getZsize()
int getZsize()
Returns the size of the image in the z-dimension. This value can be
thought of as representing the number of xy planes in an image. For
two-dimensional images, the returned value is 1. Refer to the
ImageVision Library Programming Guide for more details. See also
getSize(), getXsize() and getYsize().
hasPageBorder()
int hasPageBorder()
This functions returns TRUE if the image has page borders, FALSE
otherwise.
hasPages()
int hasPages()
This virtual function should be defined by derived classes to return
TRUE if the class implements paging. The default implementation
returns FALSE.
inherit()
int inherit(int typeMask=0, int orderMask=0, int allowDiffColorModels=FALSE)protected
This is a convenience method that can be called in an ilImage-
derived subclass' reset() method to inherit standard image
attributes such as page size, data type, orientation, and so forth,
from the image's inputs. Only those attributes that have not been
explicitly set are affected. The following attributes are set by
inherit:
color model
data type
data order
data orientation
color map
size
page size
min and max values
The parameters typeMask and orderMask, if non-zero, limit the
possible inherited data type and order to the subsets specified in
the respective masks. If allowDiffColorModels is TRUE, then the
image is allowed to have a different color model than its inputs.
Normally, this is not allowed, and a color converting image is
automatically inserted to coerce the input color models to the
image's color model.
initColorModel()
void initColorModel(int noAlpha=FALSE) protected
Initializes the color model based on the number of channels if it
has never been explicitly set with setColorModel(). Images with one
channel are set to iflLuminance. Images with two channel are set to
iflLuminanceAlpha. Images with three channels are set to iflRGB.
Images with four channels are set to iflRGBA by default. If noAlpha
is true, then images with two or four channels are set to
iflMultiSpectral instead. All other cases are set to
iflMultiSpectral.
initMinMax()
void initMinMax(int force=FALSE) protected
Initializes the minimum and maximum value of a pixel based on the
data type (for example, 0 and 255) for unsigned char data. force is
FALSE by default, indicating that the minimum and maximum values
should not be forced to change if they have already been set.
initPageSize()
void initPageSize(const iflSize& pageSize) protected
void initPageSize(int nx, int ny, int nz, int nc) protected
Initializes the page size to pageSize only if it has not been
previously set (separate flags track whether x/y, z and c values
have been set). The member pageSizeBytes is also computed to match
the new page dimensions and the image's data type.
initScaleMinMax()
void initScaleMinMax(int force=FALSE)
Initializes the scale minimum and maximum to the image minimum and
maximum values. If scale minimum and maximum have already been set,
they are unchanged, unless force is TRUE. The scale minimum and
maximum are used during color conversion and display. By default,
the scale minimum and maximum track the image minimum and maximum
values.
isColorImg()
int isColorImg()
Returns TRUE if the image is a color converter that was created with
getColorImg(). Otherwise FALSE is returned.
isIntegral()
int isIntegral()
Returns TRUE if the image's data type is an integral valued type. If
it is a floating point type, then FALSE is returned. This function
is based on the standalone function, iflDataIsIntegral() (see the
iflDataSize man page).
isMirrorOrientation()
int isMirrorOrientation(iflOrientation otherOri,
iflOrientation workOri=iflOrientation(0))
The routine returns TRUE if otherOri is a mirror image of workOri.
If workOri is defaulted, the orientation of the image is used
instead. This can be useful when implementing operations that have
calculations that depend on a particular frame of reference. For
example, when implementing an image rotation operator, the angle can
need to be negated to produce consistent results on inputs of
arbitrary orientation.
isPartialPage()
int isPartialPage(int x, int y, int z, int c) protected
Returns TRUE if the page referenced by the coordinates (x, y, z, c)
is only partially filled with image data; that is, if the page
straddles the edge of the image.
isSigned()
int isSigned()
Returns TRUE if the image's data type is signed. If it is unsigned,
then FALSE is returned. This function is based on the standalone
function, iflDataIsSigned() (see the iflDataSize man page).
isValidPage()
int isValidPage(int x, int y, int z, int c) protected
Returns TRUE if the pixel referenced by the coordinates (x, y, z, c)
is within the image boundary. The image boundary is defined to be
within
(-xPageBorder ,-yPageBorder, -zPageBorder, 0) and (size.x, size.y,
size.z, size.c).
isWritable()
int isWritable()
This function returns TRUE if the image can be written to; FALSE
otherwise.
hwDefine()
virtual ilHwOp* hwDefine() protected
This virtual returns a new'ed ilHwOp object that specifies the
hardware-accelerated implementation of the operation. Currently,
user-defined hardware acceleration is unsupported. Therefore, you
should not override this virtual method. For more information on
hardware acceleration, see ilHwDefs.h and the Programmer's Guide.
hwGetPass()
virtual ilHwPass* hwGetPass(const ilHwTarget& target,
int force=FALSE)
This function returns a ilHwPass object for a given target (defining
the graphics server and visual class). This ilHwPass object
specifies how the operation is performed in the graphics hardware.
Currently, user-defined hardware acceleration is unsupported.
Therefore, you should not override this virtual method. For more
information on hardware acceleration, see ilHwDefs.h and the
Programmer's Guide.
lockPage()
ilPage* lockPage(int x, int y, int z, int c, ilStatus& status,
int mode=ilLMread)
This is the single page version of lockPageSet(). It returns a
pointer to the page containing the pixel x, y, z, c. The status
value specifies the error code if a page could
not be referenced. If the function succeeds, status is set to
ilOKAY. See qLockPageSet() for a description of mode and possible
status returns. See also unlockPage().
lockPageSet()
ilStatus lockPageSet(ilLockRequest* set, int mode=ilLMread,
int count=1, ilCallback* perPageCb=NULL)
This function queues a list of lock page requests with
qLockPageSet() and waits for them to complete. Each ilLockRequest
in the set array is locked and a pointer to the page is deposited in
the corresponding ilLockRequest. As a consequence, this causes all
the image data for the pages to be computed. If all of the requests
succeed, ilOKAY is returned. If one or more fail, an error code
will be returned and the ilLockRequest structures will contain
individual status codes. At a later time, unlockPageSet() can be
called to release the set of pages.
See qLockPageSet() and unlockPageSet() for more information.
lockTile()
ilLockedTile* lockTile(int x, int y, int nx, int ny,
const ilConfig* config=NULL, int mode=ilLMread)
This is the 2-D version of lockTile3D(). It calls lockTile3D() with
z set to 0 and nz set to 1.
lockTile3D()
ilLockedTile* lockTile3D(int x, int y, int z, int nx, int ny, int nz,
const ilConfig* config=NULL, int mode=ilLMread)
This function causes the tiles that intersect the indicated image
volume to be ``locked.'' This is accomplished by ``locking'' the
image pages which store the data for the affected tiles. These
pages remain locked until the ilLockedTile object returned by
lockTile3D() is deleted. The status result of the function can be
retrieved by calling the getStatus() method of the returned
ilLockedTile object.
``Locking'' is implemented by a virtual function in ilImage. In the
default implementation, copies of the affected pages are computed
and stored in locally allocated storage. Some derived classes
provide more interesting implementations which manage shared cache
storage, etc. One example is ilMemCacheImg.
mapFlipTrans()
iflOrientation mapFlipTrans(iflOrientation fromOrientation,
iflFlip& flip, int& transXY,
iflOrientation workOrientation=iflOrientation(0))
This function determines the flips and/or transpositions required to
map from fromOrientation to workOrientation (if the work orientation
is zero, the image's orientation is used). The return value is the
work orientation. The required flip and transXY values are also
returned.
mapFromInput()
virtual ilStatus mapFromInput(float& u, float& v, float& w,
float x, float y, float z, int idx=0)
ilStatus mapFromInput(float& u, float& v, float x, float y, int idx=0)
ilStatus mapFromInput(iflXYfloat& uv, const iflXYfloat& xy, int idx=0)
Maps a point, (x,y,z), from the idx'th input image's output
coordinate space to this image's output coordinate space and returns
the result in (u,v,w). This virtual function's default
implementation is the identity mapping. It can be overridden in
derived classes (like ilWarpImg) to take into account any address
manipulations that an operator can perform. The overloaded versions
provide 2D address mapping, which is sufficient for most
applications. Note that the IL does not yet support images with
non-identity coordinate mappings in the z dimension, and all
coordinates (input and output) are described in the orientation of
this image. See also mapFromSource(), mapToInput().
mapFromSource()
ilStatus mapFromSource(float& u, float& v, float& w, float x,
float y, float z)
ilStatus mapFromSource(float& u, float& v, float x, float y)
ilStatus mapFromSource(iflXYfloat& self, const iflXYfloat& src)
Maps a point, (x,y,z), in the ultimate source image's input
coordinate space to this image's output coordinate space and returns
the result in (u,v,w). Both points are defined in this image's
orientation. One possible use for this is to determine where to plot
annotation that is tied to the source image when zooming and
rotating an image. The ilView function, setLoc(), also uses this
function to position a location in the source image of an operator
chain at the center of the viewed region. The overloaded versions
provide 2D address mapping, which is sufficient for most
applications. Note that the IL does not yet support images with
non-identity coordinate mappings in the z dimension. See also
mapToSource(), mapFromInput() and the ilView man page.
mapSize()
void mapSize(iflOrientation fromOri, int& x, int& y,
iflOrientation workOri=iflOrientation(0))
Transposes the x and y size as needed, based on fromOri and workOri.
If workOri is 0, then the image's orientation is used.
mapOrientation()
iflOrientation mapOrientation(int flipX, int flipY, int transXY=FALSE)
The function returns the orientation that results from applying the
flips and transpose requested to the image's orientation. If flipX
is TRUE, the x dimension is flipped. If flipY is TRUE, the y
dimension is flipped. If transXY is TRUE, the x and y dimensions
are transposed.
mapTile()
void mapTile(iflOrientation fromOri, iflTile2Dint& tile,
iflOrientation workOri=iflOrientation(0))
void mapTile(iflOrientation fromOri, iflTile2Dfloat& tile,
iflOrientation workOri=iflOrientation(0))
void mapTile(iflOrientation fromOri, iflTile2Dint &tile, iflFlip &flip,
int &transXY, iflOrientation workOri=iflOrientation(0))
The tile referenced by tile is mapped from orientation fromOri to
the orientation workOri. If workOri is defaulted, the orientation
of the image is used instead. The origin and size members of tile
are recomputed to reflect this mapping. The value returned in the
iflFlip enumerated type, flip indicates whether the x or the y axis,
or both, had to be flipped to effect the mapping.
If no flipping was required, then iflNoFlip is returned. If the x
or y axis was flipped, iflXFlip or iflYFlip is returned. If both
axes were flipped, (iflXFlip | iflYFlip) is returned. If, to effect
the mapping, the x and y axes had to be interchanged (that is, the
new x origin and size are the old y origin and size and the converse
is true), then a 1 is returned in transXY; otherwise transXY is 0.
mapToInput()
virtual ilStatus mapToInput(float& x, float& y, float& z,
float u, float v, float w, int idx=0)
ilStatus mapToInput(float& x, float& y, float u, float v, int idx=0)
ilStatus mapToInput(iflXYfloat& xy, const iflXYfloat& uv, int idx=0)
Maps a point, (u,v,w), in this image's output coordinate space to
the idx'th input image's output coordinate space and returns the
result in (x,y,z). This virtual function's default implementation
assumes the identity mapping. It can be overridden in derived
classes (like ilWarpImg) to take into account any address
manipulations that an operator can perform. The overloaded versions
provide 2D address mapping, which is sufficient for most
applications. Note that the IL does not yet support images with
non-identity coordinate mappings in the z dimension, and all points
are defined in the orientation of this image. See also
mapToSource(), mapFromInput().
mapToSource()
ilStatus mapToSource(float& x, float& y, float& z, float u,
float v, float w)
ilStatus mapToSource(float& x, float& y, float u, float v)
ilStatus mapToSource(iflXYfloat& src, const iflXYfloat& self)
Maps a point, (u,v,w), in this image's output coordinate space to
the ultimate source image's input coordinate space and returns the
result in (x,y,z). All coordinates are defined in this image's
orientation. One possible use for this is to find the source image
coordinates of a screen location in a zoomed and rotated image. The
ilView function, getLoc(), uses this function to accomplish this
task. The overloaded versions provide 2D address mapping, which is
sufficient for most applications. Note that the IL does not yet
support images with non-identity coordinate mappings in the z
dimension. See also mapFromSource(), mapToInput() and the ilView
man page.
mapXY()
void mapXY(iflOrientation fromOri, int& x, int& y,
iflOrientation workOri=iflOrientation(0))
void mapXY(iflOrientation fromOri, float& x, float& y,
iflOrientation workOri=iflOrientation(0))
void mapXYSign(iflOrientation fromOri, float& x, float& y,
iflOrientation workOri=iflOrientation(0))
The (x,y) pair of values referenced by x and y is mapped from
orientation fromOri to the orientation workOri. If workOri is
defaulted, the orientation of the image is used instead. In the
ilMapXYSign function, if a flip in the x or y dimensions is required
to transform between the two orienations, the x and y values are
negated accordingly. If a transpose is required, the x and y values
are swapped.
outOfBound()
int outOfBound(int x, int y) protected
int outOfBound(int x, int y, int z) protected
Returns TRUE if the specified point is outside of the image.
Provided as a convenience for derived classes.
qCopyTileCfg()
virtual ilStatus qCopyTileCfg(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, ilImage* other,
int ox, int oy, int oz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL)
This virtual function should be defined by derived classes to queue
a request to copy a tile from the other image to this image object.
The tile is copied to location x, y, z in this image; the tile size
is specified by nx, ny, nz. The source tile is at location ox, oy,
oz in the other image. The config parameter may be used to specify
a channel list and/or offset (the other fields are ignored).
If the other image has a different data type or order than this
image, then the data is converted as it is copied. If the two
image's color models are different, a color converter is chained
onto the other image UNLESS a channel list or offset is specified
with config; the channel re-ordering will be presumed to resolve any
color model difference.
The parent MP node (if not NULL) will have this operation added as a
dependent node. The MP manager for this queued operation will be
returned via the pMgr parameter (if not NULL) and can then used to
wait for completion, obtain a status code, and/or abort. For more
information on MP synchronization, see the ilMpManager man page.
qFillTile3D()
virtual ilStatus qFillTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, const void* data,
const ilConfig* config=NULL,
const iflTile3Dint* fillMask=NULL,
ilMpManager** pMgr=NULL);
This virtual function should be defined by derived classes to queue
a request to fill a tile at location x, y, z of size nx, ny nz with
a constant pixel value, defined by data. The ilConfig object,
config, (if not NULL) can specify a data type and order for the fill
value as well as a channel list or offset. If config specifies an
orientation, it is used to map the tile coordinates to the image's
orientation. The fillMask (if not NULL) defines a region within the
fill area that is not to be filled; it should be specified in the
same orientation as the tile.
The parent MP node (if not NULL) will have this operation added as a
dependent node. The MP manager for this queued operation will be
returned via the pMgr parameter (if not NULL) and can then used to
wait for completion, obtain a status code, and/or abort. For more
information on MP synchronization, see the ilMpManager man page.
qFillTileRGB()
virtual ilStatus qFillTileRGB(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz,
float red, float green, float blue,
const iflTile3Dint* fillMask=NULL,
iflOrientation orientation=iflOrientation(0),
ilMpManager** pMgr=NULL);
This virtual function should be defined to queue a fill tile request
in a manner similar to qFillTile3D(), except that the fill value is
specified with red, green, blue pixel components. The orientation
(if not zero) is used to map the tile and mask coordinates to the
image's orientation.
qGetSubTile3D()
virtual ilStatus qGetSubTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, void*& data,
int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL);
This virtual function should be defined by derived classes to queue
a read request for an arbitrary rectangular tile of data. The data
should be returned in the buffer pointed to by data. The source
tile origin is specified by x, y, z, and the tile size is specified
by nx, ny, nz. The destination buffer origin dx, dy, dz and size
dnx, dny, dnz may be different from the source tile; in this case,
the source tile will be properly integrated into the destination
buffer.
The ilConfig object, config, may be used to specify the data type,
order, number of channels and channel order desired for the buffer.
If config is NULL (the default) then no conversion is performed.
Otherwise, if the configuration specifies attributes different from
those of the image, then the data is converted as it is copied into
the buffer.
The configuration may also include a channel list; it should have as
many entries as there are channels in the buffer. A -1 means no
data is written for that channel. For example, if this image has
four channels and the number of channels in config is 3 and the
channel list is (1, -1, 3), then channels 1 and 3 of this image are
read into channels 0 and 2 of the buffer in the data type and order
specified in config. Channel 1 in the buffer remains unchanged. See
also the ilConfig man page.
The parent MP node (if not NULL) will have this operation added as a
dependent node. The MP manager for this queued operation will be
returned via the pMgr parameter (if not NULL) and can then used to
wait for completion, obtain a status code, and/or abort. For more
information on MP synchronization, see the ilMpManager man page.
qGetTile3D()
ilStatus qGetTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, void*& data,
const ilConfig* config=NULL, ilMpManager** pMgr=NULL)
This function calls qGetSubTile3D() with the destination tile
position and size equal to that of the source tile.
qLockPageSet()
virtual ilStatus qLockPageSet(ilMpNode* parent, ilLockRequest* set,
int mode=ilLMread, int count=1,
ilMpManager** pMgr=NULL,
ilCallback* perPageCb=NULL)
This virtual function should be defined by derived classes to queue
a request to lock pages in memory.
The set parameter is a pointer to an array of count ilLockRequest
structures:
struct ilLockRequest : public ilXYZCSint {
ilStatus status;
ilPage* page;
void init(int X, int Y, int Z, int C);
};
Each ilLockRequest structure specifies a request for a pointer to
the page containing the pixel X, Y, Z, C. After the lock request
completes each of the status codes will be filled in and page will
point at the page containing the requested pixel. If status is not
ilOKAY or X, Y, Z, C references an invalid page, page will be NULL.
The mode parameter is a logical OR of the following mode values:
name bits meaning
_________________________________________________________
ilLMpriority 0x0ff cache priority: 0(low) -> 7(high)
ilLMread 0x100 read access
ilLMwrite 0x200 write access (mark dirty)
ilLMseek 0x400 load into cache without locking
ilLMfail 0x800 succeed only if resident
ilLMforceMP 0x1000 force MP manager to be created
If mode includes ilLMfail, then the status will be set to
ilNOTRESIDENT if the page is not resident in cache, instead of
forcing the page to be made resident. See the header file
<il/ilError.h> for other status values.
In the default implementation in the ilImage base class, copies of
pages are returned in locally allocated memory. Subsequent calls to
lock the same pages will return new copies. This default
implementation ignores the mode parameter. Some derived classes
provide more interesting implementations which manage shared cache
storage, etc. One example is ilMemCacheImg.
The parent MP node (if not NULL) will have this operation added as a
dependent node. The MP manager for this queued operation will be
returned via the pMgr parameter (if not NULL) and can then used to
wait for completion, obtain a status code, and/or abort. For more
information on MP synchronization, see the ilMpManager man page.
Alternatively (or in addition), an ilPage callback, perPageCb, can
be specified; if not NULL, it will be invoked as each page is locked
(see the ilPage man page for info on how to declare a paging
callback).
qSetSubTile3D()
virtual ilStatus qSetSubTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, const void* data,
int dx, int dy, int dz,
int dnx, int dny, int dnz,
const ilConfig* config=NULL,
ilMpManager** pMgr=NULL)
This virtual function should be defined by derived classes to queue
a request to write an arbitrary tile of data taken from the buffer
pointed to by data. The image tile origin is specified by x, y, z,
and the tile size is specified by nx, ny, nz. The source buffer's
origin dx, dy, dz and size dnx, dny, dnz may be different from the
image tile; in this case, only the intersection of the two tiles is
copied.
The ilConfig object, config, may be used to specify the data type,
order, color model, number of channels and channel order of the
buffer. If config is NULL (the default) then no conversion is
performed. Otherwise, if the configuration specifies attributes
different from those of the image, then the data is converted as it
is written to the image.
The configuration may also include a channel list; it should have as
many entries as there are channels in the buffer. A -1 means no
data is written for that channel. For example, if this image has
four channels and the number of channels in config is 3 and the
channel list is (1, -1, 3), then channels 1 and 3 of this image are
read into channels 0 and 2 of the buffer in the data type and order
specified in config. Channel 1 in the buffer remains unchanged. See
also the ilConfig man page.
The parent MP node (if not NULL) will have this operation added as a
dependent node. The MP manager for this queued operation will be
returned via the pMgr parameter (if not NULL) and can then used to
wait for completion, obtain a status code, and/or abort. For more
information on MP synchronization, see the ilMpManager man page.
This is a virtual function and should be defined by derived classes.
See also setTile(), and getConfig().
qSetTile3D()
ilStatus qSetTile3D(ilMpNode* parent, int x, int y, int z,
int nx, int ny, int nz, void* data,
const ilConfig* config=NULL, ilMpManager** pMgr=NULL)
This function is a call-through to qSetSubTile3D() with the buffer
tile position and size equal to the image tile position and size.
removeInput()
ilStatus removeInput(int idx = 0)
Removes the image at index idx from the input (parent) list. If
successful, ilOKAY is returned. The default index is 0.
setColormap()
ilStatus setColormap(const iflColormap &cmap)
Sets the image's color map to the given iflColormap. If successful,
ilOKAY is returned. See also getColormap() and iflColormap.
setColorModel()
ilStatus setColorModel(iflColorModel c)
Sets the image's color model to the enumerated type, iflColorModel,
specified by c. If successful, ilOKAY is returned. See also
getColorModel().
setCompression()
ilStatus setCompression(iflCompression c)
Sets the image's compression scheme to the enumerated type,
iflCompression, specified by c. If successful, ilOKAY is returned.
See also getCompression().
setDisplayCacheEnable()
void setDisplayCacheEnable(int en=TRUE) protected
If the enable is TRUE and this image is not hardware accelerated,
then an ilNopImg is automatically chained onto the image when it is
displayed in order to cache the image data for improved interactive
display. You shouldn't set this enable for images derived from
ilMemCacheImg because such objects have cache's of their own. It
does make sense to set it for an uncached, unaccelerated image such
as ilJoinImg.
setOrientation()
ilStatus setOrientation(iflOrientation spc)
Sets the image's orientation to the enumerated type, iflOrientation,
specified by spc. This parameter determines whether the image origin
is, for example, the upper left corner or the lower left corner. See
also getOrientation().
setCsize()
ilStatus setCsize(int nc)
ilStatus setNumChans(int nc)
Sets the number of channels in the image. Each pixel has nc channels
or components. Returns ilOKAY upon successful completion.
setDataType()
ilStatus setDataType(iflDataType dtype)
Sets the image data type to the enumerated type, iflDataType,
specified by dtype. Returns ilOKAY upon successful completion.
setFill()
ilStatus setFill(const iflPixel& pixel)
Sets the image's fill value data member to the values in pixel.
When getTile() or copyTile() try to access pixels that are beyond
the image's edge, those pixels are set to the fill value. The
iflPixel type is defined in its header file as consisting of an
iflDataType that defines the data type of the image's pixels, an int
specifying the number of channels of data, and a pointer to the
actual pixel data. See also getFill() and clipTile().
setFillRGB()
ilStatus setFillRGB(float red, float green, float blue)
Sets the image fill value to a pixel whose elements will be
interpreted as the color indicated by red, green and blue. The
values for the color triplet should be in the range from zero to
one. See also setFill(). setFillValue()
ilStatus setFillValue(double val, int c=0)
Sets the image fill value for channel c to val. See also setFill().
setHwEnable()
void setHwEnable(ilHwAccelEnable enable)
This function enables or disables hardware acceleration for this
image object. If acceleration is successfully enabled, the image
will derive a performance improvement by using the installed
graphics hardware of the system. See the man page for
ilHwAccelerate.
setInput()
ilStatus setInput(ilImage* inimg, int idx = 0)
Inserts the image inimg into the input (parent) list at index idx.
By default, the image is inserted at index 0. Returns ilOKAY upon
successful completion. See also addInput().
setMaxColormapLevels()
void setMaxColormapLevels(int maxLevels)
This function sets the maximum number of color levels for optimal
color map generation for this image object. This value may be used
to generate a color map when displaying the image if an explicit
color map is not supplied.
setMaxValue()
ilStatus setMaxValue(double val)
Sets the maximum allowable value for all channels.
setMinValue()
ilStatus setMinValue(double val)
Sets the minimum allowable value for all channels.
setNumInputs()
void setNumInputs(int num) protected
Sets the maximum number of inputs allowed by this image to num. The
maximum number of inputs is checked by addInput() and by setInput().
setOrder()
ilStatus setOrder(iflOrder order)
Sets the pixel channel order of this image to order. The enumerated
type, iflOrder can be one of ilInterleaved, ilSequential or
ilSeparate. Returns ilOKAY upon successful completion. See also
getOrder().
setPageBorder()
ilStatus setPageBorder(const iflXYZint& border)
ilStatus setPageBorder(int nx, int ny, int nz=0)
Sets the current page border size to nx, ny, nz.
setPageSize()
ilStatus setPageSize(const iflSize& pageSize)
ilStatus setPageSize(int nx, int ny, int nz, int nc)
ilStatus setPageSize(int nx, int ny)
ilStatus setPageSizeZ(int nz)
ilStatus setPageSizeC(int nc)
Functions to set the page size. For each of the versions of this
function, the x size is set to nx, the y size is set to ny, the z
size is set to nz, and the number of channels is set to nc. See
also ilCacheImg. If the number of channels is set to 0 (or is not
set), it is then up to the derived classes to set the actual c
dimension of the page. One might, in a derived class, check the
order of the data and then set the c dimension to 1 for iflSeparate
data or to the number of image channels for iflInterleaved or
iflSequential data.
setPixel()
ilStatus setPixel(int x, int y, iflPixel& pix)
This function is the 2-D version of setPixel3D(). It calls
setPixel3D() with z set to 0. See also setPixel3D().
setPixel3D()
ilStatus setPixel3D(int x, int y, int z, iflPixel& pix)
Writes the iflPixel specified by pix to the location specified by x,
y, and z. An iflPixel specifies the channel data type, the number
of channels per pixel and a pointer to the pixel data. This
function calls setSubTile3D() with the tile size nx, ny and nz set
to 1. Returns ilOKAY upon successful completion. See also
getPixel3D() and setSubTile3D(), setPixel().
setPriority()
void setPriority(int pri)
This function sets the cache priority of this image, the default is
zero (the lowest priority). By setting a larger value (up to the
maximum of 7), the likelihood that this image's pages will stay in
the global cache is increased.
setScaleMinMax()
ilStatus setScaleMinMax(double min, double max)
Sets the scale minimum and maximum to min and max. The scale
minimum and maximum are used during color conversion and display.
By default, the scale minimum and maximum track the image minimum
and maximum values.
setScaleType()
ilStatus setScaleType(iflDataType type=iflDataType(0))
Sets the scale minimum and maximum to the minimum and maximum values
of the data type passed in type. If type is defaulted, then this
object's data type is used. The scale minimum and maximum are used
during color conversion. By default, the scale minimum and maximum
track the image minimum and maximum values.
setSize()
ilStatus setSize(const iflSize &size)
ilStatus setSize(int nx, int ny)
Sets the image size to the value referenced by size. The second
versions allows just the x and y size to be set. Returns ilOKAY
upon successful completion. See also getSize().
setTile()
ilStatus setTile(int x, int y, int nx, int ny, const void* data,
const ilConfig* config=NULL)
ilStatus setTile3D(int x, int y, int z, int nx, int ny, int nz,
const void* data, const ilConfig* config=NULL)
ilStatus setSubTile(int x, int y, int nx, int ny, const void* data,
int dx, int dy, int dnx, int dny,
const ilConfig* config=NULL)
ilStatus setSubTile3D(int x, int y, int z, int nx, int ny, int nz,
const void* data, int dx, int dy, int dz, int dnx,
int dny, int dnz, const ilConfig* config=NULL)
These functions queue a tile write request with qSetSubTile3D() and
wait for it to complete. The source tile origin is specified by x,
y, z, and the tile size is specified by nx, ny, nz.
The 2D versions, setTile() and setSubTile(), call the corresponding
3D routine with z set to zero and nz set to one.
setTile() and setTile3D() assume that the source buffer has the same
offset and size as the request; setSubTile() and setSubTile3D()
allow the source buffer to have a different position and size,
specified by dx, dy, dnx, and dny (and dz and dnz for the 3D
version.)
See also qSetTile3D(), qSetSubTile3D() and ilGetConfig().
setTileRequirementFunction()
void setTileRequirementFunction(ilTileRequirementFuncPtr func) protected
Set a function pointer that is called to override the default
implementation of getInputTileRequirement() in a derived class.
This method should be called in the derived-class' constructor.
This really should be done as a virtual method, but it has been done
this way in order to maintain binary compatibility with IL 3.1.1.
In order to override the default getInputTileRequirement() in a
derived class, you should add a protected method such as
ilImageTile* getMyInputTileRequirement(const iflTile3Dint& tile,
int c, int nc,
int* chans, int& inputTileCount);
and then call
setTileRequirementFunction((ilTileRequirementFuncPtr)
&MyImage::getMyInputTileRequirement);
in the constructor for MyImage.
setWritable()
void setWritable(int enable=TRUE) protected
This function will enable or disable write access to this image. If
enable is TRUE, then the image will be writable; if FALSE, then the
image is not writable.
setXsize()
ilStatus setXsize(int nx)
Sets the size of the image in the x-dimension, measured in pixels.
Returns ilOKAY upon successful completion. See special notes on IL
image memory order conventions and orientations in the description
of getXsize().
setYsize()
ilStatus setYsize(int ny)
Sets the size of the image in the y-dimension, measured in pixels.
Returns ilOKAY upon successful completion.
setZsize()
ilStatus setZsize(int nz)
Sets the size of the image in the z-dimension, measured in pixels.
Returns ilOKAY upon successful completion.
unlockPage()
void unlockPage(ilPage *page)
This is the single page version of unlockPageSet(). It releases a
page previously ``locked'' by lockPage().
unlockPageSet()
virtual void unlockPageSet(ilLockRequest* set, int count=1)
This function releases a set of pages previously ``locked'' with
lockPageSet(). The set parameter is a pointer to an array of count
ilLockRequest structures.
INHERITED MEMBER FUNCTIONS
Inherited from ilLink
addResetCallback(), alterAction(), anyAltered(), clearAllowed(),
clearSet(), clearStatus(), deleteRelated(), disableAltered(),
dumpChain(), getClassPropSet(), getDescription(), getDirectParent(),
getDisabledIndex(), getFloatProp(), getGenerationID(), getIntProp(),
getMaxIndex(), getMinIndex(), getNumChildren(), getNumParents(),
getParent(), getProp(), getProp(), getPropSet(), getPtrProp(),
getRelatedChild(), getRelatedDelete(), getRelatedType(), getStatus(),
hasResetCallbacks(), ilGetClassPropSet(), inProgress(), isAllowed(),
isAltered(), isEnabled(), isRelated(), isSet(), markSet(), mpUnlock(),
neverReset(), newRelatedType(), removeParent(), removeProp(),
removeResetCallback(), reset(), resetAltered(), resetCheck(),
setAllowed(), setAltered(), setDescription(), setDisabledIndex(),
setEnabled(), setParent(), setProp(), setPropAltered(),
setRelatedDelete(), setRelatedType(), setStatus(), stopWatching(),
unalterable(), watch(), watchNotify()
SEE ALSO
ilCacheImg, ilDisplayImg, ilFileImg, iflColormap, ilMemoryImg, ilOpImg,
ilSubImg, il/ilImage.h, ifl/iflDataTypes.h
Please refer to the ImageVision Library Programming Guide for a full
description of overall concepts and architecture.
NOTES
Although the ilImage class contains no pure virtual functions, it should
only be used to derive new classes, never directly created as an object.
However, a pointer to an ilImage can be declared in order to support
polymorphism.
|
|