WebSVN – gelsvn – Diff – /trunk/apps/MeshDistance/meshdist.cpp

 #include <iostream>
 #include "Util/Timer.h"
 #include "Util/ArgExtracter.h"
 #include "CGLA/Mat4x4f.h"
 #include "Geometry/RGrid.h"
 #include "Geometry/save_raw.h"
 #include "Geometry/GridAlgorithm.h"
 #include "Geometry/build_bbtree.h"
 #include "Geometry/AABox.h"
 #include "HMesh/triangulate.h"
+#include "HMesh/obj_load.h"
 #include "HMesh/x3d_load.h"
 #include "HMesh/x3d_save.h"
 using namespace std;
 using namespace HMesh;
 using namespace Geometry;
 using namespace CGLA;
 using namespace Util;
 namespace
+{
 	Vec3i vol_dim(64);
 		const Mat4x4f fit_bounding_volume(const Vec3f& p0,
 																		const Vec3f& p7,
 																		float buf_reg)
+	{
 		Vec3f sz = p7 - p0;
 		Vec3i dims = vol_dim;
 		Vec3f scal_vec = (Vec3f(dims)-Vec3f(2*buf_reg+2))/sz;
 		float scal = min(scal_vec[0], min(scal_vec[1],scal_vec[2]));
 		Mat4x4f m = translation_Mat4x4f(Vec3f(0)+Vec3f(buf_reg+1));
 		m *= scaling_Mat4x4f(Vec3f(scal));
 		m *= translation_Mat4x4f(-p0);
 		return m;
+	}
 	bool do_ray_tests = false;
 	bool do_obb = true;
 	bool do_aabb = false;
 	bool flip_normals = false;
+}
 template<class BBTree>
 class DistCompCache
+{
 	BBTree *T;
 	float old_d;
 	Vec3i old_p;
 public:
 	DistCompCache(BBTree* _T): T(_T), old_p(-99999) {}
 	void operator()(const CGLA::Vec3i& pi, float& vox_val)
+	{
 		Vec3f p(pi);
  		if(sqr_length(pi-old_p)==1)
+ 			{
  				vox_val = T->compute_signed_distance(p,CGLA::sqr(1.001+fabs(old_d)));
+ 			}
  		else
 			vox_val = T->compute_signed_distance(p);
 		if(flip_normals) vox_val = -vox_val;
 		old_p = pi;
 		old_d = vox_val;
+	}
 };
 template<class BBTree>
 class DistComp
+{
 	BBTree *T;
 public:
 	DistComp(BBTree* _T): T(_T) {}
 	void operator()(const CGLA::Vec3i& pi, float& vox_val)
+	{
 		Vec3f p(pi);
 		vox_val =  T->compute_signed_distance(p);
 		if(flip_normals) vox_val = -vox_val;
+	}
 };
 template<class BBTree>
 class RayCast
+{
 	BBTree *T;
 public:
 	RayCast(BBTree* _T): T(_T) {}
 	void operator()(const CGLA::Vec3i& pi, float& vox_val)
+	{
 		int n = T->intersect_cnt(Vec3f(pi), Vec3f(1,0,0));
 		if(n%2==0)
 			vox_val=1000;
 		else
 			vox_val=-1000;
+	}
 };
 typedef RGrid<float> RGridf;
 int main(int argc, char** argv)
+{
 	// LOAD OBJ
     Manifold m;
     if(argc>1)
+	{
-	  ArgExtracter ae(argc, argv);
+		ArgExtracter ae(argc, argv);
-	  do_aabb = ae.extract("-A");
+		do_aabb = ae.extract("-A");
-	  do_ray_tests = ae.extract("-R");
+		do_ray_tests = ae.extract("-R");
-	  flip_normals = ae.extract("-f");
+		flip_normals = ae.extract("-f");
+		string file = ae.get_last_arg();
+		if(file.substr(file.length()-4,file.length())==".obj")
+		{
+			obj_load(file, m);
+		}
+		else
-	  x3d_load(ae.get_last_arg(), m);
+			x3d_load(file, m);
+	}
     else
+	{
-	  string fn("../../data/bunny-little.x3d");
+		string fn("../../data/bunny-little.x3d");
-	  x3d_load(fn, m);
+		x3d_load(fn, m);
+	}
 	if(!m.is_valid())
-		{
+	{
-			cout << "Not a valid manifold" << endl;
+		cout << "Not a valid manifold" << endl;
-			exit(0);
+		exit(0);
-		}
+	}
 	triangulate(m);
 	Vec3f p0,p7;
 	m.get_bbox(p0, p7);
 	Mat4x4f T = fit_bounding_volume(p0,p7,3);
 	for(VertexIter v = m.vertices_begin(); v != m.vertices_end(); ++v)
-			v->pos = T.mul_3D_point(v->pos);
+		v->pos = T.mul_3D_point(v->pos);
  	RGridf grid(vol_dim,FLT_MAX);
 	Util::Timer tim;
 	float T_build_obb=0, T_build_aabb=0, T_dist_obb=0,
 		T_dist_aabb=0, T_ray_obb=0, T_ray_aabb=0;
 	if(do_obb)
+	{
 		tim.start();
 		OBBTree obb_tree;
 		build_OBBTree(m, obb_tree);
 		T_build_obb = tim.get_secs();
 		tim.start();
 		DistCompCache<OBBTree> dist(&obb_tree);
 		for_each_voxel(grid, dist);
 		T_dist_obb = tim.get_secs();
 		save_raw_float("obb_dist.raw", grid);
 		if(do_ray_tests)
-			{
+		{
-				tim.start();
+			tim.start();
-				RayCast<OBBTree> ray(&obb_tree);
+			RayCast<OBBTree> ray(&obb_tree);
-				for_each_voxel(grid, ray);
+			for_each_voxel(grid, ray);
-				T_ray_obb = tim.get_secs();
+			T_ray_obb = tim.get_secs();
-				save_raw_float("obb_ray.raw", grid);
+			save_raw_float("obb_ray.raw", grid);
-			}
+		}
+	}
 	if(do_aabb)
+	{
 		tim.start();
 		AABBTree aabb_tree;
 		build_AABBTree(m, aabb_tree);
 		T_build_aabb = tim.get_secs();
 		tim.start();
 		DistCompCache<AABBTree> dist(&aabb_tree);
 		for_each_voxel(grid, dist);
 		T_dist_aabb = tim.get_secs();
 		save_raw_float("aabb_dist.raw", grid);
-		if(do_ray_tests)
-			{
-				tim.start();
-				RayCast<AABBTree> ray(&aabb_tree);
-				for_each_voxel(grid, ray);
-				T_ray_aabb = tim.get_secs();
+		if(do_ray_tests)
+		{
+			tim.start();
+			RayCast<AABBTree> ray(&aabb_tree);
+			for_each_voxel(grid, ray);
+			T_ray_aabb = tim.get_secs();
-				save_raw_float("aabb_ray.raw", grid);
+			save_raw_float("aabb_ray.raw", grid);
-			}
+		}
+	}
 	cout.width(10);
 	cout << "Poly";
 	cout.width(11);
 	cout <<"build_obb";
 	cout.width(12);
 	cout << "build_aabb";
 	cout.width(10);
 	cout << "dist_obb" ;
 	cout.width(10);
 	cout << "dist_aabb";
 	cout.width(10);
 	cout << "ray_obb" ;
 	cout.width(10);
 	cout << "ray_aabb";
 	cout << endl;
 	cout.precision(4);
 	cout.width(10);
 	cout << m.no_faces() << " ";
 	cout.width(10);
 	cout << T_build_obb;
 	cout.width(12);
 	cout << T_build_aabb;
 	cout.width(10);
 	cout << T_dist_obb;
 	cout.width(10);
 	cout << T_dist_aabb;
 	cout.width(10);
 	cout << T_ray_obb;
 	cout.width(10);
 	cout << T_ray_aabb;
 	cout << endl;
+}
 // Brute force code - never use ...
 //  	cout << "Computing distances" << endl;
 // 	for(int i=0;i<triangle_vec_global.size(); ++i)
 // 		{
 // 			k=0;
 // 			TRI = triangle_vec_global[i];
 // 			for_each_voxel(grid, dist_brute);
 // 		}

Subversion Repositories gelsvn

(root)/trunk/apps/MeshDistance/meshdist.cpp – Rev 309 → 341