DoubleImageCnvC - Conversions into/from the double image

Developer Documentation

Centre for Vision, Speech & Signal Processing

Comments:
The class DoubleImageCnvC performes a conversion between two color images using different representations. One of the representations is double intensity image.

Parent Classes:

ColorImageAC

DoubleImageC

Methods:

DoubleImageCnvC(): Creates a dummy image.
DoubleImageCnvC(const DoubleImageCnvC & im): Creates another handler of the image 'im'.
DoubleImageCnvC(const DoubleImageC & im): Creates another handler of the image 'im' that is possible to convert into another image.
DoubleImageCnvC(ColorImageAC * im): Creates a double intensity image from the general color image 'im' using the conversion RealY().
~DoubleImageCnvC(): Desctructor. Image conversions. ------------------
const ColorImageAC * ColorImageA() const: Returns this image as an constant general color image.
ColorImageAC * ColorImageA(): Returns this image as an general color image.
ByteImageCnvC Y(): Returns the intensity byte image.
ByteImageCnvC Red(): Returns the intensity byte image of the red component.
ByteImageCnvC Green(): Returns the intensity byte image of the green component.
ByteImageCnvC Blue(): Returns the intensity byte image of the blue component.
ByteImageCnvC LnScaleToByte(RealT scale) const: Returns the byte image which values are logarithms of the pixel values of this image. The values below 1 in this image result 0.
DoubleImageCnvC RealY(): Returns the intensity double image.
DoubleImageCnvC RealRed(): Returns the intensity double image of the red component.
DoubleImageCnvC RealGreen(): Returns the intensity double image of the green component.
DoubleImageCnvC RealBlue(): Returns the intensity double image of the blue component.
RGBImageCnvC Rgb(): Returns the image of byte RGB values.
RealRGBImageCnvC RealRgb(): Returns the image of real RGB values.
YUVImageCnvC Yuv(): Returns the image of byte YUV values.
RealYUVImageCnvC RealYuv(): Returns the image of real YUV values.

#include "amma/CoImageA.hh"

const ColorImageAC & operator=(const ColorImageAC & im): Assigment.
ByteImageCnvC Y(): Returns the intensity byte image.
ByteImageCnvC Red(): Returns the intensity byte image of the red component.
ByteImageCnvC Green(): Returns the intensity byte image of the green component.
ByteImageCnvC Blue(): Returns the intensity byte image of the blue component.
DoubleImageCnvC RealY(): Returns the intensity double image.
DoubleImageCnvC RealRed(): Returns the intensity double image of the red component.
DoubleImageCnvC RealGreen(): Returns the intensity double image of the green component.
DoubleImageCnvC RealBlue(): Returns the intensity double image of the blue component.
RGBImageCnvC Rgb(): Returns the image of byte RGB values.
RealRGBImageCnvC RealRgb(): Returns the image of real RGB values.
YUVImageCnvC Yuv(): Returns the image of byte YUV values.
RealYUVImageCnvC RealYuv(): Returns the image of real YUV values.

#include "amma/DoubleIm.hh"

const DoubleImageC & DoubleImage() const

The access to the constant double image.

DoubleImageC & DoubleImage()

The access to the double image.

DoubleImageC Copy() const

Creates a physical copy of the image

void Copy(const DoubleImageC & image)

Copies the image copy into this image.

const DoubleImageC & operator=(const DoubleImageC & im)

Assigment.

ImageAC * ACopy() const

A physical copy of this image.

ImageAC * AnotherImage() const

Creates a new empty image of the same type and size as this image is.

Conversions between color images.

ByteImageC CnvToByte() const

Converts all values of this image into value of ByteImageC. Values outside range of ByteImageC are cut.

ByteImageC ScaleCnvToByte() const

Converts all values of this image into value of ByteImageC. All values are linearly scaled to fit values of ByteImageC.

ByteImageC VarScaleCnvToByte(RealT alpha = 3) const

Converts all values of this image into value of ByteImageC. All values are linearly scaled to fit the range .

ByteImageC Y() const

Returns the grey level image of Y component

ByteImageC Red() const

Returns the red component of the color image

ByteImageC Green() const

Returns the green component of the color image

ByteImageC Blue() const

Returns the blue component of the color image

DoubleImageC RealY() const

Returns the intensity double image.

DoubleImageC RealRed() const

Returns the intensity double image of the red component.

DoubleImageC RealGreen() const

Returns the intensity double image of the green component.

DoubleImageC RealBlue() const

Returns the intensity double image of the blue component.

RGBImageC Rgb() const

Creates a new identifier for the image.

RealRGBImageC RealRgb() const

Returns the image of real RGB values.

YUVImageC Yuv() const

This image is treated as the intensity image. The function creates color image represented in Yuv color system. Y component is set according to this intensity image and cut. U and V component are zero.

RealYUVImageC RealYuv() const

This image is treated as the intensity image. The function creates color image represented in Yuv color system. Y component is set according to this intensity image. U and V component are zero.

Setting values in an image.

DoubleImageC & Fill(RealT value)

Fill the image with this value.

DoubleImageC & Frame(RealT value)

Draws a 1-pixel wide frame of this value round the image

Image statistics

RealT Max() const

Returns the maximal value in the image.

RealT Min() const

Returns the minimal value in the image.

RealT Mean() const

Returns the mean value in the image.

RealT MeanExBack() const

Returns the mean value in the image, the values BACKGROUND are not involved.

RealT Sum() const

Returns the sum of all values in the image.

DoubleImageC & BasicStatistics(RealT & minValue,RealT & maxValue,RealT & meanValue,RealT & sigma)

Estimates the image statistics, i.e. mean & standard deviation

DoubleImageC & BasicStatisticsExBackground(RealT & minValue,RealT & maxValue,RealT & meanValue,RealT & sigma)

Estimates the image statistics, i.e. mean & standard deviation ignoring pixels with BACKGROUND value

DoubleImageC LocalAverage(MaskSizeT len) const

Creates the image which values are averages. in neighborhood `len' x `len'.

Arithmetical operations

const DoubleImageC & operator+=(const RealT alpha)

Adds `alpha' to all pixel values.

const DoubleImageC & operator-=(const RealT alpha)

Subtracts `alpha' from all pixel values.

const DoubleImageC & operator*=(const RealT alpha)

Multiplies all pixel values by `alpha'.

const DoubleImageC & operator/=(const RealT alpha)

Divides all pixel values by `alpha'.

const DoubleImageC & operator+=(const DoubleImageC & image)

Adds `image' values pixel by pixel to `this' image.

const DoubleImageC & operator-=(const DoubleImageC & image)

Subtracts `image' values pixel by pixel from `this' image.

const DoubleImageC & operator*=(const DoubleImageC & image)

Multiplies all values of `this' image pixel-by-pixel.

const DoubleImageC & operator/=(const DoubleImageC & image)

Divides all values of `this' image pixel-by-pixel.

Grey level transformations

DoubleImageC & ScaleBy(const DoubleImageC & im,MaskSizeT len)

Scales this image by the image `im'. The image `im' is smoothed by local average using a mask of the size `len'. If this image is gradient image, this is equivalent to taking the log of the image before performing any operation.

DoubleImageC & Map(const RealT & aLow,const RealT & aHigh,const RealT & bLow,const RealT & bHigh)

Changes linearly all pixel values so that the interval of grey values is mapped onto interval .

DoubleImageC & AddToColumns(const RealArray1dC & r)

Every pixel values is added by the value from the corresponding column of the row `r'.

DoubleImageC & AddToRows(const RealArray1dC & c)

Every pixel values is added by the value from the corresponding column of the row `c'.

DoubleImageC & YZoom(const RealT & oldL,const RealT & newL,const RealT & gain)

All pixel values are changed using the linear transformation newValue = (oldValue - `oldL') * `gain' + `newL'.

Differential operators

const DoubleImageC & DiffRow(DoubleImageC & diffR) const

Differentiates the image along row, using central difference; returns result in diffR.

DoubleImageC & DiffRow()

Differentiates the image along row, using central difference; overwrites original image; result is shifted up one row.

const DoubleImageC & DiffCol(DoubleImageC & diffC) const

Differentiates the image along column, using central difference; returns result in diffC.

DoubleImageC & DiffCol()

Differentiate the image along column, using central difference; overwrites original image; result is shifted left one column.

const DoubleImageC & Diff(DoubleImageC & diffRow,DoubleImageC & diffCol) const

Differentiate the image along row and column, using central difference.

void Sobel(DoubleImageC & dr,DoubleImageC & dc) const

A more sensible version can be found within the Image Processing Operators classes

void MSobel(DoubleImageC & dr,DoubleImageC & dc) const

BUG: A failed attempt to provide a more efficient version of Sobel()

void Gauss(DoubleImageC & dr,DoubleImageC & dc,MaskSizeT len,RealT tau) const

For each direction (horizontally and vertically), convolved with 1D Gaussian (Array1dC::Gauss(...)) and differentiated (using DiffRow() and DiffCol()). The results are saved in the images `dr' and `dc' respectively. For Gaussian mask:

"len" is array size, rounded down to nearest odd no.
"tau" is ratio of cutoff to peak values (hence must be <= 1)

void Deriche(DoubleImageC & dr,DoubleImageC & dc,RealT alpha = 2.0,RealT omega = 0.001) const

The results of the application of Deriche's operator are saved in the images `dr' and `dc'.

DoubleImageC SqrComposition(const DoubleImageC & im2) const

Creates the image which values are ::Sqrt(sqr(*this)+sqr(im2)).

Thresholding

DoubleImageC & Threshold(const RealT thr,const RealT lowLabel,const RealT upLabel)

thresholding, if an image value >= thr, the output value is upLabel, otherwise lowLabel

DoubleImageC & LowThreshold(const RealT thr,const RealT lowLabel = 0.0)

thresholding, if an image value < `thr', the output value is lowLabel, otherwise the output value has the same value as the input one

DoubleImageC & DetectLevel(const RealT level,const RealT levelLabel,const RealT backgroundLabel)

if an image value == `level', then the output value is levelLabel, otherwise backgroundLabel

Convolutions

DoubleImageC & HorConvolution(const RealArray1dC & mask)

Convolves an image horizontally with a given mask

DoubleImageC & VerConvolution(const RealArray1dC & mask)

Convolves an image vertically with a given mask

DoubleImageC & Convolution45(const RealArray1dC & mask)

Convolves an image with a given mask in PI/4 direction. The mask elements must correspond to the inter-pixel distance ::Sqrt(2).

DoubleImageC & ConvolutionM45(const RealArray1dC & mask)

Convolves an image with a given mask in -PI/4 direction. The mask elements must correspond to the inter-pixel distance ::Sqrt(2).

DoubleImageC & Convolution2d(const RealArray2dC & mask)

2 dimensional convolution of an image with a given mask

Special operations

DoubleImageC & VerifyVerticalLineResponse(const RealT chiSqrThr,const RealArray1dC & idealResponse)

DoubleImageC & VerifyDiagonalLineResponse(const RealT chiSqrThr,const RealArray1dC & idealResponse)

DoubleImageC & Verify2DiagonalLineResponse(const RealT chiSqrThr,const RealArray1dC & idealResponse)

DoubleImageC & VerifyHorizontalLineResponse(const RealT chiSqrThr,const RealArray1dC & idealResponse)

ByteImageC WideDeltaEdgeDetection(const RealArray1dC & filter,const RealArray1dC & idealResponse,const RealArray1dC & smooth,const RealT chiSqrThr,const RealT mjuSmall,const RealT mjuBig,const IntT minLengthThr,const char lineKind,const BooleanT info = FALSE)

This subroutine detects ridge profiles. It first convolves the image by a filter optimized for ridge profile. The ridge peaks are extracted from the enhanced image by means of hysteresis thresholding. If `info' is TRUE the intermediate results are saved during processing.

ByteImageC WideDeltaEdgeDetection(const RealT d,const RealT l,const RealT chiSqrThr,const RealT mjuSmall,const RealT mjuBig,const IntT minLengthThr,const char lineKind,const BooleanT info = FALSE)

This subroutine detects ridge profiles. It first convolves the image by a filter optimized for ridge profile described by parameters `d' and `l'. The ridge peaks are extracted from the enhanced image by means of hysteresis thresholding. If `info' is TRUE the intermediate results are saved during processing.

ByteImageC SpotDetection(const RealT d,const RealT l,const RealT chiSqrThr,const RealT mjuSmall,const RealT mjuBig)

This subroutine detects spots. It first convolves the image by a filter optimized for spot profile described by parameters `d' and `l'. The spot peaks are extracted from the enhanced image by means of hysteresis thresholding.

IntT SpacekThinning()

Spacek's thinning of an edge image returns the number of edges deleted

DoubleImageC & VerNonMaxSuppression()

assign 0 to the pixel, if it is not a maximum from the 3 neighbouring pixels

DoubleImageC & HorNonMaxSuppression()

assign 0 to the pixel, if it is not a maximum from the 3 neighbouring pixels

RealT LinNonMaxSuppression(const DoubleImageC & drIm,const DoubleImageC & dcIm,const DoubleImageC & grad,RealT mean,BooleanT eightConnectivity = FALSE)

This image will be the result of linear non-maximum suppression method. The function returns the mean of maximum values.

ByteImageC HysteresisThresh(const RealT upThr,const RealT downThr)

Returns the image which pixels have different states. The state PROC_PXL means the pixel is not above the threshold `downThr'. The state UNPROC_PXL means the pixel does not belong to a string of pixels containing at least one pixel above the threshold `upThr'. The state IN_STRING means the pixel belongs to a string of edge pixels and it is a single pixel or it is inside of the string. The state JUNCT means the pixel belongs to at least three strings of edge pixels or it is the end pixel of a string.

Generating of synthetic images.

void GenerateBall(const PixelC center,const RealT radius,const RealT azimut,const RealT elevation,const RealT albedo)

Generates the ball with around the pixel `center' with the `radius'. The illumination direction is determined by the angles `azimut' [rad] and `elevation' [rad]. The surface of the ball is Lambertian with `albedo' in the range <0,1>.

void GenerateBall(const PixelC center,const RealT radius)

Generates the ball with around the pixel `center' with the `radius'.

Shape from shading.

DoubleImageC Reflectance(const RealT azimut,const RealT elevation,const RealT albedo) const

Returns the reflectance map of the image taken as a depth map. The reflectance map is generated for the illumination direction determined by the angles `azimuth' and `elevation' [rad]. The surface is supposed to be Lambertian with the `albedo'.

void TsaiShahShapeFromShading(DoubleImageC & snIm,DoubleImageC & znIm,const Vector3dC & illDirection,IndexT iterNumber)

A Simple Shape From Shading Algorithm by P.Tsai and M. Shah: CS-TR-92-24, Department of Computer Science, Technical Report, University of Central Florida, Orlando, FL 32816

void PreciseTsaiShahShapeFromShading(DoubleImageC & snIm,DoubleImageC & znIm,RealT ps,RealT qs)

One iteration of a simple shape from shading algorithm by P.Tsai and M. Shah: CS-TR-92-24, Department of Computer Science, Technical Report, University of Central Florida, Orlando, FL 32816

#include "amma/Image.hh"

ImageC<DoubleImageValueT> Copy() const: Creates another physical copy of this image.
void Copy(const ImageC<DoubleImageValueT> & image): Copies the contents of image "img" into this image.
void Copy(const ImageRectangleC & rect,const PixelC & newOrigin): Copies the region of the image defined by rectangle "rect" into the region whose origin is "newOrigin".
ImageAC * ACopy() const: A physical copy of this image.
ImageAC * AnotherImage() const: Creates a new empty image of the same type and size as this image is.
const ImageC<DoubleImageValueT> & operator=(const ImageC<DoubleImageValueT> & image): Assigment of a big object.
void ReflectUp(const ImageRectangleC & rect): Mirrors the image rectangle along its top edge.
void ReflectDown(const ImageRectangleC & rect): Mirrors the image rectangle along its bottom edge.
void ReflectLeft(const ImageRectangleC & rect): Mirrors the image rectangle along its left edge.
void ReflectRight(const ImageRectangleC & rect): Mirrors the image rectangle along its right edge.
void ReflectFrom(const ImageRectangleC & rect): Mirrors the image rectangle "rect" along its sides to fill the whole image.
void Rotate90(const ImageC<DoubleImageValueT> & originalImage): The values of image "originalImage" rotated about PI/2 rad and shifted to have the original upper-left corner and are saved into this image.
void Rotate180(const ImageC<DoubleImageValueT> & originalImage): The values of image "originalImage" rotated about PI rad and shifted to have the original upper-left corner and are saved into this image.
void Rotate270(const ImageC<DoubleImageValueT> & originalImage): The values of image "originalImage" rotated about 3/2*PI rad and shifted to have the original upper-left corner and are saved into this image.
ImageC<DoubleImageValueT> Rotate(const Point2dC & center,RealT angle,DoubleImageValueT background) const: The values of this image are rotated about "angle" (in rad) and saved to the result image.
Note the AMMA convention that the 1st or "x" coordinate of Point2dC is associated with the image row no., and the 2nd or "y" coordinate with the image column no.
void Rotate(const ImageC<DoubleImageValueT> & originalImage,const Point2dC & center,RealT angle,DoubleImageValueT background): The values of image "originalImage" rotated about "angle" rad are saved into this image.
Note the AMMA convention that the 1st or "x" coordinate of Point2dC is associated with the image row no., and the 2nd or "y" coordinate with the image column no.
void ShiftRowIndexes(const IndexT offset): Row indices of the items will be shifted by "offset".
There must be only one reference to this image.
For +ve "offset", the image is shifted down, or the coordinate system is shifted up.
void ShiftColIndexes(const IndexT offset): Column indices of the items will be shifted by "offset".
There must be only one reference to this image.
For +ve "offset", the image is shifted down, or the coordinate system is shifted up.
ImageC<DoubleImageValueT> Subsample(IntT factor = 2) const: returns an image subsampled by a factor of "factor"
void SetOrigin(const PixelC & newOrigin): The image coordinates are changed so that the top left pixel will have coordinates of "newOrigin".
There must be only one reference to this image.

Grey level operations.
ImageC<DoubleImageValueT> & Fill(DoubleImageValueT value): Fills the image with "value"
ImageC<DoubleImageValueT> & Frame(DoubleImageValueT value): Fills a 1-pixel-wide border around the image with "value"
ImageC<DoubleImageValueT> & Frame(DoubleImageValueT v,const ImageRectangleC & rect): Fills a 1-pixel-wide rectangle with "v";
the rectangle is the intersection of "this" with "rect".
ImageC<DoubleImageValueT> Pad(const ImageRectangleC & rect) const: Creates a new image whose frame is from "rect", with pixels copied from "this".
Where the new image lies outside "this", it is padded out with the nearest value from "this".

Logical conditions.
BooleanT IsValid() const: Returns FALSE if the image does not have a valid data area allocated

Access to pixels values.
const RangeBufferAccessC<DoubleImageValueT> operator[](IndexT r) const: Access to the row of the row of pixels.
RangeBufferAccessC<DoubleImageValueT> operator[](IndexT r): Access to the row of the row of pixels.
DoubleImageValueT & operator[](const Index2dC & pxl): Returns the content of the pixel.
const DoubleImageValueT & operator[](const Index2dC & pxl) const: Returns the content of the pixel.
DoubleImageValueT & operator[](const PixelC & pxl): Returns the content of the pixel.
const DoubleImageValueT & operator[](const PixelC & pxl) const: Returns the content of the pixel.
const DoubleImageValueT * CRow(PixelIndexT row) const: Access to the beginning of the row, eg. t
The returned pointer points to the first pixel of the "row".
DoubleImageValueT * Row(PixelIndexT row): Access to the beginning of the constant "row"
I.e. the returned pointer points to the first pixel of "row".
void Save(ostream & outS,BooleanT useHeader = TRUE) const: Saves templated image to stream.
For byte images it will save them in either PGM or PPM binary format. For other types it will save them in ascii if a suitable stream operator has been written for the templated class. NB. These treat images of ByteGreyValueT specialy, the image values are read as numbers not as charactors.
void Load(istream & outS,BooleanT useHeader = TRUE): Loads templated image type from ascii stream.
Should not be used for binary PGM/PPM files, but should work on most templated types. NB. These treat images of ByteGreyValueT specialy, the image values are written as numbers not as charactors.
DoubleImageValueT ** StartAddress() const: Returns the pointer to the table of pointers to image.
This being public is really only a hack! EXPERTS ONLY!
BufferRC<DoubleImageValueT> & Buffer(): Access buffer where data is stored.
const BufferRC<DoubleImageValueT> & Buffer() const: Access buffer where data is stored.
const DoubleImageValueT * CMemRow(PixelIndexT row) const: Access to the beginning of the constant allocated row
I.e. the returned pointer points to the first pixel of "row".
DoubleImageValueT * MemRow(PixelIndexT row): Access to the beginning of the allocated row
I.e. the returned pointer points to the first pixel of "row".

Error checking.
void ErrNotValid(char * functionName) const: Triggers the error event if this image does not contain any data.
void AllocData(): Allocates a memory for image.
void AllocData(DoubleImageValueT * value,BooleanT rowInv = false): Allocates a access vector to the memory with data
void DeallocAccess(): Deallocates the access vector to the memory with data.
void DeallocData(): Deallocates the access vector and the memory containing data.
RangeBufferAccessC<DoubleImageValueT> operator[](PixelIndexT row)
const RangeBufferAccessC<DoubleImageValueT> operator[](PixelIndexT row) const

#include "amma/BasImage.hh"

const ImageRectangleC & Rectangle() const: Returns the image rectangle.
const Index2dC & Origin() const: Returns the upper-left pixel coordinates of the image rectangle.
const Index2dC & End() const: Returns the lower right pixel coordinates of the image rectangle.
const ImageFileInfoC & ImageFileInfo() const: Access to the origin.
const BaseImageC & BaseImage() const: access to the constant object
BaseImageC & BaseImage(): access to the object
Modification of the object --------------------------
void SetRowSubRange(const IndexT newMin,const IndexT newMax): The range of indexes of the array will be constrained
void SetColSubRange(const IndexT newMin,const IndexT newMax): The range of indexes of the array will be constrained.
void SetSubRange(const ImageRectangleC & range): Constrains the domain of the image.
void SetFullRectangle(): Sets the working rectangle to be allocated rectangle of the image.
void SetImageFileInfo(ImageFileInfoC * newInfo): Sets a new image file information respecting the current size of the image.
BooleanT IsEmpty() const: Returns TRUE if the image has zero size
void ErrDifferentSize(const BaseImageC & image,char * functionName) const: Triggers an error event if this image has different size from `image'.
The functionName should be the name of the function that triggers the error event.
SizeT Rnum() const: Returns number of rows.
SizeT Cnum() const: Returns number of columns.
IndexT TRow() const: Returns the top row index.
IndexT LCol() const: Returns the left side column index.
IndexT BRow() const: Returns the bottom row index.
IndexT RCol() const: Returns the right side column index.
LongIntT Area() const: Returns the area of the image rectangle expressed in number of indexs.
UIntT Count() const: Returns the number of refrences to this object.
NB. The following definition is now obsolete, The value 0 means there is no other reference to this object.
const ImageRectangleC & AllocatedRect() const: Access allocated rectangle.
BooleanT IsBlock() const: Returns TRUE if the image is allocated as one block of memory.
const BaseImageC & operator=(const BaseImageC & image): Assigment (as a big object).
ImageFileInfoC * ChangeInfo(ImageFileInfoC * newInfo): Changes the information about the origin of the image.
The function returns the old information.
void ShiftRows(const IndexT offset): All indexes of the items will be shift by 'offset'.
void ShiftCols(const IndexT offset): All indexes of the items will be shift by 'offset'.
Error checking. ---------------
void ErrNotInRange(Index2dC i,char * functionName) const: Triggers the error event if the index 'i' is out of the image range.
void ErrNotInRange(IndexT r,char * functionName) const: Triggers the error event if the row 'r' is out of the image range.
void ErrNotInAllocRange(IndexT r,char * functionName) const: Triggers the error event if the row 'r' is out of the allocated image range.
ImageRectangleC LoadImageRect(istream &): Load image rectangle from stream.
This contains a hack to load the old coloumb/row stream correctly.

#include "amma/RefCount.hh"

BooleanT ToBeDeleted() const: Returns TRUE if the content should be deleted.
RCCountT Count() const: Returns the number of refrences to this object. NB. The following definition is now obsolete, The value 0 means there is no other reference to this object.
BooleanT IsSingleReference(): Tests is there is only one reference to this object.
const RefCounterC & operator=(const RefCounterC & rC)
BooleanT ToBeDeletedUpdate(const RefCounterC & rC): This function is the condition and the assigment together. It returns TRUE if the content should be deleted before assigning of the new object. The function automatically solves the reference counter of this object as well as the other object reference counter 'rC'.
void ReportInvalidObject(char * Msg = 0): This function reports an error to the user if a problem is detected in the refrence counting mechanism.

#include "amma/ImageA.hh"

ImageAC * ACopy() const: A physical copy of the image.
ImageAC * AnotherImage() const: Creates a new empty image of the same type and size as this image is.
const ImageRectangleC & Rectangle() const: Returns the working image rectangle.
void ShiftRowIndexes(const IndexT offset): all indexes of the items will be shift by 'offset'
void ShiftColIndexes(const IndexT offset): all indexes of the items will be shift by 'offset'
void SetRowSubRange(const IndexT newMin,const IndexT newMax): the range of indexes of the array will be constrained
void SetColSubRange(const IndexT newMin,const IndexT newMax): the range of indexes of the array will be constrained
const ImageFileInfoC & ImageFileInfo() const: access to the const origin

#include "amma/RefCBase.hh"

LabelT Label() const: Returns the label of this reference counter.
The member function is useful mainly to recognize objects during debugging. The value of the label is uniquely defined pointer.

Programmer:Radek Marik, Documentation by CxxDoc: Tue Mar 20 10:49:27 2001

DoubleImageCnvC

Conversions into/from the double image

include	"amma/DbImgCnv.hh"
User Level:	Default
Library:	ImageCnv
Example:	exIter.cc
Section:	Image.Converters
In Scope:	std