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;
    string fn;
    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");
		fn = ae.get_last_arg();
    }
    load(fn, m);
    
    string file_prefix = fn.substr(0, fn.length()-4) + "-";
	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(file_prefix+"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(file_prefix+"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(file_prefix+"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(file_prefix+"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 631	Rev 643
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	`string fn;`	124	`string fn;`
125	`if(argc>1)`	125	`if(argc>1)`
126	`{`	126	`{`
127	`ArgExtracter ae(argc, argv);`	127	`ArgExtracter ae(argc, argv);`
128		128
129	`do_aabb = ae.extract("-A");`	129	`do_aabb = ae.extract("-A");`
130	`do_obb = ae.extract("-O");`	130	`do_obb = ae.extract("-O");`
131	`ae.extract("-x", vol_dim[0]);`	131	`ae.extract("-x", vol_dim[0]);`
132	`ae.extract("-y", vol_dim[1]);`	132	`ae.extract("-y", vol_dim[1]);`
133	`ae.extract("-z", vol_dim[2]);`	133	`ae.extract("-z", vol_dim[2]);`
134	`do_ray_tests = ae.extract("-R");`	134	`do_ray_tests = ae.extract("-R");`
135	`flip_normals = ae.extract("-f");`	135	`flip_normals = ae.extract("-f");`
136	`fn = ae.get_last_arg();`	136	`fn = ae.get_last_arg();`
137	`}`	137	`}`
138	`load(fn, m);`	138	`load(fn, m);`
139		139
140	`string file_prefix = fn.substr(0, fn.length()-4) + "-";`	140	`string file_prefix = fn.substr(0, fn.length()-4) + "-";`
141	`cout << "Volume dimensions " << vol_dim << endl;`	141	`cout << "Volume dimensions " << vol_dim << endl;`
142	`if(!valid(m))`	142	`if(!valid(m))`
143	`{`	143	`{`
144	`cout << "Not a valid manifold" << endl;`	144	`cout << "Not a valid manifold" << endl;`
145	`exit(0);`	145	`exit(0);`
146	`}`	146	`}`
147	`triangulate_by_edge_face_split(m);`	147	`triangulate_by_edge_face_split(m);`
148		148
149	`Vec3d p0, p7;`	149	`Vec3d p0, p7;`
150	`bbox(m, p0, p7);`	150	`bbox(m, p0, p7);`
151		151
152	`Mat4x4d T = fit_bounding_volume(p0,p7,10);`	152	`Mat4x4d T = fit_bounding_volume(p0,p7,10);`
153		153
154	`cout << "Transformation " << T << endl;`	154	`cout << "Transformation " << T << endl;`
155		155
156	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v)`	156	`for(VertexIDIterator v = m.vertices_begin(); v != m.vertices_end(); ++v)`
157	`m.pos(v) = T.mul_3D_point(m.pos(v));`	157	`m.pos(v) = T.mul_3D_point(m.pos(v));`
158		158
159		159
160	`RGridf grid(vol_dim,FLT_MAX);`	160	`RGridf grid(vol_dim,FLT_MAX);`
161	`Util::Timer tim;`	161	`Util::Timer tim;`
162		162
163		163
164	`float T_build_obb=0, T_build_aabb=0, T_dist_obb=0,`	164	`float T_build_obb=0, T_build_aabb=0, T_dist_obb=0,`
165	`T_dist_aabb=0, T_ray_obb=0, T_ray_aabb=0;`	165	`T_dist_aabb=0, T_ray_obb=0, T_ray_aabb=0;`
166		166
167	`if(do_obb)`	167	`if(do_obb)`
168	`{`	168	`{`
169	`cout << "Building OBB Tree" << endl;`	169	`cout << "Building OBB Tree" << endl;`
170	`tim.start();`	170	`tim.start();`
171	`OBBTree obb_tree;`	171	`OBBTree obb_tree;`
172	`build_OBBTree(m, obb_tree);`	172	`build_OBBTree(m, obb_tree);`
173	`T_build_obb = tim.get_secs();`	173	`T_build_obb = tim.get_secs();`
174		174
175	`cout << "Computing distances from OBB Tree" << endl;`	175	`cout << "Computing distances from OBB Tree" << endl;`
176	`tim.start();`	176	`tim.start();`
177	`DistCompCache<OBBTree> dist(&obb_tree);`	177	`DistCompCache<OBBTree> dist(&obb_tree);`
178	`for_each_voxel(grid, dist);`	178	`for_each_voxel(grid, dist);`
179	`T_dist_obb = tim.get_secs();`	179	`T_dist_obb = tim.get_secs();`
180		180
181	`cout << "Saving distance field" << endl;`	181	`cout << "Saving distance field" << endl;`
182	`save_raw_float(file_prefix+"obb_dist.raw", grid);`	182	`save_raw_float(file_prefix+"obb_dist.raw", grid);`
183		183
184	`if(do_ray_tests)`	184	`if(do_ray_tests)`
185	`{`	185	`{`
186	`cout << "Ray tests on OBB Tree" << endl;`	186	`cout << "Ray tests on OBB Tree" << endl;`
187	`tim.start();`	187	`tim.start();`
188	`RayCast<OBBTree> ray(&obb_tree);`	188	`RayCast<OBBTree> ray(&obb_tree);`
189	`for_each_voxel(grid, ray);`	189	`for_each_voxel(grid, ray);`
190	`T_ray_obb = tim.get_secs();`	190	`T_ray_obb = tim.get_secs();`
191		191
192	`cout << "Saving ray volume" << endl;`	192	`cout << "Saving ray volume" << endl;`
193	`save_raw_float(file_prefix+"obb_ray.raw", grid);`	193	`save_raw_float(file_prefix+"obb_ray.raw", grid);`
194	`}`	194	`}`
195	`}`	195	`}`
196		196
197	`if(do_aabb)`	197	`if(do_aabb)`
198	`{`	198	`{`
199	`cout << "Building AABB Tree" << endl;`	199	`cout << "Building AABB Tree" << endl;`
200	`tim.start();`	200	`tim.start();`
201	`AABBTree aabb_tree;`	201	`AABBTree aabb_tree;`
202	`build_AABBTree(m, aabb_tree);`	202	`build_AABBTree(m, aabb_tree);`
203	`T_build_aabb = tim.get_secs();`	203	`T_build_aabb = tim.get_secs();`
204		204
205	`cout << "Computing distances from AABB Tree" << endl;`	205	`cout << "Computing distances from AABB Tree" << endl;`
206	`tim.start();`	206	`tim.start();`
207	`DistCompCache<AABBTree> dist(&aabb_tree);`	207	`DistCompCache<AABBTree> dist(&aabb_tree);`
208	`for_each_voxel(grid, dist);`	208	`for_each_voxel(grid, dist);`
209	`T_dist_aabb = tim.get_secs();`	209	`T_dist_aabb = tim.get_secs();`
210		210
211	`cout << "Saving distance field" << endl;`	211	`cout << "Saving distance field" << endl;`
212	`save_raw_float(file_prefix+"aabb_dist.raw", grid);`	212	`save_raw_float(file_prefix+"aabb_dist.raw", grid);`
213		213
214	`if(do_ray_tests)`	214	`if(do_ray_tests)`
215	`{`	215	`{`
216	`cout << "Ray tests on AABB tree" << endl;`	216	`cout << "Ray tests on AABB tree" << endl;`
217	`tim.start();`	217	`tim.start();`
218	`RayCast<AABBTree> ray(&aabb_tree);`	218	`RayCast<AABBTree> ray(&aabb_tree);`
219	`for_each_voxel(grid, ray);`	219	`for_each_voxel(grid, ray);`
220	`T_ray_aabb = tim.get_secs();`	220	`T_ray_aabb = tim.get_secs();`
221		221
222	`cout << "Saving ray volume" << endl;`	222	`cout << "Saving ray volume" << endl;`
223	`save_raw_float(file_prefix+"aabb_ray.raw", grid);`	223	`save_raw_float(file_prefix+"aabb_ray.raw", grid);`
224	`}`	224	`}`
225	`}`	225	`}`
226	`cout.width(10);`	226	`cout.width(10);`
227	`cout << "Poly";`	227	`cout << "Poly";`
228	`cout.width(11);`	228	`cout.width(11);`
229	`cout <<"build_obb";`	229	`cout <<"build_obb";`
230	`cout.width(12);`	230	`cout.width(12);`
231	`cout << "build_aabb";`	231	`cout << "build_aabb";`
232	`cout.width(10);`	232	`cout.width(10);`
233	`cout << "dist_obb" ;`	233	`cout << "dist_obb" ;`
234	`cout.width(10);`	234	`cout.width(10);`
235	`cout << "dist_aabb";`	235	`cout << "dist_aabb";`
236	`cout.width(10);`	236	`cout.width(10);`
237	`cout << "ray_obb" ;`	237	`cout << "ray_obb" ;`
238	`cout.width(10);`	238	`cout.width(10);`
239	`cout << "ray_aabb";`	239	`cout << "ray_aabb";`
240	`cout << endl;`	240	`cout << endl;`
241		241
242	`cout.precision(4);`	242	`cout.precision(4);`
243	`cout.width(10);`	243	`cout.width(10);`
244	`cout << m.no_faces() << " ";`	244	`cout << m.no_faces() << " ";`
245	`cout.width(10);`	245	`cout.width(10);`
246	`cout << T_build_obb;`	246	`cout << T_build_obb;`
247	`cout.width(12);`	247	`cout.width(12);`
248	`cout << T_build_aabb;`	248	`cout << T_build_aabb;`
249	`cout.width(10);`	249	`cout.width(10);`
250	`cout << T_dist_obb;`	250	`cout << T_dist_obb;`
251	`cout.width(10);`	251	`cout.width(10);`
252	`cout << T_dist_aabb;`	252	`cout << T_dist_aabb;`
253	`cout.width(10);`	253	`cout.width(10);`
254	`cout << T_ray_obb;`	254	`cout << T_ray_obb;`
255	`cout.width(10);`	255	`cout.width(10);`
256	`cout << T_ray_aabb;`	256	`cout << T_ray_aabb;`
257	`cout << endl;`	257	`cout << endl;`
258	`}`	258	`}`
259		259
260		260
261		261
262	`// Brute force code - never use ...`	262	`// Brute force code - never use ...`
263	`// cout << "Computing distances" << endl;`	263	`// cout << "Computing distances" << endl;`
264	`// for(int i=0;i<triangle_vec_global.size(); ++i)`	264	`// for(int i=0;i<triangle_vec_global.size(); ++i)`
265	`// {`	265	`// {`
266	`// k=0;`	266	`// k=0;`
267	`// TRI = triangle_vec_global[i];`	267	`// TRI = triangle_vec_global[i];`
268	`// for_each_voxel(grid, dist_brute);`	268	`// for_each_voxel(grid, dist_brute);`
269	`// }`	269	`// }`
270		270
271		271
272		272

Subversion Repositories gelsvn

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