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/DelaunayTriangulator.cpp

    r12795 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*/ 
     
    3838// return (Cx, Cy, r^2) 
    3939inline osg::Vec3 compute_circumcircle( 
    40     const osg::Vec3 &a,  
    41     const osg::Vec3 &b,  
     40    const osg::Vec3 &a, 
     41    const osg::Vec3 &b, 
    4242    const osg::Vec3 &c) 
    4343{ 
    44     float D =  
    45         (a.x() - c.x()) * (b.y() - c.y()) -  
     44    float D = 
     45        (a.x() - c.x()) * (b.y() - c.y()) - 
    4646        (b.x() - c.x()) * (a.y() - c.y()); 
    4747 
     
    6060    else 
    6161    { 
    62         cx =  
    63         (((a.x() - c.x()) * (a.x() + c.x()) +  
     62        cx = 
     63        (((a.x() - c.x()) * (a.x() + c.x()) + 
    6464        (a.y() - c.y()) * (a.y() + c.y())) / 2 * (b.y() - c.y()) - 
    6565        ((b.x() - c.x()) * (b.x() + c.x()) + 
    6666        (b.y() - c.y()) * (b.y() + c.y())) / 2 * (a.y() - c.y())) / D; 
    6767 
    68         cy =  
    69         (((b.x() - c.x()) * (b.x() + c.x()) +  
     68        cy = 
     69        (((b.x() - c.x()) * (b.x() + c.x()) + 
    7070        (b.y() - c.y()) * (b.y() + c.y())) / 2 * (a.x() - c.x()) - 
    7171        ((a.x() - c.x()) * (a.x() + c.x()) + 
     
    8585inline bool point_in_circle(const osg::Vec3 &point, const osg::Vec3 &circle) 
    8686{ 
    87     float r2 =  
    88         (point.x() - circle.x()) * (point.x() - circle.x()) +  
     87    float r2 = 
     88        (point.x() - circle.x()) * (point.x() - circle.x()) + 
    8989        (point.y() - circle.y()) * (point.y() - circle.y()); 
    9090    return r2 <= circle.z()*circle.z(); 
     
    158158        b_(0), 
    159159        c_(0) {} 
    160          
    161      
     160 
     161 
    162162    Triangle(Vertex_index a, Vertex_index b, Vertex_index c, osg::Vec3Array *points) 
    163         :    a_(a),  
    164             b_(b),  
    165             c_(c),  
     163        :    a_(a), 
     164            b_(b), 
     165            c_(c), 
    166166            cc_(compute_circumcircle((*points)[a_], (*points)[b_], (*points)[c_])) 
    167167    { 
     
    174174    { 
    175175        if (&rhs==this) return *this; 
    176          
     176 
    177177        a_ = rhs.a_; 
    178178        b_ = rhs.b_; 
     
    182182        edge_[1]  = rhs.edge_[1]; 
    183183        edge_[2]  = rhs.edge_[2]; 
    184          
     184 
    185185        return *this; 
    186186    } 
     
    241241            ie1=c(); 
    242242            ie2=a(); 
    243         }  
     243        } 
    244244        if (ip1==ie1 || ip2==ie1) return false; 
    245245        if (ip1==ie2 || ip2==ie2) return false; 
    246      
     246 
    247247        osg::Vec2 tp1((*points)[ie1].x(),(*points)[ie1].y()); 
    248248        osg::Vec2 tp2((*points)[ie2].x(),(*points)[ie2].y()); 
    249249        return intersect(tp1,tp2,p1,p2); 
    250250    } 
    251      
     251 
    252252    bool intersectedby(const osg::Vec2 p1,const osg::Vec2 p2,osg::Vec3Array *points) const { 
    253253        // true if line [p1,p2] cuts at least one edge of this triangle 
     
    290290 
    291291    int lineBisectTest(const osg::Vec3 apt,const osg::Vec3 bpt,const osg::Vec3 cpt, const osg::Vec2 p2) const 
    292     {  
     292    { 
    293293        osg::Vec2 vp2tp=p2-osg::Vec2(apt.x(), apt.y()); // vector from p1 to a. 
    294294        // test is: cross product (z component) with ab,ac is opposite signs 
     
    310310        return 0; 
    311311    } 
    312      
     312 
    313313    int lineBisects(osg::Vec3Array *points, const unsigned int ip1, const osg::Vec2 p2) const 
    314     {  
     314    { 
    315315        // return true if line starts at vertex <ip1> and lies between the 2 edges which meet at vertex 
    316316        // <vertex> is that which uses index ip1. 
     
    343343        return 0; 
    344344    } 
    345      
     345 
    346346private: 
    347347 
     
    355355        if (det!=0) 
    356356        { 
    357             // point on line is P=p1+ua.(p2-p1) and Q=p3+ub.(p4-p3)  
     357            // point on line is P=p1+ua.(p2-p1) and Q=p3+ub.(p4-p3) 
    358358            float ua=((p4.x()-p3.x())*(p1.y()-p3.y())-(p4.y()-p3.y())*(p1.x()-p3.x()))/det; 
    359359            float ub=((p2.x()-p1.x())*(p1.y()-p3.y())-(p2.y()-p1.y())*(p1.x()-p3.x()))/det; 
     
    365365        return false; 
    366366    } 
    367      
     367 
    368368    Vertex_index a_; 
    369369    Vertex_index b_; 
    370370    Vertex_index c_; 
    371     osg::Vec3 cc_;     
     371    osg::Vec3 cc_; 
    372372    Edge edge_[3]; 
    373373}; 
     
    452452    osg::ref_ptr<osg::Vec3Array> constraintverts=new osg::Vec3Array; 
    453453    osg::ref_ptr<osgUtil::Tessellator> tscx=new osgUtil::Tessellator; // this assembles all the constraints 
    454      
     454 
    455455    for (std::vector<unsigned int>::iterator itint=vindexlist.begin(); itint!=vindexlist.end(); itint++) 
    456456    { 
     
    458458        constraintverts->push_back((*points)[*itint]); 
    459459    } 
    460      
     460 
    461461    unsigned int npts=vindexlist.size(); 
    462462 
     
    470470 
    471471    // extract triangles from gtess 
    472      
     472 
    473473    unsigned int ipr; 
    474474    for (ipr=0; ipr<gtess->getNumPrimitiveSets(); ipr++) 
     
    493493                    pidx=vindexlist[prset->index(ic)]; 
    494494                } 
    495                  
     495 
    496496                if (prset->index(ic+1)>=npts) 
    497497                { 
     
    504504                    pidx1=vindexlist[prset->index(ic+1)]; 
    505505                } 
    506                  
     506 
    507507                if (prset->index(ic+2)>=npts) 
    508508                { 
     
    541541                    pidx1=vindexlist[prset->index(ic+1)]; 
    542542                } 
    543                  
     543 
    544544                if (prset->index(ic+2)>=npts) 
    545545                { 
     
    548548                    pidx2=points->size()-1; 
    549549                } 
    550                 else  
     550                else 
    551551                { 
    552552                    pidx2=vindexlist[prset->index(ic+2)]; 
    553553                } 
    554                  
     554 
    555555                if (ic%2==0) 
    556556                { 
     
    564564            } 
    565565            break; 
    566              
     566 
    567567        case osg::PrimitiveSet::TRIANGLE_FAN: 
    568568            { 
     
    590590                        pidx1=vindexlist[prset->index(ic)]; 
    591591                    } 
    592                      
     592 
    593593                    if (prset->index(ic+1)>=npts) 
    594594                    { // this is an added point. 
     
    637637    */ 
    638638    int nrem=0; 
    639     osg::Vec3Array *vertices= dynamic_cast< osg::Vec3Array*>(getVertexArray());  
     639    osg::Vec3Array *vertices= dynamic_cast< osg::Vec3Array*>(getVertexArray()); 
    640640    if (vertices) 
    641641    { 
     
    793793    // initialize storage structures 
    794794    Triangle_list triangles; 
    795     Triangle_list discarded_tris;     
     795    Triangle_list discarded_tris; 
    796796 
    797797    // GWM July 2005 add constraint vertices to terrain 
     
    825825    // pre-sort sample points 
    826826    OSG_INFO << "DelaunayTriangulator: pre-sorting sample points\n"; 
    827     std::sort(points->begin(), points->end(), Sample_point_compare);     
     827    std::sort(points->begin(), points->end(), Sample_point_compare); 
    828828    // 24.12.06 add convex hull of points to force sensible outline. 
    829829    osg::ref_ptr<osgUtil::DelaunayConstraint> dcconvexhull=getconvexhull(points); 
     
    831831 
    832832    // set the last valid index for the point list 
    833     GLuint last_valid_index = points->size() - 1;     
     833    GLuint last_valid_index = points->size() - 1; 
    834834 
    835835    // find the minimum and maximum x values in the point list 
     
    837837    float maxx = (*points)[last_valid_index].x(); 
    838838 
    839     // find the minimum and maximum y values in the point list     
     839    // find the minimum and maximum y values in the point list 
    840840    float miny = (*points)[0].y(); 
    841841    float maxy = miny; 
    842      
     842 
    843843    OSG_INFO << "DelaunayTriangulator: finding minimum and maximum Y values\n"; 
    844844    osg::Vec3Array::const_iterator mmi; 
     
    848848        if (mmi->y() > maxy) maxy = mmi->y(); 
    849849    } 
    850      
     850 
    851851    // add supertriangle vertices to the point list 
    852852    // gwm added 1.05* to ensure that supervertices are outside the domain of points. 
     
    860860    points_->push_back(osg::Vec3(maxx + .10*(maxx - minx), maxy + .10*(maxy - miny), 0)); 
    861861    points_->push_back(osg::Vec3(minx - .10*(maxx - minx), maxy + .10*(maxy - miny), 0)); 
    862                                                                     
    863     // add supertriangles to triangle list                            
     862 
     863    // add supertriangles to triangle list 
    864864    triangles.push_back(Triangle(last_valid_index+1, last_valid_index+2, last_valid_index+3, points)); 
    865865    triangles.push_back(Triangle(last_valid_index+4, last_valid_index+1, last_valid_index+3, points)); 
    866866 
    867      
    868     // begin triangulation     
     867 
     868    // begin triangulation 
    869869    GLuint pidx = 0; 
    870     osg::Vec3Array::const_iterator i;     
    871      
    872     OSG_INFO << "DelaunayTriangulator: triangulating vertex grid (" << (points->size()-3) <<" points)\n";     
     870    osg::Vec3Array::const_iterator i; 
     871 
     872    OSG_INFO << "DelaunayTriangulator: triangulating vertex grid (" << (points->size()-3) <<" points)\n"; 
    873873 
    874874    for (i=points->begin(); i!=points->end(); ++i, ++pidx) 
     
    922922                            edge.set_duplicate(!edge.get_duplicate()); 
    923923                        } 
    924                     }                     
     924                    } 
    925925                    triangles.erase(j); 
    926926                } 
     
    982982                                if (titr->isedge(ip1,ip2)) edgused=true; 
    983983                                if (titr->isedge(ip2,ip1)) edgused=true; 
    984                                 //        if (edgused) OSG_WARN << "Edge used in triangle " << it << " " <<  
     984                                //        if (edgused) OSG_WARN << "Edge used in triangle " << it << " " << 
    985985                                //            titr->a()<<","<< titr->b()<<","<< titr->c()<<  std::endl; 
    986986                                it++; 
     
    10071007                                    { 
    10081008                                        // triangle titr starts the constraint edge 
    1009                                         std::vector<unsigned int> edgeRight, edgeLeft;  
     1009                                        std::vector<unsigned int> edgeRight, edgeLeft; 
    10101010                                        edgeRight.push_back(ip1); 
    10111011                                        edgeLeft.push_back(ip1); 
     
    10381038                                                icut=tradj->whichEdge(points_.get(),p1,p2,e1,e2); 
    10391039                                                //    OSG_WARN  << ntr << " cur triedge " << icut << " " << ip1 << 
    1040                                                 //        " to " << ip2 << " tadj " << tradj->a()<< ","<<tradj->b() <<","  
     1040                                                //        " to " << ip2 << " tadj " << tradj->a()<< ","<<tradj->b() <<"," 
    10411041                                                //        <<tradj->c() <<std::endl; 
    10421042                                                if        (icut==1) {e1=tradj->b(); e2=tradj->c();} // icut=1 implies vertex a is not involved 
     
    10801080                                { 
    10811081                                    bool deleted=false; 
    1082                                     for (std::vector<const Triangle *>::iterator deleteTri=trisToDelete.begin();  
     1082                                    for (std::vector<const Triangle *>::iterator deleteTri=trisToDelete.begin(); 
    10831083                                    deleteTri!=trisToDelete.end(); ) 
    10841084                                    { 
     
    11591159        } 
    11601160    } 
    1161      
     1161 
    11621162    // LF August 2011 fix crash when no triangle is created 
    11631163    if (!pt_indices.size()) 
    11641164    { 
    11651165        OSG_WARN << "Warning: DelaunayTriangulator::triangulate(): no triangle generated" << std::endl; 
    1166         return false;         
    1167     }     
    1168      
     1166        return false; 
     1167    } 
     1168 
    11691169    prim_tris_ = new osg::DrawElementsUInt(GL_TRIANGLES, pt_indices.size(), &(pt_indices.front())); 
    11701170 
    11711171    OSG_INFO << "DelaunayTriangulator: process done, " << prim_tris_->getNumPrimitives() << " triangles remain\n"; 
    1172      
     1172 
    11731173    return true; 
    11741174} 
     
    12651265        } 
    12661266    } 
    1267      
     1267 
    12681268    return theta/osg::PI/2.0; // should be 0 or 2 pi. 
    12691269} 
    12701270osg::DrawElementsUInt *DelaunayConstraint::makeDrawable() 
    1271 {  
     1271{ 
    12721272    // initialize index storage vector for internal triangles. 
    12731273    std::vector<GLuint> pt_indices; 
     
    12761276    for (ti=_interiorTris.begin(); ti!=_interiorTris.end(); ++ti) 
    12771277    { 
    1278          
     1278 
    12791279        //  if (normals_.valid()) { 
    12801280        //        (normals_.get())->push_back(ti->compute_normal(points)); 
    12811281        //  } 
    1282          
     1282 
    12831283        pt_indices.push_back((*ti)[0]); 
    12841284        pt_indices.push_back((*ti)[1]); 
     
    12861286    } 
    12871287    prim_tris_ = new osg::DrawElementsUInt(GL_TRIANGLES, pt_indices.size(), &(pt_indices.front())); 
    1288      
     1288 
    12891289    return prim_tris_.get(); 
    12901290} 
    1291 bool DelaunayConstraint::contains(const osg::Vec3 &testpoint) const  
     1291bool DelaunayConstraint::contains(const osg::Vec3 &testpoint) const 
    12921292{ 
    12931293    // true if point is internal to the loop. 
     
    12951295    return fabs(theta)>0.9; // should be 0 or 1 (or 2,3,4 for very complex not permitted loops). 
    12961296} 
    1297 bool DelaunayConstraint::outside(const osg::Vec3 &testpoint) const  
     1297bool DelaunayConstraint::outside(const osg::Vec3 &testpoint) const 
    12981298{ 
    12991299    // true if point is outside the loop. 
     
    13651365    tscx->setTessellationType(osgUtil::Tessellator::TESS_TYPE_GEOMETRY); 
    13661366    tscx->setBoundaryOnly(true); 
    1367     tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD);  
     1367    tscx->setWindingType( osgUtil::Tessellator::TESS_WINDING_ODD); 
    13681368    //  ODD chooses the winding =1, NOT overlapping areas of constraints. 
    13691369    // nb this includes all the edges where delaunay constraints meet 
    13701370    // draw a case to convince yourself!. 
    1371      
     1371 
    13721372    tscx->retessellatePolygons(*this); // find all edges 
    13731373}