Changeset 2945 for issm/trunk


Ignore:
Timestamp:
02/03/10 13:31:41 (15 years ago)
Author:
Mathieu Morlighem
Message:

minor renaming

Location:
issm/trunk/src/c/Bamgx
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/Bamgx/Mesh2.h

    r2942 r2945  
    123123                                Int4 color;
    124124                                Vertex * to;// use in geometry Vertex to now the Mesh Vertex associed
    125                                 VertexOnGeom * on;     // if vint 8; // set with Triangles::SetVertexFieldOn()
     125                                VertexOnGeom * onGeometry;     // if vint 8; // set with Triangles::SetVertexFieldOn()
    126126                                Vertex * onbv; // if vint == 16 on Background vertex Triangles::SetVertexFieldOnBTh()
    127127                                VertexOnEdge * onbe;   // if vint == 32 on Background edge
     
    187187                Vertex * v[2];
    188188                Int4 ref;
    189                 GeometricalEdge * on;
     189                GeometricalEdge* onGeometry;
    190190                Vertex & operator[](int i){return *v[i];};
    191191                Vertex * operator()(int i){return v[i];};
     
    410410                        aa[a] |=8 ;
    411411                }
    412 
    413412
    414413                void SetUnMarkUnSwap(int a){
     
    567566                operator const Real8 & () const {return abscisse;}
    568567                int IsRequiredVertex(){ return this? (( abscisse<0 ? (gv?gv->Required():0):0 )) : 0;}
    569                 void SetOn(){mv->on=this;mv->vint=IsVertexOnGeom;}
     568                void SetOn(){mv->onGeometry=this;mv->vint=IsVertexOnGeom;}
    570569                inline void Set(const Triangles &,Int4,Triangles &);
    571570
     
    655654                public:
    656655
    657                         enum TypeFileMesh {
    658                                 AutoMesh=0,BDMesh=1,NOPOMesh=2,amMesh=3,am_fmtMesh=4,amdbaMesh=5,
    659                                 ftqMesh=6,mshMesh=7};
    660 
    661656                        int static counter; // to kown the number of mesh in memory
    662657                        Geometry & Gh;   // Geometry
     
    689684                        VertexOnEdge *VertexOnBThEdge;
    690685
    691 
    692686                        Int4 NbCrackedVertices;
    693 
    694687
    695688                        Int4 NbCrackedEdges;
    696689                        CrackedEdge *CrackedEdges;
    697 
    698690
    699691                        R2 pmin,pmax; // extrema
     
    711703                        Triangles(Int4 i);//:BTh(*this),Gh(*new Geometry()){PreInit(i);}
    712704
    713 
    714705                        ~Triangles();
    715706                        Triangles(const char * ,Real8=-1) ;
     
    730721                        Triangles(const Triangles &,const int *flag,const int *bb); // truncature
    731722
    732                                                  void SetIntCoor(const char * from =0);
    733 
    734                                                  // void  RandomInit();
    735                                                  // void  CubeInit(int ,int);
    736 
    737                                                  Real8 MinimalHmin() {return 2.0/coefIcoor;}
    738                                                  Real8 MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
    739                                                  const Vertex & operator[]  (Int4 i) const { return vertices[i];};
    740                                                  Vertex & operator[](Int4 i) { return vertices[i];};
    741                                                  const Triangle & operator()  (Int4 i) const { return triangles[i];};
    742                                                  Triangle & operator()(Int4 i) { return triangles[i];};
    743                                                  I2 toI2(const R2 & P) const {
    744                                                          return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x))
    745                                                                                  ,(Icoor1) (coefIcoor*(P.y-pmin.y)) );}
    746                                                  R2 toR2(const I2 & P) const {
    747                                                          return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);}
    748                                                  void Add( Vertex & s,Triangle * t,Icoor2 *  =0) ;
    749                                                  void Insert();
    750                                                  //  void InsertOld();
    751                                                  void ForceBoundary();
    752                                                  void Heap();
    753                                                  void FindSubDomain(int OutSide=0);
    754                                                  Int4  ConsRefTriangle(Int4 *) const;
    755                                                  void ShowHistogram() const;
    756                                                  void  ShowRegulaty() const; // Add FH avril 2007
    757                                                  //  void ConsLinkTriangle();
    758 
    759                                                  void ReMakeTriangleContainingTheVertex();
    760                                                  void UnMarkUnSwapTriangle();
    761                                                  void SmoothMetric(Real8 raisonmax) ;
    762                                                  void BoundAnisotropy(Real8 anisomax,double hminaniso= 1e-100) ;
    763                                                  void MaxSubDivision(Real8 maxsubdiv);
    764                                                  Edge** MakeGeometricalEdgeToEdge();
    765                                                  void  SetVertexFieldOn(); 
    766                                                  void  SetVertexFieldOnBTh();
    767                                                  Int4 SplitInternalEdgeWithBorderVertices();
    768                                                  void MakeQuadrangles(double costheta);
    769                                                  int SplitElement(int choice);
    770                                                  void MakeQuadTree();
    771                                                  void NewPoints( Triangles &,int KeepVertices =1 );
    772                                                  Int4 InsertNewPoints(Int4 nbvold,Int4 & NbTSwap) ;
    773                                                  void NewPoints(int KeepVertices=1){ NewPoints(*this,KeepVertices);}
    774                                                  void ReNumberingTheTriangleBySubDomain(bool justcompress=false);
    775                                                  void ReNumberingVertex(Int4 * renu);
    776                                                  void SmoothingVertex(int =3,Real8=0.3);
    777                                                  Metric MetricAt (const R2 &) const;
    778                                                  GeometricalEdge * ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,Real8 theta,
    779                                                                          Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
    780 
    781                                                  Int4 Number(const Triangle & t) const  { return &t - triangles;}
    782                                                  Int4 Number(const Triangle * t) const  { return t - triangles;}
    783                                                  Int4 Number(const Vertex & t) const  { return &t - vertices;}
    784                                                  Int4 Number(const Vertex * t) const  { return t - vertices;}
    785                                                  Int4 Number(const Edge & t) const  { return &t - edges;}
    786                                                  Int4 Number(const Edge * t) const  { return t - edges;}
    787                                                  Int4 Number2(const Triangle * t) const  {
    788                                                          //   if(t>= triangles && t < triangles + nbt )
    789                                                          return t - triangles;
    790                                                          //  else  return t - OutSidesTriangles;
    791                                                  }
    792 
    793                                                  Vertex * NearestVertex(Icoor1 i,Icoor1 j) ;
    794                                                  Triangle * FindTriangleContening(const I2 & ,Icoor2 [3],Triangle *tstart=0) const;
    795 
    796                                                  void ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts);
    797                                                  void WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts);
    798 
    799                                                  void ReadMetric(BamgOpts* bamgopts,const Real8 hmin,const Real8 hmax,const Real8 coef);
    800                                                  void WriteMetric(BamgOpts* bamgopts);
    801                                                  void IntersectConsMetric(BamgOpts* bamgopts);
    802                                                  void BuildMetric0(BamgOpts* bamgopts);
    803                                                  void BuildMetric1(BamgOpts* bamgopts);
    804                                                  void IntersectGeomMetric(BamgOpts* bamgopts);
    805 
    806 
    807                                                  int  isCracked() const {return NbCrackedVertices != 0;}
    808                                                  int  Crack();
    809                                                  int UnCrack();
    810 
    811                                                  void ConsGeometry(Real8 =-1.0,int *equiedges=0); // construct a geometry if no geo
    812                                                  void FillHoleInMesh() ;
    813                                                  int CrackMesh();
     723                        void SetIntCoor(const char * from =0);
     724
     725                        Real8 MinimalHmin() {return 2.0/coefIcoor;}
     726                        Real8 MaximalHmax() {return Max(pmax.x-pmin.x,pmax.y-pmin.y);}
     727                        const Vertex & operator[]  (Int4 i) const { return vertices[i];};
     728                        Vertex & operator[](Int4 i) { return vertices[i];};
     729                        const Triangle & operator()  (Int4 i) const { return triangles[i];};
     730                        Triangle & operator()(Int4 i) { return triangles[i];};
     731                        I2 toI2(const R2 & P) const {
     732                                return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x))
     733                                                        ,(Icoor1) (coefIcoor*(P.y-pmin.y)) );}
     734                        R2 toR2(const I2 & P) const {
     735                                return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
     736                        }
     737                        void Add( Vertex & s,Triangle * t,Icoor2 *  =0) ;
     738                        void Insert();
     739                        void ForceBoundary();
     740                        void Heap();
     741                        void FindSubDomain(int OutSide=0);
     742                        Int4 ConsRefTriangle(Int4 *) const;
     743                        void ShowHistogram() const;
     744                        void ShowRegulaty() const; // Add FH avril 2007
     745
     746                        void ReMakeTriangleContainingTheVertex();
     747                        void UnMarkUnSwapTriangle();
     748                        void SmoothMetric(Real8 raisonmax) ;
     749                        void BoundAnisotropy(Real8 anisomax,double hminaniso= 1e-100) ;
     750                        void MaxSubDivision(Real8 maxsubdiv);
     751                        Edge** MakeGeometricalEdgeToEdge();
     752                        void SetVertexFieldOn(); 
     753                        void SetVertexFieldOnBTh();
     754                        Int4 SplitInternalEdgeWithBorderVertices();
     755                        void MakeQuadrangles(double costheta);
     756                        int SplitElement(int choice);
     757                        void MakeQuadTree();
     758                        void NewPoints( Triangles &,int KeepVertices =1 );
     759                        Int4 InsertNewPoints(Int4 nbvold,Int4 & NbTSwap) ;
     760                        void NewPoints(int KeepVertices=1){ NewPoints(*this,KeepVertices);}
     761                        void ReNumberingTheTriangleBySubDomain(bool justcompress=false);
     762                        void ReNumberingVertex(Int4 * renu);
     763                        void SmoothingVertex(int =3,Real8=0.3);
     764                        Metric MetricAt (const R2 &) const;
     765                        GeometricalEdge * ProjectOnCurve( Edge & AB, Vertex &  A, Vertex & B,Real8 theta,
     766                                                Vertex & R,VertexOnEdge & BR,VertexOnGeom & GR);
     767
     768                        Int4 Number(const Triangle & t) const  { return &t - triangles;}
     769                        Int4 Number(const Triangle * t) const  { return t - triangles;}
     770                        Int4 Number(const Vertex & t) const  { return &t - vertices;}
     771                        Int4 Number(const Vertex * t) const  { return t - vertices;}
     772                        Int4 Number(const Edge & t) const  { return &t - edges;}
     773                        Int4 Number(const Edge * t) const  { return t - edges;}
     774                        Int4 Number2(const Triangle * t) const  {
     775                                //   if(t>= triangles && t < triangles + nbt )
     776                                return t - triangles;
     777                                //  else  return t - OutSidesTriangles;
     778                        }
     779
     780                        Vertex * NearestVertex(Icoor1 i,Icoor1 j) ;
     781                        Triangle * FindTriangleContening(const I2 & ,Icoor2 [3],Triangle *tstart=0) const;
     782
     783                        void ReadMesh(BamgMesh* bamgmesh, BamgOpts* bamgopts);
     784                        void WriteMesh(BamgMesh* bamgmesh,BamgOpts* bamgopts);
     785
     786                        void ReadMetric(BamgOpts* bamgopts,const Real8 hmin,const Real8 hmax,const Real8 coef);
     787                        void WriteMetric(BamgOpts* bamgopts);
     788                        void IntersectConsMetric(BamgOpts* bamgopts);
     789                        void BuildMetric0(BamgOpts* bamgopts);
     790                        void BuildMetric1(BamgOpts* bamgopts);
     791                        void IntersectGeomMetric(BamgOpts* bamgopts);
     792
     793                        int isCracked() const {return NbCrackedVertices != 0;}
     794                        int Crack();
     795                        int UnCrack();
     796
     797                        void ConsGeometry(Real8 =-1.0,int *equiedges=0); // construct a geometry if no geo
     798                        void FillHoleInMesh() ;
     799                        int  CrackMesh();
    814800                private:
    815                                                  void GeomToTriangles1(Int4 nbvx,int KeepVertices=1);// the real constructor mesh adaption
    816                                                  void GeomToTriangles0(Int4 nbvx);// the real constructor mesh generator
    817                                                  void PreInit(Int4,char * =0 );
     801                        void GeomToTriangles1(Int4 nbvx,int KeepVertices=1);// the real constructor mesh adaption
     802                        void GeomToTriangles0(Int4 nbvx);                   // the real constructor mesh generator
     803                        void PreInit(Int4,char* =NULL );
    818804
    819805        };
     
    978964                v[0] = ThNew.vertices + Th.Number(v[0]);   
    979965                v[1] = ThNew.vertices + Th.Number(v[1]);
    980                 if (on)
    981                  on =  ThNew.Gh.edges+Th.Gh.Number(on);
     966                if (onGeometry)
     967                 onGeometry =  ThNew.Gh.edges+Th.Gh.Number(onGeometry);
    982968                if (adj[0]) adj[0] =   ThNew.edges +   Th.Number(adj[0]);
    983969                if (adj[1]) adj[1] =   ThNew.edges +   Th.Number(adj[1]);
     
    10801066        inline  void   Triangles::SetVertexFieldOn(){
    10811067                for (Int4 i=0;i<nbv;i++)
    1082                  vertices[i].on=0;
     1068                 vertices[i].onGeometry=0;
    10831069                for (Int4 j=0;j<NbVerticesOnGeomVertex;j++ )
    10841070                 VerticesOnGeomVertex[j].SetOn();
     
    10881074        inline  void   Triangles::SetVertexFieldOnBTh(){
    10891075                for (Int4 i=0;i<nbv;i++)
    1090                  vertices[i].on=0;
     1076                 vertices[i].onGeometry=0;
    10911077                for (Int4 j=0;j<NbVertexOnBThVertex;j++ )
    10921078                 VertexOnBThVertex[j].SetOnBTh();
  • issm/trunk/src/c/Bamgx/objects/Geometry.cpp

    r2913 r2945  
    342342                else{
    343343                        throw ErrorException(__FUNCT__,exprintf("No edges provided"));
     344                }
     345
     346                //CrackedEdges
     347                if (bamggeom->CrackedEdges){
     348                        if(verbose>3) printf("      processing CrackedEdges\n");
     349                        for (i=0;i<bamggeom->NumCrackedEdges;i++){
     350                                throw ErrorException(__FUNCT__,exprintf("Not implemented yet"));
     351                        }
     352                }
     353                else{
     354                        if(verbose>3) printf("      no CrackedEdges found\n");
    344355                }
    345356
     
    912923        }
    913924        /*}}}1*/
    914         /*FUNCTION  Geometry::Geometry::ProjectOnCurve {{{1*/
     925        /*FUNCTION  Geometry::ProjectOnCurve {{{1*/
    915926        GeometricalEdge* Geometry::ProjectOnCurve(const Edge & e,Real8 s,Vertex &V,VertexOnGeom &GV ) const {
    916927                Real8 save_s=s;
     
    918929retry:   
    919930                s=save_s;
    920                 GeometricalEdge* on = e.on;
     931                GeometricalEdge* on = e.onGeometry;
    921932                if (!on){
    922933                        throw ErrorException(__FUNCT__,exprintf("!on"));
    923934                }
    924                 if (!e[0].on ||  !e[1].on){
     935                if (!e[0].onGeometry ||  !e[1].onGeometry){
    925936                        throw ErrorException(__FUNCT__,exprintf("!e[0].on ||  !e[1].on"));
    926937                }
     
    932943                Real8  lge[mxe+1];
    933944                int bge=mxe/2,tge=bge;
    934                 ge[bge] = e.on;
     945                ge[bge] = e.onGeometry;
    935946                sensge[bge]=1;
    936947
    937948                R2 V0 = v0,V1=v1,V01=V1-V0;
    938                 VertexOnGeom  vg0= *v0.on,  vg1=*v1.on;
     949                VertexOnGeom  vg0= *v0.onGeometry,  vg1=*v1.onGeometry;
    939950
    940951                //    GeometricalEdge * eg0 = e.on,* eg1 = e.on, *eg=NULL;
  • issm/trunk/src/c/Bamgx/objects/Triangles.cpp

    r2944 r2945  
    436436                                        throw ErrorException(__FUNCT__,exprintf("EdgesOnGeometricEdge error: We must have : (i>0 && j >0 && i <= nbe && j <= Gh.nbe)"));
    437437                                }
    438                                 edges[i-1].on = Gh.edges + j-1;
     438                                edges[i-1].onGeometry = Gh.edges + j-1;
    439439                        }
    440440                }
     
    652652                k=0;
    653653                for (i=0;i<nbe;i++){
    654                         if (edges[i].on) k=k+1;
     654                        if (edges[i].onGeometry) k=k+1;
    655655                }
    656656                bamgmesh->NumEdgesOnGeometricEdge=k;
     
    660660                        int count=0;
    661661                        for (i=0;i<nbe;i++){
    662                                 if (edges[i].on){
     662                                if (edges[i].onGeometry){
    663663                                        bamgmesh->EdgesOnGeometricEdge[count*2+0]=(double)i+1; //back to Matlab indexing
    664                                         bamgmesh->EdgesOnGeometricEdge[count*2+1]=(double)Gh.Number(edges[i].on)+1; //back to Matlab indexing
     664                                        bamgmesh->EdgesOnGeometricEdge[count*2+1]=(double)Gh.Number(edges[i].onGeometry)+1; //back to Matlab indexing
    665665                                        count=count+1;
    666666                                }
     
    14981498                                        edges[add].v[0] = &triangles[it][VerticesOfTriangularEdge[j][0]];
    14991499                                        edges[add].v[1] = &triangles[it][VerticesOfTriangularEdge[j][1]];
    1500                                         edges[add].on=0;
     1500                                        edges[add].onGeometry=0;
    15011501                                        if (i<nbeold) // in file edge // Modif FH 06122055
    15021502                                          {
    15031503                                                edges[add].ref = edgessave[i].ref;                   
    1504                                                 edges[add].on = edgessave[i].on; //  HACK pour recuperer les aretes requise midf FH avril 2006 ????
     1504                                                edges[add].onGeometry = edgessave[i].onGeometry; //  HACK pour recuperer les aretes requise midf FH avril 2006 ????
    15051505                                          }
    15061506                                        else
     
    16911691                        Gh.edges[i].tg[0]=R2();
    16921692                        Gh.edges[i].tg[1]=R2();
    1693                         bool requis= edges[i].on;
     1693                        bool requis= edges[i].onGeometry;
    16941694                        if(requis) kreq++;
    1695                         edges[i].on =  Gh.edges + i;
     1695                        edges[i].onGeometry =  Gh.edges + i;
    16961696                        if(equiedges && i < nbeold ) {
    16971697                                int j=equiedges[i]/2;
     
    18051805                        int i,k;
    18061806                        for (k=i=0;i<nbe;i++)
    1807                          if(edges[i].on->Cracked()) k++;
     1807                         if(edges[i].onGeometry->Cracked()) k++;
    18081808                        if( k==0) return 0;
    18091809                        CurrentTh = this;
     
    18221822                        const int  nbe0  = nbe;
    18231823                        for (k=i=0;i<nbe0;i++) // on double les arete cracked
    1824                          if(edges[i].on->Cracked())
     1824                         if(edges[i].onGeometry->Cracked())
    18251825                                {
    18261826                                 e[nbe] = e[i];
     
    18281828                                 e[nbe].v[0] =  e[i].v[1];
    18291829                                 e[nbe].v[1] =  e[i].v[0];
    1830                                  e[nbe].on = e[i].on->link ; // fqux
     1830                                 e[nbe].onGeometry = e[i].onGeometry->link ; // faux
    18311831                                 CrackedEdges[k++]=CrackedEdge(edges,i,nbe);
    18321832                                 nbe++;
     
    19661966                                        throw ErrorException(__FUNCT__,exprintf("Missing  Edge %i, v0=%i,v1=%i",i ,Number(edges[i][0]),Number(edges[i][1])));
    19671967                                  }
    1968                                 if ( nbswp >=0 && edges[i].on->Cracked())
     1968                                if ( nbswp >=0 && edges[i].onGeometry->Cracked())
    19691969                                 ta.SetCracked();
    19701970                          }
     
    22602260
    22612261                        for (i=0;i<nbe;i++)
    2262                          if(edges[i].on)
     2262                         if(edges[i].onGeometry)
    22632263                          for(int j=0;j<2;j++)
    22642264                                if (!edges[i].adj[j])
    2265                                  if(!edges[i][j].on->IsRequiredVertex()) {
     2265                                 if(!edges[i][j].onGeometry->IsRequiredVertex()) {
    22662266                                         throw ErrorException(__FUNCT__,exprintf("adj and vertex required esge(?)"));
    22672267                                 }
     
    27232723                                                                                edges[nbe].v[1]=b->to;;
    27242724                                                                                edges[nbe].ref = e->ref;
    2725                                                                                 edges[nbe].on = e;
     2725                                                                                edges[nbe].onGeometry = e;
    27262726                                                                                edges[nbe].adj[0] = 0;
    27272727                                                                                edges[nbe].adj[1] = 0;
     
    28172817                                                                                                edges[nbe].v[1]=vb;
    28182818                                                                                                edges[nbe].ref = e->ref;
    2819                                                                                                 edges[nbe].on = e;
     2819                                                                                                edges[nbe].onGeometry = e;
    28202820                                                                                                edges[nbe].adj[0] = PreviousNewEdge;
    28212821                                                                                                if(PreviousNewEdge)
     
    28502850                                                                        edges[nbe].v[1]=vb;
    28512851                                                                        edges[nbe].ref = e->ref;
    2852                                                                         edges[nbe].on = e;
     2852                                                                        edges[nbe].onGeometry = e;
    28532853                                                                        edges[nbe].adj[0] = PreviousNewEdge;
    28542854                                                                        edges[nbe].adj[1] = 0;
     
    29912991                                Edge & ei = BTh.edges[iedge];
    29922992                                for(int je=0;je<2;je++) // for the 2 extremites
    2993                                  if (!ei.on->Mark() && ei[je].on->IsRequiredVertex() )
     2993                                 if (!ei.onGeometry->Mark() && ei[je].onGeometry->IsRequiredVertex() )
    29942994                                        {
    29952995                                         // a begin of curve
    2996                                          int nc = ei.on->CurveNumber;
     2996                                         int nc = ei.onGeometry->CurveNumber;
    29972997                                         if(
    2998                                                                  ei.on==Gh.curves[nc].be    &&
    2999                                                                  (GeometricalVertex *) *ei[je].on == &(*Gh.curves[nc].be)[Gh.curves[nc].kb] //  same extremity
     2998                                                                 ei.onGeometry==Gh.curves[nc].be    &&
     2999                                                                 (GeometricalVertex *) *ei[je].onGeometry == &(*Gh.curves[nc].be)[Gh.curves[nc].kb] //  same extremity
    30003000                                                )     
    30013001                                                {
     
    30523052                                                int k0equi=jedgeequi,k1equi;             
    30533053                                                Edge * peequi= BTh.edges+iedgeequi;
    3054                                                 GeometricalEdge *ongequi = peequi->on;
     3054                                                GeometricalEdge *ongequi = peequi->onGeometry;
    30553055
    30563056                                                Real8 sNew=Lstep;// abcisse of the new points (phase==1)
    30573057                                                L=0;// length of the curve
    30583058                                                Int4 i=0;// index of new points on the curve
    3059                                                 register GeometricalVertex * GA0 = *(*peequi)[k0equi].on;
     3059                                                register GeometricalVertex * GA0 = *(*peequi)[k0equi].onGeometry;
    30603060                                                Vertex *A0;
    30613061                                                A0 = GA0->to;  // the vertex in new mesh
     
    30693069                                                if(ongequi->Required() )
    30703070                                                  {
    3071                                                         GeometricalVertex *GA1 = *(*peequi)[1-k0equi].on;
     3071                                                        GeometricalVertex *GA1 = *(*peequi)[1-k0equi].onGeometry;
    30723072                                                        A1 = GA1->to;  //
    30733073                                                  }       
     
    30793079                                                         k1equi= 1 - k0equi;
    30803080
    3081                                                          if (!pe  || !ee.on){
     3081                                                         if (!pe  || !ee.onGeometry){
    30823082                                                                 throw ErrorException(__FUNCT__,exprintf("!pe  || !ee.on"));
    30833083                                                         }
    3084                                                          ee.on->SetMark();
     3084                                                         ee.onGeometry->SetMark();
    30853085                                                         Vertex & v0=ee[0], & v1=ee[1];
    30863086                                                         R2 AB= (R2) v1 - (R2) v0;
     
    31243124                                                                         A1->ReferenceNumber = eeequi.ref;
    31253125                                                                         A1->DirOfSearch =NoDirOfSearch;
    3126                                                                          e->on = ongequi;
     3126                                                                         e->onGeometry = ongequi;
    31273127                                                                         e->v[0]=  A0;
    31283128                                                                         e->v[1]=  A1;
     
    31393139
    31403140                                                         }               
    3141                                                          if (ee.on->CurveNumber!=ei.on->CurveNumber){
     3141                                                         if (ee.onGeometry->CurveNumber!=ei.onGeometry->CurveNumber){
    31423142                                                                 throw ErrorException(__FUNCT__,exprintf("ee.on->CurveNumber!=ei.on->CurveNumber"));
    31433143                                                         }
    3144                                                          if ( ee[k1].on->IsRequiredVertex()) {
    3145                                                                  if (!eeequi[k1equi].on->IsRequiredVertex()){
     3144                                                         if ( ee[k1].onGeometry->IsRequiredVertex()) {
     3145                                                                 if (!eeequi[k1equi].onGeometry->IsRequiredVertex()){
    31463146                                                                         throw ErrorException(__FUNCT__,exprintf("!eeequi[k1equi].on->IsRequiredVertex()"));
    31473147                                                                 }
    3148                                                                  register GeometricalVertex * GA1 = *eeequi[k1equi].on;
     3148                                                                 register GeometricalVertex * GA1 = *eeequi[k1equi].onGeometry;
    31493149                                                                 A1=GA1->to;// the vertex in new mesh
    31503150                                                                 if (A1-vertices<0 || A1-vertices>=nbv){
     
    31653165                                                  {
    31663166                                                        Edge *e = edges + nbe++;
    3167                                                         e->on  = ongequi;
     3167                                                        e->onGeometry  = ongequi;
    31683168                                                        e->v[0]=  A0;
    31693169                                                        e->v[1]=        A1;
     
    35073507          {
    35083508                Edge * ei = edges+i;
    3509                 GeometricalEdge *on = ei->on;
    3510                 e[Gh.Number(on)] = ei;   
     3509                GeometricalEdge *onGeometry = ei->onGeometry;
     3510                e[Gh.Number(onGeometry)] = ei;   
    35113511          }
    35123512        for ( i=0;i<nbe ; i++)
    35133513         for (int ii=0;ii<2;ii++) {
    35143514                 Edge * ei = edges+i;
    3515                  GeometricalEdge *on = ei->on;
     3515                 GeometricalEdge *onGeometry = ei->onGeometry;
    35163516                 int j= ii;
    3517                  while (!(*on)[j].Required()) {
    3518                          Adj(on,j); // next geom edge
     3517                 while (!(*onGeometry)[j].Required()) {
     3518                         Adj(onGeometry,j); // next geom edge
    35193519                         j=1-j;
    3520                          if (e[Gh.Number(on)])  break; // optimisation     
    3521                          e[Gh.Number(on)] = ei;
     3520                         if (e[Gh.Number(onGeometry)])  break; // optimisation
     3521                         e[Gh.Number(onGeometry)] = ei;
    35223522                 }
    35233523         }
     
    36813681                          {
    36823682                                Vertex & bv = Bh[i];
    3683                                 if (!bv.on) {
     3683                                if (!bv.onGeometry) {
    36843684                                        vertices[nbv].r = bv.r;
    36853685                                        vertices[nbv++].m = bv.m;}
     
    44744474                Triangle * lastT = triangles + nbt;
    44754475                for (i=0;i<nbe;i++)
    4476                  if(edges[i].on) NbEdgeOnGeom++;
     4476                 if(edges[i].onGeometry) NbEdgeOnGeom++;
    44774477                Int4 newnbe=nbe+nbe;
    44784478                //  Int4 newNbVerticesOnGeomVertex=NbVerticesOnGeomVertex;
     
    45014501                Int4 ferr=0;
    45024502                for (i=0;i<nbe;i++)
    4503                  newedges[ie].on=0;
     4503                 newedges[ie].onGeometry=0;
    45044504
    45054505                for (i=0;i<nbe;i++)
    45064506                  {
    4507                         GeometricalEdge *ong =  edges[i].on;
     4507                        GeometricalEdge *ong =  edges[i].onGeometry;
    45084508
    45094509                        newedges[ie]=edges[i];
     
    45244524                                                throw ErrorException(__FUNCT__,exprintf("!edgesGtoB"));
    45254525                                        }
    4526                                         ong= ProjectOnCurve(*edgesGtoB[Gh.Number(edges[i].on)],
     4526                                        ong= ProjectOnCurve(*edgesGtoB[Gh.Number(edges[i].onGeometry)],
    45274527                                                                edges[i][0],edges[i][1],0.5,vertices[k],
    45284528                                                                newVertexOnBThEdge[kvb],
     
    45534553                                vertices[k].r = ((R2) edges[i][0] + (R2)  edges[i][1] )*0.5;
    45544554                                vertices[k].m =  Metric(0.5,edges[i][0],0.5,edges[i][1]);
    4555                                 vertices[k].on = 0;
     4555                                vertices[k].onGeometry = 0;
    45564556                          }
    45574557                        //vertices[k].i = toI2( vertices[k].r);
     
    45624562                        vertices[k].DirOfSearch = NoDirOfSearch;
    45634563
    4564                         newedges[ie].on = Gh.Contening(AA,ong);
     4564                        newedges[ie].onGeometry = Gh.Contening(AA,ong);
    45654565                        newedges[ie++].v[1]=vertices+k;
    45664566
     
    45684568                        newedges[ie].adj[0]=newedges + ie -1;
    45694569                        newedges[ie].adj[1]=newedges+(edges[i].adj[1]-edges) ;
    4570                         newedges[ie].on =  Gh.Contening(BB,ong);
     4570                        newedges[ie].onGeometry =  Gh.Contening(BB,ong);
    45714571                        newedges[ie++].v[0]=vertices+k;
    45724572                        k++;
     
    49654965                                  Vertex &v0 = t[VerticesOfTriangularEdge[j][0]];
    49664966                                  Vertex &v1 = t[VerticesOfTriangularEdge[j][1]];
    4967                                   if (v0.on && v1.on){
     4967                                  if (v0.onGeometry && v1.onGeometry){
    49684968                                          R2 P= ((R2) v0 + (R2) v1)*0.5;
    49694969                                          if ( nbv<nbvx) {
     
    55725572                                while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
    55735573                                 if(l++ > 10000000) {
    5574                                          throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i)too big",NbSwap,l));
     5574                                         throw ErrorException(__FUNCT__,exprintf("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l));
    55755575                                 }
    55765576                                Vertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
Note: See TracChangeset for help on using the changeset viewer.