Ignore:
Timestamp:
01/20/10 16:10:17 (15 years ago)
Author:
Mathieu Morlighem
Message:

Added some comments and changed variable names

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2865 r2877  
    5151                NbVertices(0),
    5252                NbQuadTreeBoxSearch(0),
    53                 NbVerticesSearch(0)
    54         {
    55          sb =new StorageQuadTreeBox(lenStorageQuadTreeBox);
    56          root=NewQuadTreeBox();
    57         }
     53                NbVerticesSearch(0){
     54                        sb =new StorageQuadTreeBox(lenStorageQuadTreeBox);
     55                        root=NewQuadTreeBox();
     56                }
    5857        /*}}}1*/
    5958        /*FUNCTION QuadTree::~QuadTree(){{{1*/
    … …  
    6564
    6665        /*Methods*/
     66        /*FUNCTION QuadTree::Add{{{1*/
     67        void  QuadTree::Add( Vertex & w){
     68                QuadTreeBox ** pb , *b;
     69                register long i=w.i.x, j=w.i.y,l=MaxISize;
     70                pb = &root;
     71                while( (b=*pb) && (b->n<0)){
     72                        b->n--;
     73                        l >>= 1;
     74                        pb = &b->b[IJ(i,j,l)];
     75                }
     76                if  (b) {     
     77                        if (b->n > 3 &&  b->v[3] == &w) return;
     78                        if (b->n > 2 &&  b->v[2] == &w) return;
     79                        if (b->n > 1 &&  b->v[1] == &w) return;
     80                        if (b->n > 0 &&  b->v[0] == &w) return;
     81                }
     82                if (l==0){
     83                        throw ErrorException(__FUNCT__,exprintf("l==0"));
     84                }
     85                while ((b= *pb) && (b->n == 4)){ // the QuadTreeBox is full
     86                        Vertex *v4[4]; // copy of the QuadTreeBox vertices
     87
     88                        v4[0]= b->v[0];
     89                        v4[1]= b->v[1];
     90                        v4[2]= b->v[2];
     91                        v4[3]= b->v[3];
     92                        b->n = -b->n; // mark is pointer QuadTreeBox
     93                        b->b[0]=b->b[1]=b->b[2]=b->b[3]=0; // set empty QuadTreeBox ptr
     94                        l >>= 1;    // div the size by 2
     95                        for (register int k=0;k<4;k++){ // for the 4 vertices find the sub QuadTreeBox ij
     96                                register int ij;
     97                                register QuadTreeBox * bb =  b->b[ij=IJ(v4[k]->i.x,v4[k]->i.y,l)];
     98                                if (!bb)
     99                                 bb=b->b[ij]=NewQuadTreeBox(); // alloc the QuadTreeBox
     100                                bb->v[bb->n++] = v4[k];
     101                        }
     102                        pb = &b->b[IJ(i,j,l)];
     103                }
     104                if (!(b = *pb)) b=*pb= NewQuadTreeBox(); //  alloc the QuadTreeBox
     105                b->v[b->n++]=&w; // we add the vertex
     106                NbVertices++;   
     107        }
     108        /*}}}1*/
    67109        /*FUNCTION QuadTree::NearestVertex{{{1*/
    68110        Vertex*  QuadTree::NearestVertex(Icoor1 i,Icoor1 j) {
    69                 QuadTreeBox * pb[ MaxDeep ];
    70                 int  pi[ MaxDeep  ];
    71                 Icoor1 ii[  MaxDeep ], jj [ MaxDeep];
     111                QuadTreeBox* pb[MaxDeep];
     112                int  pi[MaxDeep];
     113                Icoor1 ii[MaxDeep], jj [MaxDeep];
    72114                register int l=0; // level
    73115                register QuadTreeBox * b;
    … …  
    80122                Vertex *vn=0;
    81123
    82                 // init for optimisation ---
     124                // init for optimization
    83125                b = root;
    84                 register Int4  n0;
    85                 if (!root->n)
    86                  return vn; // empty tree
    87 
    88                 while( (n0 = b->n) < 0)
    89                   {
     126                register Int4 n0;
     127
     128                if (!root->n) return vn; // empty tree
     129
     130                while( (n0 = b->n) < 0){
    90131                        // search the non empty
    91132                        // QuadTreeBox containing  the point (i,j)
    … …  
    93134                        register  int k = IJ(iplus,jplus,hb2);// QuadTreeBox number of size hb2 contening i;j
    94135                        register QuadTreeBox * b0= b->b[k];
    95                         if ( ( b0 == 0) || (b0->n == 0) )
    96                          break; // null box or empty   => break             
     136                        if ( ( b0 == 0) || (b0->n == 0) ) break; // null box or empty   => break           
    97137                        NbQuadTreeBoxSearch++;
    98138                        b=b0;   
    … …  
    100140                        j0 += J_IJ(k,hb2); // j orign of QuadTreeBox
    101141                        hb = hb2;
    102                   }
    103 
    104 
    105                 if ( n0 > 0)
    106                   { 
    107                         for(register int k=0;k<n0;k++)
    108                           {
     142                }
     143
     144                if ( n0 > 0){ 
     145                        for(register int k=0;k<n0;k++){
    109146                                I2 i2 =  b->v[k]->i;
    110147                                h0 = NORM(iplus,i2.x,jplus,i2.y);
    … …  
    113150                                        vn = b->v[k];}
    114151                                        NbVerticesSearch++;
    115                           }
     152                        }
    116153                        return vn;
    117                   }
    118                 // general case -----
     154                }
     155
     156                // general case
    119157                pb[0]= b;
    120158                pi[0]=b->n>0 ?(int)  b->n : 4  ;
    … …  
    124162                do {   
    125163                        b= pb[l];
    126                         while (pi[l]--)
    127                           {           
     164                        while (pi[l]--){             
    128165                                register int k = pi[l];
    129166
    130                                 if (b->n>0) // Vertex QuadTreeBox none empty
    131                                   {
     167                                if (b->n>0){ // Vertex QuadTreeBox none empty
    132168                                        NbVerticesSearch++;
    133169                                        I2 i2 =  b->v[k]->i;
    … …  
    138174                                                vn = b->v[k];
    139175                                          }
    140                                   }
    141                                 else // Pointer QuadTreeBox
    142                                   {
     176                                }
     177                                else{ // Pointer QuadTreeBox
    143178                                        register QuadTreeBox *b0=b;
    144179                                        NbQuadTreeBoxSearch++;
    145                                         if ((b=b->b[k]))
    146                                           {
     180                                        if ((b=b->b[k])){
    147181                                                hb >>=1 ; // div by 2
    148182                                                register Icoor1 iii = ii[l]+I_IJ(k,hb);
    149183                                                register Icoor1 jjj = jj[l]+J_IJ(k,hb);
    150184
    151                                                 if  (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h))
    152                                                   {
     185                                                if (INTER_SEG(iii,iii+hb,iplus-h,iplus+h) && INTER_SEG(jjj,jjj+hb,jplus-h,jplus+h)){
    153186                                                        pb[++l]=  b;
    154187                                                        pi[l]= b->n>0 ?(int)  b->n : 4  ;
    … …  
    156189                                                        jj[l]= jjj;
    157190
    158                                                   }
    159                                                 else
    160                                                  b=b0, hb <<=1 ;
    161                                           }
    162                                         else
    163                                         b=b0;
    164                                   }
    165                           }
     191                                                }
     192                                                else{
     193                                                        b=b0, hb <<=1 ;
     194                                                }
     195                                        }
     196                                        else b=b0;
     197                                }
     198                        }
    166199                        hb <<= 1; // mul by 2
    167200                } while (l--);
    168 
    169201                return vn;
    170202        }
    … …  
    280312        }
    281313        /*}}}1*/
     314        /*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
     315        QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long ll,StorageQuadTreeBox *nn) {
     316                len = ll;
     317                n = nn;
     318                b = new QuadTreeBox[ll];
     319                for (int i = 0; i <ll;i++)
     320                 b[i].n =0,b[i].b[0]=b[i].b[1]=b[i].b[2]=b[i].b[3]=0;
     321                bc =b;
     322                be = b +ll;
     323                if (!b){
     324                        throw ErrorException(__FUNCT__,exprintf("!b"));
     325                }
     326        }
     327        /*}}}1*/
    282328        /*FUNCTION QuadTree::ToClose {{{1*/
    283329        Vertex *   QuadTree::ToClose(Vertex & v,Real8 seuil,Icoor1 hx,Icoor1 hy){
    … …  
    357403        }
    358404        /*}}}1*/
    359         /*FUNCTION QuadTree::Add{{{1*/
    360         void  QuadTree::Add( Vertex & w){
    361                 QuadTreeBox ** pb , *b;
    362                 register long i=w.i.x, j=w.i.y,l=MaxISize;
    363                 pb = &root;
    364                 while( (b=*pb) && (b->n<0))
    365                   {
    366                         b->n--;
    367                         l >>= 1;
    368                         pb = &b->b[IJ(i,j,l)];
    369                   }
    370                 if  (b) {     
    371                         if (b->n > 3 &&  b->v[3] == &w) return;
    372                         if (b->n > 2 &&  b->v[2] == &w) return;
    373                         if (b->n > 1 &&  b->v[1] == &w) return;
    374                         if (b->n > 0 &&  b->v[0] == &w) return;
    375                 }
    376                 if (l==0){
    377                         throw ErrorException(__FUNCT__,exprintf("l==0"));
    378                 }
    379                 while ((b= *pb) && (b->n == 4)) // the QuadTreeBox is full
    380                   {
    381                         Vertex *v4[4]; // copy of the QuadTreeBox vertices
    382 
    383                         v4[0]= b->v[0];
    384                         v4[1]= b->v[1];
    385                         v4[2]= b->v[2];
    386                         v4[3]= b->v[3];
    387                         b->n = -b->n; // mark is pointer QuadTreeBox
    388                         b->b[0]=b->b[1]=b->b[2]=b->b[3]=0; // set empty QuadTreeBox ptr
    389                         l >>= 1;    // div the size by 2
    390                         for (register int k=0;k<4;k++) // for the 4 vertices find the sub QuadTreeBox ij
    391                           {
    392                                 register int ij;
    393                                 register QuadTreeBox * bb =  b->b[ij=IJ(v4[k]->i.x,v4[k]->i.y,l)];
    394                                 if (!bb)
    395                                  bb=b->b[ij]=NewQuadTreeBox(); // alloc the QuadTreeBox
    396                                 bb->v[bb->n++] = v4[k];
    397                           }
    398                         pb = &b->b[IJ(i,j,l)];
    399                   }
    400                 if (!(b = *pb))
    401                  b=*pb= NewQuadTreeBox(); //  alloc the QuadTreeBox
    402                 b->v[b->n++]=&w; // we add the vertex
    403                 NbVertices++;   
    404         }
    405         /*}}}1*/
    406         /*FUNCTION QuadTree::StorageQuadTreeBox::StorageQuadTreeBox{{{1*/
    407         QuadTree::StorageQuadTreeBox::StorageQuadTreeBox(long ll,StorageQuadTreeBox *nn) {
    408                 len = ll;
    409                 n = nn;
    410                 b = new QuadTreeBox[ll];
    411                 for (int i = 0; i <ll;i++)
    412                  b[i].n =0,b[i].b[0]=b[i].b[1]=b[i].b[2]=b[i].b[3]=0;
    413                 bc =b;
    414                 be = b +ll;
    415                 if (!b){
    416                         throw ErrorException(__FUNCT__,exprintf("!b"));
    417                 }
    418         }
    419         /*}}}1*/
    420405
    421406}
Note: See TracChangeset for help on using the changeset viewer.