User Documentation
User Documentation
DEVELOP IN NAMESPACE AMMA TREE ROOT AMMA SEARCH AMMA HOME
 

namespace std

User Level:Default

Comments:

Child namespaces:
StdIO AMMA Configureation information.
StdAMMA
StdDList Some utility functions for dealing with DLists.
StdMath
MachineInfoC Access information about the machine we're running on.
StdSys
PThread
DPComposeST Single Threaded composition operators.
StdDP
DPComposeSE Single element composition.
DPComposeMT Multi-threaded composition operators.
SourceUtilsN Utilities for dealing with documentaions variables in header files.
StdUtil
CxxParser
SrcWizardN
StdSignalN
StdSpeechN Speech processing/generation routines.
RbfUtil Validate how well a RBF model describes the data
StdNumRec
StdImageN
IPSpatFilterN Namespace to define values for spatial filter parameters
XYZImage XYZ Image stuff.
StdGUI
StdView
StudioN
VLModelDL Some expression types used in DL Models.
DarkCastle
ImageDb
SearchUtil
Child Classes:

#include "amma/BitSet16.hh"

BitSet16C Class BitSet16C is the set of 16 logical flags.
#include "amma/StdConst.hh"

StdConstC Standard constants
#include "amma/StdError.hh"

ExceptionC General Error.
ErrorCastC Casting exception class.
ErrorOutOfRangeC Exception: Out of range.
ErrorOperationFailedC Exception: Out of range.
ExceptionExitC Exit program with message and return code.
ErrorNotImplementedC Report an unimplemented function.
#include "amma/IntC.hh"

IntC Simple integer.
UIntC Simple unsigned integer.
#include "amma/DP/SubSequenceSpec.hh"

SubSequenceSpecC Specification for sub sequence.
#include "amma/DP/EditSpec.hh"

EditSpecC Edit spec.
#include "amma/DP/PlayList.hh"

PlayListC Play list.
#include "amma/DP/CompositeStream.hh"

CompositeIStreamC Input Stream Composition.
CompositeOStreamC Output Stream Composition.
#include "amma/DP/FileFormatComposite.hh"

FileFormatCompositeC Create an instance of a stream File Format.
#include "amma/ConfigFile.hh"

ConfigFileC Config file.
#include "amma/Packet.hh"

NetPacketC High level network packet.
#include "amma/NetEndPoint.hh"

NetEndPointC An end point for a network packet base protocol.
#include "amma/NetMessage.hh"

NetMsgRegisterC Net message handle.
#include "amma/NetMsgCall.hh"

NetMsgCall0BodyC
NetMsgCall0C
NetMsgCall1BodyC
NetMsgCall1C
NetMsgCall2BodyC
NetMsgCall2C
#include "amma/NetMsgSig.hh"

NetMsgSig0BodyC Net message Signal0
NetMsgSig0C Net message Signal0
NetMsgSig1BodyC Net message Signal1
NetMsgSig1C Net message Signal1
NetMsgSig2BodyC
NetMsgSig2C
#include "amma/NumericalErrors.hh"

ErrorNumericalC Report a general numerical error.
ErrorDivideByZeroC Report a division by zero.
#include "amma/Empty.hh"

EmptyC Empty data class.
#include "amma/Pair.hh"

PairC Pair of homogenious objects
#include "amma/BinStream.hh"

BinIStreamC Machine independant binary input stream.
BinOStreamC Machine independant binary output stream.
#include "amma/Tuple3.hh"

Tuple3C Class containing 3 other classes.
#include "amma/Tuple2.hh"

Tuple2C Class containing two other arbitary classes
#include "amma/Tuple4.hh"

Tuple4C Class containing 4 other classes.
#include "amma/BRefCnt.hh"

BodyRefCounterC Reference counter for huge dynamic objects
#include "amma/RCHandle.hh"

RCHandleC Template for a hanle class.
#include "amma/RCWrap.hh"

RCWrapBaseC This is a wrapper template to take an unrefrence counted object and make it refrence counted.
RCWrapC This is a wrapper template to take an unrefrence counted object and make it refrence counted.
#include "amma/BRefCntV.hh"

BodyRefCounterVC Body refrence counted object with virtual destructor.
#include "amma/RCAbstract.hh"

RCAbstractC Abstract handle class for any object derived from BodyRefCounterVC.
#include "amma/ERefCnt.hh"

ExtRefCounterC Externaly refrence counter object handle.
#include "amma/ERCHandle.hh"

ERCHandleC Externally refrence counter object handle.
#include "amma/RCHandleA.hh"

RCHandleAC RCHanleC with extentions to use abstract handles.
#include "amma/Index.hh"

IndexC Index class for indexing 1D arrays: an integer class with modified rounding and other operations
#include "amma/IndexR1d.hh"

IndexRangeC 1D index range of array
#include "amma/BuffSize.hh"

BufferSizeC Buffer size
#include "amma/SBfAccIter.hh"

SizeBufferAccessIterC
#include "amma/SBfAccIter2.hh"

SizeBufferAccessIter2C
#include "amma/SBfAccIter3.hh"

SizeBufferAccessIter3C
#include "amma/SBfAccRangeIter.hh"

SizeBufferAccessRangeIterC simple iterator for SizeBufferAccessC limited to some elements of the buffer.
#include "amma/RBfAccIter.hh"

RangeBufferAccessIterC
#include "amma/RBfAccIter2.hh"

RangeBufferAccessIter2C
#include "amma/RBfAccIter3.hh"

RangeBufferAccessIter3C
#include "amma/BooSArr1.hh"

BoolSArray1dC A simple 1 dimensional array of logical variables
#include "amma/SArr1Iter.hh"

SArray1dIterC SArray1d iterator.
#include "amma/Array1d.hh"

Array1dC 1 Dimensional array
#include "amma/SArray1d.hh"

SArray1dC A simple 1 dimensional array
#include "amma/SDArray1d.hh"

SDArray1dC1D Simple Dynamic Array.
#include "amma/SArr1Iter2.hh"

SArray1dIter2C Duel SArray1d iterator.
#include "amma/SArr1Iter3.hh"

SArray1dIter3C Triple SArray1d iterator.
#include "amma/SArr1Iter4.hh"

SArray1dIter4C Quad SArray1d iterator.
#include "amma/SArr1RangeIter.hh"

SArray1dRangeIterC SArray1d iterator.
#include "amma/SArr2Iter.hh"

SArray2dIterC SArray2dC iterator.
#include "amma/SArray2d.hh"

SArray2dC Simple 2 dimentional array.
#include "amma/SArr2Iter2.hh"

SArray2dIter2C Duel SArray2dC iterator.
#include "amma/SArr2RangeIter.hh"

SArray2dRangeIterC SArray2RangedC iterator.
#include "amma/SArr2Iter3.hh"

SArray2dIter3C Triple SArray2dC iterator.
#include "amma/SArr3Iter.hh"

SArray3dIterC
#include "amma/SArr3RangeIter.hh"

SArray3dRangeIterC
#include "amma/SArray3d.hh"

SArray3dC Simple 3 dimentional array
#include "amma/SArr3Iter2.hh"

SArray3dIter2C Duel SArray3dC iterator.
#include "amma/SArr3Iter3.hh"

SArray3dIter3C Triple SArray3dC iterator.
#include "amma/IndexR2d.hh"

IndexRange2dC An index range of a 2D array
#include "amma/IndRect.hh"

IndexRectangleC Rectangle parallel with to axis
#include "amma/DirRLUD.hh"

DirectionRLUDC Direction Right-Left-Up-Down
#include "amma/Index2d.hh"

Index2dC 2 Dimensional index
#include "amma/IndexNd.hh"

IndexNdC N-dimensional index
#include "amma/Index3d.hh"

Index3dC Index of a 3-D array
#include "amma/IndNeig2.hh"

IndexNeigh2dC Index neighbourhood in 2d grid
#include "amma/Arr1Iter.hh"

Array1dIterC Array1dC iterator.
#include "amma/Arr1Iter2.hh"

Array1dIter2C dual Array1dC iterator.
#include "amma/ArrStack.hh"

ArrayStackC Stack, array based.
ArrayStackIterC Array stack iterator.
#include "amma/Arr1Iter3.hh"

Array1dIter3C triple Array1dC iterator.
#include "amma/Array2d.hh"

Array2dC 2 Dimensional array
#include "amma/Arr2Iter.hh"

Array2dIterC Array1dC iterator.
#include "amma/Array3d.hh"

Array3dC 3 Dimensional Array
#include "amma/Arr3Iter.hh"

Array3dIterC Array1dC iterator.
#include "amma/IntrDLst.hh"

IntrDListC Double-linked circular list
MergeSortIntr
#include "amma/InCDLIte.hh"

IntrConstDLIterC Double-linked circular list iterator
#include "amma/IntrDLst.hh"

IntrMergeSort
IntrMergeSortCmpPtr
#include "amma/InDLIter.hh"

IntrDLIterC Double-linked circular list iterator
#include "amma/BoCDLIte.hh"

BodyConstDLIterC Double-linked circular list iterator
#include "amma/DList.hh"

DListC The DListC class represents double-linked list of elements
#include "amma/CDLIter.hh"

ConstDLIterC The class 'ConstDLIterC' is a representation of iterator on a constant double-linked list.
#include "amma/DLIter.hh"

DLIterC DListC iterator
#include "amma/QuickSort.hh"

SortComparisonC
#include "amma/USInDLIt.hh"

USIntrDLIterC
#include "amma/PriQueue.hh"

PriQueueC Array based priority queue.
#include "amma/PriQueueL.hh"

PriQueueLC Pointer based version of Priority Queue.
#include "amma/BlkQueue.hh"

q_Blk
BlkQueueG Basic Queue.
BlkDQueueG Queue which alows items to be removed from both ends.
#include "amma/StackIt.hh"

StackIterG Stack iterator.
#include "amma/Stack.hh"

StackG Templated stack.
#include "amma/SLIter.hh"

SLIterC Non-constant, Singly Linked list iterator
SLConstIterC Quick, Simple & Const Singly Linked list iterator.
#include "amma/SLList.hh"

SLListC Single Linked List.
#include "amma/HashIter.hh"

HashIterC Hash table iterator.
#include "amma/Hash.hh"

HashC General hash table.
#include "amma/HSet.hh"

HSetIterC Set Iterator.
HSetC Set of objects.
#include "amma/HashAR.hh"

HashARC Auto resizing hash-table.
#include "amma/RCHashAR.hh"

RCHashARC Refrence counted auto-resizing hash table.
#include "amma/BiHash.hh"

BiHashIterC Bi-directional hash table iterator
BiHashARC Bi-directional hash table.
#include "amma/Graph.hh"

GraphC Reference counted graph.
#include "amma/GraphT.hh"

GraphTC Templated graphs.
#include "amma/GraphEdge.hh"

GraphNodeIterC Node iterator.
GraphNodeHC Node handle.
#include "amma/GraphLinearIter.hh"

GraphLinearIterC Linear graph iterator.
#include "amma/GraphAdj.hh"

GraphAdjIterC Adjacency iterator.
#include "amma/GrConnIt.hh"

GraphConnIterC Connected node iterator.
#include "amma/DAGraph.hh"

DAGraphMarkerC Directed graph marker.
DAGraphC Directed graph.
#include "amma/Bucket.hh"

BucketC The class Bucket represents a container of items which can be addressed using an integer number (called bucket) of limited range <0, n).
#include "amma/Ring.hh"

RingBuffC Fixed size circular ring buffer.
#include "amma/RandBag.hh"

RandomBagC A collection of data from which items are drawn at random.
#include "amma/RingIter.hh"

RingBuffIterC Iterate through the contents of a ring buffer.
#include "amma/KwList.hh"

KIter1C
KNodeC
KListC
HelpC
#include "amma/ShiftReg.hh"

ShiftRegC Template class for a shift register based on simple 1-D array
#include "amma/BStack.hh"

BStackC Branching stack.
#include "amma/BList.hh"

BListIterC Iterate through a branching list.
BListC Branching list.
#include "amma/BGEdgeIter.hh"

BGraphAdjIterC BGraph Adjacency iterator.
#include "amma/BGNodeIter.hh"

BGraphNodeIterC Interate through nodes in a BGraph.
#include "amma/BGraphNode.hh"

BGraphNodeHC BGraph node handle
#include "amma/BLinIter.hh"

BGraphLinearIterC Graph linear iterator.
#include "amma/BGraph.hh"

BGraphC Branching graph.
#include "amma/BGBaseIter.hh"

BGraphBaseAdjIterC
#include "amma/BGraphEdge.hh"

BGraphEdgeHC BGraph edge handle.
#include "amma/BDAGraph.hh"

BDAGraphC
BDAGraphMarkerC
#include "amma/BGBaseIter.hh"

BGraphBaseNodeIterC
#include "amma/BHashInt.hh"

BHashIntC Branching Hash table.
#include "amma/StdType.hh"

StdTypeC The class StdTypeC defines all standard types in AMMA library.
#include "amma/String.hh"

StringC A reference-counted string.
SubStringC Sub-string within a larger string.
#include "amma/TextLine.hh"

TextLineC
#include "amma/rx.h"

Regex
#include "amma/Complex.hh"

ComplexC Complex algebra
#include "amma/FBOrient.hh"

FBOrientationC 2 Direction orientation
#include "amma/Dir8RLUD.hh"

Direction8RLUDC Direction Right-Left-Up-Down for 8-neighbohrhood
#include "amma/CrackCod.hh"

CrackCodeC Crackcode or Freeman code
#include "amma/ImageRec.hh"

ImageRectangleC Rectangular area used for images.
#include "amma/Point2d.hh"

Point2dC Point in 2D space
#include "amma/Chromati.hh"

ChromaticityC Chromaticity value of colour
#include "amma/Pixel.hh"

PixelC Pixel image coordinates
#include "amma/TimeCode.hh"

TIMECODE
TimeCodeC
#include "amma/ScalMath.hh"

ExtMathC The class ExtMathC is a collection of special higher transcendental functions.
#include "amma/Angle.hh"

AngleC This class is designed to deal with angles in radians. it keeps the values normalised.
#include "amma/Stream.hh"

StreamBaseC
OStreamC Standard output streams with refrence counting.
IStreamC Standard input streams with refrence counting.
#include "amma/TypeName.hh"

TypeNameC Register typename.
#include "amma/StrStream.hh"

OStrStreamC Output stream to memory.
IStrStreamC Input stream from memory.
#include "amma/VirtCon.hh"

VCInstC Virtual Constructor Instance.
VCExInstC Extended virtual constructor.
#include "amma/StreamType.hh"

StreamTypeC
#include "amma/BufStream.hh"

OBufStreamC Output stream to memory.
IBufStreamC Input stream from memory.
#include "amma/BitStream.hh"

IBitStreamC Input bit stream
OBitStreamC Output bit stream.
#include "amma/IntSArr1.hh"

IntSArray1dC A simple 1 dimensional array of integers
#include "amma/ReSArr1.hh"

RealSArray1dC A simple 1 dimensional array of real numbers
#include "amma/NArray1d.hh"

NumArray1dC 1 dimensional numerical array
#include "amma/NArray2d.hh"

NumArray2dC A 2 dimensional numerical array
#include "amma/IntArr1d.hh"

IntArray1dC Array of integers
#include "amma/LinearS2.hh"

LinearSums2dC The class LinearSums2dC serves for computation of linear dependences in 2D space.
#include "amma/ReArr1d.hh"

RealArray1dC 1 Dimensional real array
#include "amma/IntArr2d.hh"

IntArray2dC The class IntArray2dC represent 2-dimensional rectangular numerical array of integers.
#include "amma/ReArr2d.hh"

RealArray2dC 2 dimensional real array
#include "amma/StrList.hh"

StringListC Class of lists of strings
#include "amma/RectSet.hh"

IndexRectangleSetC Rectangle set.
#include "amma/pixchain.hh"

CannyStringSetC
#include "amma/GMLinesG.hh"

GMLinesGfC gf file sets - a set of lines by George Matas
#include "amma/PGgf.hh"

GfSetC Geometric feature set - can be points, line segments, point sets etc.
GfSetsC The class GfSetsC represents a set of heterogenous geometric feature sets
#include "amma/Option.hh"

OptionC The class OptionC is a simple parser of a command line.
#include "amma/Date.hh"

DateC Date & Time information.
#include "amma/Filename.hh"

FilenameC StringC representing a filename.
#include "amma/Directory.hh"

DirectoryC Directory handling.
#include "amma/UserInfo.hh"

UserInfoC User information.
#include "amma/FilePerm.hh"

FilePermissionC Unix style file permisions.
#include "amma/DeadLine.hh"

DeadLineTimerC Dead line timer.
#include "amma/ChildProc.hh"

ChildProcessC Child process handle.
#include "amma/Process.hh"

ProcessC Process handle.
#include "amma/ProcInfo.hh"

ProcessInfoC Process Information.
#include "amma/SerialIO.hh"

SerialCtrlC Class to control unix serial ports.
OSerialC Output serial stream.
ISerialC Input serial stream.
IOSerialC Input/Output serial stream.
#include "amma/PThread/Thread.hh"

ThreadC Thread handle.
#include "amma/PThread/Mutex.hh"

MutexC Mutual Exclusion lock.
MutexLockC Mutex locking class.
#include "amma/PThread/RWLock.hh"

RWLockC Read/Write lock.
RWLockHoldC RWLock locking class.
#include "amma/PThread/Conditional.hh"

ConditionalC Conditional variable.
#include "amma/PThread/SemaphoreRC.hh"

SemaphoreRC Semaphore.
#include "amma/PThread/Event.hh"

BEventC Broadcast Event.
#include "amma/PThread/Semaphore.hh"

SemaphoreC Semaphore.
#include "amma/PThread/MsgPipe.hh"

MsgPipeC Message MsgPipe
#include "amma/PThread/Launch.hh"

LaunchEventC Launch event handle.
#include "amma/PThread/EventHandler.hh"

SignalEventBodyC Signal Event handle
SignalEventC Signal Event handle
SignalEventHandlerC Event handler.
SignalEventFunc0BodyC Signal Event handle
SignalEventFunc0C Signal Event handle
SignalEventFunc1BodyC Signal Event handle
SignalEventFunc1C Signal Event handle
SignalEventFunc2BodyC Signal Event handle
SignalEventFunc2C Signal Event handle
SignalEventFunc3BodyC Signal Event handle
SignalEventFunc3C Signal Event handle
SignalEventMethod0BodyC Signal Event handle
SignalEventMethod0C Signal Event handle
SignalEventMethod1BodyC Signal Event handle
SignalEventMethod1C Signal Event handle
SignalEventMethod2BodyC Signal Event handle
SignalEventMethod2C Signal Event handle
SignalEventMethod3BodyC Signal Event handle
SignalEventMethod3C Signal Event handle
SignalEventMethod4BodyC Signal Event handle
SignalEventMethod4C Signal Event handle
SignalEventMethod5BodyC Signal Event handle
SignalEventMethod5C Signal Event handle
#include "amma/PThread/Ticker.hh"

TickerEventC Ticker event handle.
#include "amma/PThread/EventHandlerRef.hh"

SignalEventMethodRef0BodyC Signal Event handle
SignalEventMethodRef0C Signal Event handle
SignalEventMethodRef1BodyC Signal Event handle
SignalEventMethodRef1C Signal Event handle
SignalEventMethodRef2BodyC Signal Event handle
SignalEventMethodRef2C Signal Event handle
SignalEventMethodRef3BodyC Signal Event handle
SignalEventMethodRef3C Signal Event handle
#include "amma/DP/Port.hh"

DataNotReadyC Exception, Data Not Ready.
DPPlugC Plug.
DPIPortC Input port.
DPOPortC Output port.
DPIOPortC Input/Output port.
#include "amma/DP/Process.hh"

DPProcessBaseC Process handle base.
DPProcessC Templated process handle.
#include "amma/DP/ProcIOStream.hh"

DPProcessStreamC Process a stream of data.
#include "amma/DP/ProcIStream.hh"

DPProcIStreamC Convert process into input stream operator, handle.
#include "amma/DP/ProcCompose.hh"

DPComposeProcessC Mix two processes.
#include "amma/DP/FileIO.hh"

DPOFileC File output stream.
DPIFileC File input stream.
#include "amma/DP/RunningAve.hh"

DPRunningAverageC Running average on a stream of data.
#include "amma/DP/OffsetScale.hh"

DPOffsetScaleC OffsetScale a stream of data.
#include "amma/DP/Multiplex.hh"

DPMultiplexC Multiplex an operation.
#include "amma/DP/Task.hh"

DPTaskC Task handle.
#include "amma/DP/TaskThread.hh"

DPTaskThreadC Task based processing thread.
#include "amma/DP/IOConnect.hh"

DPIOConnectC Connect some IOPorts.
#include "amma/DP/TaskList.hh"

DPTaskListC List of tasks.
#include "amma/DP/SplitO.hh"

DPSplitOC Output port Splitter handle.
#include "amma/DP/Multiply.hh"

DPMultiplyC Multiply a stream of data by a value.
#include "amma/DP/StreamOp.hh"

DPIStreamOpC Stream operation handle class.
DPOStreamOpC Stream operation handle class.
#include "amma/DP/FrameInfo.hh"

FrameC FrameInfo.
FrameInfoC FrameInfo.
#include "amma/DP/RCWrapPort.hh"

IPortRCWrapBodyC
IPortRCWrapC
#include "amma/DP/Func2Stream.hh"

DPFuncIStreamC Wrapped function input stream.
DPFuncOStreamC Wrapped function output stream.
#include "amma/DP/IOTap.hh"

DPIOTapC Tap handle.
#include "amma/DP/Process2.hh"

DPProcess2BaseC Process handle base.
DPProcess2C Templated process handle.
#include "amma/DP/Convert.hh"

DPConvertC Convert a stream of data.
#include "amma/DP/ProcOStream.hh"

DPProcOStreamC Wrapped Proccess handle.
#include "amma/DP/ProcInfo.hh"

DPProcInfoC Process information.
#include "amma/DP/Process3.hh"

DPProcess3BaseC Process handle base.
DPProcess3C Templated process handle.
#include "amma/DP/IFailOver.hh"

DPIFailOverC Fail over input switch.
#include "amma/DP/Proc2IStream.hh"

DPProc2IStreamC Uses 2 arg process in input stream.
#include "amma/DP/Proc3IStream.hh"

DPProc3IStreamBodyC Uses 2 arg process in input stream.
DPProc3IStreamC
#include "amma/DP/Tap.hh"

DPTapC Tap process.
#include "amma/DP/IOJoin.hh"

DPIOPortJoinC Join an IPort and a OPort
#include "amma/DP/SPort.hh"

DPSeekCtrlC Stream position control handle class.
DPISPortC Seekable port input handle.
DPOSPortC Seekable port ouput handle.
#include "amma/DP/FuncP2Proc.hh"

DPFuncP2ProcC Function ptr to process handle.
#include "amma/DP/Pipes.hh"

DPIPipeBaseC Pipe base.
DPOPipeBaseC Pipe base body.
#include "amma/DP/EventSet.hh"

DPEventSetC Set of events.
#include "amma/DP/BinFileIO.hh"

DPOBinFileC File output stream.
DPIBinFileC File input stream.
#include "amma/DP/ProcInfo1.hh"

DPProc1InfoC Class for registering 1 arg processes.
#include "amma/DP/SPortAttach.hh"

DPSeekCtrlAttachC Seek Control attach.
DPISPortAttachC Seek control attach.
DPOSPortAttachC Seek control attach.
#include "amma/DP/MethodIO.hh"

DPOMethodC Send objects to a class method.
DPIMethodC Get objects from a class method.
#include "amma/DP/Converter.hh"

DPConverterBaseC Converter base class
DPConverterC Type conversion handle.
DPConverterFuncC Setup data conversion function.
#include "amma/DP/FileFormatStream.hh"

FileFormatStreamC Create an instance of a stream File Format.
#include "amma/DP/FileFormat.hh"

FileFormatC Templated File format
FileFormatBaseC File format base handle.
#include "amma/DP/FileFormDesc.hh"

FileFormatDescC File Format descriptor.
#include "amma/DP/TypeInfo.hh"

DPTypeInfoC Type information handle.
DPTypeInfoInstBodyC Type information instance body.
DPTypeInfoInstC Type information instance body.
#include "amma/DP/FileFormatBinStream.hh"

FileFormatBinStreamC Create an instance of a stream File Format.
#include "amma/DP/FileSeq.hh"

DPFileSequenceBaseBodyC File Sequence body.
DPFileSequenceBaseC File Sequence.
DPIFileSequenceC Input File Sequence
DPOFileSequenceC Input File Sequence
#include "amma/DP/Stream2DList.hh"

DPOStream2DListC Turn a stream into a list.
DPIStream2DListC Turn a stream into a list.
#include "amma/DP/FileFormatDList.hh"

FileFormatDListC Create an instance of a stream File Format.
#include "amma/DP/FileFormatDynamic.hh"

FileFormatDynamicC Labeled Lines sets.
#include "amma/DP/FileFormatGen.hh"

FileFormatGenericC Generic format loader.
#include "amma/DP/FuncPort.hh"

DPFuncIPortBodyC
DPFuncIPortC
DPFuncOPortBodyC
DPFuncOPortC
#include "amma/DP/Buffer.hh"

DPBufferC MT safe queue handle.
#include "amma/DP/FixedBuffer.hh"

DPFixedBufferC MT safe queue handle.
#include "amma/DP/PlayControl.hh"

DPPlayControlC Base play control handle class.
DPIPlayControlC Stream operation handle class.
#include "amma/DP/SplitI.hh"

DPSplitIPortC SplitI output handle.
DPSplitIC SplitI input handle
#include "amma/DP/Hold.hh"

DPHoldC Hold value until replaced by put.
#include "amma/DP/Signal.hh"

Signal0C Signal 0 handle.
SignalConnectorC Signal connector handle.
SignalInterConnect0C class for signal interconnector with 0 args.
Signal0FuncC Signal a function
Signal0MethodC Signal a method.
Signal0MethodRefC Signal a method.
#include "amma/DP/Signal1.hh"

Signal1C Signal 1 handle.
SignalInterConnect1C class for signal interconnector with 1 arg.
Signal1FuncC Signal a function
Signal1MethodC Signal a method.
Signal1MethodRefC Signal a method.
#include "amma/DP/Signal2.hh"

Signal2C Signal 1 handle.
SignalInterConnect2C class for signal interconnector with 1 arg.
Signal2FuncC Signal a function
Signal2MethodC Signal a method.
Signal2MethodRefC Signal a method.
#include "amma/DP/Signal3.hh"

Signal3C Signal 1 handle.
SignalInterConnect3C class for signal interconnector with 1 arg.
Signal3FuncC Signal a function
Signal3MethodC Signal a method.
Signal3MethodRefC Signal a method.
#include "amma/DP/SigConnectionSet.hh"

SignalConnectionSetC Signal connection set body.
#include "amma/DP/GFPortIO.hh"

DPIGFPortC Load a GfSet
DPOGFPortC Save a GfSet
#include "amma/DP/FileFormatGFSet.hh"

FileFormatGFSetC GF File format.
#include "amma/DP/LLinesIO.hh"

DPILabeledLineSetTextC Load a labeled line set in text format.
DPOLabeledLineSetTextC Save a labeled line set in text format.
#include "amma/DP/LLinesIOB.hh"

DPILabeledLineSetTextBodyC Load a labeled line set in text format.
DPOLabeledLineSetTextBodyC Save a labeled line set in text format.
#include "amma/DP/FileFormatLLines.hh"

FileFormatLabeledLineSetTextC Labeled Lines sets.
#include "amma/DP/Governor.hh"

DPGovernorBaseC Governor base Handle.
DPGovernorC Governor Handle.
#include "amma/DP/TimeMark.hh"

DPDateMarkC Mark the date.
DPTimeMarkC Mark the time.
#include "amma/DP/WriteGF.hh"

DPWriteGFC Write stream to GF file.
#include "amma/DP/FileFormatVecText.hh"

FileFormatVectorTextC Create a vector file format.
#include "amma/DP/TimeStamp.hh"

DPTimeStampC Time Stamp Handle.
#include "amma/DP/VectorIOText.hh"

DPIVectorTextC Load a vector in text format.
DPOVectorTextC Save a vector in text format.
#include "amma/DP/VectorIOTextB.hh"

DPIVectorTextBodyC Load a vector in text format.
DPOVectorTextBodyC Save a vector in text format.
#include "amma/DP/SeqSlice.hh"

DPSeqSliceBaseC SeqSlice base Handle.
DPSeqSliceC SeqSlice Handle.
#include "amma/DP/DataVLText.hh"

DPINumVLDataTextC Load a vector in text format.
DPONumVLDataTextC Save a vector in text format.
#include "amma/DP/DataVLTextB.hh"

DPINumVLDataTextBodyC Load a vector in text format.
DPONumVLDataTextBodyC Save a vector in text format.
#include "amma/DP/FileFormatVLText.hh"

FileFormatNumVLDataTextC Create a vector file format.
#include "amma/DP/NumLabelText.hh"

DPINumLabelTextC Load a label in text format.
DPONumLabelTextC Save a label in text format.
#include "amma/DP/FileFormatLabelText.hh"

FileFormatNumLabelTextC Text file format describing a set of NumLabel's
#include "amma/TextBase.hh"

TextPFileBaseC
#include "amma/TxtFLine.hh"

TextPFileLineC
#include "amma/TxCursor.hh"

TextCursorC Cursor in text buffer.
#include "amma/TxtPFile.hh"

TextPFileC Text File, for use in text processing.
#include "amma/HtmlFile.hh"

HtmlFileC
#include "amma/LiNumTxt.hh"

TextPFileLNC
#include "amma/TemplateFile.hh"

TemplateFileC Subsitute variables in a template file.
#include "amma/TxtFragment.hh"

TextFragmentC
#include "amma/TemplateCmplx.hh"

TemplateComplexC Setup new command.
TemplateComplexBodyC
#include "amma/NetStream.hh"

ONetStreamC Output stream to memory.
INetStreamC Input stream from memory.
#include "amma/Socket.hh"

SocketC Socket connection handle.
#include "amma/SktError.hh"

ExceptionNetC Networking exception.
#include "amma/TimeRep.hh"

TimeRepG Time representation.
RealTimeRepG Real time.
VirtTimeRepG Virtual time.
#include "amma/Timer.hh"

TimerG Basic timer stuff.
RealTimerG Real-time timer.
VirtTimerG
#include "amma/DocEntry.hh"

DocPageC
DocNodeC
#include "amma/DocEHT.hh"

DocEHTC Class for reading .eht files
#include "amma/util/SrcCheck.hh"

SrcCheckC Go through source tree..
#include "amma/util/DefFile.hh"

DefMkFileC Interograte a defs.mk file.
#include "amma/util/HdrUpdate.hh"

HdrUpdateC Update documentation variables at the top of header files.
#include "amma/util/RCSFile.hh"

RCSFileC Body class for dealing with RCS files.
RCSVersionC Class representing an RCS version number.
#include "amma/util/PatchMods.hh"

SrcPatchModsC
#include "amma/util/SrcMerge.hh"

VerDBInfoC Save version DB.
SrcMergeC
#include "amma/util/SrcInst.hh"

SrcInstC Create new directories in a source mirror.
#include "amma/util/SrcFunc.hh"

SrcUpdateFuncC Call a function for each source directory...
#include "amma/util/ManagedFile.hh"

ManagedFileC Put a brief description of your class here
#include "amma/util/VCPP.hh"

ConvertVCPP Convert defs.mk to Visual C++ make format.
#include "amma/Cxx/Parser.hh"

ParserC C++ File Parser
#include "amma/Cxx/Object.hh"

ObjectC Ya basic object.
ObjectListC Object list
DerivedC Derivedd object. like a class, struct, or namespace.
ClassTemplateC Templated class.
MethodTemplateC Templated function.
DesciptionGeneratorC Description generator.
CommentInfoC Generate a full path name, with template paramiter subs. Class containing comment info.
DataTypeC DataTyped object. like a class, struct, or namespace.
ScopeC Scoped object. like a class, struct, or namespace.
InheritIterC Iterator through all objects in the inheritance hirachy.
ClassC Class storage object.
ClassBodyC Class storage object.
ClassTemplateBodyC Templated class body.
MethodC Methodd object. like a class, struct, or namespace.
MethodTemplateBodyC Templated function body.
TypedefC Typedefd object. like a class, struct, or namespace.
VariableC Variabled object. like a class, struct, or namespace.
MarkerC Markerd object. like a class, struct, or namespace.
InheritC Inheritd object. like a class, struct, or namespace.
EnumC Enumd object. like a class, struct, or namespace.
#include "amma/Cxx/Document.hh"

DocumentC Documentor
#include "amma/Cxx/DocNode.hh"

DocNodeC Doc node.
DocNodeBodyC Body for a doc node.
#include "amma/Wizard/ClassWizard.hh"

ClassWizardBodyC
ClassWizardC
#include "amma/Wizard/DefWizard.hh"

DefWizardC Def Wizard
#include "amma/Wizard/ProjWizard.hh"

ProjWizardBodyC
ProjWizardC
#include "amma/Wizard/GenClass.hh"

GUIGenClassC Class generation dialog.
#include "amma/VectorT.hh"

VectorTC Templated vectors.
#include "amma/MatrixT.hh"

MatrixTC Templated matrix's.
#include "amma/Matrix.hh"

MatrixC General matrix ndim x mdim
#include "amma/Vector2d.hh"

Vector2dC Vector in 2d space
#include "amma/Vector3d.hh"

Vector3dC Vector in 3D space
#include "amma/Vector.hh"

VectorC General vector in n-D space
VectorNdTC Special vector with different matrix multiplication operator.
#include "amma/VecMat.hh"

VecMatC A vector and a matrix together for n-D space
#include "amma/Matrix2d.hh"

Matrix2d2C The class Matrix2d2C provides a quick implementation of a 2x2 matrix.
#include "amma/Matrix3d.hh"

Matrix3d3C Matrix 3 x 3
#include "amma/MatIter.hh"

MatrixIterC Duel matrix iterator.
#include "amma/DMatIter.hh"

DuelMatrixIterC Duel matrix iterator.
#include "amma/TMatIter.hh"

TriMatrixIterC Triple matrix iterator.
#include "amma/MatAcc.hh"

MatrixColumnC Access a matrix columb.
MatrixRowC Access a matrix row.
#include "amma/TridiMat.hh"

TridiagonalMatrixC General tridiagonal matrix
#include "amma/LqSystem.hh"

LqSystemC System for incremental solving of linear equations system
#include "amma/ImSystem.hh"

ImSystemC System for solving of linear equations system
#include "amma/SumNXX2.hh"

SumNXX2C Sum vectors items and their squares
#include "amma/GNumInteg.hh"

GNumIntegC Numerical intergration
#include "amma/ConjGrad.hh"

ConjGradC Numerical integration routine
#include "amma/RungeKutta.hh"

RungeKuttaC A fifth order Runge-Kutta scheme, also called Kutta-Merson scheme.
#include "amma/StateVec.hh"

StateVectorC An example class used in for instance the example program ex_kutta
#include "amma/Affine.hh"

AffineC General affine transformation.
#include "amma/LinearS1.hh"

LinearSums1dC Sums for computation of linear dependency features
#include "amma/Line2ABC.hh"

LineABC2dC Line in 2D space - equation Ax+By+C = 0
#include "amma/Mom01d2.hh"

Moments01d2C The class Moments01d2C is the representation of the first 3 moments (00, 01, 10) of a 2-dimensional object.
#include "amma/Mom012d2.hh"

Moments012d2C The first two moments in 2D space
#include "amma/Vector2d.hh"

Vector2dTC
#include "amma/Line2dPP.hh"

Line2dPPC Line in 2D space - represented by 2 points
#include "amma/VecMat2d.hh"

VecMat2dC A vector and a matrix together for 2-D space
#include "amma/Arc2d.hh"

Arc2dC This class implements 2d circular arcs.
#include "amma/Circle2d.hh"

Circle2dC Circle in 2-D space.
#include "amma/Affine2d.hh"

Affine2dC 2-D affine transformation
#include "amma/SArPnt2.hh"

Point2dSArray1dC 1 dimensional simple array of points in 2D space
#include "amma/PCLine.hh"

PCLineC Parametric Line.
#include "amma/PCLineSeg.hh"

PCLineSegC Parametric line segement.
#include "amma/PCurve2d.hh"

PCurve2dC 2d Parametric curve
PCurve2dIC 2d Parametric Curve Body Template
#include "amma/PRect2d.hh"

PRectangle2dC Rectangle, with sides parrallel to axies.
#include "amma/Line3dPV.hh"

Line3dPVC Line determined by one point and a vector in 3D space
#include "amma/Plan3PVV.hh"

PlanePVV3dC Plane in 3D space
#include "amma/Plan3abc.hh"

PlaneABCD3dC Plane in 3D space - equation Ax+By+Cz+D = 0
#include "amma/RGBValue.hh"

ByteRGBValueC RGB colour space
#include "amma/Point3d.hh"

Point3dC Point in 3D space
#include "amma/Line3dPP.hh"

Line3dPPC Line determined by two points in 3D space
#include "amma/MeanCo3d.hh"

MeanCovariance3dC Mean and covariance together in 3D space.
#include "amma/VecMat3d.hh"

VecMat3dC A vector and a matrix together for 3-D space
#include "amma/Vector4d.hh"

Vector4dC Point in 4D space
#include "amma/Matrix4d.hh"

Matrix4d4C Matrix 4 x 4
#include "amma/Point4d.hh"

Point4dC Point in 4D space
#include "amma/ByteImag.hh"

ByteImageC Image with byte pixel values
#include "amma/DoubleIm.hh"

DoubleImageC Double image
#include "amma/Polynomi.hh"

PolynomialC Algebraic polynomial
#include "amma/ReRGBImg.hh"

RealRGBImageC The class RealRGBImageC represents colour image with colour represented by a triple of real RGB components.
#include "amma/XYZPolyn.hh"

XYZPolynomialC 3 Algebraic polynomial
#include "amma/PtToInd2.hh"

PointToIndex2dC Conversion of Point2dC into Index2dC
#include "amma/PtToInd3.hh"

PointToIndex3dC Conversion of Point3dC into Index3dC
#include "amma/Ellipse.hh"

Ellipse2dC An ellipse in 2-D Space.
#include "amma/OProj1a2.hh"

OrthoProjection2to1dC Orthogonal projection between 1D and 2D spaces
#include "amma/OProj1a3.hh"

OrthoProjection3to1dC Orthogonal projection between 1D and 3D spaces
#include "amma/OProj2a3.hh"

OrthoProjection3to2dC Orthogonal projection between 2D and 3D spaces
#include "amma/PProj1d.hh"

PProjection1dC Projective transformation in 1D space
#include "amma/PPoint1d.hh"

PPoint1dC Point in 1D projective space
#include "amma/PPtLi2d.hh"

PPointLine2dC Point - plane in 2D projective space
#include "amma/PLine2d.hh"

PLine2dC Plane in 3D projective space
#include "amma/PPoint2d.hh"

PPoint2dC Point in 2D projective space
#include "amma/PProj2d.hh"

PProjection2dC Projective transformation in 2D space
#include "amma/PPersp2d.hh"

PPerspectivity2dC Perspective transformation in 2D space
#include "amma/PPtPl3d.hh"

PPointPlane3dC Point - plane in 3D projective space
#include "amma/PPoint3d.hh"

PPoint3dC Point in 3D projective space
#include "amma/PProj3d.hh"

PProjection3dC Projective transformation in 3D space
#include "amma/PPersp3d.hh"

PPerspectivity3dC Perspective transformation in 3D space
#include "amma/PPlane3d.hh"

PPlane3dC Plane in 3D projective space
#include "amma/Mean2d.hh"

Mean2dC Mean in 2D space
#include "amma/Mean3d.hh"

Mean3dC Mean in 3D space
#include "amma/Covar3d.hh"

Covariance3dC Covariance of 3D data
#include "amma/MeanNd.hh"

MeanNdC Mean in N-D space
#include "amma/SumNXX22.hh"

SumNXX2d2C Sum vectors items and their squares in 2D space
#include "amma/MeanCo2d.hh"

MeanCovariance2dC Mean and covariance together in 2D space.
#include "amma/SumNXX23.hh"

SumNXX2d3C Sum vectors items and their squares in 3D space
#include "amma/ExMeCo3d.hh"

MinMaxMeanCovariance3dC Extrems and mean and covariance together
#include "amma/MeanCoNd.hh"

MeanCovarianceNdC Mean and covariance together in N-D space
#include "amma/MeCoEnt2.hh"

MeanCovarianceEntropy2dC Mean and covariance and relative entropy together in 2D space.
#include "amma/MeCoEnt3.hh"

MeanCovarianceEntropy3dC Mean and covariance and relative entropy together in 3-D space.
#include "amma/RGBImage.hh"

RGBImageC RGB Colour image
#include "amma/LiPoint2.hh"

Point2dListC A data set created as a list of data
#include "amma/BVertex.hh"

BVertexC Boundary vertex
#include "amma/Edge.hh"

EdgeC Elementary boundary edge
#include "amma/Boundary.hh"

BoundaryC Crack code boundary
#include "amma/BndRegRowIter.hh"

BndRegRowIterC
#include "amma/GMLinesG.hh"

GMLineGfPtrC
GMLineGfListC
#include "amma/GMLineGf.hh"

GMLineGfC gf file sets - a line by George Matas
#include "amma/IRectTP.hh"

IntRectangleTPC Integer 2-D rectangle determined by touch points
#include "amma/IPolyg2.hh"

IntPolygon2dC An integer polygon in 2d space
#include "amma/SubPol2d.hh"

SubPolygon2dC A subpolygon in 2d space
#include "amma/Polygon2.hh"

Polygon2dC A polygon in 2d space
#include "amma/Quadrila.hh"

QuadrilateralC a Quadrilateral in 2-D.
#include "amma/Rect2d.hh"

Rectangle2dC Rectangle in 2d space
#include "amma/VVdefs.hh"

Freenode
Freelist
Point
Site
Edge
Halfedge
#include "amma/Mesh2d.hh"

Mesh2dC Class to store a 2D mesh
#include "amma/Mesh2dNode.hh"

Mesh2dNodeC Representation of a mesh node
#include "amma/Mesh2dEdgeB.hh"

Mesh2dEdgeBodyC Representation of mesh edges
#include "amma/Mesh2dEdge.hh"

Mesh2dEdgeC Representation of a mesh edge
#include "amma/Mesh2dNodeB.hh"

Mesh2dNodeBodyC Representation of a mesh node
#include "amma/Mean1d.hh"

Mean1dC The class Mean1dC keeps the information about the mean of a scalar data set.
#include "amma/IMinMax1.hh"

IntMinMax1dC The class IntMinMax1dC searches for the minimum/maximum integer value.
#include "amma/InHist1d.hh"

IntHistogram1dC 1 dimensional histogram integer indexed
#include "amma/ReHist1d.hh"

HistogramMode1dT
HistModes1dC
RealHistogram1dC RealHistogram1dC represents a histogram of real scalar values.
#include "amma/ReHist2d.hh"

RealHistogram2dC 2 dimensional histogram with real index
#include "amma/MeanCo1d.hh"

MeanCovariance1dC Compute the mean and convariance.
#include "amma/MinMax1d.hh"

MinMax1dC The class MinMax1dC searches for the minimum/maximum value.
#include "amma/NormalD1.hh"

NormalDistribution1dC Normal distribution in 1D space
#include "amma/DataSet1.hh"

DataSet1dC The class DataSet1dC represents a set of real values.
#include "amma/BinIter.hh"

BinIterC Bin table iterator.
#include "amma/BinTable.hh"

BinTableC A table of bins. Hashing for real valued paramiters.
#include "amma/BinList.hh"

BinListC Binned table of lists.
#include "amma/RealBinTable1d.hh"

RealBinTable1dIterC Sparse 1d histogram iterator.
RealBinTable1dC Sparse 1d histogram.
#include "amma/RCBinTable.hh"

RCBinIterC Bin table iterator.
RCBinTableC Table of bins.
#include "amma/DiscReal.hh"

DiscRealC Discretised real value.
#include "amma/RealSparHist1d.hh"

RealSparseHist1dIterC Sparse 1d histogram iterator.
RealSparseHist1dC Sparse 1d histogram.
#include "amma/FFT1d.hh"

FFT1dBodyC Interface class for 1d FFTW
FFT1dC Handle to 1d FFT.
#include "amma/Signal/FFT1d.hh"

FFT1dBodyC Interface class for 1d FFTW
FFT1dC Handle to 1d FFT.
#include "amma/SDFunct1.hh"

SDFunction1dC 1 Dimensional function
#include "amma/DFunct1.hh"

DFunction1dC 1 Dimensional function
#include "amma/Speech/KlattSynth.hh"

ResonatorC Resonator.
KlattSynthC Klatt synthesiser.
#include "amma/Speech/KlattFrame.hh"

KlattFrameC Klatt Frame
#include "amma/ArPoint2.hh"

Point2dArray1dC 1 dimensional array of points in 2D space
#include "amma/SArPnt3.hh"

Point3dSArray1dC 1 dimensional simple array of points in 3D space
#include "amma/ArLinPV3.hh"

Line3dPVArray1dC 1 dimensional array of lines in 3D space
#include "amma/GeneticAlgorithm.hh"

GeneC
GeneticAlgorithmC Base class implementation of genetic algorithm.
#include "amma/PermIter.hh"

PermIterC Iterate permutations.
#include "amma/CombIter.hh"

CombIterC Combination iterator.
#include "amma/CircleIter.hh"

CircleIterC Iterate around a circle.
#include "amma/BinaryPolynomial.hh"

PrimitiveBinaryPolynomialC Evaluate a binary polynomial in a recurance sequence.
#include "amma/SobelSeq.hh"

SobelSeqC Generate a sobel sequence.
#include "amma/VarLenCode.hh"

VariableLengthCodeIterC Variable length binary decoder.
VariableLengthCodeInitC
VariableLengthCodeC Variable length code table.
VariableLengthEncoderC Variable length code table.
#include "amma/SquareIter.hh"

SquareIterC Clockwise iterate around a square, starting in upperleft.
#include "amma/Num/NumLabel.hh"

NumLabelC Represents class labels for classification in PatternRec.
#include "amma/Num/NumData.hh"

NumDataC Stores data value tuples for use in data sets within PatternRec
#include "amma/Num/NumDataSet.hh"

NumDataSetC Represents data sets using lists for use with PatternRec classes.
NumVDataSetC Refines NumDataSetC to specify input type is VectorC.
NumVCDataSetC Refines NumVDataSetC to specify output type is MatrixC (covariance).
NumVLDataSetC Refines NumVDataSetC to specify output type is NumLabelC.
NumVSDataSetC Refines NumVDataSetC to specify output type is StringC.
NumVVDataSetC Refines NumVDataSetC to specify output type is VectorC.
#include "amma/Num/DataSetTuple3.hh"

DataSetTuple3C Represents a data set with three items
#include "amma/Num/NumFunc.hh"

NumFuncC Handle class for numerical functions of the form Y=f(X).
#include "amma/Num/NumFuncConstant.hh"

NumFuncConstantC Simple function Y=f(X) that always returns same output constY.
#include "amma/Num/NumMagnitude.hh"

NumMagnitudeC Handle class for magnitude estimators
#include "amma/Num/NumMagnitudeEuclidean.hh"

NumMagnitudeEuclideanC Euclidean magnitude metric.
#include "amma/Num/NumMagnitudeSqrEuclidean.hh"

NumMagnitudeSqrEuclideanC Square Euclidean magnitude metric.
#include "amma/Num/NumMagnitudeMahalanobis.hh"

NumMagnitudeMahalanobisC Mahalanobis magnitude metric.
#include "amma/Num/NumMagnitudeCityBlock.hh"

NumMagnitudeCityBlockC City Block magnitude metric.
#include "amma/Num/NumMagnitudeMax.hh"

NumMagnitudeMaxC Maximum element magnitude metric.
#include "amma/Num/NumMagnitudeRobust.hh"

NumMagnitudeRobustC Robust magnitude metric.
#include "amma/Num/NumModel.hh"

NumModelC Handle class for numerical models of the form Y=f(X).
#include "amma/Num/NumModelData.hh"

NumModelDataC Model that returns mean of samples at given input point.
#include "amma/Num/NumModelClosest.hh"

NumModelClosestC Model that returns Y corresponding to closest X in training data.
#include "amma/Num/NumModelPolynomial.hh"

NumModelPolynomialC Model for fitting n-dimensional polynomials.
#include "amma/Num/NumModelQuadratic.hh"

NumModelQuadraticC Model for fitting second order polynomial with cross parameter terms.
#include "amma/Num/NumModelBspline.hh"

NumModelBsplineC Model for fitting open B-splines.
#include "amma/Num/NumModelHybridBspline.hh"

NumModelHybridBsplineC Hybrid model for fitting open B-splines which copes with sparse training data.
#include "amma/Num/NetVector.hh"

NetVectorC Extension of VectorC class to add routines for neural networks
#include "amma/Num/WeightMatrix.hh"

WeightMatrixC Extension of MatrixC class for use with neural network
#include "amma/Num/NumModel2LayerNet.hh"

NumModel2LayerNetC Two layer feed forward neural network.
#include "amma/Num/NumParameters.hh"

NumParametersC Handle class for optimisation parameter bounds.
#include "amma/Num/NumCost.hh"

NumCostC Handle class for optimisation cost function evaluators
#include "amma/Num/NumCostFunction.hh"

NumCostFunctionC Optimisation cost function interface to functions derived from NumFuncC.
#include "amma/Num/NumCostInvert.hh"

NumCostInvertC Cost function which inverts another cost function.
#include "amma/Num/NumCostCombine.hh"

NumCostCombineC Weighted average cost of a list of cost functions.
#include "amma/Num/CostFunc.hh"

NumCostClassC Simplified cost function generation.
#include "amma/Num/NumPDF.hh"

NumPDFC Handle class for probability density functions
#include "amma/Num/NumPDFNormal.hh"

NumPDFNormalC Normal probability density function.
#include "amma/Num/NumPDFkNN.hh"

NumPDFkNNC k-Nearest-Neighbour probability density estimator.
#include "amma/Num/NumPDFModel.hh"

NumPDFModelC Probability density function represented using a numerical model.
#include "amma/Num/NumClassify.hh"

NumClassifyC Handle class for classification functions
#include "amma/Num/NumClassifySupervised.hh"

NumClassifySupervisedC Handle class for supervised classifiers
#include "amma/Num/NumClassifyUnsupervised.hh"

NumClassifyUnsupervisedC Handle base class for unsupervised classifiers/clustering algorithms.
#include "amma/Num/NumClassifyFusion.hh"

NumClassifyFusionC Handle class for fusion classifiers
#include "amma/Num/NumClassifykNN.hh"

NumClassifykNNC k-Nearest Neighbour classifier
#include "amma/Num/NumClassifyBayes.hh"

NumClassifyBayesC Bayesian classifier
#include "amma/Num/NumClassifyNormal.hh"

NumClassifyNormalC Bayes classifier with normal probability density functions
#include "amma/Num/NumClassifyFuzzyCmeans.hh"

NumClassifyFuzzyCmeansC Fuzzy C-means clustering algorithm
#include "amma/Num/NumClassifyKmeans.hh"

NumClassifyKmeansC K-means clustering algorithm
#include "amma/Num/NumClassifyFusionMean.hh"

NumClassifyFusionMeanC Fusion classifier that takes mean probabilities for each class
#include "amma/Num/NumClassifyKohonen.hh"

NumClassifyKohonenC Kohonen network clustering algorithm
#include "amma/Num/NumReduce.hh"

NumReduceC Handle class for feature dimension reduction
#include "amma/Num/NumReduceSupervised.hh"

NumReduceSupervisedC Handle class for supervised feature dimensionality reduction
#include "amma/Num/NumReduceUnsupervised.hh"

NumReduceUnsupervisedC Handle class for unsupervised feature dimensionality reduction
#include "amma/Num/NumReducePCA.hh"

NumReducePCAC Feature dimensionality reduction using Principal Component Analysis.
#include "amma/Num/NumReduceFLD.hh"

NumReduceFLDC Feature dimensionality reduction using Fisher's Linear Discriminant.
#include "amma/Num/NumError.hh"

NumErrorC Handle class for classification error counting.
#include "amma/Num/NumErrorCount.hh"

NumErrorCountC Unity weighted error counting.
#include "amma/Num/NumErrorWeight.hh"

NumErrorWeightC Weighted error counting.
#include "amma/Num/NumPerformance.hh"

NumPerformanceC Handle class for classification performance measurement
#include "amma/Num/NumPerfHoldOut.hh"

NumPerfHoldOutC Hold out method for classification performance evaluation
#include "amma/Num/NumPerfCrossVal.hh"

NumPerfCrossValC Cross validation method for classificatio performance evaluation
#include "amma/Num/NumPerfLeaveOutOne.hh"

NumPerfLeaveOutOneC Leave-Out-One method for classification performance evaluation
#include "amma/Num/NumPerfRotation.hh"

NumPerfRotationC Rotation cross validation method for classificatio performance evaluation
#include "amma/Num/NumClustCriterion.hh"

NumClustCriterionC Handle class for clustering criterion functions.
#include "amma/Num/NumClustMinVariance.hh"

NumClustMinVarianceC Related Minimum Variance clustering criteria.
#include "amma/Num/NumClustScatterDet.hh"

NumClustScatterDetC Scatter Matrix Determinant clustering criteria.
#include "amma/Num/NormalRBFunc.hh"

NormalRBFuncC Computes normal parameters of a set of unlabbelled data using EM alg
#include "amma/Num/ClassifyNormalRBFunc.hh"

ClassifyNormalRBFuncC Radial Basis Function clustering algorithm. This uses the EM algorithm to compute the parameters of a set of Gaussian based radial basis functions. If each function is treated as a seperate cluster (with a normal distribution) then they can be seen a clustering algorithm
#include "amma/Num/RbfValidate.hh"

RbfValidateC Validation of a normal mixture model
#include "amma/Num/WeightedLeastSqr2d.hh"

WeightedLeastSqr2dC Performs weighted least squares fit on a set of data points
#include "amma/Num/NdLine.hh"

NdLineC
#include "amma/Num/RbfOption.hh"

RbfOptionC Put a brief description of your class
#include "amma/Num/EstIntFunc.hh"

EstIntFuncC
#include "amma/Num/TotalKurtosis.hh"

TotalKurtosisC Put a brief description of your class
#include "amma/Num/NumOptimise.hh"

NumOptimiseC Handle class for numerical opimisers
#include "amma/Num/NumOptimiseGrid.hh"

NumOptimiseGridC Exhaustive grid search optimisation.
#include "amma/Num/NumOptimiseRandomUniform.hh"

NumOptimiseRandomUniformC Uniform distribution random search optimisation.
#include "amma/Num/NumOptimiseDescent.hh"

NumOptimiseDescentC Gradient descent optimisation algorithm.
#include "amma/Num/NumOptimiseGenetic.hh"

NumOptimiseGeneticC Genetic algorithm numerical optimisation algorithm.
#include "amma/Num/NumOptimiseMetropolis.hh"

NumOptimiseMetropolisBC Metropolis optimiser implementation class.
NumOptimiseMetropolisC Metropolis optimiser implementation class.
#include "amma/Num/Simplex.hh"

SimplexC Put a brief description of your class here
#include "amma/Num/NumOptSimmAnnContinuous.hh"

NumOptSimmAnnContinuousBC Simulated Annealing for continuous optimisation implementation class.
NumOptSimmAnnContinuousC Metropolis optimiser implementation class.
#include "amma/Num/NumSelect.hh"

NumSelectC Handle class for feature dimension reduction
#include "amma/Num/NumSelectConstant.hh"

NumSelectConstantC Constant feature subset selection.
#include "amma/Num/NumSelectGenetic.hh"

NumSelectGeneticC Genetic feature subset selection.
#include "amma/Num/NumFusionWeightedMean.hh"

NumFusionWeightedMeanC Perform fusion on outputs of a combined classifier.
#include "amma/Num/NumFusion.hh"

NumFusionC Class for performing fusion of outputs from supervised classifiers
#include "amma/Num/NumClassComb.hh"

NumClassCombC Class for combining different classifiers
#include "amma/Num/NumFusionMean.hh"

NumFusionMeanC Perform fusion on outputs of a combined classifier.
#include "amma/Num/Match.hh"

MatchC Matcher base handle.
#include "amma/Num/MatchVec.hh"

MatchVecC Match an array of vectors.
#include "amma/Num/Tracker.hh"

TrackObjectC Description of a tracked object.
TrackerC Feature tracking.
#include "amma/Num/TrackBasic.hh"

TrackerBasicC Basic tracker.
#include "amma/Num/TrackVec.hh"

FeatureVectorC Vector Feature class.
ModelVelocityC Model, constant velocity for vectors.
TrackVectorC Vector Tracker.
TrackVecPerformanceC Pefromance measurement of vector tracker.
#include "amma/Num/TrackPerf.hh"

TrackerPerformanceC Process for assesing tracker performance.
#include "amma/DataBunchIter.hh"

DataBunchIterC
#include "amma/DataBunchIterN.hh"

DataBunchIterNC
#include "amma/DataBunch.hh"

DataBunchC This is a mixture of BIG and SMALL objects, therefore do not use it as a BIG object.
#include "amma/BaseCost.hh"

BaseCostC
SimplePairwiseCostC
#include "amma/BaseOpt.hh"

BaseOptC
#include "amma/GradAssOpt.hh"

GradAssOptC
#include "amma/SAOpt.hh"

SAOptC
ICMOptC
#include "amma/MFTOpt.hh"

MFTOptC
#include "amma/Trace.hh"

TraceC
#include "amma/SimpleCost.hh"

SimpleCostC
#include "amma/TSPCost.hh"

TSPCostC
#include "amma/RGBValue.hh"

RGBValueC Integer RGB colour value.
#include "amma/YUVValue.hh"

YUVValueC
#include "amma/RGBValue.hh"

ByteRGBXValueC Integer RGB colour value.
RGBValueU16C 16-bit integer RGB colour value.
#include "amma/LuvColou.hh"

LuvColourC The L*u*v* colour space
#include "amma/LabColou.hh"

LabColourC The L*a*b* colour space
#include "amma/XYZColou.hh"

XYZColourC A XYZ(CIE) colour space
#include "amma/RGBValue.hh"

RGBPointC Real RGB colour value.
#include "amma/YUVValue.hh"

YUVPointC
ByteYUVValueC Color in YUV space
#include "amma/HLSColor.hh"

HLSPointC Color in double-hexcone HLS space
#include "amma/IrgValue.hh"

IrgValueC Intensity, Red and Green.
#include "amma/MunselPt.hh"

MunsellPointC Munsell (HVC) colour space
#include "amma/VYUValue.hh"

ByteVYUValueC Color in VYU space
#include "amma/NumImage.hh"

NumImageC Extension of ImageC that provides numerical operations
#include "amma/ImagIter.hh"

ImageIterC Pointer based image iterator.
#include "amma/ImgPIter.hh"

ImagePIterC Pointer based image iterator, with fast access to pixel location.
#include "amma/Image2Iter.hh"

Image2IterC Pointer based image iterator for image pairs.
#include "amma/Image3Iter.hh"

Image3IterC Pointer based image iterator for image triples.
#include "amma/Image.hh"

ImageC Image template
#include "amma/ImRectIt.hh"

ImageRectIterC Pointer based image rectangle iterator.
#include "amma/Image4Iter.hh"

Image4IterC Pointer based image iterator for image triples.
#include "amma/ImageS2Iter.hh"

ImageS2IterC Pointer based image iterator for image pairs.
#include "amma/ImageS3Iter.hh"

ImageS3IterC Pointer based image iterator for image pairs.
#include "amma/ImageS5Iter.hh"

ImageS5IterC Pointer based image iterator for image pairs.
#include "amma/ImageS4Iter.hh"

ImageS4IterC Pointer based image iterator for image pairs.
#include "amma/ImageS6Iter.hh"

ImageS6IterC Pointer based image iterator for image pairs.
#include "amma/ImageS7Iter.hh"

ImageS7IterC Pointer based image iterator for image pairs.
#include "amma/IntImage.hh"

IntImageC Integer image
#include "amma/YUVImage.hh"

YUVImageC Colour image, in YUV.
#include "amma/ReYUVImg.hh"

RealYUVImageC colour image in YUV with real values
#include "amma/PxString.hh"

PixelStringListC The class PixelStringListC contains a list of pixel strings.
#include "amma/BImgStat.hh"

ByteImageStatC The class ByteImageStatC is an engine for computation of statistics on byte images.
#include "amma/BImgProj.hh"

ByImgProjectionC The class ByImgProjectionC is the engine processing byte images to generate their 1D projections.
#include "amma/CrackIm.hh"

CrackImageC Image of crack codes
#include "amma/IImgStat.hh"

IntImageStatC The class IntImageStatC is an engine for computation of statistics.
#include "amma/RImgStat.hh"

RealImageStatC The class RealImageStatC is an engine for computation of statistics on real images.
#include "amma/RImgProj.hh"

RealImgProjectionC The class RealImgProjectionC is the engine processing real images to generate their 1D projections.
#include "amma/BRGBXImg.hh"

BRGBXImageC Colour image with byte RGBX values
#include "amma/RGBU16Im.hh"

RGBImageU16C Colour image with unsigned 16 bits RGB values
#include "amma/ChromaIm.hh"

ChromaticityImageC Image with chromaticity values
#include "amma/ByImgCnv.hh"

ByteImageCnvC Conversions into the byte image
#include "amma/DbImgCnv.hh"

DoubleImageCnvC Conversions into/from the double image
#include "amma/InImgCnv.hh"

IntImageCnvC Conversions into the integer image
#include "amma/RgbImCnv.hh"

RGBImageCnvC Conversions into/from the RGB image
#include "amma/YuvImCnv.hh"

YUVImageCnvC Conversions into/from the YUV image
#include "amma/RRgbICnv.hh"

RealRGBImageCnvC Conversions into/from the RGB image
#include "amma/RYuvICnv.hh"

RealYUVImageCnvC Conversions into/from the YUV image
#include "amma/CoImageA.hh"

ColorImageAC Abstract color image - conversions
#include "amma/Image/ImgIOPNM.hh"

DPIImagePNMByteRGBC Load a RGB image in PPM format.
DPOImagePNMByteRGBC Save a RGB image in PPM format.
DPIImagePNMByteGreyC Load a byte image in PGM format.
DPOImagePNMByteGreyC Save a byte image in PGM format.
#include "amma/Image/PNMFormat.hh"

FileFormatPPMC Create an instance of a PPM File Format.
FileFormatPGMC Create an instance of a PGM File Format.
FileFormatPBMC Create an instance of a PGM File Format.
#include "amma/Image/ImgIOJPeg.hh"

DPIImageJPegByteRGBC Load a RGB image in JPEG format.
DPOImageJPegByteRGBC Save a RGB image in JPEG format.
DPIImageJPegByteYUVC Load a YUV image in JPEG format.
DPOImageJPegByteYUVC Save a YUV image in JPEG format.
DPIImageJPegByteGreyC Load a Grey image in JPEG format.
DPOImageJPegByteGreyC Save a Grey image in JPEG format.
#include "amma/Image/ImgIOPNG.hh"

DPIImagePNGByteRGBC Load a RGB image in PPM format.
DPOImagePNGByteRGBC Save a RGB image in PPM format.
DPIImagePNGByteGreyC Load a RGB image in PPM format.
DPOImagePNGByteGreyC Save a RGB image in PPM format.
#include "amma/Image/JPEGFormat.hh"

FileFormatJPEGC Create an instance of a JPEG File Format.
#include "amma/Image/PNGFormat.hh"

FileFormatPNGC Create an instance of a PNG File Format.
#include "amma/Image/ImgIOTiff.hh"

DPIImageTIFFByteRGBAC Load a RGB image in PPM format.
DPOImageTIFFByteRGBAC Save a RGB image in PPM format.
#include "amma/Image/TiffFormat.hh"

FileFormatTIFFC Create an instance of a TIFF File Format.
#include "amma/Image/ImgIOCif.hh"

DPIImageCifC Load a YUV image in Cif format.
DPOImageCifC Save a YUV image in Cif format.
#include "amma/Image/CifFormat.hh"

FileFormatCifC Create an instance of a Cif File Format.
#include "amma/Image/ImgIOyuv.hh"

DPIImageYUVC Load a YUV image in YUV format.
DPOImageYUVC Save a YUV image in YUV format.
#include "amma/Image/yuvFormat.hh"

FileFormatYUVC Create an instance of a YUV File Format.
#include "amma/Image/syuvFormat.hh"

FileFormatSYUVC Create an instance of a YUV File Format.
#include "amma/Image/ImgIOrgb.hh"

DPIImageRGBC Load a RGB image in RGB format.
DPOImageRGBC Save a RGB image in raw RGB format.
#include "amma/Image/SubSamp2Intl.hh"

DPSubSample2IntlBaseC SubSample2Intl base Handle.
DPSubSample2IntlC SubSample2Intl Handle.
#include "amma/Image/rgbFormat.hh"

FileFormatRGBC Create an instance of a RGB File Format.
#include "amma/Image/rawFormat.hh"

FileFormatRawC Create an instance of a RGB File Format.
#include "amma/Image/SubSample.hh"

IPSubSampleBodyC
IPSubSampleC
#include "amma/Image/IPTransform.hh"

IPTransformC Generic Image Processing Transform class.
#include "amma/Image/SubRectangle.hh"

IPSubRectangleC Get a sub rectangle.
#include "amma/Image/IPFilter.hh"

IPFilterC Handle class for image processing filter operations.
#include "amma/Image/BiLinearInt.hh"

IPBiLinearIntC Perform bi-linear interpolation on most image amma image types
#include "amma/Image/IPGaussNoise.hh"

IPGaussNoiseC Applies Gaussian noiso to an image
#include "amma/Image/DeInterlace.hh"

IPDeInterlaceC Perform a very rough de-interlace routine. Needs to be cleverer.
#include "amma/Image/IPStatistic2d.hh"

IPStatistic2dC Window averaging filter
#include "amma/Image/IPStatEnergy2d.hh"

IPStatEnergy2dC Window averaging filter
#include "amma/Image/IPStatEntropy2d.hh"

IPStatEntropy2dC Window averaging filter
#include "amma/Image/IPSpatFilter.hh"

IPSpatFilterC Container for generic spatial filter parameters
#include "amma/Image/IPRunLength.hh"

IPRunLengthC Run-length filter
#include "amma/Image/IPLinearAverage.hh"

IPLinearAverageC Window averaging filter
#include "amma/Image/IPLinearSobel.hh"

IPLinearSobelC Sobel edge detection filters
#include "amma/Image/IPSpatDiff.hh"

IPSpatDiffC Spatial difference filter
#include "amma/Image/IPGradient.hh"

IPGradientC Spatial gradient filter
#include "amma/Image/IPConvSym.hh"

IPConvSymC Convolves an image with a 1-D odd-order symmetrical mask
#include "amma/Image/IPGaussConv.hh"

IPGaussConvolveC Filters an image with an odd-order finite-width approximation to a Gaussian mask
#include "amma/Image/TemporalAverage.hh"

IPTemporalAverageC Temporal Average of images.
#include "amma/Image/ImPyramid.hh"

ImagePyramidC Creates a (multiresolution) pyramid of subsampled images
#include "amma/Image/IPConvolve.hh"

IPConvolveC Convolves an image with a 1-D mask
#include "amma/Image/IPMorphErode.hh"

IPMorphErodeC Greylevel morphological erosion operator.
#include "amma/Image/IPMorphDilate.hh"

IPMorphDilateC Greylevel morphological dilation operator.
#include "amma/Image/IPMorphOpen.hh"

IPMorphOpenC Greylevel morphological opening operator.
#include "amma/Image/IPMorphClose.hh"

IPMorphCloseC Greylevel morphological closing operator.
#include "amma/Image/IPMorphBinDilate.hh"

IPMorphBinDilateC
#include "amma/Image/IPMorphBinErode.hh"

IPMorphBinErodeC
#include "amma/Image/IPMorphBinClose.hh"

IPMorphBinCloseC Binary morphological closing operator.
#include "amma/Image/IPMorphBinOpen.hh"

IPMorphBinOpenC Binary morphological opening operator.
#include "amma/Image/IPMorphTopHat.hh"

IPMorphTopHatC Greylevel morphological tophat operator.
#include "amma/Image/IPMorphGradient.hh"

IPMorphGradientC Greylevel morphological gradient operator.
#include "amma/Image/IPMorphSElem.hh"

IPMorphSElemC Grey level morphological operator structuring element base class.
#include "amma/Image/IPMorphSElemFlat.hh"

IPMorphSElemFlatC Flat rectangular morphological structuring element class.
#include "amma/Image/IPNonLinMedian.hh"

IPNonLinMedianC Image median filter
#include "amma/Image/IPBinary.hh"

IPBinaryC Handle class for image processing filter operations with byte output.
#include "amma/Image/IPBinCompare.hh"

IPBinCompareC Image comparison operator
#include "amma/Image/IPBinThreshold.hh"

IPBinThresholdC Image thresholding operator
#include "amma/Image/IPLabel.hh"

IPLabelC Handle class for connected component labelling operations.
#include "amma/Image/IPLabel8Con.hh"

IPLabel8ConC Grey 8-connected component labelling class
#include "amma/Image/IPConnComp.hh"

IPConnCompBaseBodyC
IPConnCompC Class for using connected component labelling. It is not restricted to only 256 labels as other AMMA classes.
#include "amma/Image/LImageIter.hh"

LImageIterC Pointer based image iterator.
#include "amma/Image/LImageIter2.hh"

LImageIter2C Pointer based image iterator.
#include "amma/Image/IPGradEst.hh"

IPEdgeGradEstC Estimate gradient directions from a binary image.
#include "amma/Image/IPEdgeDetB.hh"

IPEdgeDetBodyC Detect edges is an image
#include "amma/Image/IPEdgeDet.hh"

IPEdgeDetC Detect edges is an image
#include "amma/Image/IPEdgeLink.hh"

IPEdgeLinkC Link edges is an image
#include "amma/Image/IPEdgeLinkB.hh"

IPEdgeLinkBodyC Link edges is an image
#include "amma/Image/IPPixGradEst.hh"

IPPixEdgeGradEstC Do gradient estimation on a list of pixel locations.
#include "amma/Image/EdgeDetG.hh"

IPEdgeDetGC Generate a list of edgeles with magintude and gradiant information.
#include "amma/Image/GradEst.hh"

IPEdgeEstGC Generate a list of edgeles with magintude and gradiant information. from a byte edge image.
#include "amma/Image/EdgeGM.hh"

IPEdgeGradMagC Edge Location, Gradient and Magniture information.
#include "amma/Image/Deriche.hh"

IPEdgeDericheC Deriche edge filter.
IPEdgeDericheBodyC
#include "amma/Image/NonMaxSupp.hh"

IPLinNonMaxSuppressionC Sqr Composition.
#include "amma/Image/SqrCompos.hh"

IPSqrCompositionC Sqr Composition.
#include "amma/Image/PixelMap.hh"

PixelMapC Binned hash table of pixels in an image.
#include "amma/Image/PixelMapSearch.hh"

PixelMapSearchC Pixel map search base class.
#include "amma/Image/PCPixel.hh"

PCPixelC Pixel near Parametric curve.
#include "amma/Image/PCPixelLst.hh"

PCPixelLstC List of PCPixels.
#include "amma/Image/PPHT.hh"

PPHTLineSegExtractC Line segment extraction engine.
#include "amma/Image/PPHTC.hh"

PPHTLineSegC PPHT line extraction engine handle class.
#include "amma/Image/PCMapping.hh"

PCPixMapC Simple mapping between a curve and some pixels.
PCPixMappingC Mappings from a curve to a set of pixels.
#include "amma/Image/PixelMapNeigh.hh"

PixelMapNeighC Find all pixels within a given distance.
#include "amma/Image/IPFft2d.hh"

IPFft2dC Computes FFT of 2D images
#include "amma/Image/IPGabor.hh"

IPGaborC Computes Gabor feature images
#include "amma/Image/IPPowerSpectrum.hh"

IPPowerSpectrumC Computes the powere spectrum for an image of complex numbers
#include "amma/Image/IPDct3x3.hh"

IPDct3x3C Window averaging filter
#include "amma/Image/IPWavelet.hh"

IPWaveletC Window averaging filter
#include "amma/Image/ColourInv.hh"

ColourInvariantC Calculate a colour invarient for each pixel.
#include "amma/Image/Meteor1Format.hh"

FileFormatMeteor1C Create an instance of a Meteor1 File Format.
#include "amma/Image/ImgIOMeteor1.hh"

DPIImageMeteor1C Meteor1 frame grabber.
#include "amma/Image/BGRXValue.hh"

ByteBGRXValueC Integer BGRX colour value.
#include "amma/EnImgBnd.hh"

ImageBoundaryEngineC
#include "amma/RegSrch.hh"

BaseRSControlC
RSControlC
#include "amma/Mom012P2.hh"

Moments012Perd2C Moments in 2D space, the first two ones and perimeter
#include "amma/GLHisto.hh"

GreyLevelHistogramC Grey level image histogram
#include "amma/LabMeaIm.hh"

MeasureLabelImageC The image which contains labels and a measure
#include "amma/PxString.hh"

PixelStringC Pixel string and list of pixel strings
#include "amma/RegModel.hh"

ChromaFlatRModelC
ChromaGradRModelC
RGBFlatRModelC
GradRModelC
#include "amma/SmallRMo.hh"

SmallRModelC
#include "amma/ConstMod.hh"

ConstantRModelC
#include "amma/PolynRMo.hh"

RegionPolynBoundC
PolRModelC
#include "amma/ReMarkMo.hh"

ReMarkRModelC
#include "amma/FlatRMo.hh"

FlatRModelC
#include "amma/ByIntRMo.hh"

Byte2IntRModelC
#include "amma/RAGTable.hh"

RAGTableC
#include "amma/IntByRMo.hh"

Int2ByteRModelC
#include "amma/ThresRMo.hh"

ThresholdRModelC
#include "amma/RgbRMo.hh"

RgbRModelC
#include "amma/ChrDRMod.hh"

ChromaMahaRModelC Region model based on Mahalanobis distance
#include "amma/ProbRMo.hh"

ProbabilityRModelC
#include "amma/RAGTable.hh"

NeighbourLabelsC
#include "amma/CamCorr.hh"

CameraCorrectionC Camera correction table (removing of gamma correction)
#include "amma/LColMod.hh"

LineColorModelsC Line color model
#include "amma/IDens2d.hh"

IntDensity2dC Density image.
#include "amma/IBDens2d.hh"

ByteImgDensity2dC Combined Byte and Density image.
#include "amma/Video.hh"

VideoInC Template i/p video stream class
VideoOutC Template o/p video stream class
#include "amma/VideoByte.hh"

VideoByteInC Video input stream for ByteImageC images
VideoByteOutC Video output stream for ByteImageC images
#include "amma/VideoYUV.hh"

VideoYUVInC Video input stream for YUVImageC
VideoYUVOutC Video output stream for YUVImageC
#include "amma/ImgField.hh"

ImgFieldC Template class for video fields
#include "amma/VideoIntl.hh"

VideoIntlInC Template class for interlaced video i/p stream
VideoIntlOutC Template class for interlaced video o/p stream
#include "amma/FieldIter.hh"

FieldIterC Pixel iterator for ImgFieldC field template class.
#include "amma/PSImage.hh"

PSImageC This class creates Postscript files that illustrate fields of 2D vectors and/or covariance matrices
#include "amma/ImgIOPS.hh"

DPIImagePSByteRGBC Load a RGB image in PPM format.
DPOImagePSByteRGBC Save a RGB image in PPM format.
DPIImagePSByteGreyC Load a Grey image in PPM format.
DPOImagePSByteGreyC Save a Grey image in PPM format.
#include "amma/GeomIOPS.hh"

DPIImagePSLine2dPPC Load a RGB image in PPM format.
DPOImagePSLine2dPPC Save a RGB image in PPM format.
#include "amma/PSFormat.hh"

FileFormatPSC Create an instance of a PS File Format.
#include "amma/RAG/RAG.hh"

RAGC Class to construct a region adjacency graph from a segmentation map; label 0 is reserved for outer region which is not of interest.
#include "amma/RAG/RmSmallMrg.hh"

RmSmallMrgC Class to decide whether the node of a graph should be merged with any of its neighbours and which neighbour
#include "amma/RAG/MergeCrit.hh"

MergeCritC Class to decide whether two nodes of an adjacency should be merged based on the motion measurement associated with each of them.
#include "amma/RAG/RmThinMrg.hh"

RmThinMrgC Class to decide whether the node of a graph should be merged with any of its neighbours and which neighbour
#include "amma/RAG/RegNode.hh"

RegNodeC Representation of a two-dimensional, arbitrarily-shaped region as a node in a region adjacency graph
#include "amma/RAG/RegEdge.hh"

RegEdgeC Representation of a boundary between two two-dimensional, arbitrarily-shaped regions as an edge in a region adjacency graph
#include "amma/Region/RegionSet.hh"

RegionSetC Class for representing the segmentation
#include "amma/Region/RegionSetB.hh"

RegionSetBodyC Class for describing the result of a segmentation; include a segmentation map and statistics associated to each region
#include "amma/Region/IPRegionB.hh"

IPRegionBodyC Virtual segmentation class (provides interface for real classes)
#include "amma/Region/IPRegion.hh"

IPRegionC Handle class for a basic segmentation class
#include "amma/Region/RegGrowSeq.hh"

RegGrowSeqC Region growing class with each region grown sequentially
#include "amma/Region/PixStackSelect.hh"

PixStackSelectC Class for selecting next pixel on which some processing needs to be done.
#include "amma/Region/RegGrowSeqB.hh"

RegGrowSeqBodyC Region growing class with each region grown sequentially
#include "amma/Region/RegClassify.hh"

RegClassifyC Class to determine whether a pixel belongs to a region based on its intensity.
#include "amma/Region/RegClassCol.hh"

RegClassColC Class to determine whether a pixel belongs to a region based on its colour.
#include "amma/Region/RegClassConnComp.hh"

RegClassConnCompC Class to determine whether a pixel belongs to a region based on its label. This class is useful for connected component labelling.
#include "amma/Region/RegColCovMatcher.hh"

RegColCovMatcherC Class for matching regions in successive frames
#include "amma/Region/RegColMeanMatcher.hh"

RegColMeanMatcherC Class for matching regions in successive frames
#include "amma/Region/RegColMeanCovMatcher.hh"

RegColMeanCovMatcherC Class for matching regions in successive frames
#include "amma/Region/RegClassMot.hh"

RegClassMotC Class to determine whether a pixel belongs to a region based on its motion vector.
#include "amma/Region/PointContour.hh"

PointContourC Class to fill a contour represented by a list of points (floating points)
#include "amma/Region/RegGrowStealSeq.hh"

RegGrowStealSeqC Region growing class with each region grown sequentially
#include "amma/Region/RegGrowStealSeqB.hh"

RegGrowStealSeqBodyC Region growing class with each region grown sequentially
#include "amma/Region/NumCostDerin.hh"

NumCostDerinC Class to calculate the pdf for the purpose of image segmentation
#include "amma/Region/NumCostDerinB.hh"

NumCostDerinBC Implementation class for Derin part of the Bayesian criterion.
#include "amma/Region/NumOptimiseGibbsSampling.hh"

NumOptimiseGibbsSamplingC GibbsSampling optimiser handle class.
#include "amma/Motion/LMSOpticFlow.hh"

LMSOpticFlowC Least-mean-squared gradient method for optical flow
#include "amma/Motion/MultiScaleMotion.hh"

MultiScaleMotionC Performs multiscale motion estimation
#include "amma/Motion/LMSRegionMatch.hh"

LMSRegionMatchC Computes a 2D motion vector from 2 images over a region using a least-mean-square fit
#include "amma/Motion/NumCostMotEst.hh"

NumCostMotEstC Optimisation cost function for image patch comparison.
#include "amma/Motion/NumCostMotEstB.hh"

NumCostMotEstBC Implementation class for cost function used for comparing image regions.
#include "amma/Motion/NumCostMotEstBase.hh"

NumCostMotEstBaseC Optimisation cost function for image patch comparison.
#include "amma/Motion/MotModel.hh"

MotModelC Base class for the motion models
#include "amma/Motion/QuAffMotModel.hh"

QuAffMotModelC Class for methods specific to the quasi-affine motion model
#include "amma/Motion/TransMotModel.hh"

TransMotModelC Class for methods specific to the translational motion model
#include "amma/Motion/AffineMotModel.hh"

AffineMotModelC Class for methods specific to the affine motion model
#include "amma/Motion/PerspectiveMotModel.hh"

PerspectiveMotModelC Class for methods specific to the perspective motion model
#include "amma/Motion/QuadraticMotModel.hh"

QuadraticMotModelC Class for methods specific to the quadratic motion model
#include "amma/Motion/NumOptimiseImageDescent.hh"

NumOptimiseImageDescentC Gradient descent optimisation algorithm for motion estimation.
#include "amma/Motion/NumOptimiseDiehlMotEst.hh"

NumOptimiseDiehlMotEstC Gradient descent optimisation algorithm for motion estimation.
#include "amma/Motion/MatchMotEst.hh"

MatchMotEstC Class for motion estimation
#include "amma/Motion/MultiMatchMotEst.hh"

MultiMatchMotEstC Motion estimation with templated motion model
#include "amma/Motion/MatchMotEstBase.hh"

MatchMotEstBaseC Put a brief description of your class here
#include "amma/Motion/MultiMatchMotEstBase.hh"

MultiMatchMotEstBaseC Put a brief description of your class here
#include "amma/Motion/RegionMotComp.hh"

RegionMotCompC Class for motion compensation of arbitrary shapes.
#include "amma/Motion/MCErrorSegmentBase.hh"

MCErrorSegmentBaseC Generic class for segmentation based on the motion compensated error image.
#include "amma/Motion/MultiLevel.hh"

MultiLevelC Class for producing multiresolution or multiscale images
#include "amma/Motion/MCErrorSegment1.hh"

MCErrorSegment1C Generic class for segmentation based on the motion compensated error image.
#include "amma/Motion/MCErrorSegment2.hh"

MCErrorSegment2C Generic class for segmentation based on the motion compensated error image.
#include "amma/Motion/MCErrorSegment3.hh"

MCErrorSegment3C Generic class for segmentation based on the motion compensated error image.
#include "amma/FastFourierTrans2d.hh"

FastFourierTrans2dC Put a brief description of your class here
#include "amma/Font.hh"

FontC Class for loading in an AMMA font and inserting them into images
#include "amma/Image3d.hh"

Image3dC 3D Image class
#include "amma/Im3dFilter.hh"

Image3dFilterC Handle template class for convolution in 3d images
#include "amma/Corner.hh"

CornerC
#include "amma/CrnSusan.hh"

SusanC Susan corner detector
#include "amma/SubSampl.hh"

VSubSample Some simple sub-sampling filters.
#include "amma/RankOrd.hh"

VRankOrder Some rank order filters
#include "amma/IPBWSubSample.hh"

IPBWSubSampleC Sub-sample a byte image by sx,sy.
#include "amma/GeomFeatSet.hh"

GeomFeatSetC Geometric feature array
#include "amma/GeomPt2dFt.hh"

GeomPt2dFeatC 2D point feature inherited from GeomFeatC
#include "amma/GeomLine2dFt.hh"

GeomLine2dFeatC 2D line feature inherited from GeomFeatC
#include "amma/aff.hh"

AffTransfC The class AffTransfC represents an affine transformation from one space into another.
#include "amma/Quartern.hh"

QuarternC
#include "amma/Homtm.hh"

HomtmC
#include "amma/RigidT.hh"

RigidTransC
#include "amma/ComFile.hh"

ComFileC ComFileC is a class which provides a file parser for multiview sets of 3D points/meshes/range images.
#include "amma/VecSet.hh"

VectorSetC
#include "amma/Regis.hh"

RegisC Registers two 3d data sets.
#include "amma/NRegis.hh"

ViewT ViewT is used internally by NRegisC
CorresT CorresT is used internally by NRegisC
NRegisC N-Point Set Registration.
#include "amma/PRegis.hh"

PRegisC Finds the pose.
#include "amma/CorrSet.hh"

CorSpecT CorSpecT holds the information for one correspondence set.
CorrSetC Provides routines for correspondence sets (it stores an array of CorSpecT's)
#include "amma/MeanRegis.hh"

MeanRegisC MeanRegisC registers N point sets, using Pennec's method of mean shape.
#include "amma/Schmitt.hh"

SchmittC The SchmittC class registers N point sets using Schmitt's method.
#include "amma/Polops.hh"

FaceT Structure used in PolopsC to represent a face.
SubGroupT Structure used in PolopsC to represent ??
PolopsC PolopsC is a general purpose class for Polyehdral data structures.
#include "amma/IndTri.hh"

TriNearestT
IndTriC IndTriC is used to determine the nearest point on a triangle.
#include "amma/Vizz.hh"

VizzC
#include "amma/FloatRange.hh"

FloatRangeC Range image where each pixel is stored using a float.
#include "amma/VectRange.hh"

VectRangeC Range image stored using a vector for each point, ie full
#include "amma/ByteRange.hh"

ByteRangeC Range images with one byte per pixel.
#include "amma/ristags.h"

s_risparams
risversion
s_risheader
s_risdir
s_risfile
#include "amma/PolopRan.hh"

PolopRanC
#include "amma/SynthRan.hh"

SynthRanC SynthRanC is a class which provides facilities to create synthetic range images from a synthetic 3D model (a .tri file).
#include "amma/VTRing.hh"

TEdgeC
VTVertexC
VTEdgeC
VTFaceC
VTRingC
#include "amma/VTBound.hh"

VTDirEdgeC
VTBoundC
#include "amma/VTBackTrack.hh"

VTBackTrackC
#include "amma/VTNear.hh"

VTNearestPointC
VTNearC
VTPointStuffC
#include "amma/HoppeTri.hh"

MeshOptC
#include "amma/VTNear.hh"

VTLoadedC
#include "amma/sl_cast.hh"

t_uv
t_tri
t_vector
t_casteljau
#include "amma/sl_disp.hh"

LoopRoseC
#include "amma/Slime.hh"

PatchLookUpTableC
#include "amma/HoppeSlime.hh"

HopSlimeC
#include "amma/Slime.hh"

SlimeC
#include "amma/NN.hh"

NNC
#include "amma/Nearest.hh"

NearestC
#include "amma/Hash3d.hh"

Hash3dC
#include "amma/DNearest.hh"

DNearestC
#include "amma/Mesh.hh"

MeshElemC
MeshNodeC
MeshEdgeC
MeshC
MeshNearestPointT
#include "amma/Surface.hh"

SurfaceC
#include "amma/SurfEdge.hh"

SurfaceEdgeC
#include "amma/SurfNode.hh"

SurfaceNodeC
#include "amma/SurfElem.hh"

ElementC
#include "amma/SurfAdj.hh"

SurfaceAdjC
#include "amma/SurfBoun.hh"

SurfaceBoundC
#include "amma/SurfElem.hh"

SurfaceElementC
#include "amma/TriSet.hh"

BodyTriSetC A simple mesh class
#include "amma/Tri.hh"

TriNearestPointC
TriC
TriOrthoC
#include "amma/SurfNP.hh"

SurfaceNearestPointT
#include "amma/SurfExt.hh"

SurfaceExtC
#include "amma/Bucket3to2.hh"

BaseBucket3to2dC
#include "amma/BuckList.hh"

Bucket3to2dC
#include "amma/BuckArr.hh"

BucketArray3to2dC
#include "amma/SurfNear.hh"

SurfaceNearestPointC
SurfaceNearestC
#include "amma/CTriSet.hh"

BodyCTriSetC Coloured (textured) BodyTriSet
#include "amma/TriSet.hh"

TriSetC A simple mesh class
#include "amma/TriEdgeSet.hh"

EdgeC
TriEdgeSetC Class Description
#include "amma/CTriSet.hh"

CTriSetC Coloured (textured) TriSet
#include "amma/NormVol.hh"

NormalVolumeC
#include "amma/BVoxSet.hh"

BaseVoxSetC
#include "amma/Vox.hh"

VoxC
VoxNormalC
VoxPointNormalC
VoxBoundPointNormalC
VoxEmptyC
#include "amma/VoxSet.hh"

VoxSetC
VoxSetArrayC
#include "amma/BaseRegis.hh"

BaseRegisC BaseRegisC is an Abstract Base Class, which is reference counted (Big Object) and provides the core operations for doing point set registration.
#include "amma/PolRegis.hh"

PolRegisC PolRegisC uses the Surface Based Nearest Neighbour Method and is reference counted (Big Object).
#include "amma/RanRegis.hh"

RanRegisC RanRegisC uses the Range Image Search Nearest Neighbour Method and is reference counted (Big Object).
#include "amma/BaseRegisHC.hh"

BaseRegisHC BaseRegisHC is a Handle to the Abstract Base Class, BaseRegisC, which is reference counted.
#include "amma/VoxRegis.hh"

VoxRegisC VoxRegisC uses the Voxel Based Nearest Neighbour Method and is reference counted (Big Object).
#include "amma/PolRegisHC.hh"

PolRegisHC PolRegisHC is a Handle to the Derived Class PolRegisC, which is reference counted.
#include "amma/VoxRegisHC.hh"

VoxRegisHC VoxRegisHC is a Handle to the Derived Class VoxRegisC, which is reference counted.
#include "amma/RanRegisHC.hh"

RanRegisHC RanRegisHC is a Handle to the Derived Class RanRegisC, which is reference counted.
#include "amma/HoppeSlime.hh"

PointStuffC
PLBackupC
#include "amma/HomTransMatC.hh"

HomTransMatC
#include "amma/HtmFunctionsC.hh"

HtmFunctionsC
#include "amma/DisplacementImage.hh"

DisplacementImageC A displacement map image
#include "amma/DetailPoint.hh"

DetailPointC A point mapped onto a mesh
#include "amma/DetailLayer.hh"

DetailLayerC A mesh mapped onto another
#include "amma/PointMapper.hh"

PointMapperC A class which maps points.
#include "amma/AMFigure.hh"

MotionSeqC
AMFigureC
#include "amma/AMSegment.hh"

AMSegmentC
SegDynaTC
SegStatTC SegStatTC is a transformation class for an articulated figure
#include "amma/AMParse.hh"

AccParsC
#include "amma/GUI/Canvas.hh"

GUICanvasC Widget in which graphics can be rendered.
#include "amma/GUI/RenderTools.hh"

GUIRenderListC List of render instructions.
#include "amma/GUI/Render.hh"

GUIRenderC Render instruction handle.
#include "amma/GUI/Window.hh"

GUIWindowC Window handle.
#include "amma/GUI/Manager.hh"

GUIManagerC GUI Manager class
#include "amma/GUI/RenderTools.hh"

GUIRenderPointC Draw a single point
GUIRenderPixelListC Draw a list of points
GUIRenderLineC Draw line
GUIRenderTextC Draw line
GUIRenderClearC Clear the window.
GUIRenderByteImageC Draw a byte image.
GUIRenderRGBImageC Draw a rgb image.
#include "amma/GUI/Widget.hh"

GUIWidgetC Base Widget handle.
#include "amma/GUI/Menu.hh"

GUIMenuC Pixmap
#include "amma/GUI/SignalInfo.hh"

GTKSignalInfoC Signal info
#include "amma/GUI/Widget.hh"

GUIWidgetBodyC Widget base body.
#include "amma/GUI/Button.hh"

GUIButtonC Button handle.
#include "amma/GUI/VUIWorkArea.hh"

ViewWorkAreaC Work area.
#include "amma/GUI/VUIObject.hh"

ViewObjectC View object as widget
#include "amma/GUI/VUIDisplayMap.hh"

DisplayMapC Mapping between displayable objects and widgets.
#include "amma/GUI/ViewManager.hh"

ViewManagerC View manager.
ViewManagerBodyC View manager body.
#include "amma/GUI/PixmapInfo.hh"

ScaledPixmapC PixmapC.
#include "amma/GUI/VUIDisplayMapReg.hh"

SetDefaultDisplayC Class to add display function to default display list.
#include "amma/GUI/Cursor.hh"

GUICursorC Cursor handle
#include "amma/GUI/CWidget.hh"

GUIContainerWidgetC Container Widget
#include "amma/GUI/LBox.hh"

GUILBoxC Layout box
#include "amma/GUI/Menu.hh"

GUIMenuItemC Menu item
GUIMenuBarC Pixmap
#include "amma/GUI/Label.hh"

GUILabelC Label
#include "amma/GUI/FileSelector.hh"

GUIFileSelectorC FileSelector
#include "amma/GUI/Pixmap.hh"

GUIPixmapC Pixmap
#include "amma/GUI/TextEntry.hh"

GUITextEntryC TextEntry
#include "amma/GUI/Slider.hh"

GUISliderC Slider
#include "amma/GUI/MouseEvent.hh"

GUIMouseEventC Mouse event information.
GUICListEventC Print description of mouse event to stream.
#include "amma/GUI/OneChild.hh"

GUIOneChildC Base class for all widgets with exactly one child.
#include "amma/GUI/Fixed.hh"

GUIFixedWidgetC Fixed layout widget.
#include "amma/GUI/ScrolledArea.hh"

GUIScrolledAreaC ScrolledArea handle.
#include "amma/GUI/EventBox.hh"

GUIEventBoxBodyC Event box widget.
GUIEventBoxC Event box.
#include "amma/GUI/Frame.hh"

GUIFrameC Put a frame around some other widgets.
#include "amma/GUI/ToggleButton.hh"

GUIToggleButtonC Toggle Button handle.
GUICheckButtonC Check Button handle.
#include "amma/GUI/StatusBar.hh"

GUIStatusBarC Status bar.
#include "amma/GUI/Combo.hh"

GUIComboC Combo handle.
#include "amma/GUI/List.hh"

GUIListC List handle.
#include "amma/GUI/MenuCheck.hh"

GUIMenuCheckItemC Menu item
#include "amma/GUI/RawCanvas.hh"

GUIRawCanvasC RawCanvas handle.
#include "amma/GUI/Table.hh"

GUITableC Table.
#include "amma/GUI/Ruler.hh"

GUIRulerC Ruler .
#include "amma/GUI/SpinButton.hh"

GUISpinButtonC Spin button body.
#include "amma/GUI/Tree.hh"

GUITreeC Tree
GUITreeItemC Leaf of tree.
#include "amma/GUI/PackInfo.hh"

GUIPackInfoC Packing info widget.
#include "amma/GUI/ToolTips.hh"

GUIToolTipsC Tool tip set handle.
#include "amma/GUI/Separator.hh"

GUISeparatorC Vertical or horizontal separator.
#include "amma/GUI/Bitmap.hh"

GUIBitmapBodyC Bitmap body.
GUIBitmapC Bitmap.
#include "amma/GUI/Notebook.hh"

GUINotebookC Layout box
#include "amma/GUI/CList.hh"

GUICListCellC Cell info.
GUICListBodyC CList widget body.
GUICListC CList widget.
#include "amma/GUI/VLabel.hh"

GUIVLabelC Vertical Label.
#include "amma/GUI/RadioButton.hh"

GUIRadioButtonC
#include "amma/GUI/Graph1d.hh"

GUIGraph1dC Graph of a 1d function.
#include "amma/GUI/3D/3DCanvas.hh"

Canvas3DC 3D Canvas Widget.
#include "amma/GUI/3D/gtkglarea.h"

_GtkGLArea
_GtkGLAreaClass
#include "amma/GUI/3D/Object.hh"

DObject3DC Handle to basic object in a 3d world.
DObjectSet3DC Handle to basic object in a 3d world.
#include "amma/GUI/3D/ViewPoint.hh"

DViewPoint3DC Setup a view point in the 3D world.
#include "amma/GUI/3D/Cube.hh"

DCube3DC Handle to basic object in a 3d world.
#include "amma/GUI/3D/Util.hh"

DSwapBuff3DC Swap buffers.
DTransform3DC Transform objects
#include "amma/GUI/3D/Lines.hh"

DLine3DC Draw some lines.
#include "amma/GUI/3D/Polops.hh"

DPolops3DC Draw some lines.
#include "amma/GUI/3D/View3D.hh"

View3DBodyC 3D Viewer widget.
View3DC 3D Viewer widget.
#include "amma/GUI/3D/Light.hh"

DLight3DC Draw some lines.
#include "amma/GUI/3D/Pixmap3D.hh"

GUIPixmap3DBodyC A 3D pixmap.
GUIPixmap3DC A 3D pixmap.
#include "amma/GUI/3D/Disp3DIO.hh"

DPDisplay3DBodyC
DPDisplay3DC
DPODisplay3DC Display 3D handle.
#include "amma/GUI/3D/DispFormat3D.hh"

IOFormatDisplay3DC Create an instance of a Display3D IO Format.
#include "amma/GUI/Event.hh"

EventC Event body.
#include "amma/GUI/ViewGroup.hh"

GroupC Object Group handle
#include "amma/GUI/ViewObject.hh"

ObjectC Object handle
DeltaC Delta base.
#include "amma/GUI/ViewData.hh"

DataC Data Object handle
DeltaUpdateC Update data object.
#include "amma/GUI/ViewDelta.hh"

DeltaAddC Add object to group.
DeltaRemoveC Remove object from group.
#include "amma/GUI/ViewSequence.hh"

SequenceBaseBodyC
SequenceBaseC
PlayControlC View play control.
PlayControlBodyC View play control.
SequenceC
SequenceBodyC
#include "amma/GUI/DispIO.hh"

DPDisplayBodyC
DPDisplayC
DPODisplayBodyC
DPODisplayC Display handle template.
#include "amma/GUI/DispFormat.hh"

IOFormatDisplayC Create an instance of a Display IO Format.
#include "amma/GUI/GroupTree.hh"

GUIGroupTreeC Tree displaying a group hirachy.
#include "amma/GUI/PlayControl.hh"

GUIPlayControlC Play Control GUI interface.
GUIPlayControlBodyC Play Control GUI interface body.
#include "amma/RawFileC.hh"

RawFileC
#include "amma/SerialPortC.hh"

SerialPortC
#include "amma/RawIO.hh"

RawIOC
#include "amma/RawIOBas.hh"

RawIOBaseC
#include "amma/Thread/Ticker.hh"

TickerFC Ticker handle.
#include "amma/INetProtocolC.hh"

INetProtocolC
#include "amma/SocketsC.hh"

SocketsC Socket client.
#include "amma/SocketServerC.hh"

SocketServerC Socket Server.
#include "amma/ServerC.hh"

ServerC
#include "amma/Sound/Sound.hh"

SoundDrvBaseBodyC Sound driver base.
SoundDrvC Sound driver handle.
#include "amma/Studio/SwitchDriver.hh"

ConnectionC Switch connection.
SwitchDriverBodyC Body class for video switch controller.
SwitchDriverC Video switch controller.
#include "amma/Studio/Switch.hh"

SalvoC Salvo
SalvoBodyC Salvo body
SwitchBodyC Body class for video switch controller.
SwitchC Video switch controller.
#include "amma/Studio/SwitchLeitch.hh"

SwitchLevelC
SwitchLeitchBodyC Leitch switch controller body.
SwitchLeitchC Leitch switch controller.
#include "amma/Studio/SwitchManager.hh"

SwitchManagerBodyC Switch manager.
SwitchManagerC Switch manager.
#include "amma/Studio/SwitchModel.hh"

SwitchMatrixC
SwitchModelBodyC Model switch controller body.
SwitchModelC Model switch controller.
#include "amma/Studio/SwitchSalvo.hh"

SwitchSalvoBodyC Salvo switch body.
SwitchSalvoC Salvo switch .
#include "amma/Studio/GUISwitchMatrix.hh"

GUISwitchMatrixBodyC Switch config widget body.
GUISwitchMatrixC Switch config widget handle.
#include "amma/Studio/GUISwitch.hh"

GUISwitchBodyC Switch config widget body.
GUISwitchC Switch config widget handle.
#include "amma/Studio/SwitchNetSrv.hh"

SwitchNetSrvC Net switch server.
SwitchNetSrvBodyC Net switch server.
#include "amma/Studio/GUISwitchManager.hh"

GUISwitchManagerBodyC Switch config widget body.
GUISwitchManagerC Switch config widget handle.
#include "amma/Studio/SwitchNet.hh"

SwitchNetBodyC Model switch controller body.
SwitchNetC Model switch controller.
#include "amma/Studio/SwitchMap.hh"

MatrixMapC Mappings for each matrix.
SwitchMapBodyC Body for mapping switch connections.
SwitchMapC Video switch controller.
#include "amma/Logic2/LExprType.hh"

VLExprTypeC Expression Type.
#include "amma/Logic2/LExprLab.hh"

VLExprLabelC Expression label handle.
#include "amma/Logic2/LBindLst.hh"

VLBindLst Set of variable bindings.
#include "amma/Logic2/LSymbIter.hh"

VLSymbIterC Symbol list iterator.
#include "amma/Logic2/LSubstBase.hh"

VLSubstBaseC Subsitution handle.
#include "amma/Logic2/LExprSet.hh"

VLExprSet Set that handles equivelent expressions correctly.
#include "amma/Logic2/LSymb.hh"

VLSymbC Symbolic token.
#include "amma/Logic2/LMinTermSOP.hh"

VLMinTermSOP Sum of Products.
#include "amma/Logic2/LMinTerm.hh"

VLMinTermC Logical min-term.
#include "amma/Logic2/LSpace.hh"

VLSpaceC Handle for a logical space.
#include "amma/Logic2/LSymb.hh"

VLSymbDCC Symbol handle.
#include "amma/Logic2/LSymbSet.hh"

VLSymbSetC Set of symbols.
#include "amma/Logic2/LNExpr.hh"

VLNExpr Named expression.
#include "amma/Logic2/LValue.hh"

VLValue Logical value.
VLValInt Integer Value
VLValFloat Floating point value.
VLValStr String.
#include "amma/Logic2/LOps.hh"

VLNotC Negation.
#include "amma/Logic2/LExprIter.hh"

VLExprIter This iterator works over Index labels for the expression.
VLExprIterC
#include "amma/Logic2/LVar.hh"

VLVarC Create a variable.
#include "amma/Logic2/LBindLstIter.hh"

VLBindLstIter Iterate through a bind list.
#include "amma/Logic2/LBindLst.hh"

VLBindLstC Refrence counted version of a bind list.
#include "amma/Logic2/LExprLabLst.hh"

VLExprLabelLst
#include "amma/Logic2/LMinTermPIter.hh"

VLMinTermPartIter Convert a composite minterm into a list of VLMinTerm singles
#include "amma/Logic2/ConstraintSet.hh"

VLConstraintSetC Logical constraint
#include "amma/Logic2/Constraint.hh"

VLConstraintC Logical constraint
#include "amma/Logic2/LCIndType.hh"

VLCIndTypeC Type index handle.
#include "amma/Logic2/LCIndTypeIter.hh"

VLCIndTypeIterC Type iterator
#include "amma/Logic2/LCIndLeaf.hh"

VLCIndLeafC Leaf node.
#include "amma/Logic2/LCIndVal.hh"

VLCIndValC Index by pure symbol
#include "amma/Logic2/LCIndValIter.hh"

VLCIndValIterC Symbol value iterator
#include "amma/Logic2/LCIndExpr.hh"

VLCIndExprC Leaf node.
#include "amma/Logic2/LCFiltIndexIter.hh"

VLCFiltIndexIter Filtered Index Iterator.
#include "amma/Logic2/LIndexIter.hh"

VLIndexIterC VLCIndex iterator.
#include "amma/Logic2/LIndex.hh"

VLIndexC Index of expressions.
#include "amma/Logic2/LCFiltIndexIter.hh"

VLFiltIndexIter Filtered Index Iterator.
#include "amma/Logic2/LCIndexItPnt.hh"

VLCIndexIterPntC Iteration point handle.
#include "amma/Logic2/ListIndex.hh"

VLListIndexC Sets indexed by Expressions.
VLListIndexIterC List index iterator.
#include "amma/Logic2/LFiltIndexIter.hh"

VLCFiltIndexIterC Filtered Index Iterator.
VLFiltIndexIterC Filtered Index Iterator, Typed access
#include "amma/Logic2/MinTermIndex.hh"

VLMinTermIndexC Setup a mapping between an arbitary type and a MinTerm.
#include "amma/Logic2/BNPIndexIter.hh"

VLBNPIndexIterC Branching Neg/Pos index iterator.
#include "amma/Logic2/BIndex.hh"

VLBIndexC Branching index.
#include "amma/Logic2/BNPIndex.hh"

VLBNPIndexC Branching Neg/Pos Index.
#include "amma/Logic2/BNPListIndex.hh"

VLBNPListIndexC This is a specialisation of VLNPIndex.
#include "amma/Logic2/LMinTermIndexIter.hh"

VLMinTermIndexIterC MinTerm index iterator.
#include "amma/Logic2/LTypeIndex.hh"

VLTypeIndexC TypeIndex.
#include "amma/Logic2/LExprSetIter.hh"

VLExprSetIterC Expression set iterator.
#include "amma/Logic2/LExprSet.hh"

VLExprSetC
#include "amma/Logic2/LRule.hh"

VLRuleC Replacement rule.
#include "amma/Logic2/Theory.hh"

VLTheoryC A Theory is a set of rules.
#include "amma/Logic2/LSubst.hh"

VLSubstSetC Set of substitutions, will do expression matching.
#include "amma/Logic2/SpaceSet.hh"

VLSpaceSetC Set of spaces.
VLSpaceSetIterC Iterator for set of spaces.
#include "amma/Logic2/LBndTypeSearch.hh"

VLBndTypeSearchC Search though TypeInd for Expression types that involve one or more values from bnds.
#include "amma/Logic2/SpaceDiff.hh"

VLSpaceDiffBodyC Find the difference between a set of spaces and a new space.
VLSpaceDiffC Find the difference between a set of spaces and a new space.
#include "amma/Logic2/DeciElem.hh"

VLDeciListElemC Decision List Element.
#include "amma/Logic2/DeciList.hh"

VLDeciListC Decision List.
#include "amma/Logic2/CandDescrim.hh"

VLCandidateDescrimC candidate descrimination term.
#include "amma/Logic2/CandDescrimSet.hh"

VLCandidateDescrimSetC Candidate Descrimination Set.
#include "amma/Logic2/SpaceDiffMV.hh"

VLSpaceDiffMVBodyC Find the difference between a set of spaces and a new space.
VLSpaceDiffMVC Find the difference between a set of spaces and a new space.
#include "amma/Logic2/LExprGen.hh"

VLExprGeneratorC Expression generator.
#include "amma/Logic2/SpaceDiffIter.hh"

VLSpaceDiffIterC Iterate all possible differences between two spaces.
#include "amma/Logic2/LDeciExprGen.hh"

VLDeciExprGenC Iterate through possible expressions.
#include "amma/Logic2/ExprFragSet.hh"

VLExprFragmentSetBodyC Generate the set of all possible fragments of an expression/minterm.
VLExprFragmentSetC Generate the set of all possible fragments of an expression/minterm.
#include "amma/Logic2/DLModel.hh"

VLModelDLC Decision List Model.
#include "amma/Logic2/Model.hh"

DPModelC Model of a system.
#include "amma/Logic2/DLModelAction.hh"

VLModelDLActionC Action model.
#include "amma/Logic2/ModelBuilder.hh"

DPModelBuilderC Model builder handle.
#include "amma/Logic2/ModelStep.hh"

DPModelStepC Information about a step in a plan.
#include "amma/Logic2/RuleModel.hh"

VLModelRuleC Simple Rule Model.
#include "amma/Logic2/DLModelBuilder.hh"

DPModelDLBuilderC DL Model builder handle.
#include "amma/Logic2/DLSModel.hh"

VLModelDLSC Decision List (Single) Model.
#include "amma/Logic2/DLSModelBuilder.hh"

DPModelDLSBuilderC DL Model builder handle.
#include "amma/Logic2/NonLinearPlan.hh"

VLNonLinearPlanC non-linear plan handle
VLNonLinearPlan The body of a non-linear plan.
#include "amma/Logic2/NLPlanner.hh"

VLNLPlannerC Planner class.
#include "amma/Logic2/PlanLinear.hh"

VLPlanLinearC Simple linear plan.
#include "amma/Logic2/Plan.hh"

VLPlanBadStateC Exception class for bad state for plan.
VLPlanC An abstract plan.
#include "amma/Logic2/PlanSingle.hh"

VLPlanSingleOpC Simple linear plan.
#include "amma/Logic2/Act2Plan.hh"

VLAct2PlanC Process to turn an action into a simple plan.
#include "amma/Logic2/Planner.hh"

VLPlannerC Planner handle.
#include "amma/Logic2/PlanNL.hh"

VLPlannerNLC Non-linear planner.
#include "amma/Logic2/PlanOneStep.hh"

VLPlannerOneStepC One step planner.
#include "amma/Logic2/PlanNLB.hh"

VLPlannerNLBodyC Non-linear planner body.
#include "amma/Logic2/PlanStep.hh"

VLStepC Logical step in a plan
#include "amma/Logic2/World.hh"

VLWorldC World interface.
#include "amma/Logic2/TestWorld.hh"

VLTestWorldC Test world.
#include "amma/Logic2/AsyncWorld.hh"

VLAsyncWorldC Async world base.
#include "amma/Logic2/DarkCastle.hh"

PlayerC Player
RoomC Room.
ObjectC Object
EntityC Adventure Entity Handle.
PortalC Portal between rooms.
WorldC World body
InterfaceC Test world.
#include "amma/Logic2/Executor.hh"

VLExecutorC Exevutor body.
#include "amma/Logic2/RandomAct.hh"

VLRandomActC Random Action Generator.
#include "amma/DERA/RegOrderedGrow.hh"

RegSeedC Stores seeds for region growing
RegOrderedGrowC Segmentation using region growing ordered by boundary pixel intensity.
#include "amma/DERA/StaticTrack.hh"

StaticTrackC Performs static tracking stage, no temporal information
#include "amma/DERA/RegBoundary.hh"

RegBoundaryC Stores a region boundary as well as statistcs
#include "amma/DERA/ClusterTrack.hh"

ClusterTrackC Performs motion cluster tracking, considers only current frame motion
#include "amma/DERA/FeatureTrack.hh"

FeatureTrackC Performs history analysis of the tracked objects, ie temporal filtering
#include "amma/DERA/MotionTrack.hh"

MotionTrackC Performs motion tracking stage
#include "amma/DERA/NumCostRegion.hh"

NumCostRegionC Optimisation cost function interface for image region comparison.
#include "amma/visualdb/NumVBDataSet.hh"

NumVBDataSetC
#include "amma/visualdb/DatabaseUtils.hh"

DatabaseUtils
Shape
#include "amma/visualdb/ImageDb.hh"

ImageDbC Defines Save(StringC & filename)for type ThisClassC
#include "amma/visualdb/ImageIndex.hh"

ImageIndexC
#include "amma/visualdb/ImageSet.hh"

ImageRegionC Put a brief description of your class
#include "amma/visualdb/RmSmallClusters.hh"

RmSmallClustersC Class to decide whether the node of a graph should be merged with any of its neighbours and which neighbour
#include "amma/visualdb/ClusterNode.hh"

ClusterNodeC Representation of a two-dimensional, arbitrarily-shaped region as a node in a region adjacency graph
#include "amma/visualdb/ClusterRAG.hh"

ClusterRAGC
#include "amma/visualdb/RegionVector.hh"

RegionVectorC
#include "amma/visualdb/MergeCloseClusters.hh"

MergeCloseClustersC Class to decide whether the node of a graph should be merged with any of its neighbours and which neighbour
#include "amma/visualdb/MeanShiftAlg.hh"

MeanShiftAlgC Put a brief description of your class here
#include "amma/visualdb/StatMeasure.hh"

StatMeasureC
#include "amma/visualdb/IllumiNorm.hh"

IllumiNormC
#include "amma/visualdb/Dct.hh"

DctC
#include "amma/visualdb/Intensity.hh"

IntensityC
#include "amma/visualdb/ColourC.hh"

ColourC
#include "amma/visualdb/Wavelet.hh"

WaveletC
#include "amma/visualdb/Gabor.hh"

GaborC
#include "amma/visualdb/ColourThread.hh"

ColourThread
#include "amma/visualdb/IntensityThread.hh"

IntensityThread
#include "amma/visualdb/DctThread.hh"

DctThread
#include "amma/visualdb/WaveletThread.hh"

WaveletThread
#include "amma/visualdb/GaborThread.hh"

GaborThread
#include "amma/visualdb/QueryThread.hh"

QueryThread
#include "amma/visualdb/NNetDb.hh"

NNetDbC
#include "amma/visualdb/IdbCanvasData.hh"

IdbCanvasDataC Put a brief description of your class here
#include "amma/visualdb/ImageGrid.hh"

ImageGridC Put a brief description of your class here
#include "amma/visualdb/QueryOption.hh"

QueryOptionC Put a brief description of your class here
#include "amma/visualdb/QueryCanvasData.hh"

QueryCanvasDataC Put a brief description of your class here
#include "amma/visualdb/QueryControl.hh"

QueryControlC Put a brief description of your class here
#include "amma/LabelImage.hh"

LabelImageC Put a brief description of your class
#include "amma/VecImage.hh"

VecImageC
#include "amma/Pizza2C.hh"

Pizza2C
#include "amma/Pizza3C.hh"

Pizza3C
#include "fftw/fftw-int.h"

fftw_time_struct
#include "fftw/fftw.h"
fftw_twiddle_struct
fftw_rader_data_struct
fftw_plan_node_struct
fftw_plan_struct
Enumerated types:

#include "amma/Index2d.hh"
enum NeighbourOrderT { NEIGH_RIGHT = 0, NEIGH_DOWN_RIGHT = 1, NEIGH_DOWN = 2, NEIGH_DOWN_LEFT = 3, NEIGH_LEFT = 4, NEIGH_UP_LEFT = 5, NEIGH_UP = 6, NEIGH_UP_RIGHT = 7, NEIGH_CENTER = 8 } ;
enum GridMetricT { CITY_BLOCK, MAX_VALUE, SQUARE_EUCLID } ;

#include "amma/Directio.hh"
enum DirectionT { RIGHT = 64, UP_RIGHT = 96, UP = 128, UP_LEFT = 160, LEFT = 192, DOWN_LEFT = 224, DOWN = 0, DOWN_RIGHT = 32 } ;

#include "amma/DirRLUD.hh"
enum DirectionRLUDT { TO_DOWN = 0, TO_RIGHT = 1, TO_UP = 2, TO_LEFT = 3, TO_NODIR = 4 } ;

#include "amma/Dir8RLUD.hh"
enum Direction8RLUDT { D8_D = 0, D8_R = 1, D8_U = 2, D8_L = 3, D8_DR = 4, D8_UR = 5, D8_UL = 6, D8_DL = 7, D8_NO = 8 } ;

#include "amma/CrackCod.hh"
enum CrackCodeT { CR_DOWN = 0, CR_RIGHT = 1, CR_UP = 2, CR_LEFT = 3, CR_NODIR = 4 } ;
enum RelativeCrackCodeT { CR_AHEAD = 0, CR_TO_LEFT = 1, CR_BACK = 2, CR_TO_RIGHT = 3, CR_RNODIR = 4 } ;

#include "amma/ColorCnv.hh"
enum GrabberT { STANDARD, TELCHAR, ABEKAS } ;

A list of grabbers.

#include "amma/Image/IPWavelet.hh"
enum WaveletFilterT { WaveletFilterT_D4, WaveletFilterT_D6, WaveletFilterT_D6sym, WaveletFilterT_D8, WaveletFilterT_D10 } ;

#include "amma/Quartern.hh"
enum JointT { JNULL, RX, RY, RZ, RXRY, RXRZ, RYRZ, RXRYRZ, TXTYTZRXRYRZ, TXTYTZRZRYRX } ;

This list may be extended in time. Therefore please always use default in a switch to test for unprocessed option, and not for any other task.

#include "amma/Homtm.hh"
enum HtmOperT { RotNone, RotX, RotY, RotZ } ;

-----------------------------------------------------------------------------

#include "amma/Regis.hh"
enum SceModT { scene_scene, model_scene } ;
Registers two 3d data sets.

VERY QUICK EXPLANATION:

RegisC reg(base, query);
RigidTransC rt=reg.ExportRT(void);
rt will now contain the transform required to move base to register with query

MORE DETAILS:

This is a simple routine to register two 3d data sets. It assumes

that query[i] = rot * base[i] + trans + noise

and finds the Least Squares estimate of rot and trans. It is based on Arun, Huang & Blostein PAMI 9(5) 698-700 (1987) there are later enhancements to the method in Umeyama, PAMI 13(4) 376-380 (1991) and Kanatani, PAMI 16(5) 543-549 (1994). The result is always a proper rotation.

Member function Transform does rot * v + trans and InvTransform does rot^T * (v - trans)

Notes :

I use Vector3dC and Matrix3d3C throughout except where I need the SVD, where I use VectorC and MatrixC.

This routine always produces a result, which may however not be unique. The member function unique can be asked to provide the status. Examples of non-unique transformation are only 2 points or all points collinear.

Whether or not a tranf is unique depends on a threshold - nearlyzero in Regis.cc This threshold controls several things and should be developed a little further.

Programmers note:

Beware of errors caused by FixSmallToBeZero, use only for print out!

There is a switch in Regis.cc that can be used for some debugging

Some services additional to computing the pose and its covariance are available in particular Cal_dr is a standalone routine

Covariance Notes
----------------

For a meaningful covariance meaningful weights must be input, and the SceModT must be specified.

Point covariances are sigma2 = 3 rho2 - sigma2 is the rms Euclidean distance
- rho2 is the mean squared delta x, y or z

The weight[i] should be 1/sigma2. This is converted to wi = (2 for SceSce) diag[ 1/rho2, 1/rho2, 1/rho2]

Simplified uses include just setting the weights to 0/1 and not computing the covariance.

Note the details in the computation of sigma2.

#include "amma/CorrSet.hh"
enum RegMethodT { MEANREG, SCHMITT, NREG } ;
CorSpecT holds the information for one correspondence set.

#include "amma/Schmitt.hh"
enum enumXYZ { x, y, z } ;
The SchmittC class registers N point sets using Schmitt's method.

The SchmittC class registers N point sets using Schmitt's method.

There are M overlapping sets of points (Schmitt's notation), which means that each view has a point set, so M is the number of views. The overlap between two different views, are subsets of the point sets belonging to each view, and this is a correspondence set. 

 Algorithm
   - Calculate all constant matrices (Abar, Pbar, all Q's =Qr+Qt).
   - Main Loop: While not converged do
        -> Calculate all N^j's & hence the quaternions (rotations).
        -> Calculate Bbar (diff between rotated centroids).
        -> Calculate Xbar (translations).
        -> Update Rigid Transforms.
        -> Calculate MSE.
        -> Determine if convergence has occurred.

The constructor allows guesses to be passed which will then be used to initialise the elements of rtsM. Each element being associated with a view.

The expected rigid transforms can be passed via the function SetExpectedRTs, which is only used for the calculation of delta theta.



#include "amma/SynthRan.hh"
enum EnumOnOff { on, off } ;
SynthRanC is a class which provides facilities to create synthetic range images from a synthetic 3D model (a .tri file).
SynthRanC is a class which provides facilities to create synthetic range images from a synthetic 3D model (a .tri file).

The resolution of the imaginary range scanner can be controlled by specifying the number of rows and columns. You can also specify the viewing direction by using a unit directional vector.

Once the range image has been created you can save it to a .tri file (3D representation) or a .dep file (range image).

#include "amma/VTRing.hh"
enum EdgeCollapseT { HOPPEPASS, HOPPEFAIL2, HOPPEFAILFACE, HOPPEWHAT } ;

HOPPE 2 is implemented in an over restrictive way. ------------------------------------------------------------------------- -------------------------------------------------------------------------

#include "amma/VTBound.hh"
enum AddTypeT { ERROR, SURFACE_BOUND, INREGION, SELF_INTERSECT, SELF_INTERSECT_GO, SUCCESS_1, SUCCESS_2, COMPLETE, EMPTY } ;

------------------------------------------------------------------------- Each edge is represented by its iterator in the VTRingC structure. The indicator i says whether the boundary goes in the 0 or 1 direction as defined in the VTRingC structure.

#include "amma/BaseRegis.hh"
enum EnumPrediction { noPrediction = 0, prediction = 1 } ;
enum EnumRegWay { regis = 0, PREGIS = 1 } ;
enum EnumBoundary { keepBoundaryPoints = 0, discardBoundaryPoints = 1 } ;
enum EnumAngle { noAngleCheck = 0, doAngleCheck = 1 } ;
enum EnumMseCalculation { standardMse = 0, madEstimator = 1 } ;
enum EnumSigmaCheck { noDistanceCheck = 0, doDistanceCheck = 1 } ;
BaseRegisC is an Abstract Base Class, which is reference counted (Big Object) and provides the core operations for doing point set registration.
BaseRegisC is an Abstract Base Class, which is reference counted (Big Object) and provides the core operations for doing point set registration.

To avoid an accumulating error, a vector set workMovPointsM is defined which is initialized as a copy of startMovPointsM. A nearest neighbour search is performed on the fixed object. The result of this search is stored in the vector set fixM, which contains all the corresponding nearest neighbour points to workMovPointsM.

workMovPointsM and fixM will be registered and the transformation of this single iteration step is stored in rtKM. After each iteration, deltaRtKM is applied to all previous transformations, so that rtKM represents the RigidTransC to transform startMovPointsM -> fixM. The next iteration starts with workMovPointsM = rtKM o startMovPointsM, again nearest neighbour search and so on.

The returned RigidTransC of BaseRegisC contains the transformation

rtKM o (guess o startMovPointsM) = fixM

To accelerate the time expensive process of iteration, the user may select prediction (based on Besl & McKay 92), which demands less iterations.

There are further quality improving features that can be switched on and off. These are Surface Normal Check, Boundary Check and Distance Check.

The user also has the facility of choosing the method to be used to calculate the Mean Square Error.

When using the trace mode, printouts are given on each iteration step. Some of the fields are only relevant when using the prediction. Hence there fields will be blank, indicated by ------. 

 #i       - iteration number
 #pts     - number of random points on moveable surface
 #w       - number of weights minus the sum of weights
 RMS      - RMS value
 % 1st    - Comparison of the current & very 1st RMS value in %
 |Trans|  - Translation occured from previous translation
 %Tn-1    - Comparison of the last & current total translation value in %
 %Texp    - Comparison of the expected & current total translation in %
 Rotation - Current Rotation in degrees
 %Rn-1    - Comparison of the last & current total rotation in %
 %Rexp    - Comparison of the expected and current rotation in %
 NCA      - Indicates whether weights were affected by the Normal Angle Check
 BCA      - Indicates whether weights were affected by the Boundary Check
 DCA      - Indicates whether weights were affected by the Distance Check
 Thek_1   - Angle in 7D space between previous last two registration vectors
 Thetak   - Angle in 7D space between last two registration vectors
 PRP      - Prediction is Possible (Good Alignment Between last two 
            registration vectors)
 CDP      - Can Do Prediction (Parabola, Line Based or Max Allowable Update)
 PUO      - Permanent Prediction Update Occured (YES/NO)
 MSEk     - Value of MSE before attempted prediction update
 MSEp     - Value of MSE after (temporary/permanent) prediction update

FindNearest returns the vector set fixM containing the closest surface points to a given set of points workMovPointsM. It also needs an array of weights. Points that have their weight value less than NearZero will be completely ignored. Note that the derived class will provide the virtual GetNNPairs() function, which is required by FindNearest. An error message will be given by FindNearest if the sum of all weights is zero, the program will then be terminated since it is then impossible to proceed.

All vector sets that are passed to the constructors must have the same number of entries i=1...N.

There are various options provided by the constructor and member functions, which affect results obtained, except the trace option.

Trace

0 : No information is displayed.
1 : All information is displayed; the amount of detail displayed depends whether the Basic ICP or Accelerated ICP is being used.

Check Boundary

keepBoundaryPoints : Do not modify weight values of boundary points.
discardBoundaryPoints : Boundary point weight values are modified accordingly to the distance and standard deviation.

Check Normals

noAngleCheck : No normal angle check is performed.
doAngleCheck : A normal angle check is performed and each point's weight is weight is modified appropriately.

Distance Check

noDistanceCheck : Do not perform distance check.
doDistanceCheck : Perform distance check and modify each point's weight appropriately.

MSE Calculation

standardMse : Use the standard MSE calculation method.
madEstimator : Use the Median Absolute Deviation Estimator Method.

#include "amma/RanRegis.hh"
enum EnumRSquareStatus { invalid = 0, valid = 1, boundary = 2 } ;
RanRegisC uses the Range Image Search Nearest Neighbour Method and is reference counted (Big Object).
RanRegisC is derived from the base abstract class BaseRegisC and is reference counted (Big Object). This is the Body and should not be used directly. It should be used by the provided Handle Class.

The class requires two range images (FloatRangeC).

An initial guess is required to start the iterative process of motion estimate, which is passed to PerformRegistration (a member function of BaseRegisC). The result of the final transformation that registers the two surfaces will be returned as a RigidTransC.

The constructor uses the first range image to do the nearest neighbour (NN) search on.

There are various options provided by the constructor and member functions, which affect results, except the trace option. See the Base Class for more details on these options.

#include "amma/GUI/SignalInfo.hh"
enum SignalTypeT { SigTypeUnknown, SigTypeGeneric, SigTypeEvent, SigTypeEventMouseButton, SigTypeEventMouseMotion, SigTypeString, SigTypeCListSel, SigTypeCListCol } ;
Signal info

#include "amma/GUI/3D/gdkgl.h"
enum _GDK_GL_CONFIGS { GDK_GL_NONE = 0, GDK_GL_USE_GL = 1, GDK_GL_BUFFER_SIZE = 2, GDK_GL_LEVEL = 3, GDK_GL_RGBA = 4, GDK_GL_DOUBLEBUFFER = 5, GDK_GL_STEREO = 6, GDK_GL_AUX_BUFFERS = 7, GDK_GL_RED_SIZE = 8, GDK_GL_GREEN_SIZE = 9, GDK_GL_BLUE_SIZE = 10, GDK_GL_ALPHA_SIZE = 11, GDK_GL_DEPTH_SIZE = 12, GDK_GL_STENCIL_SIZE = 13, GDK_GL_ACCUM_RED_SIZE = 14, GDK_GL_ACCUM_GREEN_SIZE = 15, GDK_GL_ACCUM_BLUE_SIZE = 16, GDK_GL_ACCUM_ALPHA_SIZE = 17, GDK_GL_X_VISUAL_TYPE_EXT = 0x22, GDK_GL_TRANSPARENT_TYPE_EXT = 0x23, GDK_GL_TRANSPARENT_INDEX_VALUE_EXT = 0x24, GDK_GL_TRANSPARENT_RED_VALUE_EXT = 0x25, GDK_GL_TRANSPARENT_GREEN_VALUE_EXT = 0x26, GDK_GL_TRANSPARENT_BLUE_VALUE_EXT = 0x27, GDK_GL_TRANSPARENT_ALPHA_VALUE_EXT = 0x28 } ;

#include "amma/colorquant.h"
enum e_aryEl { BYTEMATRIX = 1, SHORTINTMATRIX, INTEGERMATRIX, FLOATMATRIX, DOUBLEMATRIX, UBYTEMATRIX, POINTERMATRIX, RGBMATRIX, XRGBMATRIX, FRGBMATRIX, YUVMATRIX, RGIMATRIX, USHORTINTMATRIX, RGBXMATRIX, USER_DEFINED = 255 } ;

#include "fftw/fftw-int.h"
enum fftw_wisdom_category { FFTW_WISDOM, RFFTW_WISDOM } ;

#include "fftw/fftw.h"
enum fftw_node_type { FFTW_NOTW, FFTW_TWIDDLE, FFTW_GENERIC, FFTW_RADER, FFTW_REAL2HC, FFTW_HC2REAL, FFTW_HC2HC, FFTW_RGENERIC } ;
Typedefs:

#include "amma/Boolean.hh"
typedef bool BoolT;

The type of the logical values true and false.

typedef bool BooleanT;
typedef bool BooleanC;

#include "amma/StdTypeA.hh"
typedef unsigned char ByteT;
typedef signed char SByteT;
typedef char CharT;
typedef signed char SCharT;
typedef unsigned char UCharT;
typedef int IntT;
typedef unsigned int UIntT;
typedef long int LongIntT;
typedef unsigned long int ULongIntT;
typedef float FloatT;
typedef double DoubleT;

Arithmetic types with limited precision ---------------------------------------

typedef signed short int Int16T;

16 bits long signed integer.

typedef unsigned short int UInt16T;

16 bits long unsigned integer. General entity types --------------------

typedef UIntT SizeT;

A number of components in a compound structure.

typedef IntT MIndexT;

A machine oriented index of containers. It must be always signed integer number to allow tests of underflowing of zero. It should not be used for other purposes than to index items of built-in raw arrays. Class IndexT based on IndexC should be used for all other cases.

typedef UIntT MUIndexT;

Machine unsigned index used for indexing of all containers with positive indexes only. It should be used only in very low level of a class hierachy. Both tests of limits of a container have the same form of testing only of the higher limit. Thus this index benefits from the definition to be circular entity without any underflowing and overflowing. The type of this index should be always corresponding to type SizeT to enable comparisions without type conversions. IAPS - Image analysis program system. End of include file StdTypeA.hh

#include "amma/Index.hh"
typedef IndexC IndexT;

General index type. ==================================================================== ======= IndexC ===================================================== ====================================================================

#include "amma/Index2d.hh"
typedef UIntT GridDistanceT;

==================================================================== ======= Index2dC =================================================== ====================================================================

#include "amma/KwList.hh"
typedef KIter1C KIterC;

#include "amma/StdType.hh"
typedef DoubleT RealT;
A number represented with double precision.

#include "amma/String.hh"
typedef StringC StrTmp;

for backward compatibility other externs

#include "amma/Pixel.hh"
typedef IndexT PixelIndexT;
Pixel image coordinates

#include "amma/Stream.hh"
typedef int streamsize;

#include "amma/FilePerm.hh"
typedef unsigned long ulong_t;
typedef ulong_t mode_t;
typedef long uid_t;
typedef uid_t gid_t;

#define S_IFMT 0xF000 /* type of file */ #define S_IFDIR 0x4000 /* directory */

#include "amma/Cxx/tokenizer.h"
typedef const char * YYSTYPE;

#include "amma/LiPoint2.hh"
typedef ConstDLIterC<Point2dC> Point2dCLIterC;
typedef DLIterC<Point2dC> Point2dLIterC;

#include "amma/BVertex.hh"
typedef int BVertexIndexT;
Boundary vertex
The relationship between pixel coordinates and boundary vertex is that the boundary vertex [i,j] is the up-left corner of the pixel (i,j). The figure contains the orientation of edges too. 
        [i,j] <------------ [i,j+1]
        |                    /^\       
        |      (i,j)          |       
        V                     |       
       [i+1,j] ---------> [i+1, j+1]


#include "amma/EdgeList.hh"
typedef ConstDLIterC<EdgeC> EdgeCPtrC;
typedef DLIterC<EdgeC> EdgePtrC;
typedef DListC<EdgePtrC> EdgePtrListC;
typedef DLIterC<EdgePtrC> EdgePtrIterC;
typedef DListC<EdgeCPtrC> EdgeCPtrListC;
typedef DLIterC<EdgeCPtrC> EdgeCPtrIterC;
Elementary boundary edge list

typedef DListC<EdgeC> EdgeListC;

IAPS - Image analysis program system. End of include file EdgeList.hh

#include "amma/GMLineGf.hh"
typedef Line2dPPC LineGfC;
typedef DListC<int> IntListC;
gf file sets - a line by George Matas

#include "amma/IPolyg2.hh"
typedef DListC<Index2dC> Index2ListC;
An integer polygon in 2d space
The IntPolygon2dC class is a representation of a polygon in 2 dimensional digital space. A polygon is the region of a plane bounded by a finite collection of line segments forming a simple closed curve.

typedef DListC<IntPolygon2dC> FooIntPolygon2dCPPPPPC;

help GNU C++ 2.6.0

#include "amma/VVdefs.hh"
typedef DListC<Index3dC> FoooIndListCC;

help to GNU C++ 2.6.0

#include "amma/MeanCo1d.hh"
typedef MeanCovariance1dC MeanVarianceC;

The alternative name of the class MeanCovariance1dC more related to the terminology used in publications on statistics.

#include "amma/FFT1d.hh"
typedef struct fftw_plan_struct * fftw_plan;
Interface class for 1d FFTW

#include "amma/Num/NumDataSet.hh"
typedef NumDataC<VectorC,VectorC> NumVVDataC;
typedef NumDataC<VectorC,MatrixC> NumVCDataC;
typedef NumDataC<VectorC,NumLabelC> NumVLDataC;
typedef NumDataC<VectorC,StringC> NumVSDataC;

#include "amma/Num/DataSetTuple3.hh"
typedef Tuple3C<VectorC,VectorC,NumLabelC> VVLDataC;
typedef DataSetTuple3C<VectorC,VectorC,NumLabelC> VVLDataSetC;

////////////////////////////////////////////////////////////////

#include "amma/BaseOpt.hh"
typedef MatrixC SoftAssignC;
typedef SArray1dC<unsigned int> HardAssignC;

#include "amma/GradAssOpt.hh"
typedef BaseCostC GradAssCostC;

------------------------------------------------------------------------- -------------------------------------------------------------------------

#include "amma/SAOpt.hh"
typedef BaseCostC SACostC;
typedef BaseCostC ICMCostC;

------------------------------------------------------------------------- *********** Simulated Annealing ***************************************** ------------------------------------------------------------------------- This is a minimizer. Major choices: Apart from the usual parameters you must choose - assignment or not. The assignment flag selects that the solution must be a permutation matrix. - some variables may be clamped (fixed) and the optimisation proceeds only over other variables All the stuff for clamping probably adds an overhead HOW DOES IT WORK? ----------------- The non-assignment method in one pass - looks at each object and computes the energy of all possible labels - the label is reassigned with a thermal probability The assignment method in one pass - loops over all objects - then chooses another object at random - computes the energy of a swap - performs the swap with thermal probability The execution times are NOT comparable as the permutation algorithm has a much smaller search space. Parameters ---------- nobjs nlabs thi tlo f passes idum ------------------------------------------------------------------------- -------------------------------------------------------------------------

#include "amma/MFTOpt.hh"
typedef BaseCostC MFTCostC;

------------------------------------------------------------------------- -------------------------------------------------------------------------

#include "amma/GreyVal.hh"
typedef SByteT SByteGreyValueT;

signed byte value

typedef UInt16T GreyValueU16T;

limited integer value grey level

typedef Int16T GreyValue16T;

limited integer value grey level

typedef RealT RealGreyValueT;

real value

typedef RealT DoubleImageValueT;

Used for double images. why is this different from RealGreyValueT ? CG. Grey value constants.

#include "amma/GreyImIt.hh"
typedef ImageIterC<ByteGreyValueT> ByteImageIterC;
typedef ImageRectIterC<ByteGreyValueT> ByteImageRectIterC;
typedef ImagePIterC<ByteGreyValueT> ByteImagePIterC;

#include "amma/ByteImag.hh"
typedef Point2dC IllDirectionC;
Image with byte pixel values
An image of byte sized chunks.

#include "amma/DoubleIm.hh"
typedef DoubleImageC RealImageC;

Nickname for the image of real pixel values.

#include "amma/pixchain.hh"
typedef DLIterC<PixelC> PixelPtrC;

class PixelListC: public ListC {};

typedef DListC<PixelC> PixelListC;

class CannyStringC: public PixelListC {};

typedef PixelListC CannyStringC;
typedef DLIterC<CannyStringC> CannyStringPtrC;

#include "amma/BaseIntl.hh"
typedef anon_enum?22 ScanT;

#include "amma/Motion/MultiScaleMotion.hh"
typedef PairC<NumImageC<RealT>> impairT;

#include "amma/Polops.hh"
typedef Vector3dC PolVecC;
Structure used in PolopsC to represent a face.

#include "amma/ristags.h"
typedef int buflen_t;
typedef long risoffset_t;
typedef unsigned short ristype_t;
typedef unsigned short rislabel_t;
typedef risfile_t RISFILE;

#include "amma/VTRing.hh"
typedef KIterC ItVertC;
typedef KIterC ItItVertC;
typedef KIterC ItTriC;
typedef KIterC ItItTriC;
typedef KIterC ItEdgeC;
typedef KIterC ItTEdgeC;

------------------------------------------------------------------------- ------------------------------------------------------------------------- A useful representation of an edge

#include "amma/VTNear.hh"
typedef DListC<VTPointStuffC> PListC;
typedef DLIterC<VTPointStuffC> PLIterC;

#include "amma/Hash3d.hh"
typedef DListC<t_hash3d_data> t_hash3d_list;
typedef DLIterC<t_hash3d_data> t_hash3d_iter;

typedef StackG< t_hash3d_data > t_hash3d_list; typedef StackIterG< t_hash3d_data > t_hash3d_iter; ======================================================== Constructs a hash table of points in 3D space using a voxel subdivision of 3D space to generate key The size of the hash table is a prime number greater than the number of points to be inserted in the table. Hash table: contains a list of `references' to points with the same hash index. Reference: a unique reference for each point should is passed to the table on insertion.

#include "amma/Mesh.hh"
typedef OrthoProjection3to2dC MeshElemProjC;

-----------------------------------------------------

#include "amma/BVoxSet.hh"
typedef unsigned char VoxRealT;

------------------------ ================================================================= #include "amma/Vox.hh" #include "amma/Status.hh" ============================================================ BaseVoxSetC data structure not dependent on the voxel data type

#include "amma/Vox.hh"
typedef VoxBoundPointNormalC VoxDataC;

==================================================================

#include "amma/HoppeSlime.hh"
typedef DListC<PointStuffC> HSListC;
typedef DLIterC<PointStuffC> HSLIterC;

-------------------------------------------------------------------------

#include "amma/AMSegment.hh"
typedef SArray1dC<SegDynaTC> FieldC;

----------------------------------------------------------------------------- Bear in mind that Segment is a MIXTURE of big and small objects. The building block of AMFigureC. Represents a rigid part of the model. It has a physical appearance which includes only shape It can be connected with other segments, so that the structure of the owner figure is determined. A segment has a static transform and a dynamic trans may be applied A Figure contains an array of segments, linked into a tree structure. A segment has one parent segment and up to 3 children ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- AMSegmentC -----------------------------------------------------------------------------

#include "amma/GUI/Widget.hh"
typedef struct _GdkEventMotion GdkEventMotion;
typedef struct _GdkWindow GdkBitmap;
Widget base body.

#include "amma/GUI/ToolTips.hh"
typedef struct _GtkTooltips GtkTooltips;

#include "amma/GUI/RadioButton.hh"
typedef struct _GSList GSList;
Radio button

typedef DListC<GUIRadioButtonBodyC *> GUIRadioButtonGroupT;

#include "amma/GUI/3D/3DCanvas.hh"
typedef struct _GdkGLContext GdkGLContext;

#include "amma/GUI/3D/gdkgl.h"
typedef struct _GdkGLPixmap GdkGLPixmap;

#include "amma/GUI/3D/gtkglarea.h"
typedef struct _GtkGLArea GtkGLArea;
typedef struct _GtkGLAreaClass GtkGLAreaClass;

#include "amma/Thread/Mutex.hh"
typedef VMutex MutexC;

#include "amma/Logic2/LExprType.hh"
typedef VLExprTypeC VLExprTypeH;
Stream operator.

#include "amma/Logic2/LSymb.hh"
typedef DListC<VLSymbC> VLSymbLstC;
List of symbols.
Include "amma/DList.hh" to use.

typedef DLIterC<VLSymbC> VLSymbLstIterC;
Symbol handle.
Unlike VLSymbC creates new symbol by default.

#include "amma/Logic2/LSymbSet.hh"
typedef VLSymbSetC VLSymbSet;
Set of symbols.
BIG OBJECT.

This is a simple set of symbols, this will NOT do any pattern matching, or unification operations.

typedef HSetIterC<VLSymbC> VLSymbSetIterC;

///////////////////////////////////////////////

#include "amma/Logic2/LExprIter.hh"
typedef VLExprIter VLExprTypeIterC;

//////////////////////// Iterator & Handle.

#include "amma/Logic2/Types.hh"
typedef UIntT DBID;

#include "amma/Logic2/LExprLabLst.hh"
typedef VLExprLabelLst VLExprLabelLstC;
typedef DLIterC<VLExprLabelC> VLExprLabelIterC;
typedef DLIterC<VLExprLabelC> VLExprLabelLstIterC;

#include "amma/Logic2/LBindLstIter.hh"
typedef VLBindLstIter VLBindLstIterC;

#include "amma/Logic2/LMinTerm.hh"
typedef ConstDLIterC<VLMinTermC> VLMinTermLstCIterC;
Logical min-term.
this contains two sets of symbols. this first set must be all true, and the second all false.

#include "amma/Logic2/LMinTermSOP.hh"
typedef VLMinTermSOP VLMinTermSOPC;

////////////////////////////////////////////////////////////

#include "amma/Logic2/LMinTermPIter.hh"
typedef VLMinTermPartIter VLMinTermPartIterC;

//////////////////////////////////////////////////////////

#include "amma/Logic2/LRule.hh"
typedef DListC<VLRuleC> VLRuleListC;

////////////////////////////

#include "amma/Logic2/Theory.hh"
typedef HSetC<VLRuleC> VLRuleSetC;

#include "amma/Logic2/PlanStep.hh"
typedef DListC<VLStepC> VLStepLstC;
typedef DLIterC<VLStepC> VLStepIterC;

#include "amma/colorquant.h"
typedef enum e_aryEl t_aryEl;

#include "amma/visualdb/RegionVector.hh"
typedef Tuple2C<PixelC,NumLabelC> PixLabelT;
typedef NumDataC<VectorC,PixLabelT> NumVPLDataC;
typedef NumVDataSetC<PixLabelT> NumVPLDataSetC;
typedef Tuple3C<VectorC,RealT,PixelC> ImageIndexT;

#include "amma/visualdb/MeanShiftAlg.hh"
typedef NumDataC<VectorC,PixelC> NumVPixDataC;
typedef NumVDataSetC<PixelC> NumVPixDataSetC;

#include "amma/visualdb/NNetDb.hh"
typedef DListC<ImageRegionC> ImageRegSetC;
typedef RCHashARC<StringC,ImageIndexSetC> DatabaseH;

#include "amma/LabelImage.hh"
typedef LabelImageC<ByteGreyValueT> LabelByteImageC;

#include "fftw/fftw-int.h"
typedef double FFTW_TRIG_REAL;
typedef hrtime_t fftw_time;

#include "fftw/fftw.h"
typedef float fftw_real;
typedef anon_enum?46 fftw_direction;
typedef fftw_complex FFTW_COMPLEX;
typedef fftw_real FFTW_REAL;
typedef anon_enum?47 fftw_status;
typedef void * (*)(FuncArgList) fftw_malloc_type_function;
typedef void (*)(FuncArgList) fftw_free_type_function;
typedef void (*)(FuncArgList) fftw_die_type_function;
typedef fftwnd_data * fftwnd_plan;
Variables:

#include "amma/Boolean.hh"
const bool aFALSE = false;

The label of something that is not valid.

const bool aTRUE = true;
Boolean value
The class BooleanT has a long story of changes. At first, BooleanT was enumerated type what caused problems because some operations could produce value !=0, !=1 which also represented "true" and some operations on boolean values could produce the type 'int'. We also used typedef with 'int', later with 'bool'. A trouble with overloading of operators was detected (namely with operator|=). At the moment, BooleanT is a class with automatic conversion to/from the built-in type bool.

Anyway, the class BoolenT represents logical value.

#include "amma/Dir8RLUD.hh"
const IntT direction8Number = 9;
Direction Right-Left-Up-Down for 8-neighbohrhood

#include "amma/Random.hh"
const long int AMMA_RandomIntMax = 1000000000;

#include "amma/GNumInteg.hh"
const double SAFETY = 09;

a constant relating to step adjustment

#include "amma/RungeKutta.hh"
const RealT VerySmall = 10E-20;

-------------------------------------------------------------------------

#include "amma/Num/EstIntFunc.hh"
int imaxarg1;
int imaxarg2;
int iminarg1;
int iminarg2;
float sqrarg;

#include "amma/GradAssOpt.hh"
const int GradAssOptC_I1 = 30;

Loops over row-col normalization; Gold chooses 30!

const double GradAssOptC_epsC = 001;

Loops over row-col normalization; Gold chooses 0.05 ------------------------------------------------------------------------- -------------------------------------------------------------------------

#include "amma/GreyVal.hh"
const ByteGreyValueT MIN_GREY = 0;

min. grey value

const ByteGreyValueT MAX_GREY = 255;

max. --- // ---

const ByteGreyValueT BLACK = 0;

black color

const ByteGreyValueT WHITE = 255;

white color for byte images

const ByteGreyValueT WHITEb = 1;

white color for binary images

const GreyValueT GLEVELS = 256;

number of grey levels

const GreyValueT BACKGROUND = 0;

the label for background pixel

#include "amma/VTRing.hh"
const int MAXV = 4;
const int SORT_INTERVAL = 20;

SHOULD BE REMOVED !!!!!!!! -------------------------------------------------------------------------

#include "amma/sl_cast.hh"
const int max_sab = 2*(n_simplex_max+1)+1;
const int max_bez = 465;

for depth 5 bezier control points n=2, 3, 4, 5, 6, 7, 8, 9 -> 21, 56, 126, 252, 462, 792, 1287, 2002

#include "amma/Slime.hh"
const int maxtuple = max_sab;
const int max_table = 10;

inclusive 0..10. 0 ignored!

#include "amma/AMFigure.hh"
const int root_segment = 0;

-----------------------------------------------------------------------------

#include "amma/Logic2/Types.hh"
const BooleanT True = TRUE;
const BooleanT False = FALSE;
Methods:

#include "amma/Boolean.hh"
istream & operator>>(istream & s,BooleanC & v)

Reads the logical value 'v' from the intput stream 's'.

ostream & operator<<(ostream & s,const BooleanC & v)

Sends the logical value 'v' into the output stream 's'. ==================================================================== ======= Boolean ==================================================== ====================================================================

#include "amma/IntC.hh"
ostream & operator<<(ostream & out,const IntC & x)


istream & operator>>(istream & in,IntC & x)
Simple unsigned integer.
Its main feature is the default constructor sets its value to zero. Usefull in things like histograms.

ostream & operator<<(ostream & out,const UIntC & x)


istream & operator>>(istream & in,UIntC & x)


#include "amma/Empty.hh"
ostream & operator<<(ostream & out,const EmptyC &)


istream & operator>>(istream & in,EmptyC &)


#include "amma/Pair.hh"
ostream & operator<<(ostream & s,const PairC<DataC> & p)

Prints the pair 'p' into the stream 's'.

istream & operator>>(istream & s,PairC<DataC> & p)

Assigns the values into the pair 'p'. ======================================================================== ================= Templates ============================================ ========================================================================

#include "amma/Tuple3.hh"
ostream & operator<<(ostream & out,const Tuple3C<T1,T2,T3> & obj)


istream & operator>>(istream & in,Tuple3C<T1,T2,T3> & obj)

Binary stream operators.

BinOStreamC & operator<<(BinOStreamC & out,const Tuple3C<T1,T2,T3> & obj)


BinIStreamC & operator>>(BinIStreamC & in,Tuple3C<T1,T2,T3> & obj)


#include "amma/Tuple2.hh"
ostream & operator<<(ostream & out,const Tuple2C<T1,T2> & obj)


istream & operator>>(istream & in,Tuple2C<T1,T2> & obj)

Binary stream operators.

BinOStreamC & operator<<(BinOStreamC & out,const Tuple2C<T1,T2> & obj)

Binary stream operators.

BinIStreamC & operator>>(BinIStreamC & in,Tuple2C<T1,T2> & obj)


#include "amma/Tuple4.hh"
ostream & operator<<(ostream & out,const Tuple4C<T1,T2,T3,T4> & obj)


istream & operator>>(istream & in,Tuple4C<T1,T2,T3,T4> & obj)


BinOStreamC & operator<<(BinOStreamC & out,const Tuple4C<T1,T2,T3,T4> & obj)


BinIStreamC & operator>>(BinIStreamC & in,Tuple4C<T1,T2,T3,T4> & obj)


#include "amma/RCWrap.hh"
ostream & operator<<(ostream & out,const RCWrapBaseC & obj)
Input from stream.

istream & operator>>(istream & in,RCWrapBaseC & obj)
This is a wrapper template to take an unrefrence counted object and make it refrence counted.

ostream & operator<<(ostream & out,const RCWrapC<T> & obj)


istream & operator>>(istream & in,RCWrapC<T> & obj)

/////////////////////////////////////////////

#include "amma/Index.hh"
istream & operator>>(istream & s,IndexC & r)

Read information from the intput stream 's' and sets the index 'r' according obtained data.

ostream & operator<<(ostream & s,const IndexC & r)

Saves the index 'r' into the output stream 's'. Operations of integer numbers and indices -----------------------------------------

IntT operator+(const IntT i,const IndexC & j)

Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IntT operator-(const IntT i,const IndexC & j)

Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IntT operator*(const IntT i,const IndexC & j)

Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IntT operator/(const IntT i,const IndexC & j)

Returns the integer number constructed as division of integer number 'i' and index value 'j'.

const IntT & operator+=(IntT & i,const IndexC & j)

Adds index value 'j' to integer number 'i'.

const IntT & operator-=(IntT & i,const IndexC & j)

Subtracts index value 'j' from integer number 'i'.

const IntT & operator*=(IntT & i,const IndexC & j)

Multiplies index value 'j' by integer number 'i'.

const IntT & operator/=(IntT & i,const IndexC & j)

Divides index value 'j' by integer number 'i'.

BooleanT operator==(const IntT i,const IndexC & j)

Returns TRUE if the value of index 'j' is equal to the integer number 'i'.

BooleanT operator!=(const IntT i,const IndexC & j)

Returns TRUE if the values of index 'j' is not equal to the integer number 'i'.

BooleanT operator<(const IntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is smaller than the value of index 'j' .

BooleanT operator<=(const IntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is smaller than or equal to the value of index 'j' .

BooleanT operator>(const IntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is greater than the value of index 'j' .

BooleanT operator>=(const IntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is greater than or equal to the value of index 'j' . Operations of unsigned integer numbers and indices --------------------------------------------------

IntT operator+(const UIntT i,const IndexC & j)

Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IntT operator-(const UIntT i,const IndexC & j)

Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IntT operator*(const UIntT i,const IndexC & j)

Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IntT operator/(const UIntT i,const IndexC & j)

Returns the integer number constructed as division of integer number 'i' and index value 'j'.

const UIntT & operator+=(UIntT & i,const IndexC & j)

Adds index value 'j' to integer number 'i'.

const UIntT & operator-=(UIntT & i,const IndexC & j)

Subtracts index value 'j' from integer number 'i'.

const UIntT & operator*=(UIntT & i,const IndexC & j)

Multiplies index value 'j' by integer number 'i'.

const UIntT & operator/=(UIntT & i,const IndexC & j)

Divides index value 'j' by integer number 'i'.

BooleanT operator==(const UIntT i,const IndexC & j)

Returns TRUE if the value of index 'j' is equal to the integer number 'i'.

BooleanT operator!=(const UIntT i,const IndexC & j)

Returns TRUE if the values of index 'j' is not equal to the integer number 'i'.

BooleanT operator<(const UIntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is smaller than the value of index 'j' .

BooleanT operator<=(const UIntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is smaller than or equal to the value of index 'j' .

BooleanT operator>(const UIntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is greater than the value of index 'j' .

BooleanT operator>=(const UIntT i,const IndexC & j)

Returns TRUE if the integer number 'i' is greater than or equal to the value of index 'j' . Operations of byte (unsigned char) numbers and indices --------------------------------------------------

const ByteT & operator+=(ByteT & i,const IndexC & j)

Adds index value 'j' to byte number 'i'.

const ByteT & operator-=(ByteT & i,const IndexC & j)

Subtracts index value 'j' from byte number 'i'.

const ByteT & operator*=(ByteT & i,const IndexC & j)

Multiplies index value 'j' by byte number 'i'.

const ByteT & operator/=(ByteT & i,const IndexC & j)

Divides index value 'j' by byte number 'i'.

BooleanT operator==(const ByteT i,const IndexC & j)

Returns TRUE if the value of index 'j' is equal to the byte number 'i'.

BooleanT operator!=(const ByteT i,const IndexC & j)

Returns TRUE if the values of index 'j' is not equal to the byte number 'i'.

BooleanT operator<(const ByteT i,const IndexC & j)

Returns TRUE if the byte number 'i' is smaller than the value of index 'j' .

BooleanT operator<=(const ByteT i,const IndexC & j)

Returns TRUE if the byte number 'i' is smaller than or equal to the value of index 'j' .

BooleanT operator>(const ByteT i,const IndexC & j)

Returns TRUE if the byte number 'i' is greater than the value of index 'j' .

BooleanT operator>=(const ByteT i,const IndexC & j)

Returns TRUE if the byte number 'i' is greater than or equal to the value of index 'j' . Operations of double numbers and indices ----------------------------------------

DoubleT operator+(const DoubleT i,const IndexC & j)

Returns the double number constructed as addition of double number 'i' and index value 'j'.

DoubleT operator-(const DoubleT i,const IndexC & j)

Returns the double number constructed as subtraction of index value 'j' from double number 'i'.

DoubleT operator*(const DoubleT i,const IndexC & j)

Returns the double number constructed as multiplication of double number 'i' and index value 'j'.

DoubleT operator/(const DoubleT i,const IndexC & j)

Returns the double number constructed as division of double number 'i' and index value 'j'.

const DoubleT & operator+=(DoubleT & i,const IndexC & j)

Adds double number 'i' to index value 'j'.

const DoubleT & operator-=(DoubleT & i,const IndexC & j)

Subtracts index value 'j' from double number 'i'.

const DoubleT & operator*=(DoubleT & i,const IndexC & j)

Multiplies index value 'j' by double number 'i'.

const DoubleT & operator/=(DoubleT & i,const IndexC & j)

Divides index value 'j' by double number 'i'.

BooleanT operator==(const DoubleT i,const IndexC & j)

Returns TRUE if the value of index 'j' is equal to the double number 'i'.

BooleanT operator!=(const DoubleT i,const IndexC & j)

Returns TRUE if the values of index 'j' is not equal to the double number 'i'.

BooleanT operator<(const DoubleT i,const IndexC & j)

Returns TRUE if the double number 'i' is smaller than the value of index 'j' .

BooleanT operator<=(const DoubleT i,const IndexC & j)

Returns TRUE if the double number 'i' is smaller than or equal to the value of index 'j' .

BooleanT operator>(const DoubleT i,const IndexC & j)

Returns TRUE if the double number 'i' is greater than the value of index 'j' .

BooleanT operator>=(const DoubleT i,const IndexC & j)

Returns TRUE if the double number 'i' is greater than or equal to the value of index 'j' .

#include "amma/IndexR1d.hh"
BooleanT IsInside(IndexT i,const IndexRangeC & r)

Returns TRUE if the index 'i' is inside the index range 'r'.

istream & operator>>(istream & s,IndexRangeC & r)

Read information from the intput stream 's' and sets the index range according obtained data.

ostream & operator<<(ostream & s,const IndexRangeC & r)

Saves the index range 'r' into the output stream 's'. ==================================================================== ======= IndexRangeC ================================================ ====================================================================

#include "amma/BuffSize.hh"
istream & operator>>(istream & s,BufferSizeC & bs)

Sets buffer size 'bs' according to input stream 's'.

ostream & operator<<(ostream & s,const BufferSizeC & bs)

Saves buffer size 'bs' into output stream 's'. ///////////////////////////////////////////////////////////////////

#include "amma/BooSArr1.hh"
ostream & operator<<(ostream & s,const BoolSArray1dC & arr)

Prints array into the stream 's'.

istream & operator>>(istream & s,BoolSArray1dC & arr)

Assigns the values into the array 'arr'. ///////////////////////////////////////////////////

#include "amma/SArray1d.hh"
BinOStreamC & operator<<(BinOStreamC & s,const SArray1dC<DataC> & arr)

Prints array into the stream 's'.

BinIStreamC & operator>>(BinIStreamC & s,SArray1dC<DataC> & arr)

Assigns the values into the array 'arr'.

SArray1dC<DataC> & BubbleSort(SArray1dC<DataC> & arr)

Sorts arr using operator <.

istream & operator>>(istream & s,SArray1dC<DataC> & arr)

Assigns the values into the array 'arr'.

ostream & operator<<(ostream & s,const SArray1dC<DataC> & arr)


#include "amma/SDArray1d.hh"
ostream & operator<<(ostream & out,const SDArray1dC<T> & arr)


istream & operator>>(istream & in,SDArray1dC<T> & arr)

/////////////////////// Constructors.

#include "amma/SArray2d.hh"
ostream & operator<<(ostream & s,const SArray2dC<DataC> & arr)

Prints into the stream 's'

istream & operator>>(istream & s,SArray2dC<DataC> & arr)

Reads the array from the stream 's' ///////////////////////////////////////////////////

BinOStreamC & operator<<(BinOStreamC & s,const SArray2dC<DataC> & arr)


BinIStreamC & operator>>(BinIStreamC & s,SArray2dC<DataC> & arr)


#include "amma/SArray3d.hh"
ostream & operator<<(ostream & s,SArray3dC<DataC> & arr)


istream & operator>>(istream & s,SArray3dC<DataC> & arr)


BinOStreamC & operator<<(BinOStreamC & s,const SArray3dC<DataC> & arr)


BinIStreamC & operator>>(BinIStreamC & s,SArray3dC<DataC> & arr)


#include "amma/Index2d.hh"
ostream & operator<<(ostream & outS,const Index2dC & index)

Sends the index into the output stream.

istream & operator>>(istream & inS,Index2dC & index)

Reads the index values from the input stream. #include "amma/StdMath.hh" ==================================================================== ======= Index2dC =================================================== ====================================================================

#include "amma/Index3d.hh"
ostream & operator<<(ostream & outS,const Index3dC & index)

Sends the index into the output stream.

istream & operator>>(istream & inS,Index3dC & index)

Reads the index values from the input stream. ==================================================================== ======= Index3dC =================================================== ====================================================================

#include "amma/IndRect.hh"
ostream & operator<<(ostream & outS,const IndexRectangleC & rect)


istream & operator>>(istream & is,IndexRectangleC & rect)

read value of the rectangle from the input stream 'is' do statement for each index of the image rectangle ------------------------------------------------------------------- ******** IndexRectangleC ****************************************** -------------------------------------------------------------------

#include "amma/Array1d.hh"
ostream & operator<<(ostream & s,const Array1dC<DataC> & arr)

Prints array into the stream 's'.

istream & operator>>(istream & s,Array1dC<DataC> & arr)

Assigns the values into the array 'arr'.

Array1dC<DataC> & BubbleSort(Array1dC<DataC> & arr)

Sorts the array 'arr' using operator <. /////////////////////////////////////////////

BinOStreamC & operator<<(BinOStreamC & s,const Array1dC<DataC> & arr)


BinIStreamC & operator>>(BinIStreamC & s,Array1dC<DataC> & arr)


#include "amma/ArrStack.hh"
ostream & operator<<(ostream & s,const ArrayStackC<DataC> & stack)

print stack into the stream 's'

istream & operator>>(istream & s,ArrayStackC<DataC> & stack)
Array stack iterator.
Small object.

#include "amma/Array2d.hh"
ostream & operator<<(ostream & s,const Array2dC<DataC> & arr)

Prints into the stream 's'

istream & operator>>(istream & s,Array2dC<DataC> & arr)
Index looping.
NB. Its faster to use iterators. //////////////////////////////////////////////////////////////////////////////

BinOStreamC & operator<<(BinOStreamC & s,const Array2dC<DataC> & arr)


BinIStreamC & operator>>(BinIStreamC & s,Array2dC<DataC> & arr)

IAPS - Image analysis program system. End of include file Array2d.hh

#include "amma/Array3d.hh"
ostream & operator<<(ostream & s,const Array3dC<DataC> & arr)


istream & operator>>(istream & s,Array3dC<DataC> & arr)

IAPS - Image analysis program system. End of include file Array3d.hh

#include "amma/IntrDLst.hh"
ostream & operator<<(ostream & s,const IntrDListC<DataC> & list)

CmpT should define int Compair(const T &,const T &)

#include "amma/InCDLIte.hh"
ostream & operator<<(ostream & s,const IntrConstDLIterC<DataC> &)

---------------------------------------------------------------------- ************ IntrConstDLIterC **************************************** ----------------------------------------------------------------------

#include "amma/BoCDLIte.hh"
ostream & operator<<(ostream & s,const BodyConstDLIterC<DataC> & elm)

IAPS - Image analysis program system. End of include file BoCDLIte.hh

#include "amma/DList.hh"
istream & operator>>(istream & s,DListC<DataC> & list)
Reads the list items from the input stream and saves them to the end of the 'list'.
Input/output operation with a double linked list ------------------------------------------------

ostream & operator<<(ostream & s,const DListC<DataC> & list)
Saves the list into the output stream.

BinIStreamC & operator>>(BinIStreamC & s,DListC<DataC> & list)
Reads the list items from the input stream and saves them to the end of the 'list'.

BinOStreamC & operator<<(BinOStreamC & s,const DListC<DataC> & list)
Saves the list into the output stream.

#include "amma/CDLIter.hh"
ostream & operator<<(ostream & s,const ConstDLIterC<DataC> &)

#include "amma/StdCast.hh" ---------------------------------------------------------------------- ************ ConstDLIterC **************************************** ----------------------------------------------------------------------

#include "amma/Hash.hh"
ostream & operator<<(ostream & out,const HashC<K,T> & obj)


istream & operator>>(istream & out,HashC<K,T> & obj)

Default hash function.

UIntT StdHash(const K & dat)

Default hash function.

K StdCopy(const K & dat)


BooleanT HashIsEqual(const K & d1,const K & d2)

Misc //////////////////////

long double StdCopy(long double x)


double StdCopy(double x)


float StdCopy(float x)

///////////////

BooleanT HashIsEqual(const char * d1,const char * d2)


UIntT StdHash(const char * dat)


const char * StdCopy(const char * dat)

No point in copying a constant string. If otherwise you should use StringC intead. /////////////

UIntT StdHash(const short dat)


short StdCopy(short x)

/////////////

UIntT StdHash(const unsigned short dat)


unsigned short StdCopy(unsigned short x)

/////////////

UIntT StdHash(const int dat)


int StdCopy(int x)

/////////////

UIntT StdHash(const unsigned int dat)


unsigned int StdCopy(unsigned int x)

/////////////

UIntT StdHash(const long dat)


long StdCopy(long x)

/////////////

UIntT StdHash(const unsigned long dat)


#include "amma/HSetExtra.hh"
HSetC<DataT> DList2HSet(const DListC<DataT> & list)
Put every thing in a set into a list.

DListC<DataT> HSet2DList(const HSetC<DataT> & set)
Add a list of items to a set.

const HSetC<DataT> operator+=(HSetC<DataT> & set,const DListC<DataT> & list)
Remove a list of items from a set.

const HSetC<DataT> operator-=(HSetC<DataT> & set,const DListC<DataT> & list)
Add a set to a list .

const DListC<DataT> operator+=(DListC<DataT> & list,const HSetC<DataT> & set)
Add a set to a list .

#include "amma/HSet.hh"
ostream & operator<<(ostream & out,const HSetC<T> & obj)


istream & operator>>(istream & in,HSetC<T> & obj)


BinOStreamC & operator<<(BinOStreamC & out,const HSetC<T> & obj)


BinIStreamC & operator>>(BinIStreamC & in,HSetC<T> & obj)


#include "amma/HashAR.hh"
ostream & operator<<(ostream & out,const HashARC<K,T> & obj)

//////////////////////////////////////////////////

istream & operator>>(istream & in,HashARC<K,T> & obj)

//////////////////////////////////////////////////

BinOStreamC & operator<<(BinOStreamC & out,const HashARC<K,T> & oth)

//////////////////////////////////////////////////

BinIStreamC & operator>>(BinIStreamC & in,HashARC<K,T> & obj)


#include "amma/Graph.hh"
ostream & operator<<(ostream & s,const GraphC & g)

Saves the graph into the output stream. ------------------------------------------------------------------------- ********** GraphC ******************************************************* -------------------------------------------------------------------------

#include "amma/GraphT.hh"
ostream & operator<<(ostream & out,const GraphTC<NodeT,EdgeT> & g)
Read graph from a stream.

istream & operator>>(istream & in,GraphTC<NodeT,EdgeT> & g)
Read graph from a stream.

#include "amma/GrBestRoute.hh"
DListC<GraphEdgeIterC<NodeT,EdgeT>> GraphBestRoute(const GraphTC<NodeT,EdgeT> & graph,GraphNodeHC<NodeT,EdgeT> from,GraphNodeHC<NodeT,EdgeT> to,CostT & costOut,CostT (*)(FuncArgList) EvalT)
Find the shortest route between to nodes in a graph.

#include "amma/KwList.hh"
int k_compare(const void * p1,const void * p2)


#include "amma/StdType.hh"
RealT ValueOfRealT(const RealT x)
The class StdTypeC defines all standard types in AMMA library.
OBSOLETE!

It also solves problems with bugs in compilers (at least GNU C++ 2.7.0) or bad syntax rules in C++, who knows.


#include "amma/String.hh"
StrRepC * Scapitalize(const StrRepC *,StrRepC *)
A reference-counted string.
This class is hacked from the Gnu string class, which explains to some extent the dodgy documentation of this class. Also, Some useful operators do not appear because they are global functions (we will fix this one day). In particular:
  • use the "+" operator for concatenation of a StringC with another StringC, SubStringC, char, IndexC, IntT, LongIntT, RealT, .... Result is a string.
The libg++ info file for the String class contains the relevant information.

int compare(const StringC & x,const StringC & y)


int compare(const StringC & x,const SubStringC & y)


int compare(const StringC & x,const char * y)


int compare(const SubStringC & x,const StringC & y)


int compare(const SubStringC & x,const SubStringC & y)


int compare(const SubStringC & x,const char * y)


int fcompare(const StringC & x,const StringC & y)

ignore case

void cat(const StringC & x,const StringC & y,StringC & r)


void cat(const StringC & x,const SubStringC & y,StringC & r)


void cat(const StringC & x,const char * y,StringC & r)


void cat(const StringC & x,char y,StringC & r)


void cat(const SubStringC & x,const StringC & y,StringC & r)


void cat(const SubStringC & x,const SubStringC & y,StringC & r)


void cat(const SubStringC & x,const char * y,StringC & r)


void cat(const SubStringC & x,char y,StringC & r)


void cat(const char * x,const StringC & y,StringC & r)


void cat(const char * x,const SubStringC & y,StringC & r)


void cat(const char * x,const char * y,StringC & r)


void cat(const char * x,char y,StringC & r)


void cat(const StringC & a,const StringC & x,const StringC & y,StringC & r)


void cat(const StringC & a,const StringC & x,const SubStringC & y,StringC & r)


void cat(const StringC & a,const StringC & x,const char * y,StringC & r)


void cat(const StringC & a,const StringC & x,char y,StringC & r)


void cat(const StringC & a,const SubStringC & x,const StringC & y,StringC & r)


void cat(const StringC & a,const SubStringC & x,const SubStringC & y,StringC & r)


void cat(const StringC & a,const SubStringC & x,const char * y,StringC & r)


void cat(const StringC & a,const SubStringC & x,char y,StringC & r)


void cat(const StringC & a,const char * x,const StringC & y,StringC & r)


void cat(const StringC & a,const char * x,const SubStringC & y,StringC & r)


void cat(const StringC & a,const char * x,const char * y,StringC & r)


void cat(const StringC & a,const char * x,char y,StringC & r)


void cat(const char * a,const StringC & x,const StringC & y,StringC & r)


void cat(const char * a,const StringC & x,const SubStringC & y,StringC & r)


void cat(const char * a,const StringC & x,const char * y,StringC & r)


void cat(const char * a,const StringC & x,char y,StringC & r)


void cat(const char * a,const SubStringC & x,const StringC & y,StringC & r)


void cat(const char * a,const SubStringC & x,const SubStringC & y,StringC & r)


void cat(const char * a,const SubStringC & x,const char * y,StringC & r)


void cat(const char * a,const SubStringC & x,char y,StringC & r)


void cat(const char * a,const char * x,const StringC & y,StringC & r)


void cat(const char * a,const char * x,const SubStringC & y,StringC & r)


void cat(const char * a,const char * x,const char * y,StringC & r)


void cat(const char * a,const char * x,char y,StringC & r)

operator versions

StringC operator+(const StringC & x,const StringC & y)


StringC operator+(const StringC & x,const SubStringC & y)


StringC operator+(const StringC & x,const char * y)


StringC operator+(const StringC & x,char y)


StringC operator+(const SubStringC & x,const StringC & y)


StringC operator+(const SubStringC & x,const SubStringC & y)


StringC operator+(const SubStringC & x,const char * y)


StringC operator+(const SubStringC & x,char y)


StringC operator+(const char * x,const StringC & y)


StringC operator+(const char * x,const SubStringC & y)


StringC reverse(const StringC & x)


StringC upcase(const StringC & x)


StringC downcase(const StringC & x)


StringC capitalize(const StringC & x)


StringC operator+(const StringC & x,const IndexC & y)


StringC operator+(const StringC & x,const IntT & y)


StringC operator+(const StringC & x,const UIntT & y)


StringC operator+(const StringC & x,const LongIntT & y)


StringC operator+(const StringC & x,const ULongIntT & y)


StringC operator+(const StringC & x,const RealT & y)

prepend

ostream & operator<<(ostream & s,const StringC & x)

a zillion comparison operators

int operator==(const StringC & x,const StringC & y)


int operator!=(const StringC & x,const StringC & y)


int operator>(const StringC & x,const StringC & y)


int operator>=(const StringC & x,const StringC & y)


int operator<(const StringC & x,const StringC & y)


int operator<=(const StringC & x,const StringC & y)


int operator==(const StringC & x,const SubStringC & y)


int operator!=(const StringC & x,const SubStringC & y)


int operator>(const StringC & x,const SubStringC & y)


int operator>=(const StringC & x,const SubStringC & y)


int operator<(const StringC & x,const SubStringC & y)


int operator<=(const StringC & x,const SubStringC & y)


int operator==(const StringC & x,const char * t)


int operator!=(const StringC & x,const char * t)


int operator>(const StringC & x,const char * t)


int operator>=(const StringC & x,const char * t)


int operator<(const StringC & x,const char * t)


int operator<=(const StringC & x,const char * t)


int operator==(const SubStringC & x,const StringC & y)


int operator!=(const SubStringC & x,const StringC & y)


int operator>(const SubStringC & x,const StringC & y)


int operator>=(const SubStringC & x,const StringC & y)


int operator<(const SubStringC & x,const StringC & y)


int operator<=(const SubStringC & x,const StringC & y)


int operator==(const SubStringC & x,const SubStringC & y)


int operator!=(const SubStringC & x,const SubStringC & y)


int operator>(const SubStringC & x,const SubStringC & y)


int operator>=(const SubStringC & x,const SubStringC & y)


int operator<(const SubStringC & x,const SubStringC & y)


int operator<=(const SubStringC & x,const SubStringC & y)


int operator==(const SubStringC & x,const char * t)


int operator!=(const SubStringC & x,const char * t)


int operator>(const SubStringC & x,const char * t)


int operator>=(const SubStringC & x,const char * t)


int operator<(const SubStringC & x,const char * t)


int operator<=(const SubStringC & x,const char * t)

a helper needed by at, before, etc.

#include "amma/TextLine.hh"
void SkipLine(istream & sIn)


#include "amma/StrExt.hh"
int strcasecmp(char * s1,char * s2)
Legacy string case compair.

int strncasecmp(char * s1,char * s2,int n)
Legacy string case compair.

char * StrDup(const char * s)
Legacy string duplication
Duplicates a string into a new allocated memory. The memory is allocated by the function 'new'. IAPS - Image analysis program system. End of include file StrExt.hh

#include "amma/Complex.hh"
ostream & operator<<(ostream & outS,const ComplexC & x)


istream & operator>>(istream & inS,ComplexC & x)

====================================================================== =============== ComplexC ============================================= ======================================================================

ComplexC operator+(RealT a,const ComplexC & x)


ComplexC operator+(const ComplexC & x,RealT a)


ComplexC operator+(const ComplexC & a,const ComplexC & b)


ComplexC operator-(RealT a,const ComplexC & x)


ComplexC operator-(const ComplexC & x,RealT a)


ComplexC operator-(const ComplexC & a,const ComplexC & x)


ComplexC operator*(RealT a,const ComplexC & x)


ComplexC operator*(const ComplexC & x,RealT a)


ComplexC operator*(const ComplexC & a,const ComplexC & x)


ComplexC operator/(const ComplexC & x,RealT a)


ComplexC operator/(const ComplexC & a,const ComplexC & x)


ComplexC operator/(RealT a,const ComplexC & x)


ComplexC operator^(const ComplexC & x,RealT a)


RealT operator&&(const ComplexC & a,const ComplexC & x)


ComplexC Exp(const ComplexC & a)


ComplexC CExp(RealT a)


ComplexC Log(const ComplexC & a)

IAPS - Image analysis program system. End of include file Complex.hh

#include "amma/Dir8RLUD.hh"
ostream & operator<<(ostream & s,const Direction8RLUDC & dir)

Sends the direction into the output stream 's'. =================================================================== ================ Direction8RLUDC ================================== ===================================================================

#include "amma/Pixel.hh"
ostream & operator<<(ostream & outS,const PixelC & pxl)


istream & operator>>(istream & inS,PixelC & pxl)

-------------------------------------------------------------------- **************** PixelC ******************************************** --------------------------------------------------------------------

#include "amma/TimeCode.hh"
ostream & operator<<(ostream & s,const TimeCodeC & out)


istream & operator>>(istream & s,TimeCodeC & tc)


#include "amma/StdMath.hh"
BooleanT FloatEq(const RealT a,const RealT b)

Returns TRUE iff the value 'a' is equal to the value 'b' with float precision.

RealT Sign(const RealT a,const RealT b)

Returns the value 'a' with a sign of 'b'.

RealT Sign(const RealT a)

Returns the sign of the real number 'a'.

IntT Round(const RealT x)

Returns the value x rounded to the nearest integer.

IntT Floor(const RealT x)

Returns the greatest integral value less than or equal to 'x'.

RealT Abs(const RealT x)

Returns the absolute value of 'x'.

RealT Sqr(const RealT x)

Returns the square of 'x'.

RealT Sqrt(const RealT x)

Returns the square root of 'x'.

RealT Log(RealT r)

Returns log(r).

RealT Pow(const RealT x,const RealT y)

Returns 'x' raised to the power 'y'.

RealT Exp(RealT r)

Returns safe exp(r).

RealT Cbrt(RealT r)

Returns the cube root of 'x'.

RealT Sin(const RealT x)

Returns the sine of 'x'.

RealT ASin(const RealT x)

Returns the arc sine of 'x'.

RealT Cos(const RealT x)

Returns the cosine of 'x'.

RealT ACos(const RealT x)

Returns the arc cosine of 'x'.

RealT ATan(const RealT x)

Returns the arc tangent of 'x' in the range -pi/2 .. +pi/2.

RealT ATan2(const RealT y,const RealT x)

Returns the arc tangent of 'y/x' in the range -pi .. +pi.

RealT Sinh(const RealT x)

Returns the sine of 'x'.

RealT Cosh(const RealT x)

Returns the cosine of 'x'.

RealT Pythag(const RealT a,const RealT b)

Computes sqrt(sqr(a)+sqr(b)) without destructive overflow or underflow.

RealT Erf(const RealT x)

Returns the error function of x. Erf(x) = 2/sqrt(pi)*integral from 0 to x of exp(-t*t) dt.

RealT Erfc(const RealT x)

Returns 1.0 - Erf(x). (Use when x is large) Minimum and maximum functions ----------------------------- General macros. Do use proper function if it is possible.

DataT Min(DataT a,DataT b)

Returns the smaller value from 'a' and 'b'.

DataT Max(DataT a,DataT b)

Returns the bigger value from 'a' and 'b'. Logical operators -----------------

BooleanT IsPow2(const IntT i)

Returns TRUE if 'i' is a power of 2.

BooleanT IsInf(const RealT i)

Is infinit.

BooleanT IsPInf(const RealT i)

Is positive infinity

BooleanT IsNInf(const RealT i)

Is negative infinity

BooleanT IsNan(const RealT i)

Is Not A Number Add all new functions into the following namespace.

int isinf(double x)

Ansi flag switches prototypes off.

int isnan(double x)

but we need some way of testing so...

double erf(double x)

not in standard file

double erfc(double x)

not in standard file

double hypot(double a,double b)


#include "amma/Random.hh"
float RandomGauss(int & idum = randomIdum)

Returns a Gaussian distributed zero mean random number with variance 1.0. RandomGauss is based on Random1.

float Random1(int & idum = randomIdum)

Returns a uniform random number between 0 and 1.

long int RandomInt(int & idum = randomIdum)

Returns an integer between 0 and AMMA_RandomIntMax.

#include "amma/UsefulFn.hh"
RealT Radian(RealT angle)

conversion from degree into radian

RealT Degree(RealT angle)

conversion from radian into degree

RealT Step(RealT a)

step function return 1 if a>=0 otherwise 0

RealT RSqr(RealT r)

return r*r

IntT ILog2(IntT i)

"i" = 2 ^ "mex", "mex" = ?

RealT PowRI(RealT r,IntT n)

Returns r^n. useful function =============== GNU C++ 2.4.5 is crazy

void AMMA_Swap(T & t1,T & t2)

swap contents of t1 and t2

T AMMA_Max(const T t1,const T t2)

returns the greater item of t1 and t2

T AMMA_Min(const T t1,const T t2)

returns the less item of t1 and t2

IntT Maximum(IntT a,IntT b)

Returns the biggest number from 'a' and 'b'.

IntT Minimum(IntT a,IntT b)

Returns the smallest number from 'a' and'b'.

RealT Maximum(RealT a,RealT b)

Returns the biggest number from 'a' and 'b'.

RealT Minimum(RealT a,RealT b)

Returns the smallest number from 'a' and 'b'.

IntT Maximum(IntT a,IntT b,IntT c)

Returns the biggest number from 'a', 'b', and 'c'.

IntT Minimum(IntT a,IntT b,IntT c)

Returns the smallest number from 'a', 'b', and 'c'.

RealT Maximum(RealT a,RealT b,RealT c)

Returns the biggest number from 'a', 'b', and 'c'.

RealT Minimum(RealT a,RealT b,RealT c)

Returns the smallest number from 'a', 'b', and 'c'. ================================================================= *********** TEMPLATES implementation **************************** =================================================================

#include "amma/TypeName.hh"
const char * TypeName(const type_info & info)

This funtion will return a standard name for a class if one is known. The function will attempt to generate a standard name if one is not defined. If this cannot be done a warning is printed on standard error channel and the program will continue with the compiler generated name.

const char * TypeName(const char * name)

Same as above but uses the type_info.name() directly.

const char * RTypeName(const char * name)

Reverse lookup. Given the stanard name find the compiler specific one. (NOT IMPLEMENTED)

const type_info & RTypeInfo(const char * name)

Reverse lookup. Given the stanard name find the type info for that class.

void AddTypeName(const type_info & info,const char * newname)

Set the stanard name to be used for a particular type.

void AddTypeName(const char * sysname,const char * newname)
Register typename.
Class to make it easy to register typename. Use as global variables.

e.g. for class xyzC declare the following as global in a .cc file preferably with the definition of xyzC static TypeNameC typeNamexyzC(typeinfo(xyzC),"xyzC");


#include "amma/BinStream.hh"
short bswap_16(const short & buf)
Swap bytes of a 32 bit number.

int bswap_32(const int & buf)
Machine independant binary input stream.

#include "amma/BinStreamGrid.hh"
BinOStreamC & operator<<(BinOStreamC & out,IndexC ind)


BinIStreamC & operator>>(BinIStreamC & in,IndexC & ind)


BinOStreamC & operator<<(BinOStreamC & out,const Index2dC & ind)


BinIStreamC & operator>>(BinIStreamC & in,Index2dC & ind)


BinOStreamC & operator<<(BinOStreamC & out,const IndexRectangleC & rect)


BinIStreamC & operator>>(BinIStreamC & in,IndexRectangleC & rect)


#include "amma/BinIOPixel.hh"
BinOStreamC & operator<<(BinOStreamC & out,const PixelC & pix)


BinIStreamC & operator>>(BinIStreamC & in,PixelC & pix)


#include "amma/BinString.hh"
BinOStreamC & operator<<(BinOStreamC & out,const StringC & str)


BinOStreamC & operator<<(BinOStreamC & out,const SubStringC & str)


BinIStreamC & operator>>(BinIStreamC & in,StringC & str)


#include "amma/IntSArr1.hh"
ostream & operator<<(ostream & s,const IntSArray1dC & arr)

Prints array into the stream 's'.

istream & operator>>(istream & s,IntSArray1dC & arr)

Assigns the values into the array 'arr'.

#include "amma/ReSArr1.hh"
ostream & operator<<(ostream & s,const RealSArray1dC & arr)

Prints array into the stream 's'.

istream & operator>>(istream & s,RealSArray1dC & arr)

Assigns the values into the array 'arr'.

#include "amma/NArray1d.hh"
ostream & operator<<(ostream & s,const NumArray1dC<DataC> & arr)


istream & operator>>(istream & s,NumArray1dC<DataC> & arr)

================================================================== ======== NumArray1dC ============================================= ==================================================================

#include "amma/NArray2d.hh"
ostream & operator<<(ostream & s,const NumArray2dC<DataC> & arr)


istream & operator>>(istream & s,NumArray2dC<DataC> & arr)


#include "amma/IntArr1d.hh"
ostream & operator<<(ostream & s,const IntArray1dC & arr)


istream & operator>>(istream & s,IntArray1dC & arr)

Reads the integer array from the input stream and fill the array 'arr'. If the array 'arr' has a different size from the size of array stored in the input stream, the array 'arr' is reassigned.

#include "amma/ReArr1d.hh"
ostream & operator<<(ostream & s,const RealArray1dC & arr)


#include "amma/IntArr2d.hh"
ostream & operator<<(ostream & s,const IntArray2dC & arr)

////////////////////////////////////////////////////

#include "amma/ReArr2d.hh"
ostream & operator<<(ostream & s,const RealArray2dC & arr)


#include "amma/StrList.hh"
ostream & operator<<(ostream & s,const StringListC & list)

Saves the string list into the output stream 's'. ////////////////////////////////////////////////////////

#include "amma/PGgf.hh"
ostream & operator<<(ostream & s,const GfSetC & set)
The class GfSetsC represents a set of heterogenous geometric feature sets
GfSetsC is a list whose elements are of class GfSetC

ostream & operator<<(ostream & s,const GfSetsC & sets)

IAPS - Image analysis program system. End of include file PGgf.hh

#include "amma/Date.hh"
ostream & operator<<(ostream & out,const DateC & date)
Stream operator.

istream & operator>>(istream & in,DateC & date)
Stream operator.

BinOStreamC & operator<<(BinOStreamC & out,const DateC & date)
Stream operator.

BinIStreamC & operator>>(BinIStreamC & in,DateC & date)
Stream operator.
////////////////////////////////////////////////////////

#include "amma/UserInfo.hh"
ostream & operator<<(ostream & out,const UserInfoC & ui)


#include "amma/DP/Port.hh"
ostream & operator<<(ostream & s,const DPIPortC<DataT> & port)


ostream & operator<<(ostream & s,const DPOPortC<DataT> & port)


istream & operator>>(istream & s,DPOPortC<DataT> & port)
Input/Output port.

ostream & operator<<(ostream & s,const DPIOPortC<InT,OutT> & port)


istream & operator>>(istream & s,DPIOPortC<InT,OutT> & port)
Plug.
Used for setting up inputs.

void operator>>(DPIPortC<DataT> & source,DPPlugC<DataT> & input)
Use a plug

#include "amma/DP/ProcIOStream.hh"
BooleanT DPProcessStream(const DPIPortC<InT> & in,const DPProcessC<InT,OutT> & proc,const DPOPortC<OutT> & out)
Template function to save some typeing.
//////////////////////////////////////////////////

#include "amma/DP/ProcIStream.hh"
DPIPortC<OutT> operator>>(const DPIPortC<InT> & in,const DPProcessC<InT,OutT> & proc)
Composition operator.

DPIOPortC<OutT,InterT> operator>>(const DPIOPortC<InT,InterT> & in,const DPProcessC<InT,OutT> & proc)

////////////////////////////////////////////////////////

#include "amma/DP/ProcCompose.hh"
DPProcessC<InT,OutT> operator>>(const DPProcessC<InT,InterT> & np1,const DPProcessC<InterT,OutT> & np2)
Composition operator.
////////////////////////////////////////

#include "amma/DP/Compose.hh"
DPIOPortC<InT,OutT> operator>>(const DPIOPortC<InT,MidT> & in,DPIStreamOpC<MidT,OutT> dat)


#include "amma/DP/RunningAve.hh"
DPProcessC<NumTypeT,NumTypeT> DPRunningAverage(const NumTypeT & init,IntT len = 10)
Construct a running average.
//////////////////////////////////////////////////

#include "amma/DP/OffsetScale.hh"
DPProcessC<NumTypeT,NumTypeT> DPOffsetScale(const NumTypeT & off,const ScaleT & fact)

//////////////////////////////////////////////////

#include "amma/DP/Multiplex.hh"
DPIOPortC<InT,OutT> DPMultiplex(IntT num,const DPIOPortC<InT,OutT> & nproc)

/////////////////////////////

DPIOPortC<InT,OutT> DPMultiplex(const SArray1dC<DPIOPortC<InT,OutT>> & procs)

//////////////////////////////////

#include "amma/DP/Task.hh"
istream & operator>>(istream & in,DPTaskC & tsk)


ostream & operator<<(ostream & out,const DPTaskC & tsk)


#include "amma/DP/TaskThread.hh"
DPTaskThreadC<InT,OutT> DPTaskThread(const DPProcessC<InT,OutT> & nproc,IntT qsize = 5)
Shortcut for creating threads.
/////////////////////////////////////////

#include "amma/DP/IOConnect.hh"
DPIOConnectC<DataT> DPIOConnect(const DPIPortC<DataT> & from,const DPOPortC<DataT> & to)

///////////////////////////////////////

#include "amma/DP/TaskList.hh"
istream & operator>>(istream & in,DPTaskListC & tsk)


ostream & operator<<(ostream & out,const DPTaskListC & tsk)


#include "amma/DP/SplitO.hh"
DPOPortC<DataT> operator>>(DPSplitOC<DataT> & in,const DPOPortC<DataT> & out)

///////////////////// Composition.

DPOPortC<DataT> operator>>(DPOPortC<DataT> & out,DPSplitOC<DataT> & in)

/////////////////////////////////////////////////

#include "amma/DP/ListIO.hh"
DPOContainerC<ContainerT> DPOContainer(ContainerT & dat)
Write out stream to container, appending to contents.

DPOContainerC<ContainerT> DPOContainerOverwrite(ContainerT & dat)
Write out stream to container, overwriting existing contents.

DPIContainerC<ContainerT> DPIContainer(const ContainerT & dat)
Use container as source for stream.

DPOContainerC<DListC<DataT>> DPOList(DListC<DataT> & dat)
Use container as source for stream.

DPIContainerC<DListC<DataT>> DPIList(const DListC<DataT> & dat)

//////////////////////////////////////////////////////

#include "amma/DP/Multiply.hh"
DPIPortC<DataT> operator*(const DPIPortC<DataT> & in,const FactorT & fact)
Short cut for multipling a stream.
//////////////////////////////////////////////////

#include "amma/DP/StreamOp.hh"
DPIPortC<OutT> operator>>(const DPIPortC<InT> & in,DPIStreamOpC<InT,OutT> dat)


#include "amma/DP/Func2Stream.hh"
DPIPortC<OutT> operator>>(const DPIPortC<InT> & in,OutT (*)(FuncArgList) func)
Composition operators.

DPIOPortC<OutT,DataT> operator>>(const DPIOPortC<InT,DataT> & in,OutT (*)(FuncArgList) func)


DPOPortC<InT> operator>>(OutT (*)(FuncArgList) func,const DPOPortC<OutT> & in)


DPIOPortC<DataT,InT> operator>>(OutT (*)(FuncArgList) func,const DPIOPortC<DataT,OutT> & in)

Version with constant paramiter.

#include "amma/DP/IFailOver.hh"
DPIPortC<DataT> operator>>(const DPIPortC<DataT> & from,DPIFailOverC<DataT> & to)

//////////////////////////////////

#include "amma/DP/Tap.hh"
DPProcessC<DataT,DataT> DPTap(const DPOPortC<DataT> & aport)

//////////////////////////////////

#include "amma/DP/IOJoin.hh"
DPIOPortC<InT,OutT> DPIOPortJoin(const DPIPortC<InT> & in,const DPOPortC<OutT> & out,const DPEntityC & ahold = DPEntityC(TRUE))
Join function.

#include "amma/DP/FuncP2Proc.hh"
DPProcessC<InT,OutT> DPFunc2Proc(OutT (*)(FuncArgList) func)

Plain paramier versions.

DPProcessC<InT,OutT> operator>>(const DPProcessC<InT,InterT> & np1,OutT (*)(FuncArgList) func)


DPProcessC<InT,OutT> operator>>(InterT (*)(FuncArgList) func,const DPProcessC<InterT,OutT> & np1)

Constant refrence versions.

DPProcessC<InT,OutT> operator>>(InterT (*)(FuncArgList) func1,OutT (*)(FuncArgList) func2)

Problem: No paramiter is a class type! Solution: Use the DPFunc2Proc() on one of the func ptrs.

#include "amma/DP/DataConv.hh"
BooleanT DPCanConvert(const type_info & from,const type_info & to)
Test if conversion is possible.

RCAbstractC DPDoConvertion(const RCAbstractC & dat,const type_info & from,const type_info & to)
Do conversion through abstract handles.

BooleanT DPTypeConvert(const InT & inraw,OutT & outraw)
Do conversion through abstract handles.

BooleanT DPTypeConvert(const RCWrapBaseC & in,OutT & outraw)


#include "amma/DP/SplitI.hh"
DPIPortC<DataT> operator>>(const DPIPortC<DataT> & in,DPSplitIC<DataT> & out)
Composition

DPIPortC<OutT> operator>>(DPSplitIC<InT> & out,const DPProcessC<InT,OutT> & proc)

///////////////////////////////////////////

#include "amma/DP/Hold.hh"
DPHoldBodyC<DataT> DPHold(DataT & init)
Shortcut for creating threads.
/////////////////////////////////////////

#include "amma/DP/Signal1.hh"
ostream & operator<<(ostream & out,const Signal1C<DataT> &)
IO Operator.
Not implemented //////////////////////////

#include "amma/DP/Signal2.hh"
ostream & operator<<(ostream & out,const Signal2C<Data1T,Data2T> &)
IO Operator.
Not implemented //////////////////////////

#include "amma/DP/Signal3.hh"
ostream & operator<<(ostream & out,const Signal3C<Data1T,Data2T,Data3T> &)
IO Operator.
Not implemented //////////////////////////

#include "amma/DP/GeomIO.hh"
void InitDPGeomIO()
Initalise 2d geomerty

void InitGeom2dIO()
Initalise 3d geomerty

void InitGeom3dIO()
Initalise 4d geomerty

void InitGeom4dIO()
Initalise Nd geomerty

void InitGeomNdIO()
Initalise GF set IO.

void InitGFSetIO()


#include "amma/DP/Geom2dIO.hh"
BinOStreamC & operator<<(BinOStreamC & os,const Vector2dC & v2)


BinIStreamC & operator>>(BinIStreamC & is,Vector2dC & v2)


BinOStreamC & operator<<(BinOStreamC & os,const Point2dC & v2)


BinIStreamC & operator>>(BinIStreamC & is,Point2dC & v2)


BinOStreamC & operator<<(BinOStreamC & os,const Line2dPPC & v2)


BinIStreamC & operator>>(BinIStreamC & is,Line2dPPC & v2)


#include "amma/DP/Geom3dIO.hh"
BinOStreamC & operator<<(BinOStreamC & strm,const Vector3dC & v)


BinIStreamC & operator>>(BinIStreamC & strm,Vector3dC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const Point3dC & v)


BinIStreamC & operator>>(BinIStreamC & strm,Point3dC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const Line3dPPC & v)


BinIStreamC & operator>>(BinIStreamC & strm,Line3dPPC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const Matrix3d3C & v)


BinIStreamC & operator>>(BinIStreamC & strm,Matrix3d3C & v)


#include "amma/DP/Geom4dIO.hh"
BinOStreamC & operator<<(BinOStreamC & strm,const Vector4dC & v)


BinIStreamC & operator>>(BinIStreamC & strm,Vector4dC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const Point4dC & v)


BinIStreamC & operator>>(BinIStreamC & strm,Point4dC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const Matrix4d4C & v)


BinIStreamC & operator>>(BinIStreamC & strm,Matrix4d4C & v)


#include "amma/DP/GeomNdIO.hh"
BinOStreamC & operator<<(BinOStreamC & strm,const VectorC & v)


BinIStreamC & operator>>(BinIStreamC & strm,VectorC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const MatrixC & v)


BinIStreamC & operator>>(BinIStreamC & strm,MatrixC & v)


BinOStreamC & operator<<(BinOStreamC & strm,const SArray1dC<VectorC> & v)


BinIStreamC & operator>>(BinIStreamC & strm,SArray1dC<VectorC> & v)


#include "amma/DP/BinIOAnGeo.hh"
BinOStreamC & operator<<(BinOStreamC & strm,const PCLineC & data)


BinIStreamC & operator>>(BinIStreamC & strm,PCLineC & data)


BinOStreamC & operator<<(BinOStreamC & strm,const PCLineSegC & data)


BinIStreamC & operator>>(BinIStreamC & strm,PCLineSegC & data)


#include "amma/Timer.hh"
ostream & operator<<(ostream & s,TimerG<TIMEREP> & t)


ostream & operator<<(ostream & s,TimerG<RealTimeRepG> & t)


ostream & operator<<(ostream & s,TimerG<VirtTimeRepG> & t)
Basic timer stuff.
For timing events in seconds. ******* The use of this class is NOT recomended ******* WARNING: This code is unstable and its perfromance depends on the machine you run it on. It is also know to have problems with illegal instructions. These can be got around by adding ANSIFLAG= to the program using it.

ostream & operator<<(ostream & s,RealTimerG & t)

For timing events in seconds. ******* The use of this class is NOT recomended ******* WARNING: This code is unstable and its perfromance depends on the machine you run it on. It is also know to have problems with illegal instructions. These can be got around by adding ANSIFLAG= to the program using it. WARNING: This will NOT work in multithreaded programs.

#include "amma/DocEntry.hh"
ostream & operator<<(ostream & out,const DocPageC &)


istream & operator>>(istream & in,DocPageC &)


ostream & operator<<(ostream & out,const DocNodeC &)


istream & operator>>(istream & in,DocNodeC &)


#include "amma/DocEHT.hh"
StringC DocDate()


#include "amma/util/RCSFile.hh"
ostream & operator<<(ostream & out,const RCSFileC & file)


#include "amma/Vector.hh"
ostream & operator<<(ostream & s,const VectorC & vect)


istream & operator>>(istream & s,VectorC & vect)
Special vector with different matrix multiplication operator.
BIG Object. row vector

#include "amma/Matrix.hh"
ostream & operator<<(ostream & s,const MatrixC & mat)


istream & operator>>(istream & s,MatrixC & mat)
returns v.T() * v

MatrixC ProductT(const VectorC & v)

Returns the Mahalanobis distance for 'data' from the mean value 'meanInvCov.Vector()'using the inverse. covariance matrix 'meanInvCov.Matrix()

RealT MahalanobisDistance(const VectorC & data,const VecMatC & meanInvCov)

Returns the Mahalanobis distance for 'data' from the mean value 'meanRed' in the reduced space. 'data' are transformed into the reduced space using transformation matrix 'redTr'. Inverse covariance matrix in the reduced space is supposed to be diagonal containing square roots of eigenvalues

RealT MahalanobisDistance(const VectorC & data,const MatrixC & redTr,const VectorC & meanRed,const VectorC & invCovRed)

Returns the Mahalanobis distance for 'data' from the mean value 'subMean' in the subspace. 'data' are transformed into the reduced space using transformation matrix 'projection'. Inverse covariance matrix in the subspace is supposed to be unit.

RealT MahalanobisDistance(const VectorC & data,const MatrixC & projection,const VectorC & subMean)

returns the Mahalanobis distance for 'data' from the mean value 'meanRed' in the reduced space. 'data' are transformed into the reduced space using transformation matrix 'redTr'. Inverse covariance matrix in the reduced space is supposed to be diagonal containing square roots of eigenvalues The vector 'redData' is used during computation and therefore it needs not to be allocated inside

RealT MahalanobisDistance(const VectorC & data,const MatrixC & redTr,const VectorC & meanRed,const VectorC & invCovRed,VectorC & redData)

-------------------------------------------------------------------- **************** MatrixC ******************************************* --------------------------------------------------------------------

#include "amma/VecMat.hh"
ostream & operator<<(ostream & s,const VecMatC & vm)
Writes the object 'vm' into the output stream.

istream & operator>>(istream & s,VecMatC & vm)
Sets the object 'vm' according to the object saved in the input stream.
-------------------------------------------------------------------- **************** VecMatC ******************************************* --------------------------------------------------------------------

#include "amma/EigenVal.hh"
VecMatC QLImplicit(TridiagonalMatrixC & tridi,MatrixC & trasformation)

-------------------------------------------------------------- QL algorithm with implicit shifts, to determine the eigenvalue and eigenvectors of a real, symmetric, tridiagonal matrix. Input tridiagonal matrix is destroyed. If the eigenvectors of a tridiagonal matrix are desired, the matrix 'transformation' is input as the identity matrix. If the matrix 'tridi' is the result of the orthogonal transformation 'transformation' of a symmetric matrix, then the k-th column of the return matrix contains the normalized eigenvector of the original symmetric matrix. ===================================================================== ========== a symmetric matrix ======================================= =====================================================================

VecMatC EigenSystemJacobi(MatrixC & a,RealT isSmall = 1e-8)

----------------------------- Computes all eigenvalues and eigenvectors of a real symmetric matrix 'a'. On output, elements of 'a' above the diagonal are destroyed. The returned structure contains the vector of the eigenvalues and the matrix which columns contain the normalized eigenvectors. The used method is a sequence of similarity Jacobi transformation. For matrices of order than about 10, say, the algorithm is slower, by significant const factor, than the QR method (see 'EigenSystemHouseholderQL(MatrixC & a)' function)

TridiagonalMatrixC HouseholderReduction(MatrixC & a)

-------------------------------- Householder reduction of a real, symmetric, matrix 'a'. On output 'a' is replaced by the orthogonal matrix Q effecting the transformation. subdiagonal[0] = 0;

VecMatC EigenSystemHouseholderQL(MatrixC & a)

----------------------------------- Computes all eigenvalue and eigenvectors of a real symmetric matrix 'a'. On output, elements of 'a' above the diagonal are destroyed. The returned structure contains the vector of the eigenvalues and the matrix which columns contain the normalized eigenvectors. The used method is a Householder reduction into a tridiagonal matrix, which eigenvalues can be computed by QL algorithm. IAPS - Image analysis program system End of include file EigenVal.hh

#include "amma/Affine.hh"
ostream & operator<<(ostream & outS,const AffineC<MatrixT,VectorT> & vector)


istream & operator>>(istream & inS,AffineC<MatrixT,VectorT> & vector)

///////////////////////////////////////////////

#include "amma/LinearS1.hh"
ostream & operator<<(ostream & outS,const LinearSums1dC & sums)

Prints sums into the output stream

istream & operator>>(istream & inS,LinearSums1dC & sums)

Reads sums structure from the input stream ----------------------------------------------------------------- ******** LinearSums1dC ****************************************** -----------------------------------------------------------------

#include "amma/Point2d.hh"
Point2dC operator*(RealT lambda,const Point2dC & p)

Returns the point which is the 'lambda' multiplication of 'p'.

Point2dC operator/(RealT alpha,const Point2dC & point)

Returns the points which coordinates are equal 'alpha' divided by 'point' coordinates.

Point2dC Centroid(const Moments01d2C & mom)

Gets the centroid computed from the momets 'mom'.

Point2dC Centroid(const Moments012d2C & mom)

Gets the centroid computed from the momets 'mom'.

RealT MahalanobisDistance(const Point2dC & data,const Point2dC & mean,const Matrix2d2C & invCov)

Returns the Mahalanobis distance for 'data' from the 'mean'.

ostream & operator<<(ostream & outS,const Point2dC & point)

Writes the 'point' into the output stream.

istream & operator>>(istream & inS,Point2dC & point)

Reads the point parameters from the input stream. ------------------------------------------------------------------- ******** Point2dC ************************************************* -------------------------------------------------------------------

#include "amma/Vector2d.hh"
Vector2dC operator*(RealT alpha,const Vector2dC & v)


ostream & operator<<(ostream & outS,const Vector2dC & vector)


istream & operator>>(istream & inS,Vector2dC & vector)


#include "amma/Line2dPP.hh"
ostream & operator<<(ostream & outS,const Line2dPPC & line)

Send the 'line' to the output stream 'outS'.

istream & operator>>(istream & inS,Line2dPPC & line)

Receive the 'line' from the input stream 'inS'. IAPS - Image analysis program system. End of include file Line2dPP.hh

#include "amma/Line2ABC.hh"
ostream & operator<<(ostream & outS,const LineABC2dC & line)


istream & operator>>(istream & inS,LineABC2dC & line)

----------------------------------------------------------------- ******** LineABC2dC ******************************************* -----------------------------------------------------------------

#include "amma/Matrix2d.hh"
Matrix2d2C DirInvCovariance(const Point2dC & point,const Point2dC & center,const Point2dC & boundaryPoint,RealT sigma1,RealT sigma2)


Matrix2d2C ToMatrix2d2(const MatrixC & matrix)


ostream & operator<<(ostream & outS,const Matrix2d2C & m)

Sends the matrix 'm' to the output stream 'outS'.

istream & operator>>(istream & inS,Matrix2d2C & m)

Reads and sets the elements of the matrix 'm' from the input stream 'inS'.

#include "amma/VecMat2d.hh"
ostream & operator<<(ostream & os,const VecMat2dC & vm)

send into the output stream

istream & operator>>(istream & is,VecMat2dC & vm)

read form the input stream ----------------------------------------------------------------- ******** VecMat2dC ********************************************** -----------------------------------------------------------------

#include "amma/LinearS2.hh"
ostream & operator<<(ostream & outS,const LinearSums2dC & sums)

Prints sums into the output stream.

istream & operator>>(istream & inS,LinearSums2dC & sums)

Reads sums structure from the input stream. ----------------------------------------------------------------- ******** PlaneABCD3dC ******************************************* -----------------------------------------------------------------

#include "amma/EigVal2.hh"
VecMat2dC EigenSystemJacobi(Matrix2d2C & a)

-------------------------------- Computes all eigenvalues and eigenvectors of a real symmetric matrix 'a'. On output, elements of 'a' above the diagonal are destroyed. The returned structure contains the vector of the eigenvalues and the matrix which columns contain the normalized eigenvectors. The used method is a sequence of similarity Jacobi transformation. IAPS - Image analysis program system End of include file EigVal2.hh

#include "amma/PCLine.hh"
ostream & operator<<(ostream & outS,const PCLineC & index)

Sends the PCLineC into the output stream. //////////////////////////////////

#include "amma/PCLineSeg.hh"
ostream & operator<<(ostream & strm,const PCLineSegC & dat)
Stream output.

istream & operator>>(istream & strm,PCLineSegC & dat)
Stream input.
//////////////////////////////////////////////

#include "amma/PCurve2d.hh"
ostream & operator<<(ostream & outS,const PCurve2dC & cv)
2d Parametric Curve Body Template

#include "amma/PRect2d.hh"
ostream & operator<<(ostream & strm,const PRectangle2dC & rect)


istream & operator>>(istream & strm,PRectangle2dC & rect)


#include "amma/Point3d.hh"
Point3dC operator*(RealT alpha,const Point3dC & point)

Returns the points which coordinates are 'point' coordinates multiplied by 'alpha'.

Point3dC operator/(RealT alpha,const Point3dC & point)

Returns the points which coordinates are equal 'alpha' divided by 'point' coordinates.

ostream & operator<<(ostream & outS,const Point3dC & point)

Saves the 'point' into the output stream.

istream & operator>>(istream & inS,Point3dC & point)

Set the coordinates of the 'point' according to the information stored in the input stream. ----------------------------------------------------------------- ******** Point3dC *********************************************** -----------------------------------------------------------------

#include "amma/Vector3d.hh"
Vector3dC operator*(RealT alpha,const Vector3dC & v)

Returns the vector which coordinates are the parameter 'alpha' multiplied by the related coordinate of the vector 'v'.

Vector3dC operator/(RealT alpha,const Vector3dC & v)

Returns the vector which coordinates are the parameter 'alpha' divided by the related coordinate of the vector 'v'.

Vector3dC & ProjectToPlane111(Vector3dC & vector)

DO NOT USE.

ostream & operator<<(ostream & outS,const Vector3dC & vector)


istream & operator>>(istream & inS,Vector3dC & vector)

----------------------------------------------------------------- ******** Vector3dC ********************************************** -----------------------------------------------------------------

#include "amma/Line3dPP.hh"
Line3dPPC::DistanceT Distance(const Point3dC & point,const Line3dPPC & line)

DO NOT USE.

ostream & operator<<(ostream & outS,const Line3dPPC & line)


istream & operator>>(istream & inS,Line3dPPC & line)

//////////////////////////////////////////////////////////

#include "amma/Plan3PVV.hh"
ostream & operator<<(ostream & outS,const PlanePVV3dC & plane)


istream & operator>>(istream & inS,PlanePVV3dC & plane)


#include "amma/Plan3abc.hh"
ostream & operator<<(ostream & outS,const PlaneABCD3dC & plane)


istream & operator>>(istream & inS,PlaneABCD3dC & plane)

----------------------------------------------------------------- ******** PlaneABCD3dC ******************************************* -----------------------------------------------------------------

#include "amma/Line3dPV.hh"
ostream & operator<<(ostream & outS,const Line3dPVC & line)

Saves the 'line' into the output stream.

istream & operator>>(istream & inS,Line3dPVC & line)

Sets the 'line' according to data read from the input stream.

#include "amma/Matrix3d.hh"
ostream & operator<<(ostream & outS,const Matrix3d3C & m)

Saves the matrix 'm' into the output stream 'outS'.

istream & operator>>(istream & inS,Matrix3d3C & matrix)

Sets the matrix 'm' elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** Matrix3dC ********************************************** -----------------------------------------------------------------

#include "amma/EigVal3.hh"
VecMat3dC EigenSystemJacobi(Matrix3d3C & a)

-------------------------------- Computes all eigenvalues and eigenvectors of a real symmetric matrix 'a'. On output, elements of 'a' above the diagonal are destroyed. The returned structure contains the vector of the eigenvalues and the matrix which columns contain the normalized eigenvectors. The used method is a sequence of similarity Jacobi transformation. IAPS - Image analysis program system End of include file EigVal3.hh

#include "amma/VecMat3d.hh"
istream & operator>>(istream & is,VecMat3dC & vm)


ostream & operator<<(ostream & os,const VecMat3dC & vm)


#include "amma/Point4d.hh"
Point4dC operator*(RealT alpha,const Point4dC & point)

Returns the points which coordinates are 'point' coordinates multiplied by 'alpha'.

Point4dC operator/(RealT alpha,const Point4dC & point)

Returns the points which coordinates are equal 'alpha' divided by 'point' coordinates.

ostream & operator<<(ostream & outS,const Point4dC & point)

Saves the 'point' into the output stream.

istream & operator>>(istream & inS,Point4dC & point)

Set the coordinates of the 'point' according to the information stored in the input stream. ----------------------------------------------------------------- ******** Point4dC *********************************************** -----------------------------------------------------------------

#include "amma/Vector4d.hh"
Vector4dC operator*(RealT alpha,const Vector4dC & point)

Returns the points which coordinates are 'point' coordinates multiplied by 'alpha'.

Vector4dC operator/(RealT alpha,const Vector4dC & point)

Returns the points which coordinates are equal 'alpha' divided by 'point' coordinates.

ostream & operator<<(ostream & outS,const Vector4dC & point)

Saves the 'point' into the output stream.

istream & operator>>(istream & inS,Vector4dC & point)

Set the coordinates of the 'point' according to the information stored in the input stream.

#include "amma/Matrix4d.hh"
ostream & operator<<(ostream & outS,const Matrix4d4C & m)

Saves the matrix 'm' into the output stream 'outS'.

istream & operator>>(istream & inS,Matrix4d4C & matrix)

Sets the matrix 'm' elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** Matrix4d4C ********************************************* -----------------------------------------------------------------

#include "amma/Polynomi.hh"
ostream & operator<<(ostream & s,const PolynomialC & pol)


istream & operator>>(istream & s,PolynomialC & pol)

IAPS - Image analysis program system. End of include file Polynomial.hh

#include "amma/XYZPolyn.hh"
ostream & operator<<(ostream & s,XYZPolynomialC & pol)


istream & operator>>(istream & s,XYZPolynomialC & pol)

IAPS - Image analysis program system. End of include file XYZPolyn.hh

#include "amma/PtToInd2.hh"
ostream & operator<<(ostream & outS,const PointToIndex2dC & tr)

Sends the transformation into the output stream.

istream & operator>>(istream & inS,PointToIndex2dC & tr)

Reads a transformation from the input stream.

#include "amma/PtToInd3.hh"
ostream & operator<<(ostream & outS,const PointToIndex3dC & tr)

Sends the transformation into the output stream.

istream & operator>>(istream & inS,PointToIndex3dC & tr)

Reads a transformation from the input stream.

#include "amma/OProj2a3.hh"
ostream & operator<<(ostream & s,const OrthoProjection3to2dC & p)

Sends the orthogonal projection mapping 'p' into the output stream 's'. ------------------------------------------------------------------------- ********** OrthoProjection3to2dC **************************************** -------------------------------------------------------------------------

#include "amma/PProj1d.hh"
ostream & operator<<(ostream & outS,const PProjection1dC & p)

Saves the projection 'p' into the output stream 'outS'.

istream & operator>>(istream & inS,PProjection1dC & p)

Sets the projective transformation elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** PProjection1dC ***************************************** -----------------------------------------------------------------

#include "amma/PPoint1d.hh"
PPoint1dC operator*(RealT lambda,const PPoint1dC & p)

Returns the point which is the 'lambda' multiplication of 'p'.

PPoint1dC operator/(RealT lambda,const PPoint1dC & p)

Returns the point which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPoint1dC & point)

Writes the 'point' into the output stream.

istream & operator>>(istream & inS,PPoint1dC & point)

Reads the point parameters from the input stream.

#include "amma/PPtLi2d.hh"
PPointLine2dC operator*(RealT lambda,const PPointLine2dC & p)

Returns the point/line which is the 'lambda' multiplication of 'p'.

PPointLine2dC operator/(RealT lambda,const PPointLine2dC & p)

Returns the point/line which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPointLine2dC & p)

Writes the point/line 'p' into the output stream.

istream & operator>>(istream & inS,PPointLine2dC & p)

Reads the point/line parameters from the input stream. ------------------------------------------------------------------- ******** PPointLine2dC ******************************************* -------------------------------------------------------------------

#include "amma/PPoint2d.hh"
PPoint2dC operator*(RealT lambda,const PPoint2dC & p)

Returns the point which is the 'lambda' multiplication of 'p'.

PPoint2dC operator/(RealT lambda,const PPoint2dC & p)

Returns the point which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPoint2dC & point)

Writes the 'point' into the output stream.

istream & operator>>(istream & inS,PPoint2dC & point)

Reads the point parameters from the input stream. ------------------------------------------------------------------- ******** PPoint2dC ************************************************ -------------------------------------------------------------------

#include "amma/PProj2d.hh"
ostream & operator<<(ostream & outS,const PProjection2dC & p)

Saves the projection 'p' into the output stream 'outS'.

istream & operator>>(istream & inS,PProjection2dC & p)

Sets the projective transformation elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** PProjection2dC ***************************************** -----------------------------------------------------------------

#include "amma/PLine2d.hh"
PLine2dC operator*(RealT lambda,const PLine2dC & l)

Returns the line which is the 'lambda' multiplication of 'l'.

PLine2dC operator/(RealT lambda,const PLine2dC & p)

Returns the line which coordinates are the 'lambda' divided by the corresponding coordinate of 'l'.

ostream & operator<<(ostream & outS,const PLine2dC & l)

Writes the projective line 'l' into the output stream.

istream & operator>>(istream & inS,PLine2dC & l)

Reads the projective line parameters from the input stream. ------------------------------------------------------------------- ******** PLine2dC ************************************************ -------------------------------------------------------------------

#include "amma/PPersp2d.hh"
ostream & operator<<(ostream & outS,const PPerspectivity2dC & p)

Saves the projection 'p' into the output stream 'outS'.

istream & operator>>(istream & inS,PPerspectivity2dC & p)

Sets the projective transformation elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** PPerspectivity2dC ************************************** -----------------------------------------------------------------

#include "amma/PPtPl3d.hh"
PPointPlane3dC operator*(RealT lambda,const PPointPlane3dC & p)

Returns the point/plane which is the 'lambda' multiplication of 'p'.

PPointPlane3dC operator/(RealT lambda,const PPointPlane3dC & p)

Returns the point/plane which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPointPlane3dC & p)

Writes the point/plane 'p' into the output stream.

istream & operator>>(istream & inS,PPointPlane3dC & p)

Reads the point/plane parameters from the input stream. ------------------------------------------------------------------- ******** PPointPlane3dC ******************************************* -------------------------------------------------------------------

#include "amma/PPoint3d.hh"
PPoint3dC operator*(RealT lambda,const PPoint3dC & p)

Returns the point which is the 'lambda' multiplication of 'p'.

PPoint3dC operator/(RealT lambda,const PPoint3dC & p)

Returns the point which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPoint3dC & point)

Writes the 'point' into the output stream.

istream & operator>>(istream & inS,PPoint3dC & point)

Reads the point parameters from the input stream. ------------------------------------------------------------------- ******** PPoint3dC ************************************************ -------------------------------------------------------------------

#include "amma/PProj3d.hh"
ostream & operator<<(ostream & outS,const PProjection3dC & p)

Saves the projection 'p' into the output stream 'outS'.

istream & operator>>(istream & inS,PProjection3dC & p)

Sets the projective transformation elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** PProjection3dC ***************************************** -----------------------------------------------------------------

#include "amma/PPersp3d.hh"
ostream & operator<<(ostream & outS,const PPerspectivity3dC & p)

Saves the projection 'p' into the output stream 'outS'.

istream & operator>>(istream & inS,PPerspectivity3dC & p)

Sets the projective transformation elements according to the values read from input stream 'inS'. ----------------------------------------------------------------- ******** PPerspectivity3dC ************************************** -----------------------------------------------------------------

#include "amma/PPlane3d.hh"
PPlane3dC operator*(RealT lambda,const PPlane3dC & p)

Returns the point which is the 'lambda' multiplication of 'p'.

PPlane3dC operator/(RealT lambda,const PPlane3dC & p)

Returns the point which coordinates are the 'lambda' divided by the corresponding coordinate of 'p'.

ostream & operator<<(ostream & outS,const PPlane3dC & point)

Writes the 'point' into the output stream.

istream & operator>>(istream & inS,PPlane3dC & point)

Reads the point parameters from the input stream. ------------------------------------------------------------------- ******** PPlane3dC ************************************************ -------------------------------------------------------------------

#include "amma/Mean2d.hh"
ostream & operator<<(ostream & s,const Mean2dC & mean)


istream & operator>>(istream & s,Mean2dC & mean)


#include "amma/Mean3d.hh"
ostream & operator<<(ostream & s,const Mean3dC & mean)


istream & operator>>(istream & s,Mean3dC & mean)


#include "amma/Covar3d.hh"
ostream & operator<<(ostream & outS,const Covariance3dC & cov)


istream & operator>>(istream & inS,Covariance3dC & cov)

End of include file Covariance3d.hh

#include "amma/MeanNd.hh"
ostream & operator<<(ostream & s,const MeanNdC & mean)

Saves the statistical description of the set 'mean' into the output stream 'outS'.

istream & operator>>(istream & s,MeanNdC & mean)

Reads and sets the statistical description of the set 'mean' according to the information in the input stream 'inS'.

#include "amma/MeanCo2d.hh"
ostream & operator<<(ostream & outS,const MeanCovariance2dC & meanCov)


istream & operator>>(istream & inS,MeanCovariance2dC & meanCov)

End of include file MeanCo2d.hh

#include "amma/MeanCo3d.hh"
ostream & operator<<(ostream & outS,const MeanCovariance3dC & meanCov)


istream & operator>>(istream & inS,MeanCovariance3dC & meanCov)

End of include file MeanCo3d.hh

#include "amma/ExMeCo3d.hh"
ostream & operator<<(ostream & outS,const MinMaxMeanCovariance3dC & meanCov)

Sends the set of points into the output stream.

istream & operator>>(istream & inS,MinMaxMeanCovariance3dC & meanCov)

Read the description of the set of points from the input stream. End of include file ExMeCo3d.hh

#include "amma/MeanCoNd.hh"
ostream & operator<<(ostream & outS,const MeanCovarianceNdC & meanCov)

Saves the statistical description of the set 'meanCov' into the output stream 'outS'.

istream & operator>>(istream & inS,MeanCovarianceNdC & meanCov)

Reads and sets the statistical description of the set 'meanCov' according to the information in the input stream 'inS'. End of include file MeanCoNd.hh

#include "amma/NormalD2.hh"
RealT NormalD(const RealT x,const RealT y,const RealT meanX,const RealT meanY,const RealT sigmaX,const RealT sigmaY)

get the value of the joint density of the 2D normal distribution N(meanX, meanY; sigmaX, sigmaY; r) in the point (x,y) where correlation coeffiecient r = 0;

RealT NormalD(const Point2dC & pnt,const Point2dC & mean,const Matrix2d2C & invCovariance)

get the value of the joint density of the 2D normal distribution N(meanX, meanY; sigmaX, sigmaY; r) in the point pnt = (x,y) where meanX, meanY are determind by mean and sigmaX, sigmaY, and correlation coefficient are defined by the inversion 'invCovariance' of the covariance matrix =================================================================== ======== NormalDistribution2dC ==================================== ===================================================================

#include "amma/SumNXX23.hh"
istream & operator>>(istream & is,SumNXX2d3C & sums)


ostream & operator<<(ostream & os,const SumNXX2d3C & sums)

IAPS - Image analysis program system End of include file SumNXX23.hh

#include "amma/SumNXX22.hh"
istream & operator>>(istream & is,SumNXX2d2C & sums)


ostream & operator<<(ostream & os,const SumNXX2d2C & sums)

IAPS - Image analysis program system End of include file SumNXX22.hh

#include "amma/LiPoint2.hh"
istream & operator>>(istream & s,Point2dListC & points)

Reads the list of data from the input stream

ostream & operator<<(ostream & s,const Point2dListC & points)

Sends the list of data into the output stream

#include "amma/Edge.hh"
ostream & operator<<(ostream & s,const EdgeC & e)

Writes the elementary edge 'e' into the output stream 's'. IAPS - Image analysis program system. End of include file Edge.hh

#include "amma/Boundary.hh"
ostream & operator<<(ostream & s,const BoundaryC & b)

Prints the whole boundary into the output stream 's'.

BoundaryC Line2Boundary(const BVertexC & startVertex,const BVertexC & endVertex)

Creates a boundary which connects both boundary vertexes.

void SaveAsGF(ostream & s,const DListC<BoundaryC> & boundaries,LongIntT minArea)

Save all boundaries which inside area is bigger than 'minArea' into the stream 's'.

void SaveCompressed(ostream & s,const DListC<BoundaryC> & boundaries,LongIntT minArea)

Save all boundaries which inside area is bigger than 'minArea' into the stream 's'. IAPS - Image analysis program system. End of include file Boundary.hh

#include "amma/GMLineGf.hh"
ostream & operator<<(ostream & outS,const GMLineGfC & line)


istream & operator>>(istream & inS,GMLineGfC & line)


#include "amma/IRectTP.hh"
ostream & operator<<(ostream & s,const IntRectangleTPC & rect)

Sends the rectangle 'rect' into the output stream 's'. ==================================================================== ======= IntRectangleTPC ============================================ ====================================================================

#include "amma/IPolyg2.hh"
istream & operator>>(istream & s,IntPolygon2dC & pol)

Reads a polygon from the input stream.

ostream & operator<<(ostream & s,const IntPolygon2dC & pol)

Sends the polygon into the output stream.

void SaveAsGF(ostream & s,const DListC<IntPolygon2dC> & pols,IntPolygon2dC::AreaT minArea = 0)

Save all polygons which inside area is bigger than 'minArea' into the stream 's'. ==================================================================== ======= IntPolygon2dC ============================================== ====================================================================

#include "amma/Polygon2.hh"
istream & operator>>(istream & s,Polygon2dC & pol)

Reads a polygon from the input stream.

ostream & operator<<(ostream & s,const Polygon2dC & pol)

Sends the polygon into the output stream.

DListC<Polygon2dC> Polygons2d(const GfSetC & s)

Creates the list of polygons in 2D space from the GF set 's'. ==================================================================== ======= Polygon2dC ================================================ ====================================================================

#include "amma/SubPol2d.hh"
ostream & operator<<(ostream & s,const SubPolygon2dC & pol)

Sends the subpolygon into the output stream. IAPS - Image analysis program system. End of include file SubPol2d.hh

#include "amma/Quadrila.hh"
ostream & operator<<(ostream & s,const QuadrilateralC & q)

Sends the quadrilateral 'q' into the output stream 's'. ==================================================================== ======= QuadrilateralC ============================================ ====================================================================

#include "amma/Rect2d.hh"
ostream & operator<<(ostream & s,const Rectangle2dC & r)

Sends the rectangle 'r' into the output stream 's'. ==================================================================== ======= Rectangle2dC =============================================== ====================================================================

#include "amma/VVdefs.hh"
char * getfree()


char * myalloc()


int right_of(struct Halfedge * el,struct Point * p)


int has_endpoint()


struct Point PQ_min()


struct Halfedge * PQextractmin()


void PQinsert(struct Halfedge * he,struct Site * v,RealT offset)


void PQdelete(struct Halfedge * he)


int PQbucket(struct Halfedge * he)


int PQempty()


void PQinitialize()


void geominit()


struct Edge * bisect(struct Site * s1,struct Site * s2)


struct Site * intersect(struct Halfedge * el1,struct Halfedge * el2)


void endpoint(struct Edge * e,int lr,struct Site * s)


RealT dist(struct Site * s,struct Site * t)


void makevertex(struct Site * v)


void deref(struct Site * v)


void ref(struct Site * v)


void ELinitialize()


void ELinsert(struct Halfedge * lb,struct Halfedge * myNew)


void ELdelete(struct Halfedge * he)


struct Halfedge * HEcreate(struct Edge * e,int pm)


struct Halfedge * ELgethash(int b)


struct Halfedge * ELleftbnd(struct Point * p)


struct Halfedge * ELright(struct Halfedge * he)


struct Halfedge * ELleft(struct Halfedge * he)


struct Site * leftreg(struct Halfedge * he)


struct Site * rightreg(struct Halfedge * he)


struct Halfedge * PQfind()


void readsites(const Point2dSArray1dC & p)


char * myalloc(unsigned n)


void makefree(struct Freenode * curr,struct Freelist * fl)


char * getfree(struct Freelist * fl)


void freeinit(struct Freelist * fl,int size)


struct Site * readone()


struct Site * nextone()


void out_bisector(struct Edge * e)


void out_ep(struct Edge * e)


void out_vertex(struct Site * v)


void out_site(struct Site * s)


void out_triple(struct Site * s1,struct Site * s2,struct Site * s3)


void plotinit()


void clip_line(struct Edge * e)


DListC<Index3dC> Voronoi(int triangulate,struct Site * (*)(FuncArgList) nextsite)


DListC<Index3dC> Delauney(const Point2dSArray1dC & p)

Delauney triangulation.

#include "amma/Mesh2dNode.hh"
int operator==(const Mesh2dNodeC & mn1,const Mesh2dNodeC & mn2)


int operator!=(const Mesh2dNodeC & mn1,const Mesh2dNodeC & mn2)


ostream & operator<<(ostream & os,const Mesh2dNodeC & mn)


istream & operator>>(istream & is,Mesh2dNodeC & mn)


#include "amma/Mesh2dEdgeB.hh"
ostream & operator<<(ostream &,const Mesh2dEdgeBodyC &)


istream & operator>>(istream &,Mesh2dEdgeBodyC &)


#include "amma/Mesh2dEdge.hh"
ostream & operator<<(ostream & os,const Mesh2dEdgeC & mn)


istream & operator>>(istream & is,Mesh2dEdgeC & mn)


#include "amma/Mesh2dNodeB.hh"
int operator==(const Mesh2dNodeBodyC &,const Mesh2dNodeBodyC &)


int operator!=(const Mesh2dNodeBodyC &,const Mesh2dNodeBodyC &)


ostream & operator<<(ostream &,const Mesh2dNodeBodyC &)


istream & operator>>(istream &,Mesh2dNodeBodyC &)


#include "amma/InHist1d.hh"
ostream & operator<<(ostream & s,const IntHistogram1dC & arr)


#include "amma/ReHist1d.hh"
ostream & operator<<(ostream & s,const HistogramMode1dT & mode)

Saves the 'mode' into the output stream. ====================================================================== ======== HistModes1dC ================================================ ======================================================================

ostream & operator<<(ostream & s,const HistModes1dC & modes)
RealHistogram1dC represents a histogram of real scalar values.
It is possible set up its resolution, eg. the size of bins. The histogram works on the interval

ostream & operator<<(ostream & s,const RealHistogram1dC & arr)


#include "amma/ReHist2d.hh"
ostream & operator<<(ostream & s,const RealHistogram2dC & arr)

-------------------------------------------------------------------- **************** RealHistogram2dC ********************************** --------------------------------------------------------------------

#include "amma/Mean1d.hh"
ostream & operator<<(ostream & outS,const Mean1dC & mean)

Saves the mean structure to the output stream 'outS'.

istream & operator>>(istream & inS,Mean1dC & mean)

Reads the mean structure from the input stream 'ins'.

#include "amma/MeanCo1d.hh"
ostream & operator<<(ostream & outS,const MeanCovariance1dC & meanCov)

Saves the mean-variance structure to the output stream 'outS'.

istream & operator>>(istream & inS,MeanCovariance1dC & meanCov)

Reads the mean-variance structure from the input stream 'ins'. ===================================================================== ========= MeanCovariance1dC ========================================= =====================================================================

#include "amma/MinMax1d.hh"
ostream & operator<<(ostream & outS,const MinMax1dC & mm)

Prints the Min/Max structure to the output stream 'outS'.

istream & operator>>(istream & inS,MinMax1dC & mm)

Reads the Min/Max structure from the input stream 'ins'. ----------------------------------------------------------------- ******** MinMax1dC ********************************************** -----------------------------------------------------------------

#include "amma/DataSet1.hh"
ostream & operator<<(ostream & s,const DataSet1dC & ds)

Writes the set 'ds' into the output stream 's'.

#include "amma/IMinMax1.hh"
ostream & operator<<(ostream & outS,const IntMinMax1dC & mm)

Prints the Min/Max structure to the output stream 'outS'.

istream & operator>>(istream & inS,IntMinMax1dC & mm)

Reads the Min/Max structure from the input stream 'ins'. ----------------------------------------------------------------- ******** IntMinMax1dC ******************************************* -----------------------------------------------------------------

#include "amma/BinTable.hh"
ostream & operator<<(ostream & out,const BinTableC<IT,DIT,BT> &)


#include "amma/BinIter.hh"
ostream & operator<<(ostream & out,const BinIterC<IT,DIT,BT> &)


#include "amma/RealSparHist1d.hh"
ostream & operator<<(ostream & out,const RealSparseHist1dC & rhist)
Sparse 1d histogram iterator.

#include "amma/SDFunct1.hh"
ostream & operator<<(ostream & s,const SDFunction1dC & f)

Writes the one dimensional function 'f' into the output stream 's'.

#include "amma/DFunct1.hh"
ostream & operator<<(ostream & s,const DFunction1dC & f)

Writes the one dimensional function 'f' into the output stream 's'. -------------------------------------------------------------------- **************** DFunction1dC ************************************** --------------------------------------------------------------------

#include "amma/ArPoint2.hh"
istream & operator>>(istream & s,Point2dArray1dC & points)

Reads the array of data from the input stream

ostream & operator<<(ostream & s,const Point2dArray1dC & points)

Sends the array of data into the output stream ==================================================================== ======= Point2dArray1dC ============================================ ====================================================================

#include "amma/SArPnt2.hh"
istream & operator>>(istream & s,Point2dSArray1dC & points)

Reads the array of data from the input stream

ostream & operator<<(ostream & s,const Point2dSArray1dC & points)

Sends the array of data into the output stream

#include "amma/SArPnt3.hh"
istream & operator>>(istream & s,Point3dSArray1dC & points)

Reads the array of data from the input stream

ostream & operator<<(ostream & s,const Point3dSArray1dC & points)

Sends the array of data into the output stream ==================================================================== ======= Point3dSArray1dC ============================================ ====================================================================

#include "amma/ArLinPV3.hh"
istream & operator>>(istream & s,Line3dPVArray1dC & lines)

Reads the array of data from the input stream

ostream & operator<<(ostream & s,const Line3dPVArray1dC & lines)

Sends the array of data into the output stream

#include "amma/Num/NumLabel.hh"
NUM_IO_OPERATORS(NumLabelC)

///////////////////////////////////////////

#include "amma/Num/NumData.hh"
ostream & operator<<(ostream & out,const NumDataC<InputC,OutputC> & dat)


istream & operator>>(istream & in,NumDataC<InputC,OutputC> & dat)

////////////////////////////////////////////////////

#include "amma/Num/NumDataSet.hh"
VectorC NormaliseVector(const VectorC & X,const VecMatC & stats)
Refines NumDataSetC to specify input type is VectorC.
First refinement of NumDataSetC is that the input type is a VectorC.

NumVDataSetC is introduced to tie in with the rest of the NumFuncC hierarchy. All classes derived from NumFuncC use data sets with a VectorC input and either a VectorC or NumLabelC output.


VectorC CovToVec(const MatrixC & C)
Converts vector form to Covariance matrix for fitting

MatrixC VecToCov(const VectorC & X)
Converts class label to a class probability vector
L class label
maxLabelthe highest label value
minP value for non-class probabilities
maxP value for class probability
The vector is created with all entries set to minP except for the one corresponding to L which is set to maxP.

VectorC LabelToVec(const NumLabelC & L,UIntT maxLabel,RealT minP,RealT maxP)
Converts class probability vector to a class label
This is done by returning the index of the highest probability.

NumLabelC VecToLabel(const VectorC & X)
Data type for VectorC,VectorC input and output in PatternRec

NUM_IO_OPERATORS(NumVVDataC)
Data type for VectorC,MatrixC input and output in PatternRec
The matrix is assumed to be a covariance matrix.

NUM_IO_OPERATORS(NumVCDataC)
Data type for VectorC,NumLabelC input and output in PatternRec

NUM_IO_OPERATORS(NumVLDataC)
Data type for VectorC,StringC input and output in PatternRec

NUM_IO_OPERATORS(NumVSDataC)


NUM_IO_OPERATORS(NumVVDataSetC)
Refines NumVDataSetC to specify output type is MatrixC (covariance).
Refinement of NumDataSetC through NumVDataSetC to give data set with input type VectorC and output data type MatrixC. Is is assumed for conversion purposes between MatrixC and VectorC that the matrix is a covariance matrix.

No context yet, the class is not used. It is intended to facilitate using classes derived from NumFuncC to represent covariance matrices instead of vectors.


NUM_IO_OPERATORS(NumVCDataSetC)
Refines NumVDataSetC to specify output type is NumLabelC.
Refinement of NumDataSetC through NumVDataSetC to give data set with input type VectorC and output data type NumLabelC.

NumVLDataSetC is used to store data sets for use with classes derived from NumPDFC, NumClassifyC and NumReduceC. In each case, the elements are assumed to represent a data pair consisting of a feature vector and corresponding class label.


NUM_IO_OPERATORS(NumVLDataSetC)
Refines NumVDataSetC to specify output type is StringC.
Refinement of NumDataSetC through NumVDataSetC to give data set with input data type as VectorC and output data type StringC.


NUM_IO_OPERATORS(NumVSDataSetC)

////////////////////////////////////////////////////////////////

#include "amma/Num/NumFunc.hh"
NUM_IO_OPERATORS(NumFuncC)

//////////////////////////////////////////////////////////////

#include "amma/Num/NumMagnitude.hh"
NUM_IO_OPERATORS(NumMagnitudeC)

/////////////////////////////////////////////////////////

#include "amma/Num/NumModel.hh"
NUM_IO_OPERATORS(NumModelC)

/////////////////////////////////////////

#include "amma/Num/NetVector.hh"
ostream & operator<<(ostream & s,const NetVectorC & vect)


istream & operator>>(istream & s,NetVectorC & vect)


#include "amma/Num/NumParameters.hh"
NUM_IO_OPERATORS(NumParametersC)

///////////////////////////////////////////////////////////

#include "amma/Num/NumCost.hh"
NUM_IO_OPERATORS(NumCostC)

///////////////////////////////////////////////////////

#include "amma/Num/NumPDF.hh"
NUM_IO_OPERATORS(NumPDFC)


#include "amma/Num/NumClassify.hh"
NUM_IO_OPERATORS(NumClassifyC)


#include "amma/Num/NumClassifySupervised.hh"
NUM_IO_OPERATORS(NumClassifySupervisedC)


#include "amma/Num/NumClassifyUnsupervised.hh"
NUM_IO_OPERATORS(NumClassifyUnsupervisedC)


#include "amma/Num/NumClassifyFusion.hh"
NUM_IO_OPERATORS(NumClassifyFusionC)

///////////////////////////////////////////

#include "amma/Num/NumReduce.hh"
NUM_IO_OPERATORS(NumReduceC)


#include "amma/Num/NumReduceSupervised.hh"
NUM_IO_OPERATORS(NumReduceSupervisedC)

/////////////////////////////////////////////////

#include "amma/Num/NumReduceUnsupervised.hh"
NUM_IO_OPERATORS(NumReduceUnsupervisedC)

////////////////////////////////////////////////

#include "amma/Num/NumError.hh"
NUM_IO_OPERATORS(NumErrorC)


#include "amma/Num/NumPerformance.hh"
NUM_IO_OPERATORS(NumPerformanceC)

///////////////////////////////////////////////////

#include "amma/Num/NumClustCriterion.hh"
NUM_IO_OPERATORS(NumClustCriterionC)

///////////////////////////////////////

#include "amma/Num/NormalRBFunc.hh"
ostream & operator<<(ostream & s,const NormalRBFuncC & out)
output stream operator

istream & operator>>(istream & s,NormalRBFuncC & in)


#include "amma/Num/RbfValidate.hh"
istream & operator>>(istream & s,RbfValidateBodyC & in)
Validation of a normal mixture model
This class checks how well a computed model agrees with the data

ostream & operator<<(ostream & s,const RbfValidateC & out)
output stream operator

istream & operator>>(istream & s,RbfValidateC & in)
input stream operator

#include "amma/Num/RbfOption.hh"
ostream & operator<<(ostream & s,const RbfOptionC & out)
output stream operator

istream & operator>>(istream & s,RbfOptionC & in)
input stream operator

#include "amma/Num/TotalKurtosis.hh"
ostream & operator<<(ostream & s,const TotalKurtosisC & out)
output stream operator

istream & operator>>(istream & s,TotalKurtosisC & in)
input stream operator

#include "amma/Num/NumOptimise.hh"
NUM_IO_OPERATORS(NumOptimiseC)

//////////////////////////////////////////////////

#include "amma/Num/Simplex.hh"
istream & operator>>(istream & s,SimplexBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const SimplexC & out)
output stream operator

istream & operator>>(istream & s,SimplexC & in)
input stream operator

#include "amma/Num/NumSelect.hh"
NUM_IO_OPERATORS(NumSelectC)

/////////////////////////////////////////

#include "amma/Num/NumClassComb.hh"
istream & operator>>(istream & s,NumClassCombBodyC & in)
Class for combining different classifiers
Class for the combination of supervised classifiers

#include "amma/GreyVal.hh"
ByteGreyValueT Cut(GreyValueT level)

the result value is in the interval

ByteGreyValueT Cut(RealGreyValueT level)

Returns the grey level that is an integer value in the interval .

RealGreyValueT GammaCorrection(const GreyValueT grey,const RealT gamma)

the result value is gamma corrected 'grey' value

RealGreyValueT GammaCorrection(const RealGreyValueT grey,const RealT gamma)

the result value is gamma corrected 'grey' value

BooleanT IsSaturated(const GreyValueT grey)

Return TRUE if grey is BLACK or WHITE-1 or WHITE

#include "amma/RGBValue.hh"
ostream & operator<<(ostream & outS,const ByteRGBValueC & rgb)

Writes the representation of the colour 'rgb' into the output stream 'outS'.

istream & operator>>(istream & inS,ByteRGBValueC & rgb)

Initializes the colour 'rgb' from the input stream 'inS'.

ostream & operator<<(ostream & outS,const ByteRGBXValueC & rgbx)

Writes the representation of the colour 'rgbx' into the output stream 'outS'.

istream & operator>>(istream & inS,ByteRGBXValueC & rgbx)

Initializes the colour 'rgbx' from the input stream 'inS'. ================================================================== ******* ByteRGBXValueC ******************************************* ==================================================================

ostream & operator<<(ostream & outS,const RGBValueU16C & rgb)

Writes the representation of the colour 'rgb' into the output stream 'outS'.

istream & operator>>(istream & inS,RGBValueU16C & rgb)

Initializes the colour 'rgb' from the input stream 'inS'. =============================================================== ********** RGBValueU16C ************************************** ===============================================================

ostream & operator<<(ostream & outS,const RGBValueC & rgb)

Writes the representation of the colour 'rgb' into the output stream 'outS'.

istream & operator>>(istream & inS,RGBValueC & rgb)

Initializes the colour 'rgb' from the input stream 'inS'. =============================================================== ********** RGBValueC ****************************************** ===============================================================

#include "amma/ColorCnv.hh"
void SetYUVtoRGBTransformation(GrabberT g = STANDARD)

Sets the conversion function according to the specific grabber. ======================================================================== ========== RGB to YUV ================================================== ========================================================================

#include "amma/YUVValue.hh"
ostream & operator<<(ostream & outS,const ByteYUVValueC & yuv)


istream & operator>>(istream & inS,ByteYUVValueC & yuv)

======================================================================== ========= YUVValueC =================================================== ========================================================================

#include "amma/MunselPt.hh"
ostream & operator<<(ostream & outS,const MunsellPointC & mun)

Writes the representation of the colour 'mun' into the output stream 'outS'.

istream & operator>>(istream & inS,MunsellPointC & mun)

Initializes the colour 'mun' from the input stream 'inS'. ======================================================================== ======== MunsellPointC inlining ======================================== ========================================================================

#include "amma/BinIORGBValue.hh"
BinOStreamC & operator<<(BinOStreamC & out,const ByteRGBValueC & pix)


BinIStreamC & operator>>(BinIStreamC & in,ByteRGBValueC & pix)


BinOStreamC & operator<<(BinOStreamC & out,const RGBValueC & pix)


BinIStreamC & operator>>(BinIStreamC & in,RGBValueC & pix)


BinOStreamC & operator<<(BinOStreamC & out,const RGBValueU16C & pix)


BinIStreamC & operator>>(BinIStreamC & in,RGBValueU16C & pix)


BinOStreamC & operator<<(BinOStreamC & out,const RGBPointC & pix)


BinIStreamC & operator>>(BinIStreamC & in,RGBPointC & pix)


#include "amma/BinIOYUVValue.hh"
BinOStreamC & operator<<(BinOStreamC & out,const ByteYUVValueC & pix)


BinIStreamC & operator>>(BinIStreamC & in,ByteYUVValueC & pix)


BinOStreamC & operator<<(BinOStreamC & out,const YUVValueC & pix)


BinIStreamC & operator>>(BinIStreamC & in,YUVValueC & pix)


BinOStreamC & operator<<(BinOStreamC & out,const YUVPointC & pix)


BinIStreamC & operator>>(BinIStreamC & in,YUVPointC & pix)


#include "amma/VYUValue.hh"
BinOStreamC & operator<<(BinOStreamC & out,const ByteVYUValueC & pix)


BinIStreamC & operator>>(BinIStreamC & in,ByteVYUValueC & pix)


ostream & operator<<(ostream & out,const ByteVYUValueC & pix)


istream & operator>>(istream & in,ByteVYUValueC & pix)


#include "amma/ImageRec.hh"
ostream & operator<<(ostream & outS,const ImageRectangleC & rect)

write value of the rectangle to the output stream 'outS'

istream & operator>>(istream & is,ImageRectangleC & rect)

read value of the rectangle from the input stream 'is' /////////////////////////////////////////////////////////////////////

#include "amma/Image.hh"
ostream & operator<<(ostream & out,const ImageC<PValueT> & img)


istream & operator>>(istream & in,ImageC<PValueT> & img)

-------------------------------------------------------------------- **************** ImageC ******************************************** --------------------------------------------------------------------

#include "amma/BinImgIO.hh"
BinOStreamC & operator<<(BinOStreamC & out,const ImageRectangleC & img)


BinIStreamC & operator>>(BinIStreamC & in,ImageRectangleC & img)


BinOStreamC & operator<<(BinOStreamC & out,const ImageC<PValueT> & img)


BinIStreamC & operator>>(BinIStreamC & in,ImageC<PValueT> & img)


#include "amma/ImgNumOps.hh"
ImageC<PixelT> & operator+=(ImageC<PixelT> & im,ScalarT alpha)

Adds `alpha' to all pixel values.

ImageC<PixelT> & operator-=(ImageC<PixelT> & im,ScalarT alpha)

Subtracts `alpha' from all pixel values.

ImageC<PixelT> & operator*=(ImageC<PixelT> & im,ScalarT alpha)

Multiplies all pixel values by `alpha'.

ImageC<PixelT> & operator/=(ImageC<PixelT> & im,ScalarT alpha)

Divides all pixel values by `alpha'.

ImageC<Pixel1T> & operator+=(ImageC<Pixel1T> & im1,ImageC<Pixel2T> im2)

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

ImageC<Pixel1T> & operator-=(ImageC<Pixel1T> & im1,ImageC<Pixel2T> im2)

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

ImageC<Pixel1T> & operator*=(ImageC<Pixel1T> & im1,ImageC<Pixel2T> im2)

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

ImageC<Pixel1T> & operator/=(ImageC<Pixel1T> & im1,ImageC<Pixel2T> im2)

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

#include "amma/ByteImag.hh"
ByteImageC ByteChromaticityDiagram(const RGBImageC & image)

////////////////////////////////////////////////

#include "amma/IntImage.hh"
IntImageC ComponentLabelling4(const ByteImageC & im,SizeT & jnr)

Connected component labelling using 4-neighborhood provided that the input image 'im' is a binary image with objects labelled by values different from 0. NOT IMPLEMENTED. jnr: ... the number of connected components already found in the image

IntImageC GreyComponentLabelling4(const ByteImageC & im,SizeT & n)

Connected component labelling using 4-neighborhood of pixel provided that the input image 'im' contains regions determined by sets of 4-connected pixels. At input the value 'n' is taken as an assumed maximum label value, at output the value 'n' is the number of connected components already found in the image 'im'.

IntImageC ComponentLabelling8(const ByteImageC & im,SizeT n)

Connected component labelling using 8-neighborhood of pixel provided that the input image 'im' contains regions determined by sets of 4-connected WHITE pixels on the BLACK background. At input the value 'n' is taken as an assumed maximum label value, at output the value 'n' is the number of connected components already found in the image 'im'.

IntImageC ConnectedComponentLabelling(const CrackImageC & im,IntT & maxLabel)

trees of connected pixels are labelled uniquely Pixels labelled CR_NODIR in the crack code image im will be labelled as BACKGROUND in the result image

#include "amma/YUVImage.hh"
SumNXX2d3C RGBSumNXX2(const YUVImageC & image)

compute sums of RGB values directly from YUV image ======================================================================= ================ YUVImageC ============================================ =======================================================================

#include "amma/Image/ImgIO.hh"
void InitDPImageIO()

This calls all the following functions.

void InitStdImageCnv()


void InitStdImageCnv2()


void InitStdImageCnv3()


void InitPNMFormat()


void InitImgIOByte()


void InitImgIOReal()


void InitImgIOInt()


void InitImgIOUInt16()


void InitImgIOByteRGB()


void InitImgIORealRGB()


void InitImgIOByteYUV()


void InitImgIORealYUV()


void InitRGBImageCnv()


void InitRGB16ImageCnv()


void InitImgIOU16RGB()


void InitPixelIO()


void InitImgIOByteVYU()


void InitFrameImageCnv()


void InitCompatIORGB()


void InitCompatIOYUV()


void InitCompatIOY()


#include "amma/Image/VidIO.hh"
void InitVidIO()

This calls all the following functions.

void InitCifFormat()

Cif file formats

void InitYUVFormat()

Abakes yuv formats.

void InitRGBFormat()

raw rgb formats.

void InitRawIOFormat()

raw image formats.

void InitSYUVFormat()

Abekas Sequence in a single file

void InitImgIOComposites()

Composite image streams.

#include "amma/Image/IPBasic.hh"
ImageC<TypeC> operator+(const ImageC<TypeC> & im1,const ImageC<TypeC> & im2)
Subtracts two images pixel by pixel

ImageC<TypeC> operator-(const ImageC<TypeC> & im1,const ImageC<TypeC> & im2)
Subtracts two images pixel by pixel

#include "amma/Image/IPTransform.hh"
ImageC<OutT> operator>>(const ImageC<InT> & oth,const IPTransformC<InT,OutT> & op)
Overloads stream operator to apply filters to images of any type
////////////////////////////////////////////////////////

#include "amma/Image/IPFilter.hh"
ImageC<TypeC> operator>>(const ImageC<TypeC> & oth,const IPFilterC<TypeC> & op)
Overloads stream operator to apply filters to images of any type

#include "amma/Image/BiLinearInt.hh"
ImageC<InT> operator>>(const ImageC<InT> & oth,IPBiLinearIntC<InT,OutT> & op)
Overloads stream operator to apply filters to images of any type

#include "amma/Image/IPBinary.hh"
ImageC<ByteGreyValueT> operator>>(const ImageC<TypeC> & oth,const IPBinaryC<TypeC> & op)
Overloads stream operator to apply binary filters to images of any type

#include "amma/Image/IPLabel.hh"
ImageC<NumLabelC> operator>>(const ImageC<TypeC> & oth,const IPLabelC<TypeC> & op)
Overloads stream operator to apply labelling filters to images of any type

#include "amma/Image/IPMoments.hh"
NumDataSetC<Moments012d2C,TypeC> FindMoments(const ImageC<TypeC> & img)
Finds moments for all regions in an image
Returns a data set of moments labelled with the corresponding image value.
BUG: Only works for ImageC at the moment, needs hash table implementation instead of current array which requires hash functions for basic types int and char etc.

#include "amma/Image/PCMapping.hh"
ostream & operator<<(ostream & strm,const PCPixMapC<CurveT> & data)


istream & operator>>(istream & strm,PCPixMapC<CurveT> & data)
Mappings from a curve to a set of pixels.

ostream & operator<<(ostream & strm,const PCPixMappingC<CurveT> & data)


istream & operator>>(istream & strm,PCPixMappingC<CurveT> & data)

//////////////////////////////////////////

#include "amma/Image/SobelImg.hh"
ImageC<UIntT> IPSobelImg(ImageRectangleC rect)


#include "amma/Image/PCurveIO.hh"
BinOStreamC & operator<<(BinOStreamC & strm,const PCPixMapC<CurveT> & data)

Line-PixelSet mapping IO.

BinIStreamC & operator>>(BinIStreamC & strm,PCPixMapC<CurveT> & data)

List of Line-PixelSet mappings.

#include "amma/Image/BGRXValue.hh"
ostream & operator<<(ostream & outS,const ByteBGRXValueC & bgrx)

Writes the representation of the colour 'bgrx' into the output stream 'outS'.

istream & operator>>(istream & inS,ByteBGRXValueC & bgrx)

Initializes the colour 'bgrx' from the input stream 'inS'. ================================================================== ******* ByteBGRXValueC ******************************************* ==================================================================

#include "amma/pixchain.hh"
ostream & operator<<(ostream & outS,CannyStringC & cs)


istream & operator>>(istream & outS,CannyStringC & cs)

class CannyStringPtrC: public ListPtrC {};

#include "amma/Mom01d2.hh"
ostream & operator<<(ostream & os,const Moments01d2C & mom)


istream & operator>>(istream & is,Moments01d2C & mom)


#include "amma/Mom012P2.hh"
ostream & operator<<(ostream & os,const Moments012Perd2C & mom)


istream & operator>>(istream & is,Moments012Perd2C & mom)


Array1dC<Moments012Perd2C> Moments012Perimeterd2Green(const IntImageC & ip,const IntT jnr)

Computes 0., 1., and 2. moments and perimeter for all blobs in the labeled image 'ip' which contains the maximal label 'jnr'. The algorithm uses the Green's theorem and uses only boundary pixels for computation. NOTICE!!! The moment m11 is not computed correctly.

Array1dC<Moments012Perd2C> Moments012Perimeterd2Def(const IntImageC & ip,const IntT jnr)

Computes 0., 1., and 2. moments and perimeter for all blobs in the labeled image 'ip' which contains the maximal label 'jnr'. The algorithm uses a definition of moments directly.

#include "amma/Mom012d2.hh"
ostream & operator<<(ostream & os,const Moments012d2C & mom)


istream & operator>>(istream & is,Moments012d2C & mom)


#include "amma/CrackIm.hh"
CrackImageC NearestNeighbour(const ByteImageC & image,const IntT maxDif)

Assign a direction toward the neighboring pixel which has the minimal difference in grey level not bigger than 'maxDif'. If all neighboring pixels differ too much assign 'NO_DIR' to the pixel

CrackImageC NearestNeighbour(const RGBImageC & image,const IntT maxDist)

Assign a direction toward the neighboring pixel which has the minimal distance in RGB space from the pixel value not bigger than 'maxDist'. If all neighboring pixels differ too much assign 'NO_DIR' to the pixel

#include "amma/ShapeDsc.hh"
RealT SpatialFeature(const ByteImageC & image,const Point2dC & centroid,const RealT area)

density of regions in the image

RealT SpatialFeature(const IntImageC & image,const Point2dC & centroid,const RealT area)

density of regions in the image

RealArray1dC SpatialFeature(const IntImageC & lab_image,const Array1dC<Point2dC> & centroid,const RealArray1dC & area)

density of regions in the image

RealArray1dC Moments(const IntImageC & ip,const IntT irn0,const IntT nr0,const IntT ii0,const IntT jj0,IntT nlz0)

Measures a moment of a specified region or every region in a labeled image. IRN : Label of specified region (0 ~ NR) (I) BT(NR): Moment of each region (O) NR : Number of regions (I) II : Order of x component of moment (I) JJ : Order of y component of moment (I) NLZ : Specification of normalization (I) NLZ=0 ... Moment around center of gravity NLZ=1 ... Moment based on principal axis Reference [1] R & K, pp. 427-428.

Array1dC<Point2dC> RegionCentroids(const IntImageC & ip,IntT irn,IntT nr)

Measures the coordinates of the center of gravity of a specified region or every region in a labeled image. IP(ISX,ISY) : Labeled image array (I) IRN : Label of specified region (0~NR) (I) JF(2,NR) : Coordinates of center of gravity of each region (O) NR : Number of regions (>0) (I) Reference [1] R&K, p. 410.

IntArray1dC PerimeterLengths(const IntImageC & ip,const IntT irn0,const IntT nr0,const IntT nc0)

Measures the length of perimeter of a specified region or every region in a labeled image. IP(ISX,ISY): Labeled image array (input) (I) IRN : Label of specified region (0 ~ NR) (I) JF(NR) : Length of perimeter of each region (O) NR : Number of regions (I) NC : Specification of connectedness (4 or 8. When another value is set, 8-adjacency is assumed.) (I) Reference [1] R&K, pp. 350-352.

Array1dC<VectorC> BlobsDescriptionJames(const IntImageC & ip,const IntT jnr)

shape description of all blobs using SPIDER libraries, ip ... labeled image jnr ... the maximal label in the 'ip' returns ... a feature vector for each labeled blob

Array1dC<VectorC> BlobsDescription(const IntImageC & ip,const IntT jnr)

shape description of all blob's boundary edges, ip ... labeled image jnr ... the maximal label in the 'ip' returns ... a feature vector for each labeled blob

Array1dC<VectorC> BlobsDescription(const ListC<BoundaryC> & bl,const ByteImageC & image)

shape description of all blob's boundaries the labels of blobs are store in the 'image' returns ... a feature vector for each labeled blob IAPS - Image analysis program system. End of include file ShapeDsc.hh

#include "amma/PxString.hh"
ostream & operator<<(ostream & s,const PixelStringC & str)
The class PixelStringListC contains a list of pixel strings.

ostream & operator<<(ostream & s,const PixelStringListC & str)

Writes the set of strings of pixel into the output stream. IAPS - Image analysis program system. End of include file PxString.hh

#include "amma/RegModel.hh"
BooleanT InRegion(ChromaFlatRModelC & model,const EdgeC & edge)


BooleanT InRegion(ChromaGradRModelC & model,const EdgeC & edge)


BooleanT InRegion(RGBFlatRModelC & model,const EdgeC & edge)


BooleanT InRegion(GradRModelC & model,const EdgeC & edge)


#include "amma/SmallRMo.hh"
BooleanT CountRegion(SmallRModelC & model,const EdgeC & edge)


BooleanT RecolorRegion(SmallRModelC & model,const EdgeC & edge)


BooleanT ReMarkRegion(SmallRModelC & model,const EdgeC & edge)


void SmallRegionRemovingAccWeakBoundary(double minAveGrad,ByteImageC & orig,ByteImageC & segm)


#include "amma/ConstMod.hh"
BooleanT InRegion(ConstantRModelC & model,const EdgeC & edge)

IAPS - Image analysis program system. End of include file ConstantRModel.hh

#include "amma/PolynRMo.hh"
BooleanT SpreadModel(PolRModelC & model,const EdgeC & edge)


BooleanT BuildModel(PolRModelC & model,const EdgeC & edge)

The new model is created from pixels which don't belong to any region. The edge in the pixel and the distance from the model must be enough small.

BooleanT SetBetterModel(PolRModelC & model,const EdgeC & edge)


BooleanT SetBetterModelContinue(PolRModelC & model,const EdgeC & edge)


BooleanT LastSpreadModel(PolRModelC & model,const EdgeC & edge)


BooleanT SpreadIntoUnprocessed(PolRModelC & model,const EdgeC & edge)


BooleanT ResetProcessed(PolRModelC & model,const EdgeC & edge)


#include "amma/ReMarkMo.hh"
BooleanT InRegion(ReMarkRModelC & model,const EdgeC & edge)

IAPS - Image analysis program system. End of include file ReMarkRModel.hh

#include "amma/FlatRMo.hh"
BooleanT InRegion(FlatRModelC & model,const EdgeC & edge)


#include "amma/ByIntRMo.hh"
BooleanT InRegion(Byte2IntRModelC & model,const EdgeC & edge)


IntImageC ToIntLabels(ByteImageC & image,int & regNumber)

IAPS - Image analysis program system. End of include file ByIntRMo.hh

#include "amma/IntByRMo.hh"
BooleanT InRegion(Int2ByteRModelC & model,const EdgeC & edge)


ByteImageC ToByteLabels(IntImageC & image,RAGTableC & rag)

IAPS - Image analysis program system. End of include file ByIntRMo.hh

#include "amma/ThresRMo.hh"
BooleanT InRegion(ThresholdRModelC & model,const EdgeC & edge)

is the edge inside the region IAPS - Image analysis program system. End of include file ThresholdRModel.hh

#include "amma/RgbRMo.hh"
BooleanT InRegion(RgbRModelC & model,const EdgeC & edge,GreyValueT label)

is the edge inside the region IAPS - Image analysis program system. End of include file RgbRModel.hh

#include "amma/ChrDRMod.hh"
BooleanT InRegion(ChromaMahaRModelC & model,const EdgeC & edge)

Is the edge inside the region ? ------------------------------------------------------------------ *************** ChromaMahaRModelC ******************************** ------------------------------------------------------------------

#include "amma/ProbRMo.hh"
BooleanT InRegion(ProbabilityRModelC & model,const EdgeC & edge,GreyValueT label)

is the edge inside the region IAPS - Image analysis program system. End of include file ProbabilityRModel.hh

#include "amma/CamCorr.hh"
ostream & operator<<(ostream & outS,const CameraCorrectionC & table)


istream & operator>>(istream & inS,CameraCorrectionC & table)

IAPS - Image analysis program system. End of include file CamCorr.hh

#include "amma/LColMod.hh"
ostream & operator<<(ostream & outS,const LineColorModelsC & table)


istream & operator>>(istream & inS,LineColorModelsC & table)

IAPS - Image analysis program system. End of include file LColMod.hh

#include "amma/Region/RegClassCol.hh"
ostream & operator<<(ostream & s,const RegClassColC<ValT,StatT> & out)
output stream operator

istream & operator>>(istream & s,RegClassColC<ValT,StatT> & in)
input stream operator

#include "amma/Region/RegColCovMatcher.hh"
istream & operator>>(istream & s,RegColCovMatcherBodyC & in)
Class for matching regions in successive frames

ostream & operator<<(ostream & s,const RegColCovMatcherC & out)
output stream operator

istream & operator>>(istream & s,RegColCovMatcherC & in)
input stream operator

#include "amma/Region/RegColMeanMatcher.hh"
istream & operator>>(istream & s,RegColMeanMatcherBodyC & in)
Class for matching regions in successive frames

ostream & operator<<(ostream & s,const RegColMeanMatcherC & out)
output stream operator

istream & operator>>(istream & s,RegColMeanMatcherC & in)
input stream operator

#include "amma/Region/RegColMeanCovMatcher.hh"
istream & operator>>(istream & s,RegColMeanCovMatcherBodyC & in)
Class for matching regions in successive frames

ostream & operator<<(ostream & s,const RegColMeanCovMatcherC & out)
output stream operator

istream & operator>>(istream & s,RegColMeanCovMatcherC & in)
input stream operator

#include "amma/Region/RegClassMot.hh"
ostream & operator<<(ostream & s,const RegClassMotC<ValT,StatT> & out)
output stream operator

istream & operator>>(istream & s,RegClassMotC<ValT,StatT> & in)
input stream operator

#include "amma/Region/PointContour.hh"
istream & operator>>(istream & s,PointContourBodyC & in)
Class to fill a contour represented by a list of points (floating points)
All the pixels enclosed by the contour are labelled 'in_label'; the other pixels in the bounding box are labelled 'out_label'

ostream & operator<<(ostream & s,const PointContourC & out)
output stream operator

istream & operator>>(istream & s,PointContourC & in)
input stream operator

#include "amma/Motion/MotModel.hh"
istream & operator>>(istream & s,MotModelBodyC & in)
Base class for the motion models

ostream & operator<<(ostream & s,const MotModelC & out)
output stream operator

istream & operator>>(istream & s,MotModelC & in)
input stream operator

#include "amma/Motion/QuAffMotModel.hh"
ostream & operator<<(ostream & s,const QuAffMotModelC & out)
output stream operator

istream & operator>>(istream & s,QuAffMotModelC & in)
input stream operator

#include "amma/Motion/TransMotModel.hh"
ostream & operator<<(ostream & s,const TransMotModelC & out)
output stream operator

istream & operator>>(istream & s,TransMotModelC & in)
input stream operator

#include "amma/Motion/AffineMotModel.hh"
ostream & operator<<(ostream & s,const AffineMotModelC & out)
output stream operator

istream & operator>>(istream & s,AffineMotModelC & in)
input stream operator

#include "amma/Motion/PerspectiveMotModel.hh"
ostream & operator<<(ostream & s,const PerspectiveMotModelC & out)
output stream operator

istream & operator>>(istream & s,PerspectiveMotModelC & in)
input stream operator

#include "amma/Motion/QuadraticMotModel.hh"
ostream & operator<<(ostream & s,const QuadraticMotModelC & out)
output stream operator

istream & operator>>(istream & s,QuadraticMotModelC & in)
input stream operator

#include "amma/Motion/MatchMotEstBase.hh"
istream & operator>>(istream & s,MatchMotEstBaseBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const MatchMotEstBaseC & out)
output stream operator

istream & operator>>(istream & s,MatchMotEstBaseC & in)
input stream operator

#include "amma/Motion/MultiMatchMotEstBase.hh"
istream & operator>>(istream & s,MultiMatchMotEstBaseBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const MultiMatchMotEstBaseC & out)
output stream operator

istream & operator>>(istream & s,MultiMatchMotEstBaseC & in)
input stream operator

#include "amma/Motion/RegionMotComp.hh"
ostream & operator<<(ostream & s,const RegionMotCompBodyC<MotModelT,ContourT> & out)


istream & operator>>(istream & s,RegionMotCompBodyC<MotModelT,ContourT> & in)
Stream constructor
This creates a new instance of the class from an input stream.

ostream & operator<<(ostream & s,const RegionMotCompC<MotModelT,ContourT> & out)

//////////////////////////// input your class members

istream & operator>>(istream & s,RegionMotCompC<MotModelT,ContourT> & in)
Stream constructor
This creates a new instance of the class from an input stream.

#include "amma/Motion/MCErrorSegmentBase.hh"
RegionSetC<VectorC> operator>>(const ImageC<NumLabelC> & oth,const MCErrorSegmentBaseC & op)

////////////////////////////////////////////////////////

#include "amma/Motion/MultiLevel.hh"
istream & operator>>(istream & s,MultiLevelBodyC & in)
Class for producing multiresolution or multiscale images


ostream & operator<<(ostream & s,const MultiLevelC & out)
output stream operator

istream & operator>>(istream & s,MultiLevelC & in)
input stream operator

#include "amma/Motion/MCErrorSegment1.hh"
RegionSetC<VectorC> operator>>(const ImageC<NumLabelC> & oth,const MCErrorSegment1C & op)

////////////////////////////////////////////////////////

#include "amma/Motion/MCErrorSegment2.hh"
RegionSetC<VectorC> operator>>(const ImageC<NumLabelC> & oth,const MCErrorSegment2C & op)

////////////////////////////////////////////////////////

#include "amma/Motion/MCErrorSegment3.hh"
RegionSetC<VectorC> operator>>(const ImageC<NumLabelC> & oth,const MCErrorSegment3C & op)

////////////////////////////////////////////////////////

#include "amma/Motion/NumLabelImageConv.hh"
ImageC<NumLabelC> ByteImageCT2ImageCNumLabelCT(const ImageC<ByteGreyValueT> & dat)


ImageC<ByteGreyValueT> ImageCNumLabelCT2ByteImageCT(const ImageC<NumLabelC> & dat)


#include "amma/FastFourierTrans2d.hh"
istream & operator>>(istream & s,FastFourierTrans2dBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const FastFourierTrans2dC & out)
output stream operator

istream & operator>>(istream & s,FastFourierTrans2dC & in)
input stream operator

#include "amma/Im3dMaths.hh"
Image3dC<DataT> operator+(const Image3dC<DataT> & a,const Image3dC<DataT> & b)
overload of the adding function
///////////////////////////////////////////////////////////////////

Image3dC<DataT> operator-(const Image3dC<DataT> & a,const Image3dC<DataT> & b)
overload of the substracting function

Image3dC<DataT> operator*(const Image3dC<DataT> & a,const Image3dC<DataT> & b)
overload of the multiplication function

Image3dC<DataT> operator/(const Image3dC<DataT> & a,const Image3dC<DataT> & b)
overload of the division function

Image3dC<DataT> sqr(const Image3dC<DataT> & in)
overload of sqr

Image3dC<DataT> sqrt(const Image3dC<DataT> & in)
overload of sqrt

#include "amma/Corner.hh"
ostream & operator<<(ostream & out,const CornerC & corn)


istream & operator>>(istream & in,CornerC & corn)

//////////////////////////////////// A somewhat arbitary distance messure between two corners.

#include "amma/GeomPt2dFt.hh"
ostream & operator<<(ostream & outS,const GeomPt2dFeatC & feat)

Writes the feature essentials into the output stream.

#include "amma/GeomLine2dFt.hh"
ostream & operator<<(ostream & outS,const GeomLine2dFeatC & feat)

Writes the feature essentials into the output stream.

#include "amma/aff.hh"
ostream & operator<<(ostream & outS,AffTransfC & transf)

Prints transformation to the output stream

istream & operator>>(istream & inS,AffTransfC & transf)

Reads transformation from the input stream

#include "amma/Quartern.hh"
QuarternC operator*(const QuarternC q,const QuarternC p)

returns q x p, quarternion multiplication can return q[0] < 0

QuarternC operator*(const QuarternC & q1,const RealT & val)

returns q[i] = q1[i]*val, for i=0..3

QuarternC operator+(const QuarternC & q1,const QuarternC & q2)

returns q[i] = q1[i] + q2[i], for i=0..3

QuarternC operator-(const QuarternC & q1,const QuarternC & q2)

returns q[i] = q1[i] - q2[i], for i=0..3

ostream & operator<<(ostream & outS,const QuarternC & quartern)

ouput stream operator ------------------------------------------------------------------------- End of include file Quartern.hh -------------------------------------------------------------------------

#include "amma/RigidT.hh"
RigidTransC operator*(const RigidTransC & q,const RigidTransC & p)

returns q x p ie applies p then q

Vector3dC operator*(const RigidTransC & q,const Vector3dC & v)

Apply transform to v

RigidTransC operator*(const RigidTransC & p1,const RealT & val)

returns trans[i] = p1.trans[i]*val (i=0..2) and rot[i] = p1.rot[i]*val (i=0..3)

RigidTransC operator+(const RigidTransC & p1,const RigidTransC & p2)

returns trans[i] = p1.trans[i] + p2.trans[i] (i=0..2) and rot[i] = p1.rot[i] + p2.rot[i] (i=0..3)

RigidTransC operator-(const RigidTransC & p1,const RigidTransC & p2)

returns trans[i] = p1.trans[i] - p2.trans[i] (i=0..2) and rot[i] = p1.rot[i] - p2.rot[i] (i=0..3) To do VectorC ConvertRTtoV7(RigidTransC rt); RigidTransC ConvertV7toRT(VectorC v);

VectorC ConvertRTtoV6(RigidTransC rt)

Converts a RigidTrans to a 6 component vector containing 3 vector r and 3 vector trans, note problems for angles near PI (ExportAxTheta in Quartern.hh)

RigidTransC ConvertV6toRT(VectorC v)

Converts a 6 component vector containing 3 vector r and 3 vector trans to a RigidTransC

ostream & operator<<(ostream & outS,const RigidTransC & rt)

output stream operator ------------------------------------------------------------------------- End of include file RigidTrans.hh -------------------------------------------------------------------------

#include "amma/Homtm.hh"
HomtmC operator*(const RealT &,const HomtmC &)

RealT * HomtmC = HomtmC

Vector3dC operator*(const HomtmC &,const Vector3dC &)

HomtmC * Vector3dC = Vector3dC Ok. This is not mathematically correct : you can't multiply a 4x4 matrix with a 3d vector. Here, we make the assumption that the 3x3 vector has a 4th scale component which is equal to 1.

Vector4dC operator*(const HomtmC &,const Vector4dC &)

Vector4dC <- HomtmC * Vector4dC

HomtmC operator+(const HomtmC &,const Vector3dC &)

HomtmC <- HomtmC + Vector3dC

HomtmC operator-(const HomtmC &,const Vector3dC &)

HomtmC <- HomtmC - Vector3dC

ostream & operator<<(ostream &,const HomtmC &)

ouput stream operator

istream & operator>>(istream &,HomtmC &)

input stream operator ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- -----------------------------------------------------------------------------

#include "amma/Polops.hh"
ostream & operator<<(ostream & strm,const PolopsC &)


istream & operator>>(istream & strm,PolopsC &)

------------------------------------------------------------------------- -------------------------------------------------------------------------

PolopsC PolopsConcatenate(SArray1dC<PolopsC> parr)
Constructs a Polops from an array of Polops

PolopsC PolopsConcatenate(SArray1dC<PolopsC> parr,SArray1dC<SubGroupT> sub)
Constructs a Polops from an array of Polops, updates the begin
and end of the subgroups, ignores the string

PolopsC PolopsConcatenate(DListC<PolopsC> plist)
Constructs a Polops from a list of Polops
------------------------------------------------------------------------- ------------------------------------------------------------------------- ------------------------------------------------------------------------- Access to elements of the structure -------------------------------------------------------------------------

#include "amma/IndTri.hh"
void FastNearestBaryInside(const Vector3dC & v0,const Vector3dC & v1,const Vector3dC & v2,const Vector3dC & p,Vector3dC & b)

The following routines are derivatives of the first

double FastDistToTri(const Vector3dC & v0,const Vector3dC & v1,const Vector3dC & v2,const Vector3dC & p)


void FastNearestBaryInside(const Vector3dC & v0,const Vector3dC & v1,const Vector3dC & v2,const Vector3dC & p,Vector3dC & b,Vector3dC & nearest,double & dist)

----------------------------------------------------------------------------- ----------------------------------------------------------------------------- *** End of include file IndTri.hh ******************************************* -----------------------------------------------------------------------------

#include "amma/ByteRange.hh"
ostream & operator<<(ostream & s,const ByteRangeC & range)

------------------------------------------------------------------------- ------------------------------------------------------------------------- End of include file ByteRange.hh -------------------------------------------------------------------------

#include "amma/FloatRange.hh"
ostream & operator<<(ostream & s,const FloatRangeC & range)

------------------------------------------------------------------------- ------------------------------------------------------------------------- End of include file FloatRange.hh -------------------------------------------------------------------------

#include "amma/VectRange.hh"
ostream & operator<<(ostream & s,const VectRangeC & range)

------------------------------------------------------------------------- ------------------------------------------------------------------------- End of include file VectRange.hh -------------------------------------------------------------------------

#include "amma/ristags.h"
int RisNativeEndian(void)


unsigned long RisSizeOf(risdir_t * rdp)


RISFILE * RisFileCreate(char * filename,int oflag,int pmode,risparams_t * rpp)


RISFILE * RisFileOpen(char * filename,int oflag)


RISFILE * RisFileAttach(int fid,int mode)


int RisFileStat(RISFILE * rfp,risparams_t * rpp)


int RisFileFlush(RISFILE * rfp)


int RisFileClose(RISFILE * rfp)


int RisFileGetRootDir(RISFILE * rfp,risdir_t * rdp)


int RisFileReadDirEntry(RISFILE * rfp,risdir_t * dir,risdir_t * rdp,int which)


int RisFileWriteDirEntry(RISFILE * rfp,risdir_t * dir,risdir_t * rdp,int which)


int RisFileSearchDir(RISFILE * rfp,risdir_t * dir,risdir_t * ret,rislabel_t tag)


long RisFileRead(RISFILE * rfp,risdir_t * rdp,vaddr_t buffer,long size)


long RisFileWrite(RISFILE * rfp,risdir_t * rdp,vaddr_t buffer)


#include "amma/VTRing.hh"
int operator==(TEdgeC & te1,TEdgeC & te2)


int operator!=(TEdgeC & te1,TEdgeC & te2)

------------------------------------------------------------------------- ------------------------------------------------------------------------- Remember that KList is a BIG object when using copy cons & = on VTVertexC ------------------------------------------------------------------------- Markers ------- A vertex, an edge and a face each have an integer id that can be used by the user. A face also has a byte called used. VTRingC: "VTFaceC.used" is never used. All 3 id's are used only by Print(), various Renumber*() and for debug printouts "VTVertexC.id" is used by RenumberVerts() SaveTri(), VTRingToPol VTBoundC: "VTVertexC.id" is used by SaveTri() //"VTEdgeC.id" is used by Print() "VTFaceC.id" must be set to 0..ntfaces-1 VTBackTrackC: as for VTBoundC "VTFaceC.id" is set to 0..ntfaces-1 -------------------------------------------------------------------------

VTRingC PolToVTRing(PolopsC pol,int nv = 3)

Calling purify and Check are advised before calling this

PolopsC VTRingToPol(VTRingC vt)

----------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------- End of include file VTRing.hh -----------------------------------------------------------------------------------------

#include "amma/sl_cast.hh"
t_vector operator*(double f,t_vector v)

A Casteljau set of tables for some nsimplex. nsimplex = 2=tri, 4=pent. 5=hex alldepths from depth_elev_min to depth_elev_max are accomodated. Note that the multiindices, Sabin net, etc are all 0 indexed, like Shoemake, not like Loop & DeRose

double tri_area(double u0,double v0,double u1,double v1,double u2,double v2)


double tri_area(t_tri t)


#include "amma/Slime.hh"
void VectorCopy(t_vector & a,const Vector3dC & b)


void VectorCopy(Vector3dC & a,const t_vector & b)


#include "amma/nn_comp.hh"
void direct_nn1toM(VectorSetC & set0,VectorSetC & set1,SArray1dC<IntT> & pn01)


void direct_nn1to1(VectorSetC & set0,VectorSetC & set1,SArray1dC<IntT> & pn01,SArray1dC<IntT> & pn0)

grid nn computation

void grid_nn1toM(VectorSetC & set0,VectorSetC & set1,SArray1dC<IntT> & nn01,int * ng,Vector3dC * lim,Vector3dC & size)

hash table nn computation

void hash_nn1toM(VectorSetC & set0,VectorSetC & set1,SArray1dC<IntT> & nn01,Vector3dC & size)

============================================================== HASH SUBROUTINES

void hash_test_element(RealT * pemin,IntT * pnodemin,Vector3dC & data,Hash3dC & hash,IntT i,IntT j,IntT k)


void hash_test_all_elements(RealT * pemin,IntT * pnodemin,Vector3dC & data,Hash3dC & hash)


void hash_test_recursive(RealT * pemin,IntT * pnodemin,Vector3dC & data,Hash3dC & hash)

==============================================================

#include "amma/Tri.hh"
ostream & operator<<(ostream & s,const TriC & t)

Saves the list into the output stream. -------------------------------------------------------------------- ================================================================== #include "amma/TriSet.icc" #include "amma/TriSet.icc"

#include "amma/BuckList.hh"
ostream & operator<<(ostream & s,Bucket3to2dC<DataC> & bucket)

Saves the list into the output stream. -------------------------------------------------------------------- =====================================================================

#include "amma/TriSet.hh"
ostream & operator<<(ostream & s,const TriSetC & t)
Output triset to a stream.

istream & operator>>(istream & s,const TriSetC & t)
Input triset from a stream.

ostream & operator<<(ostream & s,const BodyTriSetC & t)

Saves the list into the output stream. --------------------------------------------------------------------

#include "amma/BVoxSet.hh"
ostream & operator<<(ostream & s,BaseVoxSetC & t)

Saves the list into the output stream. -------------------------------------------------------------------- ============================================================ ============================================================ ============================================================

#include "amma/Vox.hh"
ostream & operator<<(ostream & s,const VoxC & t)


ostream & operator<<(ostream & s,const VoxNormalC & t)


ostream & operator<<(ostream & s,const VoxPointNormalC & t)


ostream & operator<<(ostream & s,const VoxBoundPointNormalC & t)

Saves the list into the output stream. -------------------------------------------------------------------- ================================================================== General definition of voxel data (voxel contains all data for NearestPoint evaluation)

#include "amma/HomTransMatC.hh"
HomTransMatC operator*(const RealT &,const HomTransMatC &)

RealT * HomTransMatC = HomTransMatC

Vector3dC operator*(const HomTransMatC &,const Vector3dC &)

HomTransMatC * Vector3dC = Vector3dC Ok. This is not mathematically correct : you can't multiply a 4x4 matrix with a 3d vector. Here, we make the assumption that the 3x3 vector has a 4th scale component which is equal to 1.

Vector4dC operator*(const HomTransMatC &,const Vector4dC &)

HomTransMatC * Vector4dC = Vector4dC

ostream & operator<<(ostream &,const HomTransMatC &)

ouput stream operator

istream & operator>>(istream &,HomTransMatC &)

input stream operator

#include "amma/Surf3DIO.hh"
void InitSurf3DIO()


void InitHomTransMatCIO()


void InitPolopsIO()


void InitTriSetIO()


void InitSurf3DCnv()


#include "amma/AMFigure.hh"
ostream & operator<<(ostream & s,const MotionSeqC &)


istream & operator>>(istream & s,const MotionSeqC &)

----------------------------------------------------------------------------- ----------------------------------------------------------------------------- WARNING: Problems are expected when the static root transf is not identity. For the moment we stick with T(c) T(Rs) T(Rd, td) T(-c) but we may change to T(c + td) T(Rs) T(Rd) T(-c) ??? To be safe the root static transformation should always be zero and the rcenter should also be zero.... AMFigureC is a BIG object The FigureC assume that the first segment is the root segment Everything is 0-indexed. It is understood that a child always is later than its parent in the array of segments. This is needed in routines like statictoglobal. Fortunately it is a common convention in data files. The internal storage of rotation is a 3x3 matrix. This means that some precision may be lost when converting from Euler angles and back. The error is thought to be very small, 1e-14. Of course the exact Euler sequence XYZ or ZYY is irretrievably lost The definitive documentation for this class is a LaTeX file held by AJS for now. Ideally you should not attempt to understand the acclaim stuff without this document! Length and angles units: The convention used by AMFigure is that all angles are radians and the length has no dimension or units. What is put in is what comes out. Working notes on acclaim I/O may be found at the bottom of this file. Testing - How do we know this code works ---------------------------------------- acclaim - i have a few doubts but these important tests are passed: = A skeleton/moseq/skin can be read and written. This validates a lot, in particular some of the Euler angles conversions = Converting all the joints to balls and moving the static to identity look exactly the same in boneshow. -----------------------------------------------------------------------------

#include "amma/GUI/Render.hh"
GUIRenderListC operator+(const GUIRenderC & o1,const GUIRenderC & o2)

////////////////////////////////////////////////

#include "amma/GUI/Widget.hh"
DListC<GUIWidgetC> operator+(DListC<GUIWidgetC> lst,const GUIWidgetC & widge)


#include "amma/GUI/MouseEvent.hh"
ostream & operator<<(ostream &,const GUIMouseEventC & me)
Print description of mouse event to stream.
///// GUICListEventC ////////////////////////////////////////////////

#include "amma/GUI/3D/gdkgl.h"
gint gdk_gl_query(void)


gchar * gdk_gl_get_info(void)


GdkVisual * gdk_gl_choose_visual(int * attrlist)


int gdk_gl_get_config(GdkVisual * visual,int attrib)


GdkGLContext * gdk_gl_context_new(GdkVisual * visual)


GdkGLContext * gdk_gl_context_share_new(GdkVisual * visual,GdkGLContext * sharelist,gint direct)


GdkGLContext * gdk_gl_context_attrlist_share_new(int * attrlist,GdkGLContext * sharelist,gint direct)


GdkGLContext * gdk_gl_context_ref(GdkGLContext * context)


void gdk_gl_context_unref(GdkGLContext * context)


gint gdk_gl_make_current(GdkDrawable * drawable,GdkGLContext * context)


void gdk_gl_swap_buffers(GdkDrawable * drawable)


void gdk_gl_wait_gdk(void)


void gdk_gl_wait_gl(void)


GdkGLPixmap * gdk_gl_pixmap_new(GdkVisual * visual,GdkPixmap * pixmap)


GdkGLPixmap * gdk_gl_pixmap_ref(GdkGLPixmap * glpixmap)


void gdk_gl_pixmap_unref(GdkGLPixmap * glpixmap)


gint gdk_gl_pixmap_make_current(GdkGLPixmap * glpixmap,GdkGLContext * context)


void gdk_gl_use_gdk_font(GdkFont * font,int first,int count,int list_base)


#include "amma/GUI/3D/gtkglarea.h"
GtkType gtk_gl_area_get_type(void)


GtkWidget * gtk_gl_area_new(int * attrList)


GtkWidget * gtk_gl_area_share_new(int * attrList,GtkGLArea * share)


gint gtk_gl_area_make_current(GtkGLArea * glarea)


gint gtk_gl_area_begingl(GtkGLArea * glarea)


void gtk_gl_area_endgl(GtkGLArea * glarea)


void gtk_gl_area_swapbuffers(GtkGLArea * glarea)


void gtk_gl_area_swap_buffers(GtkGLArea * glarea)


void gtk_gl_area_size(GtkGLArea * glarea,gint width,gint height)


#include "amma/GUI/3D/Object.hh"
ostream & operator<<(ostream & strm,const DObject3DC &)


ostream & operator<<(ostream & strm,const DObjectSet3DC &)


istream & operator>>(istream & strm,DObjectSet3DC &)


#include "amma/GUI/3D/Lines.hh"
ostream & operator<<(ostream & strm,const DLine3DC &)


istream & operator>>(istream & strm,DLine3DC &)


#include "amma/GUI/3D/Polops.hh"
ostream & operator<<(ostream & strm,const DPolops3DC &)


istream & operator>>(istream & strm,DPolops3DC &)


#include "amma/GUI/View.hh"
void InitStdView()

Include all standard Views.

void InitViewNum()

View numerical objects. (VectorC, MatrixC...)

void InitViewGeom()

View geometric objects. (Point2dC, PixelC)

void InitViewGeomEdge()

View geometric objects. (Line2dPPC)

void InitViewImage()

View images.

void InitViewGF()

View GF files.

#include "amma/INetProtocolC.hh"
int INetProtocolCF(void)


#include "amma/SocketsC.hh"
int SocketsCClient()


int SocketsCClients(void)
Socket client.
Open a client socket.

#include "amma/SocketServerC.hh"
int SocketServerCF(void)
Socket Server.
Class to setup a socket server.

#include "amma/ServerC.hh"
int ServerCF(void)


#include "amma/Studio/Switch.hh"
void InitStudioNSwitchIO()


#include "amma/Logic2/LExprType.hh"
ostream & operator<<(ostream &,const VLExprTypeC & et)

/////////////////////////////////////////////////////

#include "amma/Logic2/LExprLab.hh"
ostream & operator<<(ostream & out,const VLExprLabelC & obj)
Output to stream.

istream & operator>>(istream & out,VLExprLabelC & obj)
Input from stream.

#include "amma/Logic2/LSymb.hh"
ostream & operator<<(ostream & out,const VLSymbC & obj)
Output to stream.

istream & operator>>(istream & out,VLSymbC & obj)
Input from stream.

#include "amma/Logic2/LCompose.hh"
VLMinTermC operator*(const VLMinTermC & arg1,const VLSymbC & arg2)


VLMinTermC operator*(const VLMinTermC & arg1,const VLMinTermC & arg2)


VLMinTermC operator*(const VLSymbC & arg1,const VLSymbC & arg2)


VLMinTermC operator*(const VLSymbC & arg1,const VLMinTermC & arg2)


VLMinTermSOPC operator+(const VLMinTermC & arg2,const VLSymbC & Symb)


VLMinTermSOPC operator+(const VLSymbC & Symb1,const VLSymbC & Symb2)


VLMinTermC operator!(const VLSymbC & arg1)


VLMinTermSOPC operator+(const VLSymbC & Symb,const VLMinTermSOPC & arg2)


#include "amma/Logic2/LBindLst.hh"
ostream & operator<<(ostream & out,const VLBindLst & obj)
Stream operator.

#include "amma/Logic2/LSpace.hh"
ostream & operator<<(ostream & x,const VLSpaceC & space)

Send to output

istream & operator>>(istream & x,VLSpaceC & space)

Send to output ///////////////////////////////////////////////////////

#include "amma/Logic2/DeciElem.hh"
ostream & operator<<(ostream &,const VLDeciListElemC & obj)


istream & operator<<(istream &,VLDeciListElemC & obj)

/////////////////////////////////////////////////////////

#include "amma/Logic2/CandDescrim.hh"
ostream & operator<<(ostream & out,const VLCandidateDescrimC & obj)
Output to stream.

#include "amma/Logic2/DLModelAction.hh"
ostream & operator<<(ostream & out,const VLModelDLActionC & obj)
Output to stream.

istream & operator>>(istream & in,VLModelDLActionC & obj)
Input from stream.

#include "amma/Logic2/Executor.hh"
VLExecutorC<ActionT,StateT> & operator>>(const DPIPortC<VLPlanC<ActionT,StateT>> & from,VLExecutorC<ActionT,StateT> & to)

/////////////////////////////////////

#include "amma/colorquant.h"
char * nameAry(ARY * ary)


char * infoAry(ARY * ary)


int isEqBoundsAry(ARY * a1,ARY * a2)


int isInAry(ARY * ary,int x,int y)


void * consAry1(int firstrow,int lastrow,int firstcol,int lastcol,int elSize,void * mem)


void destAry(void * ary)


ARY * makary(int fr,int lr,int fc,int lc,t_aryEl matrix_type)


ARY * makmemary(int firstrow,int lastrow,int firstcol,int lastcol,t_aryEl arytype,void * addr)


CARY * makCary(int rows,int cols)


BARY * makBary(int rows,int cols)


SARY * makSary(int rows,int cols)


IARY * makIary(int rows,int cols)


FARY * makFary(int rows,int cols)


DARY * makDary(int rows,int cols)


PARY * makPary(int rows,int cols)


USARY * makUSary(int rows,int cols)


RGBARY * makRGBary(int rows,int cols)


XRGBARY * makXRGBary(int rows,int cols)


RGBXARY * makRGBXary(int rows,int cols)


YUVARY * makYUVary(int rows,int cols)


FRGBARY * makFRGBary(int rows,int cols)


RGIARY * makRGIary(int rows,int cols)


void InitialiseBary(BARY * array,unsigned char value)


void InitialiseIary(IARY * array,int value)


void InitialiseUSary(USARY * array,unsigned short int ptr)


void InitialiseFary(FARY * array,float value)


void InitialiseDary(DARY * array,double value)


void InitialisePary(PARY * array,void * ptr)


ARY * Px2Ary(char * filename)


BARY * P5pgm2Bary(char * filename)


BARY * P4pbm2Bary(char * filename)


FARY * Pgm2Fary(char * filename)


FARY * P5pgm2Fary(char * filename)


RGBARY * P6ppm2RGBary(char * filename)


RGBARY * MoveP6ppm2RGBary(RGBARY * RGBary,char * filename)


YUVARY * P6ppm2YUVary(char * filename)


FILE * ReadP5header(char * filename,int * cols,int * rows)


int Ary2Px(ARY * ary,char * filename)


void * Bary2P5pgm(BARY * image,char * filename)


void * Bary2P4pbm(BARY * image,char * filename)


void * RGBary2P6ppm(RGBARY * image,char * filename)


int XRGBary2P6ppm(XRGBARY * image,char * filename)


int RGBXary2P6ppm(RGBXARY * image,char * filename)


void * YUVary2P6ppm(YUVARY * image,char * filename)


void * Bary2P5pgmCm(BARY * image,char * filename,char * comment)


void * Bary2P4pbmCm(BARY * image,char * filename,char * comment)


void * RGBary2P6ppmCm(RGBARY * image,char * filename,char * comment)


IARY * P2pgm2Iary(char * filename)


void * Iary2P2pgm(IARY * ary,char * filename)


IARY * MoveP2pgm2Iary(IARY * ary,char * filename)


void CutFary2P5pgm(FARY * image,char * filename)


void ScaleFary2P5pgm(FARY * image,char * filename)


void ScaleMinMaxFary(FARY * image,float min,float max)


BARY * ScaleFary2Bary(FARY * fary)


BARY * ScaleMinMaxFary2Bary(FARY * fary)


FARY * P5pgmRoi2Fary(char * filename,int * roi,int fullImage,int extend)


FARY * P5pgmRoi2Fary1(FILE * file,int cols,int rows,int * roi,int fullImage,int extend,void * mem)


const void * WriteAry(const void * ary,char * filename)


void * ReadAry(char * filename)


void ReadInAry(ARY *,char * filename)


void printFary(FARY * ary)


void printIary(IARY * ary)


ARY * CopyAry(ARY * ary)


void ScaleFillBary(BARY * dest,BARY * src,float f_zoom1,float f_zoom2)


void InitBorderFary(FARY * image,int border,int pixel)


FARY * ExtendFary(FARY * in_image,int border)


float MinFary(FARY * ary)


float MaxFary(FARY * ary)


void ScaleMaxFary(FARY * ary,int requested_max)


void SetYoff(int off)


t_frgb Yuv2Frgb(t_yuv p)


t_rgb Yuv2Rgb(t_yuv p)


t_rgI Yuv2Rgi(t_yuv yuv)


t_rgI Frgb2Rgi(t_frgb frgb)


t_rgI Rgb2Rgi(t_rgb rgb)


t_rgb Frgb2Rgb(t_frgb frgb)


t_frgb Rgb2Frgb(t_rgb frgb)


t_rg Frgb2Rg(t_frgb frgb)


RGBARY * YUVary2RGBary(YUVARY * ary)


FRGBARY * YUVary2FRGBary(YUVARY * ary)


RGIARY * YUVary2RGIary(YUVARY * ary)


BARY * Fary2Bary(FARY * fary)


BARY * Iary2Bary(IARY * in)


RGBARY * XRGBary2RGBary(XRGBARY * image)


RGBARY * XBGRary2RGBary(XRGBARY * xrgb)


RGBARY * RGBXary2RGBary(RGBXARY * rgbx)


void RGBXaryToRGBary(RGBXARY * rgbx,RGBARY * rgb)


void RGBary2Fary3(RGBARY * col_image,FARY * out[])


void RGBary2FaryArr3(RGBARY * col_image,FARY * red,FARY * green,FARY * blue)


RGBARY * Fary3_2RGBary(FARY * out[])


RGBARY * FaryArr3_2RGBary(FARY * red,FARY * green,FARY * blue)


FARY * RGBary2Y(RGBARY * image)


SARY * Bary2Sary(BARY * bary)


BARY * Sary2Bary(SARY * sary)


BARY * USary2Bary(USARY * usary)


void USaryToBary(USARY * usary,BARY * bary)


void LastPnmHeader(int * cols,int * rows,int * levels)


void ExitOnAryError(void)


void ReturnOnAryError(void)


#include "amma/visualdb/ImageSet.hh"
ostream & operator<<(ostream & s,const ImageRegionC & out)
output stream operator

istream & operator>>(istream & s,ImageRegionC & in)
input stream operator

#include "amma/visualdb/RegionVector.hh"
ostream & operator<<(ostream & s,const RegionVectorC & out)
output stream operator

istream & operator>>(istream & s,RegionVectorC & in)
input stream operator

#include "amma/visualdb/MeanShiftAlg.hh"
istream & operator>>(istream & s,MeanShiftAlgBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const MeanShiftAlgC & out)
output stream operator

istream & operator>>(istream & s,MeanShiftAlgC & in)
input stream operator

#include "amma/visualdb/IdbCanvasData.hh"
istream & operator>>(istream & s,IdbCanvasDataBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const IdbCanvasDataC & out)
output stream operator

istream & operator>>(istream & s,IdbCanvasDataC & in)
input stream operator

#include "amma/visualdb/ImageGrid.hh"
istream & operator>>(istream & s,ImageGridBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const ImageGridC & out)
output stream operator

istream & operator>>(istream & s,ImageGridC & in)
input stream operator

#include "amma/visualdb/QueryOption.hh"
istream & operator>>(istream & s,QueryOptionBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const QueryOptionC & out)
output stream operator

istream & operator>>(istream & s,QueryOptionC & in)
input stream operator

#include "amma/visualdb/QueryCanvasData.hh"
istream & operator>>(istream & s,QueryCanvasDataBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const QueryCanvasDataC & out)
output stream operator

istream & operator>>(istream & s,QueryCanvasDataC & in)
input stream operator

#include "amma/visualdb/QueryControl.hh"
istream & operator>>(istream & s,QueryControlBodyC & in)
Put a brief description of your class here
Put a more detailed description of your class handle here. You use embedded html to make it clearer in the html documentation

ostream & operator<<(ostream & s,const QueryControlC & out)
output stream operator

istream & operator>>(istream & s,QueryControlC & in)
input stream operator

#include "amma/LabelImage.hh"
istream & operator>>(istream & s,LabelImageC<PixTypeT> & in)


ostream & operator<<(ostream & s,const LabelImageC<PixTypeT> & out)
Stream constructor

#include "amma/VecImage.hh"
istream & operator>>(istream & s,VecImageC & in)
input stream operator

#include "amma/Pizza2C.hh"
ostream & operator<<(ostream & s,const Pizza2C & pizza)


#include "amma/Pizza3C.hh"
ostream & operator<<(ostream & s,const Pizza3C & pizza)


#include "fftw/fftw-int.h"
fftw_twiddle * fftw_create_twiddle(int n,const fftw_codelet_desc * d)


void fftw_destroy_twiddle(fftw_twiddle * tw)


void fftw_strided_copy(int,fftw_complex *,int,fftw_complex *)


void fftw_executor_simple(int,const fftw_complex *,fftw_complex *,fftw_plan_node *,int,int)


fftwnd_plan fftwnd_create_plan_aux(int rank,const int * n,fftw_direction dir,int flags)


fftw_plan * fftwnd_new_plan_array(int rank)


fftw_plan * fftwnd_create_plans_generic(fftw_plan * plans,int rank,const int * n,fftw_direction dir,int flags)


fftw_plan * fftwnd_create_plans_specific(fftw_plan * plans,int rank,const int * n,const int * n_after,fftw_direction dir,int flags,fftw_complex * in,int istride,fftw_complex * out,int ostride)


int fftwnd_work_size(int rank,const int * n,int flags,int ncopies)


void fftwnd_aux(fftwnd_plan p,int cur_dim,fftw_complex * in,int istride,fftw_complex * out,int ostride,fftw_complex * work)


void fftwnd_aux_howmany(fftwnd_plan p,int cur_dim,int howmany,fftw_complex * in,int istride,int idist,fftw_complex * out,int ostride,int odist,fftw_complex * work)


int fftw_wisdom_lookup(int n,int flags,fftw_direction dir,enum fftw_wisdom_category category,int istride,int ostride,enum fftw_node_type * type,int * signature,int replace_p)


void fftw_wisdom_add(int n,int flags,fftw_direction dir,enum fftw_wisdom_category cat,int istride,int ostride,enum fftw_node_type type,int signature)


double fftw_estimate_node(fftw_plan_node * p)


fftw_plan_node * fftw_make_node_notw(int size,const fftw_codelet_desc * config)


fftw_plan_node * fftw_make_node_real2hc(int size,const fftw_codelet_desc * config)


fftw_plan_node * fftw_make_node_hc2real(int size,const fftw_codelet_desc * config)


fftw_plan_node * fftw_make_node_twiddle(int n,const fftw_codelet_desc * config,fftw_plan_node * recurse,int flags)


fftw_plan_node * fftw_make_node_hc2hc(int n,fftw_direction dir,const fftw_codelet_desc * config,fftw_plan_node * recurse,int flags)


fftw_plan_node * fftw_make_node_generic(int n,int size,fftw_generic_codelet * codelet,fftw_plan_node * recurse,int flags)


fftw_plan_node * fftw_make_node_rgeneric(int n,int size,fftw_direction dir,fftw_rgeneric_codelet * codelet,fftw_plan_node * recurse,int flags)


int fftw_factor(int n)


fftw_plan_node * fftw_make_node(void)


fftw_plan fftw_make_plan(int n,fftw_direction dir,fftw_plan_node * root,int flags,enum fftw_node_type wisdom_type,int wisdom_signature)


void fftw_use_plan(fftw_plan p)


void fftw_use_node(fftw_plan_node * p)


void fftw_destroy_plan_internal(fftw_plan p)


fftw_plan fftw_pick_better(fftw_plan p1,fftw_plan p2)


fftw_plan fftw_lookup(fftw_plan * table,int n,int flags)


void fftw_insert(fftw_plan * table,fftw_plan this_plan,int n)


void fftw_make_empty_table(fftw_plan * table)


void fftw_destroy_table(fftw_plan * table)


void fftw_complete_twiddle(fftw_plan_node * p,int n)


fftw_plan_node * fftw_make_node_rader(int n,int size,fftw_direction dir,fftw_plan_node * recurse,int flags)


fftw_time fftw_gettimeofday_get_time(void)


fftw_time fftw_gettimeofday_time_diff(fftw_time t1,fftw_time t2)


fftw_time get_Mac_microseconds(void)


fftw_time fftw_time_diff(fftw_time t1,fftw_time t2)


unsigned long GetPerfTime(void)


double GetPerfSec(double ticks)


double SECONDR(void)


long clock(void)


#include "fftw/fftw.h"
fftw_plan fftw_create_plan_specific(int n,fftw_direction dir,int flags,fftw_complex * in,int istride,fftw_complex * out,int ostride)


fftw_plan fftw_create_plan(int n,fftw_direction dir,int flags)


void fftw_print_plan(fftw_plan plan)


void fftw_destroy_plan(fftw_plan plan)


void fftw(fftw_plan plan,int howmany,fftw_complex * in,int istride,int idist,fftw_complex * out,int ostride,int odist)


void fftw_one(fftw_plan plan,fftw_complex * in,fftw_complex * out)


void fftw_die(const char * s)


void * fftw_malloc(size_t n)


void fftw_free(void * p)


void fftw_check_memory_leaks(void)


void fftw_print_max_memory_usage(void)


size_t fftw_sizeof_fftw_real(void)


void fftw_forget_wisdom(void)


void fftw_export_wisdom(void (*)(FuncArgList) emitter,void * data)


fftw_status fftw_import_wisdom(ScopePath (*)(FuncArgList) g,void * data)


void fftw_export_wisdom_to_file(FILE * output_file)


fftw_status fftw_import_wisdom_from_file(FILE * input_file)


char * fftw_export_wisdom_to_string(void)


fftw_status fftw_import_wisdom_from_string(const char * input_string)


void fftw_fprint_plan(FILE * f,fftw_plan plan)


fftwnd_plan fftw2d_create_plan(int nx,int ny,fftw_direction dir,int flags)


fftwnd_plan fftw3d_create_plan(int nx,int ny,int nz,fftw_direction dir,int flags)


fftwnd_plan fftwnd_create_plan(int rank,const int * n,fftw_direction dir,int flags)


fftwnd_plan fftw2d_create_plan_specific(int nx,int ny,fftw_direction dir,int flags,fftw_complex * in,int istride,fftw_complex * out,int ostride)


fftwnd_plan fftw3d_create_plan_specific(int nx,int ny,int nz,fftw_direction dir,int flags,fftw_complex * in,int istride,fftw_complex * out,int ostride)


fftwnd_plan fftwnd_create_plan_specific(int rank,const int * n,fftw_direction dir,int flags,fftw_complex * in,int istride,fftw_complex * out,int ostride)


void fftwnd_destroy_plan(fftwnd_plan plan)


void fftwnd_fprint_plan(FILE * f,fftwnd_plan p)


void fftwnd_print_plan(fftwnd_plan p)


void fftwnd(fftwnd_plan plan,int howmany,fftw_complex * in,int istride,int idist,fftw_complex * out,int ostride,int odist)


void fftwnd_one(fftwnd_plan p,fftw_complex * in,fftw_complex * out)



Documentation by CxxDoc: Fri Mar 16 21:16:36 2001
Centre for Vision, Speech & Signal Processing