WebSVN – gelsvn – Diff – /branches/cpp11-devel/apps/MeshDistance/meshdist.cpp


#include <iostream>
 
#include <Util/Timer.h>
#include <Util/ArgExtracter.h>
 
#include <CGLA/Mat4x4d.h>
 
#include <Geometry/RGrid.h>
#include <Geometry/HGrid.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/Manifold.h>
 
#include <HMesh/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 Mat4x4d fit_bounding_volume(const Vec3d& p0,
																		const Vec3d& p7,
																		float buf_reg) 
	{
		Vec3d sz = p7 - p0;
		Vec3i dims = vol_dim;
		Vec3d scal_vec = (Vec3d(dims)-Vec3d(2*buf_reg+2))/sz;
		float scal = min(scal_vec[0], min(scal_vec[1],scal_vec[2]));
		
		Mat4x4d m = translation_Mat4x4d(Vec3d(0)+Vec3d(buf_reg+1));
		m *= scaling_Mat4x4d(Vec3d(scal));
		m *= translation_Mat4x4d(-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)
	{
		Vec3d 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);
		
		do_aabb = ae.extract("-A");
		do_obb = ae.extract("-O");
		ae.extract("-x", vol_dim[0]);
		ae.extract("-y", vol_dim[1]);
		ae.extract("-z", vol_dim[2]);
		do_ray_tests = ae.extract("-R");
		flip_normals = ae.extract("-f");
		string file = ae.get_last_arg();
        
        cout << "loading " << file << "... " << flush; 
		load(file, m);
        cout << " done" << endl;
	}
    else
	{
		string fn("../../data/bunny-little.x3d");
		x3d_load(fn, m);
	}
	cout << "Volume dimensions " << vol_dim << endl;
	if(!valid(m))
	{
		cout << "Not a valid manifold" << endl;
		exit(0);
	}
	triangulate_by_edge_face_split(m);
	
	Vec3d p0, p7;
	bbox(m, p0, p7);
	
	Mat4x4d T = fit_bounding_volume(p0,p7,10);
    
    cout << "Transformation " << T << endl;
	
	for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v)
		m.pos(*v) = T.mul_3D_point(m.pos(*v));
	
	
 	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)
	{
		cout << "Building OBB Tree" << endl;
		tim.start();
		OBBTree obb_tree;
		build_OBBTree(m, obb_tree);
		T_build_obb = tim.get_secs();
		
		cout << "Computing distances from OBB Tree" << endl;
		tim.start();
		DistCompCache<OBBTree> dist(&obb_tree);
		for_each_voxel(grid, dist);
		T_dist_obb = tim.get_secs();
		
		cout << "Saving distance field" << endl;
		save_raw_float("obb_dist.raw", grid);
		
		if(do_ray_tests)
		{
			cout << "Ray tests on OBB Tree" << endl;
			tim.start();
			RayCast<OBBTree> ray(&obb_tree);
			for_each_voxel(grid, ray);
			T_ray_obb = tim.get_secs();
			
			cout << "Saving ray volume" << endl;
			save_raw_float("obb_ray.raw", grid);
		}
	}
	
	if(do_aabb)
	{
		cout << "Building AABB Tree" << endl;
		tim.start();
		AABBTree aabb_tree;
		build_AABBTree(m, aabb_tree);
		T_build_aabb = tim.get_secs();
		
		cout << "Computing distances from AABB Tree" << endl;
		tim.start();
		DistCompCache<AABBTree> dist(&aabb_tree);
		for_each_voxel(grid, dist);
		T_dist_aabb = tim.get_secs();
		
		cout << "Saving distance field" << endl;
		save_raw_float("aabb_dist.raw", grid);
		
		if(do_ray_tests)
		{
			cout << "Ray tests on AABB tree" << endl;
			tim.start();
			RayCast<AABBTree> ray(&aabb_tree);
			for_each_voxel(grid, ray);
			T_ray_aabb = tim.get_secs();
			
			cout << "Saving ray volume" << endl;
			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);
// 		}
 
 
 

Rev 596	Rev 630
1	`#include <iostream>`	1	`#include <iostream>`
2		2
3	`#include <Util/Timer.h>`	3	`#include <Util/Timer.h>`
4	`#include <Util/ArgExtracter.h>`	4	`#include <Util/ArgExtracter.h>`
5		5
6	`#include <CGLA/Mat4x4d.h>`	6	`#include <CGLA/Mat4x4d.h>`
7		7
8	`#include <Geometry/RGrid.h>`	8	`#include <Geometry/RGrid.h>`
9	`#include <Geometry/HGrid.h>`	9	`#include <Geometry/HGrid.h>`
10	`#include <Geometry/save_raw.h>`	10	`#include <Geometry/save_raw.h>`
11	`#include <Geometry/GridAlgorithm.h>`	11	`#include <Geometry/GridAlgorithm.h>`
12	`#include <Geometry/build_bbtree.h>`	12	`#include <Geometry/build_bbtree.h>`
13	`#include <Geometry/AABox.h>`	13	`#include <Geometry/AABox.h>`
14		14
15	`#include <HMesh/triangulate.h>`	15	`#include <HMesh/triangulate.h>`
16	`#include <HMesh/Manifold.h>`	16	`#include <HMesh/Manifold.h>`
17		17
18	`#include <HMesh/load.h>`	18	`#include <HMesh/load.h>`
19	`#include <HMesh/x3d_load.h>`	19	`#include <HMesh/x3d_load.h>`
20	`#include <HMesh/x3d_save.h>`	20	`#include <HMesh/x3d_save.h>`
21		21
22	`using namespace std;`	22	`using namespace std;`
23	`using namespace HMesh;`	23	`using namespace HMesh;`
24	`using namespace Geometry;`	24	`using namespace Geometry;`
25	`using namespace CGLA;`	25	`using namespace CGLA;`
26	`using namespace Util;`	26	`using namespace Util;`
27		27
28	`namespace`	28	`namespace`
29	`{`	29	`{`
30		30
31	`Vec3i vol_dim(64);`	31	`Vec3i vol_dim(64);`
32		32
33	`const Mat4x4d fit_bounding_volume(const Vec3d& p0,`	33	`const Mat4x4d fit_bounding_volume(const Vec3d& p0,`
34	`const Vec3d& p7,`	34	`const Vec3d& p7,`
35	`float buf_reg)`	35	`float buf_reg)`
36	`{`	36	`{`
37	`Vec3d sz = p7 - p0;`	37	`Vec3d sz = p7 - p0;`
38	`Vec3i dims = vol_dim;`	38	`Vec3i dims = vol_dim;`
39	`Vec3d scal_vec = (Vec3d(dims)-Vec3d(2*buf_reg+2))/sz;`	39	`Vec3d scal_vec = (Vec3d(dims)-Vec3d(2*buf_reg+2))/sz;`
40	`float scal = min(scal_vec[0], min(scal_vec[1],scal_vec[2]));`	40	`float scal = min(scal_vec[0], min(scal_vec[1],scal_vec[2]));`
41		41
42	`Mat4x4d m = translation_Mat4x4d(Vec3d(0)+Vec3d(buf_reg+1));`	42	`Mat4x4d m = translation_Mat4x4d(Vec3d(0)+Vec3d(buf_reg+1));`
43	`m *= scaling_Mat4x4d(Vec3d(scal));`	43	`m *= scaling_Mat4x4d(Vec3d(scal));`
44	`m *= translation_Mat4x4d(-p0);`	44	`m *= translation_Mat4x4d(-p0);`
45	`return m;`	45	`return m;`
46	`}`	46	`}`
47		47
48	`bool do_ray_tests = false;`	48	`bool do_ray_tests = false;`
49	`bool do_obb = true;`	49	`bool do_obb = true;`
50	`bool do_aabb = false;`	50	`bool do_aabb = false;`
51	`bool flip_normals = false;`	51	`bool flip_normals = false;`
52		52
53	`}`	53	`}`
54		54
55		55
56		56
57	`template<class BBTree>`	57	`template<class BBTree>`
58	`class DistCompCache`	58	`class DistCompCache`
59	`{`	59	`{`
60	`BBTree *T;`	60	`BBTree *T;`
61	`float old_d;`	61	`float old_d;`
62	`Vec3i old_p;`	62	`Vec3i old_p;`
63	`public:`	63	`public:`
64		64
65	`DistCompCache(BBTree* _T): T(_T), old_p(-99999) {}`	65	`DistCompCache(BBTree* _T): T(_T), old_p(-99999) {}`
66		66
67	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`	67	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`
68	`{`	68	`{`
69	`Vec3f p(pi);`	69	`Vec3f p(pi);`
70	`if(sqr_length(pi-old_p)==1)`	70	`if(sqr_length(pi-old_p)==1)`
71	`vox_val = T->compute_signed_distance(p,CGLA::sqr(1.001+fabs(old_d)));`	71	`vox_val = T->compute_signed_distance(p,CGLA::sqr(1.001+fabs(old_d)));`
72	`else`	72	`else`
73	`vox_val = T->compute_signed_distance(p);`	73	`vox_val = T->compute_signed_distance(p);`
74	`if(flip_normals) vox_val = -vox_val;`	74	`if(flip_normals) vox_val = -vox_val;`
75	`old_p = pi;`	75	`old_p = pi;`
76	`old_d = vox_val;`	76	`old_d = vox_val;`
77	`}`	77	`}`
78	`};`	78	`};`
79		79
80	`template<class BBTree>`	80	`template<class BBTree>`
81	`class DistComp`	81	`class DistComp`
82	`{`	82	`{`
83	`BBTree *T;`	83	`BBTree *T;`
84	`public:`	84	`public:`
85		85
86	`DistComp(BBTree* _T): T(_T) {}`	86	`DistComp(BBTree* _T): T(_T) {}`
87		87
88	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`	88	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`
89	`{`	89	`{`
90	`Vec3d p(pi);`	90	`Vec3d p(pi);`
91	`vox_val = T->compute_signed_distance(p);`	91	`vox_val = T->compute_signed_distance(p);`
92	`if(flip_normals) vox_val = -vox_val;`	92	`if(flip_normals) vox_val = -vox_val;`
93	`}`	93	`}`
94	`};`	94	`};`
95		95
96		96
97	`template<class BBTree>`	97	`template<class BBTree>`
98	`class RayCast`	98	`class RayCast`
99	`{`	99	`{`
100	`BBTree *T;`	100	`BBTree *T;`
101		101
102	`public:`	102	`public:`
103		103
104	`RayCast(BBTree* _T): T(_T) {}`	104	`RayCast(BBTree* _T): T(_T) {}`
105		105
106	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`	106	`void operator()(const CGLA::Vec3i& pi, float& vox_val)`
107	`{`	107	`{`
108	`int n = T->intersect_cnt(Vec3f(pi), Vec3f(1,0,0));`	108	`int n = T->intersect_cnt(Vec3f(pi), Vec3f(1,0,0));`
109	`if(n%2==0)`	109	`if(n%2==0)`
110	`vox_val=1000;`	110	`vox_val=1000;`
111	`else`	111	`else`
112	`vox_val=-1000;`	112	`vox_val=-1000;`
113	`}`	113	`}`
114	`};`	114	`};`
115		115
116		116
117	`typedef RGrid<float> RGridf;`	117	`typedef RGrid<float> RGridf;`
118		118
119		119
120	`int main(int argc, char** argv)`	120	`int main(int argc, char** argv)`
121	`{`	121	`{`
122	`// LOAD OBJ`	122	`// LOAD OBJ`
123	`Manifold m;`	123	`Manifold m;`
124	`if(argc>1)`	124	`if(argc>1)`
125	`{`	125	`{`
126	`ArgExtracter ae(argc, argv);`	126	`ArgExtracter ae(argc, argv);`
127		127
128	`do_aabb = ae.extract("-A");`	128	`do_aabb = ae.extract("-A");`
129	`do_obb = ae.extract("-O");`	129	`do_obb = ae.extract("-O");`
130	`ae.extract("-x", vol_dim[0]);`	130	`ae.extract("-x", vol_dim[0]);`
131	`ae.extract("-y", vol_dim[1]);`	131	`ae.extract("-y", vol_dim[1]);`
132	`ae.extract("-z", vol_dim[2]);`	132	`ae.extract("-z", vol_dim[2]);`
133	`do_ray_tests = ae.extract("-R");`	133	`do_ray_tests = ae.extract("-R");`
134	`flip_normals = ae.extract("-f");`	134	`flip_normals = ae.extract("-f");`
135	`string file = ae.get_last_arg();`	135	`string file = ae.get_last_arg();`
136		136
137	`cout << "loading " << file << "... " << flush;`	137	`cout << "loading " << file << "... " << flush;`
138	`load(file, m);`	138	`load(file, m);`
139	`cout << " done" << endl;`	139	`cout << " done" << endl;`
140	`}`	140	`}`
141	`else`	141	`else`
142	`{`	142	`{`
143	`string fn("../../data/bunny-little.x3d");`	143	`string fn("../../data/bunny-little.x3d");`
144	`x3d_load(fn, m);`	144	`x3d_load(fn, m);`
145	`}`	145	`}`
146	`cout << "Volume dimensions " << vol_dim << endl;`	146	`cout << "Volume dimensions " << vol_dim << endl;`
147	`if(!valid(m))`	147	`if(!valid(m))`
148	`{`	148	`{`
149	`cout << "Not a valid manifold" << endl;`	149	`cout << "Not a valid manifold" << endl;`
150	`exit(0);`	150	`exit(0);`
151	`}`	151	`}`
152	`triangulate_by_edge_face_split(m);`	152	`triangulate_by_edge_face_split(m);`
153		153
154	`Vec3d p0, p7;`	154	`Vec3d p0, p7;`
155	`bbox(m, p0, p7);`	155	`bbox(m, p0, p7);`
156		156
157	`Mat4x4d T = fit_bounding_volume(p0,p7,10);`	157	`Mat4x4d T = fit_bounding_volume(p0,p7,10);`
158		158
159	`cout << "Transformation " << T << endl;`	159	`cout << "Transformation " << T << endl;`
160		160
161	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v)`	161	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v)`
162	`m.pos(v) = T.mul_3D_point(m.pos(v));`	162	`m.pos(v) = T.mul_3D_point(m.pos(v));`
163		163
164		164
165	`RGridf grid(vol_dim,FLT_MAX);`	165	`RGridf grid(vol_dim,FLT_MAX);`
166	`Util::Timer tim;`	166	`Util::Timer tim;`
167		167
168		168
169	`float T_build_obb=0, T_build_aabb=0, T_dist_obb=0,`	169	`float T_build_obb=0, T_build_aabb=0, T_dist_obb=0,`
170	`T_dist_aabb=0, T_ray_obb=0, T_ray_aabb=0;`	170	`T_dist_aabb=0, T_ray_obb=0, T_ray_aabb=0;`
171		171
172	`if(do_obb)`	172	`if(do_obb)`
173	`{`	173	`{`
174	`cout << "Building OBB Tree" << endl;`	174	`cout << "Building OBB Tree" << endl;`
175	`tim.start();`	175	`tim.start();`
176	`OBBTree obb_tree;`	176	`OBBTree obb_tree;`
177	`build_OBBTree(m, obb_tree);`	177	`build_OBBTree(m, obb_tree);`
178	`T_build_obb = tim.get_secs();`	178	`T_build_obb = tim.get_secs();`
179		179
180	`cout << "Computing distances from OBB Tree" << endl;`	180	`cout << "Computing distances from OBB Tree" << endl;`
181	`tim.start();`	181	`tim.start();`
182	`DistCompCache<OBBTree> dist(&obb_tree);`	182	`DistCompCache<OBBTree> dist(&obb_tree);`
183	`for_each_voxel(grid, dist);`	183	`for_each_voxel(grid, dist);`
184	`T_dist_obb = tim.get_secs();`	184	`T_dist_obb = tim.get_secs();`
185		185
186	`cout << "Saving distance field" << endl;`	186	`cout << "Saving distance field" << endl;`
187	`save_raw_float("obb_dist.raw", grid);`	187	`save_raw_float("obb_dist.raw", grid);`
188		188
189	`if(do_ray_tests)`	189	`if(do_ray_tests)`
190	`{`	190	`{`
191	`cout << "Ray tests on OBB Tree" << endl;`	191	`cout << "Ray tests on OBB Tree" << endl;`
192	`tim.start();`	192	`tim.start();`
193	`RayCast<OBBTree> ray(&obb_tree);`	193	`RayCast<OBBTree> ray(&obb_tree);`
194	`for_each_voxel(grid, ray);`	194	`for_each_voxel(grid, ray);`
195	`T_ray_obb = tim.get_secs();`	195	`T_ray_obb = tim.get_secs();`
196		196
197	`cout << "Saving ray volume" << endl;`	197	`cout << "Saving ray volume" << endl;`
198	`save_raw_float("obb_ray.raw", grid);`	198	`save_raw_float("obb_ray.raw", grid);`
199	`}`	199	`}`
200	`}`	200	`}`
201		201
202	`if(do_aabb)`	202	`if(do_aabb)`
203	`{`	203	`{`
204	`cout << "Building AABB Tree" << endl;`	204	`cout << "Building AABB Tree" << endl;`
205	`tim.start();`	205	`tim.start();`
206	`AABBTree aabb_tree;`	206	`AABBTree aabb_tree;`
207	`build_AABBTree(m, aabb_tree);`	207	`build_AABBTree(m, aabb_tree);`
208	`T_build_aabb = tim.get_secs();`	208	`T_build_aabb = tim.get_secs();`
209		209
210	`cout << "Computing distances from AABB Tree" << endl;`	210	`cout << "Computing distances from AABB Tree" << endl;`
211	`tim.start();`	211	`tim.start();`
212	`DistCompCache<AABBTree> dist(&aabb_tree);`	212	`DistCompCache<AABBTree> dist(&aabb_tree);`
213	`for_each_voxel(grid, dist);`	213	`for_each_voxel(grid, dist);`
214	`T_dist_aabb = tim.get_secs();`	214	`T_dist_aabb = tim.get_secs();`
215		215
216	`cout << "Saving distance field" << endl;`	216	`cout << "Saving distance field" << endl;`
217	`save_raw_float("aabb_dist.raw", grid);`	217	`save_raw_float("aabb_dist.raw", grid);`
218		218
219	`if(do_ray_tests)`	219	`if(do_ray_tests)`
220	`{`	220	`{`
221	`cout << "Ray tests on AABB tree" << endl;`	221	`cout << "Ray tests on AABB tree" << endl;`
222	`tim.start();`	222	`tim.start();`
223	`RayCast<AABBTree> ray(&aabb_tree);`	223	`RayCast<AABBTree> ray(&aabb_tree);`
224	`for_each_voxel(grid, ray);`	224	`for_each_voxel(grid, ray);`
225	`T_ray_aabb = tim.get_secs();`	225	`T_ray_aabb = tim.get_secs();`
226		226
227	`cout << "Saving ray volume" << endl;`	227	`cout << "Saving ray volume" << endl;`
228	`save_raw_float("aabb_ray.raw", grid);`	228	`save_raw_float("aabb_ray.raw", grid);`
229	`}`	229	`}`
230	`}`	230	`}`
231	`cout.width(10);`	231	`cout.width(10);`
232	`cout << "Poly";`	232	`cout << "Poly";`
233	`cout.width(11);`	233	`cout.width(11);`
234	`cout <<"build_obb";`	234	`cout <<"build_obb";`
235	`cout.width(12);`	235	`cout.width(12);`
236	`cout << "build_aabb";`	236	`cout << "build_aabb";`
237	`cout.width(10);`	237	`cout.width(10);`
238	`cout << "dist_obb" ;`	238	`cout << "dist_obb" ;`
239	`cout.width(10);`	239	`cout.width(10);`
240	`cout << "dist_aabb";`	240	`cout << "dist_aabb";`
241	`cout.width(10);`	241	`cout.width(10);`
242	`cout << "ray_obb" ;`	242	`cout << "ray_obb" ;`
243	`cout.width(10);`	243	`cout.width(10);`
244	`cout << "ray_aabb";`	244	`cout << "ray_aabb";`
245	`cout << endl;`	245	`cout << endl;`
246		246
247	`cout.precision(4);`	247	`cout.precision(4);`
248	`cout.width(10);`	248	`cout.width(10);`
249	`cout << m.no_faces() << " ";`	249	`cout << m.no_faces() << " ";`
250	`cout.width(10);`	250	`cout.width(10);`
251	`cout << T_build_obb;`	251	`cout << T_build_obb;`
252	`cout.width(12);`	252	`cout.width(12);`
253	`cout << T_build_aabb;`	253	`cout << T_build_aabb;`
254	`cout.width(10);`	254	`cout.width(10);`
255	`cout << T_dist_obb;`	255	`cout << T_dist_obb;`
256	`cout.width(10);`	256	`cout.width(10);`
257	`cout << T_dist_aabb;`	257	`cout << T_dist_aabb;`
258	`cout.width(10);`	258	`cout.width(10);`
259	`cout << T_ray_obb;`	259	`cout << T_ray_obb;`
260	`cout.width(10);`	260	`cout.width(10);`
261	`cout << T_ray_aabb;`	261	`cout << T_ray_aabb;`
262	`cout << endl;`	262	`cout << endl;`
263	`}`	263	`}`
264		264
265		265
266		266
267	`// Brute force code - never use ...`	267	`// Brute force code - never use ...`
268	`// cout << "Computing distances" << endl;`	268	`// cout << "Computing distances" << endl;`
269	`// for(int i=0;i<triangle_vec_global.size(); ++i)`	269	`// for(int i=0;i<triangle_vec_global.size(); ++i)`
270	`// {`	270	`// {`
271	`// k=0;`	271	`// k=0;`
272	`// TRI = triangle_vec_global[i];`	272	`// TRI = triangle_vec_global[i];`
273	`// for_each_voxel(grid, dist_brute);`	273	`// for_each_voxel(grid, dist_brute);`
274	`// }`	274	`// }`
275		275
276		276
277		277

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/apps/MeshDistance/meshdist.cpp – Rev 596 → 630