Mmg
Simplicial remeshers (mesh adaptation, isovalue discretization, lagrangian movement)
colver_s.c
Go to the documentation of this file.
1/* =============================================================================
2** This file is part of the mmg software package for the tetrahedral
3** mesh modification.
4** Copyright (c) Bx INP/CNRS/Inria/UBordeaux/UPMC, 2004-
5**
6** mmg is free software: you can redistribute it and/or modify it
7** under the terms of the GNU Lesser General Public License as published
8** by the Free Software Foundation, either version 3 of the License, or
9** (at your option) any later version.
10**
11** mmg is distributed in the hope that it will be useful, but WITHOUT
12** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13** FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14** License for more details.
15**
16** You should have received a copy of the GNU Lesser General Public
17** License and of the GNU General Public License along with mmg (in
18** files COPYING.LESSER and COPYING). If not, see
19** <http://www.gnu.org/licenses/>. Please read their terms carefully and
20** use this copy of the mmg distribution only if you accept them.
21** =============================================================================
22*/
23
36#include "libmmgs_private.h"
37#include "mmgexterns_private.h"
38#include "inlined_functions_private.h"
39
59int chkcol(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,int8_t i,MMG5_int *list,int8_t typchk,
60 double (*MMGS_lenEdg)(MMG5_pMesh,MMG5_pSol,MMG5_int ,MMG5_int,int8_t),
61 double (*MMGS_caltri)(MMG5_pMesh,MMG5_pSol,MMG5_pTria)) {
62 MMG5_pTria pt,pt0,pt1,pt2;
63 MMG5_pPoint p1,p2;
64 double len,lon,ps,cosnold,cosnnew,kal,n0old[3],n1old[3],n00old[3];
65 double n0new[3],n1new[3],n00new[3];
66 MMG5_int *adja,jel,kel,ip1,ip2,l,ll;
67 int ilist;
68 int8_t i1,i2,j,jj,j2,lj,open,voy;
69
70 pt0 = &mesh->tria[0];
71 pt = &mesh->tria[k];
72 i1 = MMG5_inxt2[i];
73 i2 = MMG5_iprv2[i];
74 ip1 = pt->v[i1];
75 ip2 = pt->v[i2];
76
77#ifndef NDEBUG
78 /* suppression of maybe-uninitialized value on arm */
79 lon = 0.;
80 n00old[0] = n00old[1] = n00old[2] = 0.;
81 n0old[0] = n0old[1] = n0old[2] = 0.;
82 n1old[0] = n1old[1] = n1old[2] = 0.;
83 n00new[0] = n00new[1] = n00new[2] = 0.;
84 n0new[0] = n0new[1] = n0new[2] = 0.;
85 n1new[0] = n1new[1] = n1new[2] = 0.;
86#endif
87
88 if ( MMGS_lenEdg ) {
89 lon = MMGS_lenEdg(mesh,met,ip1,ip2,0);
90 if ( !lon ) return 0;
91 lon = MG_MIN(lon,MMGS_LSHRT);
92 lon = MG_MAX(1.0/lon,MMGS_LLONG);
93 }
94
95 /* collect all triangles around vertex i1 */
96 ilist = boulechknm(mesh,k,i1,list);
97 if ( ilist <= 0 ) return 0;
98
99 /* check for open ball */
100 adja = &mesh->adja[3*(k-1)+1];
101 open = adja[i] == 0;
102
103 if ( ilist+open > 3 ) {
104 /* check references */
105 if ( MG_EDG(pt->tag[i2]) ) {
106 jel = list[1] / 3;
107 pt1 = &mesh->tria[jel];
108 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
109 }
110
111 /* analyze ball */
112 assert ( ilist-1+open > 1 );
113 for (l=1; l<ilist-1+open; l++) {
114 jel = list[l] / 3;
115 j = list[l] % 3;
116 jj = MMG5_inxt2[j];
117 j2 = MMG5_iprv2[j];
118 pt1 = &mesh->tria[jel];
119
120 /* check length */
121 if ( MMGS_lenEdg ) {
122 ip1 = pt1->v[j2];
123 len = MMGS_lenEdg(mesh,met,ip1,ip2,0);
124 if ( len > lon || !len ) return 0;
125 }
126
127 /* check normal flipping */
128 if ( !MMG5_nortri(mesh,pt1,n1old) ) return 0;
129 memcpy(pt0,pt1,sizeof(MMG5_Tria));
130 pt0->v[j] = ip2;
131 if ( !MMG5_nortri(mesh,pt0,n1new) ) return 0;
132
133 ps = n1new[0]*n1old[0] + n1new[1]*n1old[1] + n1new[2]*n1old[2];
134 if ( ps < 0.0 ) return 0;
135
136 /* keep normals at 1st triangles */
137 if ( l == 1 && !open ) {
138 memcpy(n00old,n1old,3*sizeof(double));
139 memcpy(n00new,n1new,3*sizeof(double));
140 }
141
142 /* check normals deviation */
143 if ( !(pt1->tag[j2] & MG_GEO) ) {
144 if ( l > 1 ) {
145 cosnold = n0old[0]*n1old[0] + n0old[1]*n1old[1] + n0old[2]*n1old[2];
146 cosnnew = n0new[0]*n1new[0] + n0new[1]*n1new[1] + n0new[2]*n1new[2];
147 if ( cosnold < MMG5_ANGEDG ) {
148 if ( cosnnew < cosnold ) return 0;
149 }
150 else if ( cosnnew < MMG5_ANGEDG ) return 0;
151 }
152 }
153
154 /* check geometric support */
155 if ( l == 1 ) {
156 pt0->tag[j2] |= pt->tag[i1];
157 }
158 else if ( l == ilist-2+open ) {
159 if ( !open ) {
160 ll = list[ilist-1] / 3;
161 lj = list[ilist-1] % 3;
162 pt0->tag[jj] |= mesh->tria[ll].tag[lj];
163 }
164 else {
165 assert ( list[0]/3 == k );
166 pt0->tag[jj] |= pt->tag[i];
167 }
168 }
169 if ( chkedg(mesh,0) ) return 0;
170
171 /* check quality */
172 kal = MMGS_ALPHAD*MMGS_caltri(mesh,met,pt0);
173
174 if ( kal < MMGS_NULKAL ) return 0;
175
176 memcpy(n0old,n1old,3*sizeof(double));
177 memcpy(n0new,n1new,3*sizeof(double));
178 }
179
180 /* check angle between 1st and last triangles */
181 if ( !open && !(pt->tag[i] & MG_GEO) ) {
182 cosnold = n00old[0]*n1old[0] + n00old[1]*n1old[1] + n00old[2]*n1old[2];
183 cosnnew = n00new[0]*n1new[0] + n00new[1]*n1new[1] + n00new[2]*n1new[2];
184 if ( cosnold < MMG5_ANGEDG ) {
185 if ( cosnnew < cosnold ) return 0;
186 }
187 else if ( cosnnew < MMG5_ANGEDG ) return 0;
188
189 /* other checks for reference collapse */
190 jel = list[ilist-1] / 3;
191 j = list[ilist-1] % 3;
192 j = MMG5_iprv2[j];
193 pt = &mesh->tria[jel];
194 if ( MG_EDG(pt->tag[j]) ) {
195 jel = list[ilist-2] / 3;
196 pt1 = &mesh->tria[jel];
197 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
198 }
199 }
200 }
201
202 /* specific test: no collapse if any interior edge is EDG */
203 else if ( ilist == 3 ) {
204 /* Remark: if ilist==3 and i is an open ridge, we pass in the previous
205 * test (open+ilist > 3) so here, ip1 is in the middle of the 3
206 * triangles */
207
208 p1 = &mesh->point[pt->v[i1]];
209 if ( MS_SIN(p1->tag) ) return 0;
210 else if ( MG_EDG(pt->tag[i2]) && !MG_EDG(pt->tag[i]) ) return 0;
211 else if ( !MG_EDG(pt->tag[i2]) && MG_EDG(pt->tag[i]) ) return 0;
212 else if ( MG_EDG(pt->tag[i2]) && MG_EDG(pt->tag[i]) && MG_EDG(pt->tag[i1]) ) return 0;
213
214 /* Check geometric approximation */
215 jel = list[1] / 3;
216 j = list[1] % 3;
217 jj = MMG5_inxt2[j];
218 j2 = MMG5_iprv2[j];
219 pt0 = &mesh->tria[0];
220 pt1 = &mesh->tria[jel];
221 memcpy(pt0,pt1,sizeof(MMG5_Tria));
222 pt0->v[j] = ip2;
223
224 jel = list[2] / 3;
225 j = list[2] % 3;
226 pt1 = &mesh->tria[jel];
227 pt0->tag[jj] |= pt1->tag[j];
228 pt0->tag[j2] |= pt1->tag[MMG5_inxt2[j]];
229 if ( chkedg(mesh,0) ) return 0;
230
231 /* check quality */
232 kal = MMGS_ALPHAD*MMGS_caltri(mesh,met,pt0);
233
234 if ( kal < MMGS_NULKAL ) return 0;
235 }
236
237 /* for specific configurations along open ridge */
238 else if ( ilist == 2 ) {
239 if ( !open ) return 0;
240
241 jel = list[1] / 3;
242 j = list[1] % 3;
243
244 /* Topological test */
245 adja = &mesh->adja[3*(jel-1)+1];
246 kel = adja[j] / 3;
247 voy = adja[j] % 3;
248 pt2 = &mesh->tria[kel];
249
250 if ( pt2->v[voy] == ip2) return 0;
251
252 jj = MMG5_inxt2[j];
253 pt1 = &mesh->tria[jel];
254 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
255 else if ( !(pt1->tag[jj] & MG_GEO) ) return 0;
256
257 p1 = &mesh->point[pt->v[i1]];
258 p2 = &mesh->point[pt1->v[j]];
259 if ( p2->tag > p1->tag || p2->ref != p1->ref ) return 0;
260
261 /* Check geometric approximation */
262 j2 = MMG5_iprv2[j];
263 pt0 = &mesh->tria[0];
264 memcpy(pt0,pt,sizeof(MMG5_Tria));
265 pt0->v[i1] = pt1->v[j2];
266
267 if ( chkedg(mesh,0) ) return 0;
268
269 /* check quality */
270 kal = MMGS_ALPHAD*MMGS_caltri(mesh,met,pt0);
271
272 if ( kal < MMGS_NULKAL ) return 0;
273
274 }
275
276 return ilist;
277}
278
279/* collapse edge i of k, i1->i2 */
280int colver(MMG5_pMesh mesh,MMG5_int *list,int ilist) {
281 MMG5_pTria pt,pt1,pt2;
282 MMG5_int *adja,k,iel,jel,kel,ip1,ip2;
283 int8_t i,i1,i2,j,jj,open;
284
285 iel = list[0] / 3;
286 i1 = list[0] % 3;
287 i = MMG5_iprv2[i1];
288 i2 = MMG5_inxt2[i1];
289 pt = &mesh->tria[iel];
290 ip1 = pt->v[i1];
291 ip2 = pt->v[i2];
292
293 /* check for open ball */
294 adja = &mesh->adja[3*(iel-1)+1];
295 open = adja[i] == 0;
296
297 /* update vertex ip1 -> ip2 */
298 for (k=1; k<ilist-1+open; k++) {
299 jel = list[k] / 3;
300 jj = list[k] % 3;
301 pt1 = &mesh->tria[jel];
302 pt1->v[jj] = ip2;
303 pt1->base = mesh->base;
304 }
305
306 /* update adjacent with 1st elt */
307 jel = list[1] / 3;
308 jj = list[1] % 3;
309 j = MMG5_iprv2[jj];
310 pt1 = &mesh->tria[jel];
311 pt1->tag[j] |= pt->tag[i1];
312 pt1->edg[j] = MG_MAX(pt->edg[i1],pt1->edg[j]);
313 if ( adja[i1] ) {
314 kel = adja[i1] / 3;
315 k = adja[i1] % 3;
316 mesh->adja[3*(kel-1)+1+k] = 3*jel + j;
317 mesh->adja[3*(jel-1)+1+j] = 3*kel + k;
318 pt2 = &mesh->tria[kel];
319 pt2->tag[k] |= pt1->tag[j];
320 pt2->edg[k] = MG_MAX(pt1->edg[j],pt2->edg[k]);
321 }
322 else
323 mesh->adja[3*(jel-1)+1+j] = 0;
324
325 /* adjacent with last elt */
326 if ( !open ) {
327 iel = list[ilist-1] / 3;
328 i1 = list[ilist-1] % 3;
329 pt = &mesh->tria[iel];
330
331 jel = list[ilist-2] / 3;
332 jj = list[ilist-2] % 3;
333 j = MMG5_inxt2[jj];
334 pt1 = &mesh->tria[jel];
335 pt1->tag[j] |= pt->tag[i1];
336 pt1->edg[j] = MG_MAX(pt->edg[i1],pt1->edg[j]);
337 adja = &mesh->adja[3*(iel-1)+1];
338 if ( adja[i1] ) {
339 kel = adja[i1] / 3;
340 k = adja[i1] % 3;
341 mesh->adja[3*(kel-1)+1+k] = 3*jel + j;
342 mesh->adja[3*(jel-1)+1+j] = 3*kel + k;
343 pt2 = &mesh->tria[kel];
344 pt2->tag[k] |= pt1->tag[j];
345 pt2->edg[k] = MG_MAX(pt1->edg[j],pt2->edg[k]);
346 }
347 else
348 mesh->adja[3*(jel-1)+1+j] = 0;
349 }
350
351 MMGS_delPt(mesh,ip1);
352 if ( !MMGS_delElt(mesh,list[0] / 3) ) return 0;
353 if ( !open ) {
354 if ( !MMGS_delElt(mesh,list[ilist-1] / 3) ) return 0;
355 }
356
357 return 1;
358}
359
360
370int colver3(MMG5_pMesh mesh,MMG5_int* list) {
371 MMG5_pTria pt,pt1,pt2;
372 MMG5_int *adja,iel,jel,kel,mel,ip;
373 int8_t i,i1,j,j1,j2,k,m;
374
375 /* update of new point for triangle list[0] */
376 iel = list[0] / 3;
377 i = list[0] % 3;
378 i1 = MMG5_inxt2[i];
379 pt = &mesh->tria[iel];
380 ip = pt->v[i];
381
382 jel = list[1] / 3;
383 j = list[1] % 3;
384 j1 = MMG5_inxt2[j];
385 j2 = MMG5_iprv2[j];
386 pt1 = &mesh->tria[jel];
387
388 kel = list[2] / 3;
389 k = list[2] % 3;
390 pt2 = &mesh->tria[kel];
391
392 /* update info */
393 pt1->v[j] = pt->v[i1];
394 pt1->tag[j1] |= pt2->tag[k];
395 pt1->edg[j1] = MG_MAX(pt1->edg[j1],pt2->edg[k]);
396 pt1->tag[j2] |= pt->tag[i];
397 pt1->edg[j2] = MG_MAX(pt1->edg[j2],pt->edg[i]);
398 pt1->base = mesh->base;
399
400 /* update neighbours of new triangle */
401 adja = &mesh->adja[3*(jel-1)+1];
402 adja[j1] = mesh->adja[3*(kel-1)+1+k];
403 adja[j2] = mesh->adja[3*(iel-1)+1+i];
404
405 mel = adja[j2] / 3;
406 if ( mel ) {
407 m = adja[j2] % 3;
408 pt = &mesh->tria[mel];
409 pt->tag[m] = pt1->tag[j2];
410 pt->edg[m] = pt1->edg[j2];
411 mesh->adja[3*(mel-1)+1+m] = 3*jel + j2;
412 }
413
414 mel = adja[j1] / 3;
415 if ( mel ) {
416 m = adja[j1] % 3;
417 pt = &mesh->tria[mel];
418 pt->tag[m] = pt1->tag[j1];
419 pt->edg[m] = pt1->edg[j1];
420 mesh->adja[3*(mel-1)+1+m] = 3*jel + j1;
421 }
422
423 /* remove vertex + elements */
424 MMGS_delPt(mesh,ip);
425 if ( !MMGS_delElt(mesh,iel) ) return 0;
426 if ( !MMGS_delElt(mesh,kel) ) return 0;
427
428 return 1;
429}
430
431
432/* collapse point along open ridge */
433int colver2(MMG5_pMesh mesh,MMG5_int* list) {
434 MMG5_pTria pt,pt1;
435 MMG5_int *adja,iel,jel,kel,ip;
436 int8_t i1,i2,jj,j2,k;
437
438 /* update of new point for triangle list[0] */
439 iel = list[0] / 3;
440 i1 = list[0] % 3;
441 i2 = MMG5_inxt2[i1];
442 pt = &mesh->tria[iel];
443 ip = pt->v[i1];
444
445 jel = list[1] / 3;
446 j2 = list[1] % 3;
447 jj = MMG5_iprv2[j2];
448 pt1 = &mesh->tria[jel];
449
450 /* update info */
451 pt->v[i1] = pt1->v[jj];
452 pt->tag[i2] |= pt1->tag[j2];
453 pt->edg[i2] = pt1->edg[j2];
454 pt->base = mesh->base;
455
456 /* update neighbours of new triangle */
457 adja = &mesh->adja[3*(iel-1)+1];
458 adja[i2] = mesh->adja[3*(jel-1)+1+j2];
459 adja = &mesh->adja[3*(jel-1)+1];
460 kel = adja[j2] / 3;
461 k = adja[j2] % 3;
462 if ( kel )
463 mesh->adja[3*(kel-1)+1+k] = 3*iel + i2;
464
465 /* remove vertex + element */
466 MMGS_delPt(mesh,ip);
467 if ( !MMGS_delElt(mesh,jel) ) return 0;
468
469 return 1;
470}
471
472/* collapse edge i of k, i1->i2 */
473int litcol(MMG5_pMesh mesh,MMG5_int k,int8_t i,double kali) {
474 MMG5_pTria pt,pt0,pt1;
475 MMG5_pPoint p1,p2;
476 double kal,ps,cosnold,cosnnew;
477 double n0old[3],n0new[3],n1old[3],n1new[3],n00old[3],n00new[3];
478 MMG5_int list[MMG5_TRIA_LMAX+2],jel,ip2,l;
479 int ilist;
480 int8_t i1,i2,j,jj,j2,open;
481
482 pt0 = &mesh->tria[0];
483 pt = &mesh->tria[k];
484 i1 = MMG5_inxt2[i];
485 i2 = MMG5_iprv2[i];
486 ip2 = pt->v[i2];
487
488#ifndef NDEBUG
489 n00old[0] = n00old[1] = n00old[2] = 0.;
490 n0old[0] = n0old[1] = n0old[2] = 0.;
491 n1old[0] = n1old[1] = n1old[2] = 0.;
492 n00new[0] = n00new[1] = n00new[2] = 0.;
493 n0new[0] = n0new[1] = n0new[2] = 0.;
494 n1new[0] = n1new[1] = n1new[2] = 0.;
495#endif
496
497 /* collect all triangles around vertex i1 */
498 if ( pt->v[i1] & MG_NOM ) return 0;
499
500 ilist = MMG5_boulet(mesh,k,i1,list,1,&open);
501
502#ifndef NDEBUG
503 /* check for open ball */
504 int8_t opn;
505 MMG5_int *adja = &mesh->adja[3*(k-1)+1];
506 opn = adja[i] == 0;
507 assert ( opn == open );
508#endif
509
510 if ( ilist > 3 ) {
511 /* check references */
512 jel = list[1] / 3;
513 pt1 = &mesh->tria[jel];
514 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
515
516 /* analyze ball */
517 assert ( ilist-1+open > 1 );
518 for (l=1; l<ilist-1+open; l++) {
519 jel = list[l] / 3;
520 j = list[l] % 3;
521 j2 = MMG5_iprv2[j];
522 pt1 = &mesh->tria[jel];
523
524 /* check normal flipping */
525 if ( !MMG5_nortri(mesh,pt1,n1old) ) return 0;
526 memcpy(pt0,pt1,sizeof(MMG5_Tria));
527 pt0->v[j] = ip2;
528 if ( !MMG5_nortri(mesh,pt0,n1new) ) return 0;
529 ps = n1new[0]*n1old[0] + n1new[1]*n1old[1] + n1new[2]*n1old[2];
530 if ( ps < 0.0 ) return 0;
531
532 /* keep normals at 1st triangles */
533 if ( l == 1 && !open ) {
534 memcpy(n00old,n1old,3*sizeof(double));
535 memcpy(n00new,n1new,3*sizeof(double));
536 }
537
538 /* check normals deviation */
539 if ( !(pt1->tag[j2] & MG_GEO) ) {
540 if ( l > 1 ) {
541 cosnold = n0old[0]*n1old[0] + n0old[1]*n1old[1] + n0old[2]*n1old[2];
542 cosnnew = n0new[0]*n1new[0] + n0new[1]*n1new[1] + n0new[2]*n1new[2];
543 if ( cosnold < MMG5_ANGEDG ) {
544 if ( cosnnew < MG_MIN(0.0,cosnold) ) return 0;
545 }
546 else if ( cosnnew < MMG5_ANGEDG ) return 0;
547 }
548
549 memcpy(n0old,n1old,3*sizeof(double));
550 memcpy(n0new,n1new,3*sizeof(double));
551 }
552 /* check quality */
553 kal = MMGS_ALPHAD*MMG5_caltri_iso(mesh,NULL,pt0);
554 if ( kal < MMGS_NULKAL ) return 0;
555 }
556
557 /* check angle between 1st and last triangles */
558 if ( !open ) {
559 cosnold = n00old[0]*n1old[0] + n00old[1]*n1old[1] + n00old[2]*n1old[2];
560 cosnnew = n00new[0]*n1new[0] + n00new[1]*n1new[1] + n00new[2]*n1new[2];
561 if ( cosnold < MMG5_ANGEDG ) {
562 if ( cosnnew < MG_MIN(0.0,cosnold) ) return 0;
563 }
564 else if ( cosnnew < MMG5_ANGEDG ) return 0;
565
566 /* other reference checks */
567 jel = list[ilist-1] / 3;
568 pt = &mesh->tria[jel];
569 jel = list[ilist-2] / 3;
570 pt1 = &mesh->tria[jel];
571 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
572 }
573
574 return colver(mesh,list,ilist);
575 }
576
577 /* specific test: no collapse if any interior edge is EDG */
578 else if ( ilist == 3 ) {
579 p1 = &mesh->point[pt->v[i1]];
580 if ( MS_SIN(p1->tag) ) return 0;
581 else if ( MG_EDG(pt->tag[i2]) && !MG_EDG(pt->tag[i]) ) return 0;
582 else if ( !MG_EDG(pt->tag[i2]) && MG_EDG(pt->tag[i]) ) return 0;
583 else if ( MG_EDG(pt->tag[i2]) && MG_EDG(pt->tag[i]) && MG_EDG(pt->tag[i1]) ) return 0;
584
585 return colver3(mesh,list);
586 }
587
588 /* for specific configurations along open ridge */
589 else if ( ilist == 2 ) {
590 if ( !open ) return 0;
591 jel = list[1] / 3;
592 j = list[1] % 3;
593 jj = MMG5_inxt2[j];
594 pt1 = &mesh->tria[jel];
595 if ( MMG5_abs(pt->ref) != MMG5_abs(pt1->ref) ) return 0;
596 else if ( !(pt1->tag[jj] & MG_GEO) ) return 0;
597
598 p1 = &mesh->point[pt->v[i1]];
599 p2 = &mesh->point[pt1->v[jj]];
600 if ( p2->tag > p1->tag || p2->ref != p1->ref ) return 0;
601
602 return colver2(mesh,list);
603 }
604
605 return 0;
606}
607
608
609
mesh
MMG5_pMesh * mesh
Definition: API_functionsf_2d.c:66
MMG5_boulet
int MMG5_boulet(MMG5_pMesh mesh, MMG5_int start, int ip, MMG5_int *list, int8_t s, int8_t *opn)
Definition: boulep.c:363
boulechknm
int boulechknm(MMG5_pMesh mesh, MMG5_int start, int ip, MMG5_int *list)
Definition: boulep_s.c:51
colver
int colver(MMG5_pMesh mesh, MMG5_int *list, int ilist)
Definition: colver_s.c:280
colver3
int colver3(MMG5_pMesh mesh, MMG5_int *list)
Definition: colver_s.c:370
colver2
int colver2(MMG5_pMesh mesh, MMG5_int *list)
Definition: colver_s.c:433
chkcol
int chkcol(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, int8_t i, MMG5_int *list, int8_t typchk, double(*MMGS_lenEdg)(MMG5_pMesh, MMG5_pSol, MMG5_int, MMG5_int, int8_t), double(*MMGS_caltri)(MMG5_pMesh, MMG5_pSol, MMG5_pTria))
Definition: colver_s.c:59
litcol
int litcol(MMG5_pMesh mesh, MMG5_int k, int8_t i, double kali)
Definition: colver_s.c:473
inlined_functions_private.h
libmmgs_private.h
MMGS_delElt
int MMGS_delElt(MMG5_pMesh mesh, MMG5_int iel)
Definition: zaldy_s.c:93
MMGS_LLONG
#define MMGS_LLONG
Definition: libmmgs_private.h:38
chkedg
int chkedg(MMG5_pMesh, MMG5_int)
Definition: mmgs1.c:214
MMGS_delPt
void MMGS_delPt(MMG5_pMesh mesh, MMG5_int ip)
Definition: zaldy_s.c:58
MMGS_ALPHAD
#define MMGS_ALPHAD
Definition: libmmgs_private.h:34
MMGS_NULKAL
#define MMGS_NULKAL
Definition: libmmgs_private.h:42
MMGS_LSHRT
#define MMGS_LSHRT
Definition: libmmgs_private.h:39
MS_SIN
#define MS_SIN(tag)
Definition: libmmgs_private.h:49
MG_GEO
#define MG_GEO
Definition: mmgcommon_private.h:146
MG_MIN
#define MG_MIN(a, b)
Definition: mmgcommon_private.h:141
MG_MAX
#define MG_MAX(a, b)
Definition: mmgcommon_private.h:140
MG_EDG
#define MG_EDG(tag)
Definition: mmgcommon_private.h:173
MMG5_iprv2
static const uint8_t MMG5_iprv2[3]
Definition: mmgcommon_private.h:586
MMG5_TRIA_LMAX
#define MMG5_TRIA_LMAX
Definition: mmgcommon_private.h:59
MMG5_inxt2
static const uint8_t MMG5_inxt2[6]
Definition: mmgcommon_private.h:585
MMG5_nortri
int MMG5_nortri(MMG5_pMesh mesh, MMG5_pTria pt, double *n)
Definition: tools.c:209
MMG5_ANGEDG
#define MMG5_ANGEDG
Definition: mmgcommon_private.h:90
MG_NOM
#define MG_NOM
Definition: mmgcommon_private.h:148
MMG5_caltri_iso
double MMG5_caltri_iso(MMG5_pMesh mesh, MMG5_pSol met, MMG5_pTria ptt)
Definition: quality.c:199
mmgexterns_private.h
MMG5_Mesh
MMG mesh structure.
Definition: libmmgtypes.h:613
MMG5_Mesh::point
MMG5_pPoint point
Definition: libmmgtypes.h:649
MMG5_Mesh::adja
MMG5_int * adja
Definition: libmmgtypes.h:632
MMG5_Mesh::base
MMG5_int base
Definition: libmmgtypes.h:624
MMG5_Mesh::tria
MMG5_pTria tria
Definition: libmmgtypes.h:655
MMG5_Point
Structure to store vertices of an MMG mesh.
Definition: libmmgtypes.h:276
MMG5_Point::tag
uint16_t tag
Definition: libmmgtypes.h:290
MMG5_Point::ref
MMG5_int ref
Definition: libmmgtypes.h:284
MMG5_Sol
Definition: libmmgtypes.h:671
MMG5_Tria
Structure to store triangles of a MMG mesh.
Definition: libmmgtypes.h:338
MMG5_Tria::edg
MMG5_int edg[3]
Definition: libmmgtypes.h:345
MMG5_Tria::ref
MMG5_int ref
Definition: libmmgtypes.h:341
MMG5_Tria::tag
uint16_t tag[3]
Definition: libmmgtypes.h:348
MMG5_Tria::base
MMG5_int base
Definition: libmmgtypes.h:342
MMG5_Tria::v
MMG5_int v[3]
Definition: libmmgtypes.h:340
Generated on Tue Oct 29 2024 11:49:58 for Mmg by doxygen 1.9.6