| 1 |
francois |
447 |
#include "mailleur2d_optimisation.h" |
| 2 |
|
|
#include "m3d_triangle.h" |
| 3 |
|
|
#include "mg_gestionnaire.h" |
| 4 |
|
|
#include "ot_decalage_parametre.h" |
| 5 |
|
|
#include <math.h> |
| 6 |
|
|
|
| 7 |
|
|
|
| 8 |
francois |
494 |
MAILLEUR2D_OPTIMISATION::MAILLEUR2D_OPTIMISATION(MG_MAILLAGE* mgmai,int niv):MAILLEUR(false),mg_maillage(mgmai),niveau_optimisation(niv) |
| 9 |
francois |
447 |
{ |
| 10 |
|
|
} |
| 11 |
|
|
|
| 12 |
|
|
MAILLEUR2D_OPTIMISATION::~MAILLEUR2D_OPTIMISATION() |
| 13 |
|
|
{ |
| 14 |
|
|
} |
| 15 |
|
|
|
| 16 |
|
|
void MAILLEUR2D_OPTIMISATION::change_niveau_optimisation(int num) |
| 17 |
|
|
{ |
| 18 |
|
|
niveau_optimisation=num; |
| 19 |
|
|
} |
| 20 |
|
|
|
| 21 |
|
|
int MAILLEUR2D_OPTIMISATION::get_niveau_optimisation(void) |
| 22 |
|
|
{ |
| 23 |
|
|
return niveau_optimisation; |
| 24 |
|
|
} |
| 25 |
|
|
|
| 26 |
francois |
448 |
void MAILLEUR2D_OPTIMISATION::optimise(MG_VOLUME* mgvolume) |
| 27 |
|
|
{ |
| 28 |
|
|
LISTE_MG_TRIANGLE::iterator ittr; |
| 29 |
|
|
TPL_MAP_ENTITE<M3D_TRIANGLE*> lsttrim3d; |
| 30 |
|
|
for (MG_TRIANGLE* tri=mg_maillage->get_premier_triangle(ittr);tri!=NULL;tri=mg_maillage->get_suivant_triangle(ittr)) |
| 31 |
|
|
{ |
| 32 |
|
|
M3D_TRIANGLE* nvtri=new M3D_TRIANGLE(tri->get_id(),tri->get_lien_topologie(),tri->get_noeud1(),tri->get_noeud2(),tri->get_noeud3(),tri->get_segment1(),tri->get_segment2(),tri->get_segment3(),tri->get_origine()); |
| 33 |
|
|
lsttrim3d.ajouter(nvtri); |
| 34 |
|
|
} |
| 35 |
francois |
447 |
|
| 36 |
francois |
448 |
TPL_MAP_ENTITE<M3D_TRIANGLE*>::ITERATEUR it2; |
| 37 |
francois |
454 |
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud; |
| 38 |
francois |
448 |
|
| 39 |
francois |
454 |
|
| 40 |
francois |
448 |
for (M3D_TRIANGLE* tri=lsttrim3d.get_premier(it2);tri!=NULL;tri=lsttrim3d.get_suivant(it2)) |
| 41 |
|
|
{ |
| 42 |
|
|
mg_maillage->supprimer_mg_triangleid(tri->get_id()); |
| 43 |
francois |
454 |
mg_maillage->ajouter_mg_triangle(tri); |
| 44 |
|
|
liste_noeud.ajouter(tri->get_noeud1()); |
| 45 |
|
|
liste_noeud.ajouter(tri->get_noeud2()); |
| 46 |
|
|
liste_noeud.ajouter(tri->get_noeud3()); |
| 47 |
francois |
448 |
} |
| 48 |
|
|
|
| 49 |
|
|
int nbcoquille=mgvolume->get_nb_mg_coquille(); |
| 50 |
|
|
for (int i=0;i<nbcoquille;i++) |
| 51 |
|
|
{ |
| 52 |
|
|
MG_COQUILLE* coq=mgvolume->get_mg_coquille(i); |
| 53 |
|
|
int nbface=coq->get_nb_mg_coface(); |
| 54 |
|
|
for (int j=0;j<nbface;j++) |
| 55 |
|
|
{ |
| 56 |
|
|
MG_FACE* face=coq->get_mg_coface(j)->get_face(); |
| 57 |
francois |
454 |
optimise_avec_calcul_uv(face); |
| 58 |
francois |
448 |
} |
| 59 |
|
|
} |
| 60 |
|
|
|
| 61 |
|
|
} |
| 62 |
|
|
|
| 63 |
francois |
573 |
|
| 64 |
|
|
void MAILLEUR2D_OPTIMISATION::optimise(MG_COQUE* mgcoque) |
| 65 |
|
|
{ |
| 66 |
|
|
LISTE_MG_TRIANGLE::iterator ittr; |
| 67 |
|
|
TPL_MAP_ENTITE<M3D_TRIANGLE*> lsttrim3d; |
| 68 |
|
|
for (MG_TRIANGLE* tri=mg_maillage->get_premier_triangle(ittr);tri!=NULL;tri=mg_maillage->get_suivant_triangle(ittr)) |
| 69 |
|
|
{ |
| 70 |
|
|
M3D_TRIANGLE* nvtri=new M3D_TRIANGLE(tri->get_id(),tri->get_lien_topologie(),tri->get_noeud1(),tri->get_noeud2(),tri->get_noeud3(),tri->get_segment1(),tri->get_segment2(),tri->get_segment3(),tri->get_origine()); |
| 71 |
|
|
lsttrim3d.ajouter(nvtri); |
| 72 |
|
|
} |
| 73 |
|
|
|
| 74 |
|
|
TPL_MAP_ENTITE<M3D_TRIANGLE*>::ITERATEUR it2; |
| 75 |
|
|
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud; |
| 76 |
|
|
|
| 77 |
|
|
|
| 78 |
|
|
for (M3D_TRIANGLE* tri=lsttrim3d.get_premier(it2);tri!=NULL;tri=lsttrim3d.get_suivant(it2)) |
| 79 |
|
|
{ |
| 80 |
|
|
mg_maillage->supprimer_mg_triangleid(tri->get_id()); |
| 81 |
|
|
mg_maillage->ajouter_mg_triangle(tri); |
| 82 |
|
|
liste_noeud.ajouter(tri->get_noeud1()); |
| 83 |
|
|
liste_noeud.ajouter(tri->get_noeud2()); |
| 84 |
|
|
liste_noeud.ajouter(tri->get_noeud3()); |
| 85 |
|
|
} |
| 86 |
|
|
|
| 87 |
|
|
int nbcoquille=mgcoque->get_nb_mg_coquille(); |
| 88 |
|
|
for (int i=0;i<nbcoquille;i++) |
| 89 |
|
|
{ |
| 90 |
|
|
MG_COQUILLE* coq=mgcoque->get_mg_coquille(i); |
| 91 |
|
|
int nbface=coq->get_nb_mg_coface(); |
| 92 |
|
|
for (int j=0;j<nbface;j++) |
| 93 |
|
|
{ |
| 94 |
|
|
MG_FACE* face=coq->get_mg_coface(j)->get_face(); |
| 95 |
|
|
optimise_avec_calcul_uv(face); |
| 96 |
|
|
} |
| 97 |
|
|
} |
| 98 |
|
|
|
| 99 |
|
|
} |
| 100 |
francois |
454 |
void MAILLEUR2D_OPTIMISATION::optimise_avec_calcul_uv(MG_FACE* mgface) |
| 101 |
|
|
{ |
| 102 |
|
|
TPL_MAP_ENTITE<MG_NOEUD*> liste_noeud; |
| 103 |
|
|
TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it; |
| 104 |
|
|
for (MG_TRIANGLE *mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_premier(it);mgtri!=NULL;mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_suivant(it)) |
| 105 |
|
|
{ |
| 106 |
|
|
if (mg_maillage->get_mg_triangleid(mgtri->get_id())!=mgtri) continue; |
| 107 |
|
|
liste_noeud.ajouter(mgtri->get_noeud1()); |
| 108 |
|
|
liste_noeud.ajouter(mgtri->get_noeud2()); |
| 109 |
|
|
liste_noeud.ajouter(mgtri->get_noeud3()); |
| 110 |
|
|
} |
| 111 |
|
|
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR it2; |
| 112 |
|
|
for (MG_NOEUD* no=liste_noeud.get_premier(it2);no!=NULL;no=liste_noeud.get_suivant(it2)) |
| 113 |
|
|
{ |
| 114 |
|
|
double uv[2]; |
| 115 |
|
|
double *xyz=no->get_coord(); |
| 116 |
|
|
mgface->inverser(uv,xyz); |
| 117 |
|
|
no->change_u(uv[0]); |
| 118 |
|
|
no->change_v(uv[1]); |
| 119 |
|
|
} |
| 120 |
sattarpa |
644 |
reinit(); |
| 121 |
|
|
optimise(mgface); |
| 122 |
francois |
454 |
} |
| 123 |
|
|
|
| 124 |
|
|
|
| 125 |
|
|
|
| 126 |
sattarpa |
644 |
void MAILLEUR2D_OPTIMISATION::reinit(void) |
| 127 |
|
|
{ |
| 128 |
|
|
lst_tri_qual.clear(); |
| 129 |
|
|
lst_tri_qual2.clear(); |
| 130 |
|
|
} |
| 131 |
francois |
454 |
|
| 132 |
|
|
|
| 133 |
|
|
|
| 134 |
|
|
|
| 135 |
francois |
447 |
void MAILLEUR2D_OPTIMISATION::optimise(MG_FACE* mgface) |
| 136 |
|
|
{ |
| 137 |
|
|
TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it; |
| 138 |
|
|
for (MG_TRIANGLE *mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_premier(it);mgtri!=NULL;mgtri=(MG_TRIANGLE*)mgface->get_lien_maillage()->get_suivant(it)) |
| 139 |
|
|
{ |
| 140 |
francois |
448 |
if (mg_maillage->get_mg_triangleid(mgtri->get_id())!=mgtri) continue; |
| 141 |
francois |
447 |
M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)mgtri; |
| 142 |
|
|
double qual=OPERATEUR::qualite_triangle(mtri->get_noeud1()->get_coord(),mtri->get_noeud2()->get_coord(),mtri->get_noeud3()->get_coord()); |
| 143 |
|
|
mtri->change_qualite(qual); |
| 144 |
|
|
if (mtri->get_qualite()<0.1*niveau_optimisation) |
| 145 |
|
|
{ |
| 146 |
|
|
std::pair<const double,M3D_TRIANGLE*> tmp(mtri->get_qualite(),mtri); |
| 147 |
|
|
lst_tri_qual.insert(tmp); |
| 148 |
|
|
} |
| 149 |
|
|
} |
| 150 |
|
|
periode_u=mgface->get_surface()->get_periode_u(); |
| 151 |
|
|
periode_v=mgface->get_surface()->get_periode_v(); |
| 152 |
|
|
decalage=new OT_DECALAGE_PARAMETRE(periode_u,periode_v); |
| 153 |
|
|
for (int phase=0;phase<2;phase++) |
| 154 |
|
|
{ |
| 155 |
|
|
ORDRE_TRIANGLE& lst=lst_tri_qual; |
| 156 |
|
|
if (phase==1) |
| 157 |
|
|
lst=lst_tri_qual2; |
| 158 |
|
|
int ok=0; |
| 159 |
|
|
do |
| 160 |
|
|
{ |
| 161 |
|
|
ORDRE_TRIANGLE::iterator i=lst.begin(); |
| 162 |
|
|
if (i==lst.end()) |
| 163 |
|
|
{ |
| 164 |
|
|
ok=1; |
| 165 |
|
|
continue; |
| 166 |
|
|
} |
| 167 |
|
|
M3D_TRIANGLE* tri=(*i).second; |
| 168 |
francois |
448 |
if (tri->get_qualite()<0.1*niveau_optimisation) |
| 169 |
francois |
447 |
{ |
| 170 |
|
|
MG_NOEUD* no[3]; |
| 171 |
|
|
no[0]=tri->get_noeud1(); |
| 172 |
|
|
no[1]=tri->get_noeud2(); |
| 173 |
|
|
no[2]=tri->get_noeud3(); |
| 174 |
|
|
double crit[3],u[3],v[3],x[3],y[3],z[3]; |
| 175 |
|
|
int ierr=bouge_point(mgface,no[0],crit[0],u[0],v[0],x[0],y[0],z[0]); |
| 176 |
|
|
if (ierr==0) crit[0]=0.; |
| 177 |
|
|
ierr=bouge_point(mgface,no[1],crit[1],u[1],v[1],x[1],y[1],z[1]); |
| 178 |
|
|
if (ierr==0) crit[1]=0.; |
| 179 |
|
|
ierr=bouge_point(mgface,no[2],crit[2],u[2],v[2],x[2],y[2],z[2]); |
| 180 |
|
|
if (ierr==0) crit[2]=0.; |
| 181 |
|
|
double critopt=std::max(crit[0],crit[1]); |
| 182 |
|
|
critopt=std::max(critopt,crit[2]); |
| 183 |
|
|
int num=-1; |
| 184 |
|
|
if (critopt>tri->get_qualite()) |
| 185 |
|
|
{ |
| 186 |
|
|
if (critopt==crit[0]) num=0; |
| 187 |
|
|
if (critopt==crit[1]) num=1; |
| 188 |
|
|
if (critopt==crit[2]) num=2; |
| 189 |
|
|
} |
| 190 |
|
|
if (num!=-1) |
| 191 |
|
|
{ |
| 192 |
|
|
no[num]->change_u(u[num]); |
| 193 |
|
|
no[num]->change_v(v[num]); |
| 194 |
|
|
no[num]->change_x(x[num]); |
| 195 |
|
|
no[num]->change_y(y[num]); |
| 196 |
|
|
no[num]->change_z(z[num]); |
| 197 |
|
|
int nb_tri=no[num]->get_lien_triangle()->get_nb(); |
| 198 |
|
|
for (int i=0;i<nb_tri;i++) |
| 199 |
|
|
{ |
| 200 |
|
|
M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)no[num]->get_lien_triangle()->get(i); |
| 201 |
|
|
double qual=OPERATEUR::qualite_triangle(mtri->get_noeud1()->get_coord(),mtri->get_noeud2()->get_coord(),mtri->get_noeud3()->get_coord()); |
| 202 |
|
|
mtri->change_qualite(qual); |
| 203 |
|
|
} |
| 204 |
|
|
} |
| 205 |
|
|
} |
| 206 |
|
|
else ok=1; |
| 207 |
|
|
if ((tri->get_qualite()<0.1*niveau_optimisation) && (phase==0)) |
| 208 |
|
|
{ |
| 209 |
|
|
std::pair<const double,M3D_TRIANGLE*> tmp(1./tri->get_qualite(),tri); |
| 210 |
|
|
lst_tri_qual2.insert(tmp); |
| 211 |
|
|
} |
| 212 |
|
|
lst.erase(i); |
| 213 |
|
|
} |
| 214 |
|
|
while (ok==0); |
| 215 |
|
|
} |
| 216 |
|
|
delete decalage; |
| 217 |
|
|
} |
| 218 |
|
|
|
| 219 |
|
|
|
| 220 |
|
|
|
| 221 |
|
|
int MAILLEUR2D_OPTIMISATION::bouge_point(MG_FACE* mgface,MG_NOEUD* mg_noeud,double& crit,double &u,double& v,double& x,double& y, double& z) |
| 222 |
|
|
{ |
| 223 |
|
|
if (mg_noeud->get_lien_topologie()!=mgface) return 0; |
| 224 |
|
|
if (mg_noeud->get_origine()==IMPOSE) return 0; |
| 225 |
|
|
double du=decalage->calcul_decalage_parametre_u(mg_noeud->get_u()); |
| 226 |
|
|
double dv=decalage->calcul_decalage_parametre_v(mg_noeud->get_v()); |
| 227 |
|
|
double u1=decalage->decalage_parametre_u(mg_noeud->get_u(),du); |
| 228 |
|
|
double v1=decalage->decalage_parametre_v(mg_noeud->get_v(),dv); |
| 229 |
|
|
double uopt=0.; |
| 230 |
|
|
double vopt=0.; |
| 231 |
|
|
double qual_dep=1.; |
| 232 |
|
|
int nb_tri=mg_noeud->get_lien_triangle()->get_nb(); |
| 233 |
|
|
for (int i=0;i<nb_tri;i++) |
| 234 |
|
|
{ |
| 235 |
|
|
M3D_TRIANGLE* tri=(M3D_TRIANGLE*)mg_noeud->get_lien_triangle()->get(i); |
| 236 |
|
|
qual_dep=std::min(qual_dep,tri->get_qualite()); |
| 237 |
|
|
MG_NOEUD* no1=tri->get_noeud1(); |
| 238 |
|
|
MG_NOEUD* no2=tri->get_noeud2(); |
| 239 |
|
|
MG_NOEUD* no3=tri->get_noeud3(); |
| 240 |
|
|
MG_NOEUD *noeud1,*noeud2; |
| 241 |
|
|
if (no1==mg_noeud) |
| 242 |
|
|
{ |
| 243 |
|
|
noeud1=no2; |
| 244 |
|
|
noeud2=no3; |
| 245 |
|
|
} |
| 246 |
|
|
if (no2==mg_noeud) |
| 247 |
|
|
{ |
| 248 |
|
|
noeud1=no1; |
| 249 |
|
|
noeud2=no3; |
| 250 |
|
|
} |
| 251 |
|
|
if (no3==mg_noeud) |
| 252 |
|
|
{ |
| 253 |
|
|
noeud1=no1; |
| 254 |
|
|
noeud2=no2; |
| 255 |
|
|
} |
| 256 |
|
|
double u2=noeud1->get_u()+du; |
| 257 |
|
|
double v2=noeud1->get_v()+dv; |
| 258 |
|
|
uopt=uopt+u2; |
| 259 |
|
|
vopt=vopt+v2; |
| 260 |
|
|
u2=noeud2->get_u()+du; |
| 261 |
|
|
v2=noeud2->get_v()+dv; |
| 262 |
|
|
uopt=uopt+u2; |
| 263 |
|
|
vopt=vopt+v2; |
| 264 |
|
|
} |
| 265 |
|
|
uopt=uopt/2./nb_tri; |
| 266 |
|
|
vopt=vopt/2./nb_tri; |
| 267 |
|
|
|
| 268 |
|
|
double ddeb=sqrt((u1-uopt)*(u1-uopt)+(v1-vopt)*(v1-vopt)); |
| 269 |
|
|
double alpha=0.5; |
| 270 |
|
|
double d=alpha*ddeb; |
| 271 |
|
|
double qual=qual_dep; |
| 272 |
|
|
double testu[8]={1.,-1.,0.,0.,0.707106781,-0.707106781,-0.707106781,0.707106781}; |
| 273 |
|
|
double testv[8]={0.,0.,1.,-1.,0.707106781,0.707106781,-0.707106781,-0.707106781}; |
| 274 |
|
|
double uu=u1; |
| 275 |
|
|
double vv=v1; |
| 276 |
|
|
while (alpha>0.09) |
| 277 |
|
|
{ |
| 278 |
|
|
double qualcoq=0.; |
| 279 |
|
|
for (int nb_essai=0;nb_essai<8;nb_essai++) |
| 280 |
|
|
{ |
| 281 |
|
|
double uv[2]; |
| 282 |
|
|
double xyz[3]; |
| 283 |
|
|
uv[0]=uu+d*testu[nb_essai]-du; |
| 284 |
|
|
uv[1]=vv+d*testv[nb_essai]-dv; |
| 285 |
|
|
int valide1=mgface->valide_parametre_u(uv[0]); |
| 286 |
|
|
int valide2=mgface->valide_parametre_v(uv[1]); |
| 287 |
|
|
if (!((valide1) && (valide2) )) break; |
| 288 |
|
|
mgface->evaluer(uv,xyz); |
| 289 |
|
|
double qual1=1.; |
| 290 |
|
|
for (int i=0;i<nb_tri;i++) |
| 291 |
|
|
{ |
| 292 |
|
|
M3D_TRIANGLE* tri=(M3D_TRIANGLE*)mg_noeud->get_lien_triangle()->get(i); |
| 293 |
|
|
MG_NOEUD* no1=tri->get_noeud1(); |
| 294 |
|
|
MG_NOEUD* no2=tri->get_noeud2(); |
| 295 |
|
|
MG_NOEUD* no3=tri->get_noeud3(); |
| 296 |
|
|
double *xyz1=no1->get_coord(); |
| 297 |
|
|
double *xyz2=no2->get_coord(); |
| 298 |
|
|
double *xyz3=no3->get_coord(); |
| 299 |
|
|
if (no1==mg_noeud) xyz1=xyz; |
| 300 |
|
|
if (no2==mg_noeud) xyz2=xyz; |
| 301 |
|
|
if (no3==mg_noeud) xyz3=xyz; |
| 302 |
|
|
double qualtmp=OPERATEUR::qualite_triangle(xyz1,xyz2,xyz3); |
| 303 |
|
|
OT_VECTEUR_3D n1n3(xyz1,xyz3); |
| 304 |
|
|
OT_VECTEUR_3D n1n2(xyz1,xyz2); |
| 305 |
|
|
double xyznormal[3]; |
| 306 |
|
|
mgface->calcul_normale_unitaire(uv,xyznormal); |
| 307 |
|
|
OT_VECTEUR_3D normalface(xyznormal); |
| 308 |
|
|
OT_VECTEUR_3D normal=normalface&n1n3; |
| 309 |
|
|
normal.norme(); |
| 310 |
|
|
n1n2.norme(); |
| 311 |
|
|
if (normal*n1n2<0.0001) qualtmp=0.; |
| 312 |
|
|
if (qualtmp<qual1) qual1=qualtmp; |
| 313 |
|
|
} |
| 314 |
|
|
if (qual1>qualcoq) |
| 315 |
|
|
{ |
| 316 |
|
|
qualcoq=qual1; |
| 317 |
|
|
crit=qualcoq; |
| 318 |
|
|
u=uv[0]+du; |
| 319 |
|
|
v=uv[1]+dv; |
| 320 |
|
|
} |
| 321 |
|
|
} |
| 322 |
|
|
|
| 323 |
|
|
if (qualcoq<qual+0.0001) alpha=alpha-0.1; |
| 324 |
|
|
else |
| 325 |
|
|
{ |
| 326 |
|
|
qual=qualcoq; |
| 327 |
|
|
uu=u; |
| 328 |
|
|
vv=v; |
| 329 |
|
|
} |
| 330 |
|
|
d=ddeb*alpha; |
| 331 |
|
|
|
| 332 |
|
|
} |
| 333 |
|
|
if (qual>qual_dep) |
| 334 |
|
|
{ |
| 335 |
|
|
u=decalage->decalage_parametre_u(u,-du); |
| 336 |
|
|
v=decalage->decalage_parametre_v(v,-dv); |
| 337 |
|
|
double uv[2]; |
| 338 |
|
|
uv[0]=u; |
| 339 |
|
|
uv[1]=v; |
| 340 |
|
|
double xyz[3]; |
| 341 |
|
|
mgface->evaluer(uv,xyz); |
| 342 |
|
|
x=xyz[0]; |
| 343 |
|
|
y=xyz[1]; |
| 344 |
|
|
z=xyz[2]; |
| 345 |
|
|
return 1; |
| 346 |
|
|
} |
| 347 |
|
|
return 0; |
| 348 |
|
|
} |
