Changeset 3407
- Timestamp:
- 04/06/10 11:19:09 (15 years ago)
- Location:
- issm/trunk/src/c/Bamgx/objects
- Files:
-
- 2 added
- 2 deleted
- 19 edited
Legend:
- Unmodified
- Added
- Removed
-
issm/trunk/src/c/Bamgx/objects/BamgObjects.h
r3391 r3407 6 6 #include "./DoubleAndInt.h" 7 7 #include "./Direction.h" 8 #include "./ BamgVertex.h"8 #include "./MeshVertex.h" 9 9 #include "./TriangleAdjacent.h" 10 10 #include "./Edge.h" -
issm/trunk/src/c/Bamgx/objects/CrackedEdge.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "TriangleAdjacent.h" 13 13 #include "Edge.h" -
issm/trunk/src/c/Bamgx/objects/Edge.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "TriangleAdjacent.h" 13 13 … … 21 21 22 22 public: 23 Vertex* v[2];23 MeshVertex* v[2]; 24 24 long ref; 25 25 GeometricalEdge* onGeometry; … … 27 27 28 28 //Operators 29 Vertex & operator[](int i){return *v[i];};30 Vertex * operator()(int i){return v[i];};29 MeshVertex & operator[](int i){return *v[i];}; 30 MeshVertex * operator()(int i){return v[i];}; 31 31 R2 operator()(double t) const; // return the point 32 const Vertex & operator[](int i) const { return *v[i];};32 const MeshVertex & operator[](int i) const { return *v[i];}; 33 33 34 34 //Methods 35 void ReNumbering( Vertex *vb,Vertex *ve, long *renu){35 void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){ 36 36 if (v[0] >=vb && v[0] <ve) v[0] = vb + renu[v[0]-vb]; 37 37 if (v[1] >=vb && v[1] <ve) v[1] = vb + renu[v[1]-vb]; -
issm/trunk/src/c/Bamgx/objects/GeometricalVertex.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 13 13 namespace bamg { … … 16 16 class Geometry; 17 17 18 class GeometricalVertex : public Vertex {18 class GeometricalVertex : public MeshVertex { 19 19 20 20 public: -
issm/trunk/src/c/Bamgx/objects/Geometry.cpp
r3335 r3407 120 120 } 121 121 else{ 122 ISSMERROR(exprintf("No Vertex provided"));122 ISSMERROR(exprintf("No MeshVertex provided")); 123 123 } 124 124 … … 438 438 double eps=1e-20; 439 439 QuadTree quadtree; // build quadtree to find duplicates 440 Vertex* v0=vertices;440 MeshVertex* v0=vertices; 441 441 GeometricalVertex* v0g=(GeometricalVertex*) (void*)v0; 442 442 … … 457 457 458 458 //find nearest vertex already present in the quadtree (NULL if empty) 459 Vertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y);459 MeshVertex* v=quadtree.NearestVertex(vertices[i].i.x,vertices[i].i.y); 460 460 461 461 //if there is a vertex found that is to close to vertices[i] -> error … … 465 465 j=vg-v0g; 466 466 //check that the clostest vertex is not itself... 467 if ( v != &( Vertex &) vertices[j]){468 ISSMERROR(exprintf(" v != &( Vertex &) vertices[j]"));467 if ( v != &(MeshVertex &) vertices[j]){ 468 ISSMERROR(exprintf(" v != &(MeshVertex &) vertices[j]")); 469 469 } 470 470 vertices[i].link = vertices + j; … … 830 830 /*}}}1*/ 831 831 /*FUNCTION Geometry::ProjectOnCurve {{{1*/ 832 GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s, Vertex &V,VertexOnGeom &GV) const {832 GeometricalEdge* Geometry::ProjectOnCurve(const Edge &e,double s,MeshVertex &V,VertexOnGeom &GV) const { 833 833 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/ProjectOnCurve)*/ 834 834 /*Add a vertex on an existing geometrical edge according to the metrics of the two vertices constituting the edge*/ … … 849 849 850 850 //Get the two vertices of the edge 851 const Vertex &v0=e[0];852 const Vertex &v1=e[1];851 const MeshVertex &v0=e[0]; 852 const MeshVertex &v1=e[1]; 853 853 854 854 //Get position of V0, V1 and vector v0->v1 … … 916 916 917 917 if ((*eg0)(sens0)==(GeometricalVertex*)vg0) 918 vg0=VertexOnGeom(*( Vertex*) vg0,*eg0,sens0); //vg0 = absisce918 vg0=VertexOnGeom(*(MeshVertex*) vg0,*eg0,sens0); //vg0 = absisce 919 919 920 920 if ((*eg1)(sens1)==(GeometricalVertex*)vg1) 921 vg1=VertexOnGeom(*( Vertex*) vg1,*eg1,sens1);921 vg1=VertexOnGeom(*(MeshVertex*) vg1,*eg1,sens1); 922 922 923 923 double sg; -
issm/trunk/src/c/Bamgx/objects/Geometry.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "Edge.h" 13 13 #include "GeometricalVertex.h" … … 70 70 long Number(const Curve * c) const { return c - curves;} 71 71 void UnMarkEdges() {for (int i=0;i<nbe;i++) edges[i].SetUnMark();} 72 GeometricalEdge * ProjectOnCurve(const Edge & ,double, Vertex &,VertexOnGeom &) const ;72 GeometricalEdge * ProjectOnCurve(const Edge & ,double,MeshVertex &,VertexOnGeom &) const ; 73 73 GeometricalEdge * Containing(const R2 P, GeometricalEdge * start) const; 74 74 void WriteGeometry(BamgGeom* bamggeom, BamgOpts* bamgopts); -
issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.cpp
r3332 r3407 45 45 double ba,bb; 46 46 TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb); 47 Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);47 MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); 48 48 NewItem(A,Metric(ba,v0,bb,v1)); 49 49 t=edge; … … 51 51 if (det(v0.i,v1.i,b)>=0) { 52 52 TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb); 53 Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);53 MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); 54 54 NewItem(A,Metric(ba,v0,bb,v1)); 55 55 return; … … 81 81 long int verbosity=2; 82 82 TriangleAdjacent edge=CloseBoundaryEdge(a,t,ba,bb); 83 Vertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1);83 MeshVertex & v0 = *edge.EdgeVertex(0), & v1 = *edge.EdgeVertex(1); 84 84 NewItem(A,Metric(ba,v0,bb,v1)); 85 85 return; … … 233 233 lIntTria[Size].x = x; 234 234 Metric m0,m1,m2; 235 register Vertex * v;235 register MeshVertex * v; 236 236 if ((v=(*tt)(0))) m0 = v->m; 237 237 if ((v=(*tt)(1))) m1 = v->m; … … 308 308 /*}}}1*/ 309 309 /*FUNCTION ListofIntersectionTriangles::NewPoints{{{1*/ 310 long ListofIntersectionTriangles::NewPoints( Vertex* vertices,long &nbv,long nbvx){310 long ListofIntersectionTriangles::NewPoints(MeshVertex* vertices,long &nbv,long nbvx){ 311 311 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NewPoints)*/ 312 312 -
issm/trunk/src/c/Bamgx/objects/ListofIntersectionTriangles.h
r3391 r3407 10 10 #include "../include/macros.h" 11 11 #include "Metric.h" 12 #include " BamgVertex.h"12 #include "MeshVertex.h" 13 13 #include "Edge.h" 14 14 #include "GeometricalEdge.h" … … 82 82 void SplitEdge(const Triangles & ,const R2 &,const R2 &,int nbegin=0); 83 83 double Length(); 84 long NewPoints( Vertex *,long & nbv,long nbvx);84 long NewPoints(MeshVertex *,long & nbv,long nbvx); 85 85 void NewSubSeg(GeometricalEdge *e,double s0,double s1){ 86 86 long int verbosity=0; -
issm/trunk/src/c/Bamgx/objects/QuadTree.cpp
r3332 r3407 121 121 /*Methods*/ 122 122 /*FUNCTION QuadTree::Add{{{1*/ 123 void QuadTree::Add( Vertex &w){123 void QuadTree::Add(MeshVertex &w){ 124 124 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/Add)*/ 125 125 … … 164 164 165 165 //Copy the 4 vertices in the current QuadTreebox 166 Vertex* v4[4];166 MeshVertex* v4[4]; 167 167 v4[0]= b->v[0]; 168 168 v4[1]= b->v[1]; … … 206 206 /*}}}1*/ 207 207 /*FUNCTION QuadTree::NearestVertex{{{1*/ 208 Vertex* QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {208 MeshVertex* QuadTree::NearestVertex(Icoor1 i,Icoor1 j) { 209 209 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertex)*/ 210 210 … … 225 225 Icoor1 jplus( j<MaxISize?(j<0?0:j):MaxISize-1); 226 226 //initial nearest vertex pointer 227 Vertex* vn=NULL;227 MeshVertex* vn=NULL; 228 228 229 229 //Get initial Quadtree box (largest) … … 294 294 295 295 //if the current subbox is holding vertices, 296 if (b->n>0){ // Vertex QuadTreeBox not empty296 if (b->n>0){ // MeshVertex QuadTreeBox not empty 297 297 NbVerticesSearch++; 298 298 I2 i2 = b->v[k]->i; … … 345 345 /*}}}1*/ 346 346 /*FUNCTION QuadTree::NearestVertexWithNormal{{{1*/ 347 Vertex* QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) {347 MeshVertex* QuadTree::NearestVertexWithNormal(Icoor1 i,Icoor1 j) { 348 348 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/NearestVertexWithNormal)*/ 349 349 … … 359 359 Icoor1 jplus( j<MaxISize?(j<0?0:j):MaxISize-1); 360 360 361 Vertex *vn=0;361 MeshVertex *vn=0; 362 362 363 363 // init for optimisation --- … … 412 412 int k = pi[l]; 413 413 414 if (b->n>0) // Vertex QuadTreeBox none empty414 if (b->n>0) // MeshVertex QuadTreeBox none empty 415 415 { 416 416 NbVerticesSearch++; … … 473 473 /*}}}1*/ 474 474 /*FUNCTION QuadTree::ToClose {{{1*/ 475 Vertex * QuadTree::ToClose(Vertex & v,double seuil,Icoor1 hx,Icoor1 hy){475 MeshVertex * QuadTree::ToClose(MeshVertex & v,double seuil,Icoor1 hx,Icoor1 hy){ 476 476 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/ToClose)*/ 477 477 … … 490 490 Icoor1 i0=0,j0=0; 491 491 492 // Vertex *vn=0;492 // MeshVertex *vn=0; 493 493 494 494 if (!root->n) … … 507 507 register int k = pi[l]; 508 508 509 if (b->n>0) // Vertex QuadTreeBox none empty509 if (b->n>0) // MeshVertex QuadTreeBox none empty 510 510 { 511 511 NbVerticesSearch++; -
issm/trunk/src/c/Bamgx/objects/QuadTree.h
r3332 r3407 16 16 17 17 class Triangles; 18 class Vertex;18 class MeshVertex; 19 19 20 20 class QuadTree{ … … 23 23 public: 24 24 long n; 25 //contains only one object form the list (either Vertex or QuadTreeBox)26 // if n < 4 => Vertex else => QuadTreeBox;25 //contains only one object form the list (either MeshVertex or QuadTreeBox) 26 // if n < 4 => MeshVertex else => QuadTreeBox; 27 27 union{ 28 28 QuadTreeBox* b[4]; 29 Vertex* v[4];29 MeshVertex* v[4]; 30 30 }; 31 31 }; … … 55 55 long NbQuadTreeBox,NbVertices; 56 56 long NbQuadTreeBoxSearch,NbVerticesSearch; 57 Vertex* NearestVertex(Icoor1 i,Icoor1 j);58 Vertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);59 Vertex* ToClose(Vertex & ,double ,Icoor1,Icoor1);57 MeshVertex* NearestVertex(Icoor1 i,Icoor1 j); 58 MeshVertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j); 59 MeshVertex* ToClose(MeshVertex & ,double ,Icoor1,Icoor1); 60 60 long SizeOf() const {return sizeof(QuadTree)+sb->SizeOf();} 61 void Add( Vertex & w);61 void Add( MeshVertex & w); 62 62 QuadTreeBox* NewQuadTreeBox(){ 63 63 if(! (sb->bc<sb->be)) sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb); -
issm/trunk/src/c/Bamgx/objects/Triangle.cpp
r3332 r3407 12 12 /*FUNCTION Triangle(Triangles *Th,long i,long j,long k) {{{1*/ 13 13 Triangle::Triangle(Triangles *Th,long i,long j,long k) { 14 Vertex *v=Th->vertices;14 MeshVertex *v=Th->vertices; 15 15 long nbv = Th->nbv; 16 16 if (i<0 || j<0 || k<0){ … … 28 28 } 29 29 /*}}}*/ 30 /*FUNCTION Triangle( Vertex *v0,Vertex *v1,Vertex *v2) {{{1*/31 Triangle::Triangle( Vertex *v0,Vertex *v1,Vertex *v2){30 /*FUNCTION Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2) {{{1*/ 31 Triangle::Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2){ 32 32 TriaVertices[0]=v0; 33 33 TriaVertices[1]=v1; … … 155 155 /*}}}1*/ 156 156 /*FUNCTION Triangle::Quadrangle {{{1*/ 157 Triangle* Triangle::Quadrangle( Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const{157 Triangle* Triangle::Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const{ 158 158 // return the other triangle of the quad if a quad or 0 if not a quat 159 159 Triangle * t =0; … … 187 187 q= -1; 188 188 else if(option){ 189 const Vertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]];190 const Vertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]];191 const Vertex & v1 = *TriaVertices[OppositeEdge[a]];192 const Vertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]];189 const MeshVertex & v2 = *TriaVertices[VerticesOfTriangularEdge[a][0]]; 190 const MeshVertex & v0 = *TriaVertices[VerticesOfTriangularEdge[a][1]]; 191 const MeshVertex & v1 = *TriaVertices[OppositeEdge[a]]; 192 const MeshVertex & v3 = * t->TriaVertices[OppositeEdge[TriaAdjSharedEdge[a]&3]]; 193 193 q = QuadQuality(v0,v1,v2,v3); // do the float part 194 194 } … … 221 221 if(a2/4 !=0) return 0; // arete lock or MarkUnSwap 222 222 223 register Vertex *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]];224 register Vertex *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]];225 register Vertex *s1=t1->TriaVertices[OppositeVertex[a1]];226 register Vertex *s2=t2->TriaVertices[OppositeVertex[a2]];223 register MeshVertex *sa=t1->TriaVertices[VerticesOfTriangularEdge[a1][0]]; 224 register MeshVertex *sb=t1->TriaVertices[VerticesOfTriangularEdge[a1][1]]; 225 register MeshVertex *s1=t1->TriaVertices[OppositeVertex[a1]]; 226 register MeshVertex *s2=t2->TriaVertices[OppositeVertex[a2]]; 227 227 228 228 Icoor2 det1=t1->det , det2=t2->det ; -
issm/trunk/src/c/Bamgx/objects/Triangle.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "TriangleAdjacent.h" 13 13 … … 22 22 23 23 private: 24 Vertex* TriaVertices[3]; // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer24 MeshVertex* TriaVertices[3]; // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer 25 25 Triangle* TriaAdjTriangles[3]; // 3 pointers toward the adjacent triangles 26 26 short TriaAdjSharedEdge[3]; // number of the edges in the adjacent triangles the edge number 1 is the edge number TriaAdjSharedEdge[1] in the Adjacent triangle 1 … … 36 36 Triangle() {} 37 37 Triangle(Triangles *Th,long i,long j,long k); 38 Triangle( Vertex *v0,Vertex *v1,Vertex *v2);38 Triangle(MeshVertex *v0,MeshVertex *v1,MeshVertex *v2); 39 39 40 40 //Operators 41 const Vertex & operator[](int i) const {return *TriaVertices[i];};42 Vertex & operator[](int i) {return *TriaVertices[i];};43 const Vertex * operator()(int i) const {return TriaVertices[i];};44 Vertex * & operator()(int i) {return TriaVertices[i];};41 const MeshVertex & operator[](int i) const {return *TriaVertices[i];}; 42 MeshVertex & operator[](int i) {return *TriaVertices[i];}; 43 const MeshVertex * operator()(int i) const {return TriaVertices[i];}; 44 MeshVertex * & operator()(int i) {return TriaVertices[i];}; 45 45 46 46 //Methods … … 57 57 TriangleAdjacent Adj(int i) const {return TriangleAdjacent(TriaAdjTriangles[i],TriaAdjSharedEdge[i]&3);}; 58 58 Triangle* TriangleAdj(int i) const {return TriaAdjTriangles[i&3];} 59 Triangle* Quadrangle( Vertex * & v0,Vertex * & v1,Vertex * & v2,Vertex * & v3) const ;59 Triangle* Quadrangle(MeshVertex * & v0,MeshVertex * & v1,MeshVertex * & v2,MeshVertex * & v3) const ; 60 60 void ReNumbering(Triangle *tb,Triangle *te, long *renu){ 61 61 if (link >=tb && link <te) link = tb + renu[link -tb]; … … 64 64 if (TriaAdjTriangles[2] >=tb && TriaAdjTriangles[2] <te) TriaAdjTriangles[2] = tb + renu[TriaAdjTriangles[2]-tb]; 65 65 } 66 void ReNumbering( Vertex *vb,Vertex *ve, long *renu){66 void ReNumbering(MeshVertex *vb,MeshVertex *ve, long *renu){ 67 67 if (TriaVertices[0] >=vb && TriaVertices[0] <ve) TriaVertices[0] = vb + renu[TriaVertices[0]-vb]; 68 68 if (TriaVertices[1] >=vb && TriaVertices[1] <ve) TriaVertices[1] = vb + renu[TriaVertices[1]-vb]; … … 123 123 double qualite() ; 124 124 void Set(const Triangle &,const Triangles &,Triangles &); 125 int In( Vertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;}125 int In(MeshVertex *v) const { return TriaVertices[0]==v || TriaVertices[1]==v || TriaVertices[2]==v ;} 126 126 127 127 }; -
issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.cpp
r3332 r3407 41 41 /*}}}*/ 42 42 /*FUNCTION TriangleAdjacent::EdgeVertex {{{1*/ 43 Vertex* TriangleAdjacent::EdgeVertex(const int & i) const {43 MeshVertex* TriangleAdjacent::EdgeVertex(const int & i) const { 44 44 return t->TriaVertices[VerticesOfTriangularEdge[a][i]]; 45 45 } 46 46 /*}}}*/ 47 47 /*FUNCTION TriangleAdjacent::OppositeVertex {{{1*/ 48 Vertex* TriangleAdjacent::OppositeVertex() const {48 MeshVertex* TriangleAdjacent::OppositeVertex() const { 49 49 return t->TriaVertices[bamg::OppositeVertex[a]]; 50 50 } -
issm/trunk/src/c/Bamgx/objects/TriangleAdjacent.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 13 13 namespace bamg { … … 43 43 int swap(); 44 44 TriangleAdjacent Adj() const; 45 Vertex* EdgeVertex(const int & i) const;46 Vertex* OppositeVertex() const;45 MeshVertex* EdgeVertex(const int & i) const; 46 MeshVertex* OppositeVertex() const; 47 47 Icoor2& det() const; 48 48 }; -
issm/trunk/src/c/Bamgx/objects/Triangles.cpp
r3354 r3407 267 267 //Vertices 268 268 if (verbose) printf("Reading vertices (%i)\n",nbv); 269 vertices=( Vertex*)xmalloc(nbv*sizeof(Vertex));270 ordre=( Vertex**)xmalloc(nbv*sizeof(Vertex*));269 vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex)); 270 ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*)); 271 271 for (i=0;i<nbv;i++){ 272 272 vertices[i].r.x=x[i]; … … 319 319 if(verbose>5) printf(" processing Vertices\n"); 320 320 321 vertices=( Vertex*)xmalloc(nbv*sizeof(Vertex));322 ordre=( Vertex**)xmalloc(nbv*sizeof(Vertex*));321 vertices=(MeshVertex*)xmalloc(nbv*sizeof(MeshVertex)); 322 ordre=(MeshVertex**)xmalloc(nbv*sizeof(MeshVertex*)); 323 323 324 324 for (i=0;i<nbv;i++){ … … 450 450 for (i=0;i<nbe;i++){ 451 451 for (j=0;j<2;j++) { 452 Vertex *v=edges[i].v[j];452 MeshVertex *v=edges[i].v[j]; 453 453 long i0=v->color,j0; 454 454 if(i0==-1){ … … 726 726 Triangle &t =triangles[i]; 727 727 Triangle* ta; 728 Vertex *v0,*v1,*v2,*v3;728 MeshVertex *v0,*v1,*v2,*v3; 729 729 if (reft[i]<0) continue; 730 730 if ((ta=t.Quadrangle(v0,v1,v2,v3)) !=0 && &t<ta) { … … 775 775 VertexOnGeom &v=VerticesOnGeomVertex[i]; 776 776 ISSMASSERT(v.OnGeomVertex()); 777 bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number(( Vertex*)v)+1; //back to Matlab indexing777 bamgmesh->VerticesOnGeometricVertex[i*2+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing 778 778 bamgmesh->VerticesOnGeometricVertex[i*2+1]=Gh.Number((GeometricalVertex*)v)+1; //back to Matlab indexing 779 779 } … … 791 791 ISSMERROR(exprintf("A vertices supposed to be OnGeometricEdge is actually not")); 792 792 } 793 bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number(( Vertex*)v)+1; //back to Matlab indexing793 bamgmesh->VerticesOnGeometricEdge[i*3+0]=Number((MeshVertex*)v)+1; //back to Matlab indexing 794 794 bamgmesh->VerticesOnGeometricEdge[i*3+1]=Gh.Number((const GeometricalEdge*)v)+1; //back to Matlab indexing 795 795 bamgmesh->VerticesOnGeometricEdge[i*3+2]=(double)v; //absisce … … 1020 1020 for (int j=0;j<2;j++){ 1021 1021 1022 Vertex V;1022 MeshVertex V; 1023 1023 VertexOnGeom GV; 1024 1024 Gh.ProjectOnCurve(edges[i],ss[j],V,GV); … … 1066 1066 /*}}}1*/ 1067 1067 /*FUNCTION Triangles::AddVertex{{{1*/ 1068 void Triangles::AddVertex( Vertex &s,Triangle* t, Icoor2* det3) {1068 void Triangles::AddVertex( MeshVertex &s,Triangle* t, Icoor2* det3) { 1069 1069 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/Add)*/ 1070 1070 // ------------------------------------------- … … 1086 1086 Triangle* tt[3]; 1087 1087 //three vertices of t 1088 Vertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2];1088 MeshVertex &s0 = (*t)[0], &s1=(*t)[1], &s2=(*t)[2]; 1089 1089 //three determinants 1090 1090 Icoor2 det3local[3]; … … 1435 1435 for (j=0;j<2;j++){ 1436 1436 //get current vertex 1437 Vertex* v=edges[i].v[j];1437 MeshVertex* v=edges[i].v[j]; 1438 1438 //get vertex color (i0) 1439 1439 long i0=v->color; … … 1575 1575 for (i=0;i<nbv;i++){ 1576 1576 if((j=colorV[i])>=0){ 1577 Vertex & v = Gh.vertices[j];1577 MeshVertex & v = Gh.vertices[j]; 1578 1578 v = vertices[i]; 1579 1579 v.color =0; … … 2326 2326 delete [] Edgeflags; 2327 2327 2328 //Reset Vertex to On2328 //Reset MeshVertex to On 2329 2329 SetVertexFieldOn(); 2330 2330 … … 2560 2560 ISSMERROR(exprintf("&e==NULL")); 2561 2561 } 2562 Vertex * v0 = e(0),*v1 = e(1);2562 MeshVertex * v0 = e(0),*v1 = e(1); 2563 2563 Triangle *t = v0->t; 2564 2564 int sens = Gh.subdomains[i].sens; … … 2640 2640 ISSMERROR(exprintf("no starting triangle provided and no quadtree available")); 2641 2641 } 2642 Vertex *a = quadtree->NearestVertex(B.x,B.y) ;2642 MeshVertex *a = quadtree->NearestVertex(B.x,B.y) ; 2643 2643 2644 2644 if (!a || !a->t ) { … … 2739 2739 R2 AB; 2740 2740 GeometricalVertex *a,*b; 2741 Vertex *va,*vb;2741 MeshVertex *va,*vb; 2742 2742 GeometricalEdge * e; 2743 2743 … … 3118 3118 if (vog.IsRequiredVertex()){ 3119 3119 GeometricalVertex* gv=vog; 3120 Vertex *bv = vog;3120 MeshVertex *bv = vog; 3121 3121 ISSMASSERT(gv->to); // use of Geom -> Th 3122 3122 VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->to,bv); … … 3205 3205 long i=0;// index of new points on the curve 3206 3206 register GeometricalVertex * GA0 = *(*peequi)[k0equi].onGeometry; 3207 Vertex *A0;3207 MeshVertex *A0; 3208 3208 A0 = GA0->to; // the vertex in new mesh 3209 Vertex *A1;3209 MeshVertex *A1; 3210 3210 VertexOnGeom *GA1; 3211 3211 Edge* PreviousNewEdge = 0; … … 3225 3225 ISSMASSERT(pe && ee.onGeometry); 3226 3226 ee.onGeometry->SetMark(); 3227 Vertex & v0=ee[0], & v1=ee[1];3227 MeshVertex & v0=ee[0], & v1=ee[1]; 3228 3228 R2 AB=(R2)v1-(R2)v0; 3229 3229 double L0=L,LAB; … … 3431 3431 * the initial simple mesh from this edge and 2 boundary triangles*/ 3432 3432 3433 Vertex * v0=ordre[0], *v1=ordre[1];3433 MeshVertex * v0=ordre[0], *v1=ordre[1]; 3434 3434 3435 3435 nbt = 2; … … 3471 3471 3472 3472 //Get new vertex 3473 Vertex *newvertex=ordre[icount];3473 MeshVertex *newvertex=ordre[icount]; 3474 3474 3475 3475 //Find the triangle in which newvertex is located … … 3548 3548 long iv=nbvold; 3549 3549 for (i=nbvold;i<nbv;i++){ 3550 Vertex &vi=*ordre[i];3550 MeshVertex &vi=*ordre[i]; 3551 3551 vi.i=toI2(vi.r); 3552 3552 vi.r=toR2(vi.i); … … 3556 3556 if (!quadtree->ToClose(vi,seuil,hi,hj)){ 3557 3557 // a good new point 3558 Vertex &vj = vertices[iv];3558 MeshVertex &vj = vertices[iv]; 3559 3559 long j=vj.ReferenceNumber; 3560 3560 if (&vj!=ordre[j]){ … … 3703 3703 Triangle &tt = *t.TriangleAdj(j); 3704 3704 if ( ! &tt || it < Number(tt) && ( tt.link || t.link)){ 3705 Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];3706 Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];3705 MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]]; 3706 MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]]; 3707 3707 R2 AB= (R2) v1-(R2) v0; 3708 3708 Metric M = v0; … … 3762 3762 /*}}}1*/ 3763 3763 /*FUNCTION Triangles::NearestVertex{{{1*/ 3764 Vertex* Triangles::NearestVertex(Icoor1 i,Icoor1 j) {3764 MeshVertex* Triangles::NearestVertex(Icoor1 i,Icoor1 j) { 3765 3765 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/NearestVertex)*/ 3766 3766 return quadtree->NearestVertex(i,j); … … 3787 3787 if (verbosity>5) printf(" Inserting initial mesh points\n"); 3788 3788 for (i=0;i<Bh.nbv;i++){ 3789 Vertex &bv=Bh[i];3789 MeshVertex &bv=Bh[i]; 3790 3790 if (!bv.onGeometry){ 3791 3791 vertices[nbv].r = bv.r; … … 3826 3826 for(j=0;j<3;j++){ 3827 3827 TriangleAdjacent tj(t,j); 3828 Vertex &vA = *tj.EdgeVertex(0);3829 Vertex &vB = *tj.EdgeVertex(1);3828 MeshVertex &vA = *tj.EdgeVertex(0); 3829 MeshVertex &vB = *tj.EdgeVertex(1); 3830 3830 3831 3831 //if t is a boundary triangle, or tj locked, continue … … 3858 3858 // for all the triangle containing the vertex i 3859 3859 for (i=nbvold;i<nbv;i++){ 3860 Vertex* s = vertices + i;3860 MeshVertex* s = vertices + i; 3861 3861 TriangleAdjacent ta(s->t, EdgesVertexTriangle[s->vint][1]); 3862 3862 Triangle* tbegin= (Triangle*) ta; … … 3917 3917 3918 3918 if (inbvx) { 3919 vertices=new Vertex[nbvx];3919 vertices=new MeshVertex[nbvx]; 3920 3920 if (!vertices){ 3921 3921 ISSMERROR(exprintf("!vertices")); 3922 3922 } 3923 ordre=new ( Vertex* [nbvx]);3923 ordre=new (MeshVertex* [nbvx]); 3924 3924 if (!ordre){ 3925 3925 ISSMERROR(exprintf("!ordre")); … … 3948 3948 /*}}}1*/ 3949 3949 /*FUNCTION Triangles::ProjectOnCurve{{{1*/ 3950 GeometricalEdge* Triangles::ProjectOnCurve( Edge & BhAB, Vertex & vA,Vertex & vB,3951 double theta, Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR) {3950 GeometricalEdge* Triangles::ProjectOnCurve( Edge & BhAB, MeshVertex & vA, MeshVertex & vB, 3951 double theta,MeshVertex & R,VertexOnEdge & BR,VertexOnGeom & GR) { 3952 3952 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshQuad.cpp/ProjectOnCurve)*/ 3953 3953 … … 3955 3955 double tA=0,tB=0; 3956 3956 R2 A=vA,B=vB; 3957 Vertex * pvA=&vA, * pvB=&vB;3957 MeshVertex * pvA=&vA, * pvB=&vB; 3958 3958 if (vA.vint == IsVertexOnVertex){ 3959 3959 pA=vA.onBackgroundVertex; … … 3964 3964 } 3965 3965 else { 3966 ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA)));3966 ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vA))); 3967 3967 } 3968 3968 … … 3975 3975 } 3976 3976 else { 3977 ISSMERROR(exprintf("ProjectOnCurve On Vertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB)));3977 ISSMERROR(exprintf("ProjectOnCurve On MeshVertex %i forget call to SetVertexFieldOnBTh",BTh.Number(vB))); 3978 3978 } 3979 3979 Edge * e = &BhAB; … … 4026 4026 // 2 for find the vertex 4027 4027 int iii; 4028 Vertex *v0=pvA,*v1;4028 MeshVertex *v0=pvA,*v1; 4029 4029 Edge *neee,*eee; 4030 4030 double lg =0; // length of the curve … … 4227 4227 4228 4228 /*Reconstruct mesh beginning with 2 triangles*/ 4229 Vertex * v0=ordre[0], *v1=ordre[1];4229 MeshVertex * v0=ordre[0], *v1=ordre[1]; 4230 4230 4231 4231 triangles[0](0) = NULL; // Infinite vertex … … 4260 4260 long NbSwap=0; 4261 4261 for (int icount=2; icount<nbvb; icount++) { 4262 Vertex *vi = ordre[icount];4262 MeshVertex *vi = ordre[icount]; 4263 4263 Icoor2 dete[3]; 4264 4264 Triangle *tcvi = FindTriangleContaining(vi->i,dete); … … 4273 4273 for ( i = 0; i < nbe; i++){ 4274 4274 if (st[i] >=0){ //edge alone => on border 4275 Vertex &a=edges[i][0], &b=edges[i][1];4275 MeshVertex &a=edges[i][0], &b=edges[i][1]; 4276 4276 if (a.t && b.t){ 4277 4277 knbe++; … … 4298 4298 // change the link of ta; 4299 4299 int ja = ta; 4300 Vertex *v0= ta.EdgeVertex(0);4301 Vertex *v1= ta.EdgeVertex(1);4300 MeshVertex *v0= ta.EdgeVertex(0); 4301 MeshVertex *v1= ta.EdgeVertex(1); 4302 4302 long k =edge4->SortAndAdd(v0?Number(v0):nbv,v1? Number(v1):nbv); 4303 4303 … … 4313 4313 for (i=0;i<nbt;i++){ 4314 4314 if (triangles[i].link) { 4315 triangles[i]=Triangle(( Vertex *) NULL,(Vertex *) NULL,(Vertex *) NULL);4315 triangles[i]=Triangle((MeshVertex *) NULL,(MeshVertex *) NULL,(MeshVertex *) NULL); 4316 4316 triangles[i].color=-1; 4317 4317 } … … 4379 4379 printf("This edge is on geometrical edge number %i\n",Gh.Number(edges[i].onGeometry)+1); 4380 4380 if (edges[i][j].onGeometry->OnGeomVertex()) 4381 printf("the vertex number %i of this edge is a geometric Vertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1);4381 printf("the vertex number %i of this edge is a geometric MeshVertex number %i\n",Gh.Number(edges[i][j].onGeometry->gv)+1); 4382 4382 else if (edges[i][j].onGeometry->OnGeomEdge()) 4383 4383 printf("the vertex number %i of this edge is a geometric Edge number %i\n",Gh.Number(edges[i][j].onGeometry->ge)+1); … … 4471 4471 // from on mesh to over mesh 4472 4472 // -- so do ReNumbering at the beginning 4473 Vertex * ve = vertices+nbv;4473 MeshVertex * ve = vertices+nbv; 4474 4474 long it,ie,i; 4475 4475 … … 4485 4485 for (i=0;i< NbVerticesOnGeomVertex;i++) 4486 4486 { 4487 Vertex *v = VerticesOnGeomVertex[i].mv;4487 MeshVertex *v = VerticesOnGeomVertex[i].mv; 4488 4488 if (v>=vertices && v < ve) 4489 4489 VerticesOnGeomVertex[i].mv=vertices+renu[Number(v)]; … … 4493 4493 for (i=0;i< NbVerticesOnGeomEdge;i++) 4494 4494 { 4495 Vertex *v =VerticesOnGeomEdge[i].mv;4495 MeshVertex *v =VerticesOnGeomEdge[i].mv; 4496 4496 if (v>=vertices && v < ve) 4497 4497 VerticesOnGeomEdge[i].mv=vertices+renu[Number(v)]; … … 4501 4501 for (i=0;i< NbVertexOnBThVertex;i++) 4502 4502 { 4503 Vertex *v=VertexOnBThVertex[i].v;4503 MeshVertex *v=VertexOnBThVertex[i].v; 4504 4504 if (v>=vertices && v < ve) 4505 4505 VertexOnBThVertex[i].v=vertices+renu[Number(v)]; … … 4508 4508 for (i=0;i< NbVertexOnBThEdge;i++) 4509 4509 { 4510 Vertex *v=VertexOnBThEdge[i].v;4510 MeshVertex *v=VertexOnBThEdge[i].v; 4511 4511 if (v>=vertices && v < ve) 4512 4512 VertexOnBThEdge[i].v=vertices+renu[Number(v)]; … … 4520 4520 { 4521 4521 i=it; 4522 Vertex ti=vertices[i],tj;4522 MeshVertex ti=vertices[i],tj; 4523 4523 while ( (j=renu[i]) >= 0){ 4524 4524 // i is old, and j is new … … 4572 4572 int Nberr=0; 4573 4573 for (i=0;i<nbt;i++) { 4574 Vertex & v0 = triangles[i][0];4575 Vertex & v1 = triangles[i][1];4576 Vertex & v2 = triangles[i][2];4574 MeshVertex & v0 = triangles[i][0]; 4575 MeshVertex & v1 = triangles[i][1]; 4576 MeshVertex & v2 = triangles[i][2]; 4577 4577 4578 4578 //If this is not a boundary triangle … … 4635 4635 hmin=Min(hmin,he); 4636 4636 hmax=Max(hmax,he); 4637 Vertex & v=K[j];4637 MeshVertex & v=K[j]; 4638 4638 D2xD2 M((Metric)v); 4639 4639 betaK += sqrt(M.det()); … … 4680 4680 if ( !ta || !ta->link || Number(ta) >= it) 4681 4681 { 4682 Vertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]];4683 Vertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]];4682 MeshVertex & vP = triangles[it][VerticesOfTriangularEdge[j][0]]; 4683 MeshVertex & vQ = triangles[it][VerticesOfTriangularEdge[j][1]]; 4684 4684 if ( !& vP || !&vQ) continue; 4685 4685 R2 PQ = vQ.r - vP.r; … … 4777 4777 ISSMERROR(exprintf("!t")); 4778 4778 } 4779 Vertex & vi = vertices[i];4779 MeshVertex & vi = vertices[i]; 4780 4780 TriangleAdjacent ta(t,EdgesVertexTriangle[vertices[i].vint][0]); 4781 Vertex *pvj0 = ta.EdgeVertex(0);4781 MeshVertex *pvj0 = ta.EdgeVertex(0); 4782 4782 while (1) { 4783 4783 ta=Previous(Adj(ta)); … … 4785 4785 ISSMERROR(exprintf("vertices+i != ta.EdgeVertex(1)")); 4786 4786 } 4787 Vertex & vj = *(ta.EdgeVertex(0));4787 MeshVertex & vj = *(ta.EdgeVertex(0)); 4788 4788 if ( &vj ) { 4789 4789 j= &vj-vertices; … … 4924 4924 // get the Info on background mesh 4925 4925 double s = newVertexOnBThEdge[kvb]; 4926 Vertex & bv0 = newVertexOnBThEdge[kvb][0];4927 Vertex & bv1 = newVertexOnBThEdge[kvb][1];4926 MeshVertex & bv0 = newVertexOnBThEdge[kvb][0]; 4927 MeshVertex & bv1 = newVertexOnBThEdge[kvb][1]; 4928 4928 // compute the metrix of the new points 4929 4929 vertices[k].m = Metric(1-s,bv0,s,bv1); … … 4993 4993 if (&tt >= lastT) 4994 4994 t.SetAdj2(j,0,0);// unset adj 4995 const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];4996 const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];4995 const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]]; 4996 const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]]; 4997 4997 long ke =edge4->SortAndFind(Number(v0),Number(v1)); 4998 4998 if (ke>0) … … 5004 5004 if (ii<nbt) // good triangle 5005 5005 kedge[3*ii+jj] = ks; 5006 Vertex &A=vertices[ks];5006 MeshVertex &A=vertices[ks]; 5007 5007 double aa,bb,cc,dd; 5008 5008 if ((dd=Area2(v0.r,v1.r,A.r)) >=0){ … … 5042 5042 5043 5043 5044 const Vertex & v0 = t[VerticesOfTriangularEdge[j][0]];5045 const Vertex & v1 = t[VerticesOfTriangularEdge[j][1]];5044 const MeshVertex & v0 = t[VerticesOfTriangularEdge[j][0]]; 5045 const MeshVertex & v1 = t[VerticesOfTriangularEdge[j][1]]; 5046 5046 if ( kedge[3*i+j] < 0) 5047 5047 { … … 5122 5122 5123 5123 Triangle &t0=triangles[i]; 5124 Vertex * v0=t0(i0);5125 Vertex * v1=t0(i1);5126 Vertex * v2=t0(i2);5124 MeshVertex * v0=t0(i0); 5125 MeshVertex * v1=t0(i1); 5126 MeshVertex * v2=t0(i2); 5127 5127 5128 5128 if (nbmkadj>=10){ … … 5147 5147 ISSMERROR(exprintf("kedge[3*i+i0]<0")); 5148 5148 } 5149 Vertex * v3 = vertices + kedge[3*i+k0];5149 MeshVertex * v3 = vertices + kedge[3*i+k0]; 5150 5150 5151 5151 t0(i2) = v3; … … 5167 5167 } 5168 5168 5169 Vertex * v01 = vertices + kedge[3*i+k2];5170 Vertex * v02 = vertices + kedge[3*i+k1];5169 MeshVertex * v01 = vertices + kedge[3*i+k2]; 5170 MeshVertex * v02 = vertices + kedge[3*i+k1]; 5171 5171 t0(i1) = v01; 5172 5172 t0(i2) = v02; … … 5190 5190 ISSMERROR(exprintf("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0")); 5191 5191 } 5192 Vertex * v12 = vertices + kedge[3*i+k0];5193 Vertex * v02 = vertices + kedge[3*i+k1];5194 Vertex * v01 = vertices + kedge[3*i+k2];5192 MeshVertex * v12 = vertices + kedge[3*i+k0]; 5193 MeshVertex * v02 = vertices + kedge[3*i+k1]; 5194 MeshVertex * v01 = vertices + kedge[3*i+k2]; 5195 5195 t0(i1) = v01; 5196 5196 t0(i2) = v02; … … 5237 5237 double a3[]={1./3.,1./3.,1./3.}; 5238 5238 vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m); 5239 Vertex * vc = vertices +nbv++;5239 MeshVertex * vc = vertices +nbv++; 5240 5240 t3(i0) = vc; 5241 5241 t4(i1) = vc; … … 5353 5353 if ( &tt && tt.link && it < Number(tt)) 5354 5354 { // an internal edge 5355 Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];5356 Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];5355 MeshVertex &v0 = t[VerticesOfTriangularEdge[j][0]]; 5356 MeshVertex &v1 = t[VerticesOfTriangularEdge[j][1]]; 5357 5357 if (v0.onGeometry && v1.onGeometry){ 5358 5358 R2 P= ((R2) v0 + (R2) v1)*0.5; … … 5374 5374 Icoor2 dete[3]; 5375 5375 for (int i=nbvold;i<nbv;i++) {// for all the new point 5376 Vertex & vi = vertices[i];5376 MeshVertex & vi = vertices[i]; 5377 5377 vi.i = toI2(vi.r); 5378 5378 vi.r = toR2(vi.i); … … 5477 5477 ISSMERROR(exprintf("kkk>=1000")); 5478 5478 } 5479 Vertex &vI = *edge.EdgeVertex(0);5480 Vertex &vJ = *edge.EdgeVertex(1);5479 MeshVertex &vI = *edge.EdgeVertex(0); 5480 MeshVertex &vJ = *edge.EdgeVertex(1); 5481 5481 I2 I=vI, J=vJ, IJ= J-I; 5482 5482 IJ_IA = (IJ ,(A-I)); … … 5518 5518 // the probleme is in case of the fine and long internal hole 5519 5519 // for exemple neart the training edge of a wing 5520 Vertex * s=0,*s1=0, *s0=0;5520 MeshVertex * s=0,*s1=0, *s0=0; 5521 5521 Icoor2 imax = MaxICoor22; 5522 5522 Icoor2 l0 = imax,l1 = imax; … … 5605 5605 if ((link + linkp) == 1) 5606 5606 { // a boundary edge 5607 Vertex * st = edge.EdgeVertex(1);5607 MeshVertex * st = edge.EdgeVertex(1); 5608 5608 I2 I=*st; 5609 5609 Icoor2 ll = Norme2_2 (C-I); … … 5650 5650 /*}}}1*/ 5651 5651 /*FUNCTION ForceEdge{{{1*/ 5652 int ForceEdge( Vertex &a,Vertex & b,TriangleAdjacent & taret) {5652 int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret) { 5653 5653 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/ForceEdge)*/ 5654 5654 … … 5661 5661 5662 5662 TriangleAdjacent tta(a.t,EdgesVertexTriangle[a.vint][0]); 5663 Vertex *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2;5663 MeshVertex *v1, *v2 = tta.EdgeVertex(0),*vbegin =v2; 5664 5664 // we turn around a in the direct sens 5665 5665 … … 5686 5686 if((det1 < 0) && (det2 >0)) { 5687 5687 // try to force the edge 5688 Vertex * va = &a, *vb = &b;5688 MeshVertex * va = &a, *vb = &b; 5689 5689 tc = Previous(tc); 5690 5690 if (!v1 || !v2){ … … 5696 5696 ISSMERROR(exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l)); 5697 5697 } 5698 Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);5698 MeshVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1); 5699 5699 if (( aa == &a ) && (bb == &b) || (bb == &a ) && (aa == &b)) { 5700 5700 tc.SetLock(); … … 5726 5726 /*}}}1*/ 5727 5727 /*FUNCTION swap{{{1*/ 5728 void swap(Triangle *t1,short a1, Triangle *t2,short a2, Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2){5728 void swap(Triangle *t1,short a1, Triangle *t2,short a2, MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2){ 5729 5729 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/swap)*/ 5730 5730 // -------------------------------------------------------------- … … 5771 5771 /*}}}1*/ 5772 5772 /*FUNCTION SwapForForcingEdge{{{1*/ 5773 int SwapForForcingEdge( Vertex * & pva ,Vertex * & pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) {5773 int SwapForForcingEdge(MeshVertex * & pva ,MeshVertex * & pvb ,TriangleAdjacent & tt1,Icoor2 & dets1, Icoor2 & detsa,Icoor2 & detsb, int & NbSwap) { 5774 5774 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/SwapForForcingEdge)*/ 5775 5775 // l'arete ta coupe l'arete pva pvb … … 5788 5788 } 5789 5789 5790 Vertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]];5791 Vertex & s1= (*t1)[OppositeVertex[a1]];5792 Vertex & s2= (*t2)[OppositeVertex[a2]];5790 MeshVertex & sa= (* t1)[VerticesOfTriangularEdge[a1][0]]; 5791 MeshVertex & s1= (*t1)[OppositeVertex[a1]]; 5792 MeshVertex & s2= (*t2)[OppositeVertex[a2]]; 5793 5793 5794 5794 -
issm/trunk/src/c/Bamgx/objects/Triangles.h
r3391 r3407 14 14 #include "DoubleAndInt.h" 15 15 #include "Direction.h" 16 #include " BamgVertex.h"16 #include "MeshVertex.h" 17 17 #include "TriangleAdjacent.h" 18 18 #include "Edge.h" … … 48 48 long NbOfTriangleSearchFind; 49 49 long NbOfSwapTriangle; 50 Vertex* vertices;50 MeshVertex* vertices; 51 51 long NbVerticesOnGeomVertex; 52 52 VertexOnGeom * VerticesOnGeomVertex; … … 66 66 Edge* edges; 67 67 QuadTree* quadtree; 68 Vertex** ordre;68 MeshVertex** ordre; 69 69 SubDomain* subdomains; 70 70 ListofIntersectionTriangles lIntTria; … … 86 86 87 87 //Operators 88 const Vertex & operator[] (long i) const { return vertices[i];};89 Vertex & operator[](long i) { return vertices[i];};88 const MeshVertex & operator[] (long i) const { return vertices[i];}; 89 MeshVertex & operator[](long i) { return vertices[i];}; 90 90 const Triangle & operator() (long i) const { return triangles[i];}; 91 91 Triangle & operator()(long i) { return triangles[i];}; … … 101 101 return R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y); 102 102 } 103 void AddVertex( Vertex & s,Triangle * t,Icoor2 * =0) ;103 void AddVertex(MeshVertex & s,Triangle * t,Icoor2 * =0) ; 104 104 void Insert(); 105 105 void ForceBoundary(); … … 124 124 void SmoothingVertex(int =3,double=0.3); 125 125 Metric MetricAt (const R2 &) const; 126 GeometricalEdge* ProjectOnCurve( Edge & AB, Vertex & A, Vertex & B,double theta,Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);126 GeometricalEdge* ProjectOnCurve( Edge & AB, MeshVertex & A, MeshVertex & B,double theta, MeshVertex & R,VertexOnEdge & BR,VertexOnGeom & GR); 127 127 long Number(const Triangle & t) const { return &t - triangles;} 128 128 long Number(const Triangle * t) const { return t - triangles;} 129 long Number(const Vertex & t) const { return &t - vertices;}130 long Number(const Vertex * t) const { return t - vertices;}129 long Number(const MeshVertex & t) const { return &t - vertices;} 130 long Number(const MeshVertex * t) const { return t - vertices;} 131 131 long Number(const Edge & t) const { return &t - edges;} 132 132 long Number(const Edge * t) const { return t - edges;} 133 133 long Number2(const Triangle * t) const { return t - triangles; } 134 Vertex* NearestVertex(Icoor1 i,Icoor1 j) ;134 MeshVertex* NearestVertex(Icoor1 i,Icoor1 j) ; 135 135 Triangle* FindTriangleContaining(const I2 & ,Icoor2 [3],Triangle *tstart=0) const; 136 136 void ReadMesh(double* index,double* x,double* y,int nods,int nels); … … 180 180 void swap(Triangle *t1,short a1, 181 181 Triangle *t2,short a2, 182 Vertex *s1,Vertex *s2,Icoor2 det1,Icoor2 det2);183 int SwapForForcingEdge( Vertex * & pva ,Vertex * & pvb ,182 MeshVertex *s1,MeshVertex *s2,Icoor2 det1,Icoor2 det2); 183 int SwapForForcingEdge(MeshVertex * & pva ,MeshVertex * & pvb , 184 184 TriangleAdjacent & tt1,Icoor2 & dets1, 185 185 Icoor2 & detsa,Icoor2 & detsb, int & nbswap); 186 int ForceEdge( Vertex &a,Vertex & b,TriangleAdjacent & taret) ;186 int ForceEdge(MeshVertex &a, MeshVertex & b,TriangleAdjacent & taret) ; 187 187 inline TriangleAdjacent Previous(const TriangleAdjacent & ta){ 188 188 return TriangleAdjacent(ta.t,PreviousEdge[ta.a]); … … 197 197 int j=i;i=on->DirAdj[i];on=on->Adj[j]; 198 198 } 199 inline double qualite(const Vertex &va,const Vertex &vb,constVertex &vc){199 inline double qualite(const MeshVertex &va,const MeshVertex &vb,const MeshVertex &vc){ 200 200 double ret; 201 201 I2 ia=va,ib=vb,ic=vc; -
issm/trunk/src/c/Bamgx/objects/VertexOnEdge.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "Edge.h" 13 13 … … 20 20 21 21 public: 22 Vertex* v;22 MeshVertex* v; 23 23 Edge* be; 24 24 double abcisse; 25 25 26 26 //Constructors 27 VertexOnEdge( Vertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {}27 VertexOnEdge( MeshVertex * w, Edge *bw,double s) :v(w),be(bw),abcisse(s) {} 28 28 VertexOnEdge(){} 29 29 30 30 //Operators 31 31 operator double () const { return abcisse;} 32 operator Vertex* () const { return v;}32 operator MeshVertex* () const { return v;} 33 33 operator Edge* () const { return be;} 34 Vertex & operator[](int i) const { return (*be)[i];}34 MeshVertex & operator[](int i) const { return (*be)[i];} 35 35 36 36 //Methods -
issm/trunk/src/c/Bamgx/objects/VertexOnGeom.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 #include "GeometricalVertex.h" 13 13 #include "GeometricalEdge.h" … … 22 22 public: 23 23 24 Vertex* mv;24 MeshVertex* mv; 25 25 double abscisse; 26 26 union{ … … 31 31 //Constructors/Destructors 32 32 VertexOnGeom(): mv(0),abscisse(0){gv=0;} 33 VertexOnGeom( Vertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;}34 VertexOnGeom( Vertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;}33 VertexOnGeom(MeshVertex & m,GeometricalVertex &g) : mv(&m),abscisse(-1){gv=&g;} 34 VertexOnGeom(MeshVertex & m,GeometricalEdge &g,double s) : mv(&m),abscisse(s){ge=&g;} 35 35 36 36 //Operators 37 operator Vertex*() const {return mv;}37 operator MeshVertex*() const {return mv;} 38 38 operator GeometricalVertex * () const {return gv;} 39 39 operator GeometricalEdge * () const {return ge;} -
issm/trunk/src/c/Bamgx/objects/VertexOnVertex.h
r3391 r3407 9 9 #include "../include/typedefs.h" 10 10 #include "../include/macros.h" 11 #include " BamgVertex.h"11 #include "MeshVertex.h" 12 12 13 13 namespace bamg { … … 19 19 20 20 public: 21 Vertex* v;22 Vertex* bv;21 MeshVertex* v; 22 MeshVertex* bv; 23 23 24 24 //Constructors 25 VertexOnVertex( Vertex * w,Vertex *bw) :v(w),bv(bw){}25 VertexOnVertex(MeshVertex * w,MeshVertex *bw) :v(w),bv(bw){} 26 26 VertexOnVertex() {}; 27 27
Note:
See TracChangeset
for help on using the changeset viewer.