PUBLIC

BaseVoxSetC::BaseVoxSetC(void) BaseVoxSetC::BaseVoxSetC(const Vector3dC,const Vector3dC,const RealT,const RealT) BaseVoxSetC::BaseVoxSetC(const BaseVoxSetC &) BaseVoxSetC::~BaseVoxSetC(void) BaseVoxSetC::operator=(const BaseVoxSetC &) BaseVoxSetC::SetEncodeScheme(const IntT) BaseVoxSetC::SetWeightScheme(const IntT) BaseVoxSetC::SetFusionScheme(const IntT) BaseVoxSetC::FusionType(void) const BaseVoxSetC::MinimumNormalCosine(void) const BaseVoxSetC::Size(void) const BaseVoxSetC::Resolution(void) const BaseVoxSetC::LowerLimit(void) const BaseVoxSetC::UpperLimit(void) const BaseVoxSetC::MaximumSignedDistance(void) const BaseVoxSetC::InRange(const Vector3dC &) BaseVoxSetC::Index(const Vector3dC) BaseVoxSetC::NormalVolumeBoundingBox(const TriC &,Index3dC &,Index3dC &) BaseVoxSetC::IndexLimits(const Vector3dC,Index3dC &,Index3dC &) BaseVoxSetC::Vector(const Index3dC) BaseVoxSetC::AddTriSet(TriSetC &) BaseVoxSetC::AddTriSet(TriSetC &,Vector3dC) BaseVoxSetC::InsertElement(const TriC &) BaseVoxSetC::InsertElement(const TriC &,const Vector3dC) BaseVoxSetC::EncodeSetup(Vector3dC,Vector3dC,RealT,RealT) BaseVoxSetC::IndexRange(const IntT) BaseVoxSetC::MaximumWeight(void) const BaseVoxSetC::InsertElement(TriSetC &,Vector3dC) BaseVoxSetC::InsertElementView(const TriC &,const Vector3dC) BaseVoxSetC::InsertElementNormal(const TriC &,const Vector3dC) BaseVoxSetC::EncodePoint(const TriC &,const Vector3dC,const Vector3dC) BaseVoxSetC::EncodePoint(const TriC &,const Vector3dC,const Vector3dC,TriNearestPointC &) BaseVoxSetC::EncodeDistance(const RealT) const BaseVoxSetC::DecodeDistance(const VoxRealT) const BaseVoxSetC::EncodeWeight(const RealT) const BaseVoxSetC::DecodeWeight(const VoxRealT) const BaseVoxSetC::EncodeNormal(const RealT) const BaseVoxSetC::DecodeNormal(const VoxRealT) const BaseVoxSetC::EncodePoint(const Vector3dC) const BaseVoxSetC::DecodePoint(const Index3dC) const BaseVoxSetC::operator<<(ostream &,BaseVoxSetC &)

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

Comments:
------------------------ ================================================================= #include "amma/Vox.hh" #include "amma/Status.hh" ============================================================ BaseVoxSetC data structure not dependent on the voxel data type

VoxSetC
VoxSetArrayC

const IntT bucket_size;

= 200; no. of grid slots in u,v projection plane (defualt size)

const RealT max_weight;

= 10.0; // maximum weight value reqd for VoxDataC

const IntT encode_type_default;

= 2;

const IntT weight_type_default;

= 1;

const IntT fusion_type_default;

= 1; ------------------------------------ Volumetric Representation

IntT voxel_size;

RealT voxel_resolution;

Vector3dC voxel_xmin;

Vector3dC voxel_xmax;

RealT max_distance;

RealT ramp_distance;

RealT min_normal_cos;

IntT encode_type;

IntT weight_type;

IntT fusion_type;

--------------------------------- Voxel Encoding functions for VoxDataC

BaseVoxSetC()

empty

BaseVoxSetC(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

BaseVoxSetC(const BaseVoxSetC & vox)

copy

~BaseVoxSetC()

Destructor.
Needed to keep the version gcc egcs-1.0.2 happy. const BaseVoxSetC operator=(const BaseVoxSetC& vox);

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)