User Documentation
RAVL, Recognition And Vision Library
DEVELOP HOME PAGE CLASS LIST CONTENTS
 

namespace RavlN
Ravl namespace

User Level:Normal
Library: RavlCore

Comments:

This namespace contains all the core ravl functionality.

Child Classes:

#include "Ravl/BinStream.hh"

BinOStreamC Machine independant binary output stream.
BinIStreamC Machine independant binary input stream.
#include "Ravl/Pair.hh"

PairC Pair of homogenious objects
#include "Ravl/Index.hh"

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

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

RCHandleC Base class for handles to reference counter objects
RCBodyC Base class for all reference counted objects
#include "Ravl/SmartPtr.hh"

SmartPtrC Smart pointer.
#include "Ravl/Exception.hh"

ExceptionC RAVL Exception.
ExceptionErrorCastC Casting exception class.
ExceptionOperationFailedC Exception: Operation Failed
ExceptionOutOfRangeC Exception: Out of Range
ExceptionAssertionFailedC Exception: Assertion Failed
ExceptionNumericalC Exception: Numerical exception.
ExceptionEndOfStreamC Exception thrown when end of stream found.
#include "Ravl/Trigger.hh"

TriggerC Signal Event handle
#include "Ravl/Calls.hh"

CallFunc0C Signal Event handle
CallFunc1C Signal Event handle
CallFunc2C Signal Event handle
CallFunc3C Signal Event handle
CallFunc4C Signal Event handle
CallFunc5C Signal Event handle
#include "Ravl/HandleRefCounter.hh"

HandleRefCounterC Handle based reference counter.
HandleRefCounterBodyC Handle based reference counter.
#include "Ravl/MTLocks.hh"

MTReadLockC Lock system for reading.
MTWriteLockC Lock system for writing.
#include "Ravl/Stream.hh"

OStreamC Standard output streams with reference counting.
IStreamC Standard input streams with reference counting.
#include "Ravl/StrStream.hh"

StrOStreamC Output stream to memory.
StrIStreamC Input stream from memory.
#include "Ravl/BitStream.hh"

BitIStreamC Input bit stream
BitOStreamC Output bit stream.
#include "Ravl/IndexRange1d.hh"

IndexRangeC 1D index range of array
#include "Ravl/Index3d.hh"

Index3dC Index of a 3-D array
#include "Ravl/IndexRange2d.hh"

IndexRange2dC An index range of a 2D array
#include "Ravl/RCWrap.hh"

RCWrapAbstractC Abstract wrapped object handle.
RCWrapC RCWrapper handle.
#include "Ravl/Index2d.hh"

Index2dC 2 Dimensional index
#include "Ravl/IntC.hh"

IntC Integer with a default constructor that assigns it a value of 0
UIntC unsigned integer with a default constructor that assigns it a value of 0.
#include "Ravl/TFVector.hh"

TFVectorC Fixed size vector.
#include "Ravl/TFMatrix.hh"

TFMatrixC Fixed size NxM matrix.
#include "Ravl/Empty.hh"

EmptyC Empty data class.
#include "Ravl/RCAbstract.hh"

RCAbstractC Abstract handle class for any object derived from RCBodyVC.
#include "Ravl/CallMethods.hh"

CallMethod0C Signal Event handle
CallMethod1C Signal Event handle
CallMethod2C Signal Event handle
CallMethod3C Signal Event handle
CallMethod4C Signal Event handle
CallMethod5C Signal Event handle
#include "Ravl/CallMethodRefs.hh"

CallMethodRef0C Signal Event handle
CallMethodRef1C Signal Event handle
CallMethodRef2C Signal Event handle
CallMethodRef3C Signal Event handle
CallMethodRef4C Signal Event handle
CallMethodRef5C Signal Event handle
#include "Ravl/FIndex.hh"

FIndexC Fixed sized Index
#include "Ravl/IndexRange3d.hh"

IndexRange3dC An index range of a 3D array
#include "Ravl/RealC.hh"

RealC Real value with a default constructor that assigns it a value of 0.
#include "Ravl/SubIndexRange2dIter.hh"

SubIndexRange2dIterC Slide a rectangular window over a larger rectangle.
#include "Ravl/RealRange1d.hh"

RealRangeC 1D Range of real values.
#include "Ravl/SubIndexRange3dIter.hh"

SubIndexRange3dIterC Slide a rectangular window over a larger rectangle.
#include "Ravl/RealRange2d.hh"

RealRange2dC An index range of a 2D array
#include "Ravl/RCHandleV.hh"

RCHandleVC Handle from objects derived from RCBodyVC.
RCBodyVC Base class for all reference counted objects, where derivation is expected.
#include "Ravl/TimeCode.hh"

TimeCodeC Time code.
#include "Ravl/RealRange3d.hh"

RealRange3dC Range of real values in 3D
#include "Ravl/IndexRange2dIter.hh"

IndexRange2dIterC Iterate through a 2d range.
#include "Ravl/IndexRange3dIter.hh"

IndexRange3dIterC Iterate through a 3d range.
#include "Ravl/fdstreambuf.hh"

basic_fdbuf
#include "Ravl/fdstream.hh"

basic_ifdstream Basic input from a fd stream.
basic_ofdstream Derivation of general output streams, specific to unix file handles.
basic_fdstream Basic fdstream.
#include "Ravl/CompositeBuffer.hh"

CompositeBufferC Composite buffer.
#include "Ravl/BufferAccess.hh"

BufferAccessC Basic unsized buffer.
#include "Ravl/BfAccIter.hh"

BufferAccessIterC Iterator for access buffer.
#include "Ravl/BfAccIter2.hh"

BufferAccessIter2C Iterate 2 buffers at the same time.
#include "Ravl/BfAccIter3.hh"

BufferAccessIter3C Iterator for 3 buffers.
#include "Ravl/BfAccIter4.hh"

BufferAccessIter4C Iterator for 3 buffers.
#include "Ravl/BfAcc2Iter.hh"

BufferAccess2dIterC 2d buffer iterator.
#include "Ravl/BfAcc2Iter2.hh"

BufferAccess2dIter2C Iterate through a 2d buffer.
#include "Ravl/BfAcc2Iter3.hh"

BufferAccess2dIter3C Iterate through a 2d buffer.
#include "Ravl/BfAcc2Iter4.hh"

BufferAccess2dIter4C Iterate through a 2d buffer.
#include "Ravl/Slice1dIter.hh"

Slice1dIterC Slice iterator.
#include "Ravl/Slice1dIter2.hh"

Slice1dIter2C Slice iterator.
#include "Ravl/Slice1dIter3.hh"

Slice1dIter3C Slice iterator.
#include "Ravl/Slice1d.hh"

Slice1dC Slice through array
#include "Ravl/BfAcc3Iter.hh"

BufferAccess3dIterC 3D buffer iterator.
#include "Ravl/BfAcc3Iter2.hh"

BufferAccess3dIter2C 3D buffer iterator.
#include "Ravl/BfAcc3Iter3.hh"

BufferAccess3dIter3C 3D buffer iterator.
#include "Ravl/RBfAcc3d.hh"

RangeBufferAccess3dC Access to 3d buffer.
#include "Ravl/SDArray1d.hh"

SDArray1dC1D Simple Dynamic Array.
#include "Ravl/SArr1Iter.hh"

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

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

SArray1dC A simple 1 dimensional array
#include "Ravl/SArr1Iter2.hh"

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

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

SArray1dIter4C Quad SArray1d iterator.
#include "Ravl/Array2d.hh"

Array2dC 2 Dimensional array
#include "Ravl/SArr2Iter.hh"

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

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

SArray2dIter2C Duel SArray2dC iterator.
#include "Ravl/SArr2Iter3.hh"

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

SArray3dIterC SArray3dC iterator.
#include "Ravl/SArray3d.hh"

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

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

SArray3dIter3C Triple SArray3dC iterator.
#include "Ravl/Array1dIter.hh"

Array1dIterC Array1dC iterator.
#include "Ravl/Array1dIter2.hh"

Array1dIter2C dual Array1dC iterator.
#include "Ravl/Array1dIter3.hh"

Array1dIter3C triple Array1dC iterator.
#include "Ravl/Array1dIter4.hh"

Array1dIter4C triple Array1dC iterator.
#include "Ravl/Array2dIter.hh"

Array2dIterC Array1dC iterator.
#include "Ravl/Array2dIter2.hh"

Array2dIter2C dual Array2dC iterator.
#include "Ravl/Array2dIter3.hh"

Array2dIter3C triple Array2dC iterator.
#include "Ravl/Array2dIter4.hh"

Array2dIter4C triple Array2dC iterator.
#include "Ravl/Array3d.hh"

Array3dC 3 Dimensional array
#include "Ravl/Array3dIter.hh"

Array3dIterC Array1dC iterator.
#include "Ravl/Array3dIter2.hh"

Array3dIter2C dual Array3dC iterator.
#include "Ravl/Array3dIter3.hh"

Array3dIter3C triple Array3dC iterator.
#include "Ravl/Array2dSqr2Iter.hh"

Array2dSqr2IterC Iterator which slides a 2x2 window over an array.
#include "Ravl/Array2dSqr2Iter2.hh"

Array2dSqr2Iter2C Iterator which slides a 2x2 window over two arrays.
#include "Ravl/Array2dSqr3Iter.hh"

Array2dSqr3IterC Iterate through an array accessing 3x3 area.
#include "Ravl/Array2dSqr31Iter2.hh"

Array2dSqr31Iter2C Iterate through an array accessing 3x3 area.
#include "Ravl/Array2dSqr311Iter3.hh"

Array2dSqr311Iter3C Iterate through an array accessing 3x3 area.
#include "Ravl/Array2dSqr3111Iter4.hh"

Array2dSqr3111Iter4C Iterate through an array accessing 3x3 area.
#include "Ravl/Array2dSqr3311Iter4.hh"

Array2dSqr3311Iter4C Iterate through an array accessing 3x3 area.
#include "Ravl/Stack.hh"

StackC Templated, dynamicly sized stack.
#include "Ravl/StackIter.hh"

StackIterC StackC iterator.
#include "Ravl/Tuple2.hh"

Tuple2C Class containing two other arbitrary classes
#include "Ravl/Tuple3.hh"

Tuple3C Class containing 3 other classes.
#include "Ravl/BlkStackIter.hh"

BlkStackIterC BlkStackC iterator.
#include "Ravl/BlkStack.hh"

SBlkC
BlkStackC Block stack.
#include "Ravl/Tuple4.hh"

Tuple4C Class containing 4 other classes.
#include "Ravl/BinIter.hh"

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

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

BinListC Binned table of lists.
#include "Ravl/PriQueue.hh"

PriQueueC Fixed size priority queue.
#include "Ravl/PriQueueL.hh"

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

BlkQueueC Basic Queue.
#include "Ravl/FixedQueue.hh"

FixedQueueC Fixed size circular queue.
FixedQueueIterC Iterate through contents of the queue.
#include "Ravl/BinaryTreeUpIter.hh"

BinaryTreeUpIterC Iterate up through a binary tree.
#include "Ravl/BinaryTreeDownIter.hh"

BinaryTreeDownIterC Iterate down through a binary tree.
#include "Ravl/BinaryTree.hh"

BinaryTreeC Binary tree.
#include "Ravl/AVLTree.hh"

AVLTreeOverWriteC
AVLTreeC AVL Tree.
#include "Ravl/HashTree.hh"

HashTreeC Tree of hashtables.
HashTreeNodeC Base class for tree's.
HashTreeIterC Iterate through a tree.
#include "Ravl/DLink.hh"

DLinkC Double-link element.
DLinkDataC Double-link list element with data.
DLinkHeadC Double-link list head.
#include "Ravl/DLIter.hh"

DLIterC Double linked list iterator.
#include "Ravl/DList.hh"

DListC Double linked List
#include "Ravl/CDLIter.hh"

ConstDLIterC Constant iterator.
#include "Ravl/InDList.hh"

IntrDListC Double-linked circular list
#include "Ravl/InDLIter.hh"

IntrDLIterC Intrinsic list iterator.
#include "Ravl/HashIter.hh"

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

HashC General hash table.
#include "Ravl/BiHash.hh"

BiHashIterC Bi-directional hash table iterator
BiHashC Bi-directional hash table.
#include "Ravl/RCHash.hh"

RCHashC Reference counted auto-resizing hash table.
#include "Ravl/HSet.hh"

HSetIterC Set Iterator.
HSetC Set of objects.
#include "Ravl/Graph.hh"

GraphC Templated graphs.
#include "Ravl/GraphNode.hh"

GraphNodeIterC Node iterator.
GraphNodeHC Node handle.
#include "Ravl/GraphEdge.hh"

GraphEdgeIterC Edge iterator.
#include "Ravl/GraphLinearIter.hh"

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

GraphAdjIterC Adjacency iterator.
#include "Ravl/GraphConnIt.hh"

GraphConnIterC Connected node iterator.
#include "Ravl/BLink.hh"

BLinkC Link in list.
#include "Ravl/BListIter.hh"

BListIterC BList iterator.
#include "Ravl/BList.hh"

BListC Branching list.
#include "Ravl/BHashIter.hh"

BHashIterC
#include "Ravl/BStack.hh"

BStackC Stack.
#include "Ravl/BDAGraph.hh"

BDAGraphC Directed acyclic graph.
#include "Ravl/BGraphEdgeIter.hh"

BGraphAdjIterC BGraph Adjacency iterator.
#include "Ravl/BGraphNode.hh"

BGraphNodeHC BGraph node handle
#include "Ravl/BGraphLinearIter.hh"

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

BGraphC Branching graph.
#include "Ravl/BGraphNodeIter.hh"

BGraphNodeIterC Interate through nodes in a BGraph.
#include "Ravl/BGraphEdge.hh"

BGraphEdgeHC BGraph edge handle.
#include "Ravl/RandomGauss.hh"

RandomGaussC Generate random number with a gaussian distribution.
#include "Ravl/Angle.hh"

AngleC This class is designed to deal with angles in radians.
#include "Ravl/Complex.hh"

ComplexC Complex algebra
#include "Ravl/StringList.hh"

StringListC List of StringC's
#include "Ravl/Option.hh"

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

TypeNameC Register typename.
#include "Ravl/BufStream.hh"

BufOStreamC Output stream to memory.
BufIStreamC Input stream from memory.
#include "Ravl/SubStringList.hh"

SubStringListC List of SubStringC's
#include "Ravl/XMLStream.hh"

ExceptionInvalidStreamC Exception issued when an parse error occurs.
XMLAttributeC Class for handling XML attributes.
XMLElementC Information about the current element being processed.
XMLBaseC Common XML operations.
XMLIStreamC XML Input Stream.
XMLOStreamC XML Output Stream.
#include "Ravl/XMLTree.hh"

XMLTreeC XML parse tree.
#include "Ravl/CollectionIter.hh"

CollectionIterC Collection iterator.
CollectionConstIterC Collection iterator.
#include "Ravl/Collection.hh"

CollectionC Collection of data
#include "Ravl/DArray1dIter.hh"

DArray1dIterC Dynamic array iterator.
#include "Ravl/DArray1dIter2.hh"

DArray1dIter2C Dynamic array iterator.
#include "Ravl/DArray1dIter3.hh"

DArray1dIter3C Dynamic array iterator.
#include "Ravl/VirtualConstructor.hh"

VirtualConstructorC Virtual constructor base class.
VirtualConstructorInstC Virtual constructor instance.
#include "Ravl/FunctionRegister.hh"

RegisterFuncionC Save function pointer. Register function pointer.
#include "Ravl/DP/Entity.hh"

DPEntityC Data processing entity.
#include "Ravl/DP/Port.hh"

DataNotReadyC Exception, Data Not Ready.
DPIPortC Input port.
DPOPortC Output port.
#include "Ravl/DP/Process.hh"

DPProcessBaseC Process handle base.
DPProcessC Templated process handle.
#include "Ravl/DP/SPort.hh"

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

DPSeekCtrlAttachC Seek Control attach.
DPISPortAttachC Seek control attach.
DPOSPortAttachC Seek control attach.
#include "Ravl/DP/StreamOp.hh"

DPStreamOpC Abstract stream operation.
DPIStreamOpC Stream operation handle class.
DPOStreamOpC Stream operation handle class.
#include "Ravl/DP/IOJoin.hh"

DPIOPortJoinC Join an IPort and a OPort
#include "Ravl/DP/ProcOStream.hh"

DPProcOStreamC Wrapped Proccess handle.
#include "Ravl/DP/ProcIStream.hh"

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

DPOFileC File output stream.
DPIFileC File input stream.
#include "Ravl/DP/BinFileIO.hh"

DPOBinFileC Binary file output stream.
DPIBinFileC Binary file input stream.
#include "Ravl/DP/FuncP2Proc.hh"

DPFuncP2ProcC Function ptr to process handle.
#include "Ravl/DP/ProcCompose.hh"

DPComposeProcessC Mix two processes.
#include "Ravl/DP/ProcInfo.hh"

DPProcInfoC Process information.
#include "Ravl/DP/Converter.hh"

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

DPTypeInfoC Type information handle.
DPTypeInfoInstC Type information instance body.
#include "Ravl/DP/Pipes.hh"

DPIPipeBaseC Pipe base.
DPOPipeBaseC Pipe base body.
#include "Ravl/DP/FileFormat.hh"

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

FileFormatDescC File Format descriptor.
#include "Ravl/DP/FileFormatStream.hh"

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

FileFormatBinStreamC Binary stream file format.
#include "Ravl/DP/FileFormatGen.hh"

FileFormatGenericC Generic format loader.
#include "Ravl/DP/TypeConverter.hh"

TypeConverterC Type converter.
#include "Ravl/DP/FileFormatRegistry.hh"

FileFormatRegistryC Registry of file formats.
#include "Ravl/DP/Func2Stream.hh"

DPFuncIStreamC Wrapped function input stream.
DPFuncOStreamC Wrapped function output stream.
#include "Ravl/DP/IOConnect.hh"

DPIOConnectC Connect some IOPorts.
#include "Ravl/DP/IOTap.hh"

DPIOTapC Tap handle.
#include "Ravl/DP/IFailOver.hh"

DPIFailOverC Fail over input switch.
#include "Ravl/DP/Multiplex.hh"

DPMultiplexC Multiplex an operation.
#include "Ravl/DP/SplitO.hh"

DPSplitOC Output port Splitter handle.
#include "Ravl/DP/Event.hh"

DPEventC Event body.
#include "Ravl/DP/EventSet.hh"

DPEventSetC Set of events.
#include "Ravl/DP/Method2Proc.hh"

DPMethod2ProcC Methodtion handle.
#include "Ravl/DP/MethodIO.hh"

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

DPPlugBaseC Input plug base.
DPIPlugBaseC Input plug base.
DPOPlugBaseC Input plug base.
DPIPlugC Plug.
DPOPlugC Plug.
#include "Ravl/DP/ContainerIO.hh"

DPIContainerC Input from list.
DPOContainerC Output to a container.
DPOContainerOverwriteC Output to a container.
#include "Ravl/DP/Tap.hh"

DPTapC Tap process.
#include "Ravl/DP/StreamProcess.hh"

DPStreamProcessC Stream Process.
#include "Ravl/DP/Process31.hh"

DPProcess31BodyC Process body with 2 inputs and one output.
DPProcess31C Process body with 2 inputs and one output.
#include "Ravl/DP/StreamOp21.hh"

DPIStreamOp21C Stream operation handle class.
#include "Ravl/DP/StreamOp31.hh"

DPIStreamOp31C Stream operation handle class.
#include "Ravl/DP/Process21.hh"

DPProcess21BodyC Process body with 2 inputs and one output.
DPProcess21C Process body with 2 inputs and one output.
#include "Ravl/DP/OffsetScale.hh"

DPOffsetScaleC OffsetScale a stream of data.
#include "Ravl/DP/IOPort.hh"

DPIOPortC Input/Output port.
#include "Ravl/DP/RunningAverage.hh"

DPRunningAverageC Running average on a stream of data.
#include "Ravl/DP/FileSequence.hh"

DPFileSequenceBaseC File Sequence.
DPIFileSequenceC Input File Sequence
DPOFileSequenceC Input File Sequence
#include "Ravl/DP/MTIOConnect.hh"

DPMTIOConnectC Connect some IOPorts.
DPMTIOConnectBaseC Connect some IOPorts.
#include "Ravl/DP/PlayControl.hh"

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

DPThreadPipeC MT safe queue handle.
#include "Ravl/DP/Buffer.hh"

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

DPFixedBufferC MT safe queue handle.
#include "Ravl/DP/Governor.hh"

DPGovernorBaseC Governor base Handle.
DPGovernorC Governor Handle.
#include "Ravl/DP/Hold.hh"

DPHoldC Hold value until replaced by put.
#include "Ravl/OS/Date.hh"

DateC Date & Time information.
#include "Ravl/OS/DeadLineTimer.hh"

DeadLineTimerC Dead line timer.
#include "Ravl/OS/UserInfo.hh"

UserInfoC User information.
#include "Ravl/OS/FilePermission.hh"

FilePermissionC Unix style file permisions.
#include "Ravl/OS/Filename.hh"

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

DirectoryC Directory handling.
#include "Ravl/Text/TextFile.hh"

TextFileC Text File, for use in text processing.
#include "Ravl/OS/SerialIO.hh"

SerialCtrlC Class to control unix serial ports.
OSerialC Output serial stream.
ISerialC Input serial stream.
IOSerialC Input/Output serial stream.
#include "Ravl/OS/DMABuffer.hh"

DMABufferC Buffer suitable for DMA transfers
#include "Ravl/OS/OSProcess.hh"

OSProcessC OSProcess handle.
#include "Ravl/OS/ChildOSProcess.hh"

ChildOSProcessC Child process handle.
#include "Ravl/OS/SktError.hh"

ExceptionNetC Networking exception.
#include "Ravl/OS/Socket.hh"

SocketC Socket connection handle.
#include "Ravl/OS/NetStream.hh"

NetOStreamC Output stream to memory.
NetIStreamC Input stream from memory.
#include "Ravl/OS/Packet.hh"

NetPacketC Packet of stream encoded data.
#include "Ravl/OS/NetEndPoint.hh"

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

NetMsgRegisterC Net message handle.
#include "Ravl/OS/NetMsgCall.hh"

NetMsgCall0C Net message Signal0
NetMsgCall1C Net message Signal1
NetMsgCall2C NetMsgCall2
NetMsgCall3C NetMsgCall3
#include "Ravl/OS/NetIPort.hh"

NetISPortC Input port.
#include "Ravl/OS/NetIPortServer.hh"

NetISPortServerBaseC Input port server base.
NetISPortServerC Input port.
#include "Ravl/OS/NetPortManager.hh"

NetPortManagerC Net port manager.
#include "Ravl/OS/NetPortClient.hh"

NetPortClientC NetPortClient.
#include "Ravl/OS/NetPortFormat.hh"

NetPortFormatC Data format for NetPort's.
#include "Ravl/Threads/Thread.hh"

ThreadC Thread handle.
#include "Ravl/Threads/Mutex.hh"

MutexC Mutual Exclusion lock.
MutexLockC Exception safe MutexC locking class.
#include "Ravl/Threads/ConditionalMutex.hh"

ConditionalMutexC Conditional variable.
#include "Ravl/Threads/Semaphore.hh"

SemaphoreC Semaphore.
#include "Ravl/Threads/RWLock.hh"

RWLockC Read/Write lock.
RWLockHoldC Exception safe RWLockC locking class.
#include "Ravl/Threads/SemaphoreRC.hh"

SemaphoreRC Reference counted semaphore.
#include "Ravl/Threads/ThreadEvent.hh"

ThreadEventC Broadcast Event.
#include "Ravl/Threads/MessageQueue.hh"

MessageQueueC Thread safe queue.
#include "Ravl/Threads/LaunchThread.hh"

LaunchThreadC Launch event handle.
#include "Ravl/Threads/TickerTrigger.hh"

TickerTriggerC Ticker handle.
#include "Ravl/Threads/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 "Ravl/Threads/TimedTriggerQueue.hh"

TimedTriggerQueueC Timed event queue.
#include "Ravl/Threads/Signal2.hh"

Signal2C Signal with 2 arguments
SignalInterConnect2C class for signal interconnector with 1 arg.
Signal2FuncC Signal a function
Signal2MethodC Signal a method.
Signal2MethodRefC Signal a method.
#include "Ravl/Threads/Signal3.hh"

Signal3C Signal with 3 arguments.
SignalInterConnect3C class for signal interconnector with 1 arg.
Signal3FuncC Signal a function
Signal3MethodC Signal a method.
Signal3MethodRefC Signal a method.
#include "Ravl/Threads/Signal1.hh"

Signal1C Signal with 1 argument
SignalInterConnect1C class for signal interconnector with 1 arg.
Signal1FuncC Signal a function
Signal1MethodC Signal a method.
Signal1MethodRefC Signal a method.
#include "Ravl/Threads/SignalConnectionSet.hh"

SignalConnectionSetC Signal connection set body.
#include "Ravl/Text/TextFileLine.hh"

TextFileLineC Class for holding a single line of text.
#include "Ravl/Text/TextBuffer.hh"

TextBufferC Text buffer.
#include "Ravl/Text/TextCursor.hh"

TextCursorC Cursor in text buffer.
#include "Ravl/Text/TextFile.hh"

TextFileBodyC Text File, for use in text processing.
#include "Ravl/Text/TemplateFile.hh"

TemplateFileC Subsitute variables in a template file.
#include "Ravl/Text/TextFragment.hh"

TextFragmentC Fragment of text in a buffer.
#include "Ravl/Text/ConfigFile.hh"

ConfigFileC Config file.
#include "Ravl/Text/TemplateComplex.hh"

TemplateComplexC Complex template body.
#include "Ravl/TMatrix.hh"

TMatrixC Templated matrix's.
#include "Ravl/TVector.hh"

TVectorC Templated vectors.
#include "Ravl/Vector.hh"

VectorC Vector of real values.
#include "Ravl/VectorMatrix.hh"

VectorMatrixC A vector and a matrix together for n-D space
#include "Ravl/Matrix.hh"

MatrixC Matrix of real values.
#include "Ravl/MatrixRUT.hh"

MatrixRUTC Right Upper Triangular matrix.
#include "Ravl/MatrixRS.hh"

MatrixRSC Positive Symetric matrix
#include "Ravl/FMatrix.hh"

FMatrixC Real Matrix with templated size.
#include "Ravl/FVector.hh"

FVectorC Real Vector with templated size
#include "Ravl/Vector2d.hh"

Vector2dC 2D Vector
#include "Ravl/Vector3d.hh"

Vector3dC 3D Vector
#include "Ravl/Vector4d.hh"

Vector4dC 4D Vector
#include "Ravl/Matrix2d.hh"

Matrix2dC 2 by 2 matrix of real values.
#include "Ravl/Matrix3d.hh"

Matrix3dC 3 by 3 matrix of real values.
#include "Ravl/Matrix4d.hh"

Matrix4dC 4 by 4 matrix of real values.
#include "Ravl/FVectorMatrix.hh"

FVectorMatrixC
#include "Ravl/VectorMatrix2d.hh"

VectorMatrix2dC 2D Vector matrix.
#include "Ravl/VectorMatrix3d.hh"

VectorMatrix3dC 3D Vector matrix.
#include "Ravl/VectorMatrix4d.hh"

VectorMatrix4dC 4D Vector matrix.
#include "Ravl/FPoint.hh"

FPointC Real point with templated size
#include "Ravl/Point2d.hh"

Point2dC 2D Point
#include "Ravl/FAffine.hh"

FAffineC General affine transformation.
#include "Ravl/Point4d.hh"

Point4dC Point in 4D space.
#include "Ravl/LineABC2d.hh"

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

Curve2dC 2d Parametric curve
Curve2dIC 2d Parametric Curve Body Template
#include "Ravl/Curve2dLine.hh"

Curve2dLineC Parametric Line.
#include "Ravl/Curve2dLineSegment.hh"

Curve2dLineSegmentC Parametric line segement.
#include "Ravl/Line2dIter.hh"

Line2dIterC Iterate throught interger grid points along a 2d line.
#include "Ravl/Affine2d.hh"

Affine2dC 2-D affine transformation
#include "Ravl/Moments2d2.hh"

Moments2d2C The first two moments in 2D space
#include "Ravl/LinePP3d.hh"

LinePP3dC Line determined by two points in 3D space
#include "Ravl/PlaneABCD3d.hh"

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

LinePV3dC Line determined by one point and a vector in 3D space
#include "Ravl/MeanCovariance3d.hh"

MeanCovariance3dC Mean covariance in 3 dimentions.
#include "Ravl/Point3d.hh"

Point3dC Point in 3d space.
#include "Ravl/PlanePVV3d.hh"

PlanePVV3dC Plane in 3D space
#include "Ravl/Quatern3d.hh"

Quatern3dC Quaternion
#include "Ravl/RigidTransform3d.hh"

RigidTransform3dC Rigid transform in 3 dimentions.
#include "Ravl/CrackCode.hh"

CrackCodeC Crackcode or Freeman code
#include "Ravl/BVertex.hh"

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

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

BoundaryC Crack code boundary
#include "Ravl/MeanVariance.hh"

MeanVarianceC Mean and variance of a single variable.
#include "Ravl/MeanCovariance.hh"

MeanCovarianceC Mean and covariance together in N-D space
#include "Ravl/MeanNd.hh"

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

MeanC Mean a single variable.
#include "Ravl/FMean.hh"

FMeanC Mean in N-D space
#include "Ravl/FMeanCovariance.hh"

FMeanCovarianceC Mean and covariance together in N-D space
#include "Ravl/MeanCovariance2d.hh"

MeanCovariance2dC Mean covariance in 2 dimentions.
#include "Ravl/Normal.hh"

NormalC Model a normal (or gauss) multi-dimensional distribution.
#include "Ravl/Histogram.hh"

HistogramC Histogram with discrete bins.
#include "Ravl/RealHistogram1d.hh"

RealHistogram1dC Create a histogram of real values.
#include "Ravl/RealHistogram2d.hh"

RealHistogram2dC Create a histogram of real values.
#include "Ravl/PrimitiveBinaryPolynomial.hh"

PrimitiveBinaryPolynomialC Evaluate a binary polynomial in a recurance sequence.
#include "Ravl/SobolSequence.hh"

SobolSequenceC Generate a sobel sequence.
#include "Ravl/CircleIter.hh"

CircleIterC Iterate around a circle.
#include "Ravl/PermutationIter.hh"

PermutationIterC Iterate permutations.
#include "Ravl/CombinationIter.hh"

CombinationIterC Combination iterator.
#include "Ravl/SquareIter.hh"

SquareIterC Clockwise iterate through a square.
#include "Ravl/FFT1d.hh"

FFT1dC Handle to 1d FFT.
#include "Ravl/PowerSpectrum1d.hh"

PowerSpectrum1dC Power Spectrum
#include "Ravl/Correlation1d.hh"

Correlation1dC
#include "Ravl/RealCepstral.hh"

RealCepstralC Compute the real cepstral
#include "Ravl/FFT2d.hh"

FFT2dC 2d FFT.
#include "Ravl/PatternRec/DataSet1Iter.hh"

DataSet1IterC Iterate through a data set.
#include "Ravl/PatternRec/DataSet2Iter.hh"

DataSet2IterC Iterate through a data set.
#include "Ravl/PatternRec/DataSet3Iter.hh"

DataSet3IterC Iterate through a data set.
#include "Ravl/PatternRec/SampleIter.hh"

SampleIterC Iterate through a sample.
#include "Ravl/PatternRec/Sample.hh"

SampleC Sample of DataT's
#include "Ravl/PatternRec/SampleVector.hh"

SampleVectorC Sample of vectors.
#include "Ravl/PatternRec/SampleDiscrete.hh"

SampleDiscreteC Sample of discrete objects.
#include "Ravl/PatternRec/DataSetBase.hh"

DataSetBaseC Data set base class
#include "Ravl/PatternRec/SampleLabel.hh"

SampleLabelC Sample of labels.
#include "Ravl/PatternRec/DataSet1.hh"

DataSet1C Data set
#include "Ravl/PatternRec/DataSet2.hh"

DataSet2C Data set
#include "Ravl/PatternRec/DataSet3.hh"

DataSet3C Data set
#include "Ravl/PatternRec/Function1.hh"

Function1C Map a vector to a single real value.
#include "Ravl/PatternRec/Designer.hh"

DesignerC Designer base class.
#include "Ravl/PatternRec/DesignFunctionSupervised.hh"

DesignFunctionSupervisedC Supervised function designer.
#include "Ravl/PatternRec/DesignFunctionUnsupervised.hh"

DesignFunctionUnsupervisedC Unsupervised function designer.
#include "Ravl/PatternRec/Distance.hh"

DistanceC Distance Metric
#include "Ravl/PatternRec/DistanceEuclidean.hh"

DistanceEuclideanC Euclidean distance metric
#include "Ravl/PatternRec/DistanceMax.hh"

DistanceMaxC Distance max Metric
#include "Ravl/PatternRec/DistanceCityBlock.hh"

DistanceCityBlockC Distance, City block Metric
#include "Ravl/PatternRec/DistanceMahalanobis.hh"

DistanceMahalanobisC Mahalanobis distance metric
#include "Ravl/PatternRec/DistanceSqrEuclidean.hh"

DistanceSqrEuclideanC SqrEuclidean distance metric
#include "Ravl/PatternRec/DistanceRobust.hh"

DistanceRobustC Robust magnitude metric.
#include "Ravl/PatternRec/FuncLinear.hh"

FuncLinearC Linear function.
#include "Ravl/PatternRec/FuncQuadratic.hh"

FuncQuadraticC Quadratic function.
#include "Ravl/PatternRec/FuncOrthPolynomial.hh"

FuncOrthPolynomialC Orthogonal Polynomial function.
#include "Ravl/PatternRec/DesignFuncLSQ.hh"

DesignFuncLSQC Design function with Least Squares Fitting.
#include "Ravl/PatternRec/FuncPDF.hh"

FuncPDFC Abstract Probablity Distribution Function.
#include "Ravl/PatternRec/FuncPDFNormal.hh"

FuncPDFNormalC Set of normal distributions.
#include "Ravl/PatternRec/ReducePCA.hh"

ReducePCAC Dimention reduction by Principle Component Analysis
#include "Ravl/PatternRec/ReduceLinear.hh"

ReduceLinearC Linear dimension reduction.
#include "Ravl/PatternRec/ClassifyVector.hh"

ClassifyVectorC Generic classifier.
#include "Ravl/PatternRec/DesignClassifyVector.hh"

DesignClassifyVectorC Abstract classifer designer.
#include "Ravl/PatternRec/DesignDiscriminantFunction.hh"

DesignDiscriminantFunctionC Design a discriminat function classifier.
#include "Ravl/PatternRec/DesignKNearestNeighbour.hh"

DesignKNearestNeighbourC Design a discriminat function classifier.
#include "Ravl/PatternRec/ClassifyKNearestNeighbour.hh"

ClassifyKNearestNeighbourC k nearest neighbours classifier.
#include "Ravl/PatternRec/ClassifyAverageNearestNeighbour.hh"

ClassifyAverageNearestNeighbourC ClassifyAverage k nearest neighbour classifier.
#include "Ravl/SourceTools/DefsFile.hh"

DefsMkFileC Interograte a defs.mk file.
#include "Ravl/SourceTools/SourceCodeManager.hh"

SourceCodeManagerC Base class for source tree processing tools.
#include "Ravl/SourceTools/RCSFile.hh"

RCSFileC Body class for dealing with RCS files.
RCSVersionC Class representing an RCS version number.
#include "Ravl/SourceTools/LibInfo.hh"

LibInfoC Information about library.
#include "Ravl/SourceTools/ProgInfo.hh"

ProgInfoC Information about an executable.
#include "Ravl/SourceTools/BuildInfo.hh"

BuildInfoC Collects information about library dependancies.
#include "Ravl/SourceTools/AutoPortSource.hh"

AutoPortSourceC Code Porting tool.
#include "Ravl/SourceTools/AutoPortGenerator.hh"
AutoPortGeneratorC Auto port engine
Enumerated types:

#include "Ravl/RefCounter.hh"
enum CreateBodyFlagT { CreateBodyE } ;
Forward declarations.

#include "Ravl/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 } ;
Directions on grid

enum GridMetricT { CITY_BLOCK, MAX_VALUE, SQUARE_EUCLID } ;
Grid metrics.

#include "Ravl/XMLStream.hh"
enum XMLTagOpsT { XMLEndTag, XMLContent, XMLIndent, XMLIndentDown, XMLEmptyTag, XMLBeginTag, XMLComment } ;
Exception issued when an parse error occurs.

#include "Ravl/Quatern3d.hh"
enum JointT { JNULL, RX, RY, RZ, RXRY, RXRZ, RYRZ, RXRYRZ, TXTYTZRXRYRZ, TXTYTZRZRYRX } ;
Quaternion
Two quarternions may represent the same rotation q and -q, both are valid, but it can be convenient to keep q[0]>0. This code usually tries to keep q[0] positive. All the non trivial constructors build a quarternion with q[0]>=0. The multiply operation can exit with q[0]<0, this is necessary if the Rotate member function is to work.

There are many tricky conversions, and stability issues with rotations and the conversions. Be careful of angles in particular angles near 0 or PI. This affects some conversions as indicated

A "valid" quarternion has norm 1, however when a quarternion contains a vector it does not have norm 1. Be careful when using operations that may cause the quarternion not to be valid.

When a quarternion is read in it should always be normalised so that it obeys normalisation to full machine precision which is the normal state of affairs

In addition it is possible that small errors may creep in during repeated multiplication. The user should consider using the Normalize() function to correct this. It is NOT done automatically during multiplication.



#include "Ravl/CrackCode.hh"
enum CrackCodeT { CR_DOWN = 0, CR_RIGHT = 1, CR_UP = 2, CR_LEFT = 3, CR_NODIR = 4 } ;
Relative crackCode
Symbol names of crack code, ordered counter-clockwise.

enum RelativeCrackCodeT { CR_AHEAD = 0, CR_TO_LEFT = 1, CR_BACK = 2, CR_TO_RIGHT = 3, CR_RNODIR = 4 } ;

Typedefs:

#include "Ravl/Types.hh"
typedef int IntT;
Integer of at least 32 bits

typedef unsigned int UIntT;
Unsigned Integer of at least 32 bits

typedef double RealT;
Real value of at least 64 bits.

typedef float FloatT;
Real value of at least 32 bits.

typedef unsigned char ByteT;
Unigned byte of 8 bits

typedef unsigned char UByteT;
Unigned byte of 8 bits

typedef signed char SByteT;
Signed byte of 8 bits

typedef unsigned short UInt16T;
Unsigned int of 16 bits.

typedef short Int16T;
Signed int of 16 bits.

typedef __int64 Int64T;
64 bit signed integer.

typedef UIntT SizeT;
Type which can index any item in memory.

typedef UInt64T StreamOffsetT;
Type which can index any offset in a file.
This is used internally in RAVL.

typedef StreamOffsetT StreamSizeT;
Size of stream. This is seperate to allow large file support.

#include "Ravl/RCHandleV.hh"
typedef RCHandleC<RCBodyVC> AbstractC;
Abstract object handle.
Note: Objects which used abstract handles MUST be derived from RCBodyVC.

#include "Ravl/fdstream.hh"
typedef basic_ifdstream<char> ifdstream;

typedef basic_ofdstream<char> ofdstream;

#include "Ravl/Random.hh"
typedef unsigned short RandomSeedT;
Seed for random number

#include "Ravl/OS/FilePermission.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 */ #define S_IFREG 0x8000 /* regular */

Variables:

#include "Ravl/Random.hh"
const long int RandomIntMaxValue = ((UIntT)) - 1;

#include "Ravl/ScalMath.hh"
static const IntT RavlPreComputedFactorialSize = 64;
The number of precomputed factorials.

#include "Ravl/OS/Filename.hh"
const char filenameSeperator = '\\';

const char filenameSeperator = '/';
StringC representing a filename.

Methods:

#include "Ravl/Types.hh"
void Swap(DataT & v1,DataT & v2)
Swap the values of two variables.

void SetZero(ByteT & x)
Set byte value to zero.

void SetZero(IntT & x)
Set integer value to zero.

void SetZero(UIntT & x)
Set unsigned integer value to zero.

void SetZero(RealT & x)
Set real value to zero.

void SetZero(SByteT & x)
Set signed byte value to zero.

void SetZero(FloatT & x)
Set float value to zero.

void SetZero(Int64T & x)
Set integer value to zero.

void SetZero(UInt64T & x)
Set unsigned integer value to zero.

K StdCopy(const K & dat)
Copy.

const char * StdCopy(const char * dat)
Copy constant 'C' style string.
No point in copying a constant string. If otherwise you should use StringC intead.

long double StdCopy(long double x)
Copy long double.

double StdCopy(double x)
Copy double.

float StdCopy(float x)
Copy float.

bool StdCopy(bool x)
Copy bool.

short StdCopy(short x)
Copy short.

unsigned short StdCopy(unsigned short x)
Copy short.

int StdCopy(int x)
Copy int.

unsigned int StdCopy(unsigned int x)
Copy unsigned int.

long StdCopy(long x)
Copy long

unsigned long StdCopy(unsigned long x)
Copy unsigned long.

char StdCopy(char x)
Copy char.

char StdCopy(unsigned char x)
Copy unsigned char.

Int64T StdCopy(Int64T x)
Copy 64 bit int.

UInt64T StdCopy(UInt64T x)
Copy unsigned 64 bit int.

#include "Ravl/Assert.hh"
bool AssertThrowException()
Test if an exception on an assertion failure.

bool SetAssertThrowException(bool val)
Throw an exception on an assertion failure.
Note this may failed if exceptions are not supported, in which case it will return false.

void AssertFailed(char * file,int lineNo)
Called if assertion failed.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void AssertFailed(char * file,int lineNo,char * msg)
Called if assertion failed, with message.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void IssueError(char * file,int lineNo,char * msg,...)
Call when program encounters an error.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void IssueWarning(char * file,int lineNo,char * msg,...)
Call when program encounters an a unexpected occurance.
this prints the message and continues.

#include "Ravl/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'.

#include "Ravl/EntryPnt.hh"
bool UsingRavlMain()
Are we using RAVL_ENTRY_POINT.
Used to decide how to handle some internal errors.

int RavlMain(int argc,char * argv[],int (*func)(int argc,char * argv[]) )
Call through function.

#include "Ravl/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 -----------------------------------------

IndexC operator +(IntT i,const IndexC & j)
Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IndexC operator -(IntT i,const IndexC & j)
Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IndexC operator *(IntT i,const IndexC & j)
Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IndexC operator /(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'.

bool operator ==(IntT i,const IndexC & j)
Returns true if the value of index 'j' is equal to the integer number 'i'.

bool operator !=(IntT i,const IndexC & j)
Returns true if the values of index 'j' is not equal to the integer number 'i'.

bool operator <(IntT i,const IndexC & j)
Returns true if the integer number 'i' is smaller than the value of index 'j' .

bool operator <=(IntT i,const IndexC & j)
Returns true if the integer number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(IntT i,const IndexC & j)
Returns true if the integer number 'i' is greater than the value of index 'j' .

bool operator >=(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 --------------------------------------------------

IndexC operator +(const UIntT i,const IndexC & j)
Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IndexC operator -(const UIntT i,const IndexC & j)
Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IndexC operator *(const UIntT i,const IndexC & j)
Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IndexC 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'.

bool operator ==(const UIntT i,const IndexC & j)
Returns true if the value of index 'j' is equal to the integer number 'i'.

bool operator !=(const UIntT i,const IndexC & j)
Returns true if the values of index 'j' is not equal to the integer number 'i'.

bool operator <(const UIntT i,const IndexC & j)
Returns true if the integer number 'i' is smaller than the value of index 'j' .

bool 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' .

bool operator >(const UIntT i,const IndexC & j)
Returns true if the integer number 'i' is greater than the value of index 'j' .

bool 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 -------------------------------------------------- ByteT binary operators omitted, as I don't feel they make much sense (maybe wrong)

const UByteT & operator +=(UByteT & i,const IndexC & j)
Adds index value 'j' to byte number 'i'.

const UByteT & operator -=(UByteT & i,const IndexC & j)
Subtracts index value 'j' from byte number 'i'.

const UByteT & operator *=(UByteT & i,const IndexC & j)
Multiplies index value 'j' by byte number 'i'.

const UByteT & operator /=(UByteT & i,const IndexC & j)
Divides index value 'j' by byte number 'i'.

bool operator ==(const UByteT i,const IndexC & j)
Returns true if the value of index 'j' is equal to the byte number 'i'.

bool operator !=(const UByteT i,const IndexC & j)
Returns true if the values of index 'j' is not equal to the byte number 'i'.

bool operator <(const UByteT i,const IndexC & j)
Returns true if the byte number 'i' is smaller than the value of index 'j' .

bool operator <=(const UByteT i,const IndexC & j)
Returns true if the byte number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(const UByteT i,const IndexC & j)
Returns true if the byte number 'i' is greater than the value of index 'j' .

bool operator >=(const UByteT 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 ----------------------------------------

RealT operator +(RealT i,const IndexC & j)
Returns the double number constructed as addition of double number 'i' and index value 'j'.

RealT operator -(RealT i,const IndexC & j)
Returns the double number constructed as subtraction of index value 'j' from double number 'i'.

RealT operator *(RealT i,const IndexC & j)
Returns the double number constructed as multiplication of double number 'i' and index value 'j'.

RealT operator /(RealT i,const IndexC & j)
Returns the double number constructed as division of double number 'i' and index value 'j'.

const RealT & operator +=(RealT & i,const IndexC & j)
Adds double number 'i' to index value 'j'.

const RealT & operator -=(RealT & i,const IndexC & j)
Subtracts index value 'j' from double number 'i'.

const RealT & operator *=(RealT & i,const IndexC & j)
Multiplies index value 'j' by double number 'i'.

const RealT & operator /=(RealT & i,const IndexC & j)
Divides index value 'j' by double number 'i'.

bool operator ==(RealT i,const IndexC & j)
Returns true if the value of index 'j' is equal to the double number 'i'.

bool operator !=(RealT i,const IndexC & j)
Returns true if the values of index 'j' is not equal to the double number 'i'.

bool operator <(RealT i,const IndexC & j)
Returns true if the double number 'i' is smaller than the value of index 'j' .

bool operator <=(RealT i,const IndexC & j)
Returns true if the double number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(RealT i,const IndexC & j)
Returns true if the double number 'i' is greater than the value of index 'j' .

bool operator >=(RealT i,const IndexC & j)
Returns true if the double number 'i' is greater than or equal to the value of index 'j' .

#include "Ravl/String.hh"
BinOStreamC & operator <<(BinOStreamC & out,const StringC & str)
Write a string to a binary stream.

BinOStreamC & operator <<(BinOStreamC & out,const SubStringC & str)
Write a substring to a binary stream.

BinIStreamC & operator >>(BinIStreamC & in,StringC & str)
Read a string from a binary stream.

int compare(const StringC & x,const StringC & y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const StringC & x,const SubStringC & y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const StringC & x,const char * y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const StringC & y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const SubStringC & y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const char * y)
Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int readline(istream & s,StringC & x,char terminator,int discard_terminator)
Read a line of text from a stream.
///

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 RealT & y)

ostream & operator <<(ostream & s,const StringC & x)
a zillion comparison operators

bool operator ==(const StringC & x,const StringC & y)

bool operator !=(const StringC & x,const StringC & y)

bool operator >(const StringC & x,const StringC & y)

bool operator >=(const StringC & x,const StringC & y)

bool operator <(const StringC & x,const StringC & y)

bool operator <=(const StringC & x,const StringC & y)

bool operator ==(const StringC & x,const SubStringC & y)

bool operator !=(const StringC & x,const SubStringC & y)

bool operator >(const StringC & x,const SubStringC & y)

bool operator >=(const StringC & x,const SubStringC & y)

bool operator <(const StringC & x,const SubStringC & y)

bool operator <=(const StringC & x,const SubStringC & y)

bool operator ==(const StringC & x,const char * t)

bool operator !=(const StringC & x,const char * t)

bool operator >(const StringC & x,const char * t)

bool operator >=(const StringC & x,const char * t)

bool operator <(const StringC & x,const char * t)

bool operator <=(const StringC & x,const char * t)

bool operator ==(const SubStringC & x,const StringC & y)

bool operator !=(const SubStringC & x,const StringC & y)

bool operator >(const SubStringC & x,const StringC & y)

bool operator >=(const SubStringC & x,const StringC & y)

bool operator <(const SubStringC & x,const StringC & y)

bool operator <=(const SubStringC & x,const StringC & y)

bool operator ==(const SubStringC & x,const SubStringC & y)

bool operator !=(const SubStringC & x,const SubStringC & y)

bool operator >(const SubStringC & x,const SubStringC & y)

bool operator >=(const SubStringC & x,const SubStringC & y)

bool operator <(const SubStringC & x,const SubStringC & y)

bool operator <=(const SubStringC & x,const SubStringC & y)

bool operator ==(const SubStringC & x,const char * t)

bool operator !=(const SubStringC & x,const char * t)

bool operator >(const SubStringC & x,const char * t)

bool operator >=(const SubStringC & x,const char * t)

bool operator <(const SubStringC & x,const char * t)

bool operator <=(const SubStringC & x,const char * t)

#include "Ravl/RefCounter.hh"
ostream & operator <<(ostream & strm,const RCHandleC<BodyT> & obj)

istream & operator >>(istream & strm,RCHandleC<BodyT> & obj)
Base class for all reference counted objects
This holds a count of the number of handles that are available for this object.

istream & operator >>(istream &,RCBodyC & obj)
Input body.
No-op.

ostream & operator <<(ostream &,const RCBodyC & obj)
Output body.
No-op.

Signal Event handle

#include "Ravl/Calls.hh"
CallFunc0C<RetT> Trigger(RetT (*nfunc)() )

CallFunc1C<DataT,RetT> Trigger(RetT (*nfunc)(DataT & dat) ,const DataT & dat)

CallFunc2C<Data1T,Data2T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallFunc3C<Data1T,Data2T,Data3T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallFunc4C<Data1T,Data2T,Data3T,Data4T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallFunc5C<Data1T,Data2T,Data3T,Data4T,Data5T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)
Labotimized version for Visual C++. Doesn't template on return types.

CallFunc0C<bool> Trigger(bool (*nfunc)() )

CallFunc1C<DataT,bool> Trigger(bool (*nfunc)(DataT & dat) ,const DataT & dat)

CallFunc2C<Data1T,Data2T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallFunc3C<Data1T,Data2T,Data3T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallFunc4C<Data1T,Data2T,Data3T,Data4T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallFunc5C<Data1T,Data2T,Data3T,Data4T,Data5T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

#include "Ravl/MTLocks.hh"
int MTThreadID()
Get current thread id.

Lock system for reading.

This class provides exceptions safe system DB locking. NB. The locking mechanism is NOT garuanteed to be recursive, so you can't call ReadLock twice then Unlock twice. You also can't go directly between a read lock to a write lock just by calling MTWriteLock(), you have to Unlock the ReadLock first.

#include "Ravl/Stream.hh"
istream & operator >>(istream & is,bool & b)
Fix for Visual C++'s lack of a bool stream operator.

ostream & operator <<(ostream & os,bool b)
Fix for Visual C++'s lack of a bool stream operator.

bool EnableURLMapper()
Enable url mapping of filenames.
With the expection of 'file:' specifications this enabled the changing of URL's to a RAVL special files. i.e. 'http:' becomes '@http:' This allows us to implement handlers in seperate libraries which can link in as required. If the 'file:' if found not to have a domain specifier then the 'file:' is stripped off and the file is treated normally.

Note: At the moment the URL handling mechanism may not handle relative filenames correctly as it uses the program current working directory as a start point. If this becomes a problem some optional data maybe added to StreamC which holds a current directory.


bool DisableURLMapper()
Dissable url mapping of filenames.

bool IsURLMappingEnabled()
Test if URL mapping enabled.
Returns true if it is.

Reference counter IO stream base class.

#include "Ravl/BinStream.hh"
short bswap_16(const short & buf)
Swap bytes of a 16 bit number.

int bswap_32(const int & buf)
Swap bytes of a 32 bit number.

Machine independant binary input stream.

BinIStreamC & operator >>(BinIStreamC & s,IndexC & ind)

BinOStreamC & operator <<(BinOStreamC & s,const IndexC & ind)

BinOStreamC & operator <<(BinOStreamC & out,const TFVectorC<DataT,N> & dat)

BinIStreamC & operator >>(BinIStreamC & in,TFVectorC<DataT,N> & dat)

#include "Ravl/IndexRange1d.hh"
bool IsInside(IndexC i,const IndexRangeC & range)
1D index range of array
The class IndexRangeC is a representation of an interval of one dimensional index.

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'.

BinOStreamC & operator <<(BinOStreamC & s,const IndexRangeC & ir)

BinIStreamC & operator >>(BinIStreamC & s,IndexRangeC & ir)

#include "Ravl/IndexRange2d.hh"
ostream & operator <<(ostream & s,const IndexRange2dC & ir)

istream & operator >>(istream & s,IndexRange2dC & ir)

BinOStreamC & operator <<(BinOStreamC & s,const IndexRange2dC & ir)

BinIStreamC & operator >>(BinIStreamC & s,IndexRange2dC & ir)
/////////////////////////////////////////////////////

#include "Ravl/RCWrap.hh"
ostream & operator <<(ostream & strm,const RCWrapC<DataT> & data)
ostream operator.

istream & operator >>(istream & strm,RCWrapC<DataT> & data)
istream operator.

#include "Ravl/Index2d.hh"
NeighbourOrderT Reverse(NeighbourOrderT at)
Get the opposite direction.
==================================================================== ======= Index2dC =================================================== ====================================================================

#include "Ravl/IntC.hh"
ostream & operator <<(ostream & out,const IntC & x)

istream & operator >>(istream & in,IntC & x)

BinOStreamC & operator <<(BinOStreamC & out,const IntC & x)

BinIStreamC & operator >>(BinIStreamC & in,IntC & x)
unsigned integer with a default constructor that assigns it a value of 0.
Its main feature is the default constructor sets its value to zero. Usefull in things like histograms.

int operator -(int v1,UIntC v2)
Subtraction.
This is included to avoid some confusing type casts which can lead to odd results.

ostream & operator <<(ostream & out,const UIntC & x)

istream & operator >>(istream & in,UIntC & x)

BinOStreamC & operator <<(BinOStreamC & out,const UIntC & x)

BinIStreamC & operator >>(BinIStreamC & in,UIntC & x)

#include "Ravl/TFVector.hh"
istream & operator >>(istream & in,TFVectorC<DataT,N> & dat)

ostream & operator <<(ostream & in,const TFVectorC<DataT,N> & dat)

TFVectorC<DataT,2> TFVector2(const DataT & v1,const DataT & v2)
Create a 2d vector.
Helper function to make creation of fixed size vectors easier.

TFVectorC<DataT,3> TFVector3(const DataT & v1,const DataT & v2,const DataT & v3)
Create a 3d vector.
Helper function to make creation of fixed size vectors easier.

TFVectorC<DataT,4> TFVector4(const DataT & v1,const DataT & v2,const DataT & v3,const DataT & v4)
Create a 3d vector.
Helper function to make creation of fixed size vectors easier.

void SetZero(TFVectorC<DataT,N> & x)
Set vector to zero.

TFVectorC<DataT,N> operator *(const DataT & alpha,const TFVectorC<DataT,N> & data)

ostream & operator <<(ostream & out,const TFVectorC<ByteT,N> & dat)
Specialise byte vectors so they're treated as numerical values.

istream & operator >>(istream & in,TFVectorC<ByteT,N> & dat)
Specialise byte vectors so they're treated as numerical values.

ostream & operator <<(ostream & out,const TFVectorC<SByteT,N> & dat)
Specialise byte vectors so they're treated as numerical values.

istream & operator >>(istream & in,TFVectorC<SByteT,N> & dat)
Specialise byte vectors so they're treated as numerical values.

#include "Ravl/Empty.hh"
ostream & operator <<(ostream & out,const EmptyC &)

istream & operator >>(istream & in,EmptyC &)

BinOStreamC & operator <<(BinOStreamC & out,const EmptyC &)

BinIStreamC & operator >>(BinIStreamC & in,EmptyC &)

Basic algebraic functions

#include "Ravl/Math.hh"
DataT Abs(const DataT & a)
Returns the absolute value of 'a'

unsigned char Abs(unsigned char a)
Returns the absolute value of 'a'
Used to avoid warnings.

unsigned short Abs(unsigned short a)
Returns the absolute value of 'a'
Used to avoid warnings.

unsigned int Abs(unsigned int a)
Returns the absolute value of 'a'
Used to avoid warnings.

unsigned long Abs(unsigned long a)
Returns the absolute value of 'a'
Used to avoid warnings.

DataT Sign(const DataT & a)
Returns the sign of the real number 'a'.

RealT Sign(RealT a,RealT b)
Returns the value 'a' with a sign of 'b'.

IntT Round(RealT x)
Returns the value x rounded to the nearest integer.

IntT Floor(RealT x)
Returns the greatest integral value less than or equal to 'x'.

void SetToZero(DataT & dat)
Set 'dat' to zero.
In cases where this doesn't work, a specialised version should be provided.

DataT Sqr(const DataT & x)
Returns the square of 'x'.

RealT Sqrt(RealT x)
Returns the square root of 'x'.

DataT Min(const DataT & a,const DataT & b)
Returns the smaller value from 'a' and 'b'.

DataT Max(const DataT & a,const DataT & b)
Returns the bigger value from 'a' and 'b'.

RealT Log(RealT r)
Returns log(r).

RealT Pow(RealT x,RealT y)
Returns 'x' raised to the power 'y'.

RealT Pow(RealT x,IntT y)
Returns 'x' raised to the power 'y' where y is an integer..

RealT Exp(RealT r)
Returns safe exp(r).

IntT ILog2(IntT i)
Interger Log 2
"i" = 2 ^ "mex", "mex" = ?

RealT Sin(RealT x)
Returns the sine of 'x'.

RealT ASin(RealT x)
Returns the arc sine of 'x'.

RealT Cos(RealT x)
Returns the cosine of 'x'.

RealT ACos(RealT x)
Returns the arc cosine of 'x'.

RealT ATan(RealT x)
Returns the arc tangent of 'x' in the range -pi/2 .. +pi/2.

RealT ATan2(RealT y,RealT x)
Returns the arc tangent of 'y/x' in the range -pi .. +pi.

RealT Sinh(RealT x)
Returns the sine of 'x'.

RealT Cosh(RealT x)
Returns the cosine of 'x'.

RealT Pythag(RealT a,RealT b)
Computes sqrt(sqr(a)+sqr(b)) without destructive overflow or underflow.

bool IsSmall(RealT a,RealT norm = 1,RealT isSmall = 1 e - 8)
Is a small relative to 'norm' ?
This code does the following test 'Abs(a/norm)) < isSmall'.

This code used to be as follows, but it was changed because using x==y for floats is a bad idea, and eventually caused trouble on Visual C++. (AJS) float b = (float) ((double) Abs(a) + norm); return (b == (float) norm);


bool IsAlmostZero(RealT v,RealT threshold = 1.0e-12)
Test is a real value is near zero.
Use with care.

DataT MinComponent(DataT a)
Returns the smallest component from 'a'.

DataT MaxComponent(DataT a)
Returns the Biggest component from 'a'.

DataT ScaleMin(DataT a,DataT b)
Returns the argument which has the smallest component from 'a' and 'b'.
In a manner suitable for scaling operations.

DataT ScaleMax(DataT a,DataT b)
Returns the argument which has the largest component from 'a' and 'b'.
In a manner suitable for scaling operations.

#include "Ravl/CallMethods.hh"
CallMethod0C<ObjT,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)() )

CallMethod1C<ObjT,DataT,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)(DataT &) ,const DataT & dat)

CallMethod2C<ObjT,Data1T,Data2T,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallMethod3C<ObjT,Data1T,Data2T,Data3T,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallMethod4C<ObjT,Data1T,Data2T,Data3T,Data4T,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallMethod5C<ObjT,Data1T,Data2T,Data3T,Data4T,Data5T,RetT> Trigger(const ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

CallMethod0C<ObjT,bool> Trigger(const ObjT & nobj,bool (*nfunc)() )

CallMethod1C<ObjT,DataT,bool> Trigger(const ObjT & nobj,bool (*nfunc)(DataT &) ,const DataT & dat)

CallMethod2C<ObjT,Data1T,Data2T,bool> Trigger(const ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallMethod3C<ObjT,Data1T,Data2T,Data3T,bool> Trigger(const ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallMethod4C<ObjT,Data1T,Data2T,Data3T,Data4T,bool> Trigger(const ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallMethod5C<ObjT,Data1T,Data2T,Data3T,Data4T,Data5T,bool> Trigger(const ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

#include "Ravl/CallMethodRefs.hh"
CallMethodRef0C<ObjT,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)() )

CallMethodRef1C<ObjT,DataT,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)(DataT &) ,const DataT & dat)

CallMethodRef2C<ObjT,Data1T,Data2T,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallMethodRef3C<ObjT,Data1T,Data2T,Data3T,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallMethodRef4C<ObjT,Data1T,Data2T,Data3T,Data4T,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallMethodRef5C<ObjT,Data1T,Data2T,Data3T,Data4T,Data5T,RetT> TriggerR(ObjT & nobj,RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

CallMethodRef0C<ObjT,bool> TriggerR(ObjT & nobj,bool (*nfunc)() )

CallMethodRef1C<ObjT,DataT,bool> TriggerR(ObjT & nobj,bool (*nfunc)(DataT &) ,const DataT & dat)

CallMethodRef2C<ObjT,Data1T,Data2T,bool> TriggerR(ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallMethodRef3C<ObjT,Data1T,Data2T,Data3T,bool> TriggerR(ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallMethodRef4C<ObjT,Data1T,Data2T,Data3T,Data4T,bool> TriggerR(ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallMethodRef5C<ObjT,Data1T,Data2T,Data3T,Data4T,Data5T,bool> TriggerR(ObjT & nobj,bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

#include "Ravl/DeepCopy.hh"
IntT StdDeepCopy(const IntT & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

UIntT StdDeepCopy(const UIntT & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

RealT StdDeepCopy(const RealT & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

FloatT StdDeepCopy(const FloatT & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

ByteT StdDeepCopy(const ByteT & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

UInt16T StdDeepCopy(const UInt16T & val,UIntT levels = ((UIntT)))
Deep copy for built in type.

DataT StdDeepCopy(const DataT & val,UIntT levels = ((UIntT)))
Call deep copy on a class.

#include "Ravl/StdHash.hh"
UIntT StdHash(const K & dat)
Default hash function.

bool HashIsEqual(const K & d1,const K & d2)

bool HashIsEqual(const char * d1,const char * d2)
Compair 'C' style strings.

UIntT StdHash(const char * dat)
Hash 'C' style strings.

UIntT StdHash(bool dat)
Hash a bool.
Not alot you can do with this.

UIntT StdHash(const short dat)
Hash short.

UIntT StdHash(const unsigned short dat)
Hash unsigned short.

UIntT StdHash(const int dat)
Hash int.

UIntT StdHash(const unsigned int dat)
Hash unsigned int.

UIntT StdHash(const long dat)
Hash long value.

UIntT StdHash(const unsigned long dat)
Hash unsigned long.

UIntT StdHash(const char dat)
Hash char.

UIntT StdHash(const unsigned char dat)
Hash unsigned char.

UIntT StdHash(const Int64T dat)
Hash 64 bit int.

UIntT StdHash(const UInt64T dat)
Hash unsigned 64 bit int.

#include "Ravl/IndexRange3d.hh"
ostream & operator <<(ostream & s,const IndexRange3dC & ir)

istream & operator >>(istream & s,IndexRange3dC & ir)

BinOStreamC & operator <<(BinOStreamC & s,const IndexRange3dC & ir)

BinIStreamC & operator >>(BinIStreamC & s,IndexRange3dC & ir)
/////////////////////////////////////////////////////

#include "Ravl/RealC.hh"
ostream & operator <<(ostream & out,const RealC & x)

istream & operator >>(istream & in,RealC & x)

BinOStreamC & operator <<(BinOStreamC & out,const RealC & x)

BinIStreamC & operator >>(BinIStreamC & in,RealC & x)

#include "Ravl/Average.hh"
DataT Average(const DataT & a,const DataT & b)
Take average of 2 numbers.
This is usefull to deal with types limited value ranges. as it can be overriden.

DataT Average(const DataT & a,const DataT & b,const DataT & c)
Take average of 3 numbers.
This is usefull to deal with types limited value ranges. as it can be overriden.

DataT Average(const DataT & a,const DataT & b,const DataT & c,const DataT & d)
Take average of 4 numbers.
This is usefull to deal with types limited value ranges. as it can be overriden.

ByteT Average(const ByteT & a,const ByteT & b)
Take average of 2 numbers.
This is usefull to deal with types limited value ranges. e.g.

ByteT Average(const ByteT & a,const ByteT & b,const ByteT & c)
Take average of 3 numbers.

ByteT Average(const ByteT & a,const ByteT & b,const ByteT & c,const ByteT & d)
Take average of 4 numbers.

SByteT Average(const SByteT & a,const SByteT & b)
Take average of 2 numbers.

SByteT Average(const SByteT & a,const SByteT & b,const SByteT & c)
Take average of 3 numbers.

SByteT Average(const SByteT & a,const SByteT & b,const SByteT & c,const SByteT & d)
Take average of 4 numbers.

Int16T Average(const Int16T & a,const Int16T & b)
Take average of 2 numbers.

Int16T Average(const Int16T & a,const Int16T & b,const Int16T & c)
Take average of 3 numbers.

Int16T Average(const Int16T & a,const Int16T & b,const Int16T & c,const Int16T & d)
Take average of 4 numbers.

UInt16T Average(const UInt16T & a,const UInt16T & b)
Take average of 2 numbers.

UInt16T Average(const UInt16T & a,const UInt16T & b,const UInt16T & c)
Take average of 3 numbers.

UInt16T Average(const UInt16T & a,const UInt16T & b,const UInt16T & c,const UInt16T & d)
Take average of 4 numbers.

#include "Ravl/RealRange1d.hh"
bool IsInside(RealT i,const RealRangeC & range)
Returns true if the index 'i' is inside the index range 'r'.

IndexRangeC operator *(const RealRangeC & realRange,const IndexRangeC & indexRange)
Multiply an index range by a real range.
Multiplying by a real range of 0-1 is a unit transform.

istream & operator >>(istream & s,RealRangeC & r)
Read range from input stream.
Read information from the intput stream 's' and sets the real range according obtained data.

ostream & operator <<(ostream & s,const RealRangeC & r)
Saves the index range 'r' into the output stream 's'.

BinOStreamC & operator <<(BinOStreamC & s,const RealRangeC & ir)
Read range from binary stream.

BinIStreamC & operator >>(BinIStreamC & s,RealRangeC & ir)
Write range to binary stream.

#include "Ravl/RealRange2d.hh"
IndexRange2dC operator *(const RealRange2dC & realRange,const IndexRange2dC & indexRange)
Multiply a 2d index range by a real 2d range.
Multiplying by a real range of 0-1,0-1 is a unit transform.

ostream & operator <<(ostream & s,const RealRange2dC & ir)

istream & operator >>(istream & s,RealRange2dC & ir)

BinOStreamC & operator <<(BinOStreamC & s,const RealRange2dC & ir)

BinIStreamC & operator >>(BinIStreamC & s,RealRange2dC & ir)
/////////////////////////////////////////////////////

#include "Ravl/RCHandleV.hh"
istream & operator >>(istream & strm,RCHandleVC<BodyT> & obj)

BinIStreamC & operator >>(BinIStreamC & strm,RCHandleVC<BodyT> & obj)
Base class for all reference counted objects, where derivation is expected.
This holds a count of the number of handles that are available for this object.

istream & operator >>(istream &,RCBodyVC & obj)
Input virtual body.
No-op.

RCBodyVC * VCLoad(istream & s)
Load object from a stream via a virtual constructor

RCBodyVC * VCLoad(BinIStreamC & s)
Load object from a binary stream via a virtual constructor

BodyT * VCLoad(istream & s,BodyT *)

BodyT * VCLoad(BinIStreamC & s,BodyT *)

ostream & operator <<(ostream & strm,const RCHandleVC<BodyT> & obj)
Write a handle to a stream.

BinOStreamC & operator <<(BinOStreamC & strm,const RCHandleVC<BodyT> & obj)
Write binary handle to a stream.

#include "Ravl/TimeCode.hh"
ostream & operator <<(ostream & s,const TimeCodeC & out)
Write time code out to stream.

istream & operator >>(istream & s,TimeCodeC & tc)
Read time code in from stream.
NOT IMPLEMENTED.

#include "Ravl/RealRange3d.hh"
IndexRange3dC operator *(const RealRange3dC & realRange,const IndexRange3dC & indexRange)
Multiply a 2d index range by a real 2d range.
Multiplying by a real range of 0-1,0-1 is a unit transform.

ostream & operator <<(ostream & s,const RealRange3dC & ir)

istream & operator >>(istream & s,RealRange3dC & ir)

BinOStreamC & operator <<(BinOStreamC & s,const RealRange3dC & ir)

BinIStreamC & operator >>(BinIStreamC & s,RealRange3dC & ir)
/////////////////////////////////////////////////////

#include "Ravl/Slice1d.hh"
ostream & operator <<(ostream & out,const Slice1dC<DataT> & dat)
Write to stream.

istream & operator >>(istream & out,Slice1dC<DataT> & dat)
Read from stream.

#include "Ravl/RBfAcc3d.hh"
ostream & operator <<(ostream & s,const RangeBufferAccess3dC<DataT> & arr)

istream & operator >>(istream & s,RangeBufferAccess3dC<DataT> & arr)

BinOStreamC & operator <<(BinOStreamC & s,const RangeBufferAccess3dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,RangeBufferAccess3dC<DataT> & arr)

#include "Ravl/SDArray1d.hh"
ostream & operator <<(ostream & out,const SDArray1dC<T> & arr)

istream & operator >>(istream & in,SDArray1dC<T> & arr)
/////////////////////// Constructors.

#include "Ravl/SArray1d.hh"
BinOStreamC & operator <<(BinOStreamC & s,const SArray1dC<DataT> & arr)
Prints array into the stream 's'.

BinIStreamC & operator >>(BinIStreamC & s,SArray1dC<DataT> & arr)
Assigns the values into the array 'arr'.

SArray1dC<DataT> & BubbleSort(SArray1dC<DataT> & arr)
Sorts arr using operator <.

istream & operator >>(istream & s,SArray1dC<DataT> & arr)
Assigns the values into the array 'arr'.

ostream & operator <<(ostream & s,const SArray1dC<DataT> & arr)

#include "Ravl/SArray2d.hh"
ostream & operator <<(ostream & s,const SArray2dC<DataT> & arr)
Prints into the stream 's'

istream & operator >>(istream & s,SArray2dC<DataT> & arr)
Reads the array from the stream 's'

BinOStreamC & operator <<(BinOStreamC & s,const SArray2dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,SArray2dC<DataT> & arr)
///////////////////////////////////////////////////

#include "Ravl/SArray3d.hh"
ostream & operator <<(ostream & s,const SArray3dC<DataT> & arr)
Prints into the stream 's'

istream & operator >>(istream & s,SArray3dC<DataT> & arr)
Reads the array from the stream 's'

BinOStreamC & operator <<(BinOStreamC & s,const SArray3dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,SArray3dC<DataT> & arr)
///////////////////////////////////////////////////

#include "Ravl/Array1d.hh"
ostream & operator <<(ostream & s,const Array1dC<DataT> & arr)
Prints array into the stream 's'.

istream & operator >>(istream & s,Array1dC<DataT> & arr)
Assigns the values into the array 'arr'.

Array1dC<DataT> & BubbleSort(Array1dC<DataT> & arr)
Sorts the array 'arr' using operator <. /////////////////////////////////////////////

BinOStreamC & operator <<(BinOStreamC & s,const Array1dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,Array1dC<DataT> & arr)

#include "Ravl/Array2d.hh"
ostream & operator <<(ostream & s,const Array2dC<DataT> & arr)
Prints into the stream 's'

istream & operator >>(istream & s,Array2dC<DataT> & arr)
Reads the array from the stream 's' //////////////////////////////////////////////////////////////////////////////

BinOStreamC & operator <<(BinOStreamC & s,const Array2dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,Array2dC<DataT> & arr)

#include "Ravl/Array3d.hh"
ostream & operator <<(ostream & s,const Array3dC<DataT> & arr)
Prints into the stream 's'

istream & operator >>(istream & s,Array3dC<DataT> & arr)
Reads the array from the stream 's' //////////////////////////////////////////////////////////////////////////////

BinOStreamC & operator <<(BinOStreamC & s,const Array3dC<DataT> & arr)

BinIStreamC & operator >>(BinIStreamC & s,Array3dC<DataT> & arr)

#include "Ravl/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)

BinIStreamC & operator >>(BinIStreamC & in,Tuple2C<T1,T2> & obj)

#include "Ravl/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 "Ravl/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 "Ravl/BinTable.hh"
ostream & operator <<(ostream & s,const BinTableC<IT,DIT,BT> &)

istream & operator >>(istream & s,BinTableC<IT,DIT,BT> &)
A table of bins. Hashing for real valued paramiters.
Note: This only works for multi-dementional tables. SMALL OBJECT

Template paramiter. Examples.

IT - Index Type. ( Vector2dC )

DIT - Descritised index type. ( Index2dC )

BT - Bin Type. ( x )



#include "Ravl/BinIter.hh"
ostream & operator <<(ostream & out,const BinIterC<IT,DIT,BT> &)

#include "Ravl/BinList.hh"
ostream & operator <<(ostream & s,const BinListC<IT,DIT,BT> &)

istream & operator >>(istream & s,BinListC<IT,DIT,BT> &)
Binned table of lists.
SMALL OBJECT

This is simplified the creation of tables with lists in each of the bins.


#include "Ravl/HashTree.hh"
ostream & operator <<(ostream & s,const HashTreeC<KeyT,DataT> & tree)

istream & operator >>(istream & s,HashTreeC<KeyT,DataT> & tree)

ostream & operator <<(ostream & s,const HashTreeNodeC<KeyT,DataT> & node)

istream & operator >>(istream & s,HashTreeNodeC<KeyT,DataT> & tree)
Add a child with given key and data.
returns false if child exists.

#include "Ravl/DList.hh"
ostream & operator <<(ostream &,const DListBodyC<DataT> &)

istream & operator >>(istream &,DListBodyC<DataT> &)

BinOStreamC & operator <<(BinOStreamC &,const DListBodyC<DataT> &)

BinIStreamC & operator >>(BinIStreamC & strm,DListC<DataT> & lst)
Double linked List
This is a reference counted, doubly linked list.

Implementation:

The list contains a head element and a chain of elements. Empty list contains just its head element. Because of efficiency references to elements of a list are not checked if they are proper elements of a list or its head.

To iterate through a list efficiently, you need to use on of the list iterator class DLIterC


#include "Ravl/InDList.hh"
ostream & operator <<(ostream & s,const IntrDListC<DataT> & list)
Double-linked circular list
The IntrDListC class represents intrusive double-linked list of elements The list contains a head element and a chain of elements. Empty list contains just its head element. Because of efficiency references to elements of a list are not checked if they are proper elements of a list or its head. The class serves as a base class for more complex dynamic structures as graphs.

NB. This is a SMALL object.


#include "Ravl/Hash.hh"
ostream & operator <<(ostream & out,const HashC<K,T> & obj)

#include "Ravl/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)

#include "Ravl/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 "Ravl/Graph.hh"
ostream & operator <<(ostream & out,const GraphC<NodeT,EdgeT> & g)
Read graph from a stream.

istream & operator >>(istream & in,GraphC<NodeT,EdgeT> & g)

#include "Ravl/GraphBestRoute.hh"
DListC<GraphEdgeIterC<NodeT,EdgeT>> GraphBestRoute(const GraphC<NodeT,EdgeT> & graph,GraphNodeHC<NodeT,EdgeT> from,GraphNodeHC<NodeT,EdgeT> to,CostT & costOut,CostT (*EvalT)(const EdgeT & dat) )

#include "Ravl/StdMath.hh"
RealT Cbrt(RealT r)
Returns the cube root of 'x'.
FIXME:- We have to sort this out..

RealT Erf(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(RealT x)
Returns 1.0 - Erf(x). (Use when x is large)

RealT Log2(RealT r)
Returns logarithm to base 2.

bool IsPow2(IntT i)
Is interger power of 2 ?
Returns true if 'i' is a power of 2.

bool IsInf(RealT i)
Is infinit ?

bool IsPInf(RealT i)
Is positive infinity ?

bool IsNInf(RealT i)
Is negative infinity ?

bool IsNan(RealT i)
Is Not A Number ?

RealT Radians(RealT angle)
Convert angle from degrees to radians.

RealT Degrees(RealT angle)
Convert angle from radians to degrees.

#include "Ravl/Random.hh"
long int RandomInt(RandomSeedT & idum)
Returns an integer between 0 and RandomIntMaxValue.

long int RandomInt()
Returns an integer between 0 and RandomIntMaxValue.

double Random1(RandomSeedT & idum)
Returns a random number between 0 and 1 with a uniform distribution.

double Random1()
Returns a random number between 0 and 1 with a uniform distribution.

float RandomGauss()
Returns a Gaussian distributed zero mean random number with variance 1.0.
RandomGauss is based on Random1.

#include "Ravl/ScalMath.hh"
RealT Factorial(UIntT n)
Returns the factorial of the integer 'n'.

RealT BinomalCoeff(IntT n,IntT k)
Returns the binomial coefficient (n over k) as a real number.

#include "Ravl/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)

#include "Ravl/TFMatrix.hh"
void SetZero(TFMatrixC<DataT,N,M> & x)
Set vector to zero.

void MulAdd(const TFMatrixC<DataT,N,M> & mat,const TFVectorC<DataT,M> & vec,const TFVectorC<DataT,N> & add,TFVectorC<DataT,N> & result)
Compute result = vec * mat + add;
Unfortunatly return my value is a little slow, this gets around that by passind the location to store the result.

void Mul(const TFMatrixC<DataT,N,M> & mat,const TFVectorC<DataT,M> & vec,TFVectorC<DataT,N> & result)
Compute result = vec * mat;
Unfortunatly return my value is a little slow, this gets around that by passind the location to store the result.

void MulM(const TFMatrixC<DataT,N,M> & fmat,const TFMatrixC<DataT,M,MT> & mat,TFMatrixC<DataT,N,MT> & result)
Compute result = fmat * mat;
Unfortunatly return my value is a little slow, this gets around that by passind the location to store the result.

void TMul(const TFMatrixC<DataT,N,M> & mat,const TFVectorC<DataT,N> & vec,TFVectorC<DataT,M> & result)
Compute result = mat.T() * vec;
Transpose this matrix and multiply by 'vec'

ostream & operator <<(ostream & s,const TFMatrixC<DataT,N,M> & oth)

istream & operator >>(istream & s,TFMatrixC<DataT,N,M> & oth)

BinIStreamC & operator >>(BinIStreamC & s,TFMatrixC<DataT,N,M> & oth)

BinOStreamC & operator <<(BinOStreamC & s,const TFMatrixC<DataT,N,M> & oth)

TFMatrixC<DataT,N,M> operator *(const DataT & val,const TFMatrixC<DataT,N,M> & mat)

TFMatrixC<DataT,N,M> operator /(const DataT & val,const TFMatrixC<DataT,N,M> & mat)

TFMatrixC<DataT,N,M> operator *(const TFVectorC<DataT,N> & vec,const TFMatrixC<DataT,1,M> & mat)
Vector multiply a matrix.
The implementation for this can be found in "Ravl/TFMatrix.hh"

#include "Ravl/StringList.hh"
ostream & operator <<(ostream & s,const StringListC & list)
Saves the string list into the output stream 's'.

#include "Ravl/TypeName.hh"
const char * TypeName(const type_info & info)
Return the C++ type name for a type info instance.
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 * TypeHandleName(const type_info & info)
Lookup the name of a handle type from body type_info structure.

const char * TypeName(const char * name)
Return the C++ name for a type_info.name().
Same as TypeName(const type_info &) but uses the type_info.name() directly.

const char * RTypeName(const char * name)
Given a standardised name return the compiler specific one.
Reverse lookup. Given the stanard name find the compiler specific one.

const type_info & RTypeInfo(const char * name)
Given a standardised name return the type_info instance.
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)
Set the stanard name to be used for a particular type.

void AddTypeHandleName(const type_info & info,const char * newname)
Add body to handle type mapping.

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 in the same file as the definition of XyzC

static TypeNameC typeNameXyz(typeinfo(XyzC),"XyzC");

#include "Ravl/SubStringList.hh"
ostream & operator <<(ostream & s,const SubStringListC & list)
Saves the string list into the output stream 's'.

#include "Ravl/XMLStream.hh"
XMLOStreamC & operator <<(XMLOStreamC & strm,const XMLElementC & elem)
Output a element, well start to.

ostream & operator <<(ostream & strm,const XMLTagOpsT & elem)
Catch silly mistakes.

XMLOStreamC & operator <<(XMLOStreamC & strm,const XMLTagOpsT & elem)
Do an output stream op.

XMLIStreamC & operator >>(XMLIStreamC & strm,const XMLTagOpsT & elem)
Do an input stream op.

XMLOStreamC & operator <<(XMLOStreamC & strm,const XMLAttributeC<DataT> & elem)
Write out an attribute.

XMLIStreamC & operator >>(XMLIStreamC & strm,const XMLAttributeC<DataT> & elem)
Write out an attribute.

XMLAttributeC<DataT> XMLAttribute(const StringC & nm,const DataT & dat)
Setup an XML attribute.

XMLElementC XMLStartTag(const StringC & name)
Start writing a XML start tag.

XMLOStreamC & operator <<(XMLOStreamC & strm,const SArray1dC<DataT> & arr)

XMLIStreamC & operator >>(XMLIStreamC & strm,SArray1dC<DataT> & arr)

XMLOStreamC & operator <<(XMLOStreamC & strm,const HashC<KeyT,DataT> & elem)
Write out a hash table.
This also serves as an example.

XMLIStreamC & operator >>(XMLIStreamC & strm,HashC<KeyT,DataT> & elem)
Read in a hash table.
This also serves as an example.

#include "Ravl/Collection.hh"
ostream & operator <<(ostream & s,const CollectionC<DataT> & d)

istream & operator >>(istream & s,CollectionC<DataT> & d)

#include "Ravl/FunctionRegister.hh"
bool RegisterFunction(const char * name,DataT funcPtr)
Register function ptr.

bool LookupFunctionByName(const char * name,DataT & funcPtr)
Lookup function pointer by name.

const char * LookupFunctionByPointer(DataT & funcPtr)
Lookup function name by pointer.

bool LoadFunctionPointer(BinIStreamC & strm,DataT & funcPtr)
Load function pointer.

bool LoadFunctionPointer(istream & strm,DataT & funcPtr)
Load function pointer.

bool SaveFunctionPointer(ostream & strm,DataT & funcPtr)
Save function pointer.

bool SaveFunctionPointer(BinOStreamC & strm,const DataT & funcPtr)
Save function pointer. Register function pointer.
Class to make it easy to register functions. Use as global variables.

e.g. for class xyzC declare the following as global in a .cc file preferably in the same file as the definition of XyzC

static TypeNameC typeNameXyz(typeinfo(XyzC),"XyzC");


#include "Ravl/DP/Entity.hh"
ostream & operator <<(ostream & out,const DPEntityC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DPEntityC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DPEntityC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/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)

#include "Ravl/DP/StreamOp.hh"
DPIPortC<OutT> operator >>(const DPIPortC<InT> & in,DPIStreamOpC<InT,OutT> dat)

#include "Ravl/DP/IOJoin.hh"
DPIOPortC<InT,OutT> DPIOPortJoin(const DPIPortC<InT> & in,const DPOPortC<OutT> & out,const DPEntityC & ahold = DPEntityC (true))

#include "Ravl/DP/ProcIStream.hh"
DPIPortC<OutT> operator >>(const DPIPortC<InT> & in,const DPProcessC<InT,OutT> & proc)

DPIOPortC<OutT,InterT> operator >>(const DPIOPortC<InT,InterT> & in,const DPProcessC<InT,OutT> & proc)
////////////////////////////////////////////////////////

#include "Ravl/DP/FuncP2Proc.hh"
DPFuncP2ProcC<InT,OutT> Process(OutT (*func)(const InT &) )
Turn a function into a process.

DPProcessC<InT,OutT> operator >>(const DPProcessC<InT,InterT> & np1,OutT (*func)(InterT) )

DPProcessC<InT,OutT> operator >>(InterT (*func)(InT) ,const DPProcessC<InterT,OutT> & np1)
Constant reference versions.

DPProcessC<InT,OutT> DPFunc2Proc(OutT (*func)(const InT &) )

DPProcessC<InT,OutT> operator >>(const DPProcessC<InT,InterT> & np1,OutT (*func)(const InterT &) )

DPProcessC<InT,OutT> operator >>(InterT (*func)(const InT &) ,const DPProcessC<InterT,OutT> & np1)
Problem: No paramiter is a class type! Solution: Use the DPFunc2Proc() on one of the func ptrs.

DPProcessC<InT,OutT> operator >>(InterT (*func1)(InT) ,OutT (*func2)(InterT) )

#include "Ravl/DP/ProcCompose.hh"
DPProcessC<InT,OutT> operator >>(const DPProcessC<InT,InterT> & np1,const DPProcessC<InterT,OutT> & np2)
////////////////////////////////////////

#include "Ravl/DP/Converter.hh"
DPConverterFuncC<InT,OutT> RegisterConversion(OutT (*func)(const InT & in) ,RealT ncost = 1,const char * funcName = 0)
Register a conversion function.
Labotomise automatic type conversion. Where the conversion is required on use DP_REGISTER_CONVERTION_FT Fixed type conversion macro

#include "Ravl/DP/DataConv.hh"
bool 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.

bool DPTypeConvert(const InT & inraw,OutT & outraw)
Convert between two types using the type conversion graph.
This is an example. Its not very useful since if both types are known at compile time the necessary methods can be invoked directly.

bool DPTypeConvert(const RCWrapAbstractC & in,OutT & outraw)
Convert between a abstract handle to an object and a known type.

#include "Ravl/DP/TypeInfo.hh"
const DPTypeInfoC & TypeInfo(const type_info & ti)
Access extra information about a type.

const DPTypeInfoC & TypeInfo(const char * tn)
Access extra information about a type.

#include "Ravl/DP/FileFormatIO.hh"
bool Load(const StringC & filename,DataT & obj,StringC fileformat = "",bool verbose = false)
Load a single object.
filenamename of file containing object
objname of C++ object
fileformatformat of object file. If fileformat string is empty, the file format is detected automatically. To get a list of file formats, type conv -lf
verbose if true, a message is printed to stdout describing the filename, the format used, the object type being loaded and any status information.
More information here

bool Save(const StringC & filename,const DataT & obj,StringC fileformat = "",bool verbose = false)
Save a single object.
filenamename of file containing object
objname of C++ object
fileformatformat of object file. If fileformat string is empty, the file format is detected automatically. To get a list of file formats, type conv -lf
verbose if true, a message is printed to stdout describing the filename, the format used, the object type being loaded and any status information.
More information here

bool Load(IStreamC & is,DataT & obj,StringC fileformat = "",bool verbose = false)
Load a single object from a stream
osstream from which to load object.
objname of C++ object
fileformatformat of object file. If fileformat string is empty, the file format is detected automatically. To get a list of file formats, type conv -lf
verbose if true, a message is printed to stdout describing the filename, the format used, the object type being loaded and any status information.
More information here

bool Save(OStreamC & os,const DataT & obj,StringC fileformat = "",bool verbose = false)
Save a single object to a stream
osWhere to save the stream to.
objname of C++ object
fileformatformat of object file. If fileformat string is empty, the file format is detected automatically. To get a list of file formats, type conv -lf
verbose if true, a message is printed to stdout describing the filename, the format used, the object type being loaded and any status information.
More information here

bool Load(const StringC & filename,RCWrapAbstractC & obj,StringC fileformat,bool verbose)
Load to an abstract object handle.
NB. an instace of TypeInfoInstC must exists for the contained class if this is to work.

bool Save(const StringC & filename,const RCWrapAbstractC & obj,StringC fileformat,bool verbose)
Save an abstract object handle.
NB. an instace of TypeInfoInstC must exists for the contained class if this is to work.

DListC<FileFormatBaseC> ListFormats(bool forLoad,const StringC & fileFormat = StringC (""),const type_info & typespec = typeid (void))
List all file formats that support the given type.
forLoad == true, then for load. forLoad == false, then for save.

If fileFormat string is empty then all file formats are listed.

If typespec is void then all types are listed.


FileFormatBaseC Identify(const StringC & afile)
Identify a file.
If file format is unrecognised the returned FileFormatBaseC will be an invalid handle.

FileFormatBaseC Identify(IStreamC & is)
Identify a stream.
If file format is unrecognised the returned FileFormatBaseC will be an invalid handle.

#include "Ravl/DP/TypeConverter.hh"
TypeConverterC & SystemTypeConverter()
Default type converter used by the system.

#include "Ravl/DP/Compose.hh"
DPIOPortC<InT,OutT> operator >>(const DPIOPortC<InT,MidT> & in,DPIStreamOpC<MidT,OutT> dat)

#include "Ravl/DP/Func2Stream.hh"
DPIPortC<OutT> operator >>(const DPIPortC<InT> & in,OutT (*func)(InT) )

DPIOPortC<OutT,DataT> operator >>(const DPIOPortC<InT,DataT> & in,OutT (*func)(InT) )

DPOPortC<InT> operator >>(OutT (*func)(InT) ,const DPOPortC<OutT> & in)

DPIOPortC<DataT,InT> operator >>(OutT (*func)(InT) ,const DPIOPortC<DataT,OutT> & in)
Version with constant paramiter.

DPIPortC<OutT> operator >>(const DPIPortC<InT> & in,OutT (*func)(const InT &) )

DPIOPortC<OutT,DataT> operator >>(const DPIOPortC<InT,DataT> & in,OutT (*func)(const InT &) )

DPOPortC<InT> operator >>(OutT (*func)(const InT &) ,const DPOPortC<OutT> & in)

DPIOPortC<DataT,InT> operator >>(OutT (*func)(const InT &) ,const DPIOPortC<DataT,OutT> & in)

#include "Ravl/DP/IOConnect.hh"
DPIOConnectC<DataT> Connect(const DPIPortC<DataT> & from,const DPOPortC<DataT> & to)
///////////////////////////////////////

DPIOConnectC<DataT> operator >>(const DPIPortC<DataT> & in,const DPOPortC<DataT> & out)

DPIOConnectC<DataT> operator >>(const DPIPortC<DataT> & in,const DPIOPortC<DataT,OutT> & out)

DPOPortC<InT> operator >>(const DPIOPortC<DataT,InT> & in,const DPOPortC<DataT> & out)

void operator >>=(const DPIPortC<DataT> & in,const DPOPortC<DataT> & out)

DPIPortC<OutT> operator >>=(const DPIPortC<DataT> & in,const DPIOPortC<OutT,DataT> & out)

DPOPortC<InT> operator >>=(const DPIOPortC<DataT,InT> & in,const DPOPortC<DataT> & out)

DPIOPortC<InT,OutT> operator >>=(const DPIOPortC<DataT,OutT> & in,const DPIOPortC<InT,DataT> & out)

#include "Ravl/DP/IFailOver.hh"
DPIPortC<DataT> operator >>(const DPIPortC<DataT> & from,DPIFailOverC<DataT> & to)

#include "Ravl/DP/Multiplex.hh"
DPMultiplexC<InT,OutT> DPMultiplex(IntT num,const DPIOPortC<InT,OutT> & nproc)
Create a multiplexer.
Helper function.

DPMultiplexC<InT,OutT> DPMultiplex(const SArray1dC<DPIOPortC<InT,OutT>> & procs)
Create a multiplexer.
Helper function. //////////////////////////////////

#include "Ravl/DP/SplitO.hh"
DPOPortC<DataT> operator >>(DPSplitOC<DataT> & in,const DPOPortC<DataT> & out)

DPOPortC<DataT> operator >>(DPOPortC<DataT> & out,DPSplitOC<DataT> & in)

#include "Ravl/DP/Event.hh"
ostream & operator <<(ostream & strm,const DPEventC & obj)

istream & operator >>(istream & strm,DPEventC & obj)

#include "Ravl/DP/Method2Proc.hh"
DPMethod2ProcC<InT,OutT,ObjT> Process(const ObjT & nclass,OutT (*nmethod)(const InT &) )
Turn a function into a process.

#include "Ravl/DP/MethodIO.hh"
DPIPortC<DataT> IMethod(const ObjT & nobj,DataT (*meth)() )
Turn a class method into an input port.

DPOPortC<DataT> OMethod(const ObjT & nobj,bool (*meth)(const DataT & dat) )
Turn a class method into an output port.

#include "Ravl/DP/Plug.hh"
void operator >>(DPOPortC<DataT> & source,DPOPlugC<DataT> & output)

#include "Ravl/DP/ContainerIO.hh"
DPOPortC<typename ContainerT::ElementT> DPOContainer(ContainerT & dat)
Write out stream to container, appending to contents.

DPOPortC<typename ContainerT::ElementT> DPOContainerOverwrite(ContainerT & dat)
Write out stream to container, overwriting existing contents.

DPIPortC<typename ContainerT::ElementT> DPIContainer(const ContainerT & dat)
Use container as source for stream.

DPOContainerC<DListC<DataT>> DPOList(DListC<DataT> & dat)

DPIContainerC<DListC<DataT>> DPIList(const DListC<DataT> & dat)
//////////////////////////////////////////////////////

#include "Ravl/DP/Tap.hh"
DPProcessC<DataT,DataT> DPTap(const DPOPortC<DataT> & aport)

#include "Ravl/DP/OffsetScale.hh"
DPProcessC<NumTypeT,NumTypeT> DPOffsetScale(const NumTypeT & off,const ScaleT & fact)

#include "Ravl/DP/IOPort.hh"
ostream & operator <<(ostream & s,const DPIOPortC<InT,OutT> & port)

istream & operator >>(istream & s,DPIOPortC<InT,OutT> & port)
Input ports.

#include "Ravl/DP/RunningAverage.hh"
DPProcessC<NumTypeT,NumTypeT> DPRunningAverage(const NumTypeT & init,IntT len = 10)
Construct a running average.

#include "Ravl/DP/SequenceIO.hh"
bool OpenOSequence(DPOSPortC<DataT> & op,const StringC & fn,const StringC & fileformat = "",bool verbose = false)
Open a seekable output stream.
- Not all streams are seekable, the seek/tell functions are not garanteed to work for all formats.

- If a fileformat is a zero length string, all formats are considered. Returns TRUE on succcess.


bool OpenISequence(DPISPortC<DataT> & ip,const StringC & fn,const StringC & fileformat = "",bool verbose = false)
Open a seekable input stream.
Note: Not all streams are seekable, the seek/tell functions are not garanteed to work for all formats.

- If a fileformat is a zero length string, all formats are considered. Returns TRUE on succcess.


bool OpenOSequence(DPOPortC<DataT> & op,const StringC & fn,const StringC & fileformat = "",bool verbose = false)
Open a normal output stream
- If a fileformat is a zero length string, all formats are considered. Returns TRUE on succcess.

bool OpenISequence(DPIPortC<DataT> & ip,const StringC & fn,const StringC & fileformat = "",bool verbose = false)
Open a normal input stream
- If a fileformat is a zero length string, all formats are considered. Returns TRUE on succcess.

#include "Ravl/DP/MTIOConnect.hh"
DPMTIOConnectC<DataT> DPMTIOConnect(const DPIPortC<DataT> & from,const DPOPortC<DataT> & to)
///////////////////////////////////////

#include "Ravl/DP/ThreadPipe.hh"
DPThreadPipeC<InT,OutT> DPThread(const DPProcessC<OutT,InT> & nproc,IntT qsize = 5)
/////////////////////////////////////////

#include "Ravl/DP/Hold.hh"
DPHoldBodyC<DataT> DPHold(DataT & init)
/////////////////////////////////////////

#include "Ravl/OS/Date.hh"
bool Sleep(RealT delay)
Pause execution for 'delay' seconds.

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 "Ravl/OS/UserInfo.hh"
ostream & operator <<(ostream & out,const UserInfoC & ui)

#include "Ravl/OS/Packet.hh"
BinOStreamC & operator <<(BinOStreamC & strm,const NetPacketC & pkt)

BinIStreamC & operator >>(BinIStreamC & strm,NetPacketC & pkt)

#include "Ravl/OS/NetIPortServer.hh"
bool NetExport(const StringC & name,DPISPortC<DataT> & port)
Export ISPort.

bool NetExport(const StringC & name,DPIPortC<DataT> & port)
Export ISPort.
/////////////////////////////////////////////////

#include "Ravl/OS/NetPortManager.hh"
NetPortManagerC & GlobalNetPortManager()
Access global net port manager.

bool NetPortOpen(const StringC & addr)
Open net port manager.

#include "Ravl/Threads/Thread.hh"
void OSYield()
Yield control of processor
call if you wish a brief delay in execution. Particularly useful if you are forced to poll for an event.

UIntT CurrentThreadID()
Get ID of current running thread.

UIntT ThisThreadID()
Get ID for this thread.

#include "Ravl/Threads/Semaphore.hh"
ostream & operator <<(ostream & out,const SemaphoreC & sema)
Write out to stream.
Write the semaphore count to the stream.

istream & operator >>(istream & in,SemaphoreC & sema)
Read in from stream.
Does nothing.

#include "Ravl/Threads/LaunchThread.hh"
LaunchThreadC LaunchThread(const TriggerC & nse)
Launch a routine on another thread.

LaunchThreadC LaunchThread(bool (*nFunc)() )
Launch a routine on another thread.

LaunchThreadC LaunchThread(bool (*nFunc)(DataT &) ,const DataT & dat)
Launch a routine on another thread.

LaunchThreadC LaunchThread(bool (*nFunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)
Launch a routine on another thread.

LaunchThreadC LaunchThread(bool (*nFunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)
Launch a routine on another thread.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)() )
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)(DataT &) ,const DataT & nDat)
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &) ,const Data1T & nDat1,const Data2T & nDat2)
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3)
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3,const Data4T & nDat4)
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThread(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3,const Data4T & nDat4,const Data5T & nDat5)
Launch a method on another thread.
This calls a method on a copy of object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)() )
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)(DataT &) ,const DataT & nDat)
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &) ,const Data1T & nDat1,const Data2T & nDat2)
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3)
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3,const Data4T & nDat4)
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

LaunchThreadC LaunchThreadR(const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & nDat1,const Data2T & nDat2,const Data3T & nDat3,const Data4T & nDat4,const Data5T & nDat5)
Launch a method on another thread.
This calls a method on a reference to object 'nObj'.

#include "Ravl/Threads/TickerTrigger.hh"
ThreadC TickerTrigger(RealT ndelay,const TriggerC & nse)

ThreadC TickerTrigger(RealT ndelay,bool (*nFunc)() )

ThreadC TickerTrigger(RealT ndelay,bool (*nFunc)(DataT & dat) ,const DataT & dat)

ThreadC TickerTrigger(RealT ndelay,const ObjT & nObj,bool (*nFunc)() )

ThreadC TickerTrigger(RealT ndelay,const ObjT & nObj,bool (*nFunc)(DataT &) ,const DataT & nDat)

ThreadC TickerTrigger(RealT ndelay,const ObjT & nObj,bool (*nFunc)(Data1T &,Data2T &) ,const Data1T & nDat1,const Data2T & nDat2)

#include "Ravl/Threads/Signal.hh"
SignalConnectorC Connect(Signal0C & from,Signal0C & to)
Connect signal to another signal.

SignalConnectorC Connect(Signal0C & from,Signal0FuncBodyC::FuncT func)
Connect signal to a function with 0 args.

SignalConnectorC Connect(Signal0C & from,const DataT & obj,bool (*func)() )
Connect signal to a method with 0 args.
This holds a handle to the class to be called.

SignalConnectorC ConnectRef(Signal0C & from,DataT & obj,bool (*func)() )
Connect signal to a method with 0 args.
This holds a REFRENCE to the class to be called.

Uses reference to object not instance.

NB. It is the users responsibility to ensure the object remains valid while being used.


#include "Ravl/Threads/Signal2.hh"
ostream & operator <<(ostream & out,const Signal2C<Data1T,Data2T> &)
IO Operator.
Not implemented //////////////////////////

SignalConnectorC Connect(Signal0C & from,Signal2C<Data1T,Data2T> & oth)
Connect a signal to another signal.

#include "Ravl/Threads/Signal3.hh"
ostream & operator <<(ostream & out,const Signal3C<Data1T,Data2T,Data3T> &)
IO Operator.
Not implemented //////////////////////////

SignalConnectorC Connect(Signal0C & from,Signal3C<Data1T,Data2T,Data3T> & oth)
Connect to a signal

SignalConnectorC Connect(Signal0C & from,const ObjT & obj,bool (*func)(Data1T &,Data2T &,Data3T &) ,const Data1T & def1,const Data2T & def2,const Data3T & def3)
Connect a signal to a method.

SignalConnectorC ConnectRef(Signal0C & from,ObjT & obj,bool (*func)(Data1T &,Data2T &,Data3T &) ,const Data1T & def1,const Data2T & def2,const Data3T & def3)
Connect a signal to a method.
Uses reference to object not instance.

NB. It is the users responsibility to ensure the object remains valid while being used.


#include "Ravl/Threads/Signal1.hh"
ostream & operator <<(ostream & out,const Signal1C<DataT> &)
IO Operator.
Not implemented //////////////////////////

SignalConnectorC Connect(Signal0C & from,Signal1C<DataT> & oth)
Connect two signals together.

SignalConnectorC Connect(Signal0C & from,bool (*func)(DataT &) ,const DataT & def = DataT ())
Connect a signal to a function.

SignalConnectorC Connect(Signal0C & from,const ObjT & obj,bool (*func)(DataT & arg) ,const DataT & def = DataT ())
Connect a signal to a method.

SignalConnectorC ConnectRef(Signal0C & from,ObjT & obj,bool (*func)(DataT & arg) ,const DataT & def = DataT ())
Connect a signal to a method.
Uses reference to object not instance.

NB. It is the users responsibility to ensure the object remains valid while being used.


#include "Ravl/TVector.hh"
ostream & operator <<(ostream & s,const TVectorC<DataC> & arr)

#include "Ravl/TMatrix.hh"
TMatrixC<DataT> OuterProduct(const Slice1dC<DataT> & a,const Slice1dC<DataT> & b)
Outer product of two slices.
This treats the slices as vectors.

TMatrixC<DataT> OuterProduct(const Slice1dC<DataT> & a)
Outer product of a slice with itself.
This treats the slice as a vector.

void MulAdd(const TVectorC<DataT> & vec,const TMatrixC<DataT> & mat,const TVectorC<DataT> & add,TVectorC<DataT> & result)
Compute result = vec * mat + add;
For compatibility with the fixed length vectors.

void Mul(const TVectorC<DataT> & vec,const TMatrixC<DataT> & mat,TVectorC<DataT> & result)
Compute result = vec * mat;
For compatibility with the fixed length vectors

#include "Ravl/Matrix.hh"
bool SolveIP(MatrixC & A,VectorC & b)
Solve a general linear system A*x = b
The input vector is b, which is replaced by the ouput x.

This matrix is altered to L-U factored form by the computation.

If the input matrix is singular, false is returned and true if the operation succeeded.


VectorC Solve(const MatrixC & A,const VectorC & b)
Solve a general linear system A*x = b
Where X is the returned vector. If matrix is singular a zero length vector is returned.

VectorC SVD(const MatrixC & M)
Singular value decomposition, eg. M = U * D * V.T().
The diagonal matrix D is returned as a vector. Values for the other matrixes are not computed. If the operation failes the returned vector is invalid.

VectorC SVD_IP(MatrixC & M)
Singular value decomposition, eg. M = U * D * V.T().
The diagonal matrix D is returned as a vector. Values for the other matrixes are not computed. If the operation failes the returned vector is invalid.

NB. This function destory's the contents of this matrix!


VectorC SVD(const MatrixC & M,MatrixC & u,MatrixC & v)
Singular value decomposition, eg. M = U * D * V.T().
The diagonal matrix D is returned as a vector. This also returns the matrix u and v matrixes, the passed matrixes will be used to store the results if they are of the correct size. If the operation failes the returned vector is invalid.

VectorC SVD_IP(MatrixC & M,MatrixC & u,MatrixC & v)
Singular value decomposition, eg. M = U * D * V.T().
The diagonal matrix D is returned as a vector. This also returns the matrix u and v matrixes, the passed matrixes will be used to store the results if they are of the correct size. If the operation failes the returned vector is invalid. NB. This function destory's the contents of this matrix!

VectorC EigenValues(const MatrixC & M)
Calculate the eigen values of this matrix, for real symmetric matrices
This matrix remains unchanged. A vector of the eigen values is returned.

If any errors occured a zero length vector is generated.


VectorC EigenValuesIP(MatrixC & M)
Calculate the eigen values of this matrix, for real symmetric matrices
The contents of this matrix is destroyed. A vector of the eigen values is returned.

If any errors occured a zero length vector is generated.


VectorC EigenVectors(const MatrixC & M,MatrixC & E)
Calculate the eigen values and vectors of this matrix, for real symmetric matrices
A = E*D*E~ where D is the diagonal matrix of eigenvalues D[i,j] = ret[i] if i=j and 0 otherwise. 'ret' is the returned vector.

VectorMatrixC EigenVectors(const MatrixC & A)
Calculate the eigen values and vectors of this matrix, for real symmetric matrices
A = E*D*E~ where D is the diagonal matrix of eigenvalues D[i,j] = ret[i] if i=j and 0 otherwise. 'ret' is the returned vector and E is the returned matrix.

VectorC EigenVectorsIP(MatrixC & A)
Calculate the eigen values and vectors of this matrix, for real symmetric matrices
This matrix is filed with the eigen vectors A = E*D*E~ where D is the diagonal matrix of eigenvalues D[i,j] = ret[i] if i=j and 0 otherwise. 'ret' is the returned vector.

RealT MaxEigenValue(const MatrixC & A,VectorC & maxv)
Get the maximum eigen value and its vector, for real symmetric matrices

MatrixC RandomMatrix(int n,int m,RealT scale = 1)
Create a random matrix of values between -scale and scale with the given size.

MatrixC RandomSymmetricMatrix(int n,RealT scale = 1)
Create a random symmetric matrix of values between -scale and scale with the given size.

MatrixC RandomPositiveDefiniteMatrix(int n)
Create a random positive definite matrix.
The matrix is also symmetric in the current implementation, this may be changed at some point.

#include "Ravl/MatrixRUT.hh"
MatrixRUTC OuterProductRUT(const VectorC & vec)
Return outer product of 'vec' as a right upper triangular matrix.

MatrixRUTC OuterProductRUT(const VectorC & vec,RealT a)
Return outer product of 'vec' as a right upper triangular matrix multiplied by a.

bool SolveIP(MatrixRUTC & A,VectorC & b)
Solve a general linear system A*x = b
The input vector is b, which is replaced by the ouput x.

This matrix is altered to L-U factored form by the computation.

If the input matrix is singular, false is returned and true if the operation succeeded.


VectorC Solve(const MatrixRUTC & A,const VectorC & b)
Solve a general linear system A*x = b
Where X is the returned vector. If matrix is singular a zero length vector is returned.

#include "Ravl/MatrixRS.hh"
bool SolveIP(MatrixRSC & A,VectorC & b)
Solve a general linear system A*x = b
The input vector is b, which is replaced by the ouput x.

This matrix is altered to L-U factored form by the computation.

If the input matrix is singular, false is returned and true if the operation succeeded.


VectorC Solve(const MatrixRSC & A,const VectorC & b)
Solve a general linear system A*x = b
Where X is the returned vector. If matrix is singular a zero length vector is returned.

#include "Ravl/LeastSquares.hh"
VectorC LeastSquaresQR(const MatrixC & A,const VectorC & b)
Find a least squares solution to A*x = b
Uses the QR algorithm.

#include "Ravl/VectorMatrix.hh"
ostream & operator <<(ostream & s,const VectorMatrixC & vm)
Writes the object 'vm' into the output stream.

istream & operator >>(istream & s,VectorMatrixC & vm)
Sets the object 'vm' according to the object saved in the input stream.

#include "Ravl/MatrixDecomposition.hh"
SArray1dC<IntT> LUDecomposition(MatrixC & mat,RealT & d)
LU Decomposition with partial pivoting.
This transforms 'mat' into (L + U - I). 'd' is set to the determinant of the matrix.
The order of the rows in the matrix is changed. the mapping is returned if the decomposition was succesfull, if not an invalid array is returned.

bool LUDecompositionPD(MatrixC & mat,RealT & det)
LUDecomposition for positive definite matrices.

#include "Ravl/Vector2d.hh"
Vector2dC Angle2Vector2d(RealT angle)
Convert an angle to a unit vector in that direction.

#include "Ravl/FMatrix.hh"
bool SolveIP(FMatrixC<N,M> & mat,FVectorC<N> & b)
Solve a general linear system A*x = b
The input matix A is this one. The input vector is b, which is replaced by the ouput x.

This matrix is altered to L-U factored form by the computation.

If the input matrix is singular, false is returned and true if the operation succeeded.


FVectorC<N> Solve(const FMatrixC<N,M> & mat,const FVectorC<N> & b)
Solve a general linear system A*x = b
Where a is this matrix, and X is the returned vector. If matrix is singular a zero length vector is returned.

FVectorC<N> SVD(const FMatrixC<N,M> & mat)
Singular value decomposition, eg. mat = U * D * V.T().
The diagonal matrix D is returned as a vector. Values for the other matrixes are not computed. If the operation failes the returned vector is invalid.

FVectorC<N> SVD_IP(FMatrixC<N,M> & mat)
Singular value decomposition, eg. mat = U * D * V.T().
The diagonal matrix D is returned as a vector. Values for the other matrixes are not computed. If the operation failes an exception is thrown

NB. This function destory's the contents of this matrix!


FVectorC<M> SVD(const FMatrixC<N,M> & mat,FMatrixC<N,N> & u,FMatrixC<M,M> & v)
Singular value decomposition, eg. mat = U * D * V.T().
The diagonal matrix D is returned as a vector. This also returns the matrix u and v matrixes, the passed matrixes will be used to store the results if they are of the correct size. If the operation failes an exception will be thrown.

FVectorC<M> SVD_IP(FMatrixC<N,M> & mat,FMatrixC<N,N> & u,FMatrixC<M,M> & v)
Singular value decomposition, eg. mat = U * D * V.T().
The diagonal matrix D is returned as a vector. This also returns the matrix u and v matrixes, the passed matrixes will be used to store the results if they are of the correct size. If the operation failes the returned vector is invalid. NB. This function destory's the contents of this matrix!

void EigenValues(FMatrixC<N,M> & mat,FVectorC<N> & vec)
Calculate the eigen values of a real symmetric matrix.
This matrix remains unchanged. A vector of the eigen values is assigned to 'vec'.

void EigenValuesIP(FMatrixC<N,M> & mat,FVectorC<N> & vec)
Calculate the eigen values of a real symmetric matrix.
The contents of this matrix are destroyed. The vector is placed in 'vec'.

void EigenVectors(FMatrixC<N,M> & mat,FMatrixC<N,M> & E,FVectorC<N> & D)
Calculate the eigen values and vectors of a real symmetric matrix.
A = E*D*E~ where D is the diagonal matrix of eigenvalues D[i,j] = ret[i] if i=j and 0 otherwise. 'ret' is the returned matrix.

void EigenVectorsIP(FMatrixC<N,M> & mat,FVectorC<N> & D)
Calculate the eigen values and vectors of a real symmetric matrix.
This matrix is filed with the eigen vectors A = E*D*E~ where D is the diagonal matrix of eigenvalues D[i,j] = ret[i] if i=j and 0 otherwise. 'ret' is the returned matrix.

RealT MaxEigenValue(FMatrixC<N,M> & mat,FVectorC<N> & maxv)
Get the maximum eigen value and its vector.

#include "Ravl/Matrix2d.hh"
void MulAdd(const TFMatrixC<RealT,2,2> & R,const TFVectorC<RealT,2> & x,const TFVectorC<RealT,2> & t,TFVectorC<RealT,2> & result)

void Mul(const TFMatrixC<RealT,2,2> & R,const TFVectorC<RealT,2> & x,TFVectorC<RealT,2> & result)

void MulM(const TFMatrixC<RealT,2,2> & R1,const TFMatrixC<RealT,2,2> & R2,TFMatrixC<RealT,2,2> & result)

#include "Ravl/Matrix3d.hh"
void MulAdd(const TFMatrixC<RealT,3,3> & R,const TFVectorC<RealT,3> & x,const TFVectorC<RealT,3> & t,TFVectorC<RealT,3> & result)

void Mul(const TFMatrixC<RealT,3,3> & R,const TFVectorC<RealT,3> & x,TFVectorC<RealT,3> & result)

void MulM(const TFMatrixC<RealT,3,3> & R1,const TFMatrixC<RealT,3,3> & R2,TFMatrixC<RealT,3,3> & result)

void TMul(const TFMatrixC<RealT,3,3> & R,const TFVectorC<RealT,3> & x,TFVectorC<RealT,3> & result)

#include "Ravl/Matrix4d.hh"
void MulAdd(const TFMatrixC<RealT,4,4> & R,const TFVectorC<RealT,4> & x,const TFVectorC<RealT,4> & t,TFVectorC<RealT,4> & result)

void Mul(const TFMatrixC<RealT,4,4> & R,const TFVectorC<RealT,4> & x,TFVectorC<RealT,4> & result)

#include "Ravl/FAffine.hh"
ostream & operator <<(ostream & outS,const FAffineC<N> & vector)

istream & operator >>(istream & inS,FAffineC<N> & vector)
///////////////////////////////////////////////

#include "Ravl/LineABC2d.hh"
ostream & operator <<(ostream & outS,const LineABC2dC & line)

istream & operator >>(istream & inS,LineABC2dC & line)

#include "Ravl/Curve2d.hh"
ostream & operator <<(ostream & outS,const Curve2dC & cv)
2d Parametric Curve Body Template

#include "Ravl/Curve2dLine.hh"
ostream & operator <<(ostream & outS,const Curve2dLineC & index)
Sends the Curve2dLineC into the output stream.

#include "Ravl/Curve2dLineSegment.hh"
ostream & operator <<(ostream & strm,const Curve2dLineSegmentC & dat)
Stream output.

istream & operator >>(istream & strm,Curve2dLineSegmentC & dat)
Stream input.
//////////////////////////////////////////////

#include "Ravl/Moments2d2.hh"
ostream & operator <<(ostream & os,const Moments2d2C & mom)

istream & operator >>(istream & is,Moments2d2C & mom)

#include "Ravl/LinePP3d.hh"
RealT Distance(const Point3dC & point,const LinePP3dC & line)

ostream & operator <<(ostream & outS,const LinePP3dC & line)

istream & operator >>(istream & inS,LinePP3dC & line)
//////////////////////////////////////////////////////////

#include "Ravl/LinePV3d.hh"
ostream & operator <<(ostream & outS,const LinePV3dC & line)
Saves the 'line' into the output stream.

istream & operator >>(istream & inS,LinePV3dC & line)
Sets the 'line' according to data read from the input stream.

#include "Ravl/PlaneABCD3d.hh"
ostream & operator <<(ostream & outS,const PlaneABCD3dC & plane)

istream & operator >>(istream & inS,PlaneABCD3dC & plane)

#include "Ravl/PlanePVV3d.hh"
ostream & operator <<(ostream & outS,const PlanePVV3dC & plane)

istream & operator >>(istream & inS,PlanePVV3dC & plane)

#include "Ravl/Quatern3d.hh"
ostream & operator <<(ostream & outS,const Quatern3dC & quartern)
ouput stream operator

#include "Ravl/RigidTransform3d.hh"
VectorC ConvertRTtoV6(RigidTransform3dC 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 Quatern.hh)

RigidTransform3dC ConvertV6toRT(VectorC v)
Converts a 6 component vector containing 3 vector r and 3 vector trans to a RigidTransform3dC

ostream & operator <<(ostream & outS,const RigidTransform3dC & rt)
output stream operator

#include "Ravl/CrackCode.hh"
Index2dC CrackStep(const Index2dC & pixel,CrackCodeT crackCode)

Index2dC CrackDirection(CrackCodeT crackCode)
Crackcode or Freeman code

#include "Ravl/Edge.hh"
ostream & operator <<(ostream & s,const EdgeC & e)
Writes the elementary edge 'e' into the output stream 's'.

#include "Ravl/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.

#include "Ravl/MeanVariance.hh"
ostream & operator <<(ostream & s,const MeanVarianceC & mv)

istream & operator >>(istream & s,MeanVarianceC & mv)

#include "Ravl/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 "Ravl/MeanCovariance.hh"
ostream & operator <<(ostream & outS,const MeanCovarianceC & meanCov)
Saves the statistical description of the set 'meanCov' into the output stream 'outS'.

istream & operator >>(istream & inS,MeanCovarianceC & meanCov)
Reads and sets the statistical description of the set 'meanCov' according to the information in the input stream 'inS'.

#include "Ravl/Statistics.hh"
RealT StatNormalQ(RealT x)
Integral from x to infinity of the standard normal distribution.
return value: Qn(x) = integral of normal density from x to infinity

RealT StatNormalPercentage(RealT pc)
Compute percentage points of the standard normal distribution.
pc = probability argument (te< pc <1-te, with te=1.e-9)

return value: x = value for which Qn(x)=pc x=HUGE -> pc outside limits


RealT StatGamaQ(RealT x,RealT a)
Evaluate the cumulative gamma distribution function.
x = (0 < x), a = (0 < a) Returns integral of gamma density from x to infinity

RealT StatGamaPercentage(RealT pc,RealT a)
Evaluate the percentage points of the gamma distribution.
return value: x = value of x at which Qg(a,x)=pc, x=-1 -> pc outside limits

RealT StatBetaQ(RealT x,RealT a,RealT b)
Compute the cumulative beta, F, or Student-t distribution.
x = value of the argument (0 < x < 1)

a,b = distribution parameters (a,b > 0)

return value: Qb = integral of the beta density from 0 to x


RealT StatBetaPercentage(RealT pc,RealT a,RealT b)
Evaluate the percentage points of the beta distribution.
pc = probability argument (te< pc <1-te, with te=1.e-9)

a,b = distribution parameters (a,b > 0)

return value: x = value of x at which Qb(x,a,b)=pc x=-1 -> pc outside limits


RealT StatNonCentralGamaQ(RealT x,RealT a,RealT d)
Compute the non-central gamma cumulative distribution function.
x = value of argument (x > 0)

a = distribution parameter (a > 0)

d = non-centrality parameter (d >= 0)

return value: Qg_nc = integral of noncentral gamma density from x to infinity


RealT StatNonCentralGamaPercentage(RealT pc,RealT a,RealT d)
Evaluate percentage points of the noncentral gamma distribution.
pc = probability argument (te< pc <1-te, with te=1.e-9)

a = distribution parameter (a > 0)

d = non-centrality parameter (d >= 0)

return value: x = value of x at which Qg_nc(x,a,d)=pc x=-1 -> pc outside limits


RealT StatNonCentralBetaQ(RealT x,RealT a,RealT b,RealT d)
Compute the cumulative non-central beta distribution function.
x = value of argument (0< x <1)

a,b = distribution parameters (a,b > 0)

d = non-centrality parameter (d >= 0)

return value: Qb_nc = integral of the noncentral beta density from 0 to x


RealT StatNonCentralBetaPercentage(RealT pc,RealT a,RealT b,RealT d)
Evaluate percentage points of the noncentral beta distribution.
pc = probability argument (te< pc <1-te, with te=1.e-9)

a,b = distribution parameters (a,b > 0)

d = non-centrality parameter (d >= 0)

return value: x = value of x at which Qb_nc(x,a,b,d)=pc


#include "Ravl/Mean.hh"
ostream & operator <<(ostream & s,const MeanC & mv)

istream & operator >>(istream & s,MeanC & mv)

#include "Ravl/FMean.hh"
istream & operator >>(istream & s,FMeanC<N> & mean)
Mean in N-D space
The class MeanNdC serves for computation of the mean of a set of N-dimensional vectors.

ostream & operator <<(ostream & s,const FMeanC<N> & mean)
Saves the statistical description of the set 'mean' into the output stream 'outS'.

#include "Ravl/FMeanCovariance.hh"
ostream & operator <<(ostream & outS,const FMeanCovarianceC<N> & meanCov)
Saves the statistical description of the set 'meanCov' into the output stream 'outS'.

istream & operator >>(istream & inS,FMeanCovarianceC<N> & meanCov)
Compute the mean and covariance of an array of vectors.

#include "Ravl/Normal.hh"
ostream & operator <<(ostream & s,const NormalC & norm)

istream & operator >>(istream & s,NormalC & norm)

BinOStreamC & operator <<(BinOStreamC & s,const NormalC & norm)

BinIStreamC & operator >>(BinIStreamC & s,NormalC & norm)
Model a normal (or gauss) multi-dimensional distribution.

#include "Ravl/RealHistogram1d.hh"
ostream & operator <<(ostream & strm,const RealHistogram1dC & hist)
Write to stream.

istream & operator >>(istream & strm,RealHistogram1dC & hist)
Read from stream.

BinOStreamC & operator <<(BinOStreamC & s,const RealHistogram1dC & hist)
Binary stream IO.

BinIStreamC & operator <<(BinIStreamC & s,RealHistogram1dC & hist)
Binary stream IO.

#include "Ravl/RealHistogram2d.hh"
ostream & operator <<(ostream & strm,const RealHistogram2dC & hist)
Write to stream.

istream & operator >>(istream & strm,RealHistogram2dC & hist)
Read from stream.

BinOStreamC & operator <<(BinOStreamC & s,const RealHistogram2dC & hist)
Binary stream IO.

BinIStreamC & operator <<(BinIStreamC & s,RealHistogram2dC & hist)
Binary stream IO.

#include "Ravl/PowerSpectrum1d.hh"
Array1dC<RealT> PowerSpectrumSimple(const Array1dC<RealT> & data,int smooth = 0)
Compute the power spectrum of data with no windowing..

#include "Ravl/Convolution1d.hh"
Array1dC<DataT> Convolve1d(const Array1dC<DataT> & arr1,const Array1dC<DataT> & arr2)
Convolve arr1 and arr2 and return the result.

#include "Ravl/GenerateSignal1d.hh"
Array1dC<RealT> GenerateRandomGuass1d(SizeT size,RealT stdDeviation,RealT mean)
Generate an array containing guassian noise with specified properties.

Array1dC<RealT> GenerateGuass1d(RealT sigma,RealT mean = 0,RealT scale = 1,RealT size = 2)
Generate a 1-d guassian curve.

Array1dC<DataT> GenerateBinomial(DataT seed,SizeT size,bool doNorm = false,bool center = false)
Creates an array of binomial coefficients
(i.e. row "size" from Pascal's triangle).
E.g. Binomial(5) would create the array: 1,4,6,4,1.
Can be used as a finite approximation of a Gaussian. The "variance" of this Gaussian is (size-1)/4.
The 'seed' should be set to a unit value of the same type as the array element required. If Norm = true, the array is normalised so that the sum of the terms = 1.

#include "Ravl/PatternRec/Sample.hh"
ostream & operator <<(ostream & s,const SampleC<DataT> & dat)
Output to stream.

istream & operator >>(istream & s,SampleC<DataT> & dat)
Read from stream.

#include "Ravl/PatternRec/SampleIO.hh"
bool LoadSample(const StringC & filename,SampleC<DataT> & sample,UIntT maxSamples = ((UIntT)),const StringC & format = "",bool verbose = false)
Load sample from a file sequence

bool SaveSample(const StringC & filename,const SampleC<DataT> & sample,const StringC & format = "",bool verbose = false)
Save sample to a file sequence

#include "Ravl/PatternRec/Function1.hh"
istream & operator >>(istream & strm,Function1C & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const Function1C & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,Function1C & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const Function1C & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/Designer.hh"
istream & operator >>(istream & strm,DesignerC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DesignerC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DesignerC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DesignerC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DesignFunctionSupervised.hh"
istream & operator >>(istream & strm,DesignFunctionSupervisedC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DesignFunctionSupervisedC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DesignFunctionSupervisedC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DesignFunctionSupervisedC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DesignFunctionUnsupervised.hh"
istream & operator >>(istream & strm,DesignFunctionUnsupervisedC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DesignFunctionUnsupervisedC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DesignFunctionUnsupervisedC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DesignFunctionUnsupervisedC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/VectorLabelIO.hh"
DataSet2C<SampleC<VectorC>,SampleC<UIntT>> LoadVectorLabel(const StringC & fn)
Load a vector label dataset.

#include "Ravl/PatternRec/Distance.hh"
istream & operator >>(istream & strm,DistanceC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceEuclidean.hh"
istream & operator >>(istream & strm,DistanceEuclideanC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceEuclideanC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceEuclideanC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceEuclideanC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceMax.hh"
istream & operator >>(istream & strm,DistanceMaxC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceMaxC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceMaxC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceMaxC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceCityBlock.hh"
istream & operator >>(istream & strm,DistanceCityBlockC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceCityBlockC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceCityBlockC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceCityBlockC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceMahalanobis.hh"
istream & operator >>(istream & strm,DistanceMahalanobisC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceMahalanobisC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceMahalanobisC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceMahalanobisC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceSqrEuclidean.hh"
istream & operator >>(istream & strm,DistanceSqrEuclideanC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceSqrEuclideanC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceSqrEuclideanC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceSqrEuclideanC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DistanceRobust.hh"
istream & operator >>(istream & strm,DistanceRobustC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DistanceRobustC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DistanceRobustC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DistanceRobustC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/FuncLinear.hh"
istream & operator >>(istream & strm,FuncLinearC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncLinearC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncLinearC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncLinearC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/FuncQuadratic.hh"
istream & operator >>(istream & strm,FuncQuadraticC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncQuadraticC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncQuadraticC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncQuadraticC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/FuncOrthPolynomial.hh"
istream & operator >>(istream & strm,FuncOrthPolynomialC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncOrthPolynomialC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncOrthPolynomialC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncOrthPolynomialC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/DesignFuncLSQ.hh"
istream & operator >>(istream & strm,DesignFuncLSQC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const DesignFuncLSQC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,DesignFuncLSQC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const DesignFuncLSQC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/FuncPDF.hh"
istream & operator >>(istream & strm,FuncPDFC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncPDFC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncPDFC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncPDFC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/PatternRec/FuncPDFNormal.hh"
istream & operator >>(istream & strm,FuncPDFNormalC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncPDFNormalC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncPDFNormalC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncPDFNormalC & obj)
Save to a stream.
Uses virtual constructor.

#include "Ravl/SourceTools/RCSFile.hh"
ostream & operator <<(ostream & out,const RCSFileC & file)


Documentation by CxxDoc: Tue Aug 13 09:59:28 2002