Changeset 5401


Ignore:
Timestamp:
08/19/10 09:38:48 (15 years ago)
Author:
Mathieu Morlighem
Message:

renamed some fields and got rid of curve->next

Location:
issm/trunk/src/c/objects/Bamg
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/objects/Bamg/AdjacentTriangle.cpp

    r5148 r5401  
    1616        /*FUNCTION AdjacentTriangle::Locked {{{1*/
    1717        int  AdjacentTriangle::Locked() const {
    18                 return t->AdjEdgeNumber[a] & 4;
     18                return t->AdjEdgeIndex[a] & 4;
    1919        }
    2020        /*}}}*/
    2121        /*FUNCTION AdjacentTriangle::MarkUnSwap {{{1*/
    2222        int  AdjacentTriangle::MarkUnSwap() const {
    23                 return t->AdjEdgeNumber[a] & 8;
     23                return t->AdjEdgeIndex[a] & 8;
    2424        }
    2525        /*}}}*/
     
    2727        int  AdjacentTriangle::GetAllFlag_UnSwap() const {
    2828                // take all flag except MarkUnSwap
    29                 return t->AdjEdgeNumber[a] & 1012;
     29                return t->AdjEdgeIndex[a] & 1012;
    3030        }
    3131        /*}}}*/
     
    6565                if(t) {
    6666                        t->adj[a]=ta.t;
    67                         t->AdjEdgeNumber[a]=ta.a|l;
     67                        t->AdjEdgeIndex[a]=ta.a|l;
    6868                }
    6969                if(ta.t) {
    7070                        ta.t->adj[ta.a] = t ;
    71                         ta.t->AdjEdgeNumber[ta.a] = a| l ;
     71                        ta.t->AdjEdgeIndex[ta.a] = a| l ;
    7272                }
    7373        }
  • issm/trunk/src/c/objects/Bamg/Curve.cpp

    r5400 r5401  
    1616                FirstVertexIndex=0;
    1717                LastVertexIndex=0;
    18                 next=NULL;
    1918        }
    2019        /*}}}*/
     
    3332                FirstEdge = GhNew.edges + Gh.GetId(FirstEdge);   
    3433                LastEdge = GhNew.edges + Gh.GetId(LastEdge);
    35                 if(next) next= GhNew.curves + Gh.GetId(next);
    3634        }
    3735        /*}}}*/
  • issm/trunk/src/c/objects/Bamg/Curve.h

    r5400 r5401  
    1717                        int FirstVertexIndex;       //Last vertex index in the last edge
    1818                        int LastVertexIndex;        //First Vertex index in the first edge
    19                         Curve* next; // next curve equi to this
    2019
    2120                        //Methods
  • issm/trunk/src/c/objects/Bamg/GeometricalEdge.h

    r5340 r5401  
    1818                        R2                 tg[2];              // the 2 tangentes (tg[0] =0 => no continuity)
    1919                        GeometricalEdge   *Adj[2];
    20                         int                AdjVertexNumber[2]; // for a given vertex, this gives the index of the vertex in the adjacent edge (0 or 1)
     20                        int                AdjVertexIndex[2]; // for a given vertex, this gives the index of the vertex in the adjacent edge (0 or 1)
    2121                        int                type;
    2222
  • issm/trunk/src/c/objects/Bamg/Geometry.cpp

    r5400 r5401  
    151151                                edges[i].tg[0]=zerovector;
    152152                                edges[i].tg[1]=zerovector;
    153                                 edges[i].AdjVertexNumber[0] = edges[i].AdjVertexNumber[1] = -1;
     153                                edges[i].AdjVertexIndex[0] = edges[i].AdjVertexIndex[1] = -1;
    154154                                edges[i].Adj[0] = edges[i].Adj[1] = NULL;
    155155                                edges[i].type = 0;
     
    697697
    698698                                edges[i1].Adj[j1] = edges + i;
    699                                 edges[i1].AdjVertexNumber[j1] = j;
     699                                edges[i1].AdjVertexIndex[j1] = j;
    700700                        }
    701701                }
     
    719719                                                 * previous and next vertices connected to current vertex
    720720                                                 * normed by the edge length*/
    721                                                 tg = edges[i].v[1-j]->r - edges[i].Adj[j]->v[1-edges[i].AdjVertexNumber[j]]->r;
     721                                                tg = edges[i].v[1-j]->r - edges[i].Adj[j]->v[1-edges[i].AdjVertexIndex[j]]->r;
    722722                                                ltg= Norme2(tg);
    723723                                                tg = tg *(lAB/ltg);
     
    786786                                                                //else: go to next edge (adjacent)
    787787                                                                else{
    788                                                                         k0 = e->AdjVertexNumber[k1];//  vertex in next edge
     788                                                                        k0 = e->AdjVertexIndex[k1];//  vertex in next edge
    789789                                                                        e  = e->Adj[k1]; // next edge
    790790                                                                }
     
    873873                        ge[--bge] =eg0 = eg0->Adj[direction0];
    874874                        ISSMASSERT(bge>=0 && bge<=mxe);
    875                         direction0 = 1-( directionge[bge] = tmpge->AdjVertexNumber[direction0]);
     875                        direction0 = 1-( directionge[bge] = tmpge->AdjVertexIndex[direction0]);
    876876                }
    877877                while (eg1 != (GeometricalEdge*) vg1  &&  (*eg1)(direction1) != (GeometricalVertex*) vg1) {
     
    889889                        GeometricalEdge* tmpge = eg1;
    890890                        ge[++tge] =eg1 = eg1->Adj[direction1];
    891                         directionge[tge]= direction1 = 1-tmpge->AdjVertexNumber[direction1];
     891                        directionge[tge]= direction1 = 1-tmpge->AdjVertexIndex[direction1];
    892892                        ISSMASSERT(tge>=0 && tge<=mxe);
    893893                }
  • issm/trunk/src/c/objects/Bamg/Mesh.cpp

    r5400 r5401  
    51105110                                                                        if (b->Required() ) break;
    51115111                                                                        int kprev=k;
    5112                                                                         k = e->AdjVertexNumber[kprev];// next vertices
     5112                                                                        k = e->AdjVertexIndex[kprev];// next vertices
    51135113                                                                        e = e->Adj[kprev];
    51145114                                                                        ISSMASSERT(e);
     
    53295329                                for(int phase=0;phase<=step;phase++){
    53305330
    5331                                         /*Loop over all curves from icurve till the last curve*/
    5332                                         for(Curve *curve= Gh.curves+icurve;curve;curve= curve->next){
    5333 
    5334                                                 /*Get index of current curve*/
    5335                                                 int icurveequi= Gh.GetId(curve);
    5336 
    5337                                                 /*For phase 0, check that we are at the begining of the curve only*/
    5338                                                 if(phase==0 &&  icurveequi!=icurve)  continue;
    5339 
    5340                                                 int   k0=jedge,k1;
    5341                                                 Edge* pe=  BTh.edges+iedge;
    5342                                                 int   iedgeequi=bcurve[icurveequi]/2;
    5343                                                 int   jedgeequi=bcurve[icurveequi]%2;
    5344 
    5345                                                 int k0equi=jedgeequi,k1equi;             
    5346                                                 Edge * peequi= BTh.edges+iedgeequi;
    5347                                                 GeometricalEdge *ongequi = peequi->GeometricalEdgeHook;
    5348 
    5349                                                 double sNew=Lstep;// abscisse of the new points (phase==1)
    5350                                                 L=0;// length of the curve
    5351                                                 long i=0;// index of new points on the curve
    5352                                                 register GeometricalVertex * GA0 = *(*peequi)[k0equi].GeometricalEdgeHook;
    5353                                                 BamgVertex *A0;
    5354                                                 A0 = GA0->to;  // the vertex in new mesh
    5355                                                 BamgVertex *A1;
    5356                                                 VertexOnGeom *GA1;
    5357                                                 Edge* PreviousNewEdge = 0;
    5358 
    5359                                                 // New Curve phase
    5360                                                 ISSMASSERT(A0-vertices>=0 && A0-vertices<nbv);
    5361                                                 if(ongequi->Required()){
    5362                                                         GeometricalVertex *GA1 = *(*peequi)[1-k0equi].GeometricalEdgeHook;
    5363                                                         A1 = GA1->to;  //
    5364                                                 }       
    5365                                                 else {
    5366                                                         for(;;){
    5367                                                                 Edge &ee=*pe;
    5368                                                                 Edge &eeequi=*peequi;
    5369                                                                 k1 = 1-k0; // next vertex of the edge
    5370                                                                 k1equi= 1 - k0equi;
    5371                                                                 ISSMASSERT(pe && ee.GeometricalEdgeHook);
    5372                                                                 ee.GeometricalEdgeHook->SetMark();
    5373                                                                 BamgVertex & v0=ee[0], & v1=ee[1];
    5374                                                                 R2 AB=(R2)v1-(R2)v0;
    5375                                                                 double L0=L,LAB;
    5376                                                                 LAB=LengthInterpole(v0.m,v1.m,AB);
    5377                                                                 L+= LAB;
    5378 
    5379                                                                 if (phase){
    5380                                                                         // computation of the new points for the given curve
    5381                                                                         while ((i!=NbCreatePointOnCurve) && sNew<=L) {
    5382 
    5383                                                                                 //some checks
    5384                                                                                 ISSMASSERT(sNew>=L0);
    5385                                                                                 ISSMASSERT(LAB);
    5386                                                                                 ISSMASSERT(vertices && nbv<maxnbv);
    5387                                                                                 ISSMASSERT(edges && nbe<nbex);
    5388                                                                                 ISSMASSERT(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
    5389 
    5390                                                                                 // new vertex on edge
    5391                                                                                 A1=vertices+nbv++;
    5392                                                                                 GA1=VerticesOnGeomEdge+NbVerticesOnGeomEdge;
    5393                                                                                 Edge* e = edges + nbe++;
    5394                                                                                 double se= (sNew-L0)/LAB;
    5395                                                                                 if (se<0 || se>=1.000000001){
    5396                                                                                         ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
    5397                                                                                 }
    5398                                                                                 se = abscisseInterpole(v0.m,v1.m,AB,se,1);
    5399                                                                                 if (se<0 || se>1){
    5400                                                                                         ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
    5401                                                                                 }
    5402                                                                                 se = k1         ? se : 1. - se;
    5403                                                                                 se = k1==k1equi ? se : 1. - se;
    5404                                                                                 VertexOnBThEdge[NbVerticesOnGeomEdge++] = VertexOnEdge(A1,&eeequi,se); // save
    5405                                                                                 ongequi=Gh.ProjectOnCurve(eeequi,se,*A1,*GA1);
    5406                                                                                 A1->ReferenceNumber = eeequi.ReferenceNumber;
    5407                                                                                 A1->DirOfSearch =NoDirOfSearch;
    5408                                                                                 e->GeometricalEdgeHook = ongequi;
    5409                                                                                 e->v[0]=A0;
    5410                                                                                 e->v[1]=A1;
    5411                                                                                 e->ReferenceNumber = eeequi.ReferenceNumber;
    5412                                                                                 e->adj[0]=PreviousNewEdge;
    5413 
    5414                                                                                 if (PreviousNewEdge) PreviousNewEdge->adj[1]=e;
    5415                                                                                 PreviousNewEdge=e;
    5416                                                                                 A0=A1;
    5417                                                                                 sNew += Lstep;
    5418                                                                                 if (++i== NbCreatePointOnCurve) break;
     5331                                        /*Current curve pointer*/
     5332                                        Curve *curve= Gh.curves+icurve;
     5333
     5334                                        /*Get index of current curve*/
     5335                                        int icurveequi= Gh.GetId(curve);
     5336
     5337                                        /*For phase 0, check that we are at the begining of the curve only*/
     5338                                        if(phase==0 &&  icurveequi!=icurve)  continue;
     5339
     5340                                        int   k0=jedge,k1;
     5341                                        Edge* pe=  BTh.edges+iedge;
     5342                                        int   iedgeequi=bcurve[icurveequi]/2;
     5343                                        int   jedgeequi=bcurve[icurveequi]%2;
     5344
     5345                                        int k0equi=jedgeequi,k1equi;             
     5346                                        Edge * peequi= BTh.edges+iedgeequi;
     5347                                        GeometricalEdge *ongequi = peequi->GeometricalEdgeHook;
     5348
     5349                                        double sNew=Lstep;// abscisse of the new points (phase==1)
     5350                                        L=0;// length of the curve
     5351                                        long i=0;// index of new points on the curve
     5352                                        register GeometricalVertex * GA0 = *(*peequi)[k0equi].GeometricalEdgeHook;
     5353                                        BamgVertex *A0;
     5354                                        A0 = GA0->to;  // the vertex in new mesh
     5355                                        BamgVertex *A1;
     5356                                        VertexOnGeom *GA1;
     5357                                        Edge* PreviousNewEdge = 0;
     5358
     5359                                        // New Curve phase
     5360                                        ISSMASSERT(A0-vertices>=0 && A0-vertices<nbv);
     5361                                        if(ongequi->Required()){
     5362                                                GeometricalVertex *GA1 = *(*peequi)[1-k0equi].GeometricalEdgeHook;
     5363                                                A1 = GA1->to;  //
     5364                                        }       
     5365                                        else {
     5366                                                for(;;){
     5367                                                        Edge &ee=*pe;
     5368                                                        Edge &eeequi=*peequi;
     5369                                                        k1 = 1-k0; // next vertex of the edge
     5370                                                        k1equi= 1 - k0equi;
     5371                                                        ISSMASSERT(pe && ee.GeometricalEdgeHook);
     5372                                                        ee.GeometricalEdgeHook->SetMark();
     5373                                                        BamgVertex & v0=ee[0], & v1=ee[1];
     5374                                                        R2 AB=(R2)v1-(R2)v0;
     5375                                                        double L0=L,LAB;
     5376                                                        LAB=LengthInterpole(v0.m,v1.m,AB);
     5377                                                        L+= LAB;
     5378
     5379                                                        if (phase){
     5380                                                                // computation of the new points for the given curve
     5381                                                                while ((i!=NbCreatePointOnCurve) && sNew<=L) {
     5382
     5383                                                                        //some checks
     5384                                                                        ISSMASSERT(sNew>=L0);
     5385                                                                        ISSMASSERT(LAB);
     5386                                                                        ISSMASSERT(vertices && nbv<maxnbv);
     5387                                                                        ISSMASSERT(edges && nbe<nbex);
     5388                                                                        ISSMASSERT(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
     5389
     5390                                                                        // new vertex on edge
     5391                                                                        A1=vertices+nbv++;
     5392                                                                        GA1=VerticesOnGeomEdge+NbVerticesOnGeomEdge;
     5393                                                                        Edge* e = edges + nbe++;
     5394                                                                        double se= (sNew-L0)/LAB;
     5395                                                                        if (se<0 || se>=1.000000001){
     5396                                                                                ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
    54195397                                                                        }
     5398                                                                        se = abscisseInterpole(v0.m,v1.m,AB,se,1);
     5399                                                                        if (se<0 || se>1){
     5400                                                                                ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
     5401                                                                        }
     5402                                                                        se = k1         ? se : 1. - se;
     5403                                                                        se = k1==k1equi ? se : 1. - se;
     5404                                                                        VertexOnBThEdge[NbVerticesOnGeomEdge++] = VertexOnEdge(A1,&eeequi,se); // save
     5405                                                                        ongequi=Gh.ProjectOnCurve(eeequi,se,*A1,*GA1);
     5406                                                                        A1->ReferenceNumber = eeequi.ReferenceNumber;
     5407                                                                        A1->DirOfSearch =NoDirOfSearch;
     5408                                                                        e->GeometricalEdgeHook = ongequi;
     5409                                                                        e->v[0]=A0;
     5410                                                                        e->v[1]=A1;
     5411                                                                        e->ReferenceNumber = eeequi.ReferenceNumber;
     5412                                                                        e->adj[0]=PreviousNewEdge;
     5413
     5414                                                                        if (PreviousNewEdge) PreviousNewEdge->adj[1]=e;
     5415                                                                        PreviousNewEdge=e;
     5416                                                                        A0=A1;
     5417                                                                        sNew += Lstep;
     5418                                                                        if (++i== NbCreatePointOnCurve) break;
    54205419                                                                }
    5421 
    5422                                                                 //some checks
    5423                                                                 ISSMASSERT(ee.GeometricalEdgeHook->CurveNumber==ei.GeometricalEdgeHook->CurveNumber);
    5424                                                                 if (ee[k1].GeometricalEdgeHook->IsRequiredVertex()) {
    5425                                                                         ISSMASSERT(eeequi[k1equi].GeometricalEdgeHook->IsRequiredVertex());
    5426                                                                         register GeometricalVertex * GA1 = *eeequi[k1equi].GeometricalEdgeHook;
    5427                                                                         A1=GA1->to;// the vertex in new mesh
    5428                                                                         ISSMASSERT(A1-vertices>=0 && A1-vertices<nbv);
    5429                                                                         break;
    5430                                                                 }
    5431                                                                 if (!ee.adj[k1]) {
    5432                                                                         ISSMERROR(" adj edge %i, nbe=%i, Gh.vertices=%i",BTh.GetId(ee),nbe,Gh.vertices);
    5433                                                                 }
    5434                                                                 pe = ee.adj[k1]; // next edge
    5435                                                                 k0 = pe->Intersection(ee);
    5436                                                                 peequi= eeequi.adj[k1equi];  // next edge
    5437                                                                 k0equi=peequi->Intersection(eeequi);           
    5438                                                         }// for(;;) end of the curve
    5439                                                 }
    5440 
    5441 
    5442                                                 if (phase){ // construction of the last edge
    5443                                                         Edge* e=edges + nbe++;
    5444                                                         e->GeometricalEdgeHook  = ongequi;
    5445                                                         e->v[0]=A0;
    5446                                                         e->v[1]=A1;
    5447                                                         e->ReferenceNumber = peequi->ReferenceNumber;
    5448                                                         e->adj[0]=PreviousNewEdge;
    5449                                                         e->adj[1]=0;
    5450                                                         if (PreviousNewEdge) PreviousNewEdge->adj[1]=e;
    5451                                                         PreviousNewEdge = e;
    5452 
    5453                                                         ISSMASSERT(i==NbCreatePointOnCurve);
    5454                                                 }
    5455                                         } //  end loop on equi curve
     5420                                                        }
     5421
     5422                                                        //some checks
     5423                                                        ISSMASSERT(ee.GeometricalEdgeHook->CurveNumber==ei.GeometricalEdgeHook->CurveNumber);
     5424                                                        if (ee[k1].GeometricalEdgeHook->IsRequiredVertex()) {
     5425                                                                ISSMASSERT(eeequi[k1equi].GeometricalEdgeHook->IsRequiredVertex());
     5426                                                                register GeometricalVertex * GA1 = *eeequi[k1equi].GeometricalEdgeHook;
     5427                                                                A1=GA1->to;// the vertex in new mesh
     5428                                                                ISSMASSERT(A1-vertices>=0 && A1-vertices<nbv);
     5429                                                                break;
     5430                                                        }
     5431                                                        if (!ee.adj[k1]) {
     5432                                                                ISSMERROR(" adj edge %i, nbe=%i, Gh.vertices=%i",BTh.GetId(ee),nbe,Gh.vertices);
     5433                                                        }
     5434                                                        pe = ee.adj[k1]; // next edge
     5435                                                        k0 = pe->Intersection(ee);
     5436                                                        peequi= eeequi.adj[k1equi];  // next edge
     5437                                                        k0equi=peequi->Intersection(eeequi);           
     5438                                                }// for(;;) end of the curve
     5439                                        }
     5440
     5441
     5442                                        if (phase){ // construction of the last edge
     5443                                                Edge* e=edges + nbe++;
     5444                                                e->GeometricalEdgeHook  = ongequi;
     5445                                                e->v[0]=A0;
     5446                                                e->v[1]=A1;
     5447                                                e->ReferenceNumber = peequi->ReferenceNumber;
     5448                                                e->adj[0]=PreviousNewEdge;
     5449                                                e->adj[1]=0;
     5450                                                if (PreviousNewEdge) PreviousNewEdge->adj[1]=e;
     5451                                                PreviousNewEdge = e;
     5452
     5453                                                ISSMASSERT(i==NbCreatePointOnCurve);
     5454                                        }
    54565455
    54575456                                        if (!phase)  { //
     
    54605459                                                Lcurve = L;
    54615460                                                NbCreatePointOnCurve = NbSegOnCurve-1;
    5462 
    5463                                                 for(Curve * curve= Gh.curves+icurve;curve;curve= curve->next){
    5464                                                         NbOfNewEdge += NbSegOnCurve;
    5465                                                         NbOfNewPoints += NbCreatePointOnCurve;
    5466                                                 }
     5461                                                NbOfNewEdge += NbSegOnCurve;
     5462                                                NbOfNewPoints += NbCreatePointOnCurve;
    54675463                                        }
    54685464                                }
  • issm/trunk/src/c/objects/Bamg/Mesh.h

    r5340 r5401  
    170170        }
    171171        inline void Adj(GeometricalEdge * & on,int &i){
    172                 int j=i;i=on->AdjVertexNumber[i];on=on->Adj[j];
     172                int j=i;i=on->AdjVertexIndex[i];on=on->Adj[j];
    173173        }
    174174        inline double qualite(const BamgVertex &va,const BamgVertex &vb,const BamgVertex &vc){
  • issm/trunk/src/c/objects/Bamg/Triangle.cpp

    r5187 r5401  
    2323                vertices[2]=v+k;
    2424                adj[0]=adj[1]=adj[2]=0;
    25                 AdjEdgeNumber[0]=AdjEdgeNumber[1]=AdjEdgeNumber[2]=0;
     25                AdjEdgeIndex[0]=AdjEdgeIndex[1]=AdjEdgeIndex[2]=0;
    2626                det=0;
    2727        }
     
    3333                vertices[2]=v2;
    3434                adj[0]=adj[1]=adj[2]=0;
    35                 AdjEdgeNumber[0]=AdjEdgeNumber[1]=AdjEdgeNumber[2]=0;
     35                AdjEdgeIndex[0]=AdjEdgeIndex[1]=AdjEdgeIndex[2]=0;
    3636                if (v0) det=0;
    3737                else {
     
    4444        /*FUNCTION Triangle::Adj{{{1*/
    4545        AdjacentTriangle Triangle::Adj(int i)  const {
    46                 return AdjacentTriangle(adj[i],AdjEdgeNumber[i]&3);
     46                return AdjacentTriangle(adj[i],AdjEdgeIndex[i]&3);
    4747        };/*}}}*/
    4848        /*FUNCTION Triangle::Echo {{{1*/
     
    112112                        t = ttc;
    113113                        //NextEdge[3] = {1,2,0};
    114                         jc = NextEdge[t->AdjEdgeNumber[j]&3];
     114                        jc = NextEdge[t->AdjEdgeIndex[j]&3];
    115115                        j = NextEdge[jc];
    116116
     
    126126        /*FUNCTION Triangle::GetAllflag{{{1*/
    127127        int    Triangle::GetAllflag(int a){
    128                 return AdjEdgeNumber[a] & 1020;
     128                return AdjEdgeIndex[a] & 1020;
    129129        }/*}}}*/
    130130        /*FUNCTION Triangle::Hidden{{{1*/
    131131        int    Triangle::Hidden(int a)const {
    132                 return AdjEdgeNumber[a]&16;
     132                return AdjEdgeIndex[a]&16;
    133133        } /*}}}*/
    134134        /*FUNCTION Triangle::Locked{{{1*/
    135135        int    Triangle::Locked(int a)const {
    136                 return AdjEdgeNumber[a]&4;
     136                return AdjEdgeIndex[a]&4;
    137137        } /*}}}*/
    138138        /*FUNCTION Triangle::NuEdgeTriangleAdj{{{1*/
    139139        short  Triangle::NuEdgeTriangleAdj(int i) const {
    140140                /*Number of the  adjacent edge in adj tria (make sure it is between 0 and 2*/
    141                 return AdjEdgeNumber[i&3]&3;
     141                return AdjEdgeIndex[i&3]&3;
    142142        }/*}}}*/
    143143        /*FUNCTION Triangle::Optim{{{1*/
     
    154154                // initialize tp, jp the previous triangle & edge
    155155                Triangle *tp=adj[jp];
    156                 jp = AdjEdgeNumber[jp]&3;
     156                jp = AdjEdgeIndex[jp]&3;
    157157                do {
    158158                        while (t->swap(j,koption)){
     
    161161                                k++;
    162162                                t=  tp->adj[jp];      // set unchange t qnd j for previous triangles
    163                                 j=  NextEdge[tp->AdjEdgeNumber[jp]&3];
     163                                j=  NextEdge[tp->AdjEdgeIndex[jp]&3];
    164164                        }
    165165                        // end on this  Triangle
     
    168168
    169169                        t=  tp->adj[jp];      // set unchange t qnd j for previous triangles
    170                         j=  NextEdge[tp->AdjEdgeNumber[jp]&3];
     170                        j=  NextEdge[tp->AdjEdgeIndex[jp]&3];
    171171
    172172                } while( t != this);
     
    180180                if (link) {
    181181                        int a=-1;
    182                         if (AdjEdgeNumber[0] & 16 ) a=0;
    183                         if (AdjEdgeNumber[1] & 16 ) a=1;
    184                         if (AdjEdgeNumber[2] & 16 ) a=2;
     182                        if (AdjEdgeIndex[0] & 16 ) a=0;
     183                        if (AdjEdgeIndex[1] & 16 ) a=1;
     184                        if (AdjEdgeIndex[2] & 16 ) a=2;
    185185                        if (a>=0) {
    186186                                t = adj[a];
     
    189189                                v0 = vertices[VerticesOfTriangularEdge[a][1]];
    190190                                v1 = vertices[OppositeEdge[a]];
    191                                 v3 = t->vertices[OppositeEdge[AdjEdgeNumber[a]&3]];
     191                                v3 = t->vertices[OppositeEdge[AdjEdgeIndex[a]&3]];
    192192                        }
    193193                }
     
    198198        double   Triangle::QualityQuad(int a,int option) const{
    199199                double q;
    200                 if (!link || AdjEdgeNumber[a] &4)
     200                if (!link || AdjEdgeIndex[a] &4)
    201201                 q=  -1;
    202202                else {
     
    204204                        if (t-this<0) q=  -1;// because we do 2 times
    205205                        else if (!t->link ) q=  -1;
    206                         else if (AdjEdgeNumber[0] & 16 || AdjEdgeNumber[1] & 16  || AdjEdgeNumber[2] & 16 || t->AdjEdgeNumber[0] & 16 || t->AdjEdgeNumber[1] & 16 || t->AdjEdgeNumber[2] & 16 )
     206                        else if (AdjEdgeIndex[0] & 16 || AdjEdgeIndex[1] & 16  || AdjEdgeIndex[2] & 16 || t->AdjEdgeIndex[0] & 16 || t->AdjEdgeIndex[1] & 16 || t->AdjEdgeIndex[2] & 16 )
    207207                         q= -1;
    208208                        else if(option){
     
    210210                                const BamgVertex & v0 = *vertices[VerticesOfTriangularEdge[a][1]];
    211211                                const BamgVertex & v1 = *vertices[OppositeEdge[a]];
    212                                 const BamgVertex & v3 = * t->vertices[OppositeEdge[AdjEdgeNumber[a]&3]];
     212                                const BamgVertex & v3 = * t->vertices[OppositeEdge[AdjEdgeIndex[a]&3]];
    213213                                q =  QuadQuality(v0,v1,v2,v3); // do the float part
    214214                        }
     
    250250                a &= 3;
    251251                register Triangle *tt=adj[a];
    252                 AdjEdgeNumber [a] &= 55; // remove MarkUnSwap
    253                 register short aatt = AdjEdgeNumber[a] & 3;
     252                AdjEdgeIndex [a] &= 55; // remove MarkUnSwap
     253                register short aatt = AdjEdgeIndex[a] & 3;
    254254                if(tt){
    255255                        tt->adj[aatt]=this;
    256                         tt->AdjEdgeNumber[aatt]=a + (AdjEdgeNumber[a] & 60 ) ;
     256                        tt->AdjEdgeIndex[aatt]=a + (AdjEdgeIndex[a] & 60 ) ;
    257257                }
    258258        }/*}}}*/
     
    260260        void Triangle::SetAdj2(short a,Triangle *t,short aat){
    261261                adj[a]=t;    //the adjacent triangle to the edge a is t
    262                 AdjEdgeNumber[a]=aat; //position of the edge in the adjacent triangle
     262                AdjEdgeIndex[a]=aat; //position of the edge in the adjacent triangle
    263263                if(t) { //if t!=NULL add adjacent triangle to t (this)
    264264                        t->adj[aat]=this;
    265                         t->AdjEdgeNumber[aat]=a;
     265                        t->AdjEdgeIndex[aat]=a;
    266266                }
    267267        }/*}}}*/
    268268        /*FUNCTION Triangle::SetAllFlag{{{1*/
    269269        void   Triangle::SetAllFlag(int a,int f){
    270                 AdjEdgeNumber[a] = (AdjEdgeNumber[a] &3) + (1020 & f);
     270                AdjEdgeIndex[a] = (AdjEdgeIndex[a] &3) + (1020 & f);
    271271        }/*}}}*/
    272272        /*FUNCTION Triangle::SetDet{{{1*/
     
    281281                //if it exist
    282282                //C|=D -> C=(C|D) bitwise inclusive OR
    283                 if(t) t->AdjEdgeNumber[AdjEdgeNumber[a] & 3] |=16;
    284                 AdjEdgeNumber[a] |= 16;
     283                if(t) t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=16;
     284                AdjEdgeIndex[a] |= 16;
    285285        }/*}}}*/
    286286        /*FUNCTION Triangle::SetLocked{{{1*/
     
    288288                //mark the edge as on Boundary
    289289                register Triangle * t = adj[a];
    290                 t->AdjEdgeNumber[AdjEdgeNumber[a] & 3] |=4;
    291                 AdjEdgeNumber[a] |= 4;
     290                t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=4;
     291                AdjEdgeIndex[a] |= 4;
    292292        }/*}}}*/
    293293        /*FUNCTION Triangle::SetMarkUnSwap{{{1*/
    294294        void Triangle::SetMarkUnSwap(int a){
    295295                register Triangle * t = adj[a];
    296                 t->AdjEdgeNumber[AdjEdgeNumber[a] & 3] |=8;
    297                 AdjEdgeNumber[a] |=8 ;
     296                t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] |=8;
     297                AdjEdgeIndex[a] |=8 ;
    298298        }/*}}}*/
    299299        /*FUNCTION Triangle::SetSingleVertexToTriangleConnectivity{{{1*/
     
    306306        void Triangle::SetUnMarkUnSwap(int a){
    307307                register Triangle * t = adj[a];
    308                 t->AdjEdgeNumber[AdjEdgeNumber[a] & 3] &=55; // 23 + 32
    309                 AdjEdgeNumber[a] &=55 ;
     308                t->AdjEdgeIndex[AdjEdgeIndex[a] & 3] &=55; // 23 + 32
     309                AdjEdgeIndex[a] &=55 ;
    310310        }/*}}}*/
    311311        /*FUNCTION Triangle::swap{{{1*/
     
    316316
    317317                register Triangle *t1=this,*t2=adj[a];// les 2 triangles adjacent
    318                 register short a1=a,a2=AdjEdgeNumber[a];// les 2 numero de l arete dans les 2 triangles
     318                register short a1=a,a2=AdjEdgeIndex[a];// les 2 numero de l arete dans les 2 triangles
    319319                if(a2/4 !=0) return 0; // arete lock or MarkUnSwap
    320320
  • issm/trunk/src/c/objects/Bamg/Triangle.h

    r5340 r5401  
    1919                        BamgVertex *vertices[3];        // 3 vertices if t is triangle, t[i] allowed by access function, (*t)[i] if pointer
    2020                        Triangle   *adj[3];             // 3 pointers toward the adjacent triangles
    21                         short       AdjEdgeNumber[3];   // edge id in the adjacent triangles. The edge number 1 is the edge number AdjEdgeNumber[1] in the Adjacent triangle 1
     21                        short       AdjEdgeIndex[3];   // edge id in the adjacent triangles. The edge number 1 is the edge number AdjEdgeIndex[1] in the Adjacent triangle 1
    2222
    2323                public:
Note: See TracChangeset for help on using the changeset viewer.