VoxSetArrayC<class DataC> -

Developer Documentation

Centre for Vision, Speech & Signal Processing

Comments:
============================================================ Voxel Set stored as run-length encode array

Parent Classes:

BaseVoxSetC

Variables:

BucketArray3to2dC bucket;: ---------------------------------- Encoding TriSetC in VoxSetArrayC
SArray1dC buffer;: handle to unused buffer string
SArray1dC return_buffer;: handle to unused buffer string ------------------------------------------------- friend ostream & operator<<(ostream & s, const VoxSetC & t); friend ostream & operator<<(ostream & s,VoxSetC & t);

Methods:

VoxSetArrayC(): empty
VoxSetArrayC(const Vector3dC xmin,const Vector3dC xmax,const RealT resolution,const RealT distance): setup an empty volumetric frame dimensions [xmin,xmax] voxel 'resolution' encode surface thickness +/- distance
VoxSetArrayC(const TriSetC triset): voxel encode 'triset' dimensions = limits of triset resolution = average edge lenght of triset surface thickness = 2*resolution encode scheme = 2: vertex normal fusion scheme = 0: nearest only (weight scheme = 1: weighted ave) - not used for fusion
VoxSetArrayC(const VoxSetArrayC & vox): copy
const VoxSetArrayC operator=(const VoxSetArrayC & vox): assignment --------------------------------- Operations
DataC NearestPoint(const Vector3dC & v): return voxel corresponding to nearest point on surface to 'v'
DataC NearestPointRecursive(const Vector3dC & v): recursive nearest point search UNTESTED
RealT SignedDistance(const Vector3dC v,BooleanT & valid): return distance + validity (valid if non-boundary voxel found)
RealT SignedDistance(const Vector3dC v): distance to surface in range [-dmax,dmax] test if valid
BooleanT IsValidSignedDistance(const RealT d): inside range [-dmax,dmax] ---------------------------------- Public Operations
DataC Get(const Index3dC i): reference to voxel with index i or invalid voxel if voxel does not exist
DataC Get(const Vector3dC v): reference to voxel with index of v or invalid voxel if voxel does not exist
IntT MemoryUsed(): no. of bytes of mem used to store volumetric rep.
IntT MemoryAllocated(): no. of bytes of mem. used with buffer redundancy.
DataC GetRecursive(const Vector3dC v): Recursive search for voxel with zero-set nearest to v
DataC GetArrayRecursive(const Vector3dC v): Resursive search based on 2d internal bucket encoding of 3D space
void Put(const DataC vox): put voxel data into structure void Remove(const DataC vox); // not inculded for template instantiation remove voxel data from structure
void EncodeSetup(Vector3dC xmin,Vector3dC xmax,RealT resolution): initialise internal volumetric representation
void EncodePoint(const TriC & tri,const Vector3dC v,const Vector3dC view_normal)
void EncodePoint(const TriC & tri,const Vector3dC v,const Vector3dC view_normal,TriNearestPointC & np): ------------------------------------------------- Access/Encode in RLE
SArray1dC<VoxRealT> & GetString(const Index3dC & i): Get the RLE char array corresponting to (i[0],i[1]) in bucket plane
DataC StringGet(const Index3dC i): Get voxel data
DataC StringGet(const Vector3dC v): Get voxel data
DataC StringGet(SArray1dC<VoxRealT> & s,const IntT istart,const Index3dC i): Get voxel data stored at s[istart] with index 'i'
DataC StringGetNearest(SArray1dC<VoxRealT> & s,const Index3dC & i,const Vector3dC & v): Get nearest voxel to 'v' in s where (i[0],i[1]) is the index for s and i[2]=Index(v)[2]
DataC StringGetNearestGuaranteed(SArray1dC<VoxRealT> & s,const Index3dC & i,const Vector3dC & v): Nearest to all data in string
DataC StringGetNearestApprox(SArray1dC<VoxRealT> & s,const Index3dC & i,const Vector3dC & v): Nearest to data in string with same k value or prev/next to k value
void StringPut(const DataC vox): Put voxel data
IntT StringPut(SArray1dC<VoxRealT> & s,const IntT istart,const DataC vox): Put voxel data
IntT StringPut(SArray1dC<VoxRealT> & s,const IntT istart,const IntT nempty): put empty space
void StringSplit(SArray1dC<VoxRealT> & s,const IntT index,const IntT kprev,const IntT k,const DataC vox)
void StringInit(SArray1dC<VoxRealT> & s,const DataC vox)
IntT StringFind(SArray1dC<VoxRealT> & str,const IntT k)
IntT StringFind(SArray1dC<VoxRealT> & str,const IntT k,IntT & kcount): find array index for k^th item kcount is the total k prior to this item return -1 if item not found
IntT StringFindPrevNext(SArray1dC<VoxRealT> & str,const IntT k,IntT & iprev,IntT & kprev,IntT & inext,IntT & knext)
IntT StringFindPrevNext(SArray1dC<VoxRealT> & str,const IntT k,IntT & kcount,IntT & iprev,IntT & kprev,IntT & inext,IntT & knext): find array index for k^th item + iprev and inext array index for prev& next data items which are kprev^th and knext^th items return -1 for k^th item & iprev,inext if not found
void StringCopy(SArray1dC<VoxRealT> & s,const IntT istart,const IntT iend,SArray1dC<VoxRealT> & snew,const IntT inew)
void StringMerge(SArray1dC<VoxRealT> & s0,SArray1dC<VoxRealT> & s1): merge s1 from external VoxSet into s0 from this VoxSet
void StringCheck(SArray1dC<VoxRealT> & s)
void StringPrint(SArray1dC<VoxRealT> & s): ------------------------------------------------- functions for efficient string allocation
SArray1dC<VoxRealT> StringNew(SArray1dC<VoxRealT> sold,const IntT size)
IntT StringDataSize(SArray1dC<VoxRealT> s)
void StringSetSize(SArray1dC<VoxRealT> s,const IntT size)
IntT StringMaxDataSize(SArray1dC<VoxRealT> s): void StringShift(SArray1dC s,IntT index,IntT shift); removed for template instantiation shift contents of string shift >=0 const IntT buffer_size(200); // length of string buffer blocks

#include "amma/BVoxSet.hh"

void operator=(const BaseVoxSetC & vox): assignment --------------------------------- Internal Computation
void SetEncodeScheme(const IntT type): Volumetric Encoding Scheme 1: View Direction 2: Vertex Normal Direction (default) 3: Element Normal Direction
void SetWeightScheme(const IntT type): Weight Scheme 0: Constant weight 1: Constant Normal Weighted (default) 2: Ramp Normal Weighted
void SetFusionScheme(const IntT type): Fusion Scheme 0: Nearest Only 1: Weighted Average (default) 2: Weighted Average + Normal (-1: No Fusion)
IntT FusionType() const: return Fusion scheme used
RealT MinimumNormalCosine() const: Minimum angle cosine between surface normals for fusion used in fusion with Normal --------------------------------- Operations
IntT Size() const: number of voxel in each dimension
RealT Resolution() const: voxel resolution
Vector3dC LowerLimit() const: Lower limit of volume dimensions
Vector3dC UpperLimit() const: Upper limit of volume dimensions
RealT MaximumSignedDistance() const: maximum distance of voxel centre from surface for volume encoding
BooleanT InRange(const Vector3dC & p): returns TRUE if point 'p' is inside the volume, FALSE otherwise
Index3dC Index(const Vector3dC p): Index for (xyz) point
void NormalVolumeBoundingBox(const TriC & tri,Index3dC & imin,Index3dC & imax): Voxel Index limits for bounding box on normal volume of tri
void IndexLimits(const Vector3dC v,Index3dC & imin,Index3dC & imax): Index limits for encoding a volume
Vector3dC Vector(const Index3dC i): point from index --------------------------------- Add data to volume
void AddTriSet(TriSetC & tri): Encode mesh 'tri' into volumetric representation encoded in view direction = average normal
void AddTriSet(TriSetC & tri,Vector3dC view_normal): Encode mesh 'tri' into volumetric representation in drn of view normal
void InsertElement(const TriC & tri): insert element with confidence =1 (no viewpoint info)
void InsertElement(const TriC & tri,const Vector3dC normal_direction): insert element with view point info.
void EncodeSetup(Vector3dC xmin,Vector3dC xmax,RealT resolution,RealT distance)
IntT IndexRange(const IntT k): IntT Index3to1(const Index3dC i) const; Index3dC Index1to3(const IntT i) const;
RealT MaximumWeight() const: ------------------------------------------------ Encoding Triangulation
void InsertElement(TriSetC & triset,Vector3dC view_normal): insert all elements in 'triset' with view point direction 'view_normal'
void InsertElementView(const TriC & tri,const Vector3dC view_normal): Encode element volume in 'view normal' direction
void InsertElementNormal(const TriC & tri,const Vector3dC view_normal): Encode element volume in vertex normal direction element confidence = 'view_normal'.element normal
void EncodePoint(const TriC & tri,const Vector3dC v,const Vector3dC view_normal)
void EncodePoint(const TriC & tri,const Vector3dC v,const Vector3dC view_normal,TriNearestPointC & np)
VoxRealT EncodeDistance(const RealT d) const: [-dmax,dmax] => [0,255]
RealT DecodeDistance(const VoxRealT d) const: [0,255] => [-dmax,dmax]
VoxRealT EncodeWeight(const RealT w) const: [0,wmax] => [0,255]
RealT DecodeWeight(const VoxRealT w) const: [0,255] => [0,wmax]
VoxRealT EncodeNormal(const RealT n) const: [-1,1] => [0,255]
RealT DecodeNormal(const VoxRealT n) const: [0,255] => [-1,1]
Index3dC EncodePoint(const Vector3dC v) const: [xmin,xmax] => [0,2^16]
Vector3dC DecodePoint(const Index3dC i) const: [0,2^16] => [xmin,xmax]
ostream & operator<<(ostream & s,BaseVoxSetC & t)

Programmer:Adrian Hilton, Documentation by CxxDoc: Tue Mar 20 10:49:27 2001

VoxSetArrayC<class DataC>

include	"amma/VoxSet.hh"
User Level:	Default
Library:	vox
Example:	cri.cc
Section:	default.Adrian Hilton
In Scope:	std