Changeset 5180


Ignore:
Timestamp:
08/12/10 10:19:59 (15 years ago)
Author:
Mathieu Morlighem
Message:

As usual

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

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/objects/Bamg/BamgVertex.cpp

    r5150 r5180  
    156156
    157157                Icoor2 deta[3];
    158                 I2 IBTh  = BTh.toI2(PNew);
     158                I2 IBTh  = BTh.R2ToI2(PNew);
    159159
    160160                tstart=BTh.TriangleFindFromCoord(IBTh,deta,tstart); 
    … …  
    178178                vP.r = PNew;
    179179
    180                 vP.i = Th.toI2(PNew);
     180                vP.i = Th.R2ToI2(PNew);
    181181
    182182                BamgVertex vPnew = vP;

  • issm/trunk/src/c/objects/Bamg/Geometry.cpp

    r5177 r5180  
    425425                        then, the integer coordinates are computed using
    426426                        the transformation ]0,1[^2 -> [0 2^30-1[^2 for a quadtree of depth 30*/
    427                         vertices[i].i=toI2(vertices[i].r);
     427                        vertices[i].i=R2ToI2(vertices[i].r);
    428428
    429429                        /*find nearest vertex already present in the quadtree (NULL if empty)*/
    … …  
    932932        }
    933933        /*}}}1*/
    934         /*FUNCTION Geometry::toI2{{{1*/
    935         I2 Geometry::toI2(const R2 & P) const {
     934        /*FUNCTION Geometry::R2ToI2{{{1*/
     935        I2 Geometry::R2ToI2(const R2 & P) const {
    936936                /*coefIcoor is the coefficient used for integer coordinates:
    937937                 *                       (x-pmin.x)

  • issm/trunk/src/c/objects/Bamg/Geometry.h

    r5149 r5180  
    4848                        //Methods
    4949                        void             Echo();
    50                         I2               toI2(const R2 &P) const;
     50                        I2               R2ToI2(const R2 &P) const;
    5151                        double           MinimalHmin();
    5252                        double           MaximalHmax();

  • issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp

    r5143 r5180  
    234234                //  int OnAVertices =0;
    235235                Icoor2 dt[3];
    236                 I2 a = Bh.toI2(A) ,b= Bh.toI2(B);// compute  the Icoor a,b
     236                I2 a = Bh.R2ToI2(A) ,b= Bh.R2ToI2(B);// compute  the Icoor a,b
    237237                I2 vi,vj; 
    238238                int iedge =-1;// not a edge

  • issm/trunk/src/c/objects/Bamg/Mesh.cpp

    r5172 r5180  
    28932893                for (i=nbvold;i<nbv;i++){
    28942894                        BamgVertex &vi=*ordre[i];
    2895                         vi.i=toI2(vi.r);
    2896                         vi.r=toR2(vi.i);
     2895                        vi.i=R2ToI2(vi.r);
     2896                        vi.r=I2ToR2(vi.i);
    28972897                        double hx,hy;
    28982898                        vi.m.Box(hx,hy);
    … …  
    30983098                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, Mesh2.cpp/MetricAt)*/
    30993099
    3100                 I2 a = toI2(A);
     3100                I2 a = R2ToI2(A);
    31013101                Icoor2 deta[3];
    31023102                Triangle * t =TriangleFindFromCoord(a,deta);
    … …  
    38583858        // generation of integer coord 
    38593859        for (i=0;i<nbv;i++) {
    3860                 vertices[i].i = toI2(vertices[i].r);   
     3860                vertices[i].i = R2ToI2(vertices[i].r);   
    38613861        }
    38623862
    … …  
    42294229                                        ong=Gh.ProjectOnCurve(edges[i],
    42304230                                                                0.5,vertices[k],newVerticesOnGeomEdge[kvg++]);
    4231                                         // vertices[k].i = toI2( vertices[k].r);
     4231                                        // vertices[k].i = R2ToI2( vertices[k].r);
    42324232                                        vertices[k].ReferenceNumber = edges[i].ReferenceNumber;
    42334233                                        vertices[k].DirOfSearch = NoDirOfSearch;
    … …  
    42414241                                vertices[k].GeometricalEdgeHook = 0;
    42424242                          }
    4243                         //vertices[k].i = toI2( vertices[k].r);
     4243                        //vertices[k].i = R2ToI2( vertices[k].r);
    42444244                        R2 AB =  vertices[k].r;
    42454245                        R2 AA = (A+AB)*0.5;
    … …  
    43544354                                                          {
    43554355                                                                vertices[k].r = ((R2) v0+(R2) v1 )/2;
    4356                                                                 //vertices[k].i = toI2( vertices[k].r);
     4356                                                                //vertices[k].i = R2ToI2( vertices[k].r);
    43574357                                                                vertices[k].ReferenceNumber=0;
    43584358                                                                vertices[k].DirOfSearch =NoDirOfSearch;
    … …  
    45294529                                                                        vertices[nbv].ReferenceNumber =0;
    45304530                                                                        vertices[nbv].DirOfSearch =NoDirOfSearch;
    4531                                                                         //vertices[nbv].i = toI2(vertices[nbv].r);
     4531                                                                        //vertices[nbv].i = R2ToI2(vertices[nbv].r);
    45324532                                                                        double a3[]={1./3.,1./3.,1./3.};
    45334533                                                                        vertices[nbv].m = Metric(a3,v0->m,v1->m,v2->m);
    … …  
    46704670                for (int i=nbvold;i<nbv;i++) {// for all the new point
    46714671                        BamgVertex & vi = vertices[i];
    4672                         vi.i = toI2(vi.r);
    4673                         vi.r = toR2(vi.i);
     4672                        vi.i = R2ToI2(vi.r);
     4673                        vi.r = I2ToR2(vi.i);
    46744674
    46754675                        // a good new point
    … …  
    47034703/*}}}1*/
    47044704/*FUNCTION Mesh::ToI2{{{1*/
    4705 I2 Mesh::toI2(const R2 & P) const {
     4705I2 Mesh::R2ToI2(const R2 & P) const {
    47064706        return  I2( (Icoor1) (coefIcoor*(P.x-pmin.x)),(Icoor1) (coefIcoor*(P.y-pmin.y)) );
    47074707}
    47084708/*}}}1*/
    47094709/*FUNCTION Mesh::ToR2{{{1*/
    4710 R2 Mesh::toR2(const I2 & P) const {
     4710R2 Mesh::I2ToR2(const I2 & P) const {
    47114711        return  R2( (double) P.x/coefIcoor+pmin.x, (double) P.y/coefIcoor+pmin.y);
    47124712}

  • issm/trunk/src/c/objects/Bamg/Mesh.h

    r5170 r5180  
    7474                        double MinimalHmin();
    7575                        double MaximalHmax();
    76                         I2 toI2(const R2 & P) const;
    77                         R2 toR2(const I2 & P) const;
     76                        I2 R2ToI2(const R2 & P) const;
     77                        R2 I2ToR2(const I2 & P) const;
    7878                        void AddVertex(BamgVertex & s,Triangle * t,Icoor2 *  =0) ;
    7979                        void Insert();

  • issm/trunk/src/c/objects/Bamg/QuadTree.cpp

    r5177 r5180  
    7979                th(NULL),                   // initial mesh = NULL
    8080                NbQuadTreeBox(0),           // initial number of quadtree boxes = 0
    81                 NbVertices(0),              // initial number of vertices = 0
    82                 NbQuadTreeBoxSearch(0),     // initial ?? = 0
    83                 NbVerticesSearch(0){        // initial ?? = 0
     81                NbVertices(0){              // initial number of vertices = 0
    8482
    8583                        //create lenStorageQuadTreeBox (100) StorageQuadTreeBox elements
    … …  
    9896                th(t),
    9997                NbQuadTreeBox(0),
    100                 NbVertices(0),
    101                 NbQuadTreeBoxSearch(0),
    102                 NbVerticesSearch(0)
     98                NbVertices(0)
    10399        {
    104100         if (nbv == -1) nbv = t->nbv;
    … …  
    120116        }
    121117        /*}}}1*/
    122         /*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
    123         QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long ll,StorageQuadTreeBox *nn) {
    124                 /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/StorageQuadTreeBox)*/
    125 
    126                 /*Initilalize variables*/
    127                 len = ll;                  // number of quadtree boxes
    128                 n   = nn;                  // next StorageQuadTreeBox pointer
    129                 b   = new QuadTreeBox[ll]; // quadtree boxes
    130                 ISSMASSERT(b);             // check allocation
    131 
    132                 /*Initialize all quadtree boxes (empty)*/
    133                 for (int i = 0; i <ll;i++){
    134                         b[i].n=0;
    135                         b[i].b[0]=b[i].b[1]=b[i].b[2]=b[i].b[3]=NULL;
    136                 }
    137 
    138                 bc = b;      //first quadtree box
    139                 be = b + ll; //last quadtree box
    140 
    141         }
    142         /*}}}1*/
    143118
    144119        /*Methods*/
    … …  
    160135
    161136                //Find the smallest box where w is located
    162                 while((b=*pb) && (b->n<0)){
    163 
    164                         //shift b->n by -1
    165                         b->n--;
     137                while((b=*pb) && (b->nbitems<0)){
     138
     139                        //shift b->nbitems by -1
     140                        b->nbitems--;
    166141
    167142                        //shifted righ by one bit: level=00000010 -> 00000001
    … …  
    175150                //check that the vertex is not already in the box
    176151                if  (b) {     
    177                         if (b->n > 3 &&  b->v[3] == &w) return;
    178                         if (b->n > 2 &&  b->v[2] == &w) return;
    179                         if (b->n > 1 &&  b->v[1] == &w) return;
    180                         if (b->n > 0 &&  b->v[0] == &w) return;
     152                        if (b->nbitems > 3 &&  b->v[3] == &w) return;
     153                        if (b->nbitems > 2 &&  b->v[2] == &w) return;
     154                        if (b->nbitems > 1 &&  b->v[1] == &w) return;
     155                        if (b->nbitems > 0 &&  b->v[0] == &w) return;
    181156                }
    182157
    … …  
    188163                //Now, try to add the vertex, if the subbox is full (n=4), we have to divide it
    189164                //in 4 new subboxes
    190                 while ((b= *pb) && (b->n == 4)){ // the QuadTreeBox is full
     165                while ((b= *pb) && (b->nbitems == 4)){ // the QuadTreeBox is full
    191166
    192167                        //Copy the 4 vertices in the current QuadTreebox
    … …  
    198173
    199174                        //set n as negative (box full -> holds 4 pointers toward subboxes and not 4 vertices)
    200                         b->n = -b->n;
     175                        b->nbitems = -b->nbitems;
    201176
    202177                        //Initialize the 4 pointers toward the 4 subboxes
    … …  
    215190
    216191                                //Copy the 4 vertices
    217                                 bb->v[bb->n++] = v4[k];
     192                                bb->v[bb->nbitems++] = v4[k];
    218193                        }
    219194
    … …  
    226201
    227202                //Add w
    228                 b->v[b->n++]=&w;
     203                b->v[b->nbitems++]=&w;
    229204
    230205                //Increase NbVertices by one (we have one new vertex)
    … …  
    258233
    259234                //if the tree is empty, return NULL pointer
    260                 if (!root->n) return vn;
     235                if (!root->nbitems) return vn;
    261236
    262237                //else, find the non empty QuadTreeBox containing  the point (i,j)
    263                 while((n0=b->n)<0){
     238                while((n0=b->nbitems)<0){
    264239
    265240                        //shifted righ by one bit: hb2=01000000 -> 00100000
    … …  
    271246
    272247                        // break if NULL box or empty
    273                         if (( b0 == NULL) || (b0->n == 0)) break;
     248                        if (( b0 == NULL) || (b0->nbitems == 0)) break;
    274249
    275250                        //Get next Qudtree box
    276                         NbQuadTreeBoxSearch++;
    277251                        b=b0;   
    278252                        i0 += I_IJ(k,hb2); // i orign of QuadTreeBox (macro)
    … …  
    291265                                        vn = b->v[k];
    292266                                }
    293                                 NbVerticesSearch++;
    294267                        }
    295268                        return vn;
    … …  
    301274                //initialize pb pi ii and jj
    302275                pb[0]=b;                  //pointer toward the box b
    303                 pi[0]=b->n>0? (int)b->n:4;//number of vertices in the box
     276                pi[0]=b->nbitems>0? (int)b->nbitems:4;//number of vertices in the box
    304277                ii[0]=i0;                 // i coordinate of the box
    305278                jj[0]=j0;                 // j coordinate of the box
    … …  
    321294
    322295                                //if the current subbox is holding vertices,
    323                                 if (b->n>0){ // BamgVertex QuadTreeBox not empty
    324                                         NbVerticesSearch++;
     296                                if (b->nbitems>0){ // BamgVertex QuadTreeBox not empty
    325297                                        I2 i2 =  b->v[k]->i;
    326298                                        h0 = NORM(iplus,i2.x,jplus,i2.y);
    … …  
    333305                                else{
    334306                                        register QuadTreeBox* b0=b;
    335                                         NbQuadTreeBoxSearch++;
    336307
    337308                                        //if the next box exists:
    … …  
    345316                                                if (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h)){
    346317                                                        pb[++level]=  b;
    347                                                         pi[level]= b->n>0 ?(int)  b->n : 4  ;
     318                                                        pi[level]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
    348319                                                        ii[level]= iii;
    349320                                                        jj[level]= jjj;
    … …  
    391362                b = root;
    392363                register long  n0;
    393                 if (!root->n)
     364                if (!root->nbitems)
    394365                 return vn; // empty tree
    395366
    396                 while( (n0 = b->n) < 0)
     367                while( (n0 = b->nbitems) < 0)
    397368                  {
    398369                        // search the non empty
    … …  
    401372                        register  int k = IJ(iplus,jplus,hb2);// QuadTreeBox number of size hb2 contening i;j
    402373                        register QuadTreeBox * b0= b->b[k];
    403                         if ( ( b0 == 0) || (b0->n == 0) )
     374                        if ( ( b0 == 0) || (b0->nbitems == 0) )
    404375                         break; // null box or empty   => break             
    405                         NbQuadTreeBoxSearch++;
    406376                        b=b0;   
    407377                        i0 += I_IJ(k,hb2); // i orign of QuadTreeBox
    … …  
    421391                                        h = h0;
    422392                                        vn = b->v[k];}
    423                                         NbVerticesSearch++;
    424393                          }
    425394                        if (vn) return vn;
    … …  
    429398                l =0; // level
    430399                pb[0]= b;
    431                 pi[0]=b->n>0 ?(int)  b->n : 4  ;
     400                pi[0]=b->nbitems>0 ?(int)  b->nbitems : 4  ;
    432401                ii[0]=i0;
    433402                jj[0]=j0;
    … …  
    439408                                int k = pi[l];
    440409
    441                                 if (b->n>0) // BamgVertex QuadTreeBox none empty
     410                                if (b->nbitems>0) // BamgVertex QuadTreeBox none empty
    442411                                  {
    443                                         NbVerticesSearch++;
    444412                                        I2 i2 =  b->v[k]->i;
    445413                                        // if good direction when try --
    … …  
    455423                                  {
    456424                                        register QuadTreeBox *b0=b;
    457                                         NbQuadTreeBoxSearch++;
    458425                                        if ((b=b->b[k]))
    459426                                          {
    … …  
    465432                                                  {
    466433                                                        pb[++l]=  b;
    467                                                         pi[l]= b->n>0 ?(int)  b->n : 4  ;
     434                                                        pi[l]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
    468435                                                        ii[l]= iii;
    469436                                                        jj[l]= jjj;
    … …  
    483450        }
    484451        /*}}}1*/
     452        /*FUNCTION QuadTree::NewQuadTreeBox {{{1*/
     453        QuadTree::QuadTreeBox* QuadTree::NewQuadTreeBox(void){
     454
     455                /*if firstbox==lastbox or firstbox>lastbox (we have reach the end of the StorageQuadTreeBox)
     456                 * create a new StorageQuadTreeBox)*/
     457                if(!(sb->firstbox<sb->lastbox)){
     458                        sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
     459                }
     460                ISSMASSERT(sb && sb->firstbox->nbitems==0);
     461
     462                /*Increase counter*/
     463                NbQuadTreeBox++;
     464
     465                /*firstbox now points toward next quadtree box*/
     466                return sb->firstbox++;
     467        }/*}}}*/
    485468        /*FUNCTION QuadTree::SizeOf{{{1*/
    486469        long QuadTree::SizeOf() const {
    … …  
    508491                //  BamgVertex *vn=0;
    509492
    510                 if (!root->n)
     493                if (!root->nbitems)
    511494                 return 0; // empty tree
    512495
    513496                // general case -----
    514497                pb[0]=root;
    515                 pi[0]=root->n>0 ?(int)  root->n : 4  ;
     498                pi[0]=root->nbitems>0 ?(int)  root->nbitems : 4  ;
    516499                ii[0]=i0;
    517500                jj[0]=j0;
    … …  
    523506                                register int k = pi[l];
    524507
    525                                 if (b->n>0) // BamgVertex QuadTreeBox none empty
     508                                if (b->nbitems>0) // BamgVertex QuadTreeBox none empty
    526509                                  {
    527                                         NbVerticesSearch++;
    528510                                        I2 i2 =  b->v[k]->i;
    529511                                        if ( ABS(i-i2.x) <hx && ABS(j-i2.y) <hy )
    … …  
    539521                                  {
    540522                                        register QuadTreeBox *b0=b;
    541                                         NbQuadTreeBoxSearch++;
    542523                                        if ((b=b->b[k]))
    543524                                          {
    … …  
    549530                                                  {
    550531                                                        pb[++l]=  b;
    551                                                         pi[l]= b->n>0 ?(int)  b->n : 4  ;
     532                                                        pi[l]= b->nbitems>0 ?(int)  b->nbitems : 4  ;
    552533                                                        ii[l]= iii;
    553534                                                        jj[l]= jjj;
    … …  
    568549        /*}}}1*/
    569550
     551        /*StorageQuadTreeBox Methods*/
     552        /*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
     553        QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long nbquadtreeboxes_in,StorageQuadTreeBox *nextsb_in) {
     554                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, QuadTree.cpp/StorageQuadTreeBox)*/
     555
     556                /*Initilalize variables*/
     557                nbquadtreeboxes = nbquadtreeboxes_in;       // number of quadtree boxes
     558                nextsb          = nextsb_in;                // next StorageQuadTreeBox pointer
     559                boxes   = new QuadTreeBox[nbquadtreeboxes]; // quadtree boxes
     560                ISSMASSERT(boxes);                          // check allocation
     561
     562                /*Initialize all quadtree boxes (empty)*/
     563                for (int i = 0; i <nbquadtreeboxes;i++){
     564                        boxes[i].nbitems=0;
     565                        boxes[i].b[0]=NULL;
     566                        boxes[i].b[1]=NULL;
     567                        boxes[i].b[2]=NULL;
     568                        boxes[i].b[3]=NULL;
     569                }
     570
     571                firstbox = boxes;
     572                lastbox  = boxes + nbquadtreeboxes;
     573
     574        }
     575        /*}}}1*/
     576        /*FUNCTION QuadTree::StorageQuadTreeBox::~StorageQuadTreeBox{{{1*/
     577        QuadTree::StorageQuadTreeBox::~StorageQuadTreeBox(){
     578
     579                if(nextsb) delete nextsb;
     580                delete [] boxes;
     581
     582        }
     583        /*}}}1*/
     584        /*FUNCTION QuadTree::StorageQuadTreeBox::SizeOf {{{1*/
     585        long  QuadTree::StorageQuadTreeBox::SizeOf() const {
     586
     587                return nbquadtreeboxes*sizeof(QuadTreeBox)+sizeof(StorageQuadTreeBox)+ (nextsb?nextsb->SizeOf():0);
     588
     589        }/*}}}*/
    570590}

  • issm/trunk/src/c/objects/Bamg/QuadTree.h

    r5177 r5180  
    2626                                public:
    2727
    28                                         int n; // number of current vertices in the box
     28                                        int nbitems; // number of current vertices in the box
    2929
    3030                                        union{
    … …  
    3939
    4040                                        /*Fields*/
    41                                         QuadTreeBox *b,*bc,*be;
    42                                         long len;
    43                                         StorageQuadTreeBox* n; // next StorageQuadTreeBox
     41                                        QuadTreeBox        *boxes,*firstbox,*lastbox;
     42                                        long                nbquadtreeboxes;
     43                                        StorageQuadTreeBox *nextsb;        // next StorageQuadTreeBox
    4444
    4545                                        /*Methods*/
    4646                                        StorageQuadTreeBox(long ,StorageQuadTreeBox* =NULL);
    47                                         ~StorageQuadTreeBox() {
    48                                                 if(n) delete n;
    49                                                 delete [] b;
    50                                         }
    51                                         long  SizeOf() const {return len*sizeof(QuadTreeBox)+sizeof(StorageQuadTreeBox)+ (n?n->SizeOf():0);}
     47                                        ~StorageQuadTreeBox();
     48                                        long  SizeOf() const;
    5249                        };
    5350
    … …  
    6158                        QuadTreeBox* root;
    6259                        Mesh*        th;
    63                         long         NbQuadTreeBox,NbVertices;
    64                         long         NbQuadTreeBoxSearch,NbVerticesSearch;
     60                        long         NbQuadTreeBox;
     61                        long         NbVertices;
    6562
     63                        QuadTree();
    6664                        QuadTree(Mesh *t,long nbv=-1);
    67                         QuadTree();
    6865                        ~QuadTree();
    69                         BamgVertex* NearestVertex(Icoor1 i,Icoor1 j);
    70                         BamgVertex* NearestVertexWithNormal(Icoor1 i,Icoor1 j);
    71                         BamgVertex* ToClose(BamgVertex & ,double ,Icoor1,Icoor1);
    72                         long    SizeOf() const;
    73                         void    Add( BamgVertex & w);
    7466
    75                         /*The following function cannot be in the cpp file because QuadTreeBox is
    76                          * a private class and is declared before QuadTree::*/
    77                         QuadTreeBox* NewQuadTreeBox(void){
     67                        BamgVertex*  NearestVertex(Icoor1 i,Icoor1 j);
     68                        BamgVertex*  NearestVertexWithNormal(Icoor1 i,Icoor1 j);
     69                        QuadTreeBox* NewQuadTreeBox(void);
     70                        BamgVertex*  ToClose(BamgVertex & ,double ,Icoor1,Icoor1);
     71                        long         SizeOf() const;
     72                        void         Add( BamgVertex & w);
    7873
    79                                 /*if bc==be or bc>be (we have reach the end of the StorageQuadTreeBox)
    80                                  * create a new StorageQuadTreeBox)*/
    81                                 if(!(sb->bc<sb->be)){
    82                                         sb=new StorageQuadTreeBox(lenStorageQuadTreeBox,sb);
    83                                 }
    84                                 ISSMASSERT(sb && sb->bc->n==0);
    85 
    86                                 /*Increase counter*/
    87                                 NbQuadTreeBox++;
    88 
    89                                 /*bc now points toward next quadtree box*/
    90                                 return sb->bc++;
    91 
    92                         }
    9374        };
    9475}
Note: See TracChangeset for help on using the changeset viewer.