Ignore:
Timestamp:
01/10/07 21:32:50 (18 years ago)
Author:
bittner
Message:

samplign preprocessor updates, merge

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

Legend:

Unmodified
Added
Removed

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

    r1942 r1966  
    1616namespace GtpVisibilityPreprocessor { 
    1717 
    18 const bool pruneInvalidRays = false; 
     18const bool pruneInvalidRays = true; 
    1919 
    2020   
    … …  
    2323  { 
    2424        // this should increase coherence of the samples 
    25         Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mTotalSamples); 
    26         Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass); 
    27         Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", 
    28                                                                                          mSamplesPerEvaluation); 
     25//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mTotalSamples); 
     26//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass); 
     27//      Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", 
     28//                                                                                       mSamplesPerEvaluation); 
    2929         
    3030         
    … …  
    6969  for (int i=0; i < mTotalSamples; i += mSamplesPerPass, mPass++) { 
    7070 
    71          
    7271        cout<<"Progress : "<<(100.0f*i)/mTotalSamples<<"%"<<endl; 
    7372        rays.clear(); 
    … …  
    108107        } 
    109108 
     109        cerr<<"deleting rays"<<endl; 
     110        //clear all unreferenced rays 
     111        for (int j=0; j < vssRays.size(); j++) { 
     112          if (vssRays[j]->RefCount() == 0) 
     113                delete vssRays[j]; 
     114        } 
     115        cerr<<"done."<<endl; 
     116           
    110117         
    111          
    112         if (!mMixtureDistribution->RequiresRays()) 
    113           CLEAR_CONTAINER(vssRays); 
     118        //      if (!mMixtureDistribution->RequiresRays()) 
     119        //        CLEAR_CONTAINER(vssRays); 
    114120 
    115121        if (renderer) { 

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

    r1891 r1966  
    2727  MixtureDistribution *mMixtureDistribution; 
    2828   
    29   int mTotalSamples; 
    30   int mSamplesPerPass; 
    31   int mSamplesPerEvaluation; 
    32    
    3329}; 
    3430 

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

    r1942 r1966  
    11731173                 "0.1"); 
    11741174 
    1175   RegisterOption("SamplingPreprocessor.totalSamples", 
    1176                  optInt, 
    1177                  "total_samples=", 
    1178                  "1000000"); 
    1179  
    1180   RegisterOption("SamplingPreprocessor.samplesPerPass", 
    1181                  optInt, 
    1182                  "samples_per_pass=", 
    1183                  "10"); 
     1175  RegisterOption("Preprocessor.totalSamples", 
     1176                                 optInt, 
     1177                                 "total_samples=", 
     1178                                 "10000000"); 
     1179 
     1180  RegisterOption("Preprocessor.samplesPerPass", 
     1181                                 optInt, 
     1182                                 "samples_per_pass=", 
     1183                                 "100000"); 
     1184   
     1185  RegisterOption("Preprocessor.samplesPerEvaluation", 
     1186                                 optInt, 
     1187                                 "samples_per_evaluation=", 
     1188                                 "1000000"); 
    11841189 
    11851190  RegisterOption("RenderSampler.samples", 
    … …  
    11991204                                 "true"); 
    12001205 
    1201    RegisterOption("VssPreprocessor.initialSamples", 
    1202                                  optInt, 
    1203                                  "vss_initial_samples=", 
    1204                                  "100000"); 
     1206//    RegisterOption("VssPreprocessor.initialSamples", 
     1207//                               optInt, 
     1208//                               "vss_initial_samples=", 
     1209//                               "100000"); 
    12051210   
    12061211  RegisterOption("VssPreprocessor.testBeamSampling",  
    … …  
    12091214                                "false"); 
    12101215 
    1211   RegisterOption("VssPreprocessor.vssSamples", 
    1212                                  optInt, 
    1213                                  "vss_samples=", 
    1214                                  "1000000"); 
    1215          
    1216   RegisterOption("VssPreprocessor.vssSamplesPerPass", 
    1217                                  optInt, 
    1218                                  "vss_samples_per_pass=", 
    1219                                  "1000"); 
    1220    
    1221   RegisterOption("VssPreprocessor.samplesPerPass", 
    1222                                  optInt, 
    1223                                  "vss_samples_per_pass=", 
    1224                                  "100000"); 
     1216//   RegisterOption("VssPreprocessor.vssSamples", 
     1217//                               optInt, 
     1218//                               "vss_samples=", 
     1219//                               "1000000"); 
     1220         
     1221//   RegisterOption("VssPreprocessor.vssSamplesPerPass", 
     1222//                               optInt, 
     1223//                               "vss_samples_per_pass=", 
     1224//                               "1000"); 
     1225   
     1226//   RegisterOption("VssPreprocessor.samplesPerPass", 
     1227//                               optInt, 
     1228//                               "vss_samples_per_pass=", 
     1229//                               "100000"); 
    12251230 
    12261231  RegisterOption("VssPreprocessor.useImportanceSampling", 
    … …  
    18961901 
    18971902 
    1898         RegisterOption("RssPreprocessor.initialSamples", 
    1899                                                                         optInt, 
    1900                                                                         "rss_initial_samples=", 
    1901                                                                         "100000"); 
    1902  
    1903         RegisterOption("RssPreprocessor.vssSamples", 
    1904                                         optInt, 
    1905                                         "rss_vss_samples=", 
    1906                                         "1000000"); 
    1907  
    1908         RegisterOption("RssPreprocessor.vssSamplesPerPass", 
    1909                                         optInt, 
    1910                                         "rss_vss_samples_per_pass=", 
    1911                                         "1000"); 
    1912  
    1913         RegisterOption("RssPreprocessor.samplesPerPass", 
    1914                                         optInt, 
    1915                                         "rss_samples_per_pass=", 
    1916                                         "100000"); 
     1903//      RegisterOption("RssPreprocessor.initialSamples", 
     1904//                                                                      optInt, 
     1905//                                                                      "rss_initial_samples=", 
     1906//                                                                      "100000"); 
     1907 
     1908//      RegisterOption("RssPreprocessor.vssSamples", 
     1909//                                      optInt, 
     1910//                                      "rss_vss_samples=", 
     1911//                                      "1000000"); 
     1912 
     1913//      RegisterOption("RssPreprocessor.vssSamplesPerPass", 
     1914//                                      optInt, 
     1915//                                      "rss_vss_samples_per_pass=", 
     1916//                                      "1000"); 
     1917 
     1918//      RegisterOption("RssPreprocessor.samplesPerPass", 
     1919//                                      optInt, 
     1920//                                      "rss_samples_per_pass=", 
     1921//                                      "100000"); 
    19171922 
    19181923        RegisterOption("RssPreprocessor.useImportanceSampling", 

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

    r1952 r1966  
    11############################################################################# 
    22# Makefile for building: preprocessor 
    3 # Generated by qmake (2.00a) (Qt 4.1.2) on: ne 7. I 23:22:46 2007 
     3# Generated by qmake (2.00a) (Qt 4.1.2) on: st 10. I 21:30:27 2007 
    44# Project:  preprocessor.pro 
    55# Template: app 

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

    r1960 r1966  
    168168        Environment::GetSingleton()->GetIntValue("Preprocessor.Export.numRays", mExportNumRays); 
    169169 
     170 
     171        Environment::GetSingleton()->GetIntValue("Preprocessor.samplesPerPass", mSamplesPerPass); 
     172        Environment::GetSingleton()->GetIntValue("Preprocessor.totalSamples", mTotalSamples); 
     173        Environment::GetSingleton()->GetIntValue("Preprocessor.samplesPerEvaluation", 
     174                                                                                         mSamplesPerEvaluation); 
     175 
     176         
    170177        Debug << "******* Preprocessor Options **********" << endl; 
    171178        Debug << "detect empty view space=" << mDetectEmptyViewSpace << endl; 

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

    r1958 r1966  
    233233        GlRendererBuffer *renderer; 
    234234   
    235    
     235        int mTotalSamples; 
     236  int mSamplesPerPass; 
     237  int mSamplesPerEvaluation; 
     238 
    236239protected: 
    237240 

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

    r1948 r1966  
    692692        updateGL(); 
    693693        break; 
    694  
     694  case Qt::Key_S: { 
     695        // set view poitn and direction 
     696        QString text; 
     697        bool ok; 
     698        text.sprintf("%f %f %f", mViewPoint.x, mViewPoint.y, mViewPoint.z); 
     699        text = QInputDialog::getText(this, 
     700                                                                 "Enter a view point", 
     701                                                                 "", 
     702                                                                 QLineEdit::Normal, 
     703                                                                 text, 
     704                                                                 &ok); 
     705        if (!ok) 
     706          break; 
     707        QTextStream ts(&text); 
     708        ts>>mViewPoint.x>>mViewPoint.y>>mViewPoint.z; 
     709        mViewCellsManager->GetViewPoint(mViewPoint); 
     710        updateGL(); 
     711        break; 
     712  } 
    695713  default: 
    696714        e->ignore(); 

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

    r1952 r1966  
    142142                return 0; 
    143143          } 
    144           if (EpsilonEqualV3(hitA.mPoint, hitB.mPoint, Limits::Small)) { 
    145                 return 0; 
    146           } 
    147         } 
     144        } 
     145 
    148146         
    149147        // regardless of the pruneInvalidRays setting reject rays whic degenerate to a point 
     148        if (EpsilonEqualV3(hitA.mPoint, hitB.mPoint, Limits::Small)) { 
     149          return 0; 
     150        } 
     151         
     152         
    150153        const bool validA = ValidateRay(simpleRay.mOrigin, simpleRay.mDirection, box, hitA); 
    151154        const bool validB = //castDoubleRay &&  

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

    r1931 r1966  
    2929{ 
    3030  // this should increase coherence of the samples 
    31   Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass); 
    32   Environment::GetSingleton()->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples); 
    33   Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mRssSamples); 
    34   Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass); 
     31  //  Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass); 
     32  //Environment::GetSingleton()->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples); 
     33  //Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mRssSamples); 
     34  //Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass); 
    3535  Environment::GetSingleton()->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling); 
    3636 

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

    r1900 r1966  
    2020{ 
    2121  // this should increase coherence of the samples 
    22   Environment::GetSingleton()->GetIntValue("SamplingPreprocessor.samplesPerPass", mSamplesPerPass); 
    23   Environment::GetSingleton()->GetIntValue("SamplingPreprocessor.totalSamples", mTotalSamples); 
    2422   
    2523} 
    … …  
    8785  int intersectables, faces; 
    8886  mSceneGraph->GetStatistics(intersectables, faces); 
    89   HaltonSequence halton; 
     87  HaltonSequence posHalton; 
    9088   
    9189  int samples = 0; 
    92   int i=0; 
     90  int rssSamples = 0; 
     91 
     92  map<ViewCell *, HaltonSequence> dirHalton; 
     93   
    9394  while (samples < mTotalSamples) { 
    94         for (i=0; i < mSamplesPerPass;) { 
     95        for (int i=0; i < mSamplesPerEvaluation;) { 
    9596          SimpleRayContainer rays; 
    9697          VssRayContainer vssRays; 
    97           vector<ViewCell *> viewcells; 
     98          //      vector<ViewCell *> viewcells; 
     99           
     100          float r[5]; 
     101          Vector3 origin, direction; 
     102          posHalton.GetNext(3, r); 
     103 
     104          mViewCellsManager->GetViewPoint(origin, Vector3(r[0], r[1], r[2])); 
     105          ViewCell *viewcell = mViewCellsManager->GetViewCell(origin); 
     106           
     107          if (!viewcell || !viewcell->GetValid()) 
     108                continue; 
     109           
    98110          for (; rays.size() < 16; ) { 
    99                 if (i%10000 == 0) 
     111                if (i%100000 == 0) 
    100112                  cout<<"+"; 
    101  
    102                 float r[5]; 
    103                 halton.GetNext(5, r); 
    104                 Vector3 origin, direction; 
    105                 mViewCellsManager->GetViewPoint(origin, Vector3(r[0], r[1], r[2])); 
    106113                 
    107                 direction = UniformRandomVector(r[3],r[4]); 
    108                 ViewCell *viewcell = mViewCellsManager->GetViewCell(origin); 
     114                //              dirHalton.GetNext(2, r); 
     115                dirHalton[viewcell].GetNext(2, r); 
     116                direction = UniformRandomVector(r[0],r[1]); 
     117                //direction = UniformRandomVector(); 
    109118                 
    110                 if (viewcell && viewcell->GetValid()) { 
    111                   viewcells.push_back(viewcell); 
    112                   // cast rays in both directions to make the number of samples comparable 
    113                   // with the global sampling method which also casts a "double" ray per sample 
    114                   rays.push_back(SimpleRay(origin, 
    115                                                                    direction, 
    116                                                                    SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, 
    117                                                                    1.0f)); 
    118                   i++; 
    119                   samples++; 
    120                 } 
     119                //              viewcells.push_back(viewcell); 
     120                // cast rays in both directions to make the number of samples comparable 
     121                // with the global sampling method which also casts a "double" ray per sample 
     122                rays.push_back(SimpleRay(origin, 
     123                                                                 direction, 
     124                                                                 SamplingStrategy::DIRECTION_BASED_DISTRIBUTION, 
     125                                                                 1.0f)); 
     126                i++; 
     127                samples++; 
    121128          } 
    122129           
    … …  
    124131                           vssRays, 
    125132                           true, 
    126                            false); 
    127  
    128           if (vssRays.size()!=32) { 
    129                 cerr<<"wrong number of rays "<<(int)vssRays.size()<<endl; 
    130                 exit(1); 
    131           } 
    132                  
     133                           true); 
     134           
     135          //      if (vssRays.size()!=32) { 
     136          //            cerr<<"wrong number of rays "<<(int)vssRays.size()<<endl; 
     137          //            exit(1); 
     138          //      } 
     139 
     140          rssSamples+=vssRays.size(); 
    133141          for (int j=0; j < vssRays.size(); j++) 
    134142                if (vssRays[j]->mFlags & VssRay::Valid) { 
    … …  
    137145                  if (obj) { 
    138146                        // if ray not outside of view space 
    139                         float contribution; 
    140                         int pvsContribution = 0; 
    141                         float relativePvsContribution = 0; 
    142147                        float pdf = 1.0f; 
    143                         ViewCell *viewcell = viewcells[j/2]; 
    144                         if (viewcell->GetPvs().GetSampleContribution(obj, 
    145                                                                                                                  pdf, 
    146                                                                                                                  contribution))  
    147                           ++pvsContribution; 
    148                         relativePvsContribution += contribution; 
    149                         viewcell->GetPvs().AddSample(obj, pdf); 
     148                        //                      ViewCell *viewcell = viewcells[j/2]; 
     149 
     150                        ObjectPvs &pvs = viewcell->GetPvs(); 
     151                        pvs.AddSampleDirtyCheck(obj, pdf); 
     152                         
     153                        if (pvs.RequiresResort())  { 
     154                          pvs.SimpleSort(); 
     155                        } 
    150156                  } 
    151157                } 
    152158           
    153159          CLEAR_CONTAINER(vssRays); 
    154  
     160           
    155161          if (samples > mTotalSamples) 
    156162                break; 
    … …  
    166172        mStats << 
    167173          "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<< 
    168           "#TotalSamples\n" <<samples<<endl; 
    169  
     174          "#TotalSamples\n" <<samples<<endl<< 
     175          "#RssSamples\n" <<rssSamples<<endl; 
     176                   
    170177        mViewCellsManager->PrintPvsStatistics(mStats); 
    171178        // ComputeRenderError(); 

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

    r1771 r1966  
    4747 
    4848        int mPass; 
    49         int mSamplesPerPass; 
    50         int mTotalSamples; 
    5149         
    5250        ObjectContainer mObjects; 

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

    r1952 r1966  
    1818HaltonSequence ObjectDirectionBasedDistribution::sHalton; 
    1919HaltonSequence DirectionBasedDistribution::sHalton; 
    20 HaltonSequence MutationBasedDistribution::sHalton; 
    2120 
    2221 
    … …  
    478477        // small non-zero value 
    479478        mDistributions[i]->mRays = 1; 
     479        mDistributions[i]->mGeneratedRays = 1; 
    480480        // unit contribution per ray 
    481481        if (1 || mDistributions[i]->mType != RSS_BASED_DISTRIBUTION) 
    … …  
    511511          break; 
    512512 
    513   return mDistributions[i]->GenerateSample(ray); 
     513  bool result = mDistributions[i]->GenerateSample(ray); 
     514 
     515  if (result) 
     516        mDistributions[i]->mGeneratedRays++; 
     517   
     518  return result; 
    514519} 
    515520 
    … …  
    548553   
    549554  UpdateRatios(); 
     555 
    550556} 
    551557 
    … …  
    558564  } 
    559565} 
    560    
     566 
     567#define RAY_CAST_TIME 0.9f 
     568#define VIEWCELL_CAST_TIME 0.1f 
     569 
    561570void 
    562571MixtureDistribution::UpdateRatios() 
    … …  
    570579        float importance = 0.0f; 
    571580        if (mDistributions[i]->mRays != 0) { 
    572           //      importance = pow(mDistributions[i]->mContribution/mDistributions[i]->mRays, 3); 
    573           importance = mDistributions[i]->mContribution/mDistributions[i]->mRays; 
     581          //importance = pow(mDistributions[i]->mContribution/mDistributions[i]->mRays, 2); 
     582          importance = mDistributions[i]->mContribution/ 
     583                (RAY_CAST_TIME*mDistributions[i]->mGeneratedRays + 
     584                 VIEWCELL_CAST_TIME*mDistributions[i]->mRays); 
    574585        } 
    575586        mDistributions[i]->mRatio = importance; 
    … …  
    577588  } 
    578589 
    579   const float minratio = 0.02f; 
     590   
     591   
     592  if (sum == 0.0f) 
     593        sum = Limits::Small; 
     594 
     595  const float minratio = 0.01f; 
    580596  float threshold = minratio*sum; 
     597 
     598  // recaluate the sum 
     599  sum = 0.0f; 
    581600  for (i=0; i < mDistributions.size(); i++) { 
    582601        if (mDistributions[i]->mRatio < threshold) { 
    583           sum += threshold - mDistributions[i]->mRatio; 
    584602          mDistributions[i]->mRatio = threshold; 
    585603        } 
     604        sum += mDistributions[i]->mRatio; 
    586605  } 
    587606   
    588607  mDistributions[0]->mRatio /= sum; 
    589          
     608   
    590609  for (i=1; i < mDistributions.size(); i++) { 
    591610        float r = mDistributions[i]->mRatio / sum; 
    592611        mDistributions[i]->mRatio = mDistributions[i-1]->mRatio + r; 
    593612  } 
     613   
    594614   
    595615  cout<<"ratios: "; 
    … …  
    653673} 
    654674 
    655  
     675int 
     676MixtureDistribution::GenerateSamples(const int number, 
     677                                                                         SimpleRayContainer &rays) 
     678{ 
     679  for (int i=0; i < mDistributions.size(); i++)  
     680        mDistributions[i]->mGeneratedRays = 0; 
     681 
     682  return SamplingStrategy::GenerateSamples(number, rays); 
     683} 
    656684 
    657685void 
    … …  
    661689  //    cout<<mRays[i].mSamples<<" "; 
    662690  //  cout<<endl; 
    663    
     691  cerr<<"Muattion update..."<<endl; 
     692  cerr<<"rays = "<<mRays.size()<<endl; 
     693  if (mRays.size()) 
     694        cerr<<"Oversampling factor = "<<mRays[0].mSamples<<endl; 
    664695  for (int i=0; i < vssRays.size(); i++) { 
    665         VssRay *newRay = vssRays[i]; 
    666         if (newRay->mPvsContribution) { 
    667           // add this ray 
    668           newRay->Ref(); 
    669           if (mRays.size() < mMaxRays) 
     696        if (vssRays[i]->mPvsContribution) { 
     697          if (mRays.size() < mMaxRays) { 
     698                VssRay *newRay = new VssRay(*vssRays[i]); 
     699                // add this ray 
     700                newRay->Ref(); 
    670701                mRays.push_back(RayEntry(newRay)); 
    671           else { 
     702          } else { 
    672703                // unref the old ray 
    673                 VssRay *oldRay = mRays[mBufferStart].mRay; 
    674                 oldRay->Unref(); 
    675                 if (oldRay->RefCount() == 0) 
    676                   delete oldRay; 
    677                 mRays[mBufferStart] = RayEntry(newRay); 
     704                *mRays[mBufferStart].mRay = *vssRays[i]; 
     705                mRays[mBufferStart].mSamples = 0; 
     706                //              mRays[mBufferStart] = RayEntry(newRay); 
    678707                mBufferStart++; 
    679708                if (mBufferStart >= mMaxRays) 
    … …  
    682711        } 
    683712  } 
     713  cerr<<"Mutation update done."<<endl; 
     714 
    684715} 
    685716 
    … …  
    688719{ 
    689720  float r[5]; 
    690   sHalton.GetNext(5, r); 
    691721 
    692722  if (mRays.size() == 0) { 
    693723        // use direction based distribution 
    694724        Vector3 origin, direction; 
     725        static HaltonSequence halton; 
     726         
     727        halton.GetNext(5, r); 
    695728        mPreprocessor.mViewCellsManager->GetViewPoint(origin, 
    696729                                                                                                  Vector3(r[0], r[1], r[2])); 
    697730         
     731 
    698732        direction = UniformRandomVector(r[3], r[4]); 
    699733         
    … …  
    727761  mRays[index].mSamples++; 
    728762  mLastIndex = index; 
     763 
     764  mRays[index].mHalton.GetNext(4, r); 
    729765   
    730766  Vector3 v; 
    … …  
    732768  Vector3 d = ray->GetDir(); 
    733769  if (d.DrivingAxis() == 0) 
    734         v = Vector3(0, r[1]-0.5f, r[2]-0.5f); 
     770        v = Vector3(0, r[0]-0.5f, r[1]-0.5f); 
    735771  else 
    736772        if (d.DrivingAxis() == 1) 
    737           v = Vector3(r[1]-0.5f, 0, r[2]-0.5f); 
     773          v = Vector3(r[0]-0.5f, 0, r[1]-0.5f); 
    738774        else 
    739           v = Vector3(r[1]-0.5f, r[2]-0.5f, 0); 
     775          v = Vector3(r[0]-0.5f, r[1]-0.5f, 0); 
    740776 
    741777  v=v*mOriginMutationSize; 
    … …  
    745781  // mutate the termination 
    746782  if (d.DrivingAxis() == 0) 
    747         v = Vector3(0, r[3]-0.5f, r[4]-0.5f); 
     783        v = Vector3(0, r[2]-0.5f, r[3]-0.5f); 
    748784  else 
    749785        if (d.DrivingAxis() == 1) 
    750           v = Vector3(r[3]-0.5f, 0, r[4]-0.5f); 
     786          v = Vector3(r[2]-0.5f, 0, r[3]-0.5f); 
    751787        else 
    752           v = Vector3(r[3]-0.5f, r[4]-0.5f, 0); 
    753  
    754   float size = 1.5f*Magnitude(ray->mTerminationObject->GetBox().Diagonal()); 
     788          v = Vector3(r[2]-0.5f, r[3]-0.5f, 0); 
     789 
     790  AxisAlignedBox3 box = ray->mTerminationObject->GetBox(); 
     791  float size = 2.0f*Magnitude(box.Diagonal()); 
    755792  if (size < Limits::Small) 
    756793        return false; 
    … …  
    767804  v = v*size; 
    768805 
    769   Vector3 termination = ray->mTermination + v; 
     806  //  Vector3 termination = ray->mTermination + v; 
     807  Vector3 termination = box.Center() + v; 
    770808   
    771809  Vector3 direction = termination - origin; 
    … …  
    775813 
    776814  // shift the origin a little bit 
    777   origin += direction*0.05f; 
    778  
     815  origin += direction*0.5f; 
     816   
    779817  direction.Normalize(); 
    780818   
    … …  
    786824} 
    787825 
    788 MutationBasedDistribution::MutationBasedDistribution(Preprocessor &preprocessor) : 
     826MutationBasedDistribution::MutationBasedDistribution(Preprocessor &preprocessor 
     827                                                                                                         ) : 
    789828  SamplingStrategy(preprocessor) 
    790829{ 
    791830  mType = MUTATION_BASED_DISTRIBUTION; 
    792831  mBufferStart = 0; 
    793   mMaxRays = 1000000; 
    794  
    795   mOriginMutationSize = 2.0f; 
     832  mMaxRays = 500000; 
     833  mRays.reserve(mMaxRays); 
     834  mOriginMutationSize = 10.0f; 
    796835  mLastIndex = 0; 
    797836  //  mOriginMutationSize = Magnitude(preprocessor.mViewCellsManager-> 

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

    r1964 r1966  
    7979   
    8080  int mTotalRays; 
     81  int mGeneratedRays; 
    8182  float mTotalContribution; 
    8283   
    … …  
    231232private: 
    232233  virtual bool GenerateSample(SimpleRay &ray); 
    233   static HaltonSequence sHalton; 
     234 
    234235  struct RayEntry { 
     236        // halton sequence for generatin gmutations of this ray 
    235237        VssRay *mRay; 
    236238        int mSamples; 
    237         RayEntry(); 
    238         RayEntry(VssRay *r):mRay(r), mSamples(0) {} 
     239        HaltonSequence mHalton; 
     240 
     241        RayEntry() {} 
     242        RayEntry(VssRay *r):mRay(r), mSamples(0), mHalton() {} 
    239243  }; 
    240244   
    … …  
    296300  // container for the distributions 
    297301  vector<SamplingStrategy *> mDistributions; 
    298  
     302   
    299303  MixtureDistribution(Preprocessor &preprocessor): 
    300304        SamplingStrategy(preprocessor) 
    … …  
    330334        return false; 
    331335  } 
    332  
     336   
     337  virtual int GenerateSamples(const int number, SimpleRayContainer &rays); 
     338   
    333339private: 
    334340 

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

    r1952 r1966  
    697697        int histoMaxVal; 
    698698        Environment::GetSingleton()->GetIntValue("Preprocessor.histogram.maxValue", histoMaxVal); 
    699         maxRenderCost = max((float)histoMaxVal, maxRenderCost); 
     699        maxRenderCost = min((float)histoMaxVal, maxRenderCost); 
    700700 
    701701         
    … …  
    20392039                  PvsFilterStatistics fstat = ApplyFilter2(viewcell, 
    20402040                                                                                                   false, 
    2041                                                                                                    4.0f, 
     2041                                                                                                   1.0f, 
    20422042                                                                                                   filteredPvs); 
    20432043                   
    … …  
    23052305        {        
    23062306          // copy viewcells memory efficiently 
     2307#if VSS_STORE_VIEWCELLS 
    23072308          ray.mViewCells.reserve(viewCells.size()); 
    23082309          ray.mViewCells = viewCells; 
     2310#else 
     2311          cerr<<"Vss store viewcells not supported."<<endl; 
     2312          exit(1); 
     2313#endif 
    23092314        } 
    23102315 
    … …  
    29662971#else 
    29672972          radius = 0.5f*globalRadius + 0.5f*localRadius; 
    2968           stats.mLocalFilterCount++; 
    2969           stats.mGlobalFilterCount++; 
     2973 
     2974          if (localRadius > globalRadius)  
     2975                stats.mLocalFilterCount++; 
     2976          else 
     2977                stats.mGlobalFilterCount++; 
    29702978#endif 
    29712979           

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

    r1883 r1966  
    2929{ 
    3030  // this should increase coherence of the samples 
    31   Environment::GetSingleton()->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass); 
    32   Environment::GetSingleton()->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples); 
    33   Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamples", mVssSamples); 
    34   Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass); 
     31  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass); 
     32  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples); 
     33  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamples", mVssSamples); 
     34  //  Environment::GetSingleton()->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass); 
    3535  Environment::GetSingleton()->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling); 
    3636  

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

    r1942 r1966  
    2626    mFlags(0), 
    2727        mPass(pass), 
     28#if VSS_STORE_VIEWCELLS 
    2829        mViewCells(0), 
     30#endif 
    2931        mWeightedPvsContribution(0), 
    3032        mPdf(pdf), 
    … …  
    4345        mOriginObject(ray.sourceObject.mObject), 
    4446        mPass(0), 
     47#if VSS_STORE_VIEWCELLS 
    4548        mViewCells(0), 
     49#endif 
    4650        mPdf(1.0f), 
    4751        mTerminationNode(NULL), 

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

    r1900 r1966  
    1515 
    1616#define ABS_CONTRIBUTION_WEIGHT 0.0f 
    17  
     17#define VSS_STORE_VIEWCELLS 1 
     18   
    1819class VssRay { 
    1920public: 
    … …  
    5960  Intersectable *mTerminationObject; 
    6061 
     62#if VSS_STORE_VIEWCELLS 
    6163  ViewCellContainer mViewCells; 
    62    
     64#endif 
    6365 
    6466  //////////////////////// 

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

    r1952 r1966  
    3737 
    3838Preprocessor { 
     39        totalSamples 250000000 
     40        samplesPerPass 1000000 
     41#       initialSamples 2000000 
     42        samplesPerEvaluation 5000000 
     43 
    3944        delayVisibilityComputation false 
    4045        # stored sample rays 
    … …  
    6974        histogram { 
    7075                intervals 20 
    71                 maxValue  1000 
     76                maxValue  600000 
    7277            file        histogram.log 
    7378        } 
    7479        Export { 
    75                 rays false 
     80                rays true 
    7681                numRays 5000 
    7782        } 
    … …  
    8994 
    9095SamplingPreprocessor { 
    91         totalSamples 100000000 
    92         samplesPerPass 5000000 
    9396} 
    9497 
    … …  
    98101#       distributions rss+spatial+object_direction 
    99102#       distributions rss+object_direction+spatial+object+direction 
    100         distributions object_direction+spatial+object+direction 
     103        distributions mutation+spatial+object_direction 
    101104#       distributions rss+object_direction 
    102105#       distributions object_direction 
    103106 
    104         samplesPerPass 1000000 
    105         initialSamples 2000000 
    106         vssSamples 500000000 
    107         vssSamplesPerPass 5000000 
    108107        useImportanceSampling true 
    109108 

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

    r1942 r1966  
    2929VIEWCELLS=../data/vienna/vienna_cropped-gradient-viewcells.xml.gz 
    3030 
    31 PREFIX=../work/plots/osp-rss2-1e5 
     31PREFIX=../work/plots/osp2-1e5 
    3232 
    3333#SCENE=../data/atlanta/atlanta2.x3d 
    … …  
    3535 
    3636 
    37 #$COMMAND -preprocessor=sampling -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    38 #-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-reference.log \ 
    39 #-preprocessor_histogram_file=$PREFIX-r-reference.hlog 
    4037 
    41  
    42 #$COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    43 #-rss_update_subdivision+ -rss_split=hybrid -hybrid_depth=10 \ 
    44 #-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-i-combined-update-ccb12-nn.log \ 
    45 #-preprocessor_histogram_file=$PREFIX-i-combined-update-ccb12-nn.hlog 
     38$COMMAND -preprocessor=sampling -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
     39-preprocessor_visibility_file=$PREFIX-r-reference.xml \ 
     40-view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-reference.log \ 
     41-preprocessor_histogram_file=$PREFIX-r-reference.hlog 
    4642 
    4743# $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    48 # -rss_update_subdivision- -rss_split=hybrid -hybrid_depth=10 \ 
    49 # -view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-i-combined-ccb12-nn.log \ 
    50 # -preprocessor_histogram_file=$PREFIX-i-combined-ccb12-nn22.hlog 
    51  
    52  
    53 # ####### 
    54 # ####### 
    55 # $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    56 # -rss_use_importance- -rss_object_based_sampling- -rss_directional_sampling+ \ 
    57 # -view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-directional-based-b3.log \ 
    58 # -preprocessor_histogram_file=$PREFIX-r-directional-based-b3.hlog 
     44# -rss_distributions=direction -view_cells_filter_max_size=1 \ 
     45# -preprocessor_visibility_file=$PREFIX-r-reference-global.xml \ 
     46# -preprocessor_stats=$PREFIX-r-reference-global.log \ 
     47# -preprocessor_histogram_file=$PREFIX-r-reference-global.hlog 
    5948 
    6049# $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    61 # -rss_use_importance- -rss_object_based_sampling- -rss_directional_sampling- \ 
    62 # -view_cells_filter_max_size=1 -preprocessor_stats=$PREFIX-r-spatial-based-bb3.log \ 
    63 # -preprocessor_histogram_file=$PREFIX-r-spatial-based-bb3.hlog 
    64  
    65  
    66 $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    67 -rss_distributions=rss+object_direction+spatial+object+direction -view_cells_filter_max_size=1 \ 
    68 -preprocessor_stats=$PREFIX-i-mixed-b1-n4.log \ 
    69 -preprocessor_histogram_file=$PREFIX-i-mixed-b1-n4.hlog 
     50# -rss_distributions=mutation+object_direction+spatial -view_cells_filter_max_size=1 \ 
     51# -preprocessor_visibility_file=$PREFIX-i-mixed-b1-n4c.xml \ 
     52# -preprocessor_stats=$PREFIX-i-mixed-b1-n4c.log \ 
     53# -preprocessor_histogram_file=$PREFIX-i-mixed-b1-n4c.hlog 
    7054 
    7155# $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    … …  
    7559 
    7660 
    77 # $COMMAND -scene_filename=$SCENE -view_cells_filename=$VIEWCELLS \ 
    78 #  -rss_use_importance+ -rss_use_rss_tree- -view_cells_filter_max_size=1 \ 
    79 #  -rss_initial_samples=500000 -rss_vss_samples_per_pass=500000 -preprocessor_ray_cast_method=0 \ 
    80 #   -preprocessor_stats=$PREFIX-i-global-b1.log \ 
    81 #  -preprocessor_histogram_file=$PREFIX-i-global-b1.hlog 
    8261 
Note: See TracChangeset for help on using the changeset viewer.