Changeset 308


Ignore:
Timestamp:
10/05/05 02:19:15 (19 years ago)
Author:
mattausch
Message:

bsp tree view cells sampling possible

Location:
trunk/VUT/GtpVisibilityPreprocessor
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

    r306 r308  
    88#       filename glasgow1.x3d 
    99#       filename vienna.x3d 
    10         filename ../data/vienna/vienna-simple.x3d 
     10#       filename ../data/vienna/vienna-simple.x3d 
     11        filename ../data/vienna/vienna-buildings.x3d 
    1112#       filename ../data/vienna/viewcells-25-sel.x3d 
    1213#       filename ../data/atlanta/atlanta2.x3d 
    … …  
    1516#       viewcells ../data/atlanta/atlanta_viewcells_large.x3d 
    1617#       viewcells ../data/atlanta/atlanta_viewcells_large2.x3d 
    17 #       viewcells ../data/vienna/viewcells-25-sel.x3d 
    18         viewcells ../data/vienna/viewcells-25.x3d 
     18        viewcells ../data/vienna/viewcells-25-sel.x3d 
     19#       viewcells ../data/vienna/viewcells-25.x3d 
    1920#       viewcells ../data/vienna/viewcells-large-sel.x3d 
    2021} 
    … …  
    6061 
    6162Sampling { 
    62         totalSamples    10000 
     63        totalSamples    1000000 
    6364        samplesPerPass  5 
    6465} 
     66 
    6567 
    6668BspTree { 
    … …  
    7375        # vertical axis        = 64 
    7476         
    75         splitPlaneStrategy 32 
     77        splitPlaneStrategy 66 
    7678        # least splits + balanced polygons 
    7779        #splitPlaneStrategy 12 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Camera.h

    r162 r308  
    2424    mWidth = 640; 
    2525    mHeight = 480; 
    26     mFovy = 60*M_PI/180; 
     26    mFovy = 60*M_PI/180.0f; 
    2727  } 
    2828   

  • trunk/VUT/GtpVisibilityPreprocessor/src/Intersectable.h

    r245 r308  
    1313  KdPvs mKdPvs; 
    1414   
    15   enum { MESH_INSTANCE, TRANSFORMED_MESH_INSTANCE, SPHERE, VIEWCELL }; 
     15  enum { MESH_INSTANCE, TRANSFORMED_MESH_INSTANCE, SPHERE, VIEW_CELL }; 
    1616   
    1717  Intersectable():mailbox(0) {} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Mesh.cpp

    r258 r308  
    5454                    float &nearestT, 
    5555                    int &nearestFace, 
    56                     MeshInstance *instance 
     56                    Intersectable *instance 
    5757                    ) 
    5858{ 
    … …  
    121121                             Ray &ray, 
    122122                             const vector<int> &faces, 
    123                              MeshInstance *instance 
     123                             Intersectable *instance 
    124124                             ) 
    125125{ 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Mesh.h

    r271 r308  
    107107  CastRay( 
    108108          Ray &ray, 
    109           MeshInstance *instance 
     109           MeshInstance *instance 
    110110          ); 
    111111 
    … …  
    114114                         Ray &ray, 
    115115                         const vector<int> &faces, 
    116                          MeshInstance *instance 
     116                         Intersectable *instance 
    117117                         ); 
    118118 
    … …  
    123123                float &nearestT, 
    124124                int &nearestFace, 
    125                 MeshInstance *instance 
     125                Intersectable *instance 
    126126                ); 
    127127 

  • trunk/VUT/GtpVisibilityPreprocessor/src/MeshKdTree.cpp

    r245 r308  
    277277  } 
    278278   
    279   float oldCost = node->mFaces.size(); 
     279  float oldCost = (float)node->mFaces.size(); 
    280280  float newCost = mCt_div_ci + minSum/boxArea; 
    281281  float ratio = newCost/oldCost; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.cpp

    r306 r308  
    22#include "Mesh.h" 
    33#include "ViewCellBsp.h" // TODO: erase this 
    4 #include "Intersectable.h" 
     4#include "Mesh.h" 
    55#include "AxisAlignedBox3.h" 
    66 
    … …  
    1616{} 
    1717 
    18 Polygon3::Polygon3(Intersectable *parent): mMaterial(NULL), mParent(parent) 
     18Polygon3::Polygon3(MeshInstance *parent): mMaterial(NULL), mParent(parent) 
    1919{ 
    2020} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.h

    r306 r308  
    2424        Polygon3(); 
    2525        Polygon3(const VertexContainer &vertices); 
    26         Polygon3(Intersectable *parent); 
     26        Polygon3(MeshInstance *parent); 
    2727 
    2828        /** Copies all the vertices of the face. 
    … …  
    8181        Material *mMaterial; 
    8282         
    83         /// pointer to the intersectable this polygon is derived from 
    84         Intersectable *mParent; 
     83        /// pointer to the mesh instance this polygon is derived from 
     84        MeshInstance *mParent; 
    8585}; 
    8686 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.cpp

    r304 r308  
    1616Preprocessor::~Preprocessor() 
    1717{ 
    18   CLEAR_CONTAINER(mViewCells); 
    19   DEL_PTR(mBspTree); 
    20   DEL_PTR(mKdTree); 
    21   DEL_PTR(mRootViewCell); 
     18        DeleteViewCells(); 
     19                 
     20        DEL_PTR(mBspTree); 
     21        DEL_PTR(mKdTree); 
     22        DEL_PTR(mRootViewCell); 
    2223} 
    2324 
    … …  
    2627{ 
    2728        return X3dParser().ParseFile(filename, mViewCells); 
     29} 
     30 
     31void Preprocessor::DeleteViewCells() 
     32{ 
     33        for (int i = 0; i < mViewCells.size(); ++ i) 
     34                delete mViewCells[i]->GetMesh(); 
     35 
     36        CLEAR_CONTAINER(mViewCells); 
    2837} 
    2938 
    … …  
    9099        DEL_PTR(mBspTree); 
    91100        DEL_PTR(mRootViewCell); 
    92         mRootViewCell = new ViewCell(); 
     101        mRootViewCell = new ViewCell(NULL); 
    93102        mBspTree = new BspTree(mRootViewCell); 
    94103 
    95104        ObjectContainer objects; 
    96105        RayContainer rays; 
    97 ViewCellContainer dummy; 
     106 
    98107        switch (BspTree::sConstructionMethod) 
    99108        { 
    … …  
    102111                break; 
    103112        case BspTree::SCENE_GEOMETRY: 
    104                 CLEAR_CONTAINER(mViewCells); // we generate new view cells 
     113                DeleteViewCells(); // we generate new view cells 
    105114                mSceneGraph->CollectObjects(&objects); 
    106115                mBspTree->Construct(objects, &mViewCells); 
    107116                break; 
    108117        case BspTree::RAYS: 
    109                 CLEAR_CONTAINER(mViewCells); // we generate new view cells       
     118                DeleteViewCells(); // we generate new view cells         
    110119                mBspTree->Construct(rays, &mViewCells); 
    111120                break; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.h

    r297 r308  
    9090  virtual void BspTreeStatistics(ostream &s); 
    9191 
     92  void DeleteViewCells(); 
     93 
    9294  /// scene graph loaded from file 
    9395  SceneGraph *mSceneGraph; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Pvs.cpp

    r240 r308  
    22using namespace std; 
    33#include "Pvs.h" 
     4#include "Intersectable.h" 
    45 
    56KdPvsData * 
    … …  
    8788        data = (*i).second; 
    8889} 
     90 
     91ViewCellPvsData *ViewCellPvs::Find(Intersectable *obj) 
     92{ 
     93        ViewCellPvsMap::iterator i = mEntries.find(obj); 
     94         
     95        if (i != mEntries.end())  
     96        { 
     97                //    cout<<node<<" "<<(*i).first<<" "<<(*i).second.mVisibleSamples<<endl; 
     98                return &(*i).second; 
     99        }  
     100        else 
     101          return NULL; 
     102} 
     103 
     104int ViewCellPvs::AddObject(Intersectable *obj) 
     105{ 
     106        int result; 
     107   
     108        ViewCellPvsData *data = Find(obj); 
     109 
     110        if (data)  
     111        { 
     112                data->mVisibleSamples ++; 
     113                result = 0; 
     114        }  
     115        else  
     116        { 
     117                mEntries[obj] = ViewCellPvsData(1); 
     118                result = 1; 
     119        } 
     120 
     121        return  result; 
     122} 
     123 
     124void ViewCellPvs::GetData(const int index, Intersectable *&obj, ViewCellPvsData &data) 
     125{ 
     126        ViewCellPvsMap::iterator i = mEntries.begin(); 
     127   
     128        for (int k = 0; k!=index && i != mEntries.end(); i++, k++); 
     129 
     130        obj = (*i).first; 
     131        data = (*i).second; 
     132} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Pvs.h

    r265 r308  
    77class BspNode; 
    88class Ray; 
     9class Intersectable; 
    910 
    1011struct LtKdNode 
    … …  
    9293}; 
    9394 
     95 
     96struct LtIntersectable 
     97{ 
     98  bool operator()(const Intersectable *a, 
     99                  const Intersectable *b) const 
     100  { 
     101          return a < b; 
     102  } 
     103}; 
     104 
     105struct ViewCellPvsData { 
     106  int mVisibleSamples; 
     107  ViewCellPvsData() {} 
     108  ViewCellPvsData(const int samples): mVisibleSamples(samples) {} 
     109}; 
     110 
     111typedef std::map<Intersectable *, ViewCellPvsData, LtIntersectable> ViewCellPvsMap; 
     112 
     113class ViewCellPvs  
     114{ 
     115public: 
     116        ViewCellPvs(): mEntries() {} 
     117 
     118        ViewCellPvsMap mEntries; 
     119  
     120        int Compress() {return 0;} 
     121        int GetSize() {return (int)mEntries.size();} 
     122 
     123        ViewCellPvsData *Find(Intersectable *obj); 
     124        int AddObject(Intersectable *obj); 
     125 
     126        void GetData(const int index,  
     127                                 Intersectable *&obj, 
     128                                 ViewCellPvsData &data); 
     129 
     130}; 
     131 
    94132#endif 
    95133 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Ray.h

    r245 r308  
    1111class KdLeaf; 
    1212class MeshInstance; 
    13  
     13class ViewCell; 
    1414 
    1515// ------------------------------------------------------------------- 
    … …  
    5959  vector<KdLeaf *> leaves; 
    6060  vector<MeshInstance *> meshes; 
     61  vector<ViewCell *> viewCells; 
    6162 
    6263  // constructors 

  • trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

    r257 r308  
    66#include "MutualVisibility.h" 
    77#include "Polygon3.h" 
    8  
    9 SamplingPreprocessor::SamplingPreprocessor() 
     8#include "ViewCell.h" 
     9 
     10SamplingPreprocessor::SamplingPreprocessor(): mPass(0) 
    1011{ 
    1112  // this should increase coherence of the samples 
    … …  
    2324  ray.leaves.clear(); 
    2425  ray.meshes.clear(); 
     26  ray.viewCells.clear(); 
     27 
    2528  //  cout<<point<<" "<<direction<<endl; 
    2629  ray.Init(point, direction, Ray::LOCAL_RAY); 
    … …  
    5760 
    5861 
     62int SamplingPreprocessor::AddObjectSamples(Intersectable *obj, const Ray &ray) 
     63{ 
     64        int contributingSamples = 0; 
     65        int j; 
     66 
     67        if (mPass > 10) 
     68                for (j=1; j < ray.viewCells.size() - 1; j++)  
     69                { 
     70                        ray.viewCells[j]->AddPassingRay(ray, contributingSamples ? 1 : 0); 
     71                } 
     72 
     73        // add object to view cell 
     74        for (j=0; j < ray.viewCells.size(); j++)  
     75        { 
     76                ViewCell *vc = ray.viewCells[j]; 
     77                contributingSamples += vc->GetPvs().AddObject(obj); 
     78        } 
     79 
     80        return contributingSamples; 
     81} 
     82 
     83 
    5984void 
    6085SamplingPreprocessor::HoleSamplingPass() 
    … …  
    7499SamplingPreprocessor::CastRay(Intersectable *object, Ray &ray) 
    75100{ 
     101        int sampleContributions = 0; 
     102 
     103#ifndef TEST_BSP_VIEWCELLS 
    76104        mKdTree->CastRay(ray); 
    77         int sampleContributions = 0; 
     105         
    78106        if (ray.leaves.size()) { 
    79107                sampleContributions += AddNodeSamples(object, ray); 
    … …  
    83111                } 
    84112        } 
     113#else 
     114        mBspTree->CastRay(ray); 
     115 
     116        if (ray.viewCells.size() > 0) // view cell found 
     117        { 
     118                ++ sampleContributions; 
     119         
     120                //  cast ray to KD tree to find intersections with other objects 
     121                mKdTree->CastRay(ray); 
     122 
     123                if (ray.intersections.size())  
     124                { 
     125                        sampleContributions += AddObjectSamples(ray.intersections[0].mObject, ray); 
     126                } 
     127        } 
     128#endif 
    85129        return sampleContributions; 
    86130} 
    … …  
    190234                int passSamples = 0; 
    191235                int index = 0; 
    192                  
    193                 for (i =0; i < objects.size(); i++) { 
     236                Debug << "************************************" << endl; 
     237                Debug << "totalSamples: " << totalSamples << " (" << mTotalSamples << ")" << endl; 
     238                for (i = 0; i < objects.size(); i++) { 
    194239                        KdNode *nodeToSample = NULL; 
    195240                        Intersectable *object = objects[i]; 
    196                          
     241                 
    197242                        int pvsSize = object->mKdPvs.GetSize(); 
    198                          
    199                          
    200243                         
    201244                        if (0 && pvsSize) { 
    … …  
    210253                                 
    211254                                int maxTries = 2*pvsSize; 
    212                                  
     255                                Debug << "Finding random neighbour" << endl;     
    213256                                for (int tries = 0; tries < 10; tries++) { 
    214257                                        index = RandomValue(0, pvsSize - 1); 
    … …  
    230273                                        node->Mail(); 
    231274                                } 
    232                                  
     275                                Debug << "Get all neighbours from PVS" << endl; 
    233276                                vector<KdNode *> invisibleNeighbors; 
    234277                                // get all neighbors of all PVS nodes 
    … …  
    251294                        } 
    252295                         
    253                          
     296                 
    254297                        object->GetRandomSurfacePoint(point, normal); 
    255298                        bool viewcellSample = true; 
    … …  
    278321                                         
    279322                                        // construct a ray 
     323 
    280324                                        SetupRay(ray, point, direction); 
    281325                                        sampleContributions = CastRay(object, ray); 
    … …  
    310354                } 
    311355                 
    312                  
    313          
    314356                totalSamples += passSamples; 
    315357                 
    … …  
    319361                 
    320362                mPass++; 
    321      
     363 
    322364                int pvsSize = 0; 
     365#ifdef TEST_BSP_VIEWCELLS     
     366                for (i=0; i < mViewCells.size(); i++) { 
     367                        ViewCell *vc = mViewCells[i]; 
     368                        pvsSize += vc->GetPvs().GetSize(); 
     369                } 
     370                Debug << "pvs size: " << pvsSize << endl; 
     371#else 
    323372                for (i=0; i < objects.size(); i++) { 
    324373                        Intersectable *object = objects[i]; 
    325374                        pvsSize += object->mKdPvs.GetSize(); 
    326375                } 
    327      
     376#endif           
    328377                cout << "#Pass " << mPass<<" : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl; 
    329378                cout << "#TotalSamples=" << totalSamples/1000  
    … …  
    343392                        "#AvgRayContrib\n" << passSampleContributions/(float)passContributingSamples << endl; 
    344393        } 
    345          
     394  Debug << "Collecting leaf pvs" << endl; 
    346395  int totalPvsSize = mKdTree->CollectLeafPvs(); 
    347396  cout << "#totalPvsSize=" << totalPvsSize << endl; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.h

    r256 r308  
    5151                                                                        ); 
    5252 
     53        /** Adds objects samples to view cells. 
     54        */ 
     55        int AddObjectSamples(Intersectable *obj, const Ray &ray); 
    5356}; 
    5457 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.cpp

    r265 r308  
    11#include "ViewCell.h" 
    22#include "Mesh.h" 
     3#include "Intersectable.h" 
    34#include "MeshKdTree.h" 
    45#include "Triangle3.h" 
    56 
    6 ViewCell::ViewCell(): mMesh(NULL) 
     7ViewCell::ViewCell(): MeshInstance(NULL) 
    78{ 
    89} 
    910 
    10 ViewCell::ViewCell(Mesh *mesh): mMesh(mesh), mPvs(NULL)  
     11ViewCell::ViewCell(Mesh *mesh): MeshInstance(mesh) 
    1112{ 
    1213} 
    1314 
    14 ViewCell::~ViewCell() 
    15 { 
    16         // NOTE: should I really do this here? (I know that there is only one mesh per view cell) 
    17         DEL_PTR(mMesh); 
    18 } 
    19  
    20 Mesh *ViewCell::GetMesh()  
    21 { 
    22         return mMesh; 
    23 } 
    24  
    25 BspPvs *ViewCell::GetPVS()  
     15ViewCellPvs &ViewCell::GetPvs()  
    2616{ 
    2717        return mPvs; 
    2818} 
    2919 
    30 AxisAlignedBox3 ViewCell::GetBox() 
    31 { 
    32         return mMesh->mBox; 
    33 } 
    34    
    35 int ViewCell::CastRay(Ray &ray)  
    36 { 
    37         return 0; 
    38 } 
    39    
    40 bool ViewCell::IsConvex()  
    41 { 
    42         return mMesh->mIsConvex; 
    43 } 
    44  
    45 bool ViewCell::IsWatertight()  
    46 { 
    47         return mMesh->mIsWatertight; 
    48 } 
    49  
    50 float ViewCell::IntersectionComplexity()  
    51 { 
    52         return (float)mMesh->mFaces.size(); 
    53 } 
    54  
    5520int ViewCell::Type() const  
    5621{  
    57         return VIEWCELL;  
    58 } 
    59  
    60 void  ViewCell::GetRandomSurfacePoint(Vector3 &point, Vector3 &normal)  
    61 { 
    62         point = Vector3(0,0,0); 
     22        return VIEW_CELL;  
    6323} 
    6424 
    … …  
    12282        return new ViewCell(mesh); 
    12383} 
     84 
     85void ViewCell::AddPassingRay(const Ray &ray, const int contributions) 
     86{ 
     87        mPassingRays.AddRay(ray, contributions); 
     88} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h

    r268 r308  
    22#define _ViewCell_H__ 
    33 
    4 #include "Intersectable.h" 
     4#include "Mesh.h" 
    55#include "Containers.h" 
    6  
    7 class Mesh; 
     6#include "Ray.h" 
    87 
    98//namespace GtpVisibilityPreprocessor { 
    … …  
    1211class BspPvs; 
    1312struct Triangle3; 
     13 
    1414/** 
    15         View cell represented as a mesh 
     15        View cell with an optional mesh representation 
    1616*/ 
    17 class ViewCell: public Intersectable 
     17class ViewCell: public MeshInstance 
    1818{ 
    1919public: 
    2020        ViewCell(); 
    21         /** Default constructor taking a mesh which represents the shape of 
    22                 the viewcell. 
     21        /** Constructor taking a mesh representing the shape of the viewcell. 
    2322        */ 
    2423        ViewCell(Mesh *mesh); 
    25  
    26         /** Returns pointer to the mesh which represents the shape of the viewcell. 
     24        /** Returns PvS.  
    2725        */ 
    28         Mesh *GetMesh(); 
    29  
    30         /** Returns pointer to PVS.  
    31                 @returns PVS, i.e., the visible BSP tree nodes. 
    32         */ 
    33         BspPvs *GetPVS(); 
    34  
    35         AxisAlignedBox3 GetBox(); 
    36    
    37         int CastRay(Ray &ray); 
    38    
    39         bool IsConvex(); 
    40         bool IsWatertight(); 
    41         float IntersectionComplexity(); 
     26        ViewCellPvs &GetPvs(); 
    4227 
    4328        int Type() const; 
    44  
    45         void GetRandomSurfacePoint(Vector3 &point, Vector3 &normal); 
    4629 
    4730        /** Derives viewcells from object container. 
    … …  
    6043        static ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height); 
    6144 
     45        void AddPassingRay(const Ray &ray, const int contributions);     
     46 
    6247protected: 
    6348 
    64         /// the mesh defining the geometry of this viewcell 
    65         Mesh *mMesh; 
    66         /// the PVS (i.e., the visible bsp tree nodes) 
    67         BspPvs *mPvs; 
     49        /// the potentially visible objects 
     50        ViewCellPvs mPvs; 
    6851 
     52        /** Ray set description of the rays passing through this node */ 
     53        PassingRaySet mPassingRays; 
    6954}; 
    7055 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

    r307 r308  
    424424                                interior->ProcessPolygons(&coincident, mStoreSplitPolys); 
    425425 
    426                                 //Debug << "split node on level " << tData.mDepth << " bk: " << backPolys->size() << " frnt: " << frontPolys->size() << endl; 
    427426                                mStat.splits += splits; 
    428427 
    … …  
    437436                else // reached leaf => subdivide current viewcell 
    438437                { 
    439                         //if (tData.mPolygons->size() > 0) 
    440                         //      Debug << "Subdividing further: polygon size: " << (int)tData.mPolygons->size() << ", view cell: " << tData.mViewCell << endl; 
    441  
    442                         BspNode *root = Subdivide(tStack, tData, viewCells);             
    443  
     438                        //if (tData.mPolygons->size() > 0) Debug << "Subdividing further: polygon size: " << (int)tData.mPolygons->size() << ", view cell: " << tData.mViewCell << endl; 
     439                        BspNode *root = Subdivide(tStack, tData);                
     440 
     441                        if (viewCells && root->IsLeaf()) 
     442                        {       // generate new view cell for each leaf 
     443                                ViewCell *viewCell = new ViewCell(); 
     444                                viewCells->push_back(viewCell); 
     445                                 
     446                                dynamic_cast<BspLeaf *>(root)->SetViewCell(viewCell); 
     447                } 
    444448                        if (!mRoot) // tree empty => new root 
    445449                                mRoot = root; 
    … …  
    448452} 
    449453 
    450 int BspTree::AddMesh2Polygons(Mesh *mesh, PolygonContainer &polys, Intersectable *parent) 
     454int BspTree::AddMesh2Polygons(Mesh *mesh, PolygonContainer &polys, MeshInstance *parent) 
    451455{ 
    452456        FaceContainer::const_iterator fi; 
    … …  
    498502                        mesh = dynamic_cast<MeshInstance *>(object)->GetMesh(); 
    499503                        break; 
    500                 case Intersectable::VIEWCELL: 
     504                case Intersectable::VIEW_CELL: 
    501505                        mesh = dynamic_cast<ViewCell *>(object)->GetMesh(); 
    502506                        break; 
    … …  
    586590 
    587591                // subdivide leaf node 
    588                 BspNode *root = Subdivide(tStack, tData, viewCells); 
     592                BspNode *root = Subdivide(tStack, tData); 
     593 
     594                if (viewCells && root->IsLeaf()) 
     595                {       // generate new view cell for each leaf 
     596                        ViewCell *viewCell = new ViewCell(); 
     597                        viewCells->push_back(viewCell); 
     598 
     599                        dynamic_cast<BspLeaf *>(root)->SetViewCell(viewCell); 
     600                } 
    589601 
    590602                // empty tree => new root corresponding to unbounded space 
    … …  
    598610 
    599611 
    600 BspNode *BspTree::Subdivide(BspTraversalStack &tStack, BspTraversalData &tData,  
    601                                                         ViewCellContainer *viewCells) 
     612BspNode *BspTree::Subdivide(BspTraversalStack &tStack, BspTraversalData &tData) 
    602613{ 
    603614        //-- terminate traversal   
    … …  
    605616        { 
    606617#ifdef _DEBUG 
    607                 Debug << "subdivision terminated at depth " << tData.mDepth << ", #polys: " << (int)tData.mPolygons->size() << endl; 
     618                Debug << "subdivision terminated at depth " << tData.mDepth << ", #polys: "  
     619                          << (int)tData.mPolygons->size() << endl; 
    608620#endif 
    609621 
    … …  
    611623 
    612624                BspLeaf *leaf = dynamic_cast<BspLeaf *>(tData.mNode); 
    613  
    614                 //-- new viewcells are generated and added to each leaf 
    615                 if (viewCells) 
    616                 { 
    617                         ViewCell *viewCell = new ViewCell(); 
    618                         leaf->SetViewCell(viewCell); 
    619                         viewCells->push_back(viewCell); 
    620                         // Debug << "creating new viewcell" << endl; 
    621                 } 
    622                 //-- add viewcell stored in split polygon 
    623                 else if (!leaf->GetViewCell()) 
     625                 
     626                // add view cell to leaf 
     627                if (!leaf->GetViewCell()) 
    624628                        leaf->SetViewCell(tData.mViewCell); 
    625                 //else Debug << "Leaf already has view cell " << endl; 
    626629 
    627630                // remaining polygons are discarded or added to node 
    628                 tData.mNode->ProcessPolygons(tData.mPolygons, mStoreSplitPolys); 
     631                leaf->ProcessPolygons(tData.mPolygons, mStoreSplitPolys); 
    629632                DEL_PTR(tData.mPolygons); 
    630633 
    631                 return tData.mNode; 
     634                return leaf; 
    632635        } 
    633636 
    … …  
    644647                                                                                  &coincident); 
    645648 
    646         //-- extract view cells from coincident polygons according to plane normal 
    647649        ViewCell *frontViewCell = mViewCell; 
    648650        ViewCell *backViewCell = mViewCell; 
    649          
    650     if (!viewCells) 
    651         {       // extract the pointer to the view cells 
    652                 ExtractViewCells(&backViewCell, 
    653                                                  &frontViewCell, 
    654                                                  coincident,  
    655                                                  interior->mPlane,  
    656                                                  frontPolys->empty(),  
    657                                                  backPolys->empty()); 
    658         } 
     651 
     652#ifdef _DEBUG    
     653        if (frontPolys->empty() && backPolys->empty() && (coincident.size() > 2)) 
     654        {       for (PolygonContainer::iterator it = coincident.begin(); it != coincident.end(); ++it) 
     655                        Debug << (*it) << " " << (*it)->GetArea() << " " << (*it)->mParent << endl ; 
     656                Debug << endl;} 
     657#endif 
     658 
     659        //-- extract view cells from coincident polygons according to plane normal 
     660        ExtractViewCells(&backViewCell, &frontViewCell, coincident, interior->mPlane,  
     661                                                 frontPolys->empty(), backPolys->empty()); 
    659662         
    660663        // don't need coincident polygons anymore 
    … …  
    684687        PolygonContainer::const_iterator it, it_end = coincident.end(); 
    685688 
     689        //-- find first view cells in front and back leafs 
    686690        for (it = coincident.begin(); !(foundFront && foundBack) &&  
    687                 (it < coincident.end()); ++it) 
     691                (it != it_end); ++ it) 
    688692        { 
    689693                if (DotProd((*it)->GetSupportingPlane().mNormal, splitPlane.mNormal > 0)) 
    … …  
    9961000                if (sSplitPlaneStrategy & BALANCED_VIEW_CELLS) 
    9971001                { 
    998                         Intersectable *viewCell = (*it)->mParent; 
     1002                        MeshInstance *viewCell = (*it)->mParent; 
    9991003                 
    10001004                        if (classification == Polygon3::FRONT_SIDE) 
    … …  
    10111015                val += sLeastSplitsFactor * sumSplits / (float)polys.size(); 
    10121016 
    1013         if ((sSplitPlaneStrategy & LARGEST_POLY_AREA) && sumPolyArea)  
     1017        if (sSplitPlaneStrategy & LARGEST_POLY_AREA)  
    10141018                val += sLargestPolyAreaFactor * (float)polys.size() / sumPolyArea; // HACK 
    10151019 
    … …  
    10221026                ObjectContainer::const_iterator frontIt, frontIt_end = frontViewCells.end(); 
    10231027         
    1024                 Intersectable *intersect = NULL; 
     1028                Intersectable *vc = NULL; 
    10251029                // increase counter for view cells in front of plane 
    10261030                for (frontIt = frontViewCells.begin(); frontIt != frontIt_end; ++frontIt) 
    10271031                { 
    1028                         if (*frontIt != intersect) 
     1032                        if (*frontIt != vc) 
    10291033                        { 
    1030                                 intersect = *frontIt; 
     1034                                vc = *frontIt; 
    10311035                                sumBalancedViewCells += 1.0f; 
    10321036                        } 
    … …  
    10341038 
    10351039                ObjectContainer::const_iterator backIt, backIt_end = backViewCells.end(); 
    1036                 intersect = NULL; 
     1040                vc = NULL; 
    10371041                // decrease counter for view cells on back side of plane 
    10381042                for (backIt = backViewCells.begin(); backIt != backIt_end; ++backIt) 
    10391043                { 
    1040                         if (*backIt != intersect) 
     1044                        if (*backIt != vc) 
    10411045                        { 
    1042                                 intersect = *backIt; 
     1046                                vc = *backIt; 
    10431047                                sumBalancedViewCells -= 1.0f; 
    10441048                        } 
    … …  
    11361140} 
    11371141 
    1138 int BspTree::CollectLeafPvs() 
    1139 { 
    1140         int totalPvsSize = 0; 
    1141    
    1142         stack<BspNode *> nodeStack; 
    1143    
    1144         nodeStack.push(mRoot); 
    1145    
    1146         while (!nodeStack.empty())  
    1147         { 
    1148                 BspNode *node = nodeStack.top(); 
    1149                  
    1150                 nodeStack.pop(); 
    1151                  
    1152                 if (node->IsLeaf())  
    1153                 { 
    1154                         BspLeaf *leaf = dynamic_cast<BspLeaf *>(node); 
    1155  
    1156                         ViewCell *viewcell = leaf->GetViewCell(); 
    1157                          
    1158                         if (!viewcell->Mailed())  
    1159                         { 
    1160                                 viewcell->Mail(); // what does mail mean? 
    1161                                          
    1162                                 // add this node to pvs of all nodes it can see 
    1163                                 BspPvsMap::iterator ni;  
    1164            
    1165         /*                      for (ni = object->mBspPvs.mEntries.begin(); ni != object->mKdPvs.mEntries.end(); ni++)  
    1166                                 { 
    1167                                         BspNode *node = (*ni).first; 
    1168              
    1169                                         // $$ JB TEMPORARY solution -> should add object PVS or explictly computed 
    1170                                         // BSP tree PVS 
    1171                                 if (leaf->mBspPvs.AddNodeSample(node)) 
    1172                                                 totalPvsSize++; 
    1173                                 }*/ 
    1174                         } 
    1175                 } else  
    1176                 { 
    1177                         // traverse tree 
    1178                         BspInterior *interior = (BspInterior *)node; 
    1179        
    1180                         nodeStack.push(interior->GetFront()); 
    1181                         nodeStack.push(interior->GetBack()); 
    1182                 } 
    1183         } 
    1184  
    1185         return totalPvsSize; 
    1186 } 
    1187  
    11881142AxisAlignedBox3 BspTree::GetBoundingBox() const 
    11891143{ 
    … …  
    13031257                        extp = splitPlane->FindIntersection(ray.GetLoc(), extp, &maxt); 
    13041258 
    1305                 } else // compute intersections with objects in leaf 
     1259                } else // reached leaf => intersection with view cell 
    13061260                { 
    13071261                        BspLeaf *leaf = dynamic_cast<BspLeaf *>(node); 
    1308                         //ray.leaves.push_back(leaf); 
    1309       // TODO 
    1310                         /*ObjectContainer::const_iterator mi; 
    1311                         for (mi = leaf->mObjects.begin(); mi != leaf->mObjects.end(); ++mi)  
     1262                         
     1263                        //ray.mBspLeaves.push_back(leaf); 
     1264                         
     1265                        if (!leaf->mViewCell->Mailed()) 
    13121266                        { 
    1313                                 Intersectable *object = *mi; 
    1314                                 if (!object->Mailed())  
    1315                                 { 
    1316                                         object->Mail(); 
    1317                                         //ray.meshes.push_back(mesh); 
    1318                                         hits += object->CastRay(ray); 
    1319                                 } 
    1320                         }*/ 
    1321  
    1322                         if (hits && ray.GetType() == Ray::LOCAL_RAY) 
     1267                                ray.viewCells.push_back(leaf->mViewCell); 
     1268                                mViewCell->Mail(); 
     1269                                ++ hits; 
     1270                        } 
     1271 
     1272                        if (hits && ray.GetType() == Ray::LOCAL_RAY) 
    13231273                                if (ray.intersections[0].mT <= maxt) 
    13241274                                        break; 
    … …  
    13551305        return false; 
    13561306} 
     1307 
     1308void BspTree::CollectViewCells(BspNode *n, ViewCellContainer &viewCells) 
     1309{ 
     1310        stack<BspNode *> nodeStack; 
     1311 
     1312        nodeStack.push(n); 
     1313 
     1314        while (!nodeStack.empty())  
     1315        { 
     1316                BspNode *node = nodeStack.top(); 
     1317                nodeStack.pop(); 
     1318 
     1319                if (node->IsLeaf())  
     1320                { 
     1321                        ViewCell *viewCell = dynamic_cast<BspLeaf *>(node)->mViewCell; 
     1322 
     1323                        if (!viewCell->Mailed())  
     1324                        { 
     1325                                viewCell->Mail(); 
     1326                                viewCells.push_back(viewCell); 
     1327                        } 
     1328                } 
     1329                else  
     1330                { 
     1331                        BspInterior *interior = dynamic_cast<BspInterior *>(node); 
     1332                        nodeStack.push(interior->mFront); 
     1333                        nodeStack.push(interior->mBack); 
     1334                } 
     1335        } 
     1336} 
    13571337//} // GtpVisibilityPreprocessor 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

    r306 r308  
    327327        bool Export(const string filename); 
    328328 
     329        void CollectViewCells(BspNode *n, ViewCellContainer &viewCells); 
     330 
     331        /** A ray is cast possible intersecting the tree. 
     332                @param the ray that is cast. 
     333                @returns the number of intersections with objects stored in the tree. 
     334        */ 
     335        int CastRay(Ray &ray); 
     336 
    329337        //static bool displayDebug; 
    330338protected: 
    … …  
    368376            @param tStack current traversal stack 
    369377                @param tData traversal data also holding node to be subdivided 
    370                 @param viewCellContainer if not null, a new viewcell is created and stored in the container 
    371378                @returns new root of the subtree 
    372379        */ 
    373         BspNode *Subdivide(BspTraversalStack &tStack, BspTraversalData &tData, ViewCellContainer *viewCells = NULL); 
     380        BspNode *Subdivide(BspTraversalStack &tStack, BspTraversalData &tData); 
    374381 
    375382        /** Selects a splitting plane.  
    … …  
    436443                @returns number of polygons 
    437444        */ 
    438         int AddMesh2Polygons(Mesh *mesh, PolygonContainer &polys, Intersectable *parent); 
    439  
    440         /** A ray is cast possible intersecting the tree. 
    441                 @param the ray that is cast. 
    442                 @returns the number of intersections with objects stored in the tree. 
    443         */ 
    444         int CastRay(Ray &ray); 
     445        int AddMesh2Polygons(Mesh *mesh, PolygonContainer &polys, MeshInstance *parent); 
    445446 
    446447        /** returns next candidate index and reorders polygons so no candidate is chosen two times 

  • trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

    r292 r308  
    102102    ExportMeshInstance((MeshInstance *)object); 
    103103        break; 
    104   case Intersectable::VIEWCELL: 
     104  case Intersectable::VIEW_CELL: 
    105105        ExportViewCell((ViewCell *)object); 
    106106    break; 
Note: See TracChangeset for help on using the changeset viewer.