Changeset 13041 for OpenSceneGraph/trunk/src/osgSim/ElevationSlice.cpp

Timestamp:

03/21/12 18:36:20 (14 months ago)

Author:

robert

Message:

Ran script to remove trailing spaces and tabs

Files:

• OpenSceneGraph/trunk/src/osgSim/ElevationSlice.cpp (modified) (71 diffs)

OpenSceneGraph/trunk/src/osgSim/ElevationSlice.cpp

@@ -1 @@
-/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
  *
- * This library is open source and may be redistributed and/or modified under  
- * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * This library is open source and may be redistributed and/or modified under
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
  * (at your option) any later version.  The full license is in LICENSE file
  * included with this distribution, and on the openscenegraph.org website.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * OpenSceneGraph Public License for more details.
 */
@@ -54 +54 @@
 
         _angleIncrement = 0.005;
-        
-        _radiusList.push_back(_startRadius);        
+
+        _radiusList.push_back(_startRadius);
         _distanceList.push_back(0.0);
-        
+
         osg::Matrixd rotationMatrix;
         double angleBetweenStartEnd = acos( _startNormal * _endNormal );
@@ -68 +68 @@
             rotationMatrix.makeRotate(angle, normal);
             osg::Vec3d newVector = osg::Matrixd::transform3x3(_startPoint, rotationMatrix);
-            
+
             _em->convertXYZToLatLongHeight(newVector.x(), newVector.y(), newVector.z(), latitude, longitude, height);
             double newRadius = newVector.length() - height;
-            
+
             double distanceIncrement = _angleIncrement * (newRadius + prevRadius) *0.5;
             distance  += distanceIncrement;
-            
+
             _radiusList.push_back(newRadius);
             _distanceList.push_back(distance);
-            
+
             // OSG_NOTICE<<"  newVector = "<<newVector<<" newRadius = "<<newRadius<<" distanceIncrement="<<distanceIncrement<<std::endl;
-            
+
             prevRadius = newRadius;
         }
 
     }
-    
-        
+
+
     void computeDistanceHeight(const osg::Vec3d& v, double& distance, double& height) const
     {
@@ -95 +95 @@
         _em->convertXYZToLatLongHeight(v.x(), v.y(), v.z(),
                                        latitude, longitude, height);
-                                       
+
         // compute the radius at the point
         double Rv = v.length() - height;
@@ -101 +101 @@
         // compute the angle from the _startPoint
         double alpha = acos( vNormal * _startNormal);
-        
+
         unsigned int int_alpha = static_cast<unsigned int>(floor(alpha / _angleIncrement));
         if (int_alpha >= _distanceList.size())
@@ -107 +107 @@
             int_alpha = _distanceList.size() - 1;
         }
-        
+
         double prevAlpha = ((double)int_alpha) * _angleIncrement;
         double deltaAlpha = alpha - prevAlpha;
         double prevDistance = _distanceList[int_alpha];
         double prevRadius = _radiusList[int_alpha];
-        
+
         double averageRadius = (prevRadius + Rv)*0.5;
         double distanceIncrement = deltaAlpha * averageRadius;
-        
+
         distance = prevDistance + distanceIncrement;
 
 #if 0
         double oldDistance = alpha * (_startRadius + Rv) *0.5;
-        
+
         distance = oldDistance;
 
@@ -141 +141 @@
 
     double                              _angleIncrement;
-    
-    DoubleList                          _radiusList;    
-    DoubleList                          _distanceList;    
+
+    DoubleList                          _radiusList;
+    DoubleList                          _distanceList;
 
 };
@@ -169 +169 @@
         if (distance < rhs.distance) return true;
         if (distance > rhs.distance) return false;
-        
+
         // smallest heights first
         return (height < rhs.height);
     }
-    
+
     bool operator == (const DistanceHeightXYZ& rhs) const
     {
         return distance==rhs.distance && height==rhs.height;
     }
-    
+
     bool operator != (const DistanceHeightXYZ& rhs) const
     {
         return distance!=rhs.distance || height!=rhs.height;
     }
-    
+
     bool equal_distance(const DistanceHeightXYZ& rhs, double epsilon=1e-6) const
     {
@@ -202 +202 @@
         //OSG_NOTICE<<"Point::Point distance="<<distance<<" height="<<height<<" position="<<position<<std::endl;
     }
-    
+
     Point(const Point& point):
         osg::Referenced(),
@@ -237 +237 @@
         return (*_p2 < *rhs._p2);
     }
-    
+
     enum Classification
     {
@@ -248 +248 @@
         ENCLOSED
     };
-    
+
     Classification compare(const Segment& rhs) const
     {
@@ -267 +267 @@
 
         if (rhs._p2->distance < _p1->distance || _p2->distance < rhs._p1->distance) return SEPERATE;
-        
+
         bool rhs_p1_inside = (_p1->distance <= rhs._p1->distance) && (rhs._p1->distance <= _p2->distance);
         bool rhs_p2_inside = (_p1->distance <= rhs._p2->distance) && (rhs._p2->distance <= _p2->distance);
-        
+
         if (rhs_p1_inside && rhs_p2_inside) return ENCLOSING;
-        
+
         bool p1_inside = (rhs._p1->distance <= _p1->distance) && (_p1->distance <= rhs._p2->distance);
         bool p2_inside = (rhs._p1->distance <= _p2->distance) && (_p2->distance <= rhs._p2->distance);
@@ -279 +279 @@
 
         if (rhs_p1_inside || rhs_p2_inside || p1_inside || p2_inside) return OVERLAPPING;
-        
+
         return UNCLASSIFIED;
     }
-    
+
     double height(double d) const
     {
@@ -288 +288 @@
         return _p1->height + ((_p2->height - _p1->height) * (d - _p1->distance) / delta);
     }
-    
+
     double deltaHeight(Point& point) const
     {
         return point.height - height(point.distance);
     }
-    
+
     Point* createPoint(double d) const
     {
         if (d == _p1->distance) return _p1.get();
         if (d == _p2->distance) return _p2.get();
-        
+
         double delta = (_p2->distance - _p1->distance);
         double r = (d - _p1->distance)/delta;
         double one_minus_r = 1.0 - r;
-        return new Point(d, 
+        return new Point(d,
                          _p1->height * one_minus_r + _p2->height * r,
                          _p1->position * one_minus_r + _p2->position * r);
@@ -313 +313 @@
         double C = _p1->height;
         double D = _p2->height - _p1->height;
-        
+
         double E = rhs._p1->distance;
         double F = rhs._p2->distance - rhs._p1->distance;
         double G = rhs._p1->height;
         double H = rhs._p2->height - rhs._p1->height;
-        
+
         double div = D*F - B*H;
         if (div==0.0)
@@ -325 +325 @@
             return _p2.get();
         }
-        
+
         double r = (G*F - E*H + A*H - C*F) / div;
-        
+
         if (r<0.0)
         {
@@ -333 +333 @@
             return _p1.get();
         }
-        
+
         if (r>1.0)
         {
@@ -339 +339 @@
             return _p2.get();
         }
-        
+
 //         OSG_NOTICE<<"ElevationSlideUtils::Segment::createIntersectionPoint(): r="<<r<<std::endl;
 //         OSG_NOTICE<<"\tp1 = "<<_p1->distance<<" "<<_p1->height<<"  p2 = "<<_p2->distance<<" "<<_p2->height<<std::endl;
@@ -360 +360 @@
 
     LineConstructor() {}
-    
-    
-    
+
+
+
     void add(double d, double h, const osg::Vec3d& pos)
     {
         osg::ref_ptr<Point> newPoint = new Point(d,h,pos);
-        
-        
+
+
         if (_previousPoint.valid() && newPoint->distance != _previousPoint->distance)
         {
             const double maxGradient = 100.0;
             double gradient = fabs( (newPoint->height - _previousPoint->height) / (newPoint->distance - _previousPoint->distance) );
-            
+
             if (gradient < maxGradient)
             {
@@ -378 +378 @@
             }
         }
-        
+
         _previousPoint = newPoint;
     }
-    
+
     void endline()
     {
         _previousPoint = 0;
     }
-    
+
     void report()
     {
 
         OSG_NOTICE<<"Number of segments = "<<_segments.size()<<std::endl;
-        
+
         for(SegmentSet::iterator itr = _segments.begin();
              itr != _segments.end();
@@ -415 +415 @@
                 }
             }
-            
+
             OSG_NOTICE<<std::endl;
 
@@ -448 +448 @@
             }
         }
-        
-    }
-    
+
+    }
+
     void pruneOverlappingSegments()
     {
@@ -456 +456 @@
         SegmentSet::iterator nextItr = prevItr;
         ++nextItr;
-        
+
         double epsilon = 0.001;
-        
+
         for(SegmentSet::iterator itr = _segments.begin();
             itr != _segments.end();
@@ -490 +490 @@
 
                         if (rhs_p1_inside && lhs_p2_inside)
-                        {                    
-                            double distance_between = osg::Vec2d(lhs._p2->distance - rhs._p1->distance, 
+                        {
+                            double distance_between = osg::Vec2d(lhs._p2->distance - rhs._p1->distance,
                                                                  lhs._p2->height - rhs._p1->height).length2();
 
@@ -500 +500 @@
                                 Segment newSeg(lhs._p2.get(), rhs._p2.get());
                                 _segments.insert(newSeg);
-                                
+
                                 _segments.erase(nextItr);
-                                
+
                                 nextItr = _segments.find(newSeg);
                             }
@@ -526 +526 @@
                                     Segment seg3( cp, lhs._p2.get() );
                                     Segment seg4( rhs.createPoint(lhs._p2->distance), lhs._p2.get() );
-                                    
+
                                     _segments.erase(nextItr);
                                     _segments.erase(itr);
@@ -534 +534 @@
                                     _segments.insert(seg3);
                                     _segments.insert(seg4);
-                                    
+
                                     itr = _segments.find(seg1);
                                     nextItr = itr;
@@ -565 +565 @@
 //                                     OSG_NOTICE<<"    rhs_p1 "<<rhs._p1->distance<<" "<<rhs._p1->height<<std::endl;
 //                                     OSG_NOTICE<<"    rhs_p2 "<<rhs._p2->distance<<" "<<rhs._p2->height<<std::endl;
-                                    
-                                    
+
+
                                     Segment newSeg(lhs._p1.get(), lhs.createPoint(rhs._p1->distance));
 
@@ -620 +620 @@
                         else if (dh1>=0.0 && dh2>=0.0)
                         {
-                            
+
                             double d_left = enclosed._p1->distance - enclosing._p1->distance;
                             double d_right = enclosing._p2->distance - enclosed._p2->distance;
@@ -626 +626 @@
                             if (d_left < epsilon && d_right < epsilon)
                             {
-                                // treat ENCLOSED as ENCLOSING.                                
+                                // treat ENCLOSED as ENCLOSING.
                                 // OSG_NOTICE<<"   Treat enclosed above as enclosing "<<std::endl;
 
@@ -633 +633 @@
 
                                 _segments.erase(itr);
-                                
+
                                 itr = nextItr;
                                 ++nextItr;
@@ -641 +641 @@
                             {
 //                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"   Replace enclosing with right section"<<std::endl;
 
@@ -655 +655 @@
                                 _segments.erase(itr);
                                 _segments.insert(newSeg);
-                                
+
                                 itr = nextItr;
                                 ++nextItr;
@@ -665 +665 @@
                             {
 //                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"   Replace enclosing with left section"<<std::endl;
 
@@ -685 +685 @@
 //                                 OSG_NOTICE<<"    newSeg_p2 "<<newSeg._p2->distance<<" "<<newSeg._p2->height<<std::endl;
                             }
-                            else 
+                            else
                             {
 //                                 OSG_NOTICE<<"ENCLOSING: ENCLOSING is below enclosed "<<dh1<<" "<<dh2<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl;
-// 
+//
 //                                 OSG_NOTICE<<"   Replace enclosing with left and right sections"<<std::endl;
 
@@ -703 +703 @@
                                 _segments.insert(newSegLeft);
                                 _segments.insert(newSegRight);
-                                
+
                                 itr = _segments.find(newSegLeft);
                                 nextItr = itr;
@@ -719 +719 @@
                         {
 //                             OSG_NOTICE<<"ENCLOSING: ENCLOSING is crossing enclosed "<<dh1<<" "<<dh2<<std::endl;
-//                             
+//
 //                             OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl;
 //                             OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl;
@@ -730 +730 @@
                             if (d_left < epsilon && d_right < epsilon)
                             {
-                                // treat ENCLOSED as ENCLOSING.                                
+                                // treat ENCLOSED as ENCLOSING.
                                 if (dh1 < 0.0)
                                 {
                                     // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), cp);
                                     Segment newSegRight(cp, enclosed._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
                                     ++nextItr;
                                 }
-                                else 
+                                else
                                 {
                                     // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosed._p1.get(), cp);
                                     Segment newSegRight(cp, enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
@@ -776 +776 @@
                                 {
                                     // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), cp);
                                     Segment newSegMid(cp, enclosed._p2.get());
                                     Segment newSegRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegMid);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
                                     ++nextItr;
                                 }
-                                else 
+                                else
                                 {
                                     // OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosed._p1.get(), cp);
                                     Segment newSegRight(cp, enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
@@ -819 +819 @@
                                 {
 //                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), cp);
                                     Segment newSegRight(cp, enclosed._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
                                     ++nextItr;
                                 }
-                                else 
+                                else
                                 {
 //                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), enclosing.createPoint(enclosed._p1->distance));
                                     Segment newSegMid(enclosed._p1.get(), cp);
                                     Segment newSegRight(cp, enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegMid);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
@@ -855 +855 @@
                                 }
                             }
-                            else 
+                            else
                             {
 //                                OSG_NOTICE<<"   >> Replace enclosing with left and right sections"<<std::endl;
@@ -863 +863 @@
                                 {
 //                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), cp);
                                     Segment newSegMid(cp, enclosed._p2.get());
                                     Segment newSegRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegMid);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
                                     ++nextItr;
                                 }
-                                else 
+                                else
                                 {
 //                                    OSG_NOTICE<<"   >> enclosing left side is above enclosed left side"<<std::endl;
-                                    
+
                                     Point* cp = enclosing.createIntersectionPoint(enclosed);
                                     Segment newSegLeft(enclosing._p1.get(), enclosing.createPoint(enclosed._p1->distance));
                                     Segment newSegMid(enclosed._p1.get(), cp);
                                     Segment newSegRight(cp, enclosing._p2.get());
-                                    
+
                                     _segments.erase(itr);
                                     _segments.erase(nextItr);
-                                    
+
                                     _segments.insert(newSegLeft);
                                     _segments.insert(newSegMid);
                                     _segments.insert(newSegRight);
-                                    
+
                                     itr = _segments.find(newSegLeft);
                                     nextItr = itr;
@@ -906 +906 @@
                         {
                             OSG_NOTICE<<"ENCLOSING: ENCLOSING - error case "<<dh1<<" "<<dh2<<std::endl;
-                            
+
                             OSG_NOTICE<<"    enclosing_p1 "<<enclosing._p1->distance<<" "<<enclosing._p1->height<<std::endl;
                             OSG_NOTICE<<"    enclosing_p2 "<<enclosing._p2->distance<<" "<<enclosing._p2->height<<std::endl;
@@ -926 +926 @@
                         double d_left = enclosed._p1->distance - enclosing._p1->distance;
                         double d_right = enclosing._p2->distance - enclosed._p2->distance;
-                        
+
                         if (d_left<=epsilon)
                         {
@@ -946 +946 @@
 //                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl;
-                                
+
                                 _segments.insert(Segment(enclosing.createPoint(enclosed._p2->distance), enclosed._p2.get()));
                                 _segments.erase(nextItr);
@@ -960 +960 @@
 //                                 OSG_NOTICE<<"    enclosed_p1 "<<enclosed._p1->distance<<" "<<enclosed._p1->height<<std::endl;
 //                                 OSG_NOTICE<<"    enclosed_p2 "<<enclosed._p2->distance<<" "<<enclosed._p2->height<<std::endl;
-                                
+
                                 if (d_right<=epsilon)
                                 {
@@ -969 +969 @@
                                         Segment segLeft(enclosed._p1.get(), cp);
                                         Segment segRight(cp, enclosing._p2.get());
-                                        
+
                                         _segments.erase(itr);
                                         _segments.erase(nextItr);
-                                        
+
                                         _segments.insert(segLeft);
                                         _segments.insert(segRight);
-                                        
+
                                         itr = _segments.find(segLeft);
                                         nextItr = itr;
@@ -985 +985 @@
                                         Segment segLeft(enclosing._p1.get(), cp);
                                         Segment segRight(cp, enclosed._p2.get());
-                                        
+
                                         _segments.erase(itr);
                                         _segments.erase(nextItr);
-                                        
+
                                         _segments.insert(segLeft);
                                         _segments.insert(segRight);
-                                        
+
                                         itr = _segments.find(segLeft);
                                         nextItr = itr;
@@ -1005 +1005 @@
                                         Segment segLeft(enclosed._p1.get(), cp);
                                         Segment segRight(cp, enclosing._p2.get());
-                                        
+
                                         _segments.erase(itr);
                                         _segments.erase(nextItr);
-                                        
+
                                         _segments.insert(segLeft);
                                         _segments.insert(segRight);
-                                        
+
                                         itr = _segments.find(segLeft);
                                         nextItr = itr;
@@ -1022 +1022 @@
                                         Segment segMid(cp, enclosed._p2.get());
                                         Segment segRight(enclosing.createPoint(enclosed._p2->distance), enclosing._p2.get());
-                                        
+
                                         _segments.erase(itr);
                                         _segments.erase(nextItr);
-                                        
+
                                         _segments.insert(segLeft);
                                         _segments.insert(segMid);
                                         _segments.insert(segRight);
-                                        
+
                                         itr = _segments.find(segLeft);
                                         nextItr = itr;
                                         ++nextItr;
                                     }
-                                }                                
+                                }
                             }
                             else
@@ -1053 +1053 @@
                         break;
                     }
-                    default: 
+                    default:
                         OSG_NOTICE<<"** Not handled, advancing"<<std::endl;
                         ++nextItr;
                         break;
                 }
-                
+
                 classification = ((itr != _segments.end()) && (nextItr != _segments.end())) ?  itr->compare(*nextItr) : Segment::UNCLASSIFIED;
             }
         }
     }
-    
+
     unsigned int numOverlapping(SegmentSet::const_iterator startItr) const
     {
         if (startItr==_segments.end()) return 0;
-    
+
         SegmentSet::const_iterator nextItr = startItr;
         ++nextItr;
-        
+
         unsigned int num = 0;
         while (nextItr!=_segments.end() && startItr->compare(*nextItr)>=Segment::OVERLAPPING)
@@ -1079 +1079 @@
         return num;
     }
-    
+
     unsigned int totalNumOverlapping() const
     {
@@ -1097 +1097 @@
         SegmentSet::iterator nextItr = prevItr;
         ++nextItr;
-        
+
         intersections.push_back( prevItr->_p1->position );
         distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(prevItr->_p1->distance, prevItr->_p1->height) );
-        
+
         intersections.push_back( prevItr->_p2->position );
         distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(prevItr->_p2->distance, prevItr->_p2->height) );
 
-        for(; 
+        for(;
             nextItr != _segments.end();
             ++nextItr,++prevItr)
@@ -1115 +1115 @@
                     intersections.push_back( nextItr->_p1->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) );
-        
+
                     intersections.push_back( nextItr->_p2->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) );
                     break;
                 }
-                case(Segment::JOINED): 
+                case(Segment::JOINED):
                 {
 #if 1
                     intersections.push_back( nextItr->_p2->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) );
-#else                
+#else
                     intersections.push_back( nextItr->_p1->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) );
-        
+
                     intersections.push_back( nextItr->_p2->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) );
@@ -1134 +1134 @@
                     break;
                 }
-                default: 
+                default:
                 {
                     intersections.push_back( nextItr->_p1->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p1->distance, nextItr->_p1->height) );
-        
+
                     intersections.push_back( nextItr->_p2->position );
                     distanceHeightIntersections.push_back( ElevationSlice::DistanceHeight(nextItr->_p2->distance, nextItr->_p2->height) );
@@ -1144 +1144 @@
                 }
             }
-            
-        }
-        
-    }
-    
+
+        }
+
+    }
+
     SegmentSet _segments;
     osg::ref_ptr<Point> _previousPoint;
     osg::Plane  _plane;
     osg::ref_ptr<osg::EllipsoidModel>   _em;
-    
+
 };
 
@@ -1189 +1189 @@
 
         OSG_NOTICE<<"end_lat = "<<end_latitude<<" end_longitude = "<<end_longitude<<" end_height = "<<end_height<<std::endl;
-        
+
         // set up the main intersection plane
         osg::Vec3d planeNormal = (_endPoint - _startPoint) ^ start_upVector;
-        planeNormal.normalize();        
+        planeNormal.normalize();
         plane.set( planeNormal, _startPoint );
-        
+
         // set up the start cut off plane
         osg::Vec3d startPlaneNormal = start_upVector ^ planeNormal;
         startPlaneNormal.normalize();
         boundingPolytope.add( osg::Plane(startPlaneNormal, _startPoint) );
-        
+
         // set up the end cut off plane
         osg::Vec3d endPlaneNormal = planeNormal ^ end_upVector;
@@ -1211 +1211 @@
         // set up the main intersection plane
         osg::Vec3d planeNormal = (_endPoint - _startPoint) ^ upVector;
-        planeNormal.normalize();        
+        planeNormal.normalize();
         plane.set( planeNormal, _startPoint );
-        
+
         // set up the start cut off plane
         osg::Vec3d startPlaneNormal = upVector ^ planeNormal;
         startPlaneNormal.normalize();
         boundingPolytope.add( osg::Plane(startPlaneNormal, _startPoint) );
-        
+
         // set up the end cut off plane
         osg::Vec3d endPlaneNormal = planeNormal ^ upVector;
@@ -1224 +1224 @@
         boundingPolytope.add( osg::Plane(endPlaneNormal, _endPoint) );
     }
-    
+
     osg::ref_ptr<osgUtil::PlaneIntersector> intersector = new osgUtil::PlaneIntersector(plane, boundingPolytope);
 
@@ -1234 +1234 @@
     _intersectionVisitor.setTraversalMask(traversalMask);
     _intersectionVisitor.setIntersector( intersector.get() );
-    
+
     scene->accept(_intersectionVisitor);
-    
+
     osgUtil::PlaneIntersector::Intersections& intersections = intersector->getIntersections();
 
@@ -1255 +1255 @@
             {
                 // OSG_NOTICE<<"  transforming "<<std::endl;
-                // transform points on polyline 
+                // transform points on polyline
                 for(Polyline::iterator pitr = intersection.polyline.begin();
                     pitr != intersection.polyline.end();
@@ -1262 +1262 @@
                     *pitr = (*pitr) * (*intersection.matrix);
                 }
-                
+
                 // matrix no longer needed.
                 intersection.matrix = 0;
@@ -1270 +1270 @@
 #if 0
         osg::ref_ptr<osg::Geode> geode = new osg::Geode;
-        
+
         for(itr = intersections.begin();
             itr != intersections.end();
@@ -1290 +1290 @@
             geometry->setVertexArray( vertices );
             geometry->addPrimitiveSet( new osg::DrawArrays(GL_LINE_STRIP, 0, vertices->size()) );
-            
+
             osg::Vec4Array* colours = new osg::Vec4Array;
             colours->push_back( osg::Vec4(1.0f,1.0f,1.0f,1.0f) );
-            
+
             geometry->setColorArray( colours );
 
@@ -1299 +1299 @@
             geode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
         }
-        
+
         osgDB::writeNodeFile(*geode, "raw.osg");
 #endif
@@ -1317 +1317 @@
             {
                 osgUtil::PlaneIntersector::Intersection& intersection = *itr;
-                
+
                 if (intersection.attributes.size()!=intersection.polyline.size()) continue;
-                
+
                 Attributes::iterator aitr = intersection.attributes.begin();
                 for(Polyline::iterator pitr = intersection.polyline.begin();
@@ -1328 +1328 @@
                     double distance, height;
                     dhc.computeDistanceHeight(v, distance, height);
-                    
+
                     double pi_height = *aitr;
-                    
+
                     // OSG_NOTICE<<"computed height = "<<height<<" PI height = "<<pi_height<<std::endl;
 
@@ -1361 +1361 @@
                 constructor.endline();
             }
-        } 
+        }
 
         // copy final results
@@ -1374 +1374 @@
         {
             unsigned int previousNumOverlapping = numOverlapping;
-        
+
             constructor.pruneOverlappingSegments();
             // constructor.report();
-            
+
             numOverlapping = constructor.totalNumOverlapping();
             if (previousNumOverlapping == numOverlapping) break;
@@ -1383 +1383 @@
 
         constructor.copyPoints(_intersections, _distanceHeightIntersections);
-        
+
 #if 0
         {
@@ -1419 +1419 @@
         OSG_NOTICE<<"No intersections found."<<std::endl;
     }
-    
+
 }