Ignore:
Timestamp:
09/28/06 17:49:37 (18 years ago)
Author:
gumbau
Message:

Updated modules to the new interface and the new simplification algorithm improvements.

Location:
GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.cxx

    r1025 r1526  
    8585} 
    8686 
    87  
    88  
    89  
    9087//////////////////////////////////////////////////////////////////////// 
    9188// 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/geom/3D.h

    r1025 r1526  
    6363        }; 
    6464 
    65  
    6665        // 
    6766        // A triangular face in 3D (ie. a 2-simplex in E3) 
    … …  
    9493} 
    9594 
    96  
    97  
    9895// GFXGEOM_3D_INCLUDED 
    9996#endif 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Array.h

    r1025 r1526  
    88{ 
    99        template<class T> 
    10         class array { 
    11         protected: 
    12                 T *data; 
    13                 int len; 
    14         public: 
    15                 array() { data=NULL; len=0; } 
    16                 array(int l) { init(l); } 
    17                 ~array() { f_r_e_e(); } 
     10                class array 
     11                { 
     12                        protected: 
     13                                T *data; 
     14                                int len; 
     15                        public: 
     16                                array() { data=NULL; len=0; } 
     17                                array(int l) { init(l); } 
     18                                ~array() { f_r_e_e(); } 
    1819 
     20                                inline void init(int l); 
     21                                inline void f_r_e_e(); 
     22                                inline void resize(int l); 
    1923 
    20                 inline void init(int l); 
    21                 inline void f_r_e_e(); 
    22                 inline void resize(int l); 
     24                                inline T& ref(int i); 
     25                                inline T& operator[](int i) { return data[i]; } 
     26                                inline T& operator()(int i) { return ref(i); } 
    2327 
    24                 inline T& ref(int i); 
    25                 inline T& operator[](int i) { return data[i]; } 
    26                 inline T& operator()(int i) { return ref(i); } 
     28                                inline const T& ref(int i) const; 
     29                                inline const T& operator[](int i) const { return data[i]; } 
     30                                inline const T& operator()(int i) const { return ref(i); } 
    2731 
    28                 inline const T& ref(int i) const; 
    29                 inline const T& operator[](int i) const { return data[i]; } 
    30                 inline const T& operator()(int i) const { return ref(i); } 
    31  
    32  
    33                 inline int length() const { return len; } 
    34                 inline int maxLength() const { return len; } 
    35         }; 
     32                                inline int length() const { return len; } 
     33                                inline int maxLength() const { return len; } 
     34                }; 
    3635 
    3736        template<class T> 
    38         inline void array<T>::init(int l) 
    39         { 
    40                 data = new T[l]; 
    41                 len = l; 
    42         } 
     37                inline void array<T>::init(int l) 
     38                { 
     39                        data = new T[l]; 
     40                        len = l; 
     41                } 
    4342 
    4443        template<class T> 
    45         inline void array<T>::f_r_e_e() 
    46         { 
    47                 if( data ) 
     44                inline void array<T>::f_r_e_e() 
    4845                { 
    49                 delete[] data; 
    50                 data = NULL; 
     46                        if( data ) 
     47                        { 
     48                                delete[] data; 
     49                                data = NULL; 
     50                        } 
    5151                } 
    52         } 
    5352 
    5453        template<class T> 
    55         inline T& array<T>::ref(int i) 
    56         { 
    57         #ifdef SAFETY 
    58                 assert( data ); 
    59                 assert( i>=0 && i<len ); 
    60         #endif 
    61                 return data[i]; 
    62         } 
     54                inline T& array<T>::ref(int i) 
     55                { 
     56#ifdef SAFETY 
     57                        assert( data ); 
     58                        assert( i>=0 && i<len ); 
     59#endif 
     60                        return data[i]; 
     61                } 
    6362 
    6463        template<class T> 
    65         inline const T& array<T>::ref(int i) const 
    66         { 
    67         #ifdef SAFETY 
    68                 assert( data ); 
    69                 assert( i>=0 && i<len ); 
    70         #endif 
    71                 return data[i]; 
    72         } 
     64                inline const T& array<T>::ref(int i) const 
     65                { 
     66#ifdef SAFETY 
     67                        assert( data ); 
     68                        assert( i>=0 && i<len ); 
     69#endif 
     70                        return data[i]; 
     71                } 
    7372 
    7473        template<class T> 
    75         inline void array<T>::resize(int l) 
    76         { 
    77                 T *old = data; 
    78                 data = new T[l]; 
    79                 data = (T *)memcpy(data,old,MIN(len,l)*sizeof(T)); 
    80                 len = l; 
    81                 delete[] old; 
    82         } 
     74                inline void array<T>::resize(int l) 
     75                { 
     76                        T *old = data; 
     77                        data = new T[l]; 
     78                        data = (T *)memcpy(data,old,MIN(len,l)*sizeof(T)); 
     79                        len = l; 
     80                        delete[] old; 
     81                } 
    8382} 
    8483 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Buffer.h

    r1025 r1526  
    2525                inline int length() const { return fill; } 
    2626                inline int maxLength() const { return len; } 
     27                inline void setFill(int l){fill =       l;} 
    2728        }; 
    28  
    2929 
    3030        template<class T> 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/Heap.h

    r1025 r1526  
    1616        class Heapable 
    1717        { 
    18         private: 
    19                 int token; 
     18                private: 
    2019 
    21         public: 
    22                 Heapable() { notInHeap(); } 
     20                        int token; 
    2321 
    24                 inline int isInHeap() { return token!=NOT_IN_HEAP; } 
    25                 inline void notInHeap() { token = NOT_IN_HEAP; } 
    26                 inline int getHeapPos() { return token; } 
    27                 inline void setHeapPos(int t) { token=t; } 
     22                public: 
     23 
     24                        Heapable() { notInHeap(); } 
     25 
     26                        inline int isInHeap() { return token!=NOT_IN_HEAP; } 
     27                        inline void notInHeap() { token = NOT_IN_HEAP; } 
     28                        inline int getHeapPos() { return token; } 
     29                        inline void setHeapPos(int t) { token=t; } 
    2830        }; 
    2931 
     32        class heap_node 
     33        { 
     34                public: 
     35                        float import; 
     36                        Heapable *obj; 
    3037 
    31         class heap_node { 
    32         public: 
    33                 float import; 
    34                 Heapable *obj; 
    35  
    36                 heap_node() { obj=NULL; import=0.0; } 
    37                 heap_node(Heapable *t, float i=0.0) { obj=t; import=i; } 
    38                 heap_node(const heap_node& h) { import=h.import; obj=h.obj; } 
     38                        heap_node() { obj=NULL; import=0.0; } 
     39                        heap_node(Heapable *t, float i=0.0) { obj=t; import=i; } 
     40                        heap_node(const heap_node& h) { import=h.import; obj=h.obj; } 
    3941        }; 
    4042 
    41  
    42  
    43         class Heap : public array<heap_node> { 
    44  
     43        class Heap : public array<heap_node> 
     44        { 
    4545                // 
    4646                // The actual size of the heap.  array::length() 
    … …  
    5757                void downheap(int i); 
    5858 
    59         public: 
     59                public: 
    6060 
    6161                Heap() { size=0; } 
    6262                Heap(int s) : array<heap_node>(s) { size=0; } 
    63  
    6463 
    6564                void insert(Heapable *, float); 
    … …  
    6766 
    6867                heap_node *extract(); 
     68 
     69                //      Overhead method. 
     70                heap_node *extract(int i); 
     71 
    6972                heap_node *top() { return size<1 ? (heap_node *)NULL : &ref(0); } 
    7073                heap_node *kill(int i); 
     74 
     75                //      Gets heap size. 
     76                int     getSize(){return        size;} 
     77 
     78                //      Gets element at position i. 
     79                heap_node       *getElement(int i){return       &ref(i);} 
     80 
    7181        }; 
    7282 
    7383} 
    7484 
    75  
    7685// GFXTOOLS_HEAP_INCLUDED 
    7786#endif 
     87 

  • GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/gfx/tools/heap.cxx

    r1025 r1526  
    77void Heap::swap(int i,int j) 
    88{ 
    9     heap_node tmp = ref(i); 
     9        heap_node tmp = ref(i); 
    1010 
    11     ref(i) = ref(j); 
    12     ref(j) = tmp; 
     11        ref(i) = ref(j); 
     12        ref(j) = tmp; 
    1313 
    14     ref(i).obj->setHeapPos(i); 
    15     ref(j).obj->setHeapPos(j); 
     14        ref(i).obj->setHeapPos(i); 
     15        ref(j).obj->setHeapPos(j); 
    1616} 
    1717 
    1818void Heap::upheap(int i) 
    1919{ 
    20     if( i==0 ) return; 
     20        if( i==0 ) return; 
    2121 
    22     if( ref(i).import > ref(parent(i)).import ) { 
    23         swap(i,parent(i)); 
    24         upheap(parent(i)); 
    25     } 
     22        if( ref(i).import > ref(parent(i)).import ) 
     23        { 
     24                swap(i,parent(i)); 
     25                upheap(parent(i)); 
     26        } 
    2627} 
    2728 
    2829void Heap::downheap(int i) 
    2930{ 
    30     if (i>=size) return;        // perhaps just extracted the last 
     31        if (i>=size) return;        // perhaps just extracted the last 
    3132 
    32     int largest = i, 
    33         l = left(i), 
    34         r = right(i); 
     33        int largest = i, 
     34                        l = left(i), 
     35                        r = right(i); 
    3536 
    36     if( l<size && ref(l).import > ref(largest).import ) largest = l; 
    37     if( r<size && ref(r).import > ref(largest).import ) largest = r; 
     37        if( l<size && ref(l).import > ref(largest).import ) largest = l; 
     38        if( r<size && ref(r).import > ref(largest).import ) largest = r; 
    3839 
    39     if( largest != i ) { 
    40         swap(i,largest); 
    41         downheap(largest); 
    42     } 
     40        if( largest != i ) { 
     41                swap(i,largest); 
     42                downheap(largest); 
     43        } 
    4344} 
    44  
    45  
    4645 
    4746void Heap::insert(Heapable *t,float v) 
    4847{ 
    49     if( size == maxLength() ) 
    50     { 
    51         std::cerr << "NOTE: Growing heap from " << size << " to " << 2*size << std::endl; 
    52         resize(2*size); 
    53     } 
     48        if( size == maxLength() ) 
     49        { 
     50                std::cerr << "NOTE: Growing heap from " << size << " to " << 2*size << std::endl; 
     51                resize(2*size); 
     52        } 
    5453 
    55     int i = size++; 
     54        int i = size++; 
    5655 
    57     ref(i).obj = t; 
    58     ref(i).import = v; 
     56        ref(i).obj = t; 
     57        ref(i).import = v; 
    5958 
    60     ref(i).obj->setHeapPos(i); 
     59        ref(i).obj->setHeapPos(i); 
    6160 
    62     upheap(i); 
     61        upheap(i); 
    6362} 
    6463 
    6564void Heap::update(Heapable *t,float v) 
    6665{ 
    67     int i = t->getHeapPos(); 
     66        int i = t->getHeapPos(); 
    6867 
    69     if( i >= size ) 
    70     { 
     68        if( i >= size ) 
     69        { 
    7170                std::cerr << "WARNING: Attempting to update past end of heap!" << std::endl; 
    7271                return; 
    73     } 
    74     else if( i == NOT_IN_HEAP ) 
    75     { 
     72        } 
     73        else if( i == NOT_IN_HEAP ) 
     74        { 
    7675                std::cerr << "WARNING: Attempting to update object not in heap!" << std::endl; 
    7776                return; 
    78     } 
     77        } 
    7978 
    80     float old=ref(i).import; 
    81     ref(i).import = v; 
     79        float old=ref(i).import; 
     80        ref(i).import = v; 
    8281 
    83     if( v<old ) 
    84         downheap(i); 
    85     else 
    86         upheap(i); 
     82        if( v<old ) 
     83                downheap(i); 
     84        else 
     85                upheap(i); 
    8786} 
    88  
    89  
    9087 
    9188heap_node *Heap::extract() 
    9289{ 
    93     if( size<1 ) return 0; 
     90        if( size<1 ) return 0; 
    9491 
    95     swap(0,size-1); 
    96     size--; 
     92        swap(0,size-1); 
     93        size--; 
    9794 
    98     downheap(0); 
     95        downheap(0); 
    9996 
    100     ref(size).obj->notInHeap(); 
     97        ref(size).obj->notInHeap(); 
    10198 
    102     return &ref(size); 
     99        return &ref(size); 
     100} 
     101 
     102//      Overhead method. 
     103heap_node *Heap::extract(int i) 
     104{ 
     105        if( size<1 ) return 0; 
     106 
     107        swap(i,size-1); 
     108        size--; 
     109 
     110        downheap(i); 
     111 
     112        ref(size).obj->notInHeap(); 
     113 
     114        return &ref(size); 
    103115} 
    104116 
    105117heap_node *Heap::kill(int i) 
    106118{ 
    107     if( i>=size ) 
     119        if( i>=size ) 
    108120                std::cerr << "WARNING: Attempt to delete invalid heap node." << std::endl; 
    109121 
    110     swap(i, size-1); 
    111     size--; 
    112     ref(size).obj->notInHeap(); 
     122        swap(i, size-1); 
     123        size--; 
     124        ref(size).obj->notInHeap(); 
    113125 
    114     if( ref(i).import < ref(size).import ) 
     126        if( ref(i).import < ref(size).import ) 
    115127                downheap(i); 
    116     else 
     128        else 
    117129                upheap(i); 
    118130 
     131        return &ref(size); 
     132} 
    119133 
    120     return &ref(size); 
    121 } 
Note: See TracChangeset for help on using the changeset viewer.