RegionPolynBoundC -

User Documentation

Centre for Vision, Speech & Signal Processing

Comments:
------------------------------------------------------------------- +++++++++ RegionPolynBoundC +++++++++++++++++++++++++++++++++++++++ ------------------------------------------------------------------- The class RegionPolynBoundC contains the description of the image region. The region is described by its boundary and the polynomial surface.

Parent Classes:

BoundaryC

PolynomialC

Variables:

Methods:

RegionPolynBoundC(BoundaryC & boundary,PolynomialC & pol,GreyValueT label): Creates the description of the region with the image surface aproximated by the polynomial 'pol' with the domain restricted by the 'boundary'. The region has got the 'label'.
RegionPolynBoundC(const RegionPolynBoundC & region): Copy constructor.
GreyValueT Label(): Returns the label of the region.

#include "amma/Boundary.hh"

AreaT Area() const: Get the area of the region which is determined by the 'boundary'.
DListC<BoundaryC> Order(const EdgeC & firstEdge,BooleanT orient = TRUE): Order the edgels of this boundary such that it can be traced continuously along the direction of the first edge. The orientation of the boundary is set according to 'orient'. If the boundary is open, 'firstEdge' and 'orient' are ignored.
BooleanT Orient() const: Return the orientation of the boundary.
BoundaryC & BReverse(): Revert the order of the edges.
BoundaryC Copy() const: Create a physical copy of the boundary.
EdgeCPtrListC ConvexHull() const: The convex hull is created from the original Jordan boundary using Melkman's method. Ref.: A V Melkman. On-line construction of the convex hull of a simple polyline. Information Processing Letters, 25(1):11-12, 1987. Ref.: M Sonka, V Hlavac: Image Processing.
EdgeCPtrListC ConvexHullMM() const: The convex hull is created from the original Jordan boundary using Marik&Matas's method.
IndexRectangleC BoundingBox() const: Get the bounding box of the boundary in "boundary's" coordinates.
void WriteCompressed(ostream & s) const: Save as ASCII characters in compressed format.
void ReadCompressed(istream & s): Read a boundary stored in compressed format. The current object is deleted.

#include "amma/Polynomi.hh"

PolynomialC & Polynomial()
const PolynomialC & Polynomial() const
SizeT Dim(SizeT var,SizeT order) const
SizeT Dim() const
SizeT VarsNumber() const
SizeT Order() const
PolynomialC Copy() const
PolynomialC & Set(const VectorC & vec)
PolynomialC & Set(const PolynomialC & pol)
const PolynomialC & operator=(const PolynomialC & pol): algebraic polynomials ======================
VectorC VarBase() const
VectorC VarBase(RealT x) const
VectorC VarBase(RealT x,RealT y) const
VectorC VarBase(RealT x,RealT y,RealT z) const
RealT Value() const
RealT Value(RealT x) const
RealT Value(RealT x,RealT y) const
RealT Value(RealT x,RealT y,RealT z) const
RealT DifValue(RealT f) const
RealT DifValue(RealT x,RealT f) const
RealT DifValue(RealT x,RealT y,RealT f) const
RealT DifValue(RealT x,RealT y,RealT z,RealT f) const
PolynomialC Dif(IndexT count) const
PolynomialC DifX(IndexT count) const
PolynomialC DifY(IndexT count) const
PolynomialC Dif() const
PolynomialC DifX() const
PolynomialC DifY() const
PolynomialC DifXY() const: Chebyshev polynomials ======================
VectorC VarBaseC() const
VectorC VarBaseC(RealT x) const
VectorC VarBaseC(RealT x,RealT y) const
VectorC VarBaseC(RealT x,RealT y,RealT z) const
RealT ValueC() const
RealT ValueC(RealT x) const
RealT ValueC(RealT x,RealT y) const
RealT ValueC(RealT x,RealT y,RealT z) const

#include "amma/Vector.hh"

VectorC Copy() const: physical copy of the object
Access to the element, to the vector. -------------------------------------
const VectorC & Vector() const: access to the constant object
VectorC & Vector(): access to the object
const VectorC & Point() const: access to the constant object
VectorC & Point(): access to the object
SizeT Dim() const: returns the number of items in the vector.
VectorC SubVector(const SizeT n) const: Returns the subvector created from the first 'n' elements of this vector. Set elements. -------------
VectorC & SetZero(): set all vector items to be 0
VectorC & Set(RealT x): sets vector items to x
VectorC & SetLast(RealT f): set the last element to be 'f'
VectorC & Set(const VectorC & vec): set vector according to another one
VectorC & Set(const VectorC & vec,const IndexT n): Sets the first 'n' items of this vector according to the vector 'vec'.
VectorC & Set(const IndexT i,const VectorC & vec,const IndexT n): Sets the first 'n' items beginning from the i-th one of this vector according to the vector 'vec'.
VectorC & Set(const MatrixC & mat): set items according to "mat" items
VectorC & SetUpperHalf(const MatrixC & mat): set items according to "mat" items in its upper half
VectorC & SetOddEven(const MatrixC & mat): set items according to "mat" items with odd or even indexes only
VectorC & SetOddEvenUpperHalf(const MatrixC & mat): set items according to "mat" items with odd or even indexes only in its upper half
VectorC & SetRandom(): set elements to be random
VectorC & SetRandom(RealT lo,RealT hi): set elements to be uniformly random between lo and hi
VectorC & Swap(IndexT i,IndexT j): Swaps the elements with the indexex 'i' and 'j'.
VectorC Join(const VectorC & Oth) const: Joint *this and 'Oth' vector into a new larger vector. The new vector contains this vector first followed by the 'Oth' vector. Arithmetic Operations. ----------------------
VectorC operator+(const VectorC & b) const: Returns the sum of two vectors.
VectorC operator-(const VectorC & b) const: Returns the diference between this vector and the vector 'b'.
VectorC operator*(const RealT alfa) const: Returns the multiplication of this vector by the scalar 'alpha'.
VectorC operator*(const VectorC & b) const: Returns the vector whose elements are the results of multiplication of this vector by the vector 'b' element by element.
VectorC operator/(const RealT alfa) const: Returns the division of this vector by the scalar 'alpha'.
VectorC operator/(const VectorC & b) const: Returns the vector whose elements are the results of division of this vector by the vector 'b' element by element.
VectorC & operator+=(const VectorC & b): add the vector 'b' to the vector
VectorC & operator+=(const RealT alpha): add the scalar to each element of the vector
VectorC & operator-=(const VectorC & b): subtract the vector 'b' from the vector
VectorC & operator-=(const RealT alpha): subtract the scalar from each element of the vector
VectorC & operator*=(const RealT alpha): multiply the vector by the scalar 'alpha'
VectorC & operator/=(const RealT alpha): divide the vector by the scalar 'alpha'
VectorC & operator/=(const VectorC & vec): (*this)[index] = (*this)[index]/vec[index]
VectorC & SetMul(const MatrixC & mat,const VectorC & vec): the vector is the result of the multiplication 'mat' * 'vec'
VectorC & operator*=(const VectorC & b): multiplication (*this)[i] *= b[i]
RealT TMul(const VectorC & b) const: multiplication 'RealT' = (*this).T() * b
MatrixC MulT(const VectorC & b) const: Multiplication 'MatrixC' = (*this) * b.T(). Vector Operations. ------------------
RealT Dot(const VectorC & v) const: scalar product of vectors
VectorC Cross(const VectorC & v) const: vector product of vectors
RealT Cross3(const VectorC & v) const: 3rd coor of crossproduct
MatrixC OuterP() const: The outer product of this vector with itself. In fact, the implementation is the same one for the member function MulT().
MatrixC OuterP(const VectorC & b) const: In fact, the implementation is the same one for the member function MulT().
RealT MakeUnit(): The vector is divided by its modulus. The original modulus is returned.
RealT Modulus() const: modulus of the vector
RealT SqrEuclidDistance(const VectorC & point) const: Returns the square of Euclid distance between this point and 'point'. Useful functions. -----------------
IndexT MaxIndex() const: Returns the index of the maximum element.
IndexT FirstSmallerIndex(const RealT thr) const: Returns the index of the first element which is smaller than the threshold 'thr'. If the vector does not contain an element smaller than 'thr' the return value is set to be a size of the vector (the index of the last element + 1).
IndexT FirstZeroIndex() const: Returns the index of the first zero element. If the vector does not contain an zero element the return value is set to be a size of the vector (the index of the last element +1).
RealT Sum() const: Returns the sum all elements of the vector.
RealT Product() const: Returns the product of all elements of the vector.
VectorC & Sqrt(): All elements of the vector are changed to their square root values. It is assumed that all elements of the vector are positive or zero.
VectorC & Reciprocal(): All elements of the vector are changed to their reciprocal values. It is assumed that all elements of the vector differs from zero.
VectorC SortStraight(): The map of indexes is returned.
VectorC & FixSmallToBeZero(RealT thr = 1e-12): All element whose absolute value is smaller than 'thr' are changed to be zero.

#include "amma/ReSArr1.hh"

RealSArray1dC Copy() const: Creates a new physical copy of the real array. Special operations. -------------------
RealSArray1dC operator*(const RealT & r) const: Multiples every item of the array by the real number 'r'.
const RealSArray1dC & operator+=(const RealSArray1dC & arr): Adds the array 'arr' to this array. The operation is performed on the overlapping part of the arrays only. The function returns this array.
const RealSArray1dC & operator-=(const RealSArray1dC & arr): Subtracts the array 'arr' to this array. The operation is performed on the overlapping part of the arrays only. The function returns this array.
const RealSArray1dC & operator*=(const RealT & r): Multiplies each element of this array by the real number 'r'.
const RealSArray1dC & operator/=(const RealT & r): Divides each element of this array by the real number 'r'.
void SetZero(): Sets all items of the array to be zero.
RealT MaxValue() const: Returns the maximum value saved in the array.
IndexT MaxIndex() const: Returns the index of the maximum value.
IndexT MinIndex() const: Returns the index of the minimum value.
IndexT MaxAbsIndex() const: Returns the index of the maximum absolute value.
RealT Sum() const: Returns the sum of all elements in the array.
RealSArray1dC & StraightSort(): Sorts the array into ascending numerical order by straight insertion. It is an N^2 routine, and should only be used for small N, say < 50.
RealSArray1dC & StraightSort(const SizeT n): Sorts the first n element of the array into ascending numerical order by straight insertion. It is an N^2 routine, and should only be used for small 'n', say < 50.
RealSArray1dC Join(const RealSArray1dC & it) const: Join this array with another.

#include "amma/SArray1d.hh"

SArray1dC<RealT> Copy() const: Creates a new physical copy of the array.
const SArray1dC<RealT> & operator=(const SArray1dC<RealT> & vv): Assigment, as for a BIG_OBJECT. Access to the object and its parts. -----------------------------------
const SArray1dC<RealT> & SArray1d() const: Access to the whole constant array.
SArray1dC<RealT> & SArray1d(): Access to the whole array. Modifications of the representation -----------------------------------
SArray1dC<RealT> Enlarge(const IntT factor = 2) const: Enlarges the array by item duplications. Every item is duplicated 'factor' times. The return array is extended by adding of higher indexes.
SArray1dC<RealT> & Append(const SArray1dC<RealT> & a): This array is extended by the length of the array 'a' and the contents of both arrays are copied to it. The function supports empty arrays.
SArray1dC<RealT> Join(const SArray1dC<RealT> & Oth) const: Join this Array and another into a new Array which is returned. This does not change either of its arguments. This is placed in the array first, followed by 'Oth'. Special operations ------------------
void DebugAddresses() const: Prints addresses into 'cerrAMMA'.
const BodyRefCounterC & RefCounter() const: Returns access to reference counter.
BufferRC<RealT> & Buffer(): Access base data buffer.
Experts only.
const BufferRC<RealT> & Buffer() const: Constant access base data buffer.
Experts only.

#include "amma/SBfAcc.hh"

const SizeBufferAccessC<RealT> & operator=(RealT * bp): Changes the reference element to the element pointed by 'bp'. Access to the object --------------------
RealT * ReferenceElm(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer.
void * ReferenceVoid(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer. The function is intended to be used in printing.
const BufferAccessC<RealT> & Access(void) const: Returns this object.
RealT * DataStart() const: Returns the address of the first element of the buffer.
SizeT N() const: Returns the number of elements of the array.
SizeT Size() const: Returns the number of elements of the array.
const BufferSizeC & Limits() const: Returns the usable range of indeces expressed by this object.
const BufferSizeC & Range() const: Returns the usable range of indeces expressed by this object.
IndexT IMin() const: Returns the minimum index of the range of this access.
IndexT IMax() const: Returns the maximum index of the range of this access.
const RealT & operator[](const IndexT i) const: Read-only access to the ('i'+1)-th element of the buffer.
RealT & operator[](const IndexT i): Read-write access to the ('i'+1)-th element of the buffer.
const SizeBufferAccessC<RealT> & SAccess(void) const: Returns this object. Logical functions -----------------
BooleanT IsEmpty() const: Returns TRUE if the size of the array is zero.
BooleanT Contains(const IndexT i) const: Returns TRUE if the array contains an item with the index 'i'. Modifications of the access ---------------------------
const BufferSizeC & ShrinkHigh(const SizeT k): Changes the number of elements by subtracting the last 'k' elements.
const SizeBufferAccessC<RealT> & Swap(SizeBufferAccessC<RealT> & a): Exchanges the contents of this buffer with buffer 'a'.
void Attach(const SizeBufferAccessC<RealT> & b): Changes this buffer access to have the same access rights as 'b'.
void Attach(const BufferAccessC<RealT> & b,const SizeT size): Changes this buffer access to have the access rights as 'b' limited for 'size' elements.
SizeBufferAccessC<RealT> operator+(const SizeT i) const: Creates the new access object shifted 'i' elements to the right (towards next elements). The size is descreased to fit the the original range of this access. Modifications of the buffer contents ------------------------------------
void Fill(const RealT & d): 'd' value is assigned to all elements of the buffer.
void CopyFrom(const SizeBufferAccessC<RealT> & oth): Copy contents of another buffer into this one.
NB. Buffers MUST be the same length.

Programmer:Radek Marik, Documentation by CxxDoc: Tue Mar 20 10:48:08 2001

RegionPolynBoundC

include	"amma/PolynRMo.hh"
User Level:	Default
Library:	RegModel
Example:	exImgSeq.cc
Section:	Image.Image Processing.Region Model
In Scope:	std