Developer Documentation
RAVL, Recognition And Vision Library
USER 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.
StrRepC Internal string string representation
StrRepP Pointer to a string representation.
#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"

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

CallFunc0BodyC Signal Event handle
CallFunc0C Signal Event handle
CallFunc1BodyC Signal Event handle
CallFunc1C Signal Event handle
CallFunc2BodyC Signal Event handle
CallFunc2C Signal Event handle
CallFunc3BodyC Signal Event handle
CallFunc3C Signal Event handle
CallFunc4BodyC Signal Event handle
CallFunc4C Signal Event handle
CallFunc5BodyC 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"

StreamBaseC Reference counter IO stream base class.
OStreamC Standard output streams with reference counting.
IStreamC Standard input streams with reference counting.
#include "Ravl/StreamType.hh"

StreamTypeC Type of stream.
#include "Ravl/StrStream.hh"

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

BitStreamBaseC Bit stream base.
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"

RCWrapBaseBodyC RCWrapped object base class.
RCWrapAbstractC Abstract wrapped object handle.
RCWrapBodyC RCWrapper body.
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"

CallMethod0BodyC Signal Event handle
CallMethod0C Signal Event handle
CallMethod1BodyC Signal Event handle
CallMethod1C Signal Event handle
CallMethod2BodyC Signal Event handle
CallMethod2C Signal Event handle
CallMethod3BodyC Signal Event handle
CallMethod3C Signal Event handle
CallMethod4BodyC Signal Event handle
CallMethod4C Signal Event handle
CallMethod5BodyC Signal Event handle
CallMethod5C Signal Event handle
#include "Ravl/CallMethodRefs.hh"

CallMethodRef0BodyC Signal Event handle
CallMethodRef0C Signal Event handle
CallMethodRef1BodyC Signal Event handle
CallMethodRef1C Signal Event handle
CallMethodRef2BodyC Signal Event handle
CallMethodRef2C Signal Event handle
CallMethodRef3BodyC Signal Event handle
CallMethodRef3C Signal Event handle
CallMethodRef4BodyC Signal Event handle
CallMethodRef4C Signal Event handle
CallMethodRef5BodyC Signal Event handle
CallMethodRef5C Signal Event handle
#include "Ravl/FIndex.hh"

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

ConstBodyC Constant flag mix-in class.
#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/Buffer.hh"

BufferBodyC Buffer body.
BufferC Buffer handle.
#include "Ravl/CompositeBuffer.hh"

CompositeBufferBodyC Composite buffer body.
CompositeBufferC Composite buffer.
#include "Ravl/RBfAcc.hh"

RangeBufferAccessC Basic access to buffer with limited range
#include "Ravl/SBfAcc.hh"

SizeBufferAccessC Basic access to buffer with limited size
#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/Buffer2d.hh"

Buffer2dBodyC Buffer2D
Buffer2dC Buffer2D
#include "Ravl/SBfAcc2d.hh"

SizeBufferAccess2dC Basic access to buffer with limited size
#include "Ravl/RBfAcc2d.hh"

RangeBufferAccess2dC Basic access to buffer with limited size
#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/Buffer3d.hh"

Buffer3dBodyC Buffer2D
Buffer3dC Buffer3D
#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/SBfAcc3d.hh"

SizeBufferAccess3dC Access for 3D array.
#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"

BaseStackTypesG Basic stack types.
s_Blk
BaseStackC Base stack.
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"

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

HeapNodeC Heap node in pointer based priority queue.
#include "Ravl/BlkQueue.hh"

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

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

BinaryTreeBodyC Binary tree body.
#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"

BinaryTreeNodeC Node in binary tree.
BinaryTreeC Binary tree.
#include "Ravl/AVLTree.hh"

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

HashTreeC Tree of hashtables.
HashTreeNodeBodyC Base class for tree's.
HashTreeNodeC Base class for tree's.
HashTreeBodyC Tree of hashtables.
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
DListBodyC Double linked list body.
#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.
HashElemC
HashBaseC Base class for 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/GraphBase.hh"

GraphBaseBodyC
GraphNodeBaseBodyC The class GraphNodeBaseBodyC is a representation of graph node.
GraphEdgeBaseBodyC The class GraphEdgeBaseBodyC represents one edge of graph.
GraphAdjIterBaseC The class GraphAdjIterBaseC is the iterator of the list of graph adjacencies of a graph node.
GraphBaseC Reference counted graph.
GraphAdjRepC The class GraphAdjRepC represents a part of triple which is a basic element of graphs.
GraphNodeBaseC Graph node handle.
GraphEdgeBaseC Graph Edge handle.
#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/GraphNode.hh"

GraphNodeDatC Graph node data.
#include "Ravl/GraphAdj.hh"

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

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

GraphEdgeDatC Edge data.
#include "Ravl/GraphBaseLinearIter.hh"

GraphBaseLinearIterC Iterate through nodes of an acyclic directed graph in an order consistant with the nodes direction.
#include "Ravl/GraphBConIt.hh"

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

BLinkBodyC Link and data.
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/BHash.hh"

BHashEntryC Entry in the hash table.
BHashC Branching hash table.
#include "Ravl/BStack.hh"

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

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

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

BGraphEdgeBaseC Base Edge in BGraph.
BGraphBaseC Base BGraph
BGraphNodeBaseC Base Node in BGraph.
#include "Ravl/BGraphBaseIter.hh"

BGraphBaseAdjIterC Adjacency iterator base class.
#include "Ravl/BGraphBase.hh"

BGraphTypesC
#include "Ravl/BGraphEdge.hh"

BGraphEdgeC BGraph Edge.
#include "Ravl/BGraphNode.hh"

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

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

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

BGraphBaseLinearIterC Base Graph linear iterator.
#include "Ravl/BGraphBaseIter.hh"

BGraphBaseNodeIterC Node iterator base class.
#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.
XMLElementBodyC Information about the current element being processed.
XMLElementC Information about the current element being processed.
XMLBaseBodyC Common XML operations.
XMLBaseC Common XML operations.
XMLIStreamC XML Input Stream.
XMLOStreamC XML Output Stream.
#include "Ravl/XMLTree.hh"

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

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

CollectionC Collection of data
CollectionBodyC Collection of data.
#include "Ravl/DArray1d.hh"

DArray1dC Dynamic arrays.
#include "Ravl/DArray1dIter.hh"

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

DChunkC Chunk of a dynamic array.
DArray1dBodyC Dynamic arrays.
#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.
VirtualConstructorBodyC Virtual constructor base class.
VirtualConstructorInstBodyC Virtual constructor instance.
VirtualConstructorInstC Virtual constructor instance.
#include "Ravl/FunctionRegister.hh"

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

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

DPPortC Base port handle.
DataNotReadyC Exception, Data Not Ready.
DPPortBodyC Abstract port body.
DPIPortBaseBodyC Input port base body.
DPIPortBodyC Input port body.
DPOPortBaseBodyC Output port base body.
DPOPortBodyC Output port body.
DPIPortBaseC Input port base class.
DPIPortC Input port.
DPOPortBaseC Output port base.
DPOPortC Output port.
#include "Ravl/DP/Process.hh"

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

DPSeekCtrlBodyC Stream position control body class.
DPSeekCtrlStubBodyC Stub Stream position control body class.
DPSeekCtrlC Stream position control handle class.
DPISPortBodyC Seekable port input body.
DPOSPortBodyC Seekable port ouput body.
DPISPortC Seekable port input handle.
DPOSPortC Seekable port ouput handle.
#include "Ravl/DP/SPortAttach.hh"

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

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

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

DPProcOStreamBodyC Wrapped process body.
DPProcOStreamC Wrapped Proccess handle.
#include "Ravl/DP/Func2Proc.hh"

DPFunc2ProcBodyC Function body.
DPFunc2ProcC Function handle.
#include "Ravl/DP/ProcIStream.hh"

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

DPOFileBodyC Save objects to a file.
DPIFileBodyC Load objects from a file.
DPOFileC File output stream.
DPIFileC File input stream.
#include "Ravl/DP/BinFileIO.hh"

DPOBinFileBodyC Save objects in binary to a file.
DPIBinFileBodyC Load objects in binary from a file.
DPOBinFileC Binary file output stream.
DPIBinFileC Binary file input stream.
#include "Ravl/DP/FuncP2Proc.hh"

DPFuncP2ProcBodyC Function ptr to process body.
DPCPFuncP2ProcBodyC Function ptr to process, where function has a constant reg as argument.
DPFuncP2ProcC Function ptr to process handle.
#include "Ravl/DP/ProcCompose.hh"

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

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

DPConverterBaseC Converter base class
#include "Ravl/DP/TypeConverter.hh"

TypeConverterBodyC Type converter body.
#include "Ravl/DP/Converter.hh"

DPConverterBaseBodyC Converted base body class
DPConverterBodyC Data conversion body.
DPConverterC Type conversion handle.
DPConverterFuncC Setup data conversion function.
#include "Ravl/DP/TypeInfo.hh"

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

DPIPipeBaseC Pipe base.
DPOPipeBaseC Pipe base body.
DPIPipeBaseBodyC Pipe base body.
DPOPipeBaseBodyC Pipe base body.
DPIPipeBodyC IPipe body.
DPOPipeBodyC OPipe body.
DPIPipeC IPipe body.
DPOPipeC OPipe 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/FileFormat.hh"

FileFormatBodyC File format implementation.
#include "Ravl/DP/FileFormatStream.hh"

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

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

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

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

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

DPFuncIStreamBodyC Wrapped function input stream body.
DPCPFuncIStreamBodyC Wrapped function input stream body.
DPFuncOStreamBodyC Wrapped function output stream body.
DPCPFuncOStreamBodyC Wrapped function output stream body.
DPFuncIStreamC Wrapped function input stream.
DPFuncOStreamC Wrapped function output stream.
#include "Ravl/DP/IOConnect.hh"

DPIOConnectBaseBodyC IO Connector base
DPIOConnectBaseC IO Connector base
DPIOConnectBodyC Connect some IOPorts body.
DPIOConnectC Connect some IOPorts.
#include "Ravl/DP/IOTap.hh"

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

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

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

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

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

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

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

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

DPPlugBaseBodyC Input plug base.
DPPlugBaseC Input plug base.
DPIPlugBaseBodyC Input plug base.
DPIPlugBaseC Input plug base.
DPOPlugBaseBodyC Input plug base.
DPOPlugBaseC Input plug base.
DPIPlugBodyC Plug.
DPIPlugC Plug.
DPOPlugBodyC Plug.
DPOPlugC Plug.
#include "Ravl/DP/ContainerIO.hh"

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

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

DPStreamProcessBodyC Stream Process.
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/Method2Proc21.hh"

DPMethod2Proc21BodyC Access a 2 argument method to a process.
DPMethod2Proc21C Access a 2 argument method to a process.
#include "Ravl/DP/Method2Proc31.hh"

DPMethod2Proc31BodyC Access a 2 argument method to a process.
DPMethod2Proc31C Access a 2 argument method to a process.
#include "Ravl/DP/StreamOp21.hh"

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

DPIStreamOp31BodyC Stream operation base class.
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/Func2Proc21.hh"

DPFunc2Proc21BodyC Access a 2 argument func to a process.
DPFunc2Proc21C Access a 2 argument func to a process.
#include "Ravl/DP/Func2Proc31.hh"

DPFunc2Proc31BodyC Access a 2 argument func to a process.
DPFunc2Proc31C Access a 2 argument func to a process.
#include "Ravl/DP/OffsetScale.hh"

DPOffsetScaleBodyC OffsetScale and offset by value body
DPOffsetScaleC OffsetScale a stream of data.
#include "Ravl/DP/IOPort.hh"

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

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

DPFileSequenceBaseBodyC File Sequence body.
DPFileSequenceBaseC File Sequence.
DPIFileSequenceBodyC Input File Sequence
DPIFileSequenceC Input File Sequence
DPOFileSequenceBodyC Input File Sequence
DPOFileSequenceC Input File Sequence
#include "Ravl/DP/MTIOConnect.hh"

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

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

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

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

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

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

DPHoldBodyC Hold value until replaced by put.
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"

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

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

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

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

SocketC Socket connection handle.
SocketBodyC Socket connection body class.
#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"

NetMsgRegisterBodyC Net message body.
NetMsgRegisterC Net message handle.
#include "Ravl/OS/NetEndPoint.hh"

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

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

NetISPortBaseC Base class for NetIPorts.
NetISPortBodyC Input port body
NetISPortC Input port.
#include "Ravl/OS/NetIPortServer.hh"

NetISPortServerBaseBodyC Base class for NetIPorts.
NetISPortServerBodyC Input port body
NetISPortServerBaseC Input port server base.
NetISPortServerC Input port.
#include "Ravl/OS/NetPortManager.hh"

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

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

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

ThreadBodyC Called when a thread is cancelled. Thread body.
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"

MessageQueueBaseC MessageQueue base class.
MessageQueueC Thread safe queue.
#include "Ravl/Threads/LaunchThread.hh"

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

TickerTriggerBodyC Ticker body.
TickerTriggerC Ticker handle.
#include "Ravl/Threads/Signal.hh"

Signal0BodyC Signal base body.
Signal0C Signal 0 handle.
SignalConnector0BodyC 0 signal base connector.
SignalConnectorC Signal connector handle.
SignalInterConnect0BodyC class for signal interconnector with 0 args.
SignalInterConnect0C class for signal interconnector with 0 args.
Signal0FuncBodyC Signal a function.
Signal0FuncC Signal a function
Signal0MethodBodyC Signal a method
Signal0MethodC Signal a method.
Signal0MethodRefBodyC Signal a method
Signal0MethodRefC Signal a method.
#include "Ravl/Threads/TimedTriggerQueue.hh"

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

Signal2C Signal with 2 arguments
SignalConnector2BodyC Signal 1 connector.
SignalInterConnect2BodyC Signal 2 inter connector.
SignalInterConnect2C class for signal interconnector with 1 arg.
Signal2FuncBodyC Signal 1 function connector.
Signal2FuncC Signal a function
Signal2MethodBodyC Signal 2 method connector.
Signal2MethodC Signal a method.
Signal2MethodRefBodyC Signal 2 method connector.
Signal2MethodRefC Signal a method.
Signal2BodyC Signal 1 body.
#include "Ravl/Threads/Signal3.hh"

Signal3C Signal with 3 arguments.
SignalConnector3BodyC Signal 1 connector.
SignalInterConnect3BodyC Signal 3 inter connector.
SignalInterConnect3C class for signal interconnector with 1 arg.
Signal3FuncBodyC Signal 1 function connector.
Signal3FuncC Signal a function
Signal3MethodBodyC Signal 1 method connector.
Signal3MethodC Signal a method.
Signal3MethodRefBodyC Signal 1 method connector.
Signal3MethodRefC Signal a method.
Signal3BodyC Signal 1 body.
#include "Ravl/Threads/Signal1.hh"

Signal1C Signal with 1 argument
SignalConnector1BodyC Signal 1 connector.
SignalInterConnect1BodyC Signal 1 inter connector.
SignalInterConnect1C class for signal interconnector with 1 arg.
Signal1FuncBodyC Signal 1 function connector.
Signal1FuncC Signal a function
Signal1MethodBodyC Signal 1 method connector.
Signal1MethodC Signal a method.
Signal1MethodRefBodyC Signal 1 method connector.
Signal1MethodRefC Signal a method.
Signal1BodyC Signal 1 body.
#include "Ravl/Threads/SignalConnectionSet.hh"

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

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

TextBufferBodyC Text buffer body
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.
ConfigFileBodyC Iterate variables. Config file body.
#include "Ravl/Text/TemplateComplex.hh"

TemplateComplexC Complex template body.
TemplateComplexBodyC 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"

Curve2dBodyC 2d Parametric curve base class
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"

FFT1dBodyC Interface class for 1d FFTW
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"

FFT2dBodyC 2d FFT
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
DataSetBaseBodyC Data set base class.
#include "Ravl/PatternRec/SampleLabel.hh"

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

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

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

DataSet3C Data set
DataSet3BodyC Data set
#include "Ravl/PatternRec/Function.hh"

FunctionBodyC Map an input vector to an output vector.
FunctionC Map an input vector to an output vector.
#include "Ravl/PatternRec/Function1.hh"

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

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

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

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

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

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

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

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

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

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

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

FuncLinearCoeffBodyC Function with linear coeffiecents.
FuncLinearCoeffC Function with linear coeffiecents.
#include "Ravl/PatternRec/FuncLinear.hh"

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

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

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

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

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

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

ReduceBodyC Dimension Reduction.
ReduceC Dimension Reduction.
#include "Ravl/PatternRec/ReduceSubset.hh"

ReduceSubsetBodyC Reduce dimension by taking a subset of features.
ReduceSubsetC Reduce dimension by taking a subset of features.
#include "Ravl/PatternRec/ReducePCA.hh"

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

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

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

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

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

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

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

ClassifyDiscriminantFunctionBodyC Create a classifier based on a descriminant function.
ClassifyDiscriminantFunctionC Create a classifier based on a descriminant function.
#include "Ravl/PatternRec/ClassifyAverageNearestNeighbour.hh"

ClassifyAverageNearestNeighbourBodyC ClassifyAverage k nearest neighbour classifier.
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.
RCSFileBodyC Class for dealing with RCS files.
#include "Ravl/SourceTools/SourceFile.hh"

SourceFileBodyC Source File Body
SourceFileC Source File Body
#include "Ravl/SourceTools/LibInfo.hh"

HeaderInfoC Header info.
LibInfoBodyC Information about library.
LibInfoC Information about library.
#include "Ravl/SourceTools/ProgInfo.hh"

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

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

AutoPortSourceC Code Porting tool.
AutoPortSourceBodyC Code Porter Body
#include "Ravl/SourceTools/AutoPortGenerator.hh"
ContextC Access info about current lib.
AutoPortGeneratorBodyC Auto port engine
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/GraphBase.hh"
enum GraphTypeT { GRAPH_DIRECTED, GRAPH_UNDIRECTED } ;
The class GraphAdjRepC represents a part of triple which is a basic element of graphs.
One can imagine that every edge has two touch points, so call adjacencies, that connect nodes and edge together. Each node is connected to the edge through one adjacency. Because of effectivity, the representation of adjacency contains only the pair . The access to the nodeA is solved outside of the this class.

#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/Trigger.hh"
typedef void (*VoidFuncPtrT)() ;
Void function pointer.

#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 */

#include "Ravl/Text/ConfigFile.hh"
typedef HashIterC<StringC,StringC> ConfigFileIterVarC;
Iterate variables. Config file body.

Variables:

#include "Ravl/GraphNode.hh"
const int GraphNodeDat_CheckNum = 0 x12345678;
Graph node data.

#include "Ravl/GraphEdge.hh"
const int GraphEdgeDat_CheckNum = 0 x56781234;
Edge data.

#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/DP/BinFileIO.hh"
static const UInt16T RAVLBinaryID = 0 x4143;
Save objects in binary to a file.
Object must have a binary stream output function.

#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 fcompare(const StringC & x,const StringC & y)
Internal string string representation

StrRepC * Salloc(StrRepC *,const char *,int,int)

StrRepC * Scopy(StrRepC *,const StrRepC *)

StrRepC * Scat(StrRepC *,const char *,int,const char *,int)

StrRepC * Scat(StrRepC *,const char *,int,const char *,int,const char *,int)

StrRepC * Sprepend(StrRepC *,const char *,int)

StrRepC * Sreverse(const StrRepC *,StrRepC *)

StrRepC * Supcase(const StrRepC *,StrRepC *)

StrRepC * Sdowncase(const StrRepC *,StrRepC *)

StrRepC * Scapitalize(const StrRepC *,StrRepC *)

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/RBfAcc.hh"
ostream & operator <<(ostream & out,const RangeBufferAccessC<DataT> & dat)
Read buffer from stream.
NB. The buffer must be pre-allocated.

istream & operator >>(istream & strm,RangeBufferAccessC<DataT> & dat)
Wrtie buffer to stream.
NB. This size of the buffer is NOT written.

BinOStreamC & operator <<(BinOStreamC & out,const RangeBufferAccessC<DataT> & dat)
Read buffer from stream.
NB. The buffer must be pre-allocated.

BinIStreamC & operator >>(BinIStreamC & strm,RangeBufferAccessC<DataT> & dat)

#include "Ravl/SBfAcc.hh"
ostream & operator <<(ostream & out,const SizeBufferAccessC<DataT> & dat)
Read buffer from stream.
NB. The buffer must be pre-allocated.

istream & operator >>(istream & strm,SizeBufferAccessC<DataT> & dat)
Wrtie buffer to stream.
NB. This size of the buffer is NOT written.

BinOStreamC & operator <<(BinOStreamC & out,const SizeBufferAccessC<DataT> & dat)
Read buffer from stream.
NB. The buffer must be pre-allocated.

BinIStreamC & operator >>(BinIStreamC & strm,SizeBufferAccessC<DataT> & dat)

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

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

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

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

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

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

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

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

#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 &,DListBodyC<DataT> &)
Double linked list body.
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.


ostream & operator <<(ostream & strm,const DListC<DataT> & lst)
Send to stream.

istream & operator >>(istream & strm,DListC<DataT> & lst)
Read from stream.

BinOStreamC & operator <<(BinOStreamC & strm,const DListC<DataT> & lst)
Write to a binary stream.

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)

istream & operator >>(istream & out,HashC<K,T> & obj)
Base class for table.
BIG OBJECT!

Use HashART in HashAR.hh in preference to this, in nearly every case its faster.

The following amma classes can be used as a key for this template:

StringC, Index2dC, Index3dC, IndexNdC, PixelC, RGBValueC, RGBValueU16C, ByteRGBValueC, RGBXValueC(Doesn't use X component.)

If you want a class added e-mail me.


ostream & operator <<(ostream & out,const HashElemC<K,T> & obj)

istream & operator >>(istream & in,HashElemC<K,T> & obj)

BinOStreamC & operator <<(BinOStreamC & out,const HashElemC<K,T> & obj)

BinIStreamC & operator >>(BinIStreamC & in,HashElemC<K,T> & obj)
/////////////////////////////////////////////////////////////////

BinOStreamC & operator <<(BinOStreamC & out,const HashC<K,T> & obj)

BinIStreamC & operator >>(BinIStreamC & in,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/GraphBase.hh"
ostream & operator <<(ostream & s,const GraphAdjRepC & link)
The class GraphEdgeBaseBodyC represents one edge of graph.

ostream & operator <<(ostream & s,const GraphEdgeBaseBodyC & edge)
The class GraphNodeBaseBodyC is a representation of graph node.
It can be linked into a list of graph node. An instance of thist class contains information about the edges which go into the node and which go out.

#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 BaseFunctionRegister(const char * name,void * ptr,int size,const type_info & ti)
Register function pointer.

bool BaseFunctionLookupByName(const char * name,void * ptr,int size,const type_info & ti)
Register function pointer.

const char * BaseFunctionLookupByPointer(void * ptr,int size,const type_info & ti)
Lookup function by pointer.

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"
istream & operator >>(istream & strm,DPEntityC & obj)
Data processing entity body.
This is the base class for most of the classes in data processing system. It main function is to provide a virtual 'save' function.

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)

istream & operator >>(istream & s,DPIPortC<DataT> & port)
Output port base.

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"
void DPIncludeStdConverters()
Converted base body class
This base body class provides an abstract interface to a particular type conversion.

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.

DPIPortBaseC BaseLoad(const StringC & filename,StringC fformat,const type_info & obj_type,bool verbose = false)
Base load function.
If fileformat string is empty, the file format is detected automaticly. When verbose flag is true, a message is printed to stdout describing the filename, the format used and the object type being loaded.

DPOPortBaseC BaseSave(const StringC & filename,StringC fformat,const type_info & obj_type,bool verbose = false)
Base save function.
If fileformat string is empty, the default file format for the type is used. When verbose flag is true, a message is printed to stdout describing the filename, the format used and the object type being saved.

DPIPortBaseC BaseLoad(IStreamC & is,StringC fformat,const type_info & obj_type,bool verbose = false)
Base load function for streams.
If fileformat string is empty, the file format is detected automaticly. When verbose flag is true, a message is printed to stdout describing the filename, the format used and the object type being loaded.

DPOPortBaseC BaseSave(OStreamC & os,StringC fformat,const type_info & obj_type,bool verbose = false)
Base save function for streams
If fileformat string is empty, the default file format for the type is used. When verbose flag is true, a message is printed to stdout describing the filename, the format used and the object type being saved.

#include "Ravl/DP/TypeConverter.hh"
TypeConverterC & SystemTypeConverter()
Default type converter used by the system.

#include "Ravl/DP/FileFormatRegistry.hh"
FileFormatRegistryC & SystemFileFormatRegistry()
Access the system's format registry.

#include "Ravl/DP/CoreIO.hh"
void InitCoreIO()
Initalise core IO.

void InitFixedIndexIO()
Initalise Fixed size index io methods.

#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 >>(DPIPortC<DataT> & source,DPIPlugC<DataT> & input)
Plug.
Used for setting up inputs.

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/Method2Proc21.hh"
DPMethod2Proc21C<In1T,In2T,Out1T,ObjT> Process(const ObjT & obj,Out1T (*method)(const In1T &,const In2T &) )
Create a process from a method.

#include "Ravl/DP/Method2Proc31.hh"
DPMethod2Proc31C<In1T,In2T,In3T,Out1T,ObjT> Process(const ObjT & obj,Out1T (*method)(const In1T &,const In2T &,const In3T &) )
Create a process from a method.

#include "Ravl/DP/Func2Proc21.hh"
DPFunc2Proc21C<In1T,In2T,Out1T> Process(Out1T (*func)(const In1T &,const In2T &) )
Create a process from a func.

#include "Ravl/DP/Func2Proc31.hh"
DPFunc2Proc31C<In1T,In2T,In3T,Out1T> Process(Out1T (*func)(const In1T &,const In2T &,const In3T &) )
Create a process from a func.

#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 OpenISequenceBase(DPIPortBaseC & ip,DPSeekCtrlC & sc,const StringC & filename,const StringC & fileformat,const type_info & obj_type,bool verbose = false)
Open input stream base.
Returns TRUE on succcess.

bool OpenOSequenceBase(DPOPortBaseC & op,DPSeekCtrlC & sc,const StringC & filename,const StringC & fileformat,const type_info & obj_type,bool verbose = false)
Open output stream base.
Returns TRUE on succcess.

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 NetExportBase(const StringC & name,NetISPortServerBaseC & isp)
Export ISPort.

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.

void * StartThread(void * Data)
Use internally to start threads.

void cancellationHandler(void * data)
Called when a thread is cancelled. Thread body.

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"
ostream & operator <<(ostream & os,const SignalConnectorC & sc)
class for signal interconnector with 0 args.

ostream & operator <<(ostream & out,const Signal0C &)
Signal a function.

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/MathIO.hh"
void InitMathIO()
Initalise all the math IO.

void InitFixedVectorIO()

void InitFixedPointIO()

void InitFixedMatrixIO()

#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/Function.hh"
istream & operator >>(istream & strm,FunctionC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FunctionC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FunctionC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FunctionC & obj)
Save to a stream.
Uses virtual constructor.

#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/FuncLinearCoeff.hh"
istream & operator >>(istream & strm,FuncLinearCoeffC & obj)
Load from a stream.
Uses virtual constructor.

ostream & operator <<(ostream & out,const FuncLinearCoeffC & obj)
Save to a stream.
Uses virtual constructor.

BinIStreamC & operator >>(BinIStreamC & strm,FuncLinearCoeffC & obj)
Load from a binary stream.
Uses virtual constructor.

BinOStreamC & operator <<(BinOStreamC & out,const FuncLinearCoeffC & 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:27 2002