Mmg
Simplicial remeshers (mesh adaptation, isovalue discretization, lagrangian movement)
split_s.c
Go to the documentation of this file.
1/* ============================================================================
2** This file is part of the mmg software package for the tetrahedra
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
35#include "libmmgs_private.h"
36#include "mmgsexterns_private.h"
37#include "mmgexterns_private.h"
38
52int MMGS_split1_sim(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,int i,MMG5_int *vx) {
53 MMG5_pTria pt,pt0;
54 double n[3],nref[3],vnew,vold;
55 int is;
56
57 pt = &mesh->tria[k];
58 MMG5_nonUnitNorPts(mesh, pt->v[0], pt->v[1],pt->v[2],nref);
59
60 vold = nref[0]*nref[0] + nref[1]*nref[1] + nref[2]*nref[2];
61 if ( vold < MMG5_EPSOK ) return 0;
62
63 pt0 = &mesh->tria[0];
64
65 /* Test volume of the two created triangles */
66 memcpy(pt0,pt,sizeof(MMG5_Tria));
67
68 is = MMG5_iprv2[i];
69 pt0->v[is] = vx[i];
70
71 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
72
73 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
74 if ( vnew < MMG5_EPSOK ) return 0;
75
76 /* Check if we create a tri with wrong orientation */
77 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
78 return 0;
79 }
80
81 pt0->v[is] = pt->v[is];
82 is = MMG5_inxt2[i];
83 pt0->v[is] = vx[i];
84
85 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
86
87 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
88 if ( vnew < MMG5_EPSOK ) return 0;
89
90 /* Check if we create a tri with wrong orientation */
91 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
92 return 0;
93 }
94
95 return 1;
96}
97
109int MMGS_split1(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,int i,MMG5_int *vx) {
110 MMG5_pTria pt,pt1;
111 MMG5_pPoint ppt;
112 MMG5_int iel;
113 int8_t i1,i2;
114
115 iel = MMGS_newElt(mesh);
116 if ( !iel ) {
117 MMGS_TRIA_REALLOC(mesh,iel,mesh->gap,
118 fprintf(stderr,"\n ## Error: %s: unable to allocate"
119 " a new element.\n",__func__);
120 MMG5_INCREASE_MEM_MESSAGE();
121 fprintf(stderr," Exit program.\n");
122 return 0);
123 }
124
125 pt = &mesh->tria[k];
126 pt->flag = 0;
127 pt1 = &mesh->tria[iel];
128 pt1 = memcpy(pt1,pt,sizeof(MMG5_Tria));
129
130 i1 = MMG5_inxt2[i];
131 i2 = MMG5_inxt2[i1];
132
133
134 if ( pt->edg[i] > 0 ) {
135 ppt = &mesh->point[vx[i]];
136 ppt->ref = pt->edg[i];
137 }
138
139 pt->v[i2] = pt1->v[i1] = vx[i];
140 pt->tag[i1] = pt1->tag[i2] = MG_NOTAG;
141 pt->edg[i1] = pt1->edg[i2] = 0;
142
143 return 1;
144}
145
162int MMGS_simbulgept(MMG5_pMesh mesh,MMG5_pSol met, MMG5_int k,int i,MMG5_int ip) {
163 MMG5_pTria pt,pt0;
164 MMG5_pPoint ppt,ppt0;
165 double cal;
166 MMG5_int kadja;
167 int iadja,is;
168 static int mmgErr0 = 0, mmgErr1 = 0;
169
170 pt0 = &mesh->tria[0];
171 ppt0 = &mesh->point[0];
172 ppt = &mesh->point[ip];
173
174 /* MMG5_calelt function needs the normal(s) at point in aniso mode so we can't
175 * copy only the point coordinates */
176 memcpy(ppt0 ,ppt ,sizeof(MMG5_Point));
177 ppt0->tag = mesh->point[ip].tag;
178
179 memcpy(&met->m[0],&met->m[met->size*ip], met->size*sizeof(double));
180
181 /* Copy tria to split in tria 0 for simu purpose */
182 pt = &mesh->tria[k];
183 memcpy(pt0,pt,sizeof(MMG5_Tria));
184 is = MMG5_iprv2[i];
185 pt0->v[is] = 0;
186
187 /* For now, if ip is a ridge point, only 1 normal has been computed: allocate
188 * a new xpoint and update the second normal */
189 MMG5_int *adja = &mesh->adja[3*(k-1)+1];
190 kadja = adja[i] / 3;
191 iadja = adja[i] % 3;
192
193 /* update normal n2 if need be */
194 int8_t compute_n2 = kadja && (pt0->tag[i] & MG_GEO) ;
195 if ( compute_n2 ) {
196 MMG5_Bezier b;
197 int ier = MMG5_bezierCP(mesh,&mesh->tria[kadja],&b,1);
198 if ( !ier ) {
199 if( !mmgErr0 ) {
200 mmgErr0 = 1;
201 fprintf(stderr,"\n ## Warning: %s: function MMG5_bezierCP return 0.\n",
202 __func__);
203 }
204 assert(0);
205 }
206 double uv[2],o[3],no[3],to[3];
207 uv[0] = 0.5;
208 uv[1] = 0.5;
209 if ( iadja == 1 ) uv[0] = 0.0;
210 else if ( iadja == 2 ) uv[1] = 0.0;
211
212 ier = MMGS_bezierInt(&b,uv,o,no,to);
213 if ( !ier ) {
214 if( !mmgErr1 ) {
215 mmgErr1 = 1;
216 fprintf(stderr," ## Warning: %s: function MMGS_bezierInt return 0.\n",
217 __func__);
218 }
219 assert(0);
220 }
221 MMG5_int nxp = mesh->xp + 1;
222 if ( nxp > mesh->xpmax ) {
223 MMG5_TAB_RECALLOC(mesh,mesh->xpoint,mesh->xpmax,MMG5_GAP,MMG5_xPoint,
224 "larger xpoint table",
225 return 0);
226 }
227 ppt0->xp = nxp;
228 MMG5_pxPoint go = &mesh->xpoint[ppt0->xp];
229 memcpy(go->n2,no,3*sizeof(double));
230 assert ( ppt->xp && "missing xpoint at ridge point" );
231 MMG5_pxPoint pxp = &mesh->xpoint[ppt->xp];
232 memcpy(go->n1,pxp->n1,3*sizeof(double));
233 }
234
235 // Check the validity of the two triangles created from k.
236 cal = MMG5_calelt(mesh,met,pt0);
237 if ( cal < MMG5_EPSOK ) return 0;
238
239 pt0->v[is] = pt->v[is];
240 is = MMG5_inxt2[i];
241 pt0->v[is] = 0;
242 cal = MMG5_calelt(mesh,met,pt0);
243 if ( cal < MMG5_EPSOK ) return 0;
244
245 // Check the validity of the two triangles created from the triangle adjacent
246 // to k by edge i.
247 if ( !kadja ) return 1;
248
249 pt = &mesh->tria[kadja];
250 memcpy(pt0,pt,sizeof(MMG5_Tria));
251 is = MMG5_iprv2[iadja];
252 pt0->v[is] = 0;
253 cal = MMG5_calelt(mesh,met,pt0);
254 if ( cal < MMG5_EPSOK ) return 0;
255
256 pt0->v[is] = pt->v[is];
257 is = MMG5_inxt2[iadja];
258 pt0->v[is] = 0;
259 cal = MMG5_calelt(mesh,met,pt0);
260 if ( cal < MMG5_EPSOK ) return 0;
261
262 /* If point is ridge: copy computed second normal into xpoint */
263 if ( compute_n2 ) {
264 MMG5_pxPoint go = &mesh->xpoint[ppt0->xp];
265 MMG5_pxPoint pxp = &mesh->xpoint[ppt->xp];
266 memcpy(pxp->n2,go->n2,3*sizeof(double));
267 }
268 return 1;
269}
270
283int split1b(MMG5_pMesh mesh,MMG5_int k,int8_t i,MMG5_int ip) {
284 MMG5_pTria pt,pt1;
285 MMG5_pPoint ppt;
286 MMG5_int *adja,iel,jel,kel,mel;
287 int8_t i1,i2,j,j1,j2,m;
288
289 iel = MMGS_newElt(mesh);
290 if ( !iel ) {
291 MMGS_TRIA_REALLOC(mesh,iel,mesh->gap,
292 MMG5_INCREASE_MEM_MESSAGE();
293 return 0);
294 }
295 pt = &mesh->tria[k];
296 pt->flag = 0;
297 pt->base = mesh->base;
298
299 pt1 = &mesh->tria[iel];
300 memcpy(pt1,pt,sizeof(MMG5_Tria));
301 memcpy(&mesh->adja[3*(iel-1)+1],&mesh->adja[3*(k-1)+1],3*sizeof(MMG5_int));
302
303 ppt = &mesh->point[ip];
304 if ( pt->edg[i] ) ppt->ref = pt->edg[i];
305 if ( pt->tag[i] ) ppt->tag = pt->tag[i];
306
307 adja = &mesh->adja[3*(k-1)+1];
308 jel = adja[i] / 3;
309 j = adja[i] % 3;
310
311 /* update two triangles */
312 i1 = MMG5_inxt2[i];
313 i2 = MMG5_iprv2[i];
314 pt->v[i2] = ip;
315 pt->tag[i1] = MG_NOTAG;
316 pt->edg[i1] = 0;
317 pt1->v[i1] = ip;
318 pt1->tag[i2] = MG_NOTAG;
319 pt1->edg[i2] = 0;
320
321 /* update adjacency relations */
322 mel = adja[i1] / 3;
323 m = adja[i1] % 3;
324 mesh->adja[3*(k-1)+1+i1] = 3*iel+i2;
325 mesh->adja[3*(iel-1)+1+i2] = 3*k+i1;
326 mesh->adja[3*(iel-1)+1+i1] = 3*mel+m;
327 if(mel)
328 mesh->adja[3*(mel-1)+1+m] = 3*iel+i1;
329
330 if ( jel ) {
331 kel = MMGS_newElt(mesh);
332 if ( !kel ) {
333 MMGS_TRIA_REALLOC(mesh,kel,mesh->gap,
334 MMG5_INCREASE_MEM_MESSAGE();
335 if ( !MMGS_delElt(mesh,iel) ) return 0;
336 return 0);
337 }
338 pt = &mesh->tria[jel];
339 pt1 = &mesh->tria[kel];
340 pt->flag = 0;
341 pt->base = mesh->base;
342 memcpy(pt1,pt,sizeof(MMG5_Tria));
343 memcpy(&mesh->adja[3*(kel-1)+1],&mesh->adja[3*(jel-1)+1],3*sizeof(MMG5_int));
344
345 j1 = MMG5_inxt2[j];
346 j2 = MMG5_iprv2[j];
347 pt->v[j1] = ip;
348 pt->tag[j2] = MG_NOTAG;
349 pt->edg[j2] = 0;
350 pt1->v[j2] = ip;
351 pt1->tag[j1] = MG_NOTAG;
352 pt1->edg[j1] = 0;
353
354 /* update adjacency */
355 adja = &mesh->adja[3*(jel-1)+1];
356 mel = adja[j2] / 3;
357 m = adja[j2] % 3;
358 mesh->adja[3*(jel-1)+1+j2] = 3*kel+j1;
359 mesh->adja[3*(kel-1)+1+j1] = 3*jel+j2;
360 mesh->adja[3*(kel-1)+1+j2] = 3*mel+m;
361 if(mel)
362 mesh->adja[3*(mel-1)+1+m] = 3*kel+j2;
363
364 mesh->adja[3*(iel-1)+1+i] = 3*kel+j;
365 mesh->adja[3*(kel-1)+1+j] = 3*iel+i;
366 }
367
368 return 1;
369}
370
383int MMG5_split2_sim(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,MMG5_int *vx) {
384 MMG5_pTria pt,pt0;
385 double n[3],nref[3],vold,vnew;
386 int i1,i2,i;
387
388 pt = &mesh->tria[k];
389 MMG5_nonUnitNorPts(mesh, pt->v[0], pt->v[1],pt->v[2],nref);
390
391 vold = nref[0]*nref[0] + nref[1]*nref[1] + nref[2]*nref[2];
392 if ( vold < MMG5_EPSOK ) return 0;
393
394 pt0 = &mesh->tria[0];
395
396 memcpy(pt0,pt,sizeof(MMG5_Tria));
397
398 i = 0;
399 if ( !vx[0] ) i = 1;
400 else if ( !vx[1] ) i = 2;
401 i1 = MMG5_inxt2[i];
402 i2 = MMG5_inxt2[i1];
403
404 /* Check the quality of the 3 new triangles */
405 /* Tri 1 */
406 pt0->v[i2] = vx[i];
407 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
408
409 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
410 if ( vnew < MMG5_EPSOK ) return 0;
411
412 /* Check if we create a tri with wrong orientation */
413 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
414 return 0;
415 }
416
417 /* Tri 2 */
418 pt0->v[i1] = vx[i];
419 pt0->v[i2] = vx[i1];
420
421 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
422
423 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
424 if ( vnew < MMG5_EPSOK ) return 0;
425
426 /* Check if we create a tri with wrong orientation */
427 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
428 return 0;
429 }
430
431 /* Tri 3 */
432 pt0->v[i2] = pt->v[i2];
433 pt0->v[i1] = vx[i];
434 pt0->v[i] = vx[i1];
435
436 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
437
438 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
439 if ( vnew < MMG5_EPSOK ) return 0;
440
441 /* Check if we create a tri with wrong orientation */
442 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
443 return 0;
444 }
445
446 return 1;
447}
448
459int MMGS_split2(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,MMG5_int *vx) {
460 MMG5_pTria pt,pt1,pt2;
461 MMG5_pPoint p3,p4;
462 MMG5_int iel,jel;
463 int8_t i,i1,i2;
464
465 /* create 2 elements */
466 iel = MMGS_newElt(mesh);
467 if ( !iel ) {
468 MMGS_TRIA_REALLOC(mesh,iel,mesh->gap,
469 fprintf(stderr,"\n ## Error: %s: unable to allocate"
470 " a new element.\n",__func__);
471 MMG5_INCREASE_MEM_MESSAGE();
472 fprintf(stderr," Exit program.\n");
473 return 0);
474 }
475 jel = MMGS_newElt(mesh);
476 if ( !jel ) {
477 MMGS_TRIA_REALLOC(mesh,jel,mesh->gap,
478 fprintf(stderr,"\n ## Error: %s: unable to allocate"
479 " a new element.\n",__func__);
480 MMG5_INCREASE_MEM_MESSAGE();
481 fprintf(stderr," Exit program.\n");
482 return 0);
483 }
484
485 pt = &mesh->tria[k];
486 pt->flag = 0;
487 pt1 = &mesh->tria[iel];
488 pt2 = &mesh->tria[jel];
489 pt1 = memcpy(pt1,pt,sizeof(MMG5_Tria));
490 pt2 = memcpy(pt2,pt,sizeof(MMG5_Tria));
491
492 i = 0;
493 if ( !vx[0] ) i = 1;
494 else if ( !vx[1] ) i = 2;
495 i1 = MMG5_inxt2[i];
496 i2 = MMG5_inxt2[i1];
497
498 p3 = &mesh->point[vx[i]];
499 p4 = &mesh->point[vx[i1]];
500
501 /* update refs */
502 if ( pt->edg[i] > 0 ) p3->ref = pt->edg[i];
503 if ( pt->edg[i1] > 0 ) p4->ref = pt->edg[i1];
504
505 pt->v[i1] = pt1->v[i2] = pt2->v[i1] = vx[i];
506 pt->v[i2] = pt2->v[i] = vx[i1];
507
508 pt->tag[i] = pt->tag[i2] = pt1->tag[i1] = pt2->tag[i2] = MG_NOTAG;
509 pt->edg[i] = pt->edg[i2] = pt1->edg[i1] = pt2->edg[i2] = 0;
510
511 /* alternate configs */
512 /* pt->v[i2] = pt1->v[i] = pt2->v[i] = vx[i1]; */
513 /* pt1->v[i2] = pt2->v[i1] = vx[i]; */
514
515 /* pt->tag[i] = pt1->tag[i1] = pt1->tag[i2] = pt2->tag[i2] = MG_NOTAG; */
516 /* pt->edg[i] = pt1->edg[i1] = pt1->edg[i2] = pt2->edg[i2] = 0; */
517
518 return 1;
519}
520
532int MMGS_split3_sim(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,MMG5_int *vx) {
533 MMG5_pTria pt,pt0;
534 double n[3],nref[3],vnew,vold;
535
536 pt = &mesh->tria[k];
537 MMG5_nonUnitNorPts(mesh, pt->v[0], pt->v[1],pt->v[2],nref);
538
539 vold = nref[0]*nref[0] + nref[1]*nref[1] + nref[2]*nref[2];
540 if ( vold < MMG5_EPSOK ) return 0;
541
542 pt0 = &mesh->tria[0];
543
544 memcpy(pt0,pt,sizeof(MMG5_Tria));
545
546 /* Check the 4 new triangles */
547 /* Tri 1 */
548 pt0->v[1] = vx[2];
549 pt0->v[2] = vx[1];
550
551 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
552
553 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
554 if ( vnew < MMG5_EPSOK ) return 0;
555
556 /* Check if we create a tri with wrong orientation */
557 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
558 return 0;
559 }
560
561 /* Tri 2 */
562 pt0->v[1] = pt->v[1];
563 pt0->v[0] = vx[2];
564 pt0->v[2] = vx[0];
565
566 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
567
568 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
569 if ( vnew < MMG5_EPSOK ) return 0;
570
571 /* Check if we create a tri with wrong orientation */
572 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
573 return 0;
574 }
575
576 /* Tri 3 */
577 pt0->v[2] = pt->v[2];
578 pt0->v[0] = vx[1];
579 pt0->v[1] = vx[0];
580
581 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
582
583 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
584 if ( vnew < MMG5_EPSOK ) return 0;
585
586 /* Check if we create a tri with wrong orientation */
587 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
588 return 0;
589 }
590
591
592 /* Tri 4 */
593 pt0->v[0] = vx[2];
594 pt0->v[1] = vx[0];
595 pt0->v[2] = vx[1];
596
597 MMG5_nonUnitNorPts(mesh, pt0->v[0], pt0->v[1],pt0->v[2],n);
598
599 vnew = n[0]*n[0] + n[1]*n[1] + n[2]*n[2];
600 if ( vnew < MMG5_EPSOK ) return 0;
601
602 /* Check if we create a tri with wrong orientation */
603 if ( nref[0]*n[0]+nref[1]*n[1]+nref[2]*n[2] < 0 ) {
604 return 0;
605 }
606
607 return 1;
608}
609
620int MMGS_split3(MMG5_pMesh mesh,MMG5_pSol met,MMG5_int k,MMG5_int *vx) {
621 MMG5_pTria pt,pt1,pt2,pt3;
622 MMG5_pPoint p3,p4,p5;
623 MMG5_int iel,jel,kel;
624
625 /* create 3 elements */
626 iel = MMGS_newElt(mesh);
627 if ( !iel ) {
628 MMGS_TRIA_REALLOC(mesh,iel,mesh->gap,
629 fprintf(stderr,"\n ## Error: %s: unable to allocate"
630 " a new element.\n",__func__);
631 MMG5_INCREASE_MEM_MESSAGE();
632 fprintf(stderr," Exit program.\n");
633 return 0);
634 }
635 jel = MMGS_newElt(mesh);
636 if ( !jel ) {
637 MMGS_TRIA_REALLOC(mesh,jel,mesh->gap,
638 fprintf(stderr,"\n ## Error: %s: unable to allocate"
639 " a new element.\n",__func__);
640 MMG5_INCREASE_MEM_MESSAGE();
641 fprintf(stderr," Exit program.\n");
642 return 0);
643 }
644 kel = MMGS_newElt(mesh);
645 if ( !kel ) {
646 MMGS_TRIA_REALLOC(mesh,kel,mesh->gap,
647 fprintf(stderr,"\n ## Error: %s: unable to allocate"
648 " a new element.\n",__func__);
649 MMG5_INCREASE_MEM_MESSAGE();
650 fprintf(stderr," Exit program.\n");
651 return 0);
652 }
653
654 pt = &mesh->tria[k];
655 pt->flag = 0;
656 pt1 = &mesh->tria[iel];
657 pt2 = &mesh->tria[jel];
658 pt3 = &mesh->tria[kel];
659 pt1 = memcpy(pt1,pt,sizeof(MMG5_Tria));
660 pt2 = memcpy(pt2,pt,sizeof(MMG5_Tria));
661 pt3 = memcpy(pt3,pt,sizeof(MMG5_Tria));
662
663 p3 = &mesh->point[vx[0]];
664 p4 = &mesh->point[vx[1]];
665 p5 = &mesh->point[vx[2]];
666
667 /* update refs */
668 if ( pt->edg[0] > 0 ) p3->ref = pt->edg[0];
669 if ( pt->edg[1] > 0 ) p4->ref = pt->edg[1];
670 if ( pt->edg[2] > 0 ) p5->ref = pt->edg[2];
671
672 /* update topo */
673 pt->v[1] = pt1->v[0] = pt3->v[0] = vx[2];
674 pt->v[2] = pt2->v[0] = pt3->v[2] = vx[1];
675 pt1->v[2] = pt2->v[1] = pt3->v[1] = vx[0];
676
677 pt->tag[0] = pt1->tag[1] = pt2->tag[2] = MG_NOTAG;
678 pt->edg[0] = pt1->edg[1] = pt2->edg[2] = 0;
679
680 pt3->tag[0] = pt3->tag[1] = pt3->tag[2] = MG_NOTAG;
681 pt3->edg[0] = pt3->edg[1] = pt3->edg[2] = 0;
682
683 return 1;
684}
ier
int ier
Definition: API_functionsf_2d.c:761
mesh
MMG5_pMesh * mesh
Definition: API_functionsf_2d.c:66
MMGS_bezierInt
int MMGS_bezierInt(MMG5_pBezier pb, double uv[2], double o[3], double no[3], double to[3])
Definition: bezier_s.c:207
libmmgs_private.h
MMGS_delElt
int MMGS_delElt(MMG5_pMesh mesh, MMG5_int iel)
Definition: zaldy_s.c:93
MMGS_newElt
MMG5_int MMGS_newElt(MMG5_pMesh mesh)
Definition: zaldy_s.c:71
MMGS_TRIA_REALLOC
#define MMGS_TRIA_REALLOC(mesh, jel, wantedGap, law)
Definition: libmmgs_private.h:94
MG_GEO
#define MG_GEO
Definition: mmgcommon_private.h:146
MMG5_EPSOK
#define MMG5_EPSOK
Definition: mmgcommon_private.h:97
MMG5_INCREASE_MEM_MESSAGE
#define MMG5_INCREASE_MEM_MESSAGE()
Definition: mmgcommon_private.h:432
MMG5_GAP
#define MMG5_GAP
Definition: mmgcommon_private.h:132
MG_NOTAG
#define MG_NOTAG
Definition: mmgcommon_private.h:144
MMG5_iprv2
static const uint8_t MMG5_iprv2[3]
Definition: mmgcommon_private.h:586
MMG5_TAB_RECALLOC
#define MMG5_TAB_RECALLOC(mesh, ptr, initSize, wantedGap, type, message, law)
Definition: mmgcommon_private.h:406
MMG5_nonUnitNorPts
int MMG5_nonUnitNorPts(MMG5_pMesh, MMG5_int, MMG5_int, MMG5_int, double *)
Definition: tools.c:127
MMG5_inxt2
static const uint8_t MMG5_inxt2[6]
Definition: mmgcommon_private.h:585
mmgexterns_private.h
mmgsexterns_private.h
MMG5_split2_sim
int MMG5_split2_sim(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, MMG5_int *vx)
Definition: split_s.c:383
MMGS_split1
int MMGS_split1(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, int i, MMG5_int *vx)
Definition: split_s.c:109
MMGS_split3_sim
int MMGS_split3_sim(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, MMG5_int *vx)
Definition: split_s.c:532
MMGS_split3
int MMGS_split3(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, MMG5_int *vx)
Definition: split_s.c:620
MMGS_simbulgept
int MMGS_simbulgept(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, int i, MMG5_int ip)
Definition: split_s.c:162
MMGS_split1_sim
int MMGS_split1_sim(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, int i, MMG5_int *vx)
Definition: split_s.c:52
MMGS_split2
int MMGS_split2(MMG5_pMesh mesh, MMG5_pSol met, MMG5_int k, MMG5_int *vx)
Definition: split_s.c:459
split1b
int split1b(MMG5_pMesh mesh, MMG5_int k, int8_t i, MMG5_int ip)
Definition: split_s.c:283
MMG5_Bezier
Definition: mmgcommon_private.h:611
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::xpoint
MMG5_pxPoint xpoint
Definition: libmmgtypes.h:650
MMG5_Mesh::xp
MMG5_int xp
Definition: libmmgtypes.h:628
MMG5_Mesh::gap
double gap
Definition: libmmgtypes.h:616
MMG5_Mesh::base
MMG5_int base
Definition: libmmgtypes.h:624
MMG5_Mesh::tria
MMG5_pTria tria
Definition: libmmgtypes.h:655
MMG5_Mesh::xpmax
MMG5_int xpmax
Definition: libmmgtypes.h:620
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::xp
MMG5_int xp
Definition: libmmgtypes.h:285
MMG5_Point::ref
MMG5_int ref
Definition: libmmgtypes.h:284
MMG5_Sol
Definition: libmmgtypes.h:671
MMG5_Sol::size
int size
Definition: libmmgtypes.h:677
MMG5_Sol::m
double * m
Definition: libmmgtypes.h:680
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::flag
MMG5_int flag
Definition: libmmgtypes.h:347
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
MMG5_xPoint
Structure to store surface vertices of an MMG mesh.
Definition: libmmgtypes.h:300
MMG5_xPoint::n2
double n2[3]
Definition: libmmgtypes.h:301
MMG5_xPoint::n1
double n1[3]
Definition: libmmgtypes.h:301
Generated on Tue Oct 29 2024 11:49:58 for Mmg by doxygen 1.9.6