Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgUtil/Simplifier.cpp

    r12374 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    7474        _geometry(0), 
    7575        _computeErrorMetricUsingLength(false)  {} 
    76          
     76 
    7777    ~EdgeCollapse(); 
    7878 
     
    9292        Point* p1 = edge->_p1.get(); 
    9393        Point* p2 = edge->_p2.get(); 
    94          
     94 
    9595        if (p1==0 || p2==0) 
    9696        { 
    9797            OSG_NOTICE<<"Error computeInterpolatedPoint("<<edge<<",r) p1 and/or p2==0"<<std::endl; 
    9898            return 0; 
    99         }  
    100          
     99        } 
     100 
    101101        point->_vertex = p1->_vertex * r1 + p2->_vertex * r2; 
    102102        unsigned int s = osg::minimum(p1->_attributes.size(),p2->_attributes.size()); 
    103103        for(unsigned int i=0;i<s;++i) 
    104104        { 
    105             point->_attributes.push_back(p1->_attributes[i]*r1 + p2->_attributes[i]*r2);  
     105            point->_attributes.push_back(p1->_attributes[i]*r1 + p2->_attributes[i]*r2); 
    106106        } 
    107107        return point; 
     
    112112        return computeInterpolatedPoint(edge,0.5f); 
    113113    } 
    114      
     114 
    115115    error_type computeErrorMetric(Edge* edge,Point* point) const 
    116116    { 
     
    140140                error += fabs( (*itr)->distance(vertex) ); 
    141141            } 
    142              
     142 
    143143            // use average of error 
    144144            error /= error_type(triangles.size()); 
     
    151151        } 
    152152    } 
    153      
     153 
    154154    void updateErrorMetricForEdge(Edge* edge) 
    155155    { 
     
    162162 
    163163        osg::ref_ptr<Edge> keep_local_reference_to_edge(edge); 
    164      
     164 
    165165        if (_edgeSet.count(keep_local_reference_to_edge)!=0) 
    166166        { 
     
    169169 
    170170        edge->_proposedPoint = computeOptimalPoint(edge); 
    171          
     171 
    172172        if (_computeErrorMetricUsingLength) 
    173173        { 
     
    183183                edge->setErrorMetric( FLT_MAX ); 
    184184         } 
    185          
     185 
    186186        _edgeSet.insert(keep_local_reference_to_edge); 
    187187    } 
    188      
     188 
    189189    void updateErrorMetricForAllEdges() 
    190190    { 
     
    192192        LocalEdgeList edges; 
    193193        std::copy( _edgeSet.begin(), _edgeSet.end(), std::back_inserter(edges)); 
    194          
     194 
    195195        _edgeSet.clear(); 
    196          
     196 
    197197        for(LocalEdgeList::iterator itr=edges.begin(); 
    198198            itr!=edges.end(); 
     
    272272    { 
    273273        Point(): _protected(false), _index(0) {} 
    274          
     274 
    275275        bool _protected; 
    276276 
     
    291291            if (_vertex < rhs._vertex) return true; 
    292292            if (rhs._vertex < _vertex) return false; 
    293              
     293 
    294294            return _attributes < rhs._attributes; 
    295295        } 
    296          
     296 
    297297        bool isBoundaryPoint() const 
    298298        { 
    299299            if (_protected) return true; 
    300          
     300 
    301301            for(TriangleSet::const_iterator itr=_triangles.begin(); 
    302302                itr!=_triangles.end(); 
     
    307307                if ((triangle->_e2->_p1==this || triangle->_e2->_p2==this) && triangle->_e2->isBoundaryEdge()) return true; 
    308308                if ((triangle->_e3->_p1==this || triangle->_e3->_p2==this) && triangle->_e3->isBoundaryEdge()) return true; 
    309              
     309 
    310310                //if ((*itr)->isBoundaryTriangle()) return true; 
    311311            } 
     
    318318    { 
    319319        Edge(): _errorMetric(0.0), _maximumDeviation(1.0) {} 
    320          
     320 
    321321        void clear() 
    322322        { 
     
    328328        osg::ref_ptr<Point> _p1; 
    329329        osg::ref_ptr<Point> _p2; 
    330          
     330 
    331331        TriangleSet _triangles; 
    332332 
     
    338338        void setErrorMetric(error_type errorMetric) { _errorMetric = errorMetric; } 
    339339        error_type getErrorMetric() const { return _errorMetric; } 
    340          
     340 
    341341        bool operator < ( const Edge& rhs) const 
    342342        { 
     
    347347            if (dereference_check_less(_p1,rhs._p1)) return true; 
    348348            if (dereference_check_less(rhs._p1,_p1)) return false; 
    349              
     349 
    350350            return dereference_check_less(_p2,rhs._p2); 
    351351        } 
    352          
     352 
    353353        bool operator == ( const Edge& rhs) const 
    354354        { 
     
    366366            return false; 
    367367        } 
    368          
     368 
    369369        void addTriangle(Triangle* triangle) 
    370370        { 
     
    372372            // if (_triangles.size()>2) OSG_NOTICE<<"Warning too many triangles ("<<_triangles.size()<<") sharing edge "<<std::endl; 
    373373        } 
    374          
     374 
    375375        bool isBoundaryEdge() const 
    376376        { 
    377377            return _triangles.size()<=1; 
    378378        } 
    379          
     379 
    380380        bool isAdjacentToBoundary() const 
    381381        { 
    382             return isBoundaryEdge() || _p1->isBoundaryPoint() || _p2->isBoundaryPoint();  
    383         } 
    384          
     382            return isBoundaryEdge() || _p1->isBoundaryPoint() || _p2->isBoundaryPoint(); 
     383        } 
     384 
    385385 
    386386        void updateMaxNormalDeviationOnEdgeCollapse() 
     
    407407            } 
    408408        } 
    409          
    410         error_type getMaxNormalDeviationOnEdgeCollapse() const { return _maximumDeviation; }  
     409 
     410        error_type getMaxNormalDeviationOnEdgeCollapse() const { return _maximumDeviation; } 
    411411 
    412412    }; 
     
    415415    { 
    416416        Triangle() {} 
    417          
     417 
    418418        void clear() 
    419419        { 
     
    421421            _p2 = 0; 
    422422            _p3 = 0; 
    423          
     423 
    424424            _e1 = 0; 
    425425            _e2 = 0; 
     
    433433 
    434434 
    435             const Point* lhs_lower = dereference_check_less(_p2,_p3) ? _p2.get() : _p3.get();  
    436             const Point* rhs_lower = dereference_check_less(rhs._p2,rhs._p3) ? rhs._p2.get() : rhs._p3.get();  
     435            const Point* lhs_lower = dereference_check_less(_p2,_p3) ? _p2.get() : _p3.get(); 
     436            const Point* rhs_lower = dereference_check_less(rhs._p2,rhs._p3) ? rhs._p2.get() : rhs._p3.get(); 
    437437 
    438438            if (dereference_check_less(lhs_lower,rhs_lower)) return true; 
    439439            if (dereference_check_less(rhs_lower,lhs_lower)) return false; 
    440440 
    441             const Point* lhs_upper = dereference_check_less(_p2,_p3) ? _p3.get() : _p2.get();  
    442             const Point* rhs_upper = dereference_check_less(rhs._p2,rhs._p3) ? rhs._p3.get() : rhs._p2.get();  
     441            const Point* lhs_upper = dereference_check_less(_p2,_p3) ? _p3.get() : _p2.get(); 
     442            const Point* rhs_upper = dereference_check_less(rhs._p2,rhs._p3) ? rhs._p3.get() : rhs._p2.get(); 
    443443 
    444444            return dereference_check_less(lhs_upper,rhs_upper); 
     
    462462            _p3 = points[(lowest+2)%3]; 
    463463        } 
    464          
     464 
    465465        void update() 
    466466        { 
    467467            _plane.set(_p1->_vertex,_p2->_vertex,_p3->_vertex); 
    468              
    469         } 
    470          
     468 
     469        } 
     470 
    471471        osg::Plane computeNewPlaneOnEdgeCollapse(Edge* edge,Point* pNew) const 
    472472        { 
    473             const Point* p1 = (_p1==edge->_p1 || _p1==edge->_p2) ? pNew : _p1.get();   
    474             const Point* p2 = (_p2==edge->_p1 || _p2==edge->_p2) ? pNew : _p2.get();   
     473            const Point* p1 = (_p1==edge->_p1 || _p1==edge->_p2) ? pNew : _p1.get(); 
     474            const Point* p2 = (_p2==edge->_p1 || _p2==edge->_p2) ? pNew : _p2.get(); 
    475475            const Point* p3 = (_p3==edge->_p1 || _p3==edge->_p2) ? pNew : _p3.get(); 
    476              
     476 
    477477            return osg::Plane(p1->_vertex,p2->_vertex,p3->_vertex); 
    478478        } 
    479          
     479 
    480480        // note return 1 - dotproduct, so that deviation is in the range of 0.0 to 2.0, where 0 is coincident, 1.0 is 90 degrees, and 2.0 is 180 degrees. 
    481481        error_type computeNormalDeviationOnEdgeCollapse(Edge* edge,Point* pNew) const 
    482482        { 
    483             const Point* p1 = (_p1==edge->_p1 || _p1==edge->_p2) ? pNew : _p1.get();   
    484             const Point* p2 = (_p2==edge->_p1 || _p2==edge->_p2) ? pNew : _p2.get();   
     483            const Point* p1 = (_p1==edge->_p1 || _p1==edge->_p2) ? pNew : _p1.get(); 
     484            const Point* p2 = (_p2==edge->_p1 || _p2==edge->_p2) ? pNew : _p2.get(); 
    485485            const Point* p3 = (_p3==edge->_p1 || _p3==edge->_p2) ? pNew : _p3.get(); 
    486              
     486 
    487487            osg::Vec3 new_normal = (p2->_vertex - p1->_vertex) ^ (p3->_vertex - p2->_vertex); 
    488488            new_normal.normalize(); 
     
    499499                   error_type(_plane[3]); 
    500500        } 
    501          
     501 
    502502        bool isBoundaryTriangle() const 
    503503        { 
     
    505505        } 
    506506 
    507         
     507 
    508508        osg::ref_ptr<Point> _p1; 
    509509        osg::ref_ptr<Point> _p2; 
    510510        osg::ref_ptr<Point> _p3; 
    511          
     511 
    512512        osg::ref_ptr<Edge> _e1; 
    513513        osg::ref_ptr<Edge> _e2; 
    514514        osg::ref_ptr<Edge> _e3; 
    515          
     515 
    516516        osg::Plane _plane; 
    517517 
     
    525525        // detect if triangle is degenerate. 
    526526        if (p1==p2 || p2==p3 || p1==p3) return 0; 
    527          
     527 
    528528        Triangle* triangle = new Triangle; 
    529529 
     
    532532        points[1] = addPoint(triangle, p2); 
    533533        points[2] = addPoint(triangle, p3); 
    534          
     534 
    535535        // find the lowest value point in the list. 
    536536        unsigned int lowest = 0; 
     
    545545        triangle->_e2 = addEdge(triangle, triangle->_p2.get(), triangle->_p3.get()); 
    546546        triangle->_e3 = addEdge(triangle, triangle->_p3.get(), triangle->_p1.get()); 
    547          
     547 
    548548        triangle->update(); 
    549549 
    550550        _triangleSet.insert(triangle); 
    551          
     551 
    552552        return triangle; 
    553553    } 
    554      
     554 
    555555    Triangle* addTriangle(Point* p1, Point* p2, Point* p3) 
    556556    { 
     
    558558 
    559559        // detect if triangle is degenerate. 
    560         if (p1==p2 || p2==p3 || p1==p3)  
     560        if (p1==p2 || p2==p3 || p1==p3) 
    561561        { 
    562562            // OSG_NOTICE<<"    **** addTriangle failed - p1==p2 || p2==p3 || p1==p3"<<std::endl; 
    563563            return 0; 
    564564        } 
    565          
     565 
    566566        Triangle* triangle = new Triangle; 
    567567 
     
    570570        points[1] = addPoint(triangle, p2); 
    571571        points[2] = addPoint(triangle, p3); 
    572          
     572 
    573573        // find the lowest value point in the list. 
    574         unsigned int lowest = 0;         
     574        unsigned int lowest = 0; 
    575575        if (dereference_check_less(points[1],points[lowest])) lowest = 1; 
    576576        if (dereference_check_less(points[2],points[lowest])) lowest = 2; 
     
    583583        triangle->_e2 = addEdge(triangle, triangle->_p2.get(), triangle->_p3.get()); 
    584584        triangle->_e3 = addEdge(triangle, triangle->_p3.get(), triangle->_p1.get()); 
    585          
     585 
    586586        triangle->update(); 
    587587 
     
    596596        if (triangle->_p2.valid()) removePoint(triangle,triangle->_p2.get()); 
    597597        if (triangle->_p3.valid()) removePoint(triangle,triangle->_p3.get()); 
    598          
     598 
    599599        if (triangle->_e1.valid()) removeEdge(triangle,triangle->_e1.get()); 
    600600        if (triangle->_e2.valid()) removeEdge(triangle,triangle->_e2.get()); 
     
    612612            if (triangle->_p2==pOriginal) triangle->_p2=pNew; 
    613613            if (triangle->_p3==pOriginal) triangle->_p3=pNew; 
    614              
     614 
    615615            // fixes the edges so they point to use the new point 
    616616            triangle->_e1 = replaceEdgePoint(triangle->_e1.get(),pOriginal,pNew); 
    617617            triangle->_e2 = replaceEdgePoint(triangle->_e2.get(),pOriginal,pNew); 
    618618            triangle->_e3 = replaceEdgePoint(triangle->_e3.get(),pOriginal,pNew); 
    619              
     619 
    620620            // remove the triangle form the original point, and possibly the point if its the last triangle to use it 
    621621            removePoint(triangle, pOriginal); 
    622              
     622 
    623623            // add the triangle to that point 
    624624            addPoint(triangle,pNew); 
    625625        } 
    626          
    627     } 
    628      
     626 
     627    } 
     628 
    629629    unsigned int testTriangle(Triangle* triangle) 
    630630    { 
     
    635635            ++result; 
    636636        } 
    637         else if (triangle->_p1->_triangles.count(triangle)==0)  
     637        else if (triangle->_p1->_triangles.count(triangle)==0) 
    638638        { 
    639639            OSG_NOTICE<<"testTriangle("<<triangle<<") _p1->_triangles does not contain triangle"<<std::endl; 
     
    646646            ++result; 
    647647        } 
    648         else if (triangle->_p2->_triangles.count(triangle)==0)  
     648        else if (triangle->_p2->_triangles.count(triangle)==0) 
    649649        { 
    650650            OSG_NOTICE<<"testTriangle("<<triangle<<") _p2->_triangles does not contain triangle"<<std::endl; 
     
    657657            ++result; 
    658658        } 
    659         else if (triangle->_p3->_triangles.count(triangle)==0)  
     659        else if (triangle->_p3->_triangles.count(triangle)==0) 
    660660        { 
    661661            OSG_NOTICE<<"testTriangle("<<triangle<<") _p3->_triangles does not contain triangle"<<std::endl; 
    662662            ++result; 
    663663        } 
    664          
     664 
    665665        if (testEdge(triangle->_e1.get())) 
    666666        { 
     
    668668            OSG_NOTICE<<"testTriangle("<<triangle<<") _e1 test failed"<<std::endl; 
    669669        } 
    670          
     670 
    671671        if (testEdge(triangle->_e2.get())) 
    672672        { 
     
    710710            edge->_p2 = p1; 
    711711        } 
    712          
     712 
    713713        edge->setErrorMetric( computeErrorMetric( edge.get(), edge->_proposedPoint.get())); 
    714          
     714 
    715715        EdgeSet::iterator itr = _edgeSet.find(edge); 
    716716        if (itr==_edgeSet.end()) 
     
    724724            edge = *itr; 
    725725        } 
    726          
     726 
    727727        edge->addTriangle(triangle); 
    728          
     728 
    729729        return edge.get(); 
    730730    } 
     
    755755            { 
    756756                // remove the edge from the list, as its positoin in the list 
    757                 // may need to change once its values have been ammended  
     757                // may need to change once its values have been ammended 
    758758                _edgeSet.erase(itr); 
    759759            } 
    760              
     760 
    761761            // modify its values 
    762762            if (edge->_p1==pOriginal) edge->_p1=pNew; 
     
    785785            return edge; 
    786786        } 
    787          
     787 
    788788    } 
    789789 
     
    812812        osg::ref_ptr<Point> edge_p1 = edge->_p1; 
    813813        osg::ref_ptr<Point> edge_p2 = edge->_p2; 
    814          
     814 
    815815        TriangleMap  triangleMap; 
    816816        TriangleList triangles_p1; 
    817817        TriangleList triangles_p2; 
    818818        LocalEdgeList oldEdges; 
    819          
    820          
     819 
     820 
    821821        if (edge_p1 != pNew) 
    822822        { 
     
    834834                } 
    835835            } 
    836              
     836 
    837837            //triangles_p1 = edge_p1->_triangles; 
    838838        } 
    839                  
     839 
    840840        if (edge_p2 != pNew) 
    841841        { 
     
    861861        { 
    862862            _edgeSet.erase(*oeitr); 
    863              
     863 
    864864            const_cast<Edge*>(oeitr->get())->setErrorMetric(0.0f); 
    865              
     865 
    866866            _edgeSet.insert(*oeitr); 
    867867        } 
    868868 
    869869        TriangleList::iterator titr_p1, titr_p2; 
    870          
     870 
    871871        for(titr_p1 = triangles_p1.begin(); 
    872872            titr_p1 != triangles_p1.end(); 
     
    884884 
    885885        //OSG_NOTICE<<"  pNew="<<pNew<<"\tedge_p1"<<edge_p1.get()<<"\tedge_p2"<<edge_p2.get()<<std::endl; 
    886          
     886 
    887887        // we copy the edge's _triangles and interate the copy of the triangle set to avoid invalidating iterators. 
    888888        TriangleSet trianglesToRemove = edge->_triangles; 
     
    897897        LocalEdgeList newEdges; 
    898898 
    899   
     899 
    900900        for(titr_p1 = triangles_p1.begin(); 
    901901            titr_p1 != triangles_p1.end(); 
     
    998998 
    999999        typedef std::set< osg::ref_ptr<Edge> > LocalEdgeList; 
    1000         LocalEdgeList edges2UpdateErrorMetric;         
     1000        LocalEdgeList edges2UpdateErrorMetric; 
    10011001        TriangleSet::iterator titr; 
    1002          
     1002 
    10031003 
    10041004        // for each deleted triangle insert two new triangles 
     
    10241024                else if (edge->_p2 == tri->_p2.get()) edgeToReplace = 2; // edge p2, p3 
    10251025            } 
    1026              
     1026 
    10271027            Triangle* newTri1 = 0; 
    10281028            Triangle* newTri2 = 0; 
     
    10541054                    break; 
    10551055            } 
    1056              
     1056 
    10571057            if (newTri1) 
    10581058            { 
     
    10681068            } 
    10691069        } 
    1070          
     1070 
    10711071        // unsigned int numTriangles2 = _triangleSet.size(); 
    10721072        // unsigned int numEdges2 = _edgeSet.size(); 
     
    11181118            } 
    11191119        } 
    1120          
     1120 
    11211121        if (edge->_triangles.empty()) 
    11221122        { 
     
    11591159    Point* addPoint(Triangle* triangle, Point* point) 
    11601160    { 
    1161          
     1161 
    11621162        PointSet::iterator itr = _pointSet.find(point); 
    11631163        if (itr==_pointSet.end()) 
     
    11731173 
    11741174        point->_triangles.insert(triangle); 
    1175          
     1175 
    11761176        return point; 
    11771177    } 
     
    11831183        { 
    11841184            point->_triangles.erase(triangle); 
    1185              
     1185 
    11861186            if (point->_triangles.empty()) 
    11871187            { 
     
    11901190            } 
    11911191        } 
    1192          
    1193     } 
    1194      
     1192 
     1193    } 
     1194 
    11951195    unsigned int testPoint(Point* point) 
    11961196    { 
    11971197        unsigned int numErrors = 0; 
    1198          
     1198 
    11991199        for(TriangleSet::iterator itr=point->_triangles.begin(); 
    12001200            itr!=point->_triangles.end(); 
     
    12111211            } 
    12121212        } 
    1213          
     1213 
    12141214        return numErrors; 
    12151215    } 
    1216      
     1216 
    12171217    unsigned int testAllPoints() 
    12181218    { 
     
    12261226        return numErrors; 
    12271227    } 
    1228      
     1228 
    12291229//protected: 
    12301230 
     
    12321232 
    12331233    osg::Geometry*                  _geometry; 
    1234      
     1234 
    12351235    bool                            _computeErrorMetricUsingLength; 
    12361236    EdgeSet                         _edgeSet; 
     
    12381238    PointSet                        _pointSet; 
    12391239    PointList                       _originalPointList; 
    1240      
     1240 
    12411241}; 
    12421242 
     
    12471247 
    12481248    void setEdgeCollapse(EdgeCollapse* ec) { _ec = ec; } 
    1249      
    1250     EdgeCollapse* _ec;     
     1249 
     1250    EdgeCollapse* _ec; 
    12511251 
    12521252    // for use  in the triangle functor. 
     
    12751275        CopyArrayToPointsVisitor(EdgeCollapse::PointList& pointList): 
    12761276            _pointList(pointList) {} 
    1277          
     1277 
    12781278        template<class T> 
    12791279        void copy(T& array) 
    12801280        { 
    12811281            if (_pointList.size()!=array.size()) return; 
    1282          
    1283             for(unsigned int i=0;i<_pointList.size();++i)  
    1284                 _pointList[i]->_attributes.push_back((float)array[i]);   
    1285         } 
    1286          
     1282 
     1283            for(unsigned int i=0;i<_pointList.size();++i) 
     1284                _pointList[i]->_attributes.push_back((float)array[i]); 
     1285        } 
     1286 
    12871287        virtual void apply(osg::Array&) {} 
    12881288        virtual void apply(osg::ByteArray& array) { copy(array); } 
     
    12971297        { 
    12981298            if (_pointList.size()!=array.size()) return; 
    1299          
    1300             for(unsigned int i=0;i<_pointList.size();++i)  
     1299 
     1300            for(unsigned int i=0;i<_pointList.size();++i) 
    13011301            { 
    13021302                osg::Vec4ub& value = array[i]; 
    13031303                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
    1304                 attributes.push_back((float)value.r());   
    1305                 attributes.push_back((float)value.g());   
    1306                 attributes.push_back((float)value.b());   
    1307                 attributes.push_back((float)value.a());   
     1304                attributes.push_back((float)value.r()); 
     1305                attributes.push_back((float)value.g()); 
     1306                attributes.push_back((float)value.b()); 
     1307                attributes.push_back((float)value.a()); 
    13081308            } 
    13091309        } 
     
    13121312        { 
    13131313            if (_pointList.size()!=array.size()) return; 
    1314          
    1315             for(unsigned int i=0;i<_pointList.size();++i)  
     1314 
     1315            for(unsigned int i=0;i<_pointList.size();++i) 
    13161316            { 
    13171317                osg::Vec2& value = array[i]; 
    13181318                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
    1319                 attributes.push_back(value.x());   
    1320                 attributes.push_back(value.y());   
     1319                attributes.push_back(value.x()); 
     1320                attributes.push_back(value.y()); 
    13211321            } 
    13221322        } 
     
    13251325        { 
    13261326            if (_pointList.size()!=array.size()) return; 
    1327          
    1328             for(unsigned int i=0;i<_pointList.size();++i)  
     1327 
     1328            for(unsigned int i=0;i<_pointList.size();++i) 
    13291329            { 
    13301330                osg::Vec3& value = array[i]; 
    13311331                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
    1332                 attributes.push_back(value.x());   
    1333                 attributes.push_back(value.y());   
    1334                 attributes.push_back(value.z());   
    1335             } 
    1336         } 
    1337          
     1332                attributes.push_back(value.x()); 
     1333                attributes.push_back(value.y()); 
     1334                attributes.push_back(value.z()); 
     1335            } 
     1336        } 
     1337 
    13381338        virtual void apply(osg::Vec4Array& array) 
    13391339        { 
    13401340            if (_pointList.size()!=array.size()) return; 
    1341          
    1342             for(unsigned int i=0;i<_pointList.size();++i)  
     1341 
     1342            for(unsigned int i=0;i<_pointList.size();++i) 
    13431343            { 
    13441344                osg::Vec4& value = array[i]; 
    13451345                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
    1346                 attributes.push_back(value.x());   
    1347                 attributes.push_back(value.y());   
    1348                 attributes.push_back(value.z());   
    1349                 attributes.push_back(value.w());   
    1350             } 
    1351         } 
    1352          
     1346                attributes.push_back(value.x()); 
     1347                attributes.push_back(value.y()); 
     1348                attributes.push_back(value.z()); 
     1349                attributes.push_back(value.w()); 
     1350            } 
     1351        } 
     1352 
    13531353        EdgeCollapse::PointList& _pointList; 
    1354          
    1355          
     1354 
     1355 
    13561356    protected: 
    1357      
     1357 
    13581358        CopyArrayToPointsVisitor& operator = (const CopyArrayToPointsVisitor&) { return *this; } 
    13591359}; 
     
    13641364        CopyVertexArrayToPointsVisitor(EdgeCollapse::PointList& pointList): 
    13651365            _pointList(pointList) {} 
    1366          
     1366 
    13671367        virtual void apply(osg::Vec2Array& array) 
    13681368        { 
    13691369            if (_pointList.size()!=array.size()) return; 
    1370          
    1371             for(unsigned int i=0;i<_pointList.size();++i)  
     1370 
     1371            for(unsigned int i=0;i<_pointList.size();++i) 
    13721372            { 
    13731373                _pointList[i] = new EdgeCollapse::Point; 
    13741374                _pointList[i]->_index = i; 
    1375                  
     1375 
    13761376                osg::Vec2& value = array[i]; 
    13771377                osg::Vec3& vertex = _pointList[i]->_vertex; 
    1378                 vertex.set(value.x(),value.y(),0.0f);   
     1378                vertex.set(value.x(),value.y(),0.0f); 
    13791379            } 
    13801380        } 
     
    13831383        { 
    13841384            if (_pointList.size()!=array.size()) return; 
    1385          
    1386             for(unsigned int i=0;i<_pointList.size();++i)  
     1385 
     1386            for(unsigned int i=0;i<_pointList.size();++i) 
    13871387            { 
    13881388                _pointList[i] = new EdgeCollapse::Point; 
    13891389                _pointList[i]->_index = i; 
    1390                  
     1390 
    13911391                _pointList[i]->_vertex = array[i]; 
    13921392            } 
    13931393        } 
    1394          
     1394 
    13951395        virtual void apply(osg::Vec4Array& array) 
    13961396        { 
    13971397            if (_pointList.size()!=array.size()) return; 
    1398          
    1399             for(unsigned int i=0;i<_pointList.size();++i)  
     1398 
     1399            for(unsigned int i=0;i<_pointList.size();++i) 
    14001400            { 
    14011401                _pointList[i] = new EdgeCollapse::Point; 
    14021402                _pointList[i]->_index = i; 
    1403                  
     1403 
    14041404                osg::Vec4& value = array[i]; 
    14051405                osg::Vec3& vertex = _pointList[i]->_vertex; 
    1406                 vertex.set(value.x()/value.w(),value.y()/value.w(),value.z()/value.w());   
    1407             } 
    1408         } 
    1409          
     1406                vertex.set(value.x()/value.w(),value.y()/value.w(),value.z()/value.w()); 
     1407            } 
     1408        } 
     1409 
    14101410        EdgeCollapse::PointList& _pointList; 
    14111411 
    14121412    protected: 
    1413      
     1413 
    14141414        CopyVertexArrayToPointsVisitor& operator = (const CopyVertexArrayToPointsVisitor&) { return *this; } 
    14151415 
     
    14191419{ 
    14201420    _geometry = geometry; 
    1421      
     1421 
    14221422    // check to see if vertex attributes indices exists, if so expand them to remove them 
    14231423    if (_geometry->suitableForOptimization()) 
     
    14271427        _geometry->copyToAndOptimize(*_geometry); 
    14281428    } 
    1429      
     1429 
    14301430    // check to see if vertex attributes indices exists, if so expand them to remove them 
    14311431    if (_geometry->containsSharedArrays()) 
     
    14371437 
    14381438    unsigned int numVertices = geometry->getVertexArray()->getNumElements(); 
    1439          
     1439 
    14401440    _originalPointList.resize(numVertices); 
    1441      
     1441 
    14421442    // copy vertices across to local point list 
    14431443    CopyVertexArrayToPointsVisitor copyVertexArrayToPoints(_originalPointList); 
    14441444    _geometry->getVertexArray()->accept(copyVertexArrayToPoints); 
    1445      
     1445 
    14461446    // copy other per vertex attributes across to local point list. 
    14471447    CopyArrayToPointsVisitor        copyArrayToPoints(_originalPointList); 
     
    14551455    if (_geometry->getNormalArray() && _geometry->getNormalBinding()==osg::Geometry::BIND_PER_VERTEX) 
    14561456        geometry->getNormalArray()->accept(copyArrayToPoints); 
    1457          
     1457 
    14581458    if (_geometry->getColorArray() && _geometry->getColorBinding()==osg::Geometry::BIND_PER_VERTEX) 
    14591459        geometry->getColorArray()->accept(copyArrayToPoints); 
    1460          
     1460 
    14611461    if (_geometry->getSecondaryColorArray() && _geometry->getSecondaryColorBinding()==osg::Geometry::BIND_PER_VERTEX) 
    14621462        geometry->getSecondaryColorArray()->accept(copyArrayToPoints); 
     
    14821482    CollectTriangleIndexFunctor collectTriangles; 
    14831483    collectTriangles.setEdgeCollapse(this); 
    1484      
     1484 
    14851485    _geometry->accept(collectTriangles); 
    1486      
     1486 
    14871487} 
    1488   
     1488 
    14891489 
    14901490 
     
    15011501        { 
    15021502            array.resize(_pointList.size()); 
    1503          
    1504             for(unsigned int i=0;i<_pointList.size();++i)  
    1505             { 
    1506                 if (_index<_pointList[i]->_attributes.size())  
     1503 
     1504            for(unsigned int i=0;i<_pointList.size();++i) 
     1505            { 
     1506                if (_index<_pointList[i]->_attributes.size()) 
    15071507                { 
    15081508                    float val = (_pointList[i]->_attributes[_index]); 
     
    15101510                } 
    15111511            } 
    1512                  
     1512 
    15131513            ++_index; 
    15141514        } 
    1515          
     1515 
    15161516        // use local typedefs if usinged char,short and int to get round gcc 3.3.1 problem with defining unsigned short() 
    15171517        typedef unsigned char dummy_uchar; 
    15181518        typedef unsigned short dummy_ushort; 
    15191519        typedef unsigned int dummy_uint; 
    1520          
     1520 
    15211521        virtual void apply(osg::Array&) {} 
    15221522        virtual void apply(osg::ByteArray& array) { copy(array, char());} 
     
    15311531        { 
    15321532            array.resize(_pointList.size()); 
    1533          
    1534             for(unsigned int i=0;i<_pointList.size();++i)  
     1533 
     1534            for(unsigned int i=0;i<_pointList.size();++i) 
    15351535            { 
    15361536                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
     
    15461546        { 
    15471547            array.resize(_pointList.size()); 
    1548          
    1549             for(unsigned int i=0;i<_pointList.size();++i)  
     1548 
     1549            for(unsigned int i=0;i<_pointList.size();++i) 
    15501550            { 
    15511551                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
     
    15581558        { 
    15591559            array.resize(_pointList.size()); 
    1560          
    1561             for(unsigned int i=0;i<_pointList.size();++i)  
     1560 
     1561            for(unsigned int i=0;i<_pointList.size();++i) 
    15621562            { 
    15631563                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
     
    15661566            _index += 3; 
    15671567        } 
    1568          
     1568 
    15691569        virtual void apply(osg::Vec4Array& array) 
    15701570        { 
    15711571            array.resize(_pointList.size()); 
    1572          
    1573             for(unsigned int i=0;i<_pointList.size();++i)  
     1572 
     1573            for(unsigned int i=0;i<_pointList.size();++i) 
    15741574            { 
    15751575                EdgeCollapse::FloatList& attributes = _pointList[i]->_attributes; 
     
    15781578            _index += 4; 
    15791579        } 
    1580          
     1580 
    15811581        EdgeCollapse::PointList& _pointList; 
    15821582        unsigned int _index; 
    1583          
     1583 
    15841584    protected: 
    1585      
     1585 
    15861586        CopyPointsToArrayVisitor& operator = (CopyPointsToArrayVisitor&) { return *this; } 
    15871587}; 
     
    15911591    public: 
    15921592        NormalizeArrayVisitor() {} 
    1593          
     1593 
    15941594        template<typename Itr> 
    15951595        void normalize(Itr begin, Itr end) 
     
    16021602            } 
    16031603        } 
    1604          
     1604 
    16051605        virtual void apply(osg::Vec2Array& array) { normalize(array.begin(),array.end()); } 
    16061606        virtual void apply(osg::Vec3Array& array) { normalize(array.begin(),array.end()); } 
    16071607        virtual void apply(osg::Vec4Array& array) { normalize(array.begin(),array.end()); } 
    1608          
     1608 
    16091609}; 
    16101610 
     
    16141614        CopyPointsToVertexArrayVisitor(EdgeCollapse::PointList& pointList): 
    16151615            _pointList(pointList) {} 
    1616          
     1616 
    16171617        virtual void apply(osg::Vec2Array& array) 
    16181618        { 
    16191619            array.resize(_pointList.size()); 
    1620              
    1621             for(unsigned int i=0;i<_pointList.size();++i)  
     1620 
     1621            for(unsigned int i=0;i<_pointList.size();++i) 
    16221622            { 
    16231623                _pointList[i]->_index = i; 
     
    16301630        { 
    16311631            array.resize(_pointList.size()); 
    1632          
    1633             for(unsigned int i=0;i<_pointList.size();++i)  
     1632 
     1633            for(unsigned int i=0;i<_pointList.size();++i) 
    16341634            { 
    16351635                _pointList[i]->_index = i; 
     
    16371637            } 
    16381638        } 
    1639          
     1639 
    16401640        virtual void apply(osg::Vec4Array& array) 
    16411641        { 
    16421642            array.resize(_pointList.size()); 
    1643          
    1644             for(unsigned int i=0;i<_pointList.size();++i)  
     1643 
     1644            for(unsigned int i=0;i<_pointList.size();++i) 
    16451645            { 
    16461646                _pointList[i]->_index = i; 
     
    16491649            } 
    16501650        } 
    1651          
     1651 
    16521652        EdgeCollapse::PointList& _pointList; 
    1653          
     1653 
    16541654    protected: 
    1655      
     1655 
    16561656        CopyPointsToVertexArrayVisitor& operator = (const CopyPointsToVertexArrayVisitor&) { return *this; } 
    16571657}; 
     
    16681668    CopyPointsToVertexArrayVisitor copyVertexArrayToPoints(_originalPointList); 
    16691669    _geometry->getVertexArray()->accept(copyVertexArrayToPoints); 
    1670      
     1670 
    16711671    // copy other per vertex attributes across to local point list. 
    16721672    CopyPointsToArrayVisitor  copyArrayToPoints(_originalPointList); 
     
    16861686        _geometry->getNormalArray()->accept(nav); 
    16871687    } 
    1688          
     1688 
    16891689    if (_geometry->getColorArray() && _geometry->getColorBinding()==osg::Geometry::BIND_PER_VERTEX) 
    16901690        _geometry->getColorArray()->accept(copyArrayToPoints); 
    1691          
     1691 
    16921692    if (_geometry->getSecondaryColorArray() && _geometry->getSecondaryColorBinding()==osg::Geometry::BIND_PER_VERTEX) 
    16931693        _geometry->getSecondaryColorArray()->accept(copyArrayToPoints); 
     
    17221722        (*primitives)[pos++] = triangle->_p3->_index; 
    17231723    } 
    1724      
     1724 
    17251725    _geometry->getPrimitiveSetList().clear(); 
    17261726    _geometry->addPrimitiveSet(primitives); 
     
    17361736            _triStrip(true), 
    17371737            _smoothing(true) 
    1738              
     1738 
    17391739{ 
    17401740} 
     
    17591759 
    17601760    unsigned int numOriginalPrimitives = ec._triangleSet.size(); 
    1761      
     1761 
    17621762    if (getSampleRatio()<1.0) 
    17631763    { 
    17641764        while (!ec._edgeSet.empty() && 
    1765                continueSimplification((*ec._edgeSet.begin())->getErrorMetric() , numOriginalPrimitives, ec._triangleSet.size()) &&  
     1765               continueSimplification((*ec._edgeSet.begin())->getErrorMetric() , numOriginalPrimitives, ec._triangleSet.size()) && 
    17661766               ec.collapseMinimumErrorEdge()) 
    17671767        { 
     
    17761776        // up sampling... 
    17771777        while (!ec._edgeSet.empty() && 
    1778                continueSimplification((*ec._edgeSet.rbegin())->getErrorMetric() , numOriginalPrimitives, ec._triangleSet.size()) &&  
     1778               continueSimplification((*ec._edgeSet.rbegin())->getErrorMetric() , numOriginalPrimitives, ec._triangleSet.size()) && 
    17791779//               ec._triangleSet.size() < targetNumTriangles  && 
    17801780               ec.divideLongestEdge()) 
     
    17991799        OSG_INFO<<           "        continueSimplification(,,)  = "<<continueSimplification((*ec._edgeSet.begin())->getErrorMetric() , numOriginalPrimitives, ec._triangleSet.size())<<std::endl; 
    18001800    } 
    1801      
     1801 
    18021802    ec.copyBackToGeometry(); 
    18031803 
     
    18061806        osgUtil::SmoothingVisitor::smooth(geometry); 
    18071807    } 
    1808      
     1808 
    18091809    if (_triStrip) 
    18101810    {