Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.cxx	(revision 1025)
@@ -7,5 +7,5 @@
      mlab: (Id: polymodel.cc,v 1.21 1997/02/06 16:34:14 garland Exp)
   via
-     QSlim: (Id: polymodel.cc,v 1.5 1997/02/25 20:36:36 garland Exp)
+     simplif: (Id: polymodel.cc,v 1.5 1997/02/25 20:36:36 garland Exp)
 
  ************************************************************************/
@@ -13,5 +13,5 @@
 #include "AdjModel.h"
 
-using namespace qslim;
+using namespace simplif;
 
 int Model::in_Vertex(const Vec3& p)
@@ -329,32 +329,32 @@
 /*		// SUS: recalcular la normal en los triangulos cambiados no degenerados
 
-		qslim::Vertex * auxv0 = F->vertex(0);
-		qslim::Vertex * auxv1 = F->vertex(1);
-		qslim::Vertex * auxv2 = F->vertex(2);
-		qslim::Vec3 vd1(auxv1->operator[](qslim::X) - auxv0->operator[](qslim::X), 
-						auxv1->operator[](qslim::Y) - auxv0->operator[](qslim::Y),
-						auxv1->operator[](qslim::Z) - auxv0->operator[](qslim::Z));
-		qslim::Vec3 vd2(auxv2->operator[](qslim::X) - auxv0->operator[](qslim::X), 
-						auxv2->operator[](qslim::Y) - auxv0->operator[](qslim::Y),
-						auxv2->operator[](qslim::Z) - auxv0->operator[](qslim::Z));
-
-		qslim::unitize(vd1);
-		qslim::unitize(vd2);
-
-		qslim::Vec3 vn = vd1 ^ vd2;
-		qslim::unitize(vn);
+		simplif::Vertex * auxv0 = F->vertex(0);
+		simplif::Vertex * auxv1 = F->vertex(1);
+		simplif::Vertex * auxv2 = F->vertex(2);
+		simplif::Vec3 vd1(auxv1->operator[](simplif::X) - auxv0->operator[](simplif::X), 
+						auxv1->operator[](simplif::Y) - auxv0->operator[](simplif::Y),
+						auxv1->operator[](simplif::Z) - auxv0->operator[](simplif::Z));
+		simplif::Vec3 vd2(auxv2->operator[](simplif::X) - auxv0->operator[](simplif::X), 
+						auxv2->operator[](simplif::Y) - auxv0->operator[](simplif::Y),
+						auxv2->operator[](simplif::Z) - auxv0->operator[](simplif::Z));
+
+		simplif::unitize(vd1);
+		simplif::unitize(vd2);
+
+		simplif::Vec3 vn = vd1 ^ vd2;
+		simplif::unitize(vn);
 		
 		//auxf->vertex_normals[0] = vn;
 		//auxf->vertex_normals[1] = vn;
 		//auxf->vertex_normals[2] = vn;
-		F->vertex_normals[0][qslim::X] = vn[qslim::X];
-		F->vertex_normals[0][qslim::Y] = vn[qslim::Y];
-		F->vertex_normals[0][qslim::Z] = vn[qslim::Z];
-		F->vertex_normals[1][qslim::X] = vn[qslim::X];
-		F->vertex_normals[1][qslim::Y] = vn[qslim::Y];
-		F->vertex_normals[1][qslim::Z] = vn[qslim::Z];
-		F->vertex_normals[2][qslim::X] = vn[qslim::X];
-		F->vertex_normals[2][qslim::Y] = vn[qslim::Y];
-		F->vertex_normals[2][qslim::Z] = vn[qslim::Z];*/
+		F->vertex_normals[0][simplif::X] = vn[simplif::X];
+		F->vertex_normals[0][simplif::Y] = vn[simplif::Y];
+		F->vertex_normals[0][simplif::Z] = vn[simplif::Z];
+		F->vertex_normals[1][simplif::X] = vn[simplif::X];
+		F->vertex_normals[1][simplif::Y] = vn[simplif::Y];
+		F->vertex_normals[1][simplif::Z] = vn[simplif::Z];
+		F->vertex_normals[2][simplif::X] = vn[simplif::X];
+		F->vertex_normals[2][simplif::Y] = vn[simplif::Y];
+		F->vertex_normals[2][simplif::Z] = vn[simplif::Z];*/
 
     }
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/std.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/std.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/std.h	(revision 1025)
@@ -18,5 +18,5 @@
 
 
-namespace qslim
+namespace simplif
 {
 	//
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Buffer.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Buffer.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Buffer.h	(revision 1025)
@@ -4,5 +4,5 @@
 #include <gfx/tools/Array.h>
 
-namespace qslim
+namespace simplif
 {
 	template<class T>
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Heap.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Heap.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Heap.h	(revision 1025)
@@ -12,5 +12,5 @@
 //
 
-namespace qslim
+namespace simplif
 {
 	class Heapable
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Array.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Array.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Array.h	(revision 1025)
@@ -5,5 +5,5 @@
 #include "../std.h"
 
-namespace qslim
+namespace simplif
 {
 	template<class T>
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/heap.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/heap.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/heap.cxx	(revision 1025)
@@ -3,5 +3,5 @@
 #include <gfx/tools/Heap.h>
 
-using namespace qslim;
+using namespace simplif;
 
 void Heap::swap(int i,int j)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.cxx	(revision 1025)
@@ -9,10 +9,10 @@
 #include <gfx/SMF/smfstate.h>
 
-using namespace qslim;
+using namespace simplif;
 
 inline int streq(const char *a,const char *b) { return strcmp(a,b)==0; }
 
-float qslim::SMF_version = 1.0;
-char *qslim::SMF_version_string = "1.0";
+float simplif::SMF_version = 1.0;
+char *simplif::SMF_version_string = "1.0";
 char *SMF_source_revision = "$Id: smf.cxx,v 1.1 1997/06/16 22:11:40 garland Exp $";
 
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.cxx	(revision 1025)
@@ -8,5 +8,5 @@
 inline int streq(const char *a,const char *b) { return strcmp(a,b)==0; }
 
-using namespace qslim;
+using namespace simplif;
 
 SMF_State::SMF_State(const SMF_ivars& ivar, SMF_State *link)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smf.h	(revision 1025)
@@ -17,5 +17,5 @@
 
 
-namespace qslim
+namespace simplif
 {
 	#define SMF_MAXLINE 4096
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/SMF/smfstate.h	(revision 1025)
@@ -2,5 +2,5 @@
 #define GFXSMF_STATE_INCLUDED
 
-namespace qslim
+namespace simplif
 {
 	class SMF_State
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProjectH.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProjectH.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProjectH.cxx	(revision 1025)
@@ -27,5 +27,5 @@
 #define DOTP(a, b) (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
 
-using namespace qslim;
+using namespace simplif;
 
 static real Distance2(real x[3], real *y)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.cxx	(revision 1025)
@@ -6,5 +6,5 @@
 #include <gfx/geom/ProxGrid.h>
 
-using namespace qslim;
+using namespace simplif;
 
 ProxGrid::ProxGrid(const Vec3& lo, const Vec3& hi, real dist)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/ProxGrid.h	(revision 1025)
@@ -7,5 +7,5 @@
 
 
-namespace qslim
+namespace simplif
 {
 	class ProxGrid_Cell : public buffer<Vec3 *>
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.cxx	(revision 1025)
@@ -3,5 +3,5 @@
 #include <gfx/geom/3D.h>
 
-using namespace qslim;
+using namespace simplif;
 
 Vec3 randomPoint(const Vec3& v1, const Vec3& v2)
@@ -21,5 +21,5 @@
 }
 
-real qslim::triangleArea(const Vec3& v1, const Vec3& v2, const Vec3& v3)
+real simplif::triangleArea(const Vec3& v1, const Vec3& v2, const Vec3& v3)
 {
     Vec3 a = v2 - v1;
@@ -38,5 +38,5 @@
     real L3 = norm2(v1-v3);
 
-    return FOUR_ROOT3 * qslim::triangleArea(v1,v2,v3) / (L1+L2+L3);
+    return FOUR_ROOT3 * simplif::triangleArea(v1,v2,v3) / (L1+L2+L3);
 }
 
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.h	(revision 1025)
@@ -10,5 +10,5 @@
 //
 
-namespace qslim
+namespace simplif
 {
 	extern Vec3 randomPoint(const Vec3&, const Vec3&);  // on segment
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/cholesky.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/cholesky.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/cholesky.cxx	(revision 1025)
@@ -12,5 +12,5 @@
 //
 
-using namespace qslim;
+using namespace simplif;
 
 bool cholesky(Mat4& a, Vec4& p)
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.cxx	(revision 1025)
@@ -2,5 +2,5 @@
 #include <gfx/math/Mat2.h>
 
-using namespace qslim;
+using namespace simplif;
 
 Mat2 Mat2::identity(Vec2(1,0), Vec2(0,1));
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.cxx	(revision 1025)
@@ -2,5 +2,5 @@
 #include <gfx/math/Mat3.h>
 
-using namespace qslim;
+using namespace simplif;
 
 Mat3 Mat3::identity(Vec3(1,0,0), Vec3(0,1,0), Vec3(0,0,1));
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec2.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec2.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec2.h	(revision 1025)
@@ -10,5 +10,5 @@
  ************************************************************************/
 
-namespace qslim
+namespace simplif
 {
 	class Vec2 {
@@ -78,10 +78,10 @@
 	//
 
-	inline void qslim::Vec2::copy(const qslim::Vec2& v)
+	inline void simplif::Vec2::copy(const simplif::Vec2& v)
 	{
 		elt[0]=v.elt[0]; elt[1]=v.elt[1];
 	}
 
-	inline bool qslim::Vec2::operator==(const qslim::Vec2& v) const
+	inline bool simplif::Vec2::operator==(const simplif::Vec2& v) const
 	{
 		real dx=elt[X]-v[X],  dy=elt[Y]-v[Y];
@@ -89,5 +89,5 @@
 	}
 
-	inline bool qslim::Vec2::operator!=(const qslim::Vec2& v) const
+	inline bool simplif::Vec2::operator!=(const simplif::Vec2& v) const
 	{
 		real dx=elt[X]-v[X],  dy=elt[Y]-v[Y];
@@ -95,5 +95,5 @@
 	}
 
-	inline qslim::Vec2& qslim::Vec2::operator=(const qslim::Vec2& v)
+	inline simplif::Vec2& simplif::Vec2::operator=(const simplif::Vec2& v)
 	{
 		copy(v);
@@ -101,5 +101,5 @@
 	}
 
-	inline qslim::Vec2& qslim::Vec2::operator+=(const qslim::Vec2& v)
+	inline simplif::Vec2& simplif::Vec2::operator+=(const simplif::Vec2& v)
 	{
 		elt[0] += v[0];   elt[1] += v[1];
@@ -107,5 +107,5 @@
 	}
 
-	inline qslim::Vec2& qslim::Vec2::operator-=(const qslim::Vec2& v)
+	inline simplif::Vec2& simplif::Vec2::operator-=(const simplif::Vec2& v)
 	{
 		elt[0] -= v[0];   elt[1] -= v[1];
@@ -113,5 +113,5 @@
 	}
 
-	inline qslim::Vec2& qslim::Vec2::operator*=(qslim::real s)
+	inline simplif::Vec2& simplif::Vec2::operator*=(simplif::real s)
 	{
 		elt[0] *= s;   elt[1] *= s;
@@ -119,5 +119,5 @@
 	}
 
-	inline qslim::Vec2& qslim::Vec2::operator/=(qslim::real s)
+	inline simplif::Vec2& simplif::Vec2::operator/=(simplif::real s)
 	{
 		elt[0] /= s;   elt[1] /= s;
@@ -125,30 +125,30 @@
 	}
 
-	inline qslim::Vec2 qslim::Vec2::operator+(const qslim::Vec2& v) const
+	inline simplif::Vec2 simplif::Vec2::operator+(const simplif::Vec2& v) const
 	{
 		return Vec2(elt[0]+v[0], elt[1]+v[1]);
 	}
 
-	inline qslim::Vec2 qslim::Vec2::operator-(const qslim::Vec2& v) const
+	inline simplif::Vec2 simplif::Vec2::operator-(const simplif::Vec2& v) const
 	{
 		return Vec2(elt[0]-v[0], elt[1]-v[1]);
 	}
 
-	inline qslim::Vec2 qslim::Vec2::operator-() const
-	{
-		return qslim::Vec2(-elt[0], -elt[1]);
-	}
-
-	inline qslim::Vec2 qslim::Vec2::operator*(qslim::real s) const
+	inline simplif::Vec2 simplif::Vec2::operator-() const
+	{
+		return simplif::Vec2(-elt[0], -elt[1]);
+	}
+
+	inline simplif::Vec2 simplif::Vec2::operator*(simplif::real s) const
 	{
 		return Vec2(elt[0]*s, elt[1]*s);
 	}
 
-	inline qslim::Vec2 qslim::Vec2::operator/(qslim::real s) const
+	inline simplif::Vec2 simplif::Vec2::operator/(simplif::real s) const
 	{
 		return Vec2(elt[0]/s, elt[1]/s);
 	}
 
-	inline qslim::real qslim::Vec2::operator*(const qslim::Vec2& v) const
+	inline simplif::real simplif::Vec2::operator*(const simplif::Vec2& v) const
 	{
 		return elt[0]*v[0] + elt[1]*v[1];
@@ -156,5 +156,5 @@
 
 	// Make scalar multiplication commutative
-	inline qslim::Vec2 operator*(qslim::real s, const qslim::Vec2& v) { return v*s; }
+	inline simplif::Vec2 operator*(simplif::real s, const simplif::Vec2& v) { return v*s; }
 
 
@@ -164,13 +164,13 @@
 	//
 
-namespace qslim
+namespace simplif
 {
-	inline real norm(const qslim::Vec2& v) { return sqrt(v[0]*v[0] + v[1]*v[1]); }
-	inline real norm2(const qslim::Vec2& v) { return v[0]*v[0] + v[1]*v[1]; }
-	inline real length(const qslim::Vec2& v) { return norm(v); }
-
-	inline real unitize(qslim::Vec2& v)
-	{
-		qslim::real l=norm2(v);
+	inline real norm(const simplif::Vec2& v) { return sqrt(v[0]*v[0] + v[1]*v[1]); }
+	inline real norm2(const simplif::Vec2& v) { return v[0]*v[0] + v[1]*v[1]; }
+	inline real length(const simplif::Vec2& v) { return norm(v); }
+
+	inline real unitize(simplif::Vec2& v)
+	{
+		simplif::real l=norm2(v);
 		if( l!=1.0 && l!=0.0 )
 		{
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.cxx	(revision 1025)
@@ -2,5 +2,5 @@
 #include <gfx/math/Mat4.h>
 
-using namespace qslim;
+using namespace simplif;
 
 Mat4 Mat4::identity(Vec4(1,0,0,0),Vec4(0,1,0,0),Vec4(0,0,1,0),Vec4(0,0,0,1));
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec3.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec3.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec3.h	(revision 1025)
@@ -12,5 +12,5 @@
 #include "../std.h"
 
-namespace qslim
+namespace simplif
 {
 	class Vec3 {
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/random.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/random.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/random.h	(revision 1025)
@@ -5,5 +5,5 @@
 #include <limits.h>
 
-namespace qslim
+namespace simplif
 {
 	//
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec4.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec4.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Vec4.h	(revision 1025)
@@ -10,5 +10,5 @@
  ************************************************************************/
 
-namespace qslim
+namespace simplif
 {
 	class Vec4 {
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/jacobi.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/jacobi.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/jacobi.cxx	(revision 1025)
@@ -20,5 +20,5 @@
 //
 
-using namespace qslim;
+using namespace simplif;
 
 static
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat2.h	(revision 1025)
@@ -4,5 +4,5 @@
 #include <gfx/math/Vec2.h>
 
-namespace qslim
+namespace simplif
 {
 	class Mat2
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat3.h	(revision 1025)
@@ -5,5 +5,5 @@
 #include <ostream>
 
-namespace qslim
+namespace simplif
 {
 	class Mat3
@@ -64,6 +64,6 @@
 
 //		// Input/Output methods
-//		friend std::ostream& operator<<(std::ostream&, const qslim::Mat3&);
-//		friend std::istream& operator>>(std::istream&, qslim::Mat3&);
+//		friend std::ostream& operator<<(std::ostream&, const simplif::Mat3&);
+//		friend std::istream& operator>>(std::istream&, simplif::Mat3&);
 	};
 
@@ -134,5 +134,5 @@
 
 /*
-inline std::ostream& operator<<(std::ostream& out, const qslim::Mat3& M)
+inline std::ostream& operator<<(std::ostream& out, const simplif::Mat3& M)
 {
     return out << M.row[0] << endl << M.row[1] << endl << M.row[2];
@@ -144,5 +144,5 @@
 }
 */
-extern bool jacobi(const qslim::Mat3& m, qslim::Vec3& vals, qslim::Vec3 vecs[3]);
+extern bool jacobi(const simplif::Mat3& m, simplif::Vec3& vals, simplif::Vec3 vecs[3]);
 
 
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/math/Mat4.h	(revision 1025)
@@ -13,5 +13,5 @@
 #include <gfx/math/Vec4.h>
 
-namespace qslim
+namespace simplif
 {
 	class Mat4
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/simplif.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/simplif.h	(revision 1025)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/simplif.h	(revision 1025)
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+
+//#include "Nautilus.h"
+#include "AdjModel.h"
+#include "avars.h"
+#include <gfx/tools/Heap.h>
+#include <iostream>
+#include <fstream>
+
+namespace simplif
+{
+	class pair_info : public Heapable
+	{
+	public:
+		Vertex *v0, *v1;
+
+		Vec3 candidate;
+		real cost;
+
+		pair_info(Vertex *a,Vertex *b) { v0=a; v1=b; cost=HUGE; }
+
+		bool isValid() { return v0->isValid() && v1->isValid(); }
+	};
+
+	typedef buffer<pair_info *> pair_buffer;
+
+	class vert_info
+	{
+	public:
+
+		pair_buffer pairs;
+
+		Mat4 Q;
+		real norm;
+
+		vert_info() : Q(Mat4::zero) { pairs.init(2); norm=0.0; }
+	};
+}
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.cpp	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.cpp	(revision 1025)
@@ -33,21 +33,21 @@
 //	Recalculate the cost of the vertices of an edge
 //---------------------------------------------------------------------------
-void SimplificationMethod::compute_pair_info(qslim::pair_info *auxpair)
-{
-	qslim::Vertex *v0 = auxpair->v0;
-	qslim::Vertex *v1 = auxpair->v1;
-
-	qslim::vert_info& v0_info = vertex_info(v0);
-	qslim::vert_info& v1_info = vertex_info(v1);
-
-	qslim::Mat4 Q = v0_info.Q + v1_info.Q;
-	qslim::real norm = v0_info.norm + v1_info.norm;
-
-	auxpair->cost = qslim::quadrix_pair_target(Q, v0, v1, auxpair->candidate);
-
-	if( qslim::will_weight_by_area )
+void SimplificationMethod::compute_pair_info(simplif::pair_info *auxpair)
+{
+	simplif::Vertex *v0 = auxpair->v0;
+	simplif::Vertex *v1 = auxpair->v1;
+
+	simplif::vert_info& v0_info = vertex_info(v0);
+	simplif::vert_info& v1_info = vertex_info(v1);
+
+	simplif::Mat4 Q = v0_info.Q + v1_info.Q;
+	simplif::real norm = v0_info.norm + v1_info.norm;
+
+	auxpair->cost = simplif::quadrix_pair_target(Q, v0, v1, auxpair->candidate);
+
+	if( simplif::will_weight_by_area )
 		auxpair->cost /= norm;
 
-	if( qslim::will_preserve_mesh_quality )
+	if( simplif::will_preserve_mesh_quality )
 		auxpair->cost += pair_mesh_penalty(M0, v0, v1, auxpair->candidate);
 
@@ -70,5 +70,5 @@
 //	Reasign the new vertex to the adequate face
 //---------------------------------------------------------------------------
-int SimplificationMethod::predict_face(qslim::Face& F, qslim::Vertex *v1, qslim::Vertex *v2, qslim::Vec3& vnew, qslim::Vec3& f1, qslim::Vec3& f2, qslim::Vec3& f3)
+int SimplificationMethod::predict_face(simplif::Face& F, simplif::Vertex *v1, simplif::Vertex *v2, simplif::Vec3& vnew, simplif::Vec3& f1, simplif::Vec3& f2, simplif::Vec3& f3)
 {
 	int nmapped = 0;
@@ -93,7 +93,7 @@
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
-qslim::real SimplificationMethod::pair_mesh_penalty(qslim::Model& M, qslim::Vertex *v1, qslim::Vertex *v2, qslim::Vec3& vnew)
-{
-	static qslim::face_buffer changed;
+simplif::real SimplificationMethod::pair_mesh_penalty(simplif::Model& M, simplif::Vertex *v1, simplif::Vertex *v2, simplif::Vec3& vnew)
+{
+	static simplif::face_buffer changed;
 	changed.reset();
 
@@ -101,10 +101,10 @@
 
 	// real Nsum = 0;
-	qslim::real Nmin = 0;
+	simplif::real Nmin = 0;
 
 	for(int i=0; i<changed.length(); i++)
 	{
-		qslim::Face& F = *changed(i);
-		qslim::Vec3 f1, f2, f3;
+		simplif::Face& F = *changed(i);
+		simplif::Vec3 f1, f2, f3;
 
 		int nmapped = predict_face(F, v1, v2, vnew, f1, f2, f3);
@@ -113,6 +113,6 @@
 		if( nmapped < 2 )
 		{
-			qslim::Plane Pnew(f1, f2, f3);
-			qslim::real delta =  Pnew.normal() * F.plane().normal();
+			simplif::Plane Pnew(f1, f2, f3);
+			simplif::real delta =  Pnew.normal() * F.plane().normal();
 
 			if( Nmin > delta ) Nmin = delta;
@@ -130,7 +130,7 @@
 //	Returns true if the givens vertices are a valid pair
 //---------------------------------------------------------------------------
-bool SimplificationMethod::check_for_pair(qslim::Vertex *v0, qslim::Vertex *v1)
-{
-	const qslim::pair_buffer& pairs = vertex_info(v0).pairs;
+bool SimplificationMethod::check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1)
+{
+	const simplif::pair_buffer& pairs = vertex_info(v0).pairs;
 
 	for(int i=0; i<pairs.length(); i++)
@@ -146,10 +146,10 @@
 //	Create a new pair with two given vertices
 //---------------------------------------------------------------------------
-qslim::pair_info *SimplificationMethod::new_pair(qslim::Vertex *v0, qslim::Vertex *v1)
-{
-	qslim::vert_info& v0_info = vertex_info(v0);
-	qslim::vert_info& v1_info = vertex_info(v1);
-
-	qslim::pair_info *pair = new qslim::pair_info(v0,v1);
+simplif::pair_info *SimplificationMethod::new_pair(simplif::Vertex *v0, simplif::Vertex *v1)
+{
+	simplif::vert_info& v0_info = vertex_info(v0);
+	simplif::vert_info& v1_info = vertex_info(v1);
+
+	simplif::pair_info *pair = new simplif::pair_info(v0,v1);
 	v0_info.pairs.add(pair);
 	v1_info.pairs.add(pair);
@@ -161,8 +161,8 @@
 //	Remove a given pair
 //---------------------------------------------------------------------------
-void SimplificationMethod::delete_pair(qslim::pair_info *auxpair)
-{
-	qslim::vert_info& v0_info = vertex_info(auxpair->v0);
-	qslim::vert_info& v1_info = vertex_info(auxpair->v1);
+void SimplificationMethod::delete_pair(simplif::pair_info *auxpair)
+{
+	simplif::vert_info& v0_info = vertex_info(auxpair->v0);
+	simplif::vert_info& v1_info = vertex_info(auxpair->v1);
 
 	v0_info.pairs.remove(v0_info.pairs.find(auxpair));
@@ -178,10 +178,10 @@
 //	Contract a given pair
 //---------------------------------------------------------------------------
-void SimplificationMethod::do_contract(qslim::Model& m, qslim::pair_info *auxpair)
-{
-	qslim::Vertex *v0 = auxpair->v0;  qslim::Vertex *v1 = auxpair->v1;
-	qslim::vert_info& v0_info = vertex_info(v0);
-	qslim::vert_info& v1_info = vertex_info(v1);
-	qslim::Vec3 vnew = auxpair->candidate;
+void SimplificationMethod::do_contract(simplif::Model& m, simplif::pair_info *auxpair)
+{
+	simplif::Vertex *v0 = auxpair->v0;  simplif::Vertex *v1 = auxpair->v1;
+	simplif::vert_info& v0_info = vertex_info(v0);
+	simplif::vert_info& v1_info = vertex_info(v1);
+	simplif::Vec3 vnew = auxpair->candidate;
 	int i;
 
@@ -190,9 +190,9 @@
 	v0_info.norm += v1_info.norm;
 
-	qslim::Vec3 p(vnew);
-	qslim::Vec3 v0antes(v0->operator[](qslim::X),v0->operator[](qslim::Y),v0->operator[](qslim::Z));
+	simplif::Vec3 p(vnew);
+	simplif::Vec3 v0antes(v0->operator[](simplif::X),v0->operator[](simplif::Y),v0->operator[](simplif::Z));
 
 	// Find the edge to remove (before remove it (contract()))
-	qslim::Edge *econ=NULL;
+	simplif::Edge *econ=NULL;
 	bool finded = false;
 	for (i=0; i<v0->edgeUses().length(); i++)
@@ -210,5 +210,5 @@
 
 	// Perform the actual contraction
-	static qslim::face_buffer changed;
+	static simplif::face_buffer changed;
 	changed.reset();
 	m.contract(v0, v1, vnew, changed);
@@ -216,10 +216,10 @@
 	// Stores the simplification step
 	MeshSimplificationSequence::Step simplifstep;
-	qslim::Vec3 vdesp = p - v0antes;
+	simplif::Vec3 vdesp = p - v0antes;
 
 	// Stores the displacement in the simplification step
-	simplifstep.x=(float)vdesp[qslim::X];
-	simplifstep.y = (float)vdesp[qslim::Y];
-	simplifstep.z = (float)vdesp[qslim::Z];
+	simplifstep.x=(float)vdesp[simplif::X];
+	simplifstep.y = (float)vdesp[simplif::Y];
+	simplifstep.z = (float)vdesp[simplif::Z];
 	
 	//	Submeshes which pertains each vertex
@@ -245,5 +245,5 @@
 	for (i=0; i<changed.length(); i++)
 	{
-		qslim::Face *auxface = changed(i);
+		simplif::Face *auxface = changed(i);
 
 		if (auxface->isValid())
@@ -291,17 +291,17 @@
 	for(i=0; i<v0_info.pairs.length(); i++)
 	{
-		qslim::pair_info *p = v0_info.pairs(i);
+		simplif::pair_info *p = v0_info.pairs(i);
 		compute_pair_info(p);
 	}
 
 	// Process pairs associated with now dead vertex
-	static qslim::pair_buffer condemned(6); // collect condemned pairs for execution
+	static simplif::pair_buffer condemned(6); // collect condemned pairs for execution
 	condemned.reset();
 
 	for(i=0; i<v1_info.pairs.length(); i++)
 	{
-		qslim::pair_info *p = v1_info.pairs(i);
-
-		qslim::Vertex *u;
+		simplif::pair_info *p = v1_info.pairs(i);
+
+		simplif::Vertex *u;
 		if( p->v0 == v1 )      
 			u = p->v1;
@@ -332,5 +332,5 @@
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
-bool SimplificationMethod::decimate_quadric(qslim::Vertex *v, qslim::Mat4& Q)
+bool SimplificationMethod::decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q)
 {
 	if( vinfo.length() > 0 )
@@ -346,8 +346,8 @@
 //	Extract a pair from the heap, concract it and remove it form the heap
 //---------------------------------------------------------------------------
-void SimplificationMethod::decimate_contract(qslim::Model& m)
-{
-	qslim::heap_node *top;
-	qslim::pair_info *pair;
+void SimplificationMethod::decimate_contract(simplif::Model& m)
+{
+	simplif::heap_node *top;
+	simplif::pair_info *pair;
 
 	for(;;)
@@ -355,5 +355,5 @@
 		top = heap->extract();
 		if( !top ) return;
-		pair = (qslim::pair_info *)top->obj;
+		pair = (simplif::pair_info *)top->obj;
 
 		//Remove all the vertices of the removed edges
@@ -361,5 +361,5 @@
 		for (int i=0; i<pair->v0->edgeUses().length(); i++)
 		{		
-			qslim::Edge *econ = pair->v0->edgeUses()(i);
+			simplif::Edge *econ = pair->v0->edgeUses()(i);
 			if (pair->v1->vID == econ->org()->vID || pair->v1->vID == econ->dest()->vID)
 			{
@@ -383,11 +383,11 @@
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
-qslim::real SimplificationMethod::decimate_error(qslim::Vertex *v)
-{
-	qslim::vert_info& info = vertex_info(v);
-
-	qslim::real err = qslim::quadrix_evaluate_vertex(*v, info.Q);
-
-    if( qslim::will_weight_by_area )
+simplif::real SimplificationMethod::decimate_error(simplif::Vertex *v)
+{
+	simplif::vert_info& info = vertex_info(v);
+
+	simplif::real err = simplif::quadrix_evaluate_vertex(*v, info.Q);
+
+    if( simplif::will_weight_by_area )
 		err /= info.norm;
 
@@ -398,8 +398,8 @@
 //	Extract the minimum cost of the the valid nodes (not simplified)
 //---------------------------------------------------------------------------
-qslim::real SimplificationMethod::decimate_min_error()
-{
-	qslim::heap_node *top;
-	qslim::pair_info *pair;
+simplif::real SimplificationMethod::decimate_min_error()
+{
+	simplif::heap_node *top;
+	simplif::pair_info *pair;
 
 	for(;;)
@@ -407,5 +407,5 @@
 		top = heap->top();
 		if( !top ) return -1.0;
-		pair = (qslim::pair_info *)top->obj;
+		pair = (simplif::pair_info *)top->obj;
 
 		if( pair->isValid() )
@@ -422,7 +422,7 @@
 //	Returns the maximum error by vertex
 //---------------------------------------------------------------------------
-qslim::real SimplificationMethod::decimate_max_error(qslim::Model& m)
-{
-	qslim::real max_err = 0;
+simplif::real SimplificationMethod::decimate_max_error(simplif::Model& m)
+{
+	simplif::real max_err = 0;
 
 	for(int i=0; i<m.vertCount(); i++)
@@ -438,5 +438,5 @@
 //	Initializations
 //---------------------------------------------------------------------------
-void SimplificationMethod::decimate_init(qslim::Model& m, qslim::real limit)
+void SimplificationMethod::decimate_init(simplif::Model& m, simplif::real limit)
 {
 	int i,j;
@@ -444,10 +444,10 @@
 	vinfo.init(m.vertCount());
 
-	if( qslim::will_use_vertex_constraint )
+	if( simplif::will_use_vertex_constraint )
 		for(i=0; i<m.vertCount(); i++)
 		{
-			qslim::Vertex *v = m.vertex(i);
+			simplif::Vertex *v = m.vertex(i);
 			if( v->isValid() )
-				vertex_info(v).Q = qslim::quadrix_vertex_constraint(*v);
+				vertex_info(v).Q = simplif::quadrix_vertex_constraint(*v);
 		}
 
@@ -455,10 +455,10 @@
 		if( m.face(i)->isValid() )
 		{
-			if( qslim::will_use_plane_constraint )
-			{
-				qslim::Mat4 Q = qslim::quadrix_plane_constraint(*m.face(i));
-				qslim::real norm = 0.0;
-
-				if( qslim::will_weight_by_area )
+			if( simplif::will_use_plane_constraint )
+			{
+				simplif::Mat4 Q = simplif::quadrix_plane_constraint(*m.face(i));
+				simplif::real norm = 0.0;
+
+				if( simplif::will_weight_by_area )
 				{
 					norm = m.face(i)->area();
@@ -475,19 +475,19 @@
 		}
 
-	if( qslim::will_constrain_boundaries )
+	if( simplif::will_constrain_boundaries )
 	{
 		for(i=0; i<m.edgeCount(); i++)
-			if( m.edge(i)->isValid() && qslim::check_for_discontinuity(m.edge(i)) )
-			{
-				qslim::Mat4 B = qslim::quadrix_discontinuity_constraint(m.edge(i));
-				qslim::real norm = 0.0;
-
-				if( qslim::will_weight_by_area )
-				{
-					norm = qslim::norm2(*m.edge(i)->org() - *m.edge(i)->dest());
+			if( m.edge(i)->isValid() && simplif::check_for_discontinuity(m.edge(i)) )
+			{
+				simplif::Mat4 B = simplif::quadrix_discontinuity_constraint(m.edge(i));
+				simplif::real norm = 0.0;
+
+				if( simplif::will_weight_by_area )
+				{
+					norm = simplif::norm2(*m.edge(i)->org() - *m.edge(i)->dest());
 					B *= norm;
 				}
 
-				B *= qslim::boundary_constraint_weight;
+				B *= simplif::boundary_constraint_weight;
 				vertex_info(m.edge(i)->org()).Q += B;
 				vertex_info(m.edge(i)->org()).norm += norm;
@@ -497,5 +497,5 @@
 	}
 
-	heap = new qslim::Heap(m.validEdgeCount);
+	heap = new simplif::Heap(m.validEdgeCount);
 
 	int pair_count = 0;
@@ -504,5 +504,5 @@
 		if( m.edge(i)->isValid() )
 		{
-			qslim::pair_info *pair = new_pair(m.edge(i)->org(), m.edge(i)->dest());
+			simplif::pair_info *pair = new_pair(m.edge(i)->org(), m.edge(i)->dest());
 			//pointers_to_remove.push_back(pair);
 			compute_pair_info(pair);
@@ -517,9 +517,9 @@
 	if( proximity_limit > 0 )
 	{
-		qslim::ProxGrid grid(m.bounds.min, m.bounds.max, limit);
+		simplif::ProxGrid grid(m.bounds.min, m.bounds.max, limit);
 		for(i=0; i<m.vertCount(); i++)
 			grid.addPoint(m.vertex(i));
 
-		qslim::buffer<qslim::Vec3 *> nearby(32);
+		simplif::buffer<simplif::Vec3 *> nearby(32);
 		for(i=0; i<m.vertCount(); i++)
 		{
@@ -529,6 +529,6 @@
 			for(j=0; j<nearby.length(); j++)
 			{
-				qslim::Vertex *v1 = m.vertex(i);
-				qslim::Vertex *v2 = (qslim::Vertex *)nearby(j);
+				simplif::Vertex *v1 = m.vertex(i);
+				simplif::Vertex *v2 = (simplif::Vertex *)nearby(j);
 
 				if( v1->isValid() && v2->isValid() )
@@ -539,5 +539,5 @@
 					if( !check_for_pair(v1,v2) )
 					{
-						qslim::pair_info *pair = new_pair(v1,v2);
+						simplif::pair_info *pair = new_pair(v1,v2);
 						compute_pair_info(pair);
 						pair_count++;
@@ -586,5 +586,5 @@
 void SimplificationMethod::simplifmethod_run(int finalfaces,TIPOFUNC upb)
 {
-	decimate_init(M0, qslim::pair_selection_tolerance);
+	decimate_init(M0, simplif::pair_selection_tolerance);
 	unsigned	int	contador	=	0;
 	float					percent; // simplification percentage.
@@ -604,7 +604,7 @@
 	decim_data.clear();
 
-	while( M0.validFaceCount > finalfaces/*qslim::face_target*/
+	while( M0.validFaceCount > finalfaces/*simplif::face_target*/
 			&& M0.validFaceCount > 1
-			&& decimate_min_error() < qslim::error_tolerance ) 
+			&& decimate_min_error() < simplif::error_tolerance ) 
 	{
 		decimate_contract(M0);
@@ -629,5 +629,5 @@
 void SimplificationMethod::simplifmethod_runv(int numvertices,TIPOFUNC upb)
 {
-	decimate_init(M0, qslim::pair_selection_tolerance);
+	decimate_init(M0, simplif::pair_selection_tolerance);
 	unsigned	int	contador	=	0;
 	int						previousValidVertCount;
@@ -650,7 +650,7 @@
 	decim_data.clear();
 
-	while(	M0.validVertCount > numvertices	/*qslim::face_target*/
+	while(	M0.validVertCount > numvertices	/*simplif::face_target*/
 			&&
-			decimate_min_error() < qslim::error_tolerance
+			decimate_min_error() < simplif::error_tolerance
 			&&
 			previousValidVertCount	!=	M0.validVertCount)
@@ -730,12 +730,12 @@
 					{
 						//If the vertex is not in vertices_map, then is added
-						simplifindex=M0.in_Vertex(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x, 
+						simplifindex=M0.in_Vertex(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x, 
 									objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].y,
 									objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].z));
-						M0.in_Normal(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x, 
+						M0.in_Normal(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x, 
 									objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].y,
 									objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].z));
 
-						M0.in_TexCoord(qslim::Vec2(objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].x, 
+						M0.in_TexCoord(simplif::Vec2(objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].x, 
 									objmesh->mSubMesh[i].mVertexBuffer->mTexCoords[j].y));
 						vertices_map[auxvert] = num_final_verts;
@@ -777,11 +777,11 @@
 					{
 						//If the vertex is not in vertices_map, then is added
-						simplifindex=M0.in_Vertex(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x, 
+						simplifindex=M0.in_Vertex(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].x, 
 									objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].y,
 									objmesh->mSubMesh[i].mVertexBuffer->mPosition[j].z));
-						M0.in_Normal(qslim::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x, 
+						M0.in_Normal(simplif::Vec3(objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].x, 
 									objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].y,
 									objmesh->mSubMesh[i].mVertexBuffer->mNormal[j].z));
-						M0.in_TexCoord(qslim::Vec2(0.0,0.0));
+						M0.in_TexCoord(simplif::Vec2(0.0,0.0));
 						vertices_map[auxvert] = num_final_verts;
 						num_final_verts ++;
@@ -970,5 +970,5 @@
 		if (M0.face(i)->isValid())
 		{
-			qslim::Face *auxface	=	M0.face(i);
+			simplif::Face *auxface	=	M0.face(i);
 
 			//	Determine to which submesh pertains the triangle.
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.h	(revision 1025)
@@ -10,5 +10,5 @@
      mlab: (Id: primitives.h,v 1.7 1997/02/06 16:30:14 garland Exp)
   via
-     QSlim: (Id: primitives.h,v 1.3 1997/02/18 21:11:29 garland Exp)
+     simplif: (Id: primitives.h,v 1.3 1997/02/18 21:11:29 garland Exp)
 
  ************************************************************************/
@@ -21,5 +21,5 @@
 #include <gfx/geom/3D.h>
 
-namespace qslim
+namespace simplif
 {
 	class Vertex;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.h	(revision 1007)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.h	(revision 1025)
@@ -6,5 +6,5 @@
 #include <list>
 #include <iostream>
-#include <qslim.h>
+#include <simplif.h>
 #include <GeoMeshSimplifier.h>
 
@@ -13,52 +13,52 @@
 private:
 	Geometry::Mesh	*mGeoMesh;
-	void compute_pair_info(qslim::pair_info*);
-	qslim::Model M0;
-	qslim::array<qslim::vert_info> vinfo;
-	qslim::Heap *heap;
-	qslim::real proximity_limit;    // distance threshold squared
+	void compute_pair_info(simplif::pair_info*);
+	simplif::Model M0;
+	simplif::array<simplif::vert_info> vinfo;
+	simplif::Heap *heap;
+	simplif::real proximity_limit;    // distance threshold squared
 	int initialVertCount;
 	int initialEdgeCount;
 	int initialFaceCount;
 
-	inline qslim::vert_info& vertex_info(qslim::Vertex *v)
+	inline simplif::vert_info& vertex_info(simplif::Vertex *v)
 	{
 		return vinfo(v->validID());
 	}
 	
-	qslim::real pair_mesh_penalty(qslim::Model& M,
-																qslim::Vertex *v1,
-																qslim::Vertex *v2,
-																qslim::Vec3& vnew);
+	simplif::real pair_mesh_penalty(simplif::Model& M,
+																simplif::Vertex *v1,
+																simplif::Vertex *v2,
+																simplif::Vec3& vnew);
 	
-	int predict_face(qslim::Face& F,
-									qslim::Vertex *v1,
-									qslim::Vertex *v2,
-									qslim::Vec3& vnew,
-									qslim::Vec3& f1,
-									qslim::Vec3& f2,
-									qslim::Vec3& f3);
+	int predict_face(simplif::Face& F,
+									simplif::Vertex *v1,
+									simplif::Vertex *v2,
+									simplif::Vec3& vnew,
+									simplif::Vec3& f1,
+									simplif::Vec3& f2,
+									simplif::Vec3& f3);
 	
-	bool check_for_pair(qslim::Vertex *v0, qslim::Vertex *v1);
+	bool check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1);
 	
-	qslim::pair_info *new_pair(qslim::Vertex *v0, qslim::Vertex *v1);
+	simplif::pair_info *new_pair(simplif::Vertex *v0, simplif::Vertex *v1);
 	
-	void delete_pair(qslim::pair_info *pair);
+	void delete_pair(simplif::pair_info *pair);
 	
-	void do_contract(qslim::Model& m, qslim::pair_info *pair);
+	void do_contract(simplif::Model& m, simplif::pair_info *pair);
 	
-	bool decimate_quadric(qslim::Vertex *v, qslim::Mat4& Q);
+	bool decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q);
 	
-	void decimate_contract(qslim::Model& m);
+	void decimate_contract(simplif::Model& m);
 	
-	qslim::real decimate_error(qslim::Vertex *v);
+	simplif::real decimate_error(simplif::Vertex *v);
 	
-	qslim::real decimate_min_error();
+	simplif::real decimate_min_error();
 	
-	qslim::real decimate_max_error(qslim::Model& m);
+	simplif::real decimate_max_error(simplif::Model& m);
 	
-	void decimate_init(qslim::Model& m, qslim::real limit);
+	void decimate_init(simplif::Model& m, simplif::real limit);
 	
-	bool pair_is_valid(qslim::Vertex *u, qslim::Vertex *v);
+	bool pair_is_valid(simplif::Vertex *u, simplif::Vertex *v);
 	
 	void simplifmethod_run(int,	Geometry::TIPOFUNC	upb=0);
@@ -85,5 +85,5 @@
 	unsigned int *first_index_submesh;
 	
-	//std::vector<qslim::pair_info *> pointers_to_remove;
+	//std::vector<simplif::pair_info *> pointers_to_remove;
 
 	int indexMeshLeaves;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.h	(revision 1025)
@@ -5,5 +5,5 @@
 #include <gfx/math/Mat4.h>
 
-namespace qslim
+namespace simplif
 {
 	extern Mat4 quadrix_vertex_constraint(const Vec3&);
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.h	(revision 1025)
@@ -2,5 +2,5 @@
 #include <gfx/SMF/smf.h>
 
-namespace qslim
+namespace simplif
 {
 //	extern ostream *outfile;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.h	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjModel.h	(revision 1025)
@@ -10,5 +10,5 @@
      mlab: (Id: polymodel.h,v 1.13 1997/02/06 16:30:11 garland Exp)
   via
-     QSlim: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp)
+     simplif: (Id: polymodel.h,v 1.1 1997/02/11 15:21:29 garland Exp)
 
  ************************************************************************/
@@ -18,5 +18,5 @@
 #include <vector>
 
-namespace qslim
+namespace simplif
 {
 	class Model : public SMF_Model
@@ -58,9 +58,9 @@
 		// Basic model accessor functions
 		//
-		qslim::Vertex *vertex(int i) { return vertices(i); }
-		qslim::Vec3 & normal(int i){ return normals(i); }
-		qslim::Vec2 & texcoord(int i){ return texcoords(i); }
-		qslim::Edge *edge(int i) { return edges(i); }
-		qslim::Face *face(int i) { return faces(i); }
+		simplif::Vertex *vertex(int i) { return vertices(i); }
+		simplif::Vec3 & normal(int i){ return normals(i); }
+		simplif::Vec2 & texcoord(int i){ return texcoords(i); }
+		simplif::Edge *edge(int i) { return edges(i); }
+		simplif::Face *face(int i) { return faces(i); }
 
 		int vertCount() { return vertices.length(); }
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/AdjPrims.cxx	(revision 1025)
@@ -7,5 +7,5 @@
      mlab: (Id: primitives.cc,v 1.7 1997/02/06 16:32:45 garland Exp)
   via
-     QSlim: (Id: primitives.cc,v 1.2 1997/02/18 21:11:27 garland Exp)
+     simplif: (Id: primitives.cc,v 1.2 1997/02/18 21:11:27 garland Exp)
 
  ************************************************************************/
@@ -13,5 +13,5 @@
 #include "AdjPrims.h"
 
-using namespace qslim;
+using namespace simplif;
 
 void Vertex::kill()
@@ -215,5 +215,5 @@
 
 
-void qslim::untagFaceLoop(Vertex *v)
+void simplif::untagFaceLoop(Vertex *v)
 {
     edge_buffer& edges = v->edgeUses();
@@ -227,5 +227,5 @@
 }
 
-void qslim::collectFaceLoop(Vertex *v, face_buffer& loop)
+void simplif::collectFaceLoop(Vertex *v, face_buffer& loop)
 {
     edge_buffer& edges = v->edgeUses();
@@ -243,5 +243,5 @@
 }
 
-int qslim::classifyEdge(Edge *e)
+int simplif::classifyEdge(Edge *e)
 {
     int cls = e->faceUses().length();
@@ -252,5 +252,5 @@
 }
 
-int qslim::classifyVertex(Vertex *v)
+int simplif::classifyVertex(Vertex *v)
 {
     int border_count = 0;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.cxx	(revision 774)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/quadrics.cxx	(revision 1025)
@@ -1,5 +1,5 @@
 // $Id: quadrics.cxx,v 1.5 1997/10/01 14:07:28 garland Exp $
 
-#include "qslim.h"
+#include "simplif.h"
 #include "quadrics.h"
 
@@ -16,7 +16,7 @@
 //
 
-using namespace qslim;
-
-Mat4 qslim::quadrix_vertex_constraint(const Vec3& v)
+using namespace simplif;
+
+Mat4 simplif::quadrix_vertex_constraint(const Vec3& v)
 {
     Mat4 L(Mat4::identity);
@@ -39,5 +39,5 @@
 // quadric" discussed in the paper.
 //
-Mat4 qslim::quadrix_plane_constraint(real a, real b, real c, real d)
+Mat4 simplif::quadrix_plane_constraint(real a, real b, real c, real d)
 {
     Mat4 K(Mat4::zero);
@@ -54,10 +54,10 @@
 // Define some other convenient ways for constructing these plane quadrics.
 //
-Mat4 qslim::quadrix_plane_constraint(const Vec3& n, real d)
-{
-    return qslim::quadrix_plane_constraint(n[X], n[Y], n[Z], d);
-}
-
-Mat4 qslim::quadrix_plane_constraint(Face& T)
+Mat4 simplif::quadrix_plane_constraint(const Vec3& n, real d)
+{
+    return simplif::quadrix_plane_constraint(n[X], n[Y], n[Z], d);
+}
+
+Mat4 simplif::quadrix_plane_constraint(Face& T)
 {
     const Plane& p = T.plane();
@@ -65,8 +65,8 @@
     p.coeffs(&a, &b, &c, &d);
 
-    return qslim::quadrix_plane_constraint(a, b, c, d);
-}
-
-qslim::Mat4 qslim::quadrix_plane_constraint(const qslim::Vec3& v1, const qslim::Vec3& v2, const qslim::Vec3& v3)
+    return simplif::quadrix_plane_constraint(a, b, c, d);
+}
+
+simplif::Mat4 simplif::quadrix_plane_constraint(const simplif::Vec3& v1, const simplif::Vec3& v2, const simplif::Vec3& v3)
 {
     Plane P(v1,v2,v3);
@@ -74,8 +74,8 @@
     P.coeffs(&a, &b, &c, &d);
 
-    return qslim::quadrix_plane_constraint(a, b, c, d);
-}
-
-real qslim::quadrix_evaluate_vertex(const Vec3& v, const Mat4& K)
+    return simplif::quadrix_plane_constraint(a, b, c, d);
+}
+
+real simplif::quadrix_evaluate_vertex(const Vec3& v, const Mat4& K)
 {
     real x=v[X], y=v[Y], z=v[Z];
@@ -113,10 +113,10 @@
 }
 
-bool qslim::check_for_discontinuity(Edge *e)
+bool simplif::check_for_discontinuity(Edge *e)
 {
     return is_border(e);
 }
 
-Mat4 qslim::quadrix_discontinuity_constraint(Edge *edge, const Vec3& n)
+Mat4 simplif::quadrix_discontinuity_constraint(Edge *edge, const Vec3& n)
 {
     Vec3& org = *edge->org();
@@ -128,9 +128,9 @@
 
     real d = -n2 * org;
-    return qslim::quadrix_plane_constraint(n2, d);
-}
-
-
-Mat4 qslim::quadrix_discontinuity_constraint(Edge *edge)
+    return simplif::quadrix_plane_constraint(n2, d);
+}
+
+
+Mat4 simplif::quadrix_discontinuity_constraint(Edge *edge)
 {
     Mat4 D(Mat4::zero);
@@ -139,5 +139,5 @@
 
     for(int i=0; i<faces.length(); i++)
-		D += qslim::quadrix_discontinuity_constraint(edge,faces(i)->plane().normal());
+		D += simplif::quadrix_discontinuity_constraint(edge,faces(i)->plane().normal());
 
     return D;
@@ -150,5 +150,5 @@
 //
 
-bool qslim::quadrix_find_local_fit(const Mat4& K,
+bool simplif::quadrix_find_local_fit(const Mat4& K,
 			    const Vec3& v1, const Vec3& v2,
 			    Vec3& candidate)
@@ -159,8 +159,8 @@
     bool try_midpoint = placement_policy > PLACE_ENDPOINTS;
 
-    real c1 = qslim::quadrix_evaluate_vertex(v1, K);
-    real c2 = qslim::quadrix_evaluate_vertex(v2, K);
+    real c1 = simplif::quadrix_evaluate_vertex(v1, K);
+    real c2 = simplif::quadrix_evaluate_vertex(v2, K);
     real c3;
-    if( try_midpoint ) c3 = qslim::quadrix_evaluate_vertex(v3, K);
+    if( try_midpoint ) c3 = simplif::quadrix_evaluate_vertex(v3, K);
 
     if( c1<c2 )
@@ -182,5 +182,5 @@
 }
 
-bool qslim::quadrix_find_line_fit(const Mat4& Q,
+bool simplif::quadrix_find_line_fit(const Mat4& Q,
 			   const Vec3& v1, const Vec3& v2,
 			   Vec3& candidate)
@@ -206,5 +206,5 @@
 }
 
-bool qslim::quadrix_find_best_fit(const Mat4& Q, Vec3& candidate)
+bool simplif::quadrix_find_best_fit(const Mat4& Q, Vec3& candidate)
 {
     Mat4 K = Q;
@@ -237,5 +237,5 @@
 #include <assert.h>
 
-real qslim::quadrix_pair_target(const Mat4& Q,
+real simplif::quadrix_pair_target(const Mat4& Q,
 			 Vertex *v1,
 			 Vertex *v2,
@@ -257,10 +257,10 @@
 	{
 	    candidate = *v1;
-	    return qslim::quadrix_evaluate_vertex(candidate, Q);
+	    return simplif::quadrix_evaluate_vertex(candidate, Q);
 	}
 	else if( c2 > c1 )
 	{
 	    candidate = *v2;
-	    return qslim::quadrix_evaluate_vertex(candidate, Q);
+	    return simplif::quadrix_evaluate_vertex(candidate, Q);
 	}
 	else if( c1>0 && policy>PLACE_LINE )
@@ -273,16 +273,16 @@
     {
     case PLACE_OPTIMAL:
-	if( qslim::quadrix_find_best_fit(Q, candidate) )
+	if( simplif::quadrix_find_best_fit(Q, candidate) )
 	    break;
 
     case PLACE_LINE:
-	if( qslim::quadrix_find_line_fit(Q, *v1, *v2, candidate) )
+	if( simplif::quadrix_find_line_fit(Q, *v1, *v2, candidate) )
 	    break;
 
     default:
-		qslim::quadrix_find_local_fit(Q, *v1, *v2, candidate);
+		simplif::quadrix_find_local_fit(Q, *v1, *v2, candidate);
 		break;
     }
 
-    return qslim::quadrix_evaluate_vertex(candidate, Q);
-}
+    return simplif::quadrix_evaluate_vertex(candidate, Q);
+}
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.cxx
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.cxx	(revision 981)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/avars.cxx	(revision 1025)
@@ -9,19 +9,19 @@
 // GLOBAL SIMPLIFICATION OPTIONS
 
-int qslim::face_target = 0;
-qslim::real qslim::error_tolerance = HUGE;
+int simplif::face_target = 0;
+simplif::real simplif::error_tolerance = HUGE;
 
 
-bool qslim::will_use_plane_constraint = true;
-bool qslim::will_use_vertex_constraint = true;
+bool simplif::will_use_plane_constraint = true;
+bool simplif::will_use_vertex_constraint = true;
 
-bool qslim::will_preserve_boundaries = true;
-bool qslim::will_preserve_mesh_quality = true;
-bool qslim::will_constrain_boundaries = true;
-qslim::real qslim::boundary_constraint_weight = 1.0;
+bool simplif::will_preserve_boundaries = true;
+bool simplif::will_preserve_mesh_quality = true;
+bool simplif::will_constrain_boundaries = true;
+simplif::real simplif::boundary_constraint_weight = 1.0;
 
-bool qslim::will_weight_by_area = false;
+bool simplif::will_weight_by_area = false;
 
-int qslim::placement_policy = PLACE_ENDPOINTS;
+int simplif::placement_policy = PLACE_ENDPOINTS;
 
-qslim::real qslim::pair_selection_tolerance = 0.0;
+simplif::real simplif::pair_selection_tolerance = 0.0;
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/qslim.h
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/qslim.h	(revision 774)
+++ 	(revision )
@@ -1,38 +1,0 @@
-// -*- C++ -*-
-
-//#include "Nautilus.h"
-#include "AdjModel.h"
-#include "avars.h"
-#include <gfx/tools/Heap.h>
-#include <iostream>
-#include <fstream>
-
-namespace qslim
-{
-	class pair_info : public Heapable
-	{
-	public:
-		Vertex *v0, *v1;
-
-		Vec3 candidate;
-		real cost;
-
-		pair_info(Vertex *a,Vertex *b) { v0=a; v1=b; cost=HUGE; }
-
-		bool isValid() { return v0->isValid() && v1->isValid(); }
-	};
-
-	typedef buffer<pair_info *> pair_buffer;
-
-	class vert_info
-	{
-	public:
-
-		pair_buffer pairs;
-
-		Mat4 Q;
-		real norm;
-
-		vert_info() : Q(Mat4::zero) { pairs.init(2); norm=0.0; }
-	};
-}
Index: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsConstructor.cpp
===================================================================
--- GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsConstructor.cpp	(revision 1018)
+++ GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsConstructor.cpp	(revision 1025)
@@ -418,5 +418,5 @@
 	
 	//	2 min.
-	//	Calcular los siguiente teniendo en cuenta el QSLIM.
+	//	Calcular los siguiente teniendo en cuenta el simplif.
 	for (i = 0; i < Ordenacion.size(); i++)
 	{
