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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgSim/ElevationSlice.cpp

    r11487 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*/ 
     
    5454 
    5555        _angleIncrement = 0.005; 
    56          
    57         _radiusList.push_back(_startRadius);         
     56 
     57        _radiusList.push_back(_startRadius); 
    5858        _distanceList.push_back(0.0); 
    59          
     59 
    6060        osg::Matrixd rotationMatrix; 
    6161        double angleBetweenStartEnd = acos( _startNormal * _endNormal ); 
     
    6868            rotationMatrix.makeRotate(angle, normal); 
    6969            osg::Vec3d newVector = osg::Matrixd::transform3x3(_startPoint, rotationMatrix); 
    70              
     70 
    7171            _em->convertXYZToLatLongHeight(newVector.x(), newVector.y(), newVector.z(), latitude, longitude, height); 
    7272            double newRadius = newVector.length() - height; 
    73              
     73 
    7474            double distanceIncrement = _angleIncrement * (newRadius + prevRadius) *0.5; 
    7575            distance  += distanceIncrement; 
    76              
     76 
    7777            _radiusList.push_back(newRadius); 
    7878            _distanceList.push_back(distance); 
    79              
     79 
    8080            // OSG_NOTICE<<"  newVector = "<<newVector<<" newRadius = "<<newRadius<<" distanceIncrement="<<distanceIncrement<<std::endl; 
    81              
     81 
    8282            prevRadius = newRadius; 
    8383        } 
    8484 
    8585    } 
    86      
    87          
     86 
     87 
    8888    void computeDistanceHeight(const osg::Vec3d& v, double& distance, double& height) const 
    8989    { 
     
    9595        _em->convertXYZToLatLongHeight(v.x(), v.y(), v.z(), 
    9696                                       latitude, longitude, height); 
    97                                         
     97 
    9898        // compute the radius at the point 
    9999        double Rv = v.length() - height; 
     
    101101        // compute the angle from the _startPoint 
    102102        double alpha = acos( vNormal * _startNormal); 
    103          
     103 
    104104        unsigned int int_alpha = static_cast<unsigned int>(floor(alpha / _angleIncrement)); 
    105105        if (int_alpha >= _distanceList.size()) 
     
    107107            int_alpha = _distanceList.size() - 1; 
    108108        } 
    109          
     109 
    110110        double prevAlpha = ((double)int_alpha) * _angleIncrement; 
    111111        double deltaAlpha = alpha - prevAlpha; 
    112112        double prevDistance = _distanceList[int_alpha]; 
    113113        double prevRadius = _radiusList[int_alpha]; 
    114          
     114 
    115115        double averageRadius = (prevRadius + Rv)*0.5; 
    116116        double distanceIncrement = deltaAlpha * averageRadius; 
    117          
     117 
    118118        distance = prevDistance + distanceIncrement; 
    119119 
    120120#if 0 
    121121        double oldDistance = alpha * (_startRadius + Rv) *0.5; 
    122          
     122 
    123123        distance = oldDistance; 
    124124 
     
    141141 
    142142    double                              _angleIncrement; 
    143      
    144     DoubleList                          _radiusList;     
    145     DoubleList                          _distanceList;     
     143 
     144    DoubleList                          _radiusList; 
     145    DoubleList                          _distanceList; 
    146146 
    147147}; 
     
    169169        if (distance < rhs.distance) return true; 
    170170        if (distance > rhs.distance) return false; 
    171          
     171 
    172172        // smallest heights first 
    173173        return (height < rhs.height); 
    174174    } 
    175      
     175 
    176176    bool operator == (const DistanceHeightXYZ& rhs) const 
    177177    { 
    178178        return distance==rhs.distance && height==rhs.height; 
    179179    } 
    180      
     180 
    181181    bool operator != (const DistanceHeightXYZ& rhs) const 
    182182    { 
    183183        return distance!=rhs.distance || height!=rhs.height; 
    184184    } 
    185      
     185 
    186186    bool equal_distance(const DistanceHeightXYZ& rhs, double epsilon=1e-6) const 
    187187    { 
     
    202202        //OSG_NOTICE<<"Point::Point distance="<<distance<<" height="<<height<<" position="<<position<<std::endl; 
    203203    } 
    204      
     204 
    205205    Point(const Point& point): 
    206206        osg::Referenced(), 
     
    237237        return (*_p2 < *rhs._p2); 
    238238    } 
    239      
     239 
    240240    enum Classification 
    241241    { 
     
    248248        ENCLOSED 
    249249    }; 
    250      
     250 
    251251    Classification compare(const Segment& rhs) const 
    252252    { 
     
    267267 
    268268        if (rhs._p2->distance < _p1->distance || _p2->distance < rhs._p1->distance) return SEPERATE; 
    269          
     269 
    270270        bool rhs_p1_inside = (_p1->distance <= rhs._p1->distance) && (rhs._p1->distance <= _p2->distance); 
    271271        bool rhs_p2_inside = (_p1->distance <= rhs._p2->distance) && (rhs._p2->distance <= _p2->distance); 
    272          
     272 
    273273        if (rhs_p1_inside && rhs_p2_inside) return ENCLOSING; 
    274          
     274 
    275275        bool p1_inside = (rhs._p1->distance <= _p1->distance) && (_p1->distance <= rhs._p2->distance); 
    276276        bool p2_inside = (rhs._p1->distance <= _p2->distance) && (_p2->distance <= rhs._p2->distance); 
     
    279279 
    280280        if (rhs_p1_inside || rhs_p2_inside || p1_inside || p2_inside) return OVERLAPPING; 
    281          
     281 
    282282        return UNCLASSIFIED; 
    283283    } 
    284      
     284 
    285285    double height(double d) const 
    286286    { 
     
    288288        return _p1->height + ((_p2->height - _p1->height) * (d - _p1->distance) / delta); 
    289289    } 
    290      
     290 
    291291    double deltaHeight(Point& point) const 
    292292    { 
    293293        return point.height - height(point.distance); 
    294294    } 
    295      
     295 
    296296    Point* createPoint(double d) const 
    297297    { 
    298298        if (d == _p1->distance) return _p1.get(); 
    299299        if (d == _p2->distance) return _p2.get(); 
    300          
     300 
    301301        double delta = (_p2->distance - _p1->distance); 
    302302        double r = (d - _p1->distance)/delta; 
    303303        double one_minus_r = 1.0 - r; 
    304         return new Point(d,  
     304        return new Point(d, 
    305305                         _p1->height * one_minus_r + _p2->height * r, 
    306306                         _p1->position * one_minus_r + _p2->position * r); 
     
    313313        double C = _p1->height; 
    314314        double D = _p2->height - _p1->height; 
    315          
     315 
    316316        double E = rhs._p1->distance; 
    317317        double F = rhs._p2->distance - rhs._p1->distance; 
    318318        double G = rhs._p1->height; 
    319319        double H = rhs._p2->height - rhs._p1->height; 
    320          
     320 
    321321        double div = D*F - B*H; 
    322322        if (div==0.0) 
     
    325325            return _p2.get(); 
    326326        } 
    327          
     327 
    328328        double r = (G*F - E*H + A*H - C*F) / div; 
    329          
     329 
    330330        if (r<0.0) 
    331331        { 
     
    333333            return _p1.get(); 
    334334        } 
    335          
     335 
    336336        if (r>1.0) 
    337337        { 
     
    339339            return _p2.get(); 
    340340        } 
    341          
     341 
    342342//         OSG_NOTICE<<"ElevationSlideUtils::Segment::createIntersectionPoint(): r="<<r<<std::endl; 
    343343//         OSG_NOTICE<<"\tp1 = "<<_p1->distance<<" "<<_p1->height<<"  p2 = "<<_p2->distance<<" "<<_p2->height<<std::endl; 
     
    360360 
    361361    LineConstructor() {} 
    362      
    363      
    364      
     362 
     363 
     364 
    365365    void add(double d, double h, const osg::Vec3d& pos) 
    366366    { 
    367367        osg::ref_ptr<Point> newPoint = new Point(d,h,pos); 
    368          
    369          
     368 
     369 
    370370        if (_previousPoint.valid() && newPoint->distance != _previousPoint->distance) 
    371371        { 
    372372            const double maxGradient = 100.0; 
    373373            double gradient = fabs( (newPoint->height - _previousPoint->height) / (newPoint->distance - _previousPoint->distance) ); 
    374              
     374 
    375375            if (gradient < maxGradient) 
    376376            { 
     
    378378            } 
    379379        } 
    380          
     380 
    381381        _previousPoint = newPoint; 
    382382    } 
    383      
     383 
    384384    void endline() 
    385385    { 
    386386        _previousPoint = 0; 
    387387    } 
    388      
     388 
    389389    void report() 
    390390    { 
    391391 
    392392        OSG_NOTICE<<"Number of segments = "<<_segments.size()<<std::endl; 
    393          
     393 
    394394        for(SegmentSet::iterator itr = _segments.begin(); 
    395395             itr != _segments.end(); 
     
    415415                } 
    416416            } 
    417              
     417 
    418418            OSG_NOTICE<<std::endl; 
    419419 
     
    448448            } 
    449449        } 
    450          
    451     } 
    452      
     450 
     451    } 
     452 
    453453    void pruneOverlappingSegments() 
    454454    { 
     
    456456        SegmentSet::iterator nextItr = prevItr; 
    457457        ++nextItr; 
    458          
     458 
    459459        double epsilon = 0.001; 
    460          
     460 
    461461        for(SegmentSet::iterator itr = _segments.begin(); 
    462462            itr != _segments.end(); 
     
    490490 
    491491                        if (rhs_p1_inside && lhs_p2_inside) 
    492                         {                     
    493                             double distance_between = osg::Vec2d(lhs._p2->distance - rhs._p1->distance,  
     492                        { 
     493                            double distance_between = osg::Vec2d(lhs._p2->distance - rhs._p1->distance, 
    494494                                                                 lhs._p2->height - rhs._p1->height).length2(); 
    495495 
     
    500500                                Segment newSeg(lhs._p2.get(), rhs._p2.get()); 
    501501                                _segments.insert(newSeg); 
    502                                  
     502 
    503503                                _segments.erase(nextItr); 
    504                                  
     504 
    505505                                nextItr = _segments.find(newSeg); 
    506506                            } 
     
    526526                                    Segment seg3( cp, lhs._p2.get() ); 
    527527                                    Segment seg4( rhs.createPoint(lhs._p2->distance), lhs._p2.get() ); 
    528                                      
     528 
    529529                                    _segments.erase(nextItr); 
    530530                                    _segments.erase(itr); 
     
    534534                                    _segments.insert(seg3); 
    535535                                    _segments.insert(seg4); 
    536                                      
     536 
    537537                                    itr = _segments.find(seg1); 
    538538                                    nextItr = itr; 
     
    565565//                                     OSG_NOTICE<<"    rhs_p1 "<<rhs._p1->distance<<" "<<rhs._p1->height<<std::endl; 
    566566//                                     OSG_NOTICE<<"    rhs_p2 "<<rhs._p2->distance<<" "<<rhs._p2->height<<std::endl; 
    567                                      
    568                                      
     567 
     568 
    569569                                    Segment newSeg(lhs._p1.get(), lhs.createPoint(rhs._p1->distance)); 
    570570 
     
    620620                        else if (dh1>=0.0 && dh2>=0.0) 
    621621                        { 
    622                              
     622 
    623623                            double d_left = enclosed._p1->distance - enclosing._p1->distance; 
    624624                            double d_right = enclosing._p2->distance - enclosed._p2->distance; 
     
    626626                            if (d_left < epsilon && d_right < epsilon) 
    627627                            { 
    628                                 // treat ENCLOSED as ENCLOSING.                                 
     628                                // treat ENCLOSED as ENCLOSING. 
    629629                                // OSG_NOTICE<<"   Treat enclosed above as enclosing "<<std::endl; 
    630630 
     
    633633 
    634634                                _segments.erase(itr); 
    635                                  
     635 
    636636                                itr = nextItr; 
    637637                                ++nextItr; 
     
    641641                            { 
    642642//                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl; 
    643 //  
     643// 
    644644//                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl; 
    645645//                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl; 
    646646//                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl; 
    647647//                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl; 
    648 //  
     648// 
    649649//                                 OSG_NOTICE<<"   Replace enclosing with right section"<<std::endl; 
    650650 
     
    655655                                _segments.erase(itr); 
    656656                                _segments.insert(newSeg); 
    657                                  
     657 
    658658                                itr = nextItr; 
    659659                                ++nextItr; 
     
    665665                            { 
    666666//                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl; 
    667 //  
     667// 
    668668//                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl; 
    669669//                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl; 
    670670//                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl; 
    671671//                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl; 
    672 //  
     672// 
    673673//                                 OSG_NOTICE<<"   Replace enclosing with left section"<<std::endl; 
    674674 
     
    685685//                                 OSG_NOTICE<<"    newSeg_p2 "<<newSeg._p2->distance<<" "<<newSeg._p2->height<<std::endl; 
    686686                            } 
    687                             else  
     687                            else 
    688688                            { 
    689689//                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl; 
    690 //  
     690// 
    691691//                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl; 
    692692//                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl; 
    693693//                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl; 
    694694//                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl; 
    695 //  
     695// 
    696696//                                 OSG_NOTICE<<"   Replace enclosing with left and right sections"<<std::endl; 
    697697 
     
    703703                                _segments.insert(newSegLeft); 
    704704                                _segments.insert(newSegRight); 
    705                                  
     705 
    706706                                itr = _segments.find(newSegLeft); 
    707707                                nextItr = itr; 
     
    719719                        { 
    720720//                             OSG_NOTICE<<"ENCLOSING: ENCLOSING is crossing enclosed "<<dh1<<" "<<dh2<<std::endl; 
    721 //                              
     721// 
    722722//                             OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl; 
    723723//                             OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl; 
     
    730730                            if (d_left < epsilon && d_right < epsilon) 
    731731                            { 
    732                                 // treat ENCLOSED as ENCLOSING.                                 
     732                                // treat ENCLOSED as ENCLOSING. 
    733733                                if (dh1 < 0.0) 
    734734                                { 
    735735                                    // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    736                                      
     736 
    737737                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    738738                                    Segment newSegLeft(enclosing._p1.get(), cp); 
    739739                                    Segment newSegRight(cp, enclosed._p2.get()); 
    740                                      
     740 
    741741                                    _segments.erase(itr); 
    742742                                    _segments.erase(nextItr); 
    743                                      
     743 
    744744                                    _segments.insert(newSegLeft); 
    745745                                    _segments.insert(newSegRight); 
    746                                      
     746 
    747747                                    itr = _segments.find(newSegLeft); 
    748748                                    nextItr = itr; 
    749749                                    ++nextItr; 
    750750                                } 
    751                                 else  
     751                                else 
    752752                                { 
    753753                                    // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    754                                      
     754 
    755755                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    756756                                    Segment newSegLeft(enclosed._p1.get(), cp); 
    757757                                    Segment newSegRight(cp, enclosing._p2.get()); 
    758                                      
     758 
    759759                                    _segments.erase(itr); 
    760760                                    _segments.erase(nextItr); 
    761                                      
     761 
    762762                                    _segments.insert(newSegLeft); 
    763763                                    _segments.insert(newSegRight); 
    764                                      
     764 
    765765                                    itr = _segments.find(newSegLeft); 
    766766                                    nextItr = itr; 
     
    776776                                { 
    777777                                    // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    778                                      
     778 
    779779                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    780780                                    Segment newSegLeft(enclosing._p1.get(), cp); 
    781781                                    Segment newSegMid(cp, enclosed._p2.get()); 
    782782                                    Segment newSegRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get()); 
    783                                      
     783 
    784784                                    _segments.erase(itr); 
    785785                                    _segments.erase(nextItr); 
    786                                      
     786 
    787787                                    _segments.insert(newSegLeft); 
    788788                                    _segments.insert(newSegMid); 
    789789                                    _segments.insert(newSegRight); 
    790                                      
     790 
    791791                                    itr = _segments.find(newSegLeft); 
    792792                                    nextItr = itr; 
    793793                                    ++nextItr; 
    794794                                } 
    795                                 else  
     795                                else 
    796796                                { 
    797797                                    // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    798                                      
     798 
    799799                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    800800                                    Segment newSegLeft(enclosed._p1.get(), cp); 
    801801                                    Segment newSegRight(cp, enclosing._p2.get()); 
    802                                      
     802 
    803803                                    _segments.erase(itr); 
    804804                                    _segments.erase(nextItr); 
    805                                      
     805 
    806806                                    _segments.insert(newSegLeft); 
    807807                                    _segments.insert(newSegRight); 
    808                                      
     808 
    809809                                    itr = _segments.find(newSegLeft); 
    810810                                    nextItr = itr; 
     
    819819                                { 
    820820//                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    821                                      
     821 
    822822                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    823823                                    Segment newSegLeft(enclosing._p1.get(), cp); 
    824824                                    Segment newSegRight(cp, enclosed._p2.get()); 
    825                                      
     825 
    826826                                    _segments.erase(itr); 
    827827                                    _segments.erase(nextItr); 
    828                                      
     828 
    829829                                    _segments.insert(newSegLeft); 
    830830                                    _segments.insert(newSegRight); 
    831                                      
     831 
    832832                                    itr = _segments.find(newSegLeft); 
    833833                                    nextItr = itr; 
    834834                                    ++nextItr; 
    835835                                } 
    836                                 else  
     836                                else 
    837837                                { 
    838838//                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    839                                      
     839 
    840840                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    841841                                    Segment newSegLeft(enclosing._p1.get(), enclosing.createPoint(enclosed._p1->distance)); 
    842842                                    Segment newSegMid(enclosed._p1.get(), cp); 
    843843                                    Segment newSegRight(cp, enclosing._p2.get()); 
    844                                      
     844 
    845845                                    _segments.erase(itr); 
    846846                                    _segments.erase(nextItr); 
    847                                      
     847 
    848848                                    _segments.insert(newSegLeft); 
    849849                                    _segments.insert(newSegMid); 
    850850                                    _segments.insert(newSegRight); 
    851                                      
     851 
    852852                                    itr = _segments.find(newSegLeft); 
    853853                                    nextItr = itr; 
     
    855855                                } 
    856856                            } 
    857                             else  
     857                            else 
    858858                            { 
    859859//                                OSG_NOTICE<<"   >> Replace enclosing with left and right sections"<<std::endl; 
     
    863863                                { 
    864864//                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    865                                      
     865 
    866866                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    867867                                    Segment newSegLeft(enclosing._p1.get(), cp); 
    868868                                    Segment newSegMid(cp, enclosed._p2.get()); 
    869869                                    Segment newSegRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get()); 
    870                                      
     870 
    871871                                    _segments.erase(itr); 
    872872                                    _segments.erase(nextItr); 
    873                                      
     873 
    874874                                    _segments.insert(newSegLeft); 
    875875                                    _segments.insert(newSegMid); 
    876876                                    _segments.insert(newSegRight); 
    877                                      
     877 
    878878                                    itr = _segments.find(newSegLeft); 
    879879                                    nextItr = itr; 
    880880                                    ++nextItr; 
    881881                                } 
    882                                 else  
     882                                else 
    883883                                { 
    884884//                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl; 
    885                                      
     885 
    886886                                    Point* cp = enclosing.createIntersectionPoint(enclosed); 
    887887                                    Segment newSegLeft(enclosing._p1.get(), enclosing.createPoint(enclosed._p1->distance)); 
    888888                                    Segment newSegMid(enclosed._p1.get(), cp); 
    889889                                    Segment newSegRight(cp, enclosing._p2.get()); 
    890                                      
     890 
    891891                                    _segments.erase(itr); 
    892892                                    _segments.erase(nextItr); 
    893                                      
     893 
    894894                                    _segments.insert(newSegLeft); 
    895895                                    _segments.insert(newSegMid); 
    896896                                    _segments.insert(newSegRight); 
    897                                      
     897 
    898898                                    itr = _segments.find(newSegLeft); 
    899899                                    nextItr = itr; 
     
    906906                        { 
    907907                            OSG_NOTICE<<"ENCLOSING: ENCLOSING - error case "<<dh1<<" "<<dh2<<std::endl; 
    908                              
     908 
    909909                            OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl; 
    910910                            OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl; 
     
    926926                        double d_left = enclosed._p1->distance - enclosing._p1->distance; 
    927927                        double d_right = enclosing._p2->distance - enclosed._p2->distance; 
    928                          
     928 
    929929                        if (d_left<=epsilon) 
    930930                        { 
     
    946946//                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl; 
    947947//                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl; 
    948                                  
     948 
    949949                                _segments.insert(Segment(enclosing.createPoint(enclosed._p2->distance), enclosed._p2.get())); 
    950950                                _segments.erase(nextItr); 
     
    960960//                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl; 
    961961//                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl; 
    962                                  
     962 
    963963                                if (d_right<=epsilon) 
    964964                                { 
     
    969969                                        Segment segLeft(enclosed._p1.get(), cp); 
    970970                                        Segment segRight(cp, enclosing._p2.get()); 
    971                                          
     971 
    972972                                        _segments.erase(itr); 
    973973                                        _segments.erase(nextItr); 
    974                                          
     974 
    975975                                        _segments.insert(segLeft); 
    976976                                        _segments.insert(segRight); 
    977                                          
     977 
    978978                                        itr = _segments.find(segLeft); 
    979979                                        nextItr = itr; 
     
    985985                                        Segment segLeft(enclosing._p1.get(), cp); 
    986986                                        Segment segRight(cp, enclosed._p2.get()); 
    987                                          
     987 
    988988                                        _segments.erase(itr); 
    989989                                        _segments.erase(nextItr); 
    990                                          
     990 
    991991                                        _segments.insert(segLeft); 
    992992                                        _segments.insert(segRight); 
    993                                          
     993 
    994994                                        itr = _segments.find(segLeft); 
    995995                                        nextItr = itr; 
     
    10051005                                        Segment segLeft(enclosed._p1.get(), cp); 
    10061006                                        Segment segRight(cp, enclosing._p2.get()); 
    1007                                          
     1007 
    10081008                                        _segments.erase(itr); 
    10091009                                        _segments.erase(nextItr); 
    1010                                          
     1010 
    10111011                                        _segments.insert(segLeft); 
    10121012                                        _segments.insert(segRight); 
    1013                                          
     1013 
    10141014                                        itr = _segments.find(segLeft); 
    10151015                                        nextItr = itr; 
     
    10221022                                        Segment segMid(cp, enclosed._p2.get()); 
    10231023                                        Segment segRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get()); 
    1024                                          
     1024 
    10251025                                        _segments.erase(itr); 
    10261026                                        _segments.erase(nextItr); 
    1027                                          
     1027 
    10281028                                        _segments.insert(segLeft); 
    10291029                                        _segments.insert(segMid); 
    10301030                                        _segments.insert(segRight); 
    1031                                          
     1031 
    10321032                                        itr = _segments.find(segLeft); 
    10331033                                        nextItr = itr; 
    10341034                                        ++nextItr; 
    10351035                                    } 
    1036                                 }                                 
     1036                                } 
    10371037                            } 
    10381038                            else 
     
    10531053                        break; 
    10541054                    } 
    1055                     default:  
     1055                    default: 
    10561056                        OSG_NOTICE<<"** Not handled, advancing"<<std::endl; 
    10571057                        ++nextItr; 
    10581058                        break; 
    10591059                } 
    1060                  
     1060 
    10611061                classification = ((itr != _segments.end()) && (nextItr != _segments.end())) ?  itr->compare(*nextItr) : Segment::UNCLASSIFIED; 
    10621062            } 
    10631063        } 
    10641064    } 
    1065      
     1065 
    10661066    unsigned int numOverlapping(SegmentSet::const_iterator startItr) const 
    10671067    { 
    10681068        if (startItr==_segments.end()) return 0; 
    1069      
     1069 
    10701070        SegmentSet::const_iterator nextItr = startItr; 
    10711071        ++nextItr; 
    1072          
     1072 
    10731073        unsigned int num = 0; 
    10741074        while (nextItr!=_segments.end() && startItr->compare(*nextItr)>=Segment::OVERLAPPING) 
     
    10791079        return num; 
    10801080    } 
    1081      
     1081 
    10821082    unsigned int totalNumOverlapping() const 
    10831083    { 
     
    10971097        SegmentSet::iterator nextItr = prevItr; 
    10981098        ++nextItr; 
    1099          
     1099 
    11001100        intersections.push_back( prevItr->_p1->position ); 
    11011101        distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(prevItr->_p1->distance, prevItr->_p1->height) ); 
    1102          
     1102 
    11031103        intersections.push_back( prevItr->_p2->position ); 
    11041104        distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(prevItr->_p2->distance, prevItr->_p2->height) ); 
    11051105 
    1106         for(;  
     1106        for(; 
    11071107            nextItr != _segments.end(); 
    11081108            ++nextItr,++prevItr) 
     
    11151115                    intersections.push_back( nextItr->_p1->position ); 
    11161116                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) ); 
    1117          
     1117 
    11181118                    intersections.push_back( nextItr->_p2->position ); 
    11191119                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) ); 
    11201120                    break; 
    11211121                } 
    1122                 case(Segment::JOINED):  
     1122                case(Segment::JOINED): 
    11231123                { 
    11241124#if 1 
    11251125                    intersections.push_back( nextItr->_p2->position ); 
    11261126                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) ); 
    1127 #else                 
     1127#else 
    11281128                    intersections.push_back( nextItr->_p1->position ); 
    11291129                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) ); 
    1130          
     1130 
    11311131                    intersections.push_back( nextItr->_p2->position ); 
    11321132                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) ); 
     
    11341134                    break; 
    11351135                } 
    1136                 default:  
     1136                default: 
    11371137                { 
    11381138                    intersections.push_back( nextItr->_p1->position ); 
    11391139                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) ); 
    1140          
     1140 
    11411141                    intersections.push_back( nextItr->_p2->position ); 
    11421142                    distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) ); 
     
    11441144                } 
    11451145            } 
    1146              
    1147         } 
    1148          
    1149     } 
    1150      
     1146 
     1147        } 
     1148 
     1149    } 
     1150 
    11511151    SegmentSet _segments; 
    11521152    osg::ref_ptr<Point> _previousPoint; 
    11531153    osg::Plane  _plane; 
    11541154    osg::ref_ptr<osg::EllipsoidModel>   _em; 
    1155      
     1155 
    11561156}; 
    11571157 
     
    11891189 
    11901190        OSG_NOTICE<<"end_lat = "<<end_latitude<<" end_longitude = "<<end_longitude<<" end_height = "<<end_height<<std::endl; 
    1191          
     1191 
    11921192        // set up the main intersection plane 
    11931193        osg::Vec3d planeNormal = (_endPoint - _startPoint) ^ start_upVector; 
    1194         planeNormal.normalize();         
     1194        planeNormal.normalize(); 
    11951195        plane.set( planeNormal, _startPoint ); 
    1196          
     1196 
    11971197        // set up the start cut off plane 
    11981198        osg::Vec3d startPlaneNormal = start_upVector ^ planeNormal; 
    11991199        startPlaneNormal.normalize(); 
    12001200        boundingPolytope.add( osg::Plane(startPlaneNormal, _startPoint) ); 
    1201          
     1201 
    12021202        // set up the end cut off plane 
    12031203        osg::Vec3d endPlaneNormal = planeNormal ^ end_upVector; 
     
    12111211        // set up the main intersection plane 
    12121212        osg::Vec3d planeNormal = (_endPoint - _startPoint) ^ upVector; 
    1213         planeNormal.normalize();         
     1213        planeNormal.normalize(); 
    12141214        plane.set( planeNormal, _startPoint ); 
    1215          
     1215 
    12161216        // set up the start cut off plane 
    12171217        osg::Vec3d startPlaneNormal = upVector ^ planeNormal; 
    12181218        startPlaneNormal.normalize(); 
    12191219        boundingPolytope.add( osg::Plane(startPlaneNormal, _startPoint) ); 
    1220          
     1220 
    12211221        // set up the end cut off plane 
    12221222        osg::Vec3d endPlaneNormal = planeNormal ^ upVector; 
     
    12241224        boundingPolytope.add( osg::Plane(endPlaneNormal, _endPoint) ); 
    12251225    } 
    1226      
     1226 
    12271227    osg::ref_ptr<osgUtil::PlaneIntersector> intersector = new osgUtil::PlaneIntersector(plane, boundingPolytope); 
    12281228 
     
    12341234    _intersectionVisitor.setTraversalMask(traversalMask); 
    12351235    _intersectionVisitor.setIntersector( intersector.get() ); 
    1236      
     1236 
    12371237    scene->accept(_intersectionVisitor); 
    1238      
     1238 
    12391239    osgUtil::PlaneIntersector::Intersections& intersections = intersector->getIntersections(); 
    12401240 
     
    12551255            { 
    12561256                // OSG_NOTICE<<"  transforming "<<std::endl; 
    1257                 // transform points on polyline  
     1257                // transform points on polyline 
    12581258                for(Polyline::iterator pitr = intersection.polyline.begin(); 
    12591259                    pitr != intersection.polyline.end(); 
     
    12621262                    *pitr = (*pitr) * (*intersection.matrix); 
    12631263                } 
    1264                  
     1264 
    12651265                // matrix no longer needed. 
    12661266                intersection.matrix = 0; 
     
    12701270#if 0 
    12711271        osg::ref_ptr<osg::Geode> geode = new osg::Geode; 
    1272          
     1272 
    12731273        for(itr = intersections.begin(); 
    12741274            itr != intersections.end(); 
     
    12901290            geometry->setVertexArray( vertices ); 
    12911291            geometry->addPrimitiveSet( new osg::DrawArrays(GL_LINE_STRIP, 0, vertices->size()) ); 
    1292              
     1292 
    12931293            osg::Vec4Array* colours = new osg::Vec4Array; 
    12941294            colours->push_back( osg::Vec4(1.0f,1.0f,1.0f,1.0f) ); 
    1295              
     1295 
    12961296            geometry->setColorArray( colours ); 
    12971297 
     
    12991299            geode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF ); 
    13001300        } 
    1301          
     1301 
    13021302        osgDB::writeNodeFile(*geode, "raw.osg"); 
    13031303#endif 
     
    13171317            { 
    13181318                osgUtil::PlaneIntersector::Intersection& intersection = *itr; 
    1319                  
     1319 
    13201320                if (intersection.attributes.size()!=intersection.polyline.size()) continue; 
    1321                  
     1321 
    13221322                Attributes::iterator aitr = intersection.attributes.begin(); 
    13231323                for(Polyline::iterator pitr = intersection.polyline.begin(); 
     
    13281328                    double distance, height; 
    13291329                    dhc.computeDistanceHeight(v, distance, height); 
    1330                      
     1330 
    13311331                    double pi_height = *aitr; 
    1332                      
     1332 
    13331333                    // OSG_NOTICE<<"computed height = "<<height<<" PI height = "<<pi_height<<std::endl; 
    13341334 
     
    13611361                constructor.endline(); 
    13621362            } 
    1363         }  
     1363        } 
    13641364 
    13651365        // copy final results 
     
    13741374        { 
    13751375            unsigned int previousNumOverlapping = numOverlapping; 
    1376          
     1376 
    13771377            constructor.pruneOverlappingSegments(); 
    13781378            // constructor.report(); 
    1379              
     1379 
    13801380            numOverlapping = constructor.totalNumOverlapping(); 
    13811381            if (previousNumOverlapping == numOverlapping) break; 
     
    13831383 
    13841384        constructor.copyPoints(_intersections, _distanceHeightIntersections); 
    1385          
     1385 
    13861386#if 0 
    13871387        { 
     
    14191419        OSG_NOTICE<<"No intersections found."<<std::endl; 
    14201420    } 
    1421      
     1421 
    14221422} 
    14231423