Changeset 439


Ignore:
Timestamp:
11/29/05 00:01:43 (19 years ago)
Author:
mattausch
Message:

added vview cell manager functionality

Location:
trunk/VUT/GtpVisibilityPreprocessor
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    r261 r439  
    2727    */ 
    2828    virtual bool LoadScene(const string filename); 
    29  
    30     /** Load the input viewcells. The input viewcells should be given as a collection 
    31         of meshes. Each mesh is assume to form a bounded polyhedron defining the interior of 
    32         the viewcell. The method then builds a BSP tree of these view cells. 
    33         @param filename file to load 
    34         @return true on success 
    35     */ 
    36     virtual bool LoadViewCells(const string filename); 
    3729 
    3830    /** Generate the viewCells automatically. The particular algorithm to be used depends 

  • trunk/VUT/GtpVisibilityPreprocessor/scripts/Preprocessor.vcproj

    r437 r439  
    300300                        </File> 
    301301                        <File 
     302                                RelativePath="..\src\ViewCellsManager.cpp"> 
     303                        </File> 
     304                        <File 
     305                                RelativePath="..\src\ViewCellsManager.h"> 
     306                        </File> 
     307                        <File 
    302308                                RelativePath="..\src\VspBspTree.cpp"> 
    303309                        </File> 

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

    r374 r439  
    1010    virtual bool ComputeVisibility(); 
    1111 
    12                 virtual bool BuildBspTree() { return false; } 
    13  
    1412  }; 
    1513   

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

    r429 r439  
    66#include "ViewCell.h" 
    77#include "Environment.h" 
    8 #include "RenderSimulator.h" 
     8#include "ViewCellsManager.h" 
    99 
    1010Preprocessor::Preprocessor(): 
    … …  
    1212mBspTree(NULL), 
    1313mVspKdTree(NULL), 
    14 mRenderSimulator(NULL) 
     14mViewCellsManager(NULL) 
    1515{ 
    1616} 
    … …  
    2121        DEL_PTR(mBspTree); 
    2222        DEL_PTR(mKdTree); 
    23  
    24         DEL_PTR(mRenderSimulator); 
    25  
    26         DeleteViewCells(); 
    27 } 
    28  
    29 bool 
    30 Preprocessor::LoadViewCells(const string filename) 
    31 { 
    32         X3dParser parser; 
    33          
    34         environment->GetFloatValue("ViewCells.height", parser.mViewCellHeight); 
    35          
    36         return parser.ParseFile(filename, mViewCells); 
    37 } 
    38  
    39 bool 
    40 Preprocessor::ParseViewCellsOptions() 
    41 { 
    42         // parse type of view cells 
    43         char viewCellsStr[64]; 
    44         environment->GetStringValue("ViewCells.hierarchy", viewCellsStr); 
    45  
    46         if (strcmp(viewCellsStr, "bspTree") == 0) 
    47         { 
    48                 ViewCell::sHierarchy = ViewCell::BSP; 
    49         } 
    50         else if (strcmp(viewCellsStr, "kdTree") == 0) 
    51         { 
    52                 ViewCell::sHierarchy = ViewCell::KD; 
    53         } 
    54         else if (strcmp(viewCellsStr, "vspTree") == 0) 
    55         { 
    56                 ViewCell::sHierarchy = ViewCell::VSP; 
    57         } 
    58         else if (strcmp(viewCellsStr, "sceneDependent") == 0) 
    59         { 
    60                 //TODO 
    61         } 
    62         else 
    63         { 
    64                 cerr<<"Wrong view cells type" << viewCellsStr << endl; 
    65                 exit(1); 
    66         } 
    67  
    68         return true; 
    69 } 
    70  
    71 RenderSimulator *Preprocessor::GetRenderSimulator() 
    72 { 
    73         if (mRenderSimulator) 
    74                 return mRenderSimulator; 
    75  
    76     float objRenderCost = 0, vcOverhead = 0, moveSpeed = 0; 
    77  
    78         environment->GetFloatValue("Simulation.objRenderCost",objRenderCost); 
    79         environment->GetFloatValue("Simulation.vcOverhead", vcOverhead); 
    80         environment->GetFloatValue("Simulation.moveSpeed", moveSpeed); 
    81  
    82         Debug << "render simulator using render cost=" << objRenderCost << ", vc overhead=" << vcOverhead << ", move speed=" << moveSpeed << endl; 
    83         if (ViewCell::sHierarchy == ViewCell::BSP) 
    84         { 
    85                 mRenderSimulator = new BspViewCellRenderSimulator(objRenderCost, vcOverhead, moveSpeed, mBspTree); 
    86                 Debug << "creating bsp render simulator" << endl; 
    87         } 
    88         else if (ViewCell::sHierarchy == ViewCell::KD)// KD view cells 
    89         { 
    90                 mRenderSimulator = new KdViewCellRenderSimulator(objRenderCost, vcOverhead, moveSpeed, mKdTree); 
    91                 Debug << "creating kd render simulator" << endl; 
    92         } 
    93         else 
    94         { 
    95                 Debug << "not implemented yet" << endl; 
    96                 return NULL; 
    97         } 
    98  
    99         return mRenderSimulator; 
    100 } 
    101  
    102 void Preprocessor::DeleteViewCells() 
    103 { 
    104         for (int i = 0; i < (int)mViewCells.size(); ++ i) 
    105         { 
    106                 Mesh *mesh = mViewCells[i]->GetMesh(); 
    107                 DEL_PTR(mesh); 
    108         } 
    109         CLEAR_CONTAINER(mViewCells); 
     23        DEL_PTR(mVspKdTree); 
     24        DEL_PTR(mViewCellsManager); 
    11025} 
    11126 
    … …  
    512427                exporter->ExportIntersectable(objects[j]); 
    513428} 
     429 
     430bool Preprocessor::PrepareViewCells() 
     431{ 
     432        //-- parse type of view cell container 
     433        char viewCellsStr[64]; 
     434        environment->GetStringValue("ViewCells.type", viewCellsStr); 
     435 
     436        if (strcmp(viewCellsStr, "kdTree") == 0) 
     437        { 
     438                //mViewCellsManager = new KdViewCellsManager(mKdTree); 
     439        } 
     440        if (strcmp(viewCellsStr, "bspTree") == 0) 
     441        { 
     442                //mViewCellsManager = new BspViewCellsManager(mBspTree, mBspConstructionSamples); 
     443        } 
     444        else if (strcmp(viewCellsStr, "vspTree") == 0) 
     445        { 
     446                //mViewCellsManager = new VspKdViewCellContaienr(mVspKdTree, mVspKdConstructionSamples); 
     447        } 
     448        else if (strcmp(viewCellsStr, "sceneDependent") == 0) 
     449        { 
     450                //TODO 
     451                //mViewCellsManager = new BspViewCellContainer(mBspTree); 
     452        } 
     453        else 
     454        { 
     455                cerr<<"Wrong view cells type" << viewCellsStr << endl; 
     456                exit(1); 
     457        } 
     458 
     459        //-- parse view cells construction method 
     460        bool loadViewCells = false; 
     461        environment->GetBoolValue("ViewCell.Construction.loadFromFile", loadViewCells); 
     462 
     463        //-- load view cells from file if requested 
     464        if (loadViewCells) 
     465        { 
     466                char buff[100]; 
     467                environment->GetStringValue("ViewCells.filename", buff); 
     468                string vcFilename(buff); 
     469                mViewCellsManager->LoadViewCells(vcFilename); 
     470        } 
     471 
     472        return true; 
     473} 

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

    r429 r439  
    1414class SceneGraph; 
    1515class Exporter; 
     16class ViewCellsManager; 
     17 
    1618 
    1719/** Namespace for the external visibility preprocessor 
    … …  
    4042  virtual bool LoadScene(const string filename); 
    4143   
    42   /** Load the input viewcells. The input viewcells should be given as a collection 
    43       of meshes. Each mesh is assume to form a bounded polyhedron defining the interior of 
    44       the viewcell. The method then builds a BSP tree of these view cells. 
    45         @param filename file to load 
    46         @return true on success 
    47   */ 
    48   virtual bool LoadViewCells(const string filename); 
    49    
    5044  /** Export all preprocessed data in a XML format understandable by the 
    5145      PreprocessingInterface of the GtpVisibilityPreprocessor Module. The file can be compressed depending 
    … …  
    6054  */ 
    6155  virtual bool BuildKdTree(); 
    62    
    63    /** Build the BSP tree of currently loaded occluders/occludees/viewcells. The construction 
    64       is driven by the environment settings, which also says which of the three types of 
    65       entities should be used to drive the heuristical construction (only occluders by default) 
    66   */ 
    67   virtual bool BuildBspTree() = 0; 
    6856 
    6957  /** Compute visibility method. This method has to be reimplemented by the actual 
    … …  
    7361  virtual bool ComputeVisibility() = 0; 
    7462   
     63  /** View cells are either loaded or prepared for generation, according to the chosen environment 
     64      object. Important evironment options are, e.g, the view cell type. 
     65      Should be done after scene loading (i.e., some options are based on scene type). 
     66  */ 
     67  bool PrepareViewCells(); 
    7568   
    7669  bool 
    … …  
    8578  virtual void BspTreeStatistics(ostream &s); 
    8679 
    87   void DeleteViewCells(); 
    88  
    89   RenderSimulator *GetRenderSimulator(); 
    90  
    91   /** Parses the view cell options 
    92   */ 
    93   bool ParseViewCellsOptions(); 
    94  
    95  
    9680  /// scene graph loaded from file 
    9781  SceneGraph *mSceneGraph; 
    … …  
    10488  /// list of all loaded occludees 
    10589  ObjectContainer mOccludees; 
    106   /// list of all loaded/generated viewcells 
    107   ViewCellContainer mViewCells; 
    108    
     90    
    10991  /// BSP tree representing the viewcells 
    11092  BspTree *mBspTree; 
    11193 
    112   /// the view cell corresponding to unbounded space 
    113   BspViewCell mUnbounded; 
    114  
    115   RenderSimulator *mRenderSimulator; 
     94  ViewCellsManager *mViewCellsManager; 
    11695 
    11796  /** Kd tree inducing a coarse partition of view space that are the building 

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

    r420 r439  
    2626{} 
    2727 
    28 RenderSimulator::RenderSimulator(float objRenderCost, float vcOverhead, float moveSpeed): 
    29 mObjRenderCost(objRenderCost), mVcOverhead(vcOverhead), mMoveSpeed(moveSpeed) 
    30 { 
    31 } 
    32  
    33 /***************************************************** 
    34  *     class ViewCellRenderSimulator implementation  * 
    35  *****************************************************/ 
    36  
    37 BspViewCellRenderSimulator::BspViewCellRenderSimulator(float objRenderCost,  
     28RenderSimulator::RenderSimulator(float objRenderCost,  
     29                                                                 float vcOverhead,  
     30                                                                 float moveSpeed): 
     31mObjRenderCost(objRenderCost),  
     32mVcOverhead(vcOverhead),  
     33mMoveSpeed(moveSpeed) 
     34{ 
     35} 
     36 
     37void RenderSimulator::SetObjectRenderCost(const float objRenderCost) 
     38{ 
     39        mObjRenderCost = objRenderCost; 
     40} 
     41 
     42void RenderSimulator::SetVcOverhead(const float vcOverhead) 
     43{ 
     44        mVcOverhead = vcOverhead; 
     45} 
     46 
     47void RenderSimulator::SetMoveSpeed(const float moveSpeed) 
     48{ 
     49        mMoveSpeed = moveSpeed; 
     50} 
     51 
     52/********************************************************/ 
     53/*     class BspRenderSimulator implementation          */ 
     54/********************************************************/ 
     55 
     56BspRenderSimulator::BspRenderSimulator(float objRenderCost,  
    3857                                                                                           float vcOverhead,  
    3958                                                                                           float moveSpeed, 
    … …  
    4362} 
    4463 
    45 Real BspViewCellRenderSimulator::SimulateRendering() 
    46 { 
    47         mStat.Reset(); 
    48         mStat.Start(); 
     64SimulationStatistics BspRenderSimulator::SimulateRendering() 
     65{ 
     66        SimulationStatistics simStat; 
     67 
     68        simStat.Reset(); 
     69        simStat.Start(); 
    4970 
    5071        Real renderTime = 0; 
    … …  
    84105                renderTime += vcCost; 
    85106 
    86                 if (vcCost > mStat.maxCost) 
    87                         mStat.maxCost = vcCost; 
    88                 else if (vcCost < mStat.minCost) 
    89                         mStat.minCost = vcCost; 
     107                if (vcCost > simStat.maxCost) 
     108                        simStat.maxCost = vcCost; 
     109                else if (vcCost < simStat.minCost) 
     110                        simStat.minCost = vcCost; 
    90111 
    91112                // probability that a view cell border is crossed 
    … …  
    94115                // crossing the border of a view cell is also depending on the move speed 
    95116                loadPvsOverhead += pCrossVc * mVcOverhead; 
    96 overallarea+=area; 
     117overallarea += area; 
    97118                pInVcTotal += pInVc; 
    98119        } 
    … …  
    102123        loadPvsOverhead /= pCrossVcTotal; 
    103124 
    104         mStat.avgRtWithoutOverhead = renderTime; 
    105         mStat.avgRenderTime = renderTime + loadPvsOverhead; 
    106          
    107         mStat.maxCost /= pInVcTotal; 
    108         mStat.minCost /= pInVcTotal; 
    109  
    110         mStat.Stop(); 
    111  
    112         return renderTime + loadPvsOverhead; 
    113 } 
    114  
    115 Real BspViewCellRenderSimulator::RenderPvs(ViewCell &viewCell,  
     125        simStat.avgRtWithoutOverhead = renderTime; 
     126        simStat.avgRenderTime = renderTime + loadPvsOverhead; 
     127         
     128        simStat.maxCost /= pInVcTotal; 
     129        simStat.minCost /= pInVcTotal; 
     130 
     131        simStat.Stop(); 
     132 
     133        return simStat; 
     134} 
     135 
     136Real BspRenderSimulator::RenderPvs(ViewCell &viewCell,  
    116137                                                                           float objRenderTime) const 
    117138{ 
    … …  
    123144 *******************************************************/ 
    124145 
    125 KdViewCellRenderSimulator::KdViewCellRenderSimulator(float objRenderCost,  
     146KdRenderSimulator::KdRenderSimulator(float objRenderCost,  
    126147                                                                                         float vcOverhead, 
    127148                                                                                         float moveSpeed, 
    … …  
    131152} 
    132153 
    133 Real KdViewCellRenderSimulator::SimulateRendering() 
    134 { 
     154SimulationStatistics KdRenderSimulator::SimulateRendering() 
     155{ 
     156        SimulationStatistics simStat; 
     157 
    135158        //mKdTree->CollectLeavesPvs(); 
    136         mStat.Reset(); 
    137         mStat.Start(); 
     159        simStat.Reset(); 
     160        simStat.Start(); 
    138161 
    139162        // total render time 
    … …  
    170193                renderTime += vcCost; 
    171194 
    172                 if (vcCost > mStat.maxCost) 
    173                         mStat.maxCost = vcCost; 
    174                 else if (vcCost < mStat.minCost) 
    175                         mStat.minCost = vcCost; 
     195                if (vcCost > simStat.maxCost) 
     196                        simStat.maxCost = vcCost; 
     197                else if (vcCost < simStat.minCost) 
     198                        simStat.minCost = vcCost; 
    176199 
    177200                // probability that a view cell border is crossed 
    … …  
    186209        loadPvsOverhead /= pCrossVcTotal; 
    187210 
    188     mStat.avgRtWithoutOverhead = renderTime; 
    189         mStat.avgRenderTime = renderTime + loadPvsOverhead; 
    190  
    191         mStat.maxCost /= pInVcTotal; 
    192         mStat.minCost /= pInVcTotal; 
    193  
    194         mStat.Stop(); 
    195  
    196         return renderTime + loadPvsOverhead; 
    197 } 
    198  
    199 Real KdViewCellRenderSimulator::RenderPvs(KdLeaf *leaf,  
    200                                                                                    float objRenderTime) const 
     211    simStat.avgRtWithoutOverhead = renderTime; 
     212        simStat.avgRenderTime = renderTime + loadPvsOverhead; 
     213 
     214        simStat.maxCost /= pInVcTotal; 
     215        simStat.minCost /= pInVcTotal; 
     216 
     217        simStat.Stop(); 
     218 
     219        return simStat; 
     220} 
     221 
     222Real KdRenderSimulator::RenderPvs(KdLeaf *leaf,  
     223                                                                  float objRenderTime) const 
    201224{ 
    202225        return leaf->mKdPvs.GetSize() * objRenderTime; 

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

    r414 r439  
    4747public: 
    4848        RenderSimulator(); 
     49        /** Constructor taking the estimated render cost,  
     50                the view cell overhead, 
     51                and the average move speed of the player into account. 
     52        */ 
    4953        RenderSimulator(float objRendercost, float vcOverhead, float moveSpeed); 
    50         virtual Real SimulateRendering() = 0; 
     54 
     55        /** Simulates rendering of the view cells. 
     56                @returns the statistics of the simulation. 
     57        */ 
     58        virtual SimulationStatistics SimulateRendering() = 0; 
     59 
     60        /** Sets estimated render time for a single object in the PVS. 
     61        */ 
     62        void SetObjectRenderCost(const float objRenderCost); 
     63 
     64        /** Contant overhead for crossing a view cell border. 
     65        */ 
     66        void SetVcOverhead(const float vcOverhead); 
     67 
     68        /** Average move speed of the player during rendering. 
     69        */ 
     70        void SetMoveSpeed(const float moveSpeed); 
     71 
     72 
     73protected: 
    5174 
    5275        /// render time for single object of the PVS 
    … …  
    5679        /// move speed of player 
    5780        float mMoveSpeed; 
    58  
    59         SimulationStatistics mStat; 
    6081}; 
    6182 
    62 class BspViewCellRenderSimulator: public RenderSimulator 
     83class BspRenderSimulator: public RenderSimulator 
    6384{ 
    6485public: 
    65         BspViewCellRenderSimulator(float objRenderCost,  
     86        BspRenderSimulator(float objRenderCost,  
    6687                                                           float vcOverhead,  
    6788                                                           float moveSpeed,  
    6889                                                           BspTree *bspTree); 
    6990 
    70         Real SimulateRendering(); 
     91        SimulationStatistics SimulateRendering(); 
    7192 
    7293protected: 
    … …  
    80101}; 
    81102 
    82 class KdViewCellRenderSimulator: public RenderSimulator 
     103class KdRenderSimulator: public RenderSimulator 
    83104{ 
    84105public: 
    85         KdViewCellRenderSimulator(float objRenderCost,  
     106        KdRenderSimulator(float objRenderCost,  
    86107                                                          float vcOverhead,  
    87108                                                          float moveSpeed,  
    88109                                                          KdTree *kdTree); 
    89         Real SimulateRendering(); 
     110        SimulationStatistics SimulateRendering(); 
    90111 
    91112protected: 

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

    r437 r439  
    77#include "Polygon3.h" 
    88#include "ViewCell.h" 
     9#include "ViewCellsManager.h" 
    910#include "RenderSimulator.h" 
    1011 
    … …  
    5354} 
    5455 
    55 bool 
    56 SamplingPreprocessor::BuildBspTree() 
    57 { 
    58         // delete old tree 
    59         DEL_PTR(mBspTree); 
    60         mBspTree = new BspTree(&mUnbounded); 
    61         ObjectContainer objects; 
    62          
    63         switch (BspTree::sConstructionMethod) 
    64         { 
    65         case BspTree::FROM_INPUT_VIEW_CELLS: 
    66                 mBspTree->Construct(mViewCells); 
    67                 break; 
    68         case BspTree::FROM_SCENE_GEOMETRY: 
    69                 DeleteViewCells(); // we generate new view cells 
    70                 mSceneGraph->CollectObjects(&objects); 
    71                 mBspTree->Construct(objects); 
    72                 break; 
    73         case BspTree::FROM_SAMPLES: 
    74                 DeleteViewCells(); // we generate new view cells 
    75                 mBspTree->Construct(mSampleRays); 
    76                 break; 
    77         default: 
    78                 Debug << "Error: Method not available\n"; 
    79                 break; 
    80         } 
    81          
    82          
    83         return true; 
    84 } 
    85  
    8656int 
    8757SamplingPreprocessor::AddNodeSamples(const Ray &ray, 
    88                                                                                                                                                 Intersectable *sObject, 
    89                                                                                                                                                 Intersectable *tObject 
    90                                                                                                                                                 ) 
     58                                                                        Intersectable *sObject, 
     59                                                                        Intersectable *tObject 
     60                                                                        ) 
    9161{ 
    9262  int contributingSamples = 0; 
    … …  
    11080        for (j=1; j < ((int)ray.kdLeaves.size() - 1); j++) { 
    11181                ray.kdLeaves[j]->AddPassingRay2(ray, 
    112                                                                                                                                                 objects, 
    113                                                                                                                                                 ray.kdLeaves.size() 
    114                                                                                                                                                 ); 
     82                                                                                objects, 
     83                                                                                ray.kdLeaves.size() 
     84                                                                                ); 
    11585  } 
    11686   
    … …  
    138108  
    139109        // object can be seen from the view cell => add to view cell pvs 
    140         for (j=0; j < ray.bspIntersections.size(); ++ j) 
     110        /*for (j=0; j < ray.bspIntersections.size(); ++ j) 
    141111        {        
    142112                BspLeaf *leaf = ray.bspIntersections[j].mLeaf; 
    … …  
    145115                        contributingSamples +=  
    146116                                leaf->GetViewCell()->GetPvs().AddSample(obj); 
    147         } 
     117        }*/ 
    148118  
    149119        // rays passing through this viewcell 
    150         if (mPass > 1) 
     120        /*if (mPass > 1) 
    151121                for (j=1; j < ((int)ray.bspIntersections.size() - 1); ++ j)  
    152122                { 
    … …  
    157127                                        AddPassingRay(ray, contributingSamples ? 1 : 0); 
    158128                } 
    159   
     129 */ 
    160130        return contributingSamples; 
    161131} 
    … …  
    167137        int sampleContributions = 0; 
    168138 
    169         long t1 = GetRealTime(); 
     139/*      long t1 = GetRealTime(); 
    170140        // cast ray to KD tree to find intersection with other objects 
    171141        mKdTree->CastRay(ray); 
    … …  
    214184                break; 
    215185        } 
    216  
     186*/ 
    217187        return sampleContributions; 
    218188} 
    … …  
    413383                 
    414384                        int pvsSize = 0; 
    415                         if (ViewCell::sHierarchy == ViewCell::KD) 
    416                                 pvsSize = object->mKdPvs.GetSize(); 
     385                        //if (ViewCell::sHierarchy == ViewCell::KD) 
     386                        //      pvsSize = object->mKdPvs.GetSize(); 
    417387                                                 
    418388                         
    … …  
    479449                                        } 
    480450                                        //------------------- 
    481                                         if (ViewCell::sHierarchy == ViewCell::BSP)  
    482                                         { 
    483                                                 ProcessBspViewCells(ray, 
    484                                                                                         reverseSample ? NULL : object, 
    485                                                                                         faceIndex, 
    486                                                                                         passContributingSamples, 
    487                                                                                         passSampleContributions); 
    488  
    489                                         } 
    490                                         else if (ViewCell::sHierarchy == ViewCell::VSP) 
    491                                         { 
    492                                                 ProcessVspViewCells(ray, 
    493                                                                                         reverseSample ? NULL : object, 
    494                                                                                         faceIndex, 
    495                                                                                         passContributingSamples, 
    496                                                                                         passSampleContributions); 
    497                                         } 
     451                                        ProcessViewCells(ray, 
     452                                                                         reverseSample ? NULL : object, 
     453                                                                         faceIndex, 
     454                                                                         passContributingSamples, 
     455                                                                         passSampleContributions); 
    498456                                } 
    499457                        } else { 
    … …  
    514472                mPass++; 
    515473         
    516                 if (ViewCell::sHierarchy == ViewCell::KD) 
     474                // TODO: move into view cell container 
     475                /*if (ViewCell::sHierarchy == ViewCell::KD) 
    517476                { 
    518477                        pvsSize = 0; 
    … …  
    525484                else 
    526485                        pvsSize += passSampleContributions; 
    527                  
     486                */ 
    528487                float avgRayContrib = (passContributingSamples > 0) ?  
    529488                        passSampleContributions/(float)passContributingSamples : 0; 
    … …  
    547506        } 
    548507         
    549         if (ViewCell::sHierarchy == ViewCell::KD)        
     508//      if (ViewCell::sHierarchy == ViewCell::KD)        
    550509                cout << "#totalKdPvsSize=" << mKdTree->CollectLeafPvs() << endl; 
    551510   
    552511        //-- render simulation 
    553         RenderSimulator *rs = GetRenderSimulator(); 
    554  
    555         if (rs) 
    556         { 
    557                 cout << "\nevaluating bsp view cells render time before merge ... "; 
    558  
    559                 rs->SimulateRendering(); 
    560          
    561                 cout << " finished" << endl; 
    562  
    563                 cout << GetRenderSimulator()->mStat << endl; 
    564                 Debug << GetRenderSimulator()->mStat << endl; 
    565         } 
     512        cout << "\nevaluating bsp view cells render time before merge ... "; 
     513 
     514        SimulationStatistics ss = mViewCellsManager->SimulateRendering(); 
     515 
     516        cout << " finished" << endl; 
     517        cout << ss << endl; 
     518        Debug << ss << endl; 
    566519 
    567520        if (mBspTree) 
    … …  
    610563 
    611564                //-- render simulation 
    612                  
    613                 RenderSimulator *rs = GetRenderSimulator(); 
    614  
    615                 if (rs) 
    616                 { 
    617                         cout << "\nevaluating render time after merge ... "; 
     565                cout << "\nevaluating render time after merge ... "; 
    618566                         
    619                         rs->SimulateRendering(); 
    620  
    621                         cout << " finished" << endl; 
    622  
    623                         cout << GetRenderSimulator()->mStat << endl; 
    624                         Debug << GetRenderSimulator()->mStat << endl; 
    625                 } 
     567                SimulationStatistics ss = mViewCellsManager->SimulateRendering(); 
     568 
     569                cout << " finished" << endl; 
     570 
     571                cout << ss << endl; 
     572                Debug << ss << endl; 
    626573 
    627574                if (1) // export view cells 
    … …  
    806753} 
    807754 
    808  
     755void SamplingPreprocessor::ProcessViewCells(const Ray &ray, 
     756                                            Intersectable *object, 
     757                                                                                        const int faceIndex, 
     758                                                                                        int &contributingSamples, 
     759                                                                                        int &sampleContributions) 
     760{ 
     761} 
     762/* 
    809763void SamplingPreprocessor::ProcessVspViewCells(Ray &ray, 
    810764                                               Intersectable *object, 
    … …  
    843797                } 
    844798        } 
    845         // save rays for post processing 
    846         /*else if (((int)mVspSampleRays.size() < mPostProcessSamples) || 
    847                          ((int)mVspSampleRays.size() < mVisualizationSamples)) 
    848         { 
    849                 mVspSampleRays.push_back(new Ray(ray)); 
    850         }*/ 
    851799} 
    852800 
    … …  
    897845        } 
    898846} 
    899  
     847*/ 
    900848// merge or subdivide view cells 
    901849int SamplingPreprocessor::PostprocessViewCells(const RayContainer &rays) 

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

    r429 r439  
    6565                @param sampleContributions contribution of the samples 
    6666        */ 
    67         void ProcessBspViewCells(const Ray &ray, 
     67        /*void ProcessBspViewCells(const Ray &ray, 
    6868                                                         Intersectable *object, 
    6969                                                         const int faceIndex, 
    … …  
    7676                                                         int &contributingSamples, 
    7777                                                         int &sampleContributions); 
     78*/ 
     79        void ProcessViewCells(const Ray &ray, 
     80                                                  Intersectable *object, 
     81                                                  const int faceIndex, 
     82                                                  int &contributingSamples, 
     83                                                  int &sampleContributions); 
    7884 
    79         /** Adds objects samples to bsp view cells. 
     85        /** Adds objects samples to kd and bsp view cells. 
    8086        */ 
    8187        int AddObjectSamples(Intersectable *obj, const Ray &ray); 
    82  
    83         bool BuildBspTree(); 
    8488 
    8589        /** Post processes view cells (i.e., merges or subdivides view cells based 

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

    r430 r439  
    44#include "MeshKdTree.h" 
    55#include "Triangle3.h" 
    6  
    7 ViewCell::HierarchyType ViewCell::sHierarchy = BSP; 
    86 
    97ViewCell::ViewCell(): MeshInstance(NULL), mPiercingRays(0) 
    … …  
    1311ViewCell::ViewCell(Mesh *mesh): MeshInstance(mesh), mPiercingRays(0) 
    1412{ 
    15 } 
    16  
    17 ViewCell *ViewCell::Generate(Mesh *mesh) 
    18 { 
    19         switch(sHierarchy) 
    20         { 
    21         case KD: 
    22                 return new ViewCell(mesh); 
    23         case BSP: 
    24                 return new BspViewCell(mesh); 
    25         default: 
    26                 Debug << "should not come here 3" << endl; 
    27                 return NULL; 
    28         } 
    2913} 
    3014 
    … …  
    4428} 
    4529 
    46 void ViewCell::DeriveViewCells(const ObjectContainer &objects,  
    47                                                            ViewCellContainer &viewCells,  
    48                                                            const int maxViewCells) 
    49 { 
    50         // maximal max viewcells 
    51         int limit = maxViewCells > 0 ?  
    52                 Min((int)objects.size(), maxViewCells) : (int)objects.size(); 
    53  
    54         for (int i = 0; i < limit; ++ i) 
    55         { 
    56                 Intersectable *object = objects[i]; 
    57                  
    58                 // extract the mesh instances 
    59                 if (object->Type() == Intersectable::MESH_INSTANCE) 
    60                 { 
    61                         MeshInstance *inst = dynamic_cast<MeshInstance *>(object); 
    62  
    63                         ViewCell *viewCell = Generate(inst->GetMesh()); 
    64                         viewCells.push_back(viewCell); 
    65                 } 
    66                 //TODO: transformed meshes 
    67         } 
    68 } 
    69  
    70 ViewCell *ViewCell::ExtrudeViewCell(const Triangle3 &baseTri, const float height) 
    71 { 
    72         // one mesh per view cell 
    73         Mesh *mesh = new Mesh(); 
    74          
    75         //-- construct prism 
    76  
    77         // bottom  
    78         mesh->mFaces.push_back(new Face(2,1,0)); 
    79         // top 
    80     mesh->mFaces.push_back(new Face(3,4,5)); 
    81         // sides 
    82         mesh->mFaces.push_back(new Face(1, 4, 3, 0)); 
    83         mesh->mFaces.push_back(new Face(2, 5, 4, 1)); 
    84         mesh->mFaces.push_back(new Face(3, 5, 2, 0)); 
    85  
    86         //--- extrude new vertices for top of prism 
    87         Vector3 triNorm = baseTri.GetNormal(); 
    88  
    89         Triangle3 topTri;        
    90  
    91         // add base vertices and calculate top vertices 
    92         for (int i = 0; i < 3; ++ i) 
    93                 mesh->mVertices.push_back(baseTri.mVertices[i]); 
    94          
    95         // add top vertices      
    96         for (int i = 0; i < 3; ++ i) 
    97                 mesh->mVertices.push_back(baseTri.mVertices[i] + height * triNorm); 
    98          
    99         mesh->Preprocess(); 
    100  
    101         return Generate(mesh); 
    102 } 
    103  
    104 ViewCell *ViewCell::Merge(ViewCell &front, ViewCell &back) 
    105 { 
    106         ViewCell *vc = Generate(); 
    107         // merge pvs 
    108         vc->mPvs.Merge(front.mPvs, back.mPvs); 
    109  
    110         // merge ray sets 
    111         stable_sort(front.mPiercingRays.begin(), front.mPiercingRays.end()); 
    112         stable_sort(back.mPiercingRays.begin(), back.mPiercingRays.end()); 
    113  
    114         std::merge(front.mPiercingRays.begin(), front.mPiercingRays.end(), 
    115                            back.mPiercingRays.begin(), back.mPiercingRays.end(),  
    116                            vc->mPiercingRays.begin()); 
    117  
    118         return vc; 
    119 } 
    120  
    12130void ViewCell::AddPassingRay(const Ray &ray, const int contributions) 
    12231{ 

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

    r419 r439  
    2929 
    3030        int Type() const; 
    31  
    32         /** Derives viewcells from object container. 
    33                 @param objects the intersectables the viewcells are derived from 
    34                 @param viewCells the viewcells are returned in this container 
    35                 @param maxViewCells the maximum number of viewcells created. if 0 => unbounded 
    36         */ 
    37         static void DeriveViewCells(const ObjectContainer &objects,  
    38                                                                 ViewCellContainer &viewCells,  
    39                                                                 const int maxViewCells); 
    40  
    4131         
    4232        /** Adds a passing ray to the passing ray container. 
    … …  
    4434        void AddPassingRay(const Ray &ray, const int contributions);     
    4535 
    46         /** Constructs view cell from base triangle. The ViewCell is extruded along the normal vector. 
    47                 @param the base triangle 
    48                 @param the height of the newly created view cell 
    49         */ 
    50         static ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height); 
    51  
    52         /** Merges two view cells. 
    53                 @note the piercing rays of the front and back will be ordered    
    54                 @returns new view cell based on the merging. 
    55         */ 
    56         static ViewCell *Merge(ViewCell &front, ViewCell &back); 
    5736 
    5837        /// Ray set description of the rays passing through this node.   
    … …  
    6140        /// Rays piercing this view cell. 
    6241        RayContainer mPiercingRays; 
    63  
    64         /// view cells types 
    65         enum HierarchyType {BSP, KD, VSP}; 
    66  
    67         /** Generates view cells of type specified by view cells type. 
    68         */ 
    69         static ViewCell *Generate(Mesh *mesh = NULL); 
    70  
    71         /// type of view cells hierarchy (KD, BSP) 
    72         static HierarchyType sHierarchy; 
    7342 
    7443protected: 

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

    r437 r439  
    353353} 
    354354 
    355 void BspTree::ParseEnvironment() 
    356 { 
    357         //-- parse bsp cell tree construction method 
    358         char constructionMethodStr[60]; 
    359          
    360         environment->GetStringValue("BspTree.Construction.input", constructionMethodStr); 
    361  
    362         sConstructionMethod = FROM_INPUT_VIEW_CELLS; 
    363          
    364         if (strcmp(constructionMethodStr, "fromViewCells") == 0) 
    365                 sConstructionMethod = FROM_INPUT_VIEW_CELLS; 
    366         else if (strcmp(constructionMethodStr, "fromSceneGeometry") == 0) 
    367                 sConstructionMethod = FROM_SCENE_GEOMETRY; 
    368         else if (strcmp(constructionMethodStr, "fromSamples") == 0) 
    369                 sConstructionMethod = FROM_SAMPLES; 
    370         else  
    371         { 
    372                 cerr << "Wrong construction method " << constructionMethodStr << endl; 
    373                 exit(1); 
    374     } 
    375  
    376         Debug << "Construction method: " << constructionMethodStr << endl; 
    377 } 
    378  
    379355const BspTreeStatistics &BspTree::GetStatistics() const  
    380356{ 
    … …  
    809785                if (mGenerateViewCells) 
    810786                { 
    811                         viewCell = dynamic_cast<BspViewCell *>(ViewCell::Generate()); 
     787                        viewCell = new BspViewCell(); 
    812788                } 
    813789                else 
    … …  
    19801956{ 
    19811957        BspViewCell *viewCell =  
    1982                 dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell)); 
     1958NULL;//todo             dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell)); 
    19831959         
    19841960        if (!viewCell) 

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

    r437 r439  
    527527                VspBspLeaf *leaf = dynamic_cast<VspBspLeaf *>(tData.mNode); 
    528528         
    529                 BspViewCell *viewCell = 
    530                         dynamic_cast<BspViewCell *>(ViewCell::Generate()); 
     529                BspViewCell *viewCell = new BspViewCell(); 
    531530                 
    532531                leaf->SetViewCell(viewCell); 
    … …  
    14371436{ 
    14381437        BspViewCell *viewCell =  
    1439                 dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell)); 
     1438        NULL;//TODO     dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell)); 
    14401439         
    14411440        if (!viewCell) 

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

    r438 r439  
    99#include "VssRay.h" 
    1010#include "VssTree.h" 
    11  
     11#include "ViewCellsManager.h" 
    1212 
    1313bool useViewSpaceBox = true;//true; 
    … …  
    451451  } 
    452452         
    453   //-- construct BSP view cells 
    454   if (ViewCell::sHierarchy == ViewCell::BSP)  
    455   { 
    456           const int bspSamples = min((int)mVssRays.size(), mBspConstructionSamples); 
    457                  
    458           Debug << "bpssamples: " << bspSamples << endl; 
    459           for (int i = 0; i < bspSamples; ++ i) 
    460                   bspRays.push_back(new Ray(*mVssRays[i])); 
    461           
    462           //-- construct BSP tree using the samples 
    463           mBspTree = new BspTree(&mUnbounded);   
    464  
    465           ObjectContainer objects; 
    466           mSceneGraph->CollectObjects(&objects); 
    467           mBspTree->Construct(objects, bspRays); 
    468         } 
     453  ObjectContainer objects; 
     454  mSceneGraph->CollectObjects(&objects); 
     455 
     456  //mViewCellsManager->Construct(mVssRays, objects); 
    469457 
    470458  vssTree = new VssTree; 
    … …  
    541529 
    542530        // cast rays into BSP tree 
    543         if (ViewCell::sHierarchy == ViewCell::BSP)  
     531        /*if (ViewCell::sHierarchy == ViewCell::BSP)  
    544532          { 
    545533                for (int i = 0; i < (int)vssRays.size(); ++ i) 
    … …  
    548536                  } 
    549537          } 
    550  
     538*/ 
    551539        samples+=num; 
    552540        float pvs = vssTree->GetAvgPvsSize(); 
    … …  
    562550  delete vssTree; 
    563551 
    564   if (ViewCell::sHierarchy == ViewCell::BSP)  
    565         { 
    566           Debug << mBspTree->GetStatistics(); 
    567  
    568           ObjectContainer objects; 
    569           ExportSplits(objects, bspRays, 10000); 
    570           ExportBspPvs(objects, bspRays, 10000); 
    571  
    572           BspViewCellsStatistics stat; 
    573           mBspTree->EvaluateViewCellsStats(stat); 
    574           Debug << "original view cell partition:\n" << stat << endl; 
    575  
    576           // clear BSP samples 
    577           CLEAR_CONTAINER(bspRays); 
    578         } 
    579  
    580552  return true; 
    581553} 
    582  
    583 void VssPreprocessor::CastRay(const BspTree &tree, const VssRay & vssRay) 
    584 { 
    585   //-- cast ray to BSP tree to get intersection with view cells 
    586   Ray ray(vssRay); 
    587   mBspTree->CastRay(ray); 
    588                                  
    589   //if (0 && ray.sourceObject.mObject) 
    590   //sampleContributions +=  
    591   //AddObjectSamples(ray.sourceObject.mObject, ray); 
    592                          
    593   if (!ray.intersections.empty()) // second intersection found 
    594   { 
    595           //sampleContributions +=  
    596           AddObjectSamples(ray.intersections[0].mObject, ray); 
    597   } 
    598 } 
    599  
    600 int VssPreprocessor::AddObjectSamples(Intersectable *obj, const Ray &ray) 
    601 { 
    602   int contributingSamples = 0; 
    603   int j; 
    604   
    605   // object can be seen from the view cell => add to view cell pvs 
    606   for (j=0; j < ray.bspIntersections.size(); ++ j) 
    607         {        
    608           BspLeaf *leaf = ray.bspIntersections[j].mLeaf; 
    609           // if ray not in unbounded space 
    610           if (leaf->GetViewCell() != &mUnbounded) 
    611                 contributingSamples +=  
    612                   leaf->GetViewCell()->GetPvs().AddSample(obj); 
    613         } 
    614   
    615   // rays passing through this viewcell 
    616   if (mPass > 1) 
    617         for (j=1; j < ((int)ray.bspIntersections.size() - 1); ++ j)  
    618           { 
    619                 BspLeaf *leaf = ray.bspIntersections[j].mLeaf; 
    620                  
    621                 if (leaf->GetViewCell() != &mUnbounded) 
    622                   leaf->GetViewCell()-> 
    623                         AddPassingRay(ray, contributingSamples ? 1 : 0); 
    624           } 
    625    
    626   return contributingSamples; 
    627 } 

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

    r438 r439  
    5858 
    5959                  ); 
    60                  
    61  
    62          
    63   virtual bool BuildBspTree() { return false; } 
    6460 
    6561 

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

    r376 r439  
    2828#include "SceneGraph.h" 
    2929#include "Triangle3.h" 
    30 #include "ViewCell.h" 
     30#include "ViewCellsManager.h" 
    3131 
    3232// --------------------------------------------------------------------------- 
    … …  
    103103void 
    104104X3dParseHandlers::StartIndexedFaceSet( 
    105                                                                                                                                                         AttributeList&  attributes) 
     105                                                                          AttributeList&  attributes) 
    106106{ 
    107107  int len = attributes.getLength(); 
    … …  
    195195void 
    196196X3dParseHandlers::startElement(const XMLCh* const name, 
    197                                                                                                                         AttributeList&  attributes) 
     197                                                          AttributeList&  attributes) 
    198198{ 
    199199  StrX lname(name); 
    … …  
    385385//  StdInParseHandlers: Constructors and Destructor 
    386386// --------------------------------------------------------------------------- 
    387 X3dViewCellsParseHandlers::X3dViewCellsParseHandlers(ViewCellContainer *viewCells,  
     387X3dViewCellsParseHandlers::X3dViewCellsParseHandlers(ViewCellsManager *viewCellsManager,  
    388388                                                                                                         float viewCellHeight) : 
    389389  mElementCount(0) 
    … …  
    391391  , mCharacterCount(0) 
    392392  , mSpaceCount(0) 
    393   , mViewCells(viewCells) 
     393  , mViewCellsManager(viewCellsManager) 
    394394  , mViewCellHeight(viewCellHeight) 
    395395{ 
    … …  
    457457 
    458458void 
    459 X3dViewCellsParseHandlers::StartCoordinate( 
    460                                                                                                                                                                          AttributeList&  attributes) 
     459X3dViewCellsParseHandlers::StartCoordinate(AttributeList&  attributes) 
    461460{ 
    462461        int len = attributes.getLength(); 
    … …  
    507506 
    508507        for (i = 0; i < mCurrentVertexIndices.size(); i += 3) 
    509                 { 
     508        { 
    510509                Triangle3 baseTri(vertices[mCurrentVertexIndices[i + 0]],  
    511510                                                  vertices[mCurrentVertexIndices[i + 1]], 
    … …  
    513512 
    514513                // create view cell from base triangle 
    515                 mViewCells->push_back(ViewCell::ExtrudeViewCell(baseTri, mViewCellHeight)); 
    516  
    517                 Mesh *mesh = mViewCells->back()->GetMesh(); 
    518 #ifdef _DEBUG 
    519                 Debug << "Viewcell: "  
    520                                         << mesh->mVertices[0] << " " << mesh->mVertices[1] << " " << mesh->mVertices[2] << " "  
    521                                         << mesh->mVertices[3] << " " << mesh->mVertices[4] << " " << mesh->mVertices[5] << "\n"; 
    522 #endif 
    523                 } 
     514                mViewCellsManager->AddViewCell(mViewCellsManager->ExtrudeViewCell(baseTri, mViewCellHeight)); 
     515        } 
    524516} 
    525517 
    … …  
    527519void 
    528520X3dViewCellsParseHandlers::startElement(const XMLCh* const name, 
    529                                                                                                                                                                 AttributeList&  attributes) 
     521                                                                                AttributeList&  attributes) 
    530522{ 
    531523  StrX lname(name); 
    … …  
    608600 
    609601bool 
    610 X3dParser::ParseFile(const string filename, ViewCellContainer &viewCells) 
     602X3dParser::ParseFile(const string filename, ViewCellsManager &viewCells) 
    611603{ 
    612604  // Initialize the XML4C system 

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

    r312 r439  
    55#include "Containers.h" 
    66 
    7 class ViewCell; 
     7class ViewCellsManager; 
    88 
    99class X3dParser : public Parser 
    … …  
    1313   
    1414  bool ParseFile(const string filename, SceneGraphNode **root); 
    15   bool ParseFile(const string filename, ViewCellContainer &viewCells); 
     15  bool ParseFile(const string filename, ViewCellsManager &viewCells); 
    1616 
    1717  float mViewCellHeight; 

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

    r313 r439  
    1616class Mesh; 
    1717class Material; 
     18class ViewCellsManager; 
    1819 
    1920class X3dParseHandlers : public HandlerBase 
    … …  
    114115  //  Constructors and Destructor 
    115116  // ----------------------------------------------------------------------- 
    116   X3dViewCellsParseHandlers(ViewCellContainer *mViewCells,  
     117  X3dViewCellsParseHandlers(ViewCellsManager *viewCellsManager,  
    117118                                                        float viewCellHeight); 
    118119  ~X3dViewCellsParseHandlers(); 
    … …  
    152153  void resetDocument(); 
    153154 
    154   ViewCellContainer *mViewCells; 
     155  ViewCellsManager *mViewCellsManager; 
    155156  float mViewCellHeight; 
    156157 

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

    r422 r439  
    5454  p->KdTreeStatistics(cout); 
    5555   
    56   // parse view cell hierarchy options 
    57   p->ParseViewCellsOptions(); 
     56  // parse view cells related options 
     57  p->PrepareViewCells(); 
    5858 
    59   if (ViewCell::sHierarchy == ViewCell::BSP) 
    60   { 
    61           BspTree::ParseEnvironment(); 
    62  
    63           // We construct BSP tree immediately for "from view cells" or "from scene geometry" 
    64           // construction method.  
    65           // For the "from samples" option, construction is delayed until enough samples were collected 
    66           if (BspTree::sConstructionMethod != BspTree::FROM_SAMPLES) 
    67           {              
    68                   if (BspTree::sConstructionMethod == BspTree::FROM_INPUT_VIEW_CELLS) 
    69                   { 
    70                           //-- load view cells from file 
    71                           environment->GetStringValue("ViewCells.filename", buff); 
    72                           string vcFilename(buff); 
    73                           p->LoadViewCells(vcFilename); 
    74                           Debug << (int)p->mViewCells.size() << " view cells loaded" << endl; 
    75                   } 
    76                    
    77                   p->BuildBspTree(); 
    78          
    79                   p->Export("vc_bsptree.x3d", false, false, true); 
    80                   p->BspTreeStatistics(Debug); 
    81           } 
    82   } 
    8359 
    8460  //  p->mSceneGraph->Export("soda.x3d"); 
Note: See TracChangeset for help on using the changeset viewer.