Ignore:
Timestamp:
03/07/06 11:09:10 (19 years ago)
Author:
mattausch
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellBsp.cpp

    r676 r678  
    23032303{ 
    23042304        BspNode *lastNode; 
     2305 
    23052306        do 
    23062307        { 
     
    23552356 
    23562357        PolygonContainer candidates; 
     2358        vector<Plane3> candidatePlanes; 
    23572359 
    23582360        // bounded planes are added to the polygons (reverse polygons 
    23592361        // as they have to be outfacing 
     2362        // comment: why is this? 
    23602363        for (int i = 0; i < (int)halfSpaces.size(); ++ i) 
    23612364        { 
     
    23652368                { 
    23662369                        candidates.push_back(p->CreateReversePolygon()); 
     2370 
     2371                        Plane3 candidatePlane = p->GetSupportingPlane();//halfSpaces[i]; 
     2372                        //candidatePlane.ReverseOrientation(); 
     2373                        candidatePlanes.push_back(candidatePlane); 
     2374 
    23672375                        DEL_PTR(p); 
    23682376                } 
     
    23772385                        vertices.push_back(mBox.GetFace(i).mVertices[j]); 
    23782386 
     2387                Polygon3 *poly = new Polygon3(vertices); 
    23792388                candidates.push_back(new Polygon3(vertices)); 
    2380         } 
     2389                candidatePlanes.push_back(poly->GetSupportingPlane()); 
     2390        } 
     2391 
    23812392 
    23822393        for (int i = 0; i < (int)candidates.size(); ++ i) 
     
    24262437                 
    24272438                if (candidates[i]) 
    2428                         geom.mPolys.push_back(candidates[i]); 
     2439                { 
     2440                        geom.Add(candidates[i], candidatePlanes[i]); 
     2441                //      geom.mPolys.push_back(candidates[i]); 
     2442                } 
    24292443        } 
    24302444} 
     
    24762490                                        { 
    24772491                                                const int cf = 
    2478                                                         Polygon3::ClassifyPlane(geom->mPolys, 
     2492                                                        Polygon3::ClassifyPlane(geom->GetPolys(), 
    24792493                                                                                                        halfSpaces[i], 
    24802494                                                                                                        mEpsilon); 
     
    24902504                                        // TODO: why is this wrong?? 
    24912505                                        // test all planes of current node if still adjacent 
    2492                                         for (int i = 0; (i < (int)nodeGeom.mPolys.size()) && isAdjacent; ++ i) 
     2506                                        for (int i = 0; (i < nodeGeom.Size()) && isAdjacent; ++ i) 
    24932507                                        { 
    2494                                                 Polygon3 *poly = nodeGeom.mPolys[i]; 
     2508                                                Polygon3 *poly = nodeGeom.GetPolys()[i]; 
    24952509 
    24962510                                                const int cf = 
    2497                                                         Polygon3::ClassifyPlane(geom->mPolys, 
     2511                                                        Polygon3::ClassifyPlane(geom->GetPolys(), 
    24982512                                                                                                        poly->GetSupportingPlane(), 
    24992513                                                                                                        mEpsilon); 
     
    25162530                        BspInterior *interior = dynamic_cast<BspInterior *>(node); 
    25172531 
    2518                         const int cf = Polygon3::ClassifyPlane(nodeGeom.mPolys, 
     2532                        const int cf = Polygon3::ClassifyPlane(nodeGeom.GetPolys(), 
    25192533                                                                                                   interior->GetPlane(), 
    25202534                                                                                                   mEpsilon); 
     
    25842598                        ConstructGeometry(interior, geom); 
    25852599 
    2586                         const int cf = Polygon3::ClassifyPlane(geom.mPolys,  
     2600                        const int cf = Polygon3::ClassifyPlane(geom.GetPolys(),  
    25872601                                                                                                   halfspace,  
    25882602                                                                                                   mEpsilon); 
     
    28802894         
    28812895        PolygonContainer::const_iterator it, it_end = rhs.mPolys.end(); 
     2896 
     2897        int i = 0; 
     2898 
    28822899        for (it = rhs.mPolys.begin(); it != it_end; ++ it) 
    28832900        { 
    28842901                Polygon3 *poly = *it; 
    2885                 mPolys.push_back(new Polygon3(*poly)); 
     2902                Add(new Polygon3(*poly), rhs.mPlanes[i ++]); 
    28862903        } 
    28872904} 
     
    28912908{ 
    28922909        CLEAR_CONTAINER(mPolys); 
     2910} 
     2911 
     2912 
     2913int BspNodeGeometry::Size() const 
     2914{ 
     2915        return (int)mPolys.size(); 
     2916} 
     2917 
     2918 
     2919const PolygonContainer &BspNodeGeometry::GetPolys() 
     2920{ 
     2921        return mPolys; 
     2922} 
     2923 
     2924 
     2925void BspNodeGeometry::Add(Polygon3 *p, const Plane3 &plane) 
     2926{ 
     2927    mPolys.push_back(p); 
     2928        mPlanes.push_back(plane); 
    28932929} 
    28942930 
     
    29232959                        const Vector3 v2 = poly->mVertices[i + 1] - center; 
    29242960 
    2925                         volume += f * (DotProd(v0, CrossProd(v1, v2))); 
     2961                        // more robust version using abs and the center of mass 
     2962                        volume += fabs (f * (DotProd(v0, CrossProd(v1, v2)))); 
    29262963                } 
    29272964        } 
     
    29532990 
    29542991        return center / (float)n; 
     2992} 
     2993 
     2994 
     2995bool BspNodeGeometry::Valid() const 
     2996{ 
     2997        if (mPolys.size() < 4) 
     2998                return false; 
     2999         
     3000        return true; 
    29553001} 
    29563002 
     
    30033049 
    30043050                                        if (frontPoly->Valid(epsilon)) 
    3005                                                 front.mPolys.push_back(frontPoly); 
     3051                                        { 
     3052                                                front.Add(frontPoly, mPlanes[i]); 
     3053                                        } 
    30063054                                        else 
     3055                                        { 
    30073056                                                DEL_PTR(frontPoly); 
    3008  
     3057                                        } 
    30093058                                        if (backPoly->Valid(epsilon)) 
    3010                                                 back.mPolys.push_back(backPoly); 
     3059                                        { 
     3060                                                back.Add(backPoly, mPlanes[i]); 
     3061                                        } 
    30113062                                        else 
     3063                                        { 
    30123064                                                DEL_PTR(backPoly); 
     3065                                        } 
    30133066                                } 
    30143067                                 
    30153068                                break; 
    30163069                        case Polygon3::BACK_SIDE: 
    3017                                 back.mPolys.push_back(new Polygon3(mPolys[i]->mVertices));                       
     3070                 
     3071                                back.Add(new Polygon3(mPolys[i]->mVertices), mPlanes[i]); 
    30183072                                break; 
    30193073                        case Polygon3::FRONT_SIDE: 
    3020                                 front.mPolys.push_back(new Polygon3(mPolys[i]->mVertices));      
     3074 
     3075                                front.Add(new Polygon3(mPolys[i]->mVertices), mPlanes[i]); 
    30213076                                break; 
     3077                        // only put into back container (split should have no effect ...) 
    30223078                        case Polygon3::COINCIDENT: 
     3079 
     3080                                back.Add(new Polygon3(mPolys[i]->mVertices), mPlanes[i]); 
    30233081                                //front.mPolys.push_back(CreateReversePolygon(mPolys[i])); 
    3024                                 back.mPolys.push_back(new Polygon3(mPolys[i]->mVertices)); 
    30253082                                break; 
    30263083                        default: 
     
    30333090        { 
    30343091                // add polygon with normal pointing into positive half space to back cell 
    3035                 back.mPolys.push_back(planePoly); 
     3092                back.Add(planePoly, splitPlane); 
     3093                //back.mPolys.push_back(planePoly); 
     3094 
    30363095                // add polygon with reverse orientation to front cell 
    3037                 front.mPolys.push_back(planePoly->CreateReversePolygon()); 
     3096                Plane3 reversePlane(splitPlane); 
     3097                reversePlane.ReverseOrientation(); 
     3098                front.Add(planePoly->CreateReversePolygon(), reversePlane); 
     3099                //front.mPolys.push_back(planePoly->CreateReversePolygon()); 
    30383100        } 
    30393101} 
     
    30493111        for (int i = 0; (i < (int)mPolys.size()) && planePoly; ++ i) 
    30503112        { 
     3113#if 0 
    30513114                Plane3 plane = mPolys[i]->GetSupportingPlane(); 
    3052  
     3115#else 
     3116                Plane3 plane = mPlanes[i]; 
     3117         
     3118#endif 
    30533119                /// don't use epsilon here to get exact split planes 
    30543120                const int cf =  
    3055                         planePoly->ClassifyPlane(plane, Limits::Small); 
     3121                        planePoly->ClassifyPlane(plane, epsilon); 
    30563122                         
    30573123                // split new polygon with all previous planes 
Note: See TracChangeset for help on using the changeset viewer.