G3D::_internal::Welder Class Reference

Public Types
enum	{ GRID_RES = 32 }
typedef Array< int >	List

Public Member Functions
	Welder (const Array< Vector3 > &_oldVertexArray, Array< Vector3 > &_newVertexArray, Array< int > &_toNew, Array< int > &_toOld, float _radius)
void	toGridCoords (Vector3 v, int &x, int &y, int &z) const
int	getIndex (const Vector3 &vertex)
void	weld ()

Public Attributes
List	grid [GRID_RES][GRID_RES][GRID_RES]
const Array< Vector3 > &	oldVertexArray
Array< Vector3 > &	newVertexArray
Array< int > &	toNew
Array< int > &	toOld
const float	radius
Vector3	offset
Vector3	scale

Private Member Functions
Welder &	operator= (const Welder &w)

Member Typedef Documentation

typedef Array<int> G3D::_internal::Welder::List

Indices of newVertexArray elements in or near a grid cell.

Member Enumeration Documentation

anonymous enum

Enumerator
GRID_RES

{GRID_RES = 32};

Constructor & Destructor Documentation

G3D::_internal::Welder::Welder	(	const Array< Vector3 > &	_oldVertexArray,
		Array< Vector3 > &	_newVertexArray,
		Array< int > &	_toNew,
		Array< int > &	_toOld,
		float	_radius
	)

 :
 oldVertexArray(_oldVertexArray),
 newVertexArray(_newVertexArray),
 toNew(_toNew),
 toOld(_toOld),
 radius(_radius) {

 // Compute a scale factor that moves the range
 // of all ordinates to [0, 1]
 Vector3 minBound = Vector3::inf();
 Vector3 maxBound = -minBound;

 for (int i = 0; i < oldVertexArray.size(); ++i) {
 minBound = minBound.min(oldVertexArray[i]);
 maxBound = maxBound.max(oldVertexArray[i]);
 }

 offset = minBound;
 scale = maxBound - minBound;
 for (int i = 0; i < 3; ++i) {
 // The model might have zero extent along some axis
 if (fuzzyEq(scale[i], 0.0f)) {
 scale[i] = 1.0;
 } else {
 scale[i] = 1.0f / scale[i];
 }
 }
}

Here is the call graph for this function:

Member Function Documentation

int G3D::_internal::Welder::getIndex

(

const Vector3 &

vertex

)

Gets the index of a vertex, adding it to newVertexArray if necessary.

 {

 int closestIndex = -1;
 double distanceSquared = inf();

 int ix, iy, iz;
 toGridCoords(vertex, ix, iy, iz);

 // Check against all vertices within radius of this grid cube
 const List& list = grid[ix][iy][iz];

 for (int i = 0; i < list.size(); ++i) {
 double d = (newVertexArray[list[i]] - vertex).squaredMagnitude();

 if (d < distanceSquared) {
 distanceSquared = d;
 closestIndex = list[i];
 }
 }

 if (distanceSquared <= radius * radius) {

 return closestIndex;

 } else {

 // This is a new vertex
 int newIndex = newVertexArray.size();
 newVertexArray.append(vertex);

 // Create a new vertex and store its index in the
 // neighboring grid cells (usually, only 1 neighbor)

 Set<List*> neighbors;

 for (float dx = -1; dx <= +1; ++dx) {
 for (float dy = -1; dy <= +1; ++dy) {
 for (float dz = -1; dz <= +1; ++dz) {
 int ix, iy, iz;
 toGridCoords(vertex + Vector3(dx, dy, dz) * radius, ix, iy, iz);
 neighbors.insert(&(grid[ix][iy][iz]));
 }
 }
 }

 Set<List*>::Iterator neighbor(neighbors.begin());
 Set<List*>::Iterator none(neighbors.end());

 while (neighbor != none) {
 (*neighbor)->append(newIndex);
 ++neighbor;
 }

 return newIndex;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Welder& G3D::_internal::Welder::operator= ( const Welder &  w )

private

void G3D::_internal::Welder::toGridCoords	(	Vector3	v,
		int &	x,
		int &	y,
		int &	z
	)		const

Computes the grid index from an ordinate.

 {
 v = (v - offset) * scale;
 x = iClamp(iFloor(v.x * GRID_RES), 0, GRID_RES - 1);
 y = iClamp(iFloor(v.y * GRID_RES), 0, GRID_RES - 1);
 z = iClamp(iFloor(v.z * GRID_RES), 0, GRID_RES - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::_internal::Welder::weld

(

)

 {
 newVertexArray.resize(0);

 // Prime the vertex positions
 for (int i = 0; i < oldVertexArray.size(); ++i) {
 getIndex(oldVertexArray[i]);
 }

 // Now create the official remapping by snapping to 
 // nearby vertices.
 toNew.resize(oldVertexArray.size());
 toOld.resize(newVertexArray.size());

 for (int oi = 0; oi < oldVertexArray.size(); ++oi) {
 toNew[oi] = getIndex(oldVertexArray[oi]);
 toOld[toNew[oi]] = oi;
 }
}

Here is the call graph for this function:

Member Data Documentation

List G3D::_internal::Welder::grid[GRID_RES][GRID_RES][GRID_RES]

Array<Vector3>& G3D::_internal::Welder::newVertexArray

Vector3 G3D::_internal::Welder::offset

(oldVertexArray[i] - offset) * scale is on the range [0, 1]

const Array<Vector3>& G3D::_internal::Welder::oldVertexArray

const float G3D::_internal::Welder::radius

Must be less than one grid cell, not checked

Vector3 G3D::_internal::Welder::scale

Array<int>& G3D::_internal::Welder::toNew

Array<int>& G3D::_internal::Welder::toOld

---

The documentation for this class was generated from the following file:

• dep/g3dlite/source/MeshAlgWeld.cpp