Changeset 1771


Ignore:
Timestamp:
11/20/06 14:02:29 (18 years ago)
Author:
bittner
Message:

merge, preparing sampling strategy support for mixed distributions, filter changes, histogram output for preprocessor

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

Legend:

Unmodified
Added
Removed

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

    r1761 r1771  
    17101710                                        "sampling"); 
    17111711 
     1712        RegisterOption("Preprocessor.stats", 
     1713                                        optString, 
     1714                                        "preprocessor_stats=", 
     1715                                        "stats.log"); 
     1716 
    17121717        RegisterOption("Preprocessor.samplesFilename", 
    17131718                                        optString, 
    … …  
    17941799                                        "preprocessor_histogram_intervals=", 
    17951800                                        "20"); 
     1801 
     1802        RegisterOption("Preprocessor.histogram.file",  
     1803                                   optString, 
     1804                                   "preprocessor_histogram_file=", 
     1805                                   "histogram.log"); 
    17961806 
    17971807        RegisterOption("Preprocessor.exportKdTree",  

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

    r1563 r1771  
    119119        ////////////////////// 
    120120 
    121         ofstream mStats; 
    122121 
    123122        int mSamplesPerPass; 

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

    r1769 r1771  
    151151        char buffer[256]; 
    152152        Environment::GetSingleton()->GetStringValue("Preprocessor.visibilityFile",  buffer); 
    153      
    154153        mVisibilityFileName = buffer; 
     154         
     155        Environment::GetSingleton()->GetStringValue("Preprocessor.stats",  buffer); 
     156        mStats.open(buffer); 
     157         
     158         
    155159        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", mApplyVisibilityFilter); 
    156160        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter", 
    … …  
    935939} 
    936940 
    937 int Preprocessor::GenerateRays(const int number, 
    938                                                            const int sampleType, 
    939                                                            SimpleRayContainer &rays) 
    940 { 
    941         const int startSize = (int)rays.size(); 
    942         SamplingStrategy *strategy = GenerateSamplingStrategy(sampleType); 
    943  
    944         if (!strategy) 
    945         { 
    946                 return 0; 
    947         } 
    948  
    949         int castRays = 0; 
    950  
    951         for (int i = 0; (int)rays.size() - startSize < number; ++ i)  
    952         { 
    953                 SimpleRay newRay; 
    954  
    955                 if (strategy->GenerateSample(newRay)) 
    956                 { 
     941 
     942int 
     943Preprocessor::GenerateRays(const int number, 
     944                                                   const SamplingStrategy &strategy, 
     945                                                   SimpleRayContainer &rays) 
     946{ 
     947  return strategy.GenerateSamples(number, rays); 
     948} 
     949 
     950int 
     951Preprocessor::GenerateRays(const int number, 
     952                                                   const int sampleType, 
     953                                                   SimpleRayContainer &rays) 
     954{ 
     955  const int startSize = (int)rays.size(); 
     956  SamplingStrategy *strategy = GenerateSamplingStrategy(sampleType); 
     957  int castRays = 0; 
     958   
     959  if (!strategy) 
     960        { 
     961          return 0; 
     962        } 
     963   
    957964#if 1 
    958                         rays.AddRay(newRay); 
    959                         ++ castRays; 
     965  if (!strategy->GenerateSamples(number, rays)) 
     966        return false; 
     967  ++ castRays; 
    960968#else 
    961                         GenerateRayBundle(rays, newRay, 16, 0); 
    962                         castRays += 16; 
     969  GenerateRayBundle(rays, newRay, 16, 0); 
     970  castRays += 16; 
    963971#endif 
    964                 }        
    965         } 
    966  
    967         delete strategy; 
    968     return castRays; 
     972   
     973  delete strategy; 
     974  return castRays; 
    969975} 
    970976 
    … …  
    11551161} 
    11561162 
    1157  
    1158 } 
     1163void 
     1164Preprocessor::EvalViewCellHistogram() 
     1165{ 
     1166  char filename[256]; 
     1167  Environment::GetSingleton()->GetStringValue("Preprocessor.histogram.file", 
     1168                                                                                          filename); 
     1169   
     1170  // mViewCellsManager->EvalViewCellHistogram(filename, 1000000); 
     1171  mViewCellsManager->EvalViewCellHistogramForPvsSize(filename, 1000000); 
     1172} 
     1173 
     1174} 

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

    r1765 r1771  
    121121        bool ExportKdTree(const string filename); 
    122122 
    123         virtual int GenerateRays(const int number, 
    124                                                          const int raysType, 
    125                                                          SimpleRayContainer &rays); 
    126  
    127         bool GenerateRayBundle(SimpleRayContainer &rayBundle, 
    128                                                    const SimpleRay &mainRay, 
    129                                                    const int number, 
    130                                                    const int shuffleType) const; 
    131  
    132         virtual void CastRays(SimpleRayContainer &rays, 
    133                                                   VssRayContainer &vssRays, 
    134                                                   const bool castDoubleRays, 
    135                                                   const bool pruneInvalidRays = true); 
    136  
     123  virtual int 
     124  GenerateRays(const int number, 
     125                           const SamplingStrategy &strategy, 
     126                           SimpleRayContainer &rays); 
     127   
     128  virtual int GenerateRays(const int number, 
     129                                                   const int raysType, 
     130                                                   SimpleRayContainer &rays); 
     131   
     132  bool GenerateRayBundle(SimpleRayContainer &rayBundle, 
     133                                                 const SimpleRay &mainRay, 
     134                                                 const int number, 
     135                                                 const int shuffleType) const; 
     136   
     137  virtual void CastRays(SimpleRayContainer &rays, 
     138                                                VssRayContainer &vssRays, 
     139                                                const bool castDoubleRays, 
     140                                                const bool pruneInvalidRays = true); 
     141   
    137142        /** Returns a view cells manager of the given name. 
    138143        */ 
    … …  
    197202        bool mExportObj; 
    198203 
     204  ofstream mStats; 
     205 
    199206protected: 
    200207 
    … …  
    209216 
    210217        void EvalPvsStat(); 
     218 
     219  virtual void 
     220  EvalViewCellHistogram(); 
    211221 
    212222        ///////////////////////// 

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

    r1757 r1771  
    9696                return 0; 
    9797          } 
    98            
    9998        } 
    10099         
    … …  
    121120        const bool validSample = !pruneInvalidRays || (hitA.mObject != hitB.mObject); 
    122121 
     122         
    123123#if DEBUG_RAYCAST 
    124124        Debug<<"PR2"<<flush; 
    125125#endif 
    126126 
    127         if (validSample)  
    128         { 
     127        if (validSample) { 
    129128          if (!pruneInvalidRays || hitA.mObject)  
    130129                { 
    … …  
    137136                                                                          simpleRay.mPdf 
    138137                                                                          ); 
    139                    
     138                  if (validA) 
     139                        vssRay->mFlags |= VssRay::Valid; 
    140140                  vssRays.push_back(vssRay); 
    141141                  ++ hits; 
    … …  
    157157                                                                          simpleRay.mPdf 
    158158                                                                          ); 
     159                  if (validB) 
     160                        vssRay->mFlags |= VssRay::Valid; 
    159161                   
    160162                  vssRays.push_back(vssRay); 

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

    r1765 r1771  
    5151  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.updateSubdivision", mUpdateSubdivision); 
    5252   
    53   mStats.open("stats.log"); 
    5453  mRssTree = NULL; 
    5554} 
    … …  
    365364 
    366365void 
     366NormalizeRatios(vector<SamplingStrategy *> distributions) 
     367{ 
     368  int i; 
     369  float sumRatios = 0.0f; 
     370   
     371  for (i=0; i < distributions.size(); i++) 
     372        sumRatios += distributions[i]->mRatio; 
     373 
     374   
     375  if (sumRatios == 0.0f) { 
     376        for (i=0; i < distributions.size(); i++) { 
     377          distributions[i]->mRatio = 1.0f; 
     378          sumRatios += 1.0f; 
     379        } 
     380  } 
     381 
     382  for (i=0 ; i < distributions.size(); i++) 
     383        distributions[i]->mRatio/=sumRatios; 
     384 
     385#define MIN_RATIO 0.1f 
     386   
     387  for (i = 0; i < distributions.size(); i++) 
     388        if (distributions[i]->mRatio < MIN_RATIO) 
     389          distributions[i]->mRatio = MIN_RATIO; 
     390 
     391 
     392  sumRatios = 0.0f; 
     393  for (i=0; i < distributions.size(); i++) 
     394        sumRatios += distributions[i]->mRatio; 
     395 
     396  for (i=0 ; i < distributions.size(); i++) 
     397        distributions[i]->mRatio/=sumRatios; 
     398   
     399 
     400} 
     401 
     402void 
    367403NormalizeRatios(float ratios[4]) 
    368404{ 
    … …  
    432468  int rssSamples = 0; 
    433469 
    434   mDistributions.push_back(SamplingDistribution(SamplingStrategy::RSS_BASED_DISTRIBUTION)); 
    435   mDistributions.push_back(SamplingDistribution(SamplingStrategy::SPATIAL_BOX_BASED_DISTRIBUTION)); 
    436   mDistributions.push_back(SamplingDistribution(SamplingStrategy::DIRECTION_BASED_DISTRIBUTION)); 
    437   mDistributions.push_back(SamplingDistribution(SamplingStrategy::REVERSE_OBJECT_BASED_DISTRIBUTION)); 
     470  mDistributions.push_back(new RssBasedDistribution(*this)); 
     471  mDistributions.push_back(new SpatialBoxBasedDistribution(*this)); 
     472  mDistributions.push_back(new DirectionBasedDistribution(*this)); 
     473  mDistributions.push_back(new ReverseObjectBasedDistribution(*this)); 
    438474   
    439475  if (mLoadInitialSamples) { 
    … …  
    871907        // view cells after sampling 
    872908        mViewCellsManager->PrintStatistics(Debug); 
    873          
     909 
     910        EvalViewCellHistogram(); 
     911 
    874912        //-- render simulation after merge 
    875913        cout << "\nevaluating bsp view cells render time after sampling ... "; 

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

    r1765 r1771  
    1414class RssTreeLeaf; 
    1515 
    16   class SamplingDistribution { 
    17   public: 
    18         SamplingDistribution() {} 
    19         SamplingDistribution(const int t):mType(t) {} 
    20         int mType; 
    21         int mRays; 
    22         float mContribution; 
    23         float mTime; 
    24   }; 
    2516   
    2617/** Sampling based visibility preprocessing. The implementation is  
    … …  
    3021   
    3122public: 
    32   vector<SamplingDistribution> mDistributions; 
     23  vector<SamplingStrategy *> mDistributions; 
    3324  int mSamplesPerPass; 
    3425  int mRssSamplesPerPass; 
    … …  
    5142 
    5243   
    53   ofstream mStats; 
    5444  RssTree *mRssTree; 
    5545 

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

    r1761 r1771  
    2222  Environment::GetSingleton()->GetIntValue("SamplingPreprocessor.totalSamples", mTotalSamples); 
    2323   
    24   mStats.open("stats.log"); 
    2524} 
    2625 
    … …  
    125124          } 
    126125                 
    127           for (int j=0; j < vssRays.size(); j++) { 
    128                 Intersectable *obj = mViewCellsManager->GetIntersectable(*(vssRays[j]), 
    129                                                                                                                                  true); 
    130                 if (obj) { 
    131                   // if ray not outside of view space 
     126          for (int j=0; j < vssRays.size(); j++) 
     127                if (vssRays[j]->mFlags & VssRay::Valid) { 
     128                  Intersectable *obj = mViewCellsManager->GetIntersectable(*(vssRays[j]), 
     129                                                                                                                                   true); 
     130                  if (obj) { 
     131                        // if ray not outside of view space 
    132132                        float contribution; 
    133133                        int pvsContribution = 0; 
    … …  
    141141                        relativePvsContribution += contribution; 
    142142                        viewcell->GetPvs().AddSample(obj, pdf); 
     143                  } 
    143144                } 
    144           } 
    145145           
    146146          CLEAR_CONTAINER(vssRays); 
    … …  
    180180  mViewCellsManager->PrintStatistics(Debug); 
    181181   
     182  EvalViewCellHistogram(); 
     183 
    182184  //-- render simulation after merge 
    183185  cout << "\nevaluating bsp view cells render time after merge ... "; 

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

    r1743 r1771  
    5050        int mTotalSamples; 
    5151         
    52         ofstream mStats; 
    5352        ObjectContainer mObjects; 
    5453 

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

    r1769 r1771  
    2020} 
    2121 
     22int 
     23SamplingStrategy::GenerateSamples(const int number, 
     24                                                                  SimpleRayContainer &rays) const 
     25{ 
     26  SimpleRay ray; 
     27  int i = 0; 
     28  for (; i < number; i++) { 
     29        if (!GenerateSample(ray)) 
     30          return i; 
     31        rays.push_back(ray); 
     32  } 
     33 
     34  return i; 
     35} 
    2236 
    2337 
    … …  
    264278 
    265279#endif 
    266 } 
     280 
     281bool 
     282RssBasedDistribution::GenerateSample(SimpleRay &ray) const 
     283{ 
     284  return false; 
     285} 
     286 
     287} 
     288 
     289 

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

    r1769 r1771  
    88class Preprocessor; 
    99struct SimpleRay; 
     10class SimpleRayContainer; 
    1011 
    1112/** This class generates a specific sampling strategy. 
    … …  
    3132                 VIEWCELL_BORDER_BASED_DISTRIBUTION 
    3233         }; 
     34   
     35  /** Default constructor 
     36   */ 
     37  SamplingStrategy(const Preprocessor &preprocessor); 
     38   
     39  virtual ~SamplingStrategy(); 
     40   
     41  /** Each strategy has to implement this function. 
     42          @returns true if generated valid sample. 
     43  */ 
    3344 
    34          /** Default constructor 
    35      */ 
    36          SamplingStrategy(const Preprocessor &preprocessor); 
     45  virtual int GenerateSamples(const int number, SimpleRayContainer &rays) const; 
    3746 
    38          virtual ~SamplingStrategy(); 
     47private: 
    3948 
    40          /** Each strategy has to implement this function. 
    41                  @returns true if generated valid sample. 
    42          */ 
    43          virtual bool GenerateSample(SimpleRay &ray) const = 0; 
     49  virtual bool GenerateSample(SimpleRay &ray) const = 0; 
    4450 
     51public: 
     52  /// variables usefull for mixed distribution sampling 
     53  int mType; 
     54  int mRays; 
     55  float mContribution; 
     56  float mTime; 
     57  float mRatio; 
     58   
    4559protected: 
    46  
    47         const Preprocessor &mPreprocessor; 
    48  
     60   
     61  const Preprocessor &mPreprocessor; 
     62   
    4963}; 
    5064 
    … …  
    5468 public: 
    5569         
    56          ObjectBasedDistribution(const Preprocessor &preprocessor): 
    57          SamplingStrategy(preprocessor) {} 
     70  ObjectBasedDistribution(const Preprocessor &preprocessor): 
     71        SamplingStrategy(preprocessor) { 
     72        mType = OBJECT_BASED_DISTRIBUTION; 
     73  } 
    5874 
    59          virtual bool GenerateSample(SimpleRay &ray) const; 
     75private: 
     76  virtual bool GenerateSample(SimpleRay &ray) const; 
    6077}; 
    6178 
    … …  
    6683         
    6784         ReverseObjectBasedDistribution(const Preprocessor &preprocessor): 
    68          SamplingStrategy(preprocessor) {} 
     85           SamplingStrategy(preprocessor) { 
     86           mType = REVERSE_OBJECT_BASED_DISTRIBUTION; 
     87         } 
    6988 
    70          virtual bool GenerateSample(SimpleRay &ray) const; 
     89private: 
     90  virtual bool GenerateSample(SimpleRay &ray) const; 
    7191}; 
    7292 
    … …  
    7696 public: 
    7797         ObjectDirectionBasedDistribution(const Preprocessor &preprocessor): 
    78          SamplingStrategy(preprocessor) {} 
     98         SamplingStrategy(preprocessor) { 
     99           mType = OBJECT_DIRECTION_BASED_DISTRIBUTION; 
     100         } 
     101private: 
    79102        virtual bool GenerateSample(SimpleRay &ray) const; 
    80103}; 
    … …  
    84107{ 
    85108 public: 
    86         DirectionBasedDistribution(const Preprocessor &preprocessor): 
    87          SamplingStrategy(preprocessor) {} 
    88         virtual bool GenerateSample(SimpleRay &ray) const; 
     109  DirectionBasedDistribution(const Preprocessor &preprocessor): 
     110        SamplingStrategy(preprocessor){ 
     111        mType = DIRECTION_BASED_DISTRIBUTION; 
     112  } 
     113private: 
     114  virtual bool GenerateSample(SimpleRay &ray) const; 
    89115}; 
    90116 
    … …  
    94120 public: 
    95121         DirectionBoxBasedDistribution(const Preprocessor &preprocessor): 
    96            SamplingStrategy(preprocessor) {} 
     122           SamplingStrategy(preprocessor){ 
     123           mType = DIRECTION_BOX_BASED_DISTRIBUTION; 
     124         } 
    97125            
     126private: 
    98127           virtual bool GenerateSample(SimpleRay &ray) const; 
    99128}; 
    … …  
    104133 public: 
    105134         SpatialBoxBasedDistribution(const Preprocessor &preprocessor): 
    106          SamplingStrategy(preprocessor) {} 
     135           SamplingStrategy(preprocessor){ 
     136           mType = SPATIAL_BOX_BASED_DISTRIBUTION; 
     137         } 
    107138          
     139private: 
    108140         virtual bool GenerateSample(SimpleRay &ray) const; 
    109141}; 
    110142 
     143class RssBasedDistribution: public SamplingStrategy 
     144{ 
     145 public: 
     146  RssBasedDistribution(const Preprocessor &preprocessor): 
     147        SamplingStrategy(preprocessor){ 
     148        mType = RSS_BASED_DISTRIBUTION; 
     149  } 
     150 
     151 
     152  virtual int GenerateSamples(const int number, SimpleRayContainer &ray) const { 
     153        // TBD!!! 
     154        return 0; 
     155  } 
     156 
     157private: 
     158  virtual bool GenerateSample(SimpleRay &ray) const; 
     159   
     160}; 
    111161 
    112162class ViewCellBorderBasedDistribution: public SamplingStrategy 
    113163{ 
    114164 public: 
    115         ViewCellBorderBasedDistribution(const Preprocessor &preprocessor): 
    116          SamplingStrategy(preprocessor) {} 
    117          
    118         virtual bool GenerateSample(SimpleRay &ray) const; 
     165  ViewCellBorderBasedDistribution(const Preprocessor &preprocessor): 
     166        SamplingStrategy(preprocessor) {} 
     167   
     168  virtual bool GenerateSample(SimpleRay &ray) const; 
    119169}; 
    120170 

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

    r1761 r1771  
    108108         
    109109        int mPvsSizeDecr; 
    110          
     110 
     111   
    111112        float mVolume; 
    112113 
    … …  
    271272        float GetMergeCost() const; 
    272273 
    273  
    274   float GetCachedPvsCost() const { 
     274  void UpdatePvsCost() { 
     275        mPvsCost = GetPvs().EvalPvsCost(); 
     276  } 
     277 
     278  void SetPvsCost(const float c) { 
     279        mPvsCost = c; 
     280  } 
     281 
     282  float GetPvsCost() const { 
    275283        return mPvsCost; 
    276284  } 
    … …  
    299307        static int sReservedMailboxes; 
    300308         
     309  int GetFilteredPvsSize() const { 
     310        return mFilteredPvsSize; 
     311  } 
     312 
     313  void SetFilteredPvsSize(const int s) { 
     314        mFilteredPvsSize = s; 
     315  } 
    301316 
    302317protected: 
    … …  
    327342        */ 
    328343        bool mPvsSizeValid; 
     344 
     345  /// Filter cost of the pvs 
     346  int mFilteredPvsSize; 
     347 
    329348}; 
    330349 

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

    r1769 r1771  
    3434// $$JB HACK 
    3535#define USE_KD_PVS 0 
    36 #define KD_PVS_AREA (1e-4f) 
     36#define KD_PVS_AREA (1e-5f) 
    3737 
    3838 
    … …  
    599599 
    600600        ViewCellContainer viewCells; 
     601        // $$ JB hack - the collect best viewcells does not work? 
     602#if 1 
    601603        mViewCellsTree->CollectBestViewCellSet(viewCells, nViewCells); 
     604#else 
     605        viewCells = mViewCells; 
     606#endif 
    602607 
    603608        float maxRenderCost, minRenderCost; 
    … …  
    823828 
    824829        ViewCellContainer viewCells; 
     830         
     831        // $$ JB hack - the collect best viewcells does not work? 
     832#if 0 
    825833        mViewCellsTree->CollectBestViewCellSet(viewCells, nViewCells); 
     834#else 
     835        viewCells = mViewCells; 
     836#endif 
     837        ViewCellContainer::iterator it = viewCells.begin(), it_end = viewCells.end();            
     838        for (; it != it_end; ++it) { 
     839          //(*it)->UpdatePvsCost(); 
     840          (*it)->SetPvsCost((*it)->GetFilteredPvsSize()); 
     841        } 
     842         
    826843 
    827844        float maxPvs, maxVal, minVal; 
    828  
     845         
    829846        // sort by pvs size 
    830847        sort(viewCells.begin(), viewCells.end(), ViewCell::SmallerPvs); 
    831848 
    832         maxPvs = mViewCellsTree->GetPvsCost(viewCells.back()); 
     849        maxPvs = viewCells.back()->GetPvsCost(); 
    833850        minVal = 0; 
    834851 
    … …  
    863880        int smallerSum = 0; 
    864881 
    865         ViewCellContainer::const_iterator it = viewCells.begin(), it_end = viewCells.end();              
     882        it = viewCells.begin(); 
    866883         
    867884        for (int j = 0; j < intervals; ++ j) 
    … …  
    871888 
    872889                while ((i < (int)viewCells.size()) &&  
    873                            (mViewCellsTree->GetPvsCost(viewCells[i]) < currentPvs)) 
     890                           (viewCells[i]->GetPvsCost() < currentPvs)) 
    874891                { 
    875892                        volDif += viewCells[i]->GetVolume(); 
    … …  
    881898                } 
    882899                 
    883                 if (0 && (i < (int)viewCells.size())) 
    884                         Debug << "new pvs cost increase: " << mViewCellsTree->GetPvsCost(viewCells[i])  
    885                         << " " << currentPvs << endl; 
    886          
     900                //              if (0 && (i < (int)viewCells.size())) 
     901                //                Debug << "new pvs cost increase: " << mViewCellsTree->GetPvsCost(viewCells[i])  
     902                //                              << " " << currentPvs << endl; 
     903                 
    887904                const float volRatioDif = volDif / totalVol; 
    888905                const float volRatioSum = volSum / totalVol; 
    … …  
    900917 
    901918        outstream.close(); 
     919 
    902920} 
    903921 
    … …  
    18041822 
    18051823                  stat.avgFilterRadius += fstat.mAvgFilterRadius; 
    1806                   stat.avgFilterRatio += fstat.mLocalFilterCount / (float) fstat.mGlobalFilterCount; 
     1824                  int sum = fstat.mGlobalFilterCount + fstat.mLocalFilterCount; 
     1825                  if (sum) { 
     1826                        stat.avgFilterRatio += fstat.mLocalFilterCount / 
     1827                          (float) sum; 
     1828                  } 
    18071829                   
    18081830                   
    … …  
    25782600  float samples = (float)basePvs.GetSamples(); 
    25792601   
    2580   cout<<"f #s="<<samples<<"pvs size = "<<basePvs.GetSize(); 
     2602  Debug<<"f #s="<<samples<<"pvs size = "<<basePvs.GetSize(); 
    25812603  //  cout<<"Filter size = "<<filterSize<<endl; 
    25822604  //  cout<<"vbox = "<<vbox<<endl; 
    … …  
    26812703  } 
    26822704   
    2683   cout<<" nPvs size = "<<pvs.GetSize()<<endl; 
     2705  Debug<<" nPvs size = "<<pvs.GetSize()<<endl; 
    26842706 
    26852707#if !USE_KD_PVS 
    … …  
    26912713  } 
    26922714#endif 
     2715  viewCell->SetFilteredPvsSize(pvs.GetSize()); 
    26932716   
    26942717  Intersectable::NewMail(); 

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

    r1743 r1771  
    4747  Debug << "*********** end vss preprocessor options **************" << endl; 
    4848 
    49   mStats.open("stats.log"); 
    5049} 
    5150 

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

    r1723 r1771  
    2828  //AxisAlignedBox3 mViewSpaceBox; 
    2929 
    30   ofstream mStats; 
    3130         
    3231  ObjectContainer mObjects; 

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

    r1715 r1771  
    2424    FPosDirZ = 4,    // the direction of ray in Z-axis is positive 
    2525        BorderSample = 8,// if this ray is an adaptive border ray 
    26         ReverseSample = 16  // if this ray is a reverse sample 
     26        ReverseSample = 16,  // if this ray is a reverse sample 
     27        Valid = 32  // this ray is a valid ray 
     28                   //(with respect to detect empty viewspace) 
    2729  }; 
    2830 

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

    r1761 r1771  
    6363        loadKdTree      false 
    6464        exportKdTree false 
     65 
     66        histogram { 
     67                intervals 20 
     68                maxValue  1000 
     69            file        histogram.log 
     70        } 
    6571} 
    6672 
    … …  
    7682SamplingPreprocessor { 
    7783        totalSamples 50000000 
    78         samplesPerPass 3000000 
     84        samplesPerPass 5000000 
    7985} 
    8086 
    … …  
    8490        vssSamples 50000000 
    8591#       vssSamples 1000000 
    86         vssSamplesPerPass 3000000 
     92        vssSamplesPerPass 5000000 
    8793        useImportanceSampling true 
    8894 

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

    r1757 r1771  
    2929VIEWCELLS=../data/vienna/vienna_cropped-gradient-viewcells.xml.gz 
    3030 
    31 PREFIX=../work/plots/osp-rss 
     31PREFIX=../work/plots/osp-rss-1e5 
    3232 
    3333#SCENE=../data/atlanta/atlanta2.x3d 
    3434#PREFIX=../work/plots/atlanta2-rss9 
    3535 
    36 #$COMMAND -scene_filename=$SCENE -rss_use_importance+ -rss_update_subdivision- 
    37 #mv stats.log $PREFIX-i-combined-b3.log 
    38  
    39 #$COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    40 #-rss_use_importance+ -rss_update_subdivision+ -rss_split=regular \ 
    41 #-view_cells_filter_max_size=1 
    42   
    43 #mv stats.log $PREFIX-i-combined-update-ccb3.log  
    44  
    45 # $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    46 # -rss_use_importance+ -rss_update_subdivision+ -rss_split=heuristic \ 
    47 # -view_cells_filter_max_size=1 
    48   
    49 # mv stats.log $PREFIX-i-combined-update-ccb4.log  
    5036 
    5137$COMMAND -preprocessor=sampling -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    52 -view_cells_filter_max_size=1 
    53 mv stats.log $PREFIX-r-reference.log  
     38-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-reference.log \ 
     39-preprocessor_histogram_file=$PREFIX-r-reference.hlog 
    5440 
    5541 
    5642$COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    5743 -rss_use_importance+ -rss_update_subdivision+ -rss_split=hybrid -hybrid_depth=10 \ 
    58  -view_cells_filter_max_size=1 
    59  mv stats.log $PREFIX-i-combined-update-ccb12.log  
     44 -view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-i-combined-update-ccb12.log \ 
     45-preprocessor_histogram_file=$PREFIX-i-combined-update-ccb12.hlog 
    6046 
    6147 
    … …  
    6551$COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    6652-rss_use_importance- -rss_object_based_sampling- -rss_directional_sampling+ \ 
    67 -view_cells_filter_max_size=1 
    68 mv stats.log $PREFIX-r-directional-based-b3.log 
    69  
     53-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-directional-based-b3.log \ 
     54-preprocessor_histogram_file=$PREFIX-r-directional-based-b3.hlog 
    7055 
    7156$COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    7257-rss_use_importance- -rss_object_based_sampling- -rss_directional_sampling- \ 
    73 -view_cells_filter_max_size=1 
    74 mv stats.log $PREFIX-r-spatial-based-bb3.log 
     58-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-spatial-based-bb3.log \ 
     59-preprocessor_histogram_file=$PREFIX-r-spatial-based-bb3.hlog 
    7560 
    7661 
    7762 
    78 $COMMAND -scene_filename=$SCENE -rss_use_importance- -rss_object_based_sampling- -rss_directional_sampling+ 
    79 mv stats.log $PREFIX-r-direction-based-b3.log 
    80  
    81  
    82  
    83 #-vss_samples=500000000 
    84  
    85  
Note: See TracChangeset for help on using the changeset viewer.