Changeset 1594


Ignore:
Timestamp:
10/10/06 00:59:59 (18 years ago)
Author:
bittner
Message:

support for kd tree based pvs

Location:
GTP/trunk/Lib/Vis/Preprocessing/src
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp

    r1589 r1594  
    1313#include "IntersectableWrapper.h" 
    1414#include "BvHierarchy.h" 
     15#include "KdTree.h" 
    1516 
    1617//#include <Cg/cg.h> 
    … …  
    7879  mSnapPrefix = "snap/"; 
    7980  mUseForcedColors = false; 
    80  
     81  mRenderBoxes = false; 
    8182  mUseGlLists = true; 
    8283  //mUseGlLists = false; 
    … …  
    108109GlRenderer::RenderIntersectable(Intersectable *object) 
    109110{ 
    110  
     111  if (object->Mailed()) 
     112        return; 
     113  object->Mail(); 
     114   
    111115  glPushAttrib(GL_CURRENT_BIT); 
    112116  if (mUseFalseColors) 
    … …  
    129133  case Intersectable::BVH_INTERSECTABLE: { 
    130134 
     135         
    131136        BvhNode *node = (dynamic_cast<BvhIntersectable *>(object))->GetItem(); 
    132         //      RenderBvhNode(node); 
    133         RenderBox(node->GetBoundingBox()); 
     137 
     138        if (mRenderBoxes) 
     139          RenderBox(node->GetBoundingBox()); 
     140        else 
     141          RenderBvhNode(node); 
     142        break; 
     143  } 
     144  case Intersectable::KD_INTERSECTABLE: { 
     145        KdNode *node = (dynamic_cast<KdIntersectable *>(object))->GetItem(); 
     146 
     147        if (mRenderBoxes) 
     148          RenderBox(mKdTree->GetBox(node)); 
     149        else 
     150          RenderKdNode(node); 
    134151        break; 
    135152  } 
    … …  
    628645        BvhLeaf *leaf = (BvhLeaf *) node; 
    629646        for (int i=0; i < leaf->mObjects.size(); i++) 
    630                 cout << "leaf obj " << i << endl; 
    631           //RenderIntersectable(mObjects[i]); 
     647          RenderIntersectable(leaf->mObjects[i]); 
    632648  } else { 
    633649        BvhInterior *in = (BvhInterior *)node; 
    … …  
    635651        RenderBvhNode(in->GetFront()); 
    636652  } 
    637    
    638 } 
    639  
    640 } 
     653 
     654  //cout << "leaf obj " << i << endl; 
     655 
     656} 
     657 
     658void 
     659GlRenderer::RenderKdNode(KdNode *node) 
     660{ 
     661  if (node->IsLeaf()) { 
     662        KdLeaf *leaf = (KdLeaf *) node; 
     663        for (int i=0; i < leaf->mObjects.size(); i++) { 
     664          RenderIntersectable(leaf->mObjects[i]); 
     665        } 
     666  } else { 
     667        KdInterior *in = (KdInterior *)node; 
     668        RenderKdNode(in->mBack); 
     669        RenderKdNode(in->mFront); 
     670  } 
     671   
     672} 
     673 
     674} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.h

    r1585 r1594  
    113113  void 
    114114  RenderBvhNode(BvhNode *node); 
    115          
     115 
     116  void 
     117  RenderKdNode(KdNode *node); 
     118 
    116119  bool 
    117120  RenderScene(); 
    … …  
    161164  bool mDetectEmptyViewSpace; 
    162165  bool mSnapErrorFrames; 
     166 
     167  bool mRenderBoxes; 
    163168 
    164169  bool mUseGlLists; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/IntersectableWrapper.h

    r1587 r1594  
    157157 
    158158 
     159typedef map<KdNode *, KdIntersectable *> KdIntersectableMap; 
     160 
    159161class BvhIntersectable: public IntersectableWrapper<BvhNode *> 
    160162{ 

  • GTP/trunk/Lib/Vis/Preprocessing/src/KdTree.cpp

    r1584 r1594  
    13921392} 
    13931393 
    1394  
    1395 } 
     1394KdIntersectable * 
     1395KdTree::GetOrCreateKdIntersectable(KdNode *node) 
     1396{ 
     1397 
     1398  if (node == NULL) 
     1399        return NULL; 
     1400   
     1401  // search nodes 
     1402  std::map<KdNode *, KdIntersectable *>:: 
     1403        const_iterator it = mKdIntersectables.find(node); 
     1404   
     1405  if (it != mKdIntersectables.end())  
     1406        { 
     1407          return (*it).second; 
     1408        } 
     1409   
     1410  // not in map => create new entry 
     1411  KdIntersectable *kdObj = new KdIntersectable(node); 
     1412  mKdIntersectables[node] = kdObj; 
     1413   
     1414  return kdObj; 
     1415} 
     1416 
     1417KdNode * 
     1418KdTree::GetNode(const Vector3 &point, 
     1419                                const float maxArea) const 
     1420{ 
     1421  KdNode *node = mRoot; 
     1422   
     1423  while (!node->IsLeaf() && (GetSurfaceArea(node) > maxArea) ) { 
     1424        KdInterior *inter = (KdInterior *)node; 
     1425        if (point[inter->mAxis] < inter->mPosition) 
     1426          node = inter->mBack; 
     1427        else 
     1428          node = inter->mFront; 
     1429  } 
     1430   
     1431  return node; 
     1432} 
     1433 
     1434 
     1435} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/KdTree.h

    r1286 r1594  
    1111#include "Viewcell.h" 
    1212#include "VssRay.h" 
     13#include "IntersectableWrapper.h" 
    1314 
    1415 
    … …  
    336337  } 
    337338 
     339  /** Returns or creates a new intersectable for use in a kd based pvs. 
     340          The OspTree is responsible for destruction of the intersectable. 
     341  */ 
     342  KdIntersectable *GetOrCreateKdIntersectable(KdNode *node); 
     343 
    338344  void 
    339345  CollectObjects(KdNode *n, ObjectContainer &objects); 
    … …  
    368374    return box; 
    369375  } 
    370          
     376 
     377  float GetSurfaceArea(const KdNode *node) const { 
     378        return GetBox(node).SurfaceArea(); 
     379  } 
     380 
     381   
    371382  KdNode * 
    372383  FindRandomNeighbor(KdNode *n, 
    … …  
    379390  KdNode * 
    380391  GetRandomLeaf(const bool onlyUnmailed = false); 
    381    
     392 
     393 
     394  KdNode * 
     395  GetNode(const Vector3 &point, const float maxArea) const; 
     396 
    382397  int 
    383398  FindNeighbors(KdNode *n, 
    … …  
    574589  AxisAlignedBox3 mBox; 
    575590  KdTreeStatistics mStat; 
    576    
     591 
     592  /// stores the kd node intersectables used for pvs 
     593  KdIntersectableMap mKdIntersectables; 
     594 
    577595}; 
    578596 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Makefile

    r1585 r1594  
    11############################################################################# 
    22# Makefile for building: preprocessor 
    3 # Generated by qmake (2.00a) (Qt 4.1.2) on: ne 8. X 23:47:35 2006 
     3# Generated by qmake (2.00a) (Qt 4.1.2) on: po 9. X 21:25:05 2006 
    44# Project:  preprocessor.pro 
    55# Template: app 

  • GTP/trunk/Lib/Vis/Preprocessing/src/OspTree.h

    r1449 r1594  
    1111#include "gzstream.h" 
    1212#include "SubdivisionCandidate.h" 
     13#include "IntersectableWrapper.h" 
    1314 
    1415 
    … …  
    135136 
    136137 
    137 typedef map<KdNode *, KdIntersectable *> KdIntersectableMap; 
    138138 
    139139 
    … …  
    826826 
    827827    /// stores the kd node intersectables used for pvs 
    828         KdIntersectableMap mKdIntersectables; 
     828  KdIntersectableMap mKdIntersectables; 
    829829         
    830830private: 

  • GTP/trunk/Lib/Vis/Preprocessing/src/QtGlRenderer.cpp

    r1585 r1594  
    870870 
    871871int QtGlRendererBuffer::ComputePvs(ObjectContainer &objects,  
    872                                                                  ObjectContainer &pvs) const 
     872                                                                   ObjectContainer &pvs) const 
    873873{ 
    874874        int pvsSize = 0; 
    … …  
    950950{ 
    951951   
    952    
     952  Intersectable::NewMail(); 
     953 
    953954  ViewCell *viewcell = NULL; 
    954955 
    … …  
    975976         
    976977         
    977         // read back the texture 
    978978        ObjectPvsMap::const_iterator it = pvs.mEntries.begin(); 
    979  
     979         
    980980        mPvsSize = pvs.mEntries.size(); 
    981981           
    982982        for (; it != pvs.mEntries.end(); ++ it) { 
    983983          Intersectable *object = (*it).first; 
    984           float visibility = log10((*it).second.mSumPdf + 1)/5.0f; 
    985           glColor3f(visibility, 0.0f, 0.0f); 
    986           mUseForcedColors = true; 
    987           RenderIntersectable(object); 
    988           mUseForcedColors = false; 
     984           
     985          if (mRenderVisibilityEstimates) { 
     986                float visibility = log10((*it).second.mSumPdf + 1)/5.0f; 
     987                glColor3f(visibility, 0.0f, 0.0f); 
     988                mUseForcedColors = true; 
     989                RenderIntersectable(object); 
     990                mUseForcedColors = false; 
     991          } else { 
     992                mUseForcedColors = false; 
     993                RenderIntersectable(object); 
     994          } 
    989995        } 
    990996 
    … …  
    13601366  mCutScene = false; 
    13611367  mRenderErrors = false; 
     1368  mRenderBoxes = false; 
    13621369  mRenderFilter = true; 
     1370  mRenderVisibilityEstimates = false; 
     1371 
    13631372  mManipulatorScale = 1.0f; 
    13641373  trackball(mManipulatorLastQuat, 0.0f, 0.0f, 0.0f, 0.0f); 
    … …  
    13701379  Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter", 
    13711380                                                        tmp ); 
    1372  
    13731381  mUseSpatialFilter = tmp; 
    13741382 
    … …  
    13961404  connect(mControlWidget, SIGNAL(SetCutScene(bool)), this, SLOT(SetCutScene(bool))); 
    13971405  connect(mControlWidget, SIGNAL(SetRenderErrors(bool)), this, SLOT(SetRenderErrors(bool))); 
     1406  connect(mControlWidget, SIGNAL(SetRenderBoxes(bool)), this, SLOT(SetRenderBoxes(bool))); 
    13981407  connect(mControlWidget, SIGNAL(SetRenderFilter(bool)), this, SLOT(SetRenderFilter(bool))); 
     1408  connect(mControlWidget, SIGNAL(SetRenderVisibilityEstimates(bool)), 
     1409                  this, SLOT(SetRenderVisibilityEstimates(bool))); 
    13991410  connect(mControlWidget, SIGNAL(SetUseFilter(bool)), this, SLOT(SetUseFilter(bool))); 
    14001411  connect(mControlWidget, SIGNAL(SetUseSpatialFilter(bool)), 
    … …  
    18251836  connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetSceneCut(int))); 
    18261837 
     1838 
     1839  cb = new QCheckBox("Render boxes", vbox); 
     1840  vbox->layout()->addWidget(cb); 
     1841  cb->setChecked(false); 
     1842  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderBoxes(bool))); 
     1843 
     1844  cb = new QCheckBox("Render visibility estimates", vbox); 
     1845  vbox->layout()->addWidget(cb); 
     1846  cb->setChecked(false); 
     1847  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderVisibilityEstimates(bool))); 
     1848 
     1849   
    18271850  cb = new QCheckBox("Render errors", vbox); 
    18281851  vbox->layout()->addWidget(cb); 
    … …  
    18301853  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderErrors(bool))); 
    18311854 
     1855   
     1856  bool tmp; 
     1857 
    18321858  cb = new QCheckBox("Use filter", vbox); 
    18331859  vbox->layout()->addWidget(cb); 
    1834   cb->setChecked(true); 
     1860  Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", tmp ); 
     1861  cb->setChecked(tmp); 
    18351862  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetUseFilter(bool))); 
    18361863 
     1864   
    18371865  cb = new QCheckBox("Use spatial filter", vbox); 
    18381866  vbox->layout()->addWidget(cb); 
    1839   cb->setChecked(true); 
     1867  Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter", 
     1868                                                                                        tmp ); 
     1869  cb->setChecked(tmp); 
    18401870  connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetUseSpatialFilter(bool))); 
    18411871 

  • GTP/trunk/Lib/Vis/Preprocessing/src/QtGlRenderer.h

    r1584 r1594  
    152152  void SetShowRays(bool); 
    153153  void SetRenderFilter(bool); 
     154  void SetRenderVisibilityEstimates(bool); 
    154155  void SetUseFilter(bool); 
    155156  void SetUseSpatialFilter(bool); 
    156157  void SetRenderErrors(bool); 
     158  void SetRenderBoxes(bool); 
    157159  void SetShowViewCells(bool); 
    158160  void SetShowRenderCost(bool); 
    … …  
    179181  bool mRenderErrors; 
    180182  bool mRenderFilter; 
     183  bool mRenderVisibilityEstimates; 
    181184  bool mUseFilter; 
    182185  bool mUseSpatialFilter; 
    … …  
    266269 } 
    267270 
     271  void SetRenderBoxes(bool b) { 
     272        mRenderBoxes = b; 
     273        updateGL(); 
     274  } 
     275 
    268276 void SetRenderFilter(bool b) { 
    269277   mRenderFilter = b; 
     278   updateGL(); 
     279 } 
     280 
     281  void SetRenderVisibilityEstimates(bool b) { 
     282        mRenderVisibilityEstimates = b; 
    270283   updateGL(); 
    271284 } 

  • GTP/trunk/Lib/Vis/Preprocessing/src/Ray.h

    r1584 r1594  
    4646          Intersectable *mObject; 
    4747 
    48           /// the face of the intersectable 
     48        /// the face of the intersectable 
    4949          int mFace; 
    5050 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r1589 r1594  
    2929#define SAMPLE_ORIGIN_OBJECTS 0 
    3030 
     31// $$JB HACK 
     32#define USE_KD_PVS 1 
     33#define KD_PVS_AREA 1e-3f 
    3134 
    3235namespace GtpVisibilityPreprocessor { 
    … …  
    11831186                                                           const float filterWidth) 
    11841187{ 
    1185         ViewCell *currentViewCell = GetViewCell(viewPoint); 
    1186  
    1187         if (mMaxFilterSize < 1) { 
    1188                 prvs.mViewCell = currentViewCell; 
    1189                 return; 
    1190         } 
    1191  
    1192         const AxisAlignedBox3 box = GetFilterBBox(viewPoint, filterWidth); 
    1193  
    1194         if (currentViewCell)  
    1195         { 
    1196                 ViewCellContainer viewCells; 
    1197                 ComputeBoxIntersections(box, viewCells); 
    1198  
    1199                 ViewCell *root = ConstructLocalMergeTree2(currentViewCell, viewCells); 
    1200                 prvs.mViewCell = root; 
    1201  
     1188  ViewCell *currentViewCell = GetViewCell(viewPoint); 
     1189 
     1190  if (mMaxFilterSize < 1) { 
     1191        prvs.mViewCell = currentViewCell; 
     1192        return; 
     1193  } 
     1194   
     1195  const AxisAlignedBox3 box = GetFilterBBox(viewPoint, filterWidth); 
     1196   
     1197  if (currentViewCell)  
     1198        { 
     1199          ViewCellContainer viewCells; 
     1200          ComputeBoxIntersections(box, viewCells); 
     1201           
     1202          ViewCell *root = ConstructLocalMergeTree2(currentViewCell, viewCells); 
     1203          prvs.mViewCell = root; 
     1204           
    12021205        }  
    1203         else 
    1204         { 
    1205                 prvs.mViewCell = NULL; 
    1206                 //prvs.mPvs = root->GetPvs(); 
     1206  else 
     1207        { 
     1208          prvs.mViewCell = NULL; 
     1209          //prvs.mPvs = root->GetPvs(); 
    12071210        } 
    12081211} 
    … …  
    18081811  ViewCellContainer *viewcells = &ray.mViewCells; 
    18091812  ViewCellContainer::const_iterator it; 
     1813 
     1814  if (!ray.mTerminationObject) 
     1815        return; 
     1816   
     1817#if USE_KD_PVS 
     1818  float area = GetPreprocessor()->mKdTree->GetBox().SurfaceArea()*KD_PVS_AREA; 
     1819  KdNode *node = GetPreprocessor()->mKdTree->GetNode(ray.mTermination, area); 
     1820  Intersectable *obj = 
     1821        GetPreprocessor()->mKdTree-> 
     1822        GetOrCreateKdIntersectable(node); 
     1823#else 
     1824  Intersectable *obj = ray.mTerminationObject; 
     1825#endif 
     1826   
    18101827  for (it = viewcells->begin(); it != viewcells->end(); ++it) { 
    18111828        ViewCell *viewcell = *it; 
    18121829        if (viewcell->GetValid()) { 
    18131830          // if ray not outside of view space 
    1814           viewcell->GetPvs().AddSample(ray.mTerminationObject, ray.mPdf); 
     1831          viewcell->GetPvs().AddSample(obj, ray.mPdf); 
    18151832        } 
    18161833  } 
    … …  
    18511868        } 
    18521869 
     1870#if USE_KD_PVS 
     1871        float area = GetPreprocessor()->mKdTree->GetBox().SurfaceArea()*KD_PVS_AREA; 
     1872        KdNode *node = GetPreprocessor()->mKdTree->GetNode(ray.mTermination, area); 
     1873        Intersectable *obj = 
     1874          GetPreprocessor()->mKdTree-> 
     1875          GetOrCreateKdIntersectable(node); 
     1876#else 
     1877        Intersectable *obj = ray.mTerminationObject; 
     1878#endif 
     1879         
     1880         
    18531881        ViewCellContainer::const_iterator it = viewcells.begin(); 
    1854  
     1882         
    18551883        for (; it != viewcells.end(); ++ it)  
    18561884        { 
    … …  
    18621890 
    18631891                        if (ray.mTerminationObject)  
    1864                         {                        
    1865                                 if (viewcell->GetPvs().GetSampleContribution( 
    1866                                                         ray.mTerminationObject, 
    1867                                                         ray.mPdf, 
    1868                                                         contribution)) 
     1892                          {                      
     1893                                 
     1894 
     1895                          if (viewcell->GetPvs().GetSampleContribution(obj, 
     1896                                                                                                                   ray.mPdf, 
     1897                                                                                                                   contribution)) 
    18691898                                { 
    1870                                         ++ ray.mPvsContribution; 
    1871                                         ray.mRelativePvsContribution += contribution; 
     1899                                  ++ ray.mPvsContribution; 
     1900                                  ray.mRelativePvsContribution += contribution; 
    18721901                                } 
    18731902                        } 
    … …  
    19031932                                if (ray.mTerminationObject) 
    19041933                                { 
    1905                                         viewcell->GetPvs().AddSample(ray.mTerminationObject, ray.mPdf); 
     1934                                        viewcell->GetPvs().AddSample(obj, ray.mPdf); 
    19061935                                }                                
    19071936#if SAMPLE_ORIGIN_OBJECTS 
    … …  
    23302359  // now compute a new Pvs by including also objects intersecting the  
    23312360  // extended boxes of visible objects 
    2332  
    23332361  Intersectable::NewMail(); 
    23342362   
    … …  
    55105538                        if (ray.mTerminationObject)  
    55115539                        { 
    5512                                 // todo: maybe not correct for kd node pvs 
    5513                                 Intersectable *obj = mHierarchyManager->GetIntersectable(ray, true); 
    5514                                 if (viewcell->GetPvs().GetSampleContribution(obj, 
    5515                                                                                                                          ray.mPdf,  
    5516                                                                                                                          contribution)) 
     5540                          // todo: maybe not correct for kd node pvs 
     5541                          Intersectable *obj = mHierarchyManager->GetIntersectable(ray, true); 
     5542                           
     5543                          if (viewcell->GetPvs().GetSampleContribution(obj, 
     5544                                                                                                                   ray.mPdf,  
     5545                                                                                                                   contribution)) 
    55175546                                { 
    5518                                         ++ ray.mPvsContribution; 
     5547                                  ++ ray.mPvsContribution; 
    55195548                                } 
    5520  
    5521                                 ray.mRelativePvsContribution += contribution; 
     5549                           
     5550                          ray.mRelativePvsContribution += contribution; 
    55225551                        } 
    5523  
     5552                         
    55245553                        // for directional sampling it is important to count only contributions 
    55255554                        // made in one direction! 

  • GTP/trunk/Lib/Vis/Preprocessing/src/default.env

    r1585 r1594  
    1111# filename ../data/glasgow/glasgow1.x3d 
    1212#       filename vienna.x3d 
    13 filename ../data/vienna/vienna-simple.x3d 
     13# filename ../data/vienna/vienna-simple.x3d 
    1414# filename ../data/vienna/vienna-buildings.x3d 
    1515# filename ../data/vienna/city1500_flat_1.x3d 
    … …  
    143143        sahUseFaces false 
    144144        Termination { 
    145                 minCost 0.95 
     145                minCost 4 
    146146                maxDepth 30 
    147                 maxCostRatio 0.98 
     147                maxCostRatio 0.99 
    148148                ct_div_ci 0.5 
    149                 maxNodes 100000 
     149                maxNodes 300000 
    150150#500000  
    151151        } 
    … …  
    170170} 
    171171 
    172  
    173  
    174  
    175  
    176  
    177172ViewCells { 
    178173        # samples used for view cell construction 
    … …  
    189184 
    190185        exportToFile true 
    191         loadFromFile false 
     186        loadFromFile true 
    192187 
    193188        #type kdTree 
    194189        #type vspKdTree 
    195190        #type bspTree 
    196 #       type vspBspTree 
    197         type vspOspTree 
     191        type vspBspTree 
     192        #type vspOspTree 
    198193        #type sceneDependent 
    199194         
    … …  
    243238        Evaluation { 
    244239                samplesPerPass 1000000 
    245                 samples 1000000 
     240                samples 5000000 
    246241                statsPrefix ../scripts/viewCells 
    247242                #samplingType directional 
    … …  
    269264 
    270265 
    271         filename ../data/vienna/vsposp-seq-viewCells.xml.gz 
     266#       filename ../data/vienna/vsposp-seq-viewCells.xml.gz 
    272267 
    273268#       filename ../data/atlanta/viewcells_atlanta3.xml 
    … …  
    277272#       filename ../data/vienna/vienna_simple-21-04-avs2-viewCells.xml 
    278273#       filename ../data/vienna/vienna-viewcells-5000.xml 
    279 #       filename ../data/vienna/vienna-viewcells-1000.xml.zip 
    280         filename ../data/vienna/vsposp-seq-viewCells.xml.gz 
     274        filename ../data/vienna/vienna-viewcells-1000.xml.zip 
     275#       filename ../data/vienna/vsposp-seq-viewCells.xml.gz 
    281276 
    282277#       filename ../data/PowerPlant/power_plant_viewcells1.xml 
Note: See TracChangeset for help on using the changeset viewer.