| 1 |
|
1 |
/*****************************************************************
|
| 2 |
|
|
|
| 3 |
|
|
r3d_comp_edge.c Type:Func
|
| 4 |
|
|
|
| 5 |
|
|
Comparaison des edge d une octree
|
| 6 |
|
|
|
| 7 |
|
|
Date de creation : Tue Jul 22 16:22:09 1997
|
| 8 |
|
|
|
| 9 |
|
|
Derniere version : Wed Jul 23 10:15:36 1997
|
| 10 |
|
|
|
| 11 |
|
|
|
| 12 |
|
|
|
| 13 |
|
|
Vincent FRANCOIS
|
| 14 |
|
|
|
| 15 |
|
|
*****************************************************************/
|
| 16 |
|
|
|
| 17 |
|
|
|
| 18 |
|
|
|
| 19 |
|
|
|
| 20 |
|
|
|
| 21 |
|
|
/**************************/
|
| 22 |
|
|
/* include */
|
| 23 |
|
|
#include <stdio.h>
|
| 24 |
|
|
#include <string.h>
|
| 25 |
|
|
#include <math.h>
|
| 26 |
|
|
#include "const.h"
|
| 27 |
|
|
#include "memoire.h"
|
| 28 |
|
|
#include "struct.h"
|
| 29 |
|
|
#include "prototype.h"
|
| 30 |
|
|
|
| 31 |
|
|
#define EPS(x) 0.0002*x*x
|
| 32 |
|
|
/**************************/
|
| 33 |
|
|
/* variables globales */
|
| 34 |
|
|
extern struct s_acis *acis;
|
| 35 |
|
|
extern struct environnement env;
|
| 36 |
|
|
extern struct s_mesh *mesh;
|
| 37 |
|
|
extern struct s_param *para;
|
| 38 |
|
|
|
| 39 |
|
|
|
| 40 |
|
|
|
| 41 |
|
|
/**************************/
|
| 42 |
|
|
/* programme principal */
|
| 43 |
|
|
|
| 44 |
|
|
void r3d_comp_edge(struct s_octree *oct,int nb_edge,float dens)
|
| 45 |
|
|
{
|
| 46 |
|
|
char mess[255],type_entite[20];
|
| 47 |
|
|
int j,type,k;
|
| 48 |
|
|
struct s_edge *edge;
|
| 49 |
|
|
struct s_straight *straight;
|
| 50 |
|
|
struct s_ellipse *ellipse;
|
| 51 |
|
|
struct r_edge l_edge[10];
|
| 52 |
|
|
int nint[6],nb_entite,ok,num;
|
| 53 |
|
|
float dir[4],x1,x2,y1,y2,z1,z2,ox[4],oy[4],x[12],y[12],z[12],carac[12];
|
| 54 |
|
|
int nb_face_lien,l_face[2];
|
| 55 |
|
|
|
| 56 |
|
|
|
| 57 |
|
|
nb_entite=0;
|
| 58 |
|
|
for (j=0;j<oct->nb_edge;j++)
|
| 59 |
|
|
{
|
| 60 |
|
|
x1=oct->x;
|
| 61 |
|
|
y1=oct->y;
|
| 62 |
|
|
z1=oct->z;
|
| 63 |
|
|
x2=oct->x+oct->taille;
|
| 64 |
|
|
y2=oct->y+oct->taille;
|
| 65 |
|
|
z2=oct->z+oct->taille;
|
| 66 |
|
|
edge=oct->edge[j];
|
| 67 |
|
|
if (strcmp(acis->type_entite[edge->curve],"straight-curve")==0)
|
| 68 |
|
|
{
|
| 69 |
|
|
straight=(struct s_straight *)acis->entity[edge->curve];
|
| 70 |
|
|
memcpy(dir,straight->param->dir,3*sizeof(float));
|
| 71 |
|
|
eval_vecteur(dir);
|
| 72 |
|
|
l_edge[nb_entite].nb_carac=3;
|
| 73 |
|
|
l_edge[nb_entite].type=STRAIGHT;
|
| 74 |
|
|
memcpy(l_edge[nb_entite].carac,dir,3*sizeof(float));
|
| 75 |
|
|
l_edge[nb_entite].gtrouve=0;
|
| 76 |
|
|
l_edge[nb_entite].num=edge->num;
|
| 77 |
|
|
l_edge[nb_entite].nint[0]=geo_int_stra_plane(edge,straight,x1,y1,z1,x2,y1,z1,x1,y2,z1,&l_edge[nb_entite].x[0],&l_edge[nb_entite].y[0],&l_edge[nb_entite].z[0]);
|
| 78 |
|
|
l_edge[nb_entite].nint[1]=geo_int_stra_plane(edge,straight,x2,y1,z1,x2,y1,z2,x2,y2,z1,&l_edge[nb_entite].x[2],&l_edge[nb_entite].y[2],&l_edge[nb_entite].z[2]);
|
| 79 |
|
|
l_edge[nb_entite].nint[2]=geo_int_stra_plane(edge,straight,x2,y1,z2,x1,y1,z2,x2,y2,z2,&l_edge[nb_entite].x[4],&l_edge[nb_entite].y[4],&l_edge[nb_entite].z[4]);
|
| 80 |
|
|
l_edge[nb_entite].nint[3]=geo_int_stra_plane(edge,straight,x1,y1,z2,x1,y1,z1,x1,y2,z2,&l_edge[nb_entite].x[6],&l_edge[nb_entite].y[6],&l_edge[nb_entite].z[6]);
|
| 81 |
|
|
l_edge[nb_entite].nint[4]=geo_int_stra_plane(edge,straight,x1,y2,z1,x2,y2,z1,x1,y2,z2,&l_edge[nb_entite].x[8],&l_edge[nb_entite].y[8],&l_edge[nb_entite].z[8]);
|
| 82 |
|
|
l_edge[nb_entite].nint[5]=geo_int_stra_plane(edge,straight,x1,y1,z1,x2,y1,z1,x1,y1,z2,&l_edge[nb_entite].x[10],&l_edge[nb_entite].y[10],&l_edge[nb_entite].z[10]);
|
| 83 |
|
|
}
|
| 84 |
|
|
if (strcmp(acis->type_entite[edge->curve],"ellipse-curve")==0)
|
| 85 |
|
|
{
|
| 86 |
|
|
ellipse=(struct s_ellipse *)acis->entity[edge->curve];
|
| 87 |
|
|
memcpy(ox,ellipse->param->u,3*sizeof(float));
|
| 88 |
|
|
memcpy(oy,ellipse->param->v,3*sizeof(float));
|
| 89 |
|
|
eval_vecteur(ox);
|
| 90 |
|
|
eval_vecteur(oy);
|
| 91 |
|
|
l_edge[nb_entite].nb_carac=11;
|
| 92 |
|
|
l_edge[nb_entite].type=ELLIPSE;
|
| 93 |
|
|
memcpy(l_edge[nb_entite].carac,ellipse->param->centre,3*sizeof(float));
|
| 94 |
|
|
l_edge[nb_entite].carac[3]=ellipse->param->a;
|
| 95 |
|
|
memcpy(l_edge[nb_entite].carac+4,ox,3*sizeof(float));
|
| 96 |
|
|
l_edge[nb_entite].carac[7]=ellipse->param->b;
|
| 97 |
|
|
memcpy(l_edge[nb_entite].carac+8,oy,3*sizeof(float));
|
| 98 |
|
|
l_edge[nb_entite].gtrouve=0;
|
| 99 |
|
|
l_edge[nb_entite].num=edge->num;
|
| 100 |
|
|
l_edge[nb_entite].nint[0]=geo_int_elli_plane(edge,ellipse,x1,y1,z1,x2,y1,z1,x1,y2,z1,&l_edge[nb_entite].x[0],&l_edge[nb_entite].y[0],&l_edge[nb_entite].z[0]);
|
| 101 |
|
|
l_edge[nb_entite].nint[1]=geo_int_elli_plane(edge,ellipse,x2,y1,z1,x2,y1,z2,x2,y2,z1,&l_edge[nb_entite].x[2],&l_edge[nb_entite].y[2],&l_edge[nb_entite].z[2]);
|
| 102 |
|
|
l_edge[nb_entite].nint[2]=geo_int_elli_plane(edge,ellipse,x2,y1,z2,x1,y1,z2,x2,y2,z2,&l_edge[nb_entite].x[4],&l_edge[nb_entite].y[4],&l_edge[nb_entite].z[4]);
|
| 103 |
|
|
l_edge[nb_entite].nint[3]=geo_int_elli_plane(edge,ellipse,x1,y1,z2,x1,y1,z1,x1,y2,z2,&l_edge[nb_entite].x[6],&l_edge[nb_entite].y[6],&l_edge[nb_entite].z[6]);
|
| 104 |
|
|
l_edge[nb_entite].nint[4]=geo_int_elli_plane(edge,ellipse,x1,y2,z1,x2,y2,z1,x1,y2,z2,&l_edge[nb_entite].x[8],&l_edge[nb_entite].y[8],&l_edge[nb_entite].z[8]);
|
| 105 |
|
|
l_edge[nb_entite].nint[5]=geo_int_elli_plane(edge,ellipse,x1,y1,z1,x2,y1,z1,x1,y1,z2,&l_edge[nb_entite].x[10],&l_edge[nb_entite].y[10],&l_edge[nb_entite].z[10]);
|
| 106 |
|
|
}
|
| 107 |
|
|
if ((l_edge[nb_entite].nint[0]!=0) ||
|
| 108 |
|
|
(l_edge[nb_entite].nint[1]!=0) ||
|
| 109 |
|
|
(l_edge[nb_entite].nint[2]!=0) ||
|
| 110 |
|
|
(l_edge[nb_entite].nint[3]!=0) ||
|
| 111 |
|
|
(l_edge[nb_entite].nint[4]!=0) ||
|
| 112 |
|
|
(l_edge[nb_entite].nint[5]!=0) ) nb_entite++;
|
| 113 |
|
|
}
|
| 114 |
|
|
|
| 115 |
|
|
|
| 116 |
|
|
|
| 117 |
|
|
|
| 118 |
|
|
for (j=0;j<nb_edge;j++)
|
| 119 |
|
|
{
|
| 120 |
|
|
r3d_file(mess);
|
| 121 |
|
|
sscanf(mess,"%s",type_entite);
|
| 122 |
|
|
if (strcmp(type_entite,"STRAIGHT")==0)
|
| 123 |
|
|
{
|
| 124 |
|
|
type=STRAIGHT;
|
| 125 |
|
|
sscanf(mess,"%s %d %f %f %f",type_entite,&num,&carac[0],&carac[1],&carac[2]);
|
| 126 |
|
|
r3d_file(mess);
|
| 127 |
|
|
sscanf(mess,"%d %d %d",&nb_face_lien,&l_face[0],&l_face[1]);
|
| 128 |
|
|
r3d_file(mess);
|
| 129 |
|
|
sscanf(mess,"%d %d %d %d %d %d",&nint[0],&nint[1],&nint[2],&nint[3],&nint[4],&nint[5]);
|
| 130 |
|
|
for (k=0;k<6;k++)
|
| 131 |
|
|
if (nint[k]==1)
|
| 132 |
|
|
{
|
| 133 |
|
|
r3d_file(mess);
|
| 134 |
|
|
sscanf(mess,"%f %f %f",&x[2*k],&y[2*k],&z[2*k]);
|
| 135 |
|
|
}
|
| 136 |
|
|
}
|
| 137 |
|
|
if (strcmp(type_entite,"ELLIPSE")==0)
|
| 138 |
|
|
{
|
| 139 |
|
|
type=ELLIPSE;
|
| 140 |
|
|
sscanf(mess,"%s %d %f %f %f %f %f %f %f %f %f %f %f",type_entite,&num,&carac[0],&carac[1],&carac[2],&carac[3],&carac[4],&carac[5],&carac[6],&carac[7],&carac[8],&carac[9],&carac[10]);
|
| 141 |
|
|
r3d_file(mess);
|
| 142 |
|
|
sscanf(mess,"%d %d %d",&nb_face_lien,&l_face[0],&l_face[1]);
|
| 143 |
|
|
r3d_file(mess);
|
| 144 |
|
|
sscanf(mess,"%d %d %d %d %d %d",&nint[0],&nint[1],&nint[2],&nint[3],&nint[4],&nint[5]);
|
| 145 |
|
|
for (k=0;k<6;k++)
|
| 146 |
|
|
{
|
| 147 |
|
|
if (nint[k]>0)
|
| 148 |
|
|
{
|
| 149 |
|
|
r3d_file(mess);
|
| 150 |
|
|
sscanf(mess,"%f %f %f",&x[2*k],&y[2*k],&z[2*k]);
|
| 151 |
|
|
}
|
| 152 |
|
|
if (nint[k]>1)
|
| 153 |
|
|
{
|
| 154 |
|
|
r3d_file(mess);
|
| 155 |
|
|
sscanf(mess,"%f %f %f",&x[2*k+1],&y[2*k+1],&z[2*k+1]);
|
| 156 |
|
|
}
|
| 157 |
|
|
|
| 158 |
|
|
}
|
| 159 |
|
|
}
|
| 160 |
|
|
if ((nint[0]!=0) || (nint[1]!=0) || (nint[2]!=0) || (nint[3]!=0) || (nint[4]!=0) || (nint[5]!=0) )
|
| 161 |
|
|
{
|
| 162 |
|
|
ok=0;
|
| 163 |
|
|
for (k=0;k<nb_entite;k++)
|
| 164 |
|
|
{
|
| 165 |
|
|
if (type==l_edge[k].type)
|
| 166 |
|
|
if ( ((l_edge[k].nb_carac>0) && (EGAL(carac[0],l_edge[k].carac[0],0.0001))) || (l_edge[k].nb_carac<1) )
|
| 167 |
|
|
if ( ((l_edge[k].nb_carac>1) && (EGAL(carac[1],l_edge[k].carac[1],0.0001))) || (l_edge[k].nb_carac<2) )
|
| 168 |
|
|
if ( ((l_edge[k].nb_carac>2) && (EGAL(carac[2],l_edge[k].carac[2],0.0001))) || (l_edge[k].nb_carac<3) )
|
| 169 |
|
|
if ( ((l_edge[k].nb_carac>3) && (EGAL(carac[3],l_edge[k].carac[3],0.0001))) || (l_edge[k].nb_carac<4) )
|
| 170 |
|
|
if ( ((l_edge[k].nb_carac>4) && (EGAL(carac[4],l_edge[k].carac[4],0.0001))) || (l_edge[k].nb_carac<5) )
|
| 171 |
|
|
if ( ((l_edge[k].nb_carac>5) && (EGAL(carac[5],l_edge[k].carac[5],0.0001))) || (l_edge[k].nb_carac<6) )
|
| 172 |
|
|
if ( ((l_edge[k].nb_carac>6) && (EGAL(carac[6],l_edge[k].carac[6],0.0001))) || (l_edge[k].nb_carac<7) )
|
| 173 |
|
|
if ( ((l_edge[k].nb_carac>7) && (EGAL(carac[7],l_edge[k].carac[7],0.0001))) || (l_edge[k].nb_carac<8) )
|
| 174 |
|
|
if ( ((l_edge[k].nb_carac>8) && (EGAL(carac[8],l_edge[k].carac[8],0.0001))) || (l_edge[k].nb_carac<9) )
|
| 175 |
|
|
if ( ((l_edge[k].nb_carac>9) && (EGAL(carac[9],l_edge[k].carac[9],0.0001))) || (l_edge[k].nb_carac<10) )
|
| 176 |
|
|
if ( ((l_edge[k].nb_carac>10) && (EGAL(carac[10],l_edge[k].carac[10],0.0001))) || (l_edge[k].nb_carac<11) )
|
| 177 |
|
|
if (nint[0]==l_edge[k].nint[0])
|
| 178 |
|
|
if (nint[1]==l_edge[k].nint[1])
|
| 179 |
|
|
if (nint[2]==l_edge[k].nint[2])
|
| 180 |
|
|
if (nint[3]==l_edge[k].nint[3])
|
| 181 |
|
|
if (nint[4]==l_edge[k].nint[4])
|
| 182 |
|
|
if (nint[5]==l_edge[k].nint[5])
|
| 183 |
|
|
if ((nint[0]==0)||((nint[0]==1)&&(EGAL2(x[0],l_edge[k].x[0]))&&(EGAL2(y[0],l_edge[k].y[0]))&&(EGAL2(z[0],l_edge[k].z[0])))||
|
| 184 |
|
|
((nint[0]==2)&&(EGAL2(x[0],l_edge[k].x[0]))&&(EGAL2(y[0],l_edge[k].y[0]))&&(EGAL2(z[0],l_edge[k].z[0]))&&
|
| 185 |
|
|
(EGAL2(x[1],l_edge[k].x[1]))&&(EGAL2(y[1],l_edge[k].y[1]))&&(EGAL2(z[1],l_edge[k].z[1])))||
|
| 186 |
|
|
((nint[0]==2)&&(EGAL2(x[0],l_edge[k].x[1]))&&(EGAL2(y[0],l_edge[k].y[1]))&&(EGAL2(z[0],l_edge[k].z[1]))&&
|
| 187 |
|
|
(EGAL2(x[1],l_edge[k].x[0]))&&(EGAL2(y[1],l_edge[k].y[0]))&&(EGAL2(z[1],l_edge[k].z[0]))))
|
| 188 |
|
|
if ((nint[1]==0)||((nint[1]==1)&&(EGAL2(x[2],l_edge[k].x[2]))&&(EGAL2(y[2],l_edge[k].y[2]))&&(EGAL2(z[2],l_edge[k].z[2])))||
|
| 189 |
|
|
((nint[1]==2)&&(EGAL2(x[2],l_edge[k].x[2]))&&(EGAL2(y[2],l_edge[k].y[2]))&&(EGAL2(z[2],l_edge[k].z[2]))&&
|
| 190 |
|
|
(EGAL2(x[3],l_edge[k].x[3]))&&(EGAL2(y[3],l_edge[k].y[3]))&&(EGAL2(z[3],l_edge[k].z[3])))||
|
| 191 |
|
|
((nint[1]==2)&&(EGAL2(x[2],l_edge[k].x[3]))&&(EGAL2(y[2],l_edge[k].y[3]))&&(EGAL2(z[2],l_edge[k].z[3]))&&
|
| 192 |
|
|
(EGAL2(x[3],l_edge[k].x[2]))&&(EGAL2(y[3],l_edge[k].y[2]))&&(EGAL2(z[3],l_edge[k].z[2]))))
|
| 193 |
|
|
if ((nint[2]==0)||((nint[2]==1)&&(EGAL2(x[4],l_edge[k].x[4]))&&(EGAL2(y[4],l_edge[k].y[4]))&&(EGAL2(z[4],l_edge[k].z[4])))||
|
| 194 |
|
|
((nint[2]==2)&&(EGAL2(x[4],l_edge[k].x[4]))&&(EGAL2(y[4],l_edge[k].y[4]))&&(EGAL2(z[4],l_edge[k].z[4]))&&
|
| 195 |
|
|
(EGAL2(x[5],l_edge[k].x[5]))&&(EGAL2(y[5],l_edge[k].y[5]))&&(EGAL2(z[5],l_edge[k].z[5])))||
|
| 196 |
|
|
((nint[2]==2)&&(EGAL2(x[4],l_edge[k].x[5]))&&(EGAL2(y[4],l_edge[k].y[5]))&&(EGAL2(z[4],l_edge[k].z[5]))&&
|
| 197 |
|
|
(EGAL2(x[5],l_edge[k].x[4]))&&(EGAL2(y[5],l_edge[k].y[4]))&&(EGAL2(z[5],l_edge[k].z[4]))))
|
| 198 |
|
|
if ((nint[3]==0)||((nint[3]==1)&&(EGAL2(x[6],l_edge[k].x[6]))&&(EGAL2(y[6],l_edge[k].y[6]))&&(EGAL2(z[6],l_edge[k].z[6])))||
|
| 199 |
|
|
((nint[3]==2)&&(EGAL2(x[6],l_edge[k].x[6]))&&(EGAL2(y[6],l_edge[k].y[6]))&&(EGAL2(z[6],l_edge[k].z[6]))&&
|
| 200 |
|
|
(EGAL2(x[7],l_edge[k].x[7]))&&(EGAL2(y[7],l_edge[k].y[7]))&&(EGAL2(z[7],l_edge[k].z[7])))||
|
| 201 |
|
|
((nint[3]==2)&&(EGAL2(x[6],l_edge[k].x[7]))&&(EGAL2(y[6],l_edge[k].y[7]))&&(EGAL2(z[6],l_edge[k].z[7]))&&
|
| 202 |
|
|
(EGAL2(x[7],l_edge[k].x[6]))&&(EGAL2(y[7],l_edge[k].y[6]))&&(EGAL2(z[7],l_edge[k].z[6]))))
|
| 203 |
|
|
if ((nint[4]==0)||((nint[4]==1)&&(EGAL2(x[8],l_edge[k].x[8]))&&(EGAL2(y[8],l_edge[k].y[8]))&&(EGAL2(z[8],l_edge[k].z[8])))||
|
| 204 |
|
|
((nint[4]==2)&&(EGAL2(x[8],l_edge[k].x[8]))&&(EGAL2(y[8],l_edge[k].y[8]))&&(EGAL2(z[8],l_edge[k].z[8]))&&
|
| 205 |
|
|
(EGAL2(x[9],l_edge[k].x[9]))&&(EGAL2(y[9],l_edge[k].y[9]))&&(EGAL2(z[9],l_edge[k].z[9])))||
|
| 206 |
|
|
((nint[4]==2)&&(EGAL2(x[8],l_edge[k].x[9]))&&(EGAL2(y[8],l_edge[k].y[9]))&&(EGAL2(z[8],l_edge[k].z[9]))&&
|
| 207 |
|
|
(EGAL2(x[9],l_edge[k].x[8]))&&(EGAL2(y[9],l_edge[k].y[8]))&&(EGAL2(z[9],l_edge[k].z[8]))))
|
| 208 |
|
|
if ((nint[5]==0)||((nint[5]==1)&&(EGAL2(x[10],l_edge[k].x[10]))&&(EGAL2(y[10],l_edge[k].y[10]))&&(EGAL2(z[10],l_edge[k].z[10])))||
|
| 209 |
|
|
((nint[5]==2)&&(EGAL2(x[10],l_edge[k].x[10]))&&(EGAL2(y[10],l_edge[k].y[10]))&&(EGAL2(z[10],l_edge[k].z[10]))&&
|
| 210 |
|
|
(EGAL2(x[11],l_edge[k].x[11]))&&(EGAL2(y[11],l_edge[k].y[11]))&&(EGAL2(z[11],l_edge[k].z[11])))||
|
| 211 |
|
|
((nint[5]==2)&&(EGAL2(x[10],l_edge[k].x[11]))&&(EGAL2(y[10],l_edge[k].y[11]))&&(EGAL2(z[10],l_edge[k].z[11]))&&
|
| 212 |
|
|
(EGAL2(x[11],l_edge[k].x[10]))&&(EGAL2(y[11],l_edge[k].y[10]))&&(EGAL2(z[11],l_edge[k].z[10]))))
|
| 213 |
|
|
|
| 214 |
|
|
|
| 215 |
|
|
{
|
| 216 |
|
|
ok=1;
|
| 217 |
|
|
l_edge[k].gtrouve=1;
|
| 218 |
|
|
}
|
| 219 |
|
|
}
|
| 220 |
|
|
if (ok==0)
|
| 221 |
|
|
{
|
| 222 |
|
|
r3d_zone(ORIGINAL,OLD,oct,dens,EDGE,num,nb_face_lien,l_face);
|
| 223 |
|
|
}
|
| 224 |
|
|
}
|
| 225 |
|
|
}
|
| 226 |
|
|
for (k=0;k<nb_entite;k++)
|
| 227 |
|
|
if (l_edge[k].gtrouve==0)
|
| 228 |
|
|
r3d_zone(RETARDE2,NEW,oct,dens,EDGE,l_edge[k].num,0,l_face);
|
| 229 |
|
|
return;
|
| 230 |
|
|
}
|
