Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

principal.cpp @ 774

Revision 774, 33.9 KB checked in by gumbau, 18 years ago (diff)
GTGeometry and GeoTool? initial imports

Line
1	//Headers:
2	//#include <Ogre.h>
3	#include <iostream>
4	#include <fstream>
5
6	//#include <stdio.h>
7	#include <string.h>
8	#include <math.h>
9	#include "principal.h"
10	#include <ctime>
11
12	time_t first, second;
13
14	using namespace std;
15	using namespace Geometry;
16	//using namespace principal;
17	//--------------------------------------------------------------------------------------------------------------------------------
18	// RELLENA LA ESTRUCTURA DE VERTICES
19	//--------------------------------------------------------------------------------------------------------------------------------
20
21	void Mesh2Estructura(Geometry::Mesh *mesh){
22	// Calcular el número de vértices
23	long int countv=0;
24	long int counth=0;
25	long int pos=0;
26	long int v1, v2, v3;
27
28	for (unsigned int i=0; i<mesh->mSubMeshCount; i++){
29	countv+=mesh->mSubMesh[i].mVertexBuffer->mVertexCount;
30	}
31	Vertex = new float[countv][3];
32
33	for (unsigned int i=0; i<mesh->mSubMeshCount; i++){
34	for (unsigned int j=0; j<mesh->mSubMesh[i].mVertexBuffer->mVertexCount; j++) {
35	Vertex[pos][0] = mesh->mSubMesh[i].mVertexBuffer->mPosition[j].x;
36	Vertex[pos][1] = mesh->mSubMesh[i].mVertexBuffer->mPosition[j].y;
37	Vertex[pos][2] = mesh->mSubMesh[i].mVertexBuffer->mPosition[j].z;
38	pos++;
39	}
40	}
41
42	// Calcular el número de hojas
43	for (unsigned int i=0; i<mesh->mSubMeshCount; i++){
44	counth+=mesh->mSubMesh[i].mIndexCount;
45	}
46	counth=counth/3; // Se supone que cada 3 índices forman una hoja.
47	if ( counth > 0){
48	Hojasa = new Hoja[counth];
49	}
50	activas = counth;
51
52	// Insertar las hojas en la estructura
53	pos=0;
54	for (unsigned int i=0; i<mesh->mSubMeshCount; i++){
55	for (unsigned int j=0; j<mesh->mSubMesh[i].mIndexCount/3; j++) {
56	v1=mesh->mSubMesh[i].mIndex[j];
57	v2=mesh->mSubMesh[i].mIndex[j];
58	v3=mesh->mSubMesh[i].mIndex[j];
59	Hojasa[pos].Vertices[0]=(v1-1);
60	Hojasa[pos].Vertices[1]=(v2-1);
61	Hojasa[pos].Vertices[2]=(v3-1);
62	Hojasa[pos].Vertices[3]=(v3-1);
63	Centroh( Hojasa[pos]);
64	GetNormal ( Hojasa[pos]);
65	pos++;
66	}
67	}
68	}
69
70	//long int LeeVertices (char * arbol)
71	//
72	//{
73	// FILE* fp_origen;
74	// char linea[256], str[20];
75	// float x,y,z;
76	// long int countv=0;
77	// bool fin_vertices = false;
78	//
79	// //cuento todos los vertices, y relleno la estructura
80	// if ((fp_origen = fopen (arbol, "r")) == NULL)
81	// printf ("No he podido abrir el fichero %s\n", arbol);
82	// else
83	// {
84	// while ((fgets (linea, 255, fp_origen) != NULL) && (fin_vertices == false))
85	//
86	//
87	// switch (linea[0])
88	// {
89	// case '#':
90	// switch ( linea[2])
91	// {
92	// case 'v':
93	// sscanf(linea,"# %s %lu", str, &countv);
94	// if ( countv > 0) Vertex = new float[2*countv][3];
95	// printf ( "hay %lu vertices\n",countv);
96	// countv=0;
97	// break;
98	//
99	// default:
100	// break;
101	//
102	// }
103	// break;
104	// case 'v':
105	// switch (linea[1])
106	// {
107	// case ' ':
108	// sscanf (linea, "v %f %f %f ", &x, &y, &z);
109	// Vertex[countv][0] = x; Vertex[countv][1] = y; Vertex[countv][2] = z;
110	// countv++;
111	// break;
112	//
113	// default :
114	// break;
115	//
116	// }
117	// break;
118	//
119	//
120	// default:
121	// break;
122	//
123	// }
124	//
125	// fclose (fp_origen);
126	// }
127	// return ( countv);
128	//
129	//
130	//}
131	//--------------------------------------------------------------------------------------------------------------------------------
132	// CUENTA LAS HOJAS QUE HAY EN EL FICHERO
133	//--------------------------------------------------------------------------------------------------------------------------------
134
135	//long int CuentaHojas ( char *hojas)
136	//{
137	//
138	// FILE* fp_hojas;
139	// char linea[256];
140	// long int counth=0;
141	//
142	// if ((fp_hojas = fopen (hojas, "r")) == NULL)
143	// printf ("No he podido abrir el fichero %s\n", hojas);
144	// else
145	// {
146	//
147	// while (fgets (linea, 255, fp_hojas) != NULL)
148	//
149	// switch (linea[0])
150	// {
151	// case 'H':
152	// counth++;
153	// break;
154	//
155	// default :
156	// break;
157	// }
158	//
159	//
160	//
161	// fclose (fp_hojas);
162	//
163	// if ( counth > 0){
164	// Hojasa = new Hoja[2*counth];
165	// }
166	// }
167	// activas = counth;
168	// return (counth);
169	//}
170	//--------------------------------------------------------------------------------------------------------------------------------
171	// LEO LAS HOJAS Y RELLENO LA ESTRUCTURA DE DATOS
172	//--------------------------------------------------------------------------------------------------------------------------------
173
174	//void LeoHojas (char* hojas)
175	//{
176	// FILE* fp_hojas;
177	// char linea[256];
178	// long int v1, v2, v3, h=0;
179	//
180	// if ((fp_hojas = fopen (hojas, "r")) == NULL)
181	// printf ("No he podido abrir el fichero %s\n", hojas);
182	//
183	// else
184	// {
185	//
186	//
187	// while (fgets (linea, 255, fp_hojas) != NULL)
188	//
189	// switch (linea[0])
190	// {
191	// case 'H':
192	//
193	// fgets (linea, 255, fp_hojas);
194	// sscanf(linea, "f %lu %lu %lu", &v1, &v2, &v3);
195	//
196	// Hojasa[h].Vertices[0]=(v1-1);
197	// Hojasa[h].Vertices[1]=(v2-1);
198	// Hojasa[h].Vertices[2]=(v3-1);
199	//
200	// fgets (linea, 255, fp_hojas);
201	// sscanf(linea, "f %lu %lu %lu", &v1, &v2, &v3);
202	// Hojasa[h].Vertices[3]=(v3-1);
203	//
204	// Centroh( Hojasa[h]);
205	// GetNormal ( Hojasa[h]);
206	//
207	// h++;
208	// break;
209	//
210	// default :
211	// printf( "Hay un error al leer las hojas\n");
212	// break;
213	//
214	// }
215	//
216	// fclose(fp_hojas);
217	// }
218	//
219	//
220	//}
221
222	//--------------------------------------------------------------------------------------------------------------------------------
223	// FUNCIONES AUXILIARES
224	//--------------------------------------------------------------------------------------------------------------------------------
225
226	float max ( float a, float b)
227	{
228	if (a>b) return (a);
229	else return(b);
230	}
231
232	float min ( float a, float b)
233	{
234	if (a>b) return (b);
235	else return(a);
236	}
237
238	float distan (float x1, float y1, float z1, float x2, float y2, float z2)
239	{
240	float dist = 0;
241
242	dist = ((x2-x1)(x2-x1)) + ((y2-y1)(y2-y1)) + ((z2-z1)*(z2-z1));
243
244	return ( dist);
245	}
246
247	//--------------------------------------------------------------------------------------------------------------------------------
248	// CALCULA EL CENTRO DE UNA HOJA
249	//--------------------------------------------------------------------------------------------------------------------------------
250
251
252	void Centroh ( Hoja& Hoja1)
253	{
254
255	float max_x, min_x, max_y, min_y, max_z, min_z;
256
257
258	//x1
259	max_x = max ( max (Vertex[Hoja1.Vertices[0]][0], Vertex[Hoja1.Vertices[1]][0]),
260	max (Vertex[Hoja1.Vertices[2]][0], Vertex[Hoja1.Vertices[3]][0]));
261
262	min_x = min ( min (Vertex[Hoja1.Vertices[0]][0], Vertex[Hoja1.Vertices[1]][0]),
263	min (Vertex[Hoja1.Vertices[2]][0], Vertex[Hoja1.Vertices[3]][0]));
264
265	Hoja1.Centro[0] = (max_x + min_x)/2;
266
267	//y1
268	max_y = max ( max (Vertex[Hoja1.Vertices[0]][1], Vertex[Hoja1.Vertices[1]][1]),
269	max (Vertex[Hoja1.Vertices[2]][1], Vertex[Hoja1.Vertices[3]][1]));
270
271	min_y = min ( min (Vertex[Hoja1.Vertices[0]][1], Vertex[Hoja1.Vertices[1]][1]),
272	min (Vertex[Hoja1.Vertices[2]][1], Vertex[Hoja1.Vertices[3]][1]));
273
274	Hoja1.Centro[1] = (max_y + min_y)/2;
275
276	//z1
277	max_z = max ( max (Vertex[Hoja1.Vertices[0]][2], Vertex[Hoja1.Vertices[1]][2]),
278	max (Vertex[Hoja1.Vertices[2]][2], Vertex[Hoja1.Vertices[3]][2]));
279
280	min_z = min ( min (Vertex[Hoja1.Vertices[0]][2], Vertex[Hoja1.Vertices[1]][2]),
281	min (Vertex[Hoja1.Vertices[2]][2], Vertex[Hoja1.Vertices[3]][2]));
282
283	Hoja1.Centro[2] = (max_z + min_z)/2;
284
285
286	}
287
288	//--------------------------------------------------------------------------------------------------------------------------------
289	// CALCULA LA NORMAL DE UNA HOJA
290	//--------------------------------------------------------------------------------------------------------------------------------
291	void GetNormal (Hoja &aHoja)
292	{
293
294	float onex, oney, onez;
295	float twox, twoy, twoz;
296	float threex, threey, threez;
297
298	onex=Vertex[aHoja.Vertices[0]][0]; oney= Vertex[aHoja.Vertices[0]][1]; onez = Vertex[aHoja.Vertices[0]][2];
299	twox = Vertex[aHoja.Vertices[1]][0]; twoy = Vertex[aHoja.Vertices[1]][1]; twoz = Vertex[aHoja.Vertices[1]][2];
300	threex = Vertex[aHoja.Vertices[2]][0]; threey = Vertex[aHoja.Vertices[2]][1]; threez = Vertex[aHoja.Vertices[2]][2];
301
302	aHoja.Normal[0] = ((twoz-onez)(threey-oney)) - ((twoy-oney)(threez-onez));
303	aHoja.Normal[1] = ((twox-onex)(threez-onez)) - ((threex-onex)(twoz-onez));
304	aHoja.Normal[2] = ((threex-onex)(twoy-oney)) - ((twox-onex)(threey-oney));
305
306
307	}
308	//--------------------------------------------------------------------------------------------------------------------------------
309	// CALCULA LA distancia de Hausdorff ( distancia entre nubes de puntos)
310	//--------------------------------------------------------------------------------------------------------------------------------
311	float Hausdorff (Hoja &aHoja, Hoja& h2)
312	{
313
314	float onex, oney, onez;
315	float twox, twoy, twoz;
316	float threex, threey, threez;
317	float fourx, foury, fourz;
318	float x1, y1, z1;
319	float x2, y2, z2;
320	float x3, y3, z3;
321	float x4, y4, z4;
322
323	float dist1, dist2, dist3, dist4, distmp, dista, distb, dist;
324
325	onex=Vertex[aHoja.Vertices[0]][0]; oney= Vertex[aHoja.Vertices[0]][1]; onez = Vertex[aHoja.Vertices[0]][2];
326	twox = Vertex[aHoja.Vertices[1]][0]; twoy = Vertex[aHoja.Vertices[1]][1]; twoz = Vertex[aHoja.Vertices[1]][2];
327	threex = Vertex[aHoja.Vertices[2]][0]; threey = Vertex[aHoja.Vertices[2]][1]; threez = Vertex[aHoja.Vertices[2]][2];
328	fourx = Vertex[aHoja.Vertices[3]][0]; foury = Vertex[aHoja.Vertices[3]][1]; fourz = Vertex[aHoja.Vertices[3]][2];
329
330
331	x1 = Vertex[h2.Vertices[0]][0]; y1 = Vertex[h2.Vertices[0]][1]; z1 = Vertex[h2.Vertices[0]][2];
332	x2 = Vertex[h2.Vertices[1]][0]; y2 = Vertex[h2.Vertices[1]][1]; z2 = Vertex[h2.Vertices[1]][2];
333	x3 = Vertex[h2.Vertices[2]][0]; y3 = Vertex[h2.Vertices[2]][1]; z3 = Vertex[h2.Vertices[2]][2];
334	x4 = Vertex[h2.Vertices[3]][0]; y4 = Vertex[h2.Vertices[3]][1]; z4 = Vertex[h2.Vertices[3]][2];
335
336	// guardo las distancias mínimas de cada vértice a los 4 contrarios.
337	dist1 = distan ( onex, oney,onez,x1,y1,z1);
338	// vertice 1 con los 4 de la otra hoja
339
340	distmp = distan ( onex, oney,onez,x2,y2,z2);
341	if ( distmp < dist1) dist1 = distmp;
342
343	distmp = distan ( onex, oney,onez,x3,y3,z3);
344	if ( distmp < dist1) dist1 = distmp;
345
346	distmp = distan ( onex, oney,onez,x4,y4,z4);
347	if ( distmp < dist1) dist1 = distmp;
348
349	// vertice 2 con los 4 de la otra hoja
350
351	dist2 = distan ( twox, twoy,twoz,x1,y1,z1);
352
353	distmp = distan ( twox, twoy,twoz,x2,y2,z2);
354	if ( distmp < dist2) dist2 = distmp;
355
356	distmp = distan ( twox, twoy,twoz,x3,y3,z3);
357	if ( distmp < dist2) dist2 = distmp;
358
359	distmp = distan ( twox, twoy,twoz,x4,y4,z4);
360	if ( distmp < dist2) dist2 = distmp;
361
362	// vertice 3 con los 4 de la otra hoja
363
364	dist3 = distan ( threex, threey,threez,x1,y1,z1);
365
366	distmp = distan ( threex, threey,threez,x2,y2,z2);
367	if ( distmp < dist3) dist3 = distmp;
368
369	distmp = distan ( threex, threey,threez,x3,y3,z3);
370	if ( distmp < dist3) dist3 = distmp;
371
372	distmp = distan ( threex, threey,threez,x4,y4,z4);
373	if ( distmp < dist3) dist3 = distmp;
374
375
376	// vertice 4 con los 4 de la otra hoja
377
378	dist4 = distan ( fourx, foury,fourz,x1,y1,z1);
379
380	distmp = distan ( fourx, foury,fourz,x2,y2,z2);
381	if ( distmp < dist4) dist4 = distmp;
382
383	distmp = distan ( fourx, foury,fourz,x3,y3,z3);
384	if ( distmp < dist4) dist4 = distmp;
385
386	distmp = distan ( fourx, foury,fourz,x4,y4,z4);
387	if ( distmp < dist4) dist4 = distmp;
388
389	//de entre estos cojo el máximo
390
391	dista = max(dist1, max(dist2, max(dist3, dist4)));
392
393	//LO MISMO PERO A LA INVERSA
394
395	dist1 = distan ( x1,y1,z1, onex, oney, onez);
396	// vertice 1 con los 4 de la otra hoja
397
398	distmp = distan ( x1,y1,z1, twox, twoy, twoz);
399	if ( distmp < dist1) dist1 = distmp;
400
401	distmp = distan ( x1,y1,z1, threex, threey, threez);
402	if ( distmp < dist1) dist1 = distmp;
403
404	distmp = distan ( x1,y1,z1, fourx, foury, fourz);
405	if ( distmp < dist1) dist1 = distmp;
406
407	//2
408	dist2 = distan ( x2,y2,z2, onex, oney, onez);
409	// vertice 2 con los 4 de la otra hoja
410
411	distmp = distan ( x2,y2,z2, twox, twoy, twoz);
412	if ( distmp < dist2) dist2 = distmp;
413
414	distmp = distan ( x2,y2,z2, threex, threey, threez);
415	if ( distmp < dist2) dist2 = distmp;
416
417	distmp = distan ( x2,y2,z2, fourx, foury, fourz);
418	if ( distmp < dist2) dist2 = distmp;
419
420
421	//3
422	dist3 = distan ( x3,y3,z3, onex, oney, onez);
423	// vertice 3 con los 4 de la otra hoja
424
425	distmp = distan ( x3,y3,z3, twox, twoy, twoz);
426	if ( distmp < dist3) dist3 = distmp;
427
428	distmp = distan ( x3,y3,z3, threex, threey, threez);
429	if ( distmp < dist3) dist3 = distmp;
430
431	distmp = distan ( x3,y3,z3, fourx, foury, fourz);
432	if ( distmp < dist3) dist3 = distmp;
433
434	//4
435	dist4 = distan ( x4,y4,z4, onex, oney, onez);
436	// vertice 4 con los 4 de la otra hoja
437
438	distmp = distan ( x4,y4,z4, twox, twoy, twoz);
439	if ( distmp < dist4) dist4 = distmp;
440
441	distmp = distan ( x4,y4,z4, threex, threey, threez);
442	if ( distmp < dist4) dist4 = distmp;
443
444	distmp = distan ( x4,y4,z4, fourx, foury, fourz);
445	if ( distmp < dist4) dist4 = distmp;
446
447	//
448	distb = max(dist1, max(dist2, max(dist3, dist4)));
449
450	dist = max ( dista, distb);
451	return ( dist);
452
453	}
454
455	//--------------------------------------------------------------------------------------------------------------------------------
456	// CALCULA LA DISTANCIA ENTRE HOJAS
457	//--------------------------------------------------------------------------------------------------------------------------------
458
459	void DistanciaEntreHojas(void)
460	{
461	float dist, distmp ;
462	int j;
463
464	for ( int i=0;i<counth;i++)
465	{
466	if ( Hojasa[i].existe == true) // si la hoja aun existe
467	{
468	// inicializo para poder comparar
469	if ( i == (counth-1)) j = 0;
470	else j = i+1;
471	while (Hojasa[j].existe == false) j++;
472	//dist = Hojasa[i].Distancia(Hojasa[j]);
473	dist = Hausdorff( Hojasa[i], Hojasa[j]);
474
475	Hojasa[i].hoja_cerca = j;
476	// empiezo los calculos
477	for ( j =0; j<(counth-1);j++)
478	{
479	if ( j == i)
480	break;
481	if ( Hojasa[j].existe == true) // si la hoja aun existe
482	{
483	distmp = Hausdorff(Hojasa[i], Hojasa[j]);
484	if ( distmp < dist )
485	{
486	dist = distmp;
487	Hojasa[i].hoja_cerca = j;
488	}
489	}
490
491	}
492	Hojasa[i].dist = dist;
493	}
494	}
495
496	}
497
498	//--------------------------------------------------------------------------------------------------------------------------------
499	// DEVUELVE LA HOJA QUE TIENE UNA DISTANCIA MENOR
500	//--------------------------------------------------------------------------------------------------------------------------------
501	long int MinimaDistancia ( void)
502	{
503	float mindist =0;
504	long int cual=-1;
505	int i=0;
506
507	//inicializo
508	while (Hojasa[i].existe != true) i++;
509	mindist = Hojasa[i].dist;
510	cual =i;
511	//busco la minima
512	for ( i=0;i<counth;i++)
513	{
514	if (Hojasa[i].existe == true)
515	{
516	if ( mindist> Hojasa[i].dist)
517	{
518	mindist = Hojasa[i].dist;
519	cual = i;
520	}
521	}
522
523	}
524	return (cual);
525	}
526
527
528	//--------------------------------------------------------------------------------------------------------------------------------
529	// CALCULA LA COPLANARIDAD ENTRE HOJAS
530	//--------------------------------------------------------------------------------------------------------------------------------
531
532	void CoplanarEntreHojas(FILE* fp_coplanar)
533	{
534	float cop, coptmp ;
535	int j, i;
536	// char linea[250];
537
538	for ( i=0;i<counth;i++)
539	{
540	if ( Hojasa[i].existe == true) // si la hoja aun existe
541	{
542	// inicializo para poder comparar
543	if ( i == (counth-1)) j = 0;
544	else j = i+1;
545	while (Hojasa[j].existe == false) j++;
546	cop = Hojasa[i].Coplanaridad(Hojasa[j]);
547
548
549
550	Hojasa[i].hoja_cop = j;
551	// empiezo los calculos
552	for ( j =0; j<(counth-1);j++)
553	{
554	if (( j != i) && ( Hojasa[j].existe == true)) // si la hoja aun existe
555	{
556	coptmp = Hojasa[i].Coplanaridad(Hojasa[j]);
557	/*printf ("Hoja %i coplanaridad con hoja %i es %f\n", i, j,cop);
558	sprintf (linea,"%i %f\n",j, coptmp);
559	fputs (linea, fp_coplanar);*/
560
561	if ( coptmp > cop ) // COJO EL MAS COPLANAR , CERCANO A 1
562	{
563	cop = coptmp;
564	Hojasa[i].hoja_cop = j;
565	}
566	}
567
568	}
569	Hojasa[i].coplanar = 1 - cop; // 8/6/01 LO INVIERTO
570	}
571	}
572
573
574	}
575	//--------------------------------------------------------------------------------------------------------------------------------
576	// DEVUELVE LA HOJA QUE TIENE MÁS COPLANARIDAD// ya no vale. Ahora la buena será la minima 8/6/01
577	//--------------------------------------------------------------------------------------------------------------------------------
578	/*long int MaximaCoplanar ( void)
579	{
580	float maxcop =0;
581	long int cual=-1;
582	int i=0;
583
584	//inicializo
585	while (Hojasa[i].existe != true) i++;
586	maxcop = Hojasa[i].coplanar;
587	cual =i;
588	//busco la minima
589	for ( i=0;i<counth;i++)
590	{
591	if (Hojasa[i].existe == true)
592	{
593	if ( maxcop < Hojasa[i].coplanar)
594	{
595	maxcop = Hojasa[i].coplanar;
596	cual = i;
597	}
598	}
599
600	}
601	return (cual);
602	}
603
604	*/
605	//--------------------------------------------------------------------------------------------------------------------------------
606	//
607	//--------------------------------------------------------------------------------------------------------------------------------
608	void DosMayores(float mayores, int indices)
609	{
610
611	float m1;
612	int i;
613
614	if ( mayores[0] < mayores[1])
615	{
616	m1= mayores[0];
617	mayores[0] = mayores[1];
618	mayores[1] = m1;
619
620	i = indices[0];
621	indices[0] = indices[1];
622	indices[1] = i;
623
624	}
625
626	if ( mayores [2] < mayores [3])
627	{
628	m1 = mayores[2];
629	mayores[2] = mayores[3];
630	mayores [3] = m1;
631
632	i = indices[2];
633	indices[2] = indices[3];
634	indices[3] = i;
635
636	}
637
638	if ( mayores[0] < mayores[2])
639	{
640	m1= mayores[0];
641	mayores[0] = mayores[2];
642	mayores[2] = m1;
643
644	i = indices[0];
645	indices[0] = indices[2];
646	indices[2] = i;
647
648	}
649
650
651	if ( mayores [2] < mayores [3])
652	{
653	m1 = mayores[2];
654	mayores[2] = mayores[3];
655	mayores [3] = m1;
656
657	i = indices[2];
658	indices[2] = indices[3];
659	indices[3] = i;
660
661	}
662
663	if ( mayores [1] < mayores [2])
664	{
665	m1 = mayores[1];
666	mayores[1] = mayores[2];
667	mayores [2] = m1;
668
669	i = indices[1];
670	indices[1] = indices[2];
671	indices[2] = i;
672
673	}
674
675
676	}
677	//--------------------------------------------------------------------------------------------------------------------------------
678	//
679	//--------------------------------------------------------------------------------------------------------------------------------
680	float DiametroEsferaEnvolvente (FILE* fp_simplifica)
681	{
682	float xmax, xmin, ymax, ymin, zmax, zmin;
683	float diametro, cx, cy, cz;
684	int j;
685	char linea[250];
686
687	//inicializo al primero de los vértices de las hojas
688
689	xmax = Vertex[Hojasa[0].Vertices[0]][0];
690	xmin = xmax;
691
692	ymax = Vertex[Hojasa[0].Vertices[0]][1];
693	ymin = ymax;
694
695	zmax = Vertex[Hojasa[0].Vertices[0]][2];
696	zmin = zmax;
697
698	// ahora busco los maximos y los minimos correspondientes
699
700
701	for ( int i=1;i<counth;i++)
702	{
703	for ( j=0;j<4;j++)
704	{
705
706	if ( xmax < Vertex[Hojasa[i].Vertices[j]][0]) xmax = Vertex[Hojasa[i].Vertices[j]][0];
707	if ( xmin > Vertex[Hojasa[i].Vertices[j]][0]) xmin = Vertex[Hojasa[i].Vertices[j]][0];
708
709	if ( ymax < Vertex[Hojasa[i].Vertices[j]][1]) ymax = Vertex[Hojasa[i].Vertices[j]][1];
710	if ( ymin > Vertex[Hojasa[i].Vertices[j]][1]) ymin = Vertex[Hojasa[i].Vertices[j]][1];
711
712	if ( zmax < Vertex[Hojasa[i].Vertices[j]][2]) zmax = Vertex[Hojasa[i].Vertices[j]][2];
713	if ( zmin > Vertex[Hojasa[i].Vertices[j]][2]) zmin = Vertex[Hojasa[i].Vertices[j]][2];
714
715	}
716	}
717
718	cx = (xmax + xmin)/2;
719	cy = (ymax + ymin)/2;
720	cz = (zmax + zmin)/2;
721
722
723	diametro = ((xmax-xmin)(xmax-xmin)) + ((ymax-ymin)(ymax-ymin)) + ((zmax-zmin)*(zmax-zmin));
724	//en la pantalla
725	printf ("Centro %f %f %f\n", cx,cy,cz );
726	//en el fichero
727	sprintf (linea,"Centro %f %f %f \n",cx, cy, cz);
728	fputs (linea, fp_simplifica);
729
730	// x
731	sprintf (linea,"x %f %f\n",xmax, xmin);
732	printf (linea,"x %f %f\n",xmax, xmin);
733	fputs (linea, fp_simplifica);
734	// y
735	sprintf (linea,"y %f %f\n",ymax, ymin);
736	printf (linea,"y %f %f\n",ymax, ymin);
737	fputs (linea, fp_simplifica);
738	// z
739	sprintf (linea,"z %f %f\n",zmax, zmin);
740	printf (linea,"z %f %f\n",zmax, zmin);
741	fputs (linea, fp_simplifica);
742
743
744	return (diametro);
745	}
746
747	//--------------------------------------------------------------------------------------------------------------------------------
748	// normaliza las distancia
749	//--------------------------------------------------------------------------------------------------------------------------------
750	void NormalizaDistancia (float diametro)
751	{
752	float dtmp;
753	for (int i=0; i<counth;i++)
754	{
755	dtmp = Hojasa[i].dist;
756	Hojasa[i].dist = dtmp / diametro;
757
758	}
759	}
760
761	//--------------------------------------------------------------------------------------------------------------------------------
762	// establece el criterio como (K1 * dist + K2 * cop)/ K1+K2
763	//--------------------------------------------------------------------------------------------------------------------------------
764	void EstableceCriterio ( float diametro)
765	{
766	//Para empezar establezco K1 y K2 con 0,5
767	float coptmp2, coptmp, distmp2, distmp, criteriotmp;
768	int i, j, nhojasi, nhojasj;
769
770
771	for ( i=0; i<counth;i++)
772
773	{
774	if (Hojasa[i].existe == true)
775	{
776	//incializo criterio a un numero elevado
777	Hojasa[i].criterio = 1000;
778	nhojasi = Hojasa[i].Cuantas_hojas;
779	//coplanaridad
780	for ( j =0; j<counth;j++)
781	{
782	if (( j != i) && ( Hojasa[j].existe == true)) // si la hoja aun existe
783	{
784	//17/09/01 ANTES DE CALCULAR NADA, COMPRUEBO QUE ESTAS DOS HOJAS
785	// SE PODRIAN COLAPSAR, ED, QUE LA DIFERENCIA DE HOJAS QUE COLAPSAN
786	// ES COMO MÁXIMO 1
787
788	nhojasj = Hojasa[j].Cuantas_hojas;
789
790	if ( abs((nhojasi - nhojasj)) < 2)
791	{
792	//coplanaridad y lo invierto
793	coptmp2 = Hojasa[i].Coplanaridad(Hojasa[j]);
794	coptmp = 1 - coptmp2;
795	//distancia y la normalizo
796	distmp2 = Hausdorff( Hojasa[i], Hojasa[j]);
797	distmp = distmp2 / diametro;
798	// calculo el criterio para esa hoja
799	criteriotmp = (( K1 * distmp * distmp ) + (K2 * coptmp * distmp))/ (K1 + K2);
800	//selecciono el criterio menor
801	if (Hojasa[i].criterio > criteriotmp)
802	{Hojasa[i].criterio = criteriotmp;
803	Hojasa[i].hoja_crit = j;}
804
805	}
806	}
807
808	}
809	// printf ( "Criterio establecido para hoja %i \n", i);
810	}
811	}
812	}
813	//--------------------------------------------------------------------------------------------------------------------------------
814	// establece el criterio despues de colapsar
815	//--------------------------------------------------------------------------------------------------------------------------------
816	void EstableceCriterio2 ( float diametro, long int hojanueva)
817	{
818	//Para empezar establezco K1 y K2 con 0,5
819	float coptmp2, coptmp, distmp2, distmp, criteriotmp;
820	int i, j, nhojasi, nhojasj;
821
822	//ESTAN EN tres PROCEDIMIENTOS: COLAPSA, ESTABLECECRITERIO Y ESTABLECECRITERIO2
823
824
825	for ( i=0; i<counth;i++)
826	{
827	if ((Hojasa[i].existe == true) && (i != hojanueva))
828	{
829	nhojasi = Hojasa[i].Cuantas_hojas;
830	//¿ SE HA DESACTIVADO LA HOJA_CRIT QUE GUARDABA LA HOJA?
831	if ( Hojasa[Hojasa[i].hoja_crit].existe == false)
832	{
833	Hojasa[i].criterio = 1000;
834
835	//coplanaridad
836	for ( j =0; j<counth;j++)
837	{
838	if (( j != i) && ( Hojasa[j].existe == true)) // si la hoja aun existe
839	{
840
841
842	//17/09/01 ANTES DE CALCULAR NADA, COMPRUEBO QUE ESTAS DOS HOJAS
843	// SE PODRIAN COLAPSAR, ED, QUE LA DIFERENCIA DE HOJAS QUE COLAPSAN
844	// ES COMO MÁXIMO 1
845
846	nhojasj = Hojasa[j].Cuantas_hojas;
847
848	if ( abs((nhojasi - nhojasj)) < 2)
849	{
850
851	//coplanaridad y lo invierto
852	coptmp2 = Hojasa[i].Coplanaridad(Hojasa[j]);
853	coptmp = 1 - coptmp2;
854	//distancia y la normalizo
855	// distmp2 = Hojasa[i].Distancia(Hojasa[j]);
856	distmp2 = Hausdorff( Hojasa[i], Hojasa[j]);
857	distmp = distmp2 / diametro;
858	// calculo el criterio para esa hoja
859	criteriotmp = (( K1 * distmp * distmp ) + (K2 * coptmp * distmp))/ (K1 + K2);
860	//selecciono el criterio menor
861	if (Hojasa[i].criterio > criteriotmp)
862	{Hojasa[i].criterio = criteriotmp;
863	Hojasa[i].hoja_crit = j;}
864	}
865	}
866	}
867	}
868	else
869	{ // CALCULARE SI EL CRITERIO CON ESTA HOJA ES MENOR QUE EL ANTERIOR
870
871	nhojasj = Hojasa[hojanueva].Cuantas_hojas;//17/09/01
872
873	if ( abs((nhojasi - nhojasj)) < 2)
874	{
875
876
877	//coplanaridad y lo invierto
878	coptmp2 = Hojasa[i].Coplanaridad(Hojasa[hojanueva]);
879	coptmp = 1 - coptmp2;
880	//distancia y la normalizo
881	//distmp2 = Hojasa[i].Distancia(Hojasa[hojanueva]);
882	distmp2 = Hausdorff( Hojasa[i], Hojasa[hojanueva]);
883	distmp = distmp2 / diametro;
884	// calculo el criterio para esa hoja
885	criteriotmp = (( K1 * distmp * distmp ) + (K2 * coptmp * distmp))/ (K1 + K2);
886	//selecciono el criterio menor
887	if (Hojasa[i].criterio > criteriotmp)
888	{Hojasa[i].criterio = criteriotmp;
889	Hojasa[i].hoja_crit = hojanueva;
890	//printf ( "Cambio el criterio para hoja %i \n", i);
891	}
892	}
893	}
894	}
895
896
897	}
898	}
899	//--------------------------------------------------------------------------------------------------------------------------------
900	// DEVUELVE LA HOJA QUE TIENE EL NUMERO EN EL CAMPO CRITERIO MENOR
901	//--------------------------------------------------------------------------------------------------------------------------------
902
903	long int MinimoCriterio ( void)
904	{
905	float mincrit =0;
906	long int cual=-1;
907	int i=0;
908
909	//inicializo
910	while (Hojasa[i].existe != true) i++;
911	mincrit = Hojasa[i].criterio;
912	cual =i;
913	//busco la minima
914	for ( i=0;i<counth;i++)
915	{
916	if (Hojasa[i].existe == true)
917	{
918	if ( mincrit> Hojasa[i].criterio)
919	{
920	mincrit = Hojasa[i].criterio;
921	cual = i;
922	}
923	}
924
925	}
926	return (cual);
927	}
928
929
930	//--------------------------------------------------------------------------------------------------------------------------------
931	//
932	//--------------------------------------------------------------------------------------------------------------------------------
933	void ElijeVertices(Hoja& Hoja1, Hoja& Hoja2, long int count)
934	{
935	// criterio es el de los dos vertices más alejados del centro de la otra hoja
936
937	float a,b,c;
938	float dist[4];
939	int indices[4];
940
941	// primero de la primera hoja cojo los dos primeros vertices
942
943
944	a = Vertex[Hoja1.Vertices[0]][0];
945	b = Vertex[Hoja1.Vertices[0]][1];
946	c = Vertex[Hoja1.Vertices[0]][2];
947
948	dist[0] = ((Hoja2.Centro[0]-a)(Hoja2.Centro[0]-a)) + ((Hoja2.Centro[1]-b)(Hoja2.Centro[1]-b)) +
949	((Hoja2.Centro[2]-c)*(Hoja2.Centro[2]-c));
950
951
952	a = Vertex[Hoja1.Vertices[1]][0];
953	b = Vertex[Hoja1.Vertices[1]][1];
954	c = Vertex[Hoja1.Vertices[1]][2];
955
956	dist[1] = ((Hoja2.Centro[0]-a)(Hoja2.Centro[0]-a)) + ((Hoja2.Centro[1]-b)(Hoja2.Centro[1]-b)) +
957	((Hoja2.Centro[2]-c)*(Hoja2.Centro[2]-c));
958
959	a = Vertex[Hoja1.Vertices[2]][0];
960	b = Vertex[Hoja1.Vertices[2]][1];
961	c = Vertex[Hoja1.Vertices[2]][2];
962
963	dist[2] = ((Hoja2.Centro[0]-a)(Hoja2.Centro[0]-a)) + ((Hoja2.Centro[1]-b)(Hoja2.Centro[1]-b)) +
964	((Hoja2.Centro[2]-c)*(Hoja2.Centro[2]-c));
965
966
967	a = Vertex[Hoja1.Vertices[3]][0];
968	b = Vertex[Hoja1.Vertices[3]][1];
969	c = Vertex[Hoja1.Vertices[3]][2];
970
971	dist[3] = ((Hoja2.Centro[0]-a)(Hoja2.Centro[0]-a)) + ((Hoja2.Centro[1]-b)(Hoja2.Centro[1]-b)) +
972	((Hoja2.Centro[2]-c)*(Hoja2.Centro[2]-c));
973
974	for ( int i=0;i<4;i++) indices[i]=i;
975
976	DosMayores(dist, indices);
977
978	Hojasa[counth].Vertices[0] = Hoja1.Vertices[indices[0]];
979	Hojasa[counth].Vertices[1] = Hoja1.Vertices[indices[1]];
980
981	// segunda hoja los dos ultimos vertices
982
983
984	a = Vertex[Hoja2.Vertices[0]][0];
985	b = Vertex[Hoja2.Vertices[0]][1];
986	c = Vertex[Hoja2.Vertices[0]][2];
987
988	dist[0] = ((Hoja1.Centro[0]-a)(Hoja1.Centro[0]-a)) + ((Hoja1.Centro[1]-b)(Hoja1.Centro[1]-b)) +
989	((Hoja1.Centro[2]-c)*(Hoja1.Centro[2]-c));
990
991
992	a = Vertex[Hoja2.Vertices[1]][0];
993	b = Vertex[Hoja2.Vertices[1]][1];
994	c = Vertex[Hoja2.Vertices[1]][2];
995
996	dist[1] = ((Hoja2.Centro[0]-a)(Hoja2.Centro[0]-a)) + ((Hoja1.Centro[1]-b)(Hoja1.Centro[1]-b)) +
997	((Hoja2.Centro[2]-c)*(Hoja2.Centro[2]-c));
998
999	a = Vertex[Hoja2.Vertices[2]][0];
1000	b = Vertex[Hoja2.Vertices[2]][1];
1001	c = Vertex[Hoja2.Vertices[2]][2];
1002
1003	dist[2] = ((Hoja1.Centro[0]-a)(Hoja1.Centro[0]-a)) + ((Hoja1.Centro[1]-b)(Hoja1.Centro[1]-b)) +
1004	((Hoja1.Centro[2]-c)*(Hoja1.Centro[2]-c));
1005
1006
1007	a = Vertex[Hoja2.Vertices[3]][0];
1008	b = Vertex[Hoja2.Vertices[3]][1];
1009	c = Vertex[Hoja2.Vertices[3]][2];
1010
1011	dist[3] = ((Hoja1.Centro[0]-a)(Hoja1.Centro[0]-a)) + ((Hoja1.Centro[1]-b)(Hoja1.Centro[1]-b)) +
1012	((Hoja1.Centro[2]-c)*(Hoja1.Centro[2]-c));
1013
1014	for ( int i=0;i<4;i++) indices[i]=i;
1015
1016	DosMayores(dist, indices);
1017
1018	Hojasa[counth].Vertices[2] = Hoja2.Vertices[indices[0]];
1019	Hojasa[counth].Vertices[3] = Hoja2.Vertices[indices[1]];
1020
1021
1022
1023
1024	}
1025
1026	//--------------------------------------------------------------------------------------------------------------------------------
1027	// AÑADE HOJAS
1028	//--------------------------------------------------------------------------------------------------------------------------------
1029	long int Colapsa (FILE *fp_simplifica, float diametro)
1030	{
1031	long int i=0, cual=-1;
1032	long int otra = -1;
1033	float coptmp, coptmp2, distmp, distmp2, criteriotmp;
1034	char linea[250];
1035
1036
1037	// cual=MinimaDistancia();
1038	cual=MinimoCriterio();
1039	// otra = Hojasa[cual].hoja_cerca; //para la distancia
1040	// otra = Hojasa[cual].hoja_cop;
1041	otra = Hojasa[cual].hoja_crit;
1042
1043
1044	//desactivo las hojas cercanas
1045	Hojasa[cual].existe = false;
1046	Hojasa[otra].existe = false;
1047	//creo la hoja nueva
1048
1049	Hojasa[counth].hoja_cerca = -1;
1050	Hojasa[counth].dist = 0;
1051	Hojasa[counth].hoja_cop = -1;
1052	Hojasa[counth].coplanar = 0;
1053
1054	Hojasa[counth].Cuantas_hojas = Hojasa[cual].Cuantas_hojas + Hojasa[otra].Cuantas_hojas;
1055	ElijeVertices(Hojasa[cual], Hojasa[otra], counth);
1056	Centroh (Hojasa[counth]);
1057	GetNormal ( Hojasa[counth]);
1058
1059	//18/09/01
1060	if ( Hojasa[counth].Cuantas_hojas > 60 )
1061	{
1062	Hojasa[counth].existe = false;
1063	activas--;
1064	}
1065	else
1066	{
1067
1068
1069	//establezco el criterio para la hoja nueva
1070	Hojasa[counth].existe = true;
1071	Hojasa[counth].criterio = 1000;
1072	//coplanaridad
1073	for ( int j =0; j<(counth+1);j++)
1074	{
1075	if (( j != counth) && ( Hojasa[j].existe == true)) // si la hoja aun existe
1076	{
1077	//coplanaridad y lo invierto
1078	coptmp2 = Hojasa[counth].Coplanaridad(Hojasa[j]);
1079	coptmp = 1 - coptmp2;
1080	//distancia y la normalizo
1081	//distmp2 = Hojasa[counth].Distancia(Hojasa[j]);
1082	distmp2 = Hausdorff( Hojasa[counth], Hojasa[j]);
1083	distmp = distmp2 / diametro;
1084	// calculo el criterio para esa hoja
1085	criteriotmp = (( K1 * distmp * distmp ) + (K2 * coptmp * distmp))/ (K1 + K2);
1086	//selecciono el criterio menor
1087	if (Hojasa[counth].criterio > criteriotmp)
1088	{Hojasa[counth].criterio = criteriotmp;
1089	Hojasa[counth].hoja_crit = j;}
1090
1091	}
1092	}
1093
1094	}
1095	//en la pantalla
1096	// printf ("Nuevo %i Ver %lu %lu %lu %lu Tviej %lu %lu Engloba %i\n",
1097	// counth, Hojasa[counth].Vertices[0], Hojasa[counth].Vertices[1], Hojasa[counth].Vertices[2],
1098	// Hojasa[counth].Vertices[3], cual, otra, Hojasa[counth].Cuantas_hojas);
1099
1100	//en el fichero
1101	sprintf (linea,"Nuevo %i Ver %lu %lu %lu %lu T_viej %lu %lu Engloba %i\n",
1102	counth, Hojasa[counth].Vertices[0], Hojasa[counth].Vertices[1], Hojasa[counth].Vertices[2],
1103	Hojasa[counth].Vertices[3], cual, otra, Hojasa[counth].Cuantas_hojas);
1104	fputs (linea, fp_simplifica);
1105
1106
1107	//incremento el numero de hojas
1108	counth++;
1109	activas--;
1110
1111	return (counth-1);//porque lo he incrementado en la linea de antes
1112
1113	}
1114
1115	void simplifica(void){
1116	long int totalv=0, hnueva;
1117	float diam;
1118
1119	FILE* fp_simplifica;
1120	diam = DiametroEsferaEnvolvente(fp_simplifica );
1121	EstableceCriterio (diam);
1122
1123	while ( activas > 20) {
1124	hnueva=Colapsa(fp_simplifica, diam);
1125	EstableceCriterio2 (diam, hnueva);
1126	}
1127	}
1128
1129	//--------------------------------------------------------------------------------------------------------------------------------
1130	// MAIN DEL PROGRAMA
1131	//--------------------------------------------------------------------------------------------------------------------------------
1132
1133	//int main (int argc, char ** argv)
1134	//{
1135	//
1136	// long int totalv=0, hnueva;
1137	// float diam;
1138	// FILE* fp_simplifica;
1139	//// FILE* fp_criterio;
1140	//
1141	// first = time(NULL);
1142	//
1143	// char fvertices[100],fhojas[100],fsalida[100];
1144	// strcpy(fvertices,"H:\\GTGeometry\\tests\\bin\\vertices.obj\0");
1145	// strcpy(fhojas,"H:\\GTGeometry\\tests\\bin\\hojas.obj\0");
1146	// strcpy(fsalida,"H:\\GTGeometry\\tests\\bin\\salida.kk\0");
1147	//
1148	// argc=4;
1149	// if (argc != 4) {// el 0 es el nombre del programa
1150	// puts ("Sintaxis: fichero_arbol fichero_hojas fichero_simplif");
1151	// getchar();
1152	// return -1;
1153	// }
1154	//
1155	// //cuento todos los vertices, y relleno la estructura
1156	// totalv = LeeVertices(fvertices);
1157	//
1158	// //cuento las hojas
1159	// counth= CuentaHojas (fhojas);
1160	// printf ("Hay %lu hojas\n", counth);
1161	//
1162	// // lleno la estructura de datos de las hojas ( inicial y activas)
1163	// printf ("Ahora las leo\n");
1164	// LeoHojas(fhojas);
1165	//// DistanciaEntreHojas();
1166	//// CoplanarEntreHojas(fp_coplanar);
1167	// if ((fp_simplifica = fopen (fsalida, "w")) == NULL)
1168	// printf ("No puedo abrir el fichero %s\n", argv[3]);
1169	// else
1170	// {
1171	//
1172	// diam = DiametroEsferaEnvolvente(fp_simplifica );
1173	// EstableceCriterio (diam);
1174	// //
1175	// /*if ((fp_criterio = fopen ("criterio.obj", "w")) == NULL)
1176	// printf ("No puedo abrir el fichero distancias\n");
1177	// else
1178	// EscribeCriterio(fp_criterio);
1179	//
1180	// */while ( activas > 20)
1181	// {
1182	// hnueva=Colapsa(fp_simplifica, diam);
1183	// EstableceCriterio2 (diam, hnueva);
1184	// // EscribeCriterio(fp_criterio);
1185	//
1186	//
1187	// }
1188	//
1189	// fclose ( fp_simplifica);
1190	// // fclose ( fp_criterio);
1191	// }
1192	//
1193	// second = time(NULL);
1194	// printf("Diferencia: %f segundos\n", difftime(second, first));
1195	// getchar();
1196	// return 0;
1197	//}//main

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/principal.cpp @ 774

Download in other formats: