Changeset 438 for trunk/VUT


Ignore:
Timestamp:
11/28/05 20:08:24 (19 years ago)
Author:
bittner
Message:

vss updates

Location:
trunk/VUT/GtpVisibilityPreprocessor/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

    r434 r438  
    14421442  RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1"); 
    14431443  RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10"); 
    1444         RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95"); 
    1445         RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5"); 
    1446  
    1447         RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6"); 
     1444  RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95"); 
     1445  RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5"); 
     1446 
     1447  RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6"); 
    14481448  RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0"); 
    14491449  RegisterOption("VssTree.randomize", optBool, "randomize", "false"); 
    … …  
    14701470  RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000"); 
    14711471  RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4"); 
     1472 
     1473  RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true"); 
     1474 
     1475  RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10"); 
     1476 
     1477 
    14721478} 
    14731479 

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

    r434 r438  
    4949  ExportKdTree(const KdTree &tree) = 0; 
    5050 
    51         virtual bool 
     51  virtual bool 
    5252  ExportVssTree(const VssTree &tree) = 0; 
     53 
     54  virtual bool 
     55  ExportVssTree2(const VssTree &tree, 
     56                                 const Vector3 direction 
     57                                 ) = 0; 
    5358 
    5459  virtual bool 

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

    r437 r438  
    236236 
    237237  if (mViewSpaceBox) { 
    238         exporter->SetForcedMaterial(RgbColor(1,0,0)); 
     238        exporter->SetForcedMaterial(RgbColor(1,0,1)); 
    239239        exporter->ExportBox(*mViewSpaceBox); 
    240240        exporter->ResetForcedMaterial(); 
    … …  
    257257bool 
    258258VssPreprocessor::ExportVssTree(char *filename, 
    259                                                            VssTree *tree) 
     259                                                           VssTree *tree, 
     260                                                           const Vector3 &dir 
     261                                                           ) 
    260262{ 
    261263  Exporter *exporter = Exporter::GetExporter(filename); 
    262264  exporter->SetFilled(); 
    263265  exporter->ExportScene(mSceneGraph->mRoot); 
    264   exporter->SetWireframe(); 
    265   bool result = exporter->ExportVssTree(*tree); 
     266  //  exporter->SetWireframe(); 
     267  bool result = exporter->ExportVssTree2( *tree, dir ); 
    266268  delete exporter; 
    267269  return result; 
    … …  
    471473  vssTree->Construct(mVssRays, mViewSpaceBox); 
    472474  cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl; 
    473  
    474   ExportVssTree("vss-tree.x3d", vssTree); 
     475   
     476  ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0)); 
     477  ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(1,0,0)); 
     478  ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1)); 
     479  ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1)); 
    475480 
    476481  ExportVssTreeLeaves(vssTree, 10); 

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

    r434 r438  
    8888  bool 
    8989  ExportVssTree(char *filename, 
    90                                 VssTree *tree); 
     90                                VssTree *tree, 
     91                                const Vector3 &dir 
     92                                ); 
    9193 
    9294 

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

    r382 r438  
    99bool 
    1010VssRay::ComputeMinMaxT(const AxisAlignedBox3 &box, 
    11                                                                                                                         float &tmin, 
    12                                                                                                                         float &tmax) const 
     11                                           float &tmin, 
     12                                           float &tmax) const 
    1313{ 
    1414         
    … …  
    144144 
    145145float 
     146VssRay::GetDirParam(const int axis, const Vector3 dir) 
     147{ 
     148  return (axis == 0) ? atan2(dir.x, dir.z) : asin(dir.y); 
     149} 
     150 
     151float 
    146152VssRay::GetDirParametrization(const int axis) const 
    147153{ 
    148         float angle; 
    149         Vector3 dir = GetNormalizedDir(); 
    150         if (axis == 0) { 
    151                 angle = atan2(dir.x, dir.z); 
    152         } else { 
    153                 angle = asin(dir.y); 
    154         } 
    155         return angle; 
     154  Vector3 dir = GetNormalizedDir(); 
     155  return GetDirParam(axis, dir); 
    156156} 

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

    r434 r438  
    1212class VssRay { 
    1313public: 
    14         // various flags 
     14  // various flags 
    1515  enum { 
    1616    FPosDirX = 1,  // the direction of ray in X-axis is positive 
    … …  
    1919  }; 
    2020 
    21         static int mailID; 
     21  static int mailID; 
    2222  int mMailbox; 
    2323         
    24         // side of the ray - used for the ray classification 
    25         //  char mSide; 
    26          
    27         // computed t 
     24  // side of the ray - used for the ray classification 
     25  //  char mSide; 
     26         
     27  // computed t 
    2828  float mT; 
    2929 
    30         // inverse of the ray size 
    31         float mInvSize; 
    32          
    33         // counter of references to this ray 
     30  // inverse of the ray size 
     31  float mInvSize; 
     32   
     33  // counter of references to this ray 
    3434  short mRefCount; 
    35  
    36         // various flags 
     35   
     36  // various flags 
    3737  char mFlags; 
    3838         
    … …  
    4040  Vector3 mTermination; 
    4141         
    42         /// Termination object for the ray 
    43         /// only the termination object is actually used 
    44         Intersectable *mOriginObject; 
    45         Intersectable *mTerminationObject; 
    46          
    47         ////////////////////////////// 
    48         VssRay(const Vector3 &origin, 
    49                                 const Vector3 &termination, 
    50                                 Intersectable *originObject, 
    51                                 Intersectable *terminationObject): 
    52                 mMailbox(-1), 
     42  /// Termination object for the ray 
     43  /// only the termination object is actually used 
     44  Intersectable *mOriginObject; 
     45  Intersectable *mTerminationObject; 
     46         
     47  ////////////////////////////// 
     48  VssRay(const Vector3 &origin, 
     49                const Vector3 &termination, 
     50                Intersectable *originObject, 
     51                Intersectable *terminationObject): 
     52        mMailbox(-1), 
    5353    mOrigin(origin), 
    5454    mTermination(termination), 
    55                 mOriginObject(originObject), 
    56                 mTerminationObject(terminationObject), 
    57                 mRefCount(0), 
     55        mOriginObject(originObject), 
     56        mTerminationObject(terminationObject), 
     57        mRefCount(0), 
    5858    mFlags(0), 
    5959        mT(1.0f) 
    60         { 
     60  { 
    6161    Precompute(); 
    6262  } 
    6363         
    64         VssRay(const Ray &ray): 
    65                 mRefCount(0), 
    66                 mFlags(0), 
    67                 mMailbox(-1), 
    68                 mOriginObject(ray.sourceObject.mObject), 
    69                 mT(1.0f) 
    70         { 
    71                 if (ray.sourceObject.mObject) 
    72                         mOrigin = ray.Extrap(ray.sourceObject.mT); 
    73                 else 
    74                         mOrigin = ray.GetLoc();  
    75  
    76                 //Debug << "origin: " << mOrigin << endl; 
    77  
    78                 if (!ray.intersections.empty()) 
    79                 { 
    80                         mTermination = ray.Extrap(ray.intersections[0].mT); 
    81                         mTerminationObject = ray.intersections[0].mObject; 
    82                 } 
    83                 else 
    84                 { 
    85                         mTermination = ray.Extrap(1e6);//TODO: should be Limits::Infinity 
    86                         mTerminationObject = NULL; 
    87                 } 
    88  
    89                 Precompute(); 
    90         } 
     64  VssRay(const Ray &ray): 
     65        mRefCount(0), 
     66        mFlags(0), 
     67        mMailbox(-1), 
     68        mOriginObject(ray.sourceObject.mObject), 
     69        mT(1.0f) 
     70  { 
     71        if (ray.sourceObject.mObject) 
     72          mOrigin = ray.Extrap(ray.sourceObject.mT); 
     73        else 
     74          mOrigin = ray.GetLoc();  
     75 
     76        //Debug << "origin: " << mOrigin << endl; 
     77 
     78        if (!ray.intersections.empty()) 
     79          { 
     80                mTermination = ray.Extrap(ray.intersections[0].mT); 
     81                mTerminationObject = ray.intersections[0].mObject; 
     82          } 
     83        else 
     84          { 
     85                mTermination = ray.Extrap(1e6);//TODO: should be Limits::Infinity 
     86                mTerminationObject = NULL; 
     87          } 
     88 
     89        Precompute(); 
     90  } 
    9191 
    9292  void Precompute() { 
    9393    mFlags = 0; 
    94                 Vector3 dir = GetDir(); 
     94        Vector3 dir = GetDir(); 
    9595 
    9696#define BIDIRECTIONAL_RAY 0 
    9797#if BIDIRECTIONAL_RAY 
    98                 if (dir.y < 0) { 
    99                         // swap objects and poits        
    100                         swap(mOriginObject, mTerminationObject); 
    101                         swap(mOrigin, mTermination); 
    102                         dir = -dir; 
    103                 } 
     98        if (dir.y < 0) { 
     99          // swap objects and poits      
     100          swap(mOriginObject, mTerminationObject); 
     101          swap(mOrigin, mTermination); 
     102          dir = -dir; 
     103        } 
    104104#endif 
    105                 if (dir.x > 0.0f) mFlags |= FPosDirX; 
     105        if (dir.x > 0.0f) mFlags |= FPosDirX; 
    106106    if (dir.y > 0.0f) mFlags |= FPosDirY; 
    107107    if (dir.z > 0.0f) mFlags |= FPosDirZ; 
    … …  
    118118  } 
    119119 
    120         int HitCount() const { 
     120  int HitCount() const { 
    121121#if BIDIRECTIONAL_RAY 
    122                 if (mOriginObject && mTerminationObject) 
    123                         return 2; 
    124                 if (mOriginObject || mTerminationObject) 
    125                         return 1; 
    126                 return 0; 
     122        if (mOriginObject && mTerminationObject) 
     123          return 2; 
     124        if (mOriginObject || mTerminationObject) 
     125          return 1; 
     126        return 0; 
    127127#else 
    128                 return (mTerminationObject) ? 1 : 0; 
     128        return (mTerminationObject) ? 1 : 0; 
    129129#endif 
    130         } 
    131          
    132         Vector3 GetOrigin() const { return mOrigin; } 
     130  } 
     131         
     132  Vector3 GetOrigin() const { return mOrigin; } 
    133133  Vector3 GetTermination() const { return mTermination; } 
    134134  Vector3 GetDir() const { return mTermination - mOrigin; } 
    … …  
    136136  Vector3 GetNormalizedDir() const { return (mTermination - mOrigin)*mInvSize; } 
    137137 
    138         Vector3 Extrap(const float t) const { 
    139                 return GetOrigin() + t * GetDir(); 
    140         } 
    141          
    142         float GetDirParametrization(const int axis) const; 
    143          
    144         float GetInvSize() const { return  mInvSize; } 
     138  Vector3 Extrap(const float t) const { 
     139        return GetOrigin() + t * GetDir(); 
     140  } 
     141         
     142  float GetDirParametrization(const int axis) const; 
     143 
     144  static float VssRay::GetDirParam(const int axis, const Vector3 dir); 
     145 
     146  float GetSize() const { return  1.0f/mInvSize; } 
     147  float GetInvSize() const { return  mInvSize; } 
    145148  float GetOrigin(const int axis) const { return mOrigin[axis]; } 
    146149  float GetTermination(const int axis) const { return mTermination[axis]; } 
    … …  
    152155  bool 
    153156  ComputeMinMaxT(const AxisAlignedBox3 &box, 
    154                                                                 float &tmin, 
    155                                                                 float &tmax) const; 
     157                                float &tmin, 
     158                                float &tmax) const; 
    156159         
    157160  bool 
    158161  Intersects(const AxisAlignedBox3 &box, 
    159                                                 float &tmin, 
    160                                                 float &tmax) const; 
     162                        float &tmin, 
     163                        float &tmax) const; 
    161164         
    162165  bool 
    163166  IntersectsSphere(const Vector3 &center, 
    164                                                                         const float sqrRadius, 
    165                                                                         Vector3 &point, 
    166                                                                         float &t) const; 
     167                                  const float sqrRadius, 
     168                                  Vector3 &point, 
     169                                  float &t) const; 
    167170         
    168171  void 
    … …  
    172175  } 
    173176 
    174         void SetupEndPoints(const Vector3 &origin, 
    175                                                                                         const Vector3 &termination) 
    176         { 
    177                 mOrigin = origin; 
    178                 mTermination = termination; 
    179                 Precompute(); 
    180         } 
     177  void SetupEndPoints(const Vector3 &origin, 
     178                                          const Vector3 &termination) 
     179  { 
     180        mOrigin = origin; 
     181        mTermination = termination; 
     182        Precompute(); 
     183  } 
    181184                                                                                         
    182185  bool HasPosDir(const int axis) const { return mFlags & (1<<axis); } 
    … …  
    198201    else 
    199202      if (mRefCount < 0) 
    200                                 mRefCount++; 
     203                mRefCount++; 
    201204      else { 
    202                                 cerr<<"Trying to unref already deleted ray!"<<endl; 
    203                                 exit(1); 
     205                cerr<<"Trying to unref already deleted ray!"<<endl; 
     206                exit(1); 
    204207      } 
    205208  } 
    206209 
    207         static Vector3 
    208         GetDirection(const float a, const float b) { 
    209                 return Vector3(sin(a), sin(b), cos(a)); 
    210         } 
     210  static Vector3 
     211  GetDirection(const float a, const float b) { 
     212        return Vector3(sin(a), sin(b), cos(a)); 
     213  } 
    211214 
    212215}; 

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

    r435 r438  
    2525#include "Ray.h" 
    2626 
     27#define DEBUG_SPLIT_COST 0 
    2728 
    2829// Static variables 
    … …  
    119120  environment->GetBoolValue("VssTree.splitUseOnlyDrivingAxis", mSplitUseOnlyDrivingAxis); 
    120121  environment->GetBoolValue("VssTree.useRss", mUseRss); 
    121          
     122 
     123  environment->GetBoolValue("VssTree.interleaveDirSplits", mInterleaveDirSplits); 
     124  environment->GetIntValue("VssTree.dirSplitDepth", mDirSplitDepth); 
     125 
    122126  root = NULL; 
    123127   
    … …  
    230234        mPvsSize = pvsSize; 
    231235        mValidPvs = true; 
     236 
    232237  } 
    233238} 
    … …  
    316321  stat.rays = leaf->rays.size(); 
    317322  leaf->UpdatePvsSize(); 
     323  leaf->ComputeEntropyImportance(); 
     324 
    318325  stat.initialPvsSize = leaf->GetPvsSize(); 
    319326  // Subdivide(); 
    … …  
    478485                                                        pvsFront 
    479486                                                        ); 
    480  
     487#if DEBUG_SPLIT_COST 
    481488  cout<<axis<<" r="<<costRatio<<endl; 
    482          
     489#endif 
    483490  if (costRatio > termMaxCostRatio) { 
    484491        //              cout<<"Too big cost ratio "<<costRatio<<endl; 
    … …  
    675682  bool allowDirSplit = Magnitude(sBox.Size())*dirSplitBoxSize < Magnitude(bbox.Size()); 
    676683                 
    677  
    678   for (axis = 0; axis < 5; axis++) { 
    679         if (!mSplitUseOnlyDrivingAxis || axis == sAxis || axis == dAxis) { 
    680  
    681  
    682           if (splitType == ESplitRegular) { 
    683                 if (axis < 3) 
    684                   nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f; 
     684   
     685  for (axis = 0; axis < 5; axis++) 
     686        if (mInterleaveDirSplits || 
     687                (axis < 3 && leaf->depth < mDirSplitDepth) || 
     688                (axis >= 3 && leaf->depth >= mDirSplitDepth) 
     689                ) { 
     690          if (!mSplitUseOnlyDrivingAxis || axis == sAxis || axis == dAxis) { 
     691                 
     692                 
     693                if (splitType == ESplitRegular) { 
     694                  if (axis < 3) 
     695                        nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f; 
     696                  else 
     697                        nPosition[axis] = (dBox.Min()[axis-3] + dBox.Max()[axis-3])*0.5f; 
     698                   
     699                  nCostRatio[axis] = EvalCostRatio(leaf, 
     700                                                                                   axis, 
     701                                                                                   nPosition[axis], 
     702                                                                                   nRaysBack[axis], 
     703                                                                                   nRaysFront[axis], 
     704                                                                                   nPvsBack[axis], 
     705                                                                                   nPvsFront[axis] 
     706                                                                                   ); 
     707                } else 
     708                  if (splitType == ESplitHeuristic) { 
     709                        nCostRatio[axis] = EvalCostRatioHeuristic( 
     710                                                                                                          leaf, 
     711                                                                                                          axis, 
     712                                                                                                          nPosition[axis], 
     713                                                                                                          nRaysBack[axis], 
     714                                                                                                          nRaysFront[axis], 
     715                                                                                                          nPvsBack[axis], 
     716                                                                                                          nPvsFront[axis]); 
     717                  } else 
     718                        if (splitType == ESplitHybrid) { 
     719                          if (leaf->depth > 7) 
     720                                nCostRatio[axis] = EvalCostRatioHeuristic( 
     721                                                                                                                  leaf, 
     722                                                                                                                  axis, 
     723                                                                                                                  nPosition[axis], 
     724                                                                                                                  nRaysBack[axis], 
     725                                                                                                                  nRaysFront[axis], 
     726                                                                                                                  nPvsBack[axis], 
     727                                                                                                                  nPvsFront[axis]); 
     728                          else { 
     729                                if (axis < 3) 
     730                                  nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f; 
     731                                else 
     732                                  nPosition[axis] = (dBox.Min()[axis-3] + dBox.Max()[axis-3])*0.5f; 
     733                                 
     734                                nCostRatio[axis] = EvalCostRatio(leaf, 
     735                                                                                                 axis, 
     736                                                                                                 nPosition[axis], 
     737                                                                                                 nRaysBack[axis], 
     738                                                                                                 nRaysFront[axis], 
     739                                                                                                 nPvsBack[axis], 
     740                                                                                                 nPvsFront[axis] 
     741                                                                                                 ); 
     742                          } 
     743                        } else { 
     744                          cerr<<"VssTree: Unknown split heuristics\n"; 
     745                          exit(1); 
     746                        } 
     747                 
     748                 
     749                if ( bestAxis == -1) 
     750                  bestAxis = axis; 
    685751                else 
    686                   nPosition[axis] = (dBox.Min()[axis-3] + dBox.Max()[axis-3])*0.5f; 
    687                                  
    688                 nCostRatio[axis] = EvalCostRatio(leaf, 
    689                                                                                  axis, 
    690                                                                                  nPosition[axis], 
    691                                                                                  nRaysBack[axis], 
    692                                                                                  nRaysFront[axis], 
    693                                                                                  nPvsBack[axis], 
    694                                                                                  nPvsFront[axis] 
    695                                                                                  ); 
    696           } else 
    697                 if (splitType == ESplitHeuristic) { 
    698                   nCostRatio[axis] = EvalCostRatioHeuristic( 
    699                                                                                                         leaf, 
    700                                                                                                         axis, 
    701                                                                                                         nPosition[axis], 
    702                                                                                                         nRaysBack[axis], 
    703                                                                                                         nRaysFront[axis], 
    704                                                                                                         nPvsBack[axis], 
    705                                                                                                         nPvsFront[axis]); 
    706                 } else 
    707                   if (splitType == ESplitHybrid) { 
    708                         if (leaf->depth > 7) 
    709                           nCostRatio[axis] = EvalCostRatioHeuristic( 
    710                                                                                                                 leaf, 
    711                                                                                                                 axis, 
    712                                                                                                                 nPosition[axis], 
    713                                                                                                                 nRaysBack[axis], 
    714                                                                                                                 nRaysFront[axis], 
    715                                                                                                                 nPvsBack[axis], 
    716                                                                                                                 nPvsFront[axis]); 
    717                         else { 
    718                           if (axis < 3) 
    719                                 nPosition[axis] = (sBox.Min()[axis] + sBox.Max()[axis])*0.5f; 
    720                           else 
    721                                 nPosition[axis] = (dBox.Min()[axis-3] + dBox.Max()[axis-3])*0.5f; 
    722                                                          
    723                           nCostRatio[axis] = EvalCostRatio(leaf, 
    724                                                                                            axis, 
    725                                                                                            nPosition[axis], 
    726                                                                                            nRaysBack[axis], 
    727                                                                                            nRaysFront[axis], 
    728                                                                                            nPvsBack[axis], 
    729                                                                                            nPvsFront[axis] 
    730                                                                                            ); 
    731                         } 
    732                   } else { 
    733                         cerr<<"VssTree: Unknown split heuristics\n"; 
    734                         exit(1); 
    735                   } 
    736                          
    737                                  
    738           if ( bestAxis == -1) 
    739                 bestAxis = axis; 
    740           else 
    741                 if ( nCostRatio[axis] < nCostRatio[bestAxis] ) 
    742                   bestAxis = axis; 
    743         } 
    744   } 
    745  
     752                  if ( nCostRatio[axis] < nCostRatio[bestAxis] ) 
     753                        bestAxis = axis; 
     754          } 
     755        } 
     756   
    746757  axis = bestAxis; 
    747758  position = nPosition[bestAxis]; 
    … …  
    775786        minBox = box.Min(axis); 
    776787        maxBox = box.Max(axis); 
    777   } 
    778   else { 
     788  } else { 
    779789        box = GetDirBBox(leaf); 
    780790        minBox = box.Min(axis-3); 
    … …  
    11111121  front->SetPvsSize(pvsFront); 
    11121122  back->SetPvsSize(pvsBack); 
    1113  
     1123  // compute entropy as well 
     1124  front->ComputeEntropyImportance(); 
     1125  back->ComputeEntropyImportance(); 
     1126   
    11141127  // update stats 
    11151128  stat.rayRefs -= leaf->rays.size(); 
    … …  
    18321845VssTreeLeaf::GetImportance()  const 
    18331846{ 
    1834   return GetAvgRayContribution(); 
    1835 } 
     1847 
     1848  if (1) { 
     1849        //      return GetAvgRayContribution(); 
     1850        return GetPvsSize(); 
     1851  } else { 
     1852        return GetAvgRayContribution()*mEntropyImportance; 
     1853  } 
     1854} 
     1855 
     1856 
     1857float 
     1858VssTreeLeaf::ComputePvsEntropy() 
     1859{ 
     1860  int samples = 0; 
     1861  Intersectable::NewMail(); 
     1862  // set all object as belonging to the fron pvs 
     1863  for(VssTreeNode::RayInfoContainer::iterator ri = rays.begin(); 
     1864          ri != rays.end(); 
     1865          ri++) 
     1866        if ((*ri).mRay->IsActive()) { 
     1867          Intersectable *object = (*ri).mRay->mTerminationObject; 
     1868          if (object) { 
     1869                if (!object->Mailed()) { 
     1870                  object->Mail(); 
     1871                  object->mCounter = 1; 
     1872                } else 
     1873                  object->mCounter++; 
     1874                samples++; 
     1875          } 
     1876        } 
     1877   
     1878  float entropy = 0.0f; 
     1879   
     1880  if (samples > 1) { 
     1881        Intersectable::NewMail(); 
     1882        for(RayInfoContainer::const_iterator ri = rays.begin(); 
     1883                ri != rays.end(); 
     1884                ri++)  
     1885          if ((*ri).mRay->IsActive()) { 
     1886                Intersectable *object = (*ri).mRay->mTerminationObject; 
     1887                if (object) { 
     1888                  if (!object->Mailed()) { 
     1889                        object->Mail(); 
     1890                        float p = object->mCounter/(float)samples; 
     1891                        entropy -= p*log(p); 
     1892                  } 
     1893                } 
     1894          } 
     1895        entropy = entropy/log((float)samples); 
     1896  } 
     1897  else 
     1898        entropy = 1.0f; 
     1899   
     1900  return entropy; 
     1901} 
     1902 
     1903float 
     1904VssTreeLeaf::ComputeRayLengthEntropy() 
     1905{ 
     1906  // get sum of all ray lengths 
     1907  // consider only passing rays or originating rays 
     1908  float sum = 0.0f; 
     1909  int samples = 0; 
     1910 
     1911  for(RayInfoContainer::const_iterator ri = rays.begin(); 
     1912      ri != rays.end(); 
     1913      ri++) { 
     1914        int rayClass = (*ri).GetRayClass(); 
     1915        if ( 
     1916                rayClass == RayInfo::PASSING_RAY 
     1917                //              || 
     1918                //              rayClass == RayInfo::SOURCE_RAY 
     1919                //              rayClass == RayInfo::TERMINATION_RAY 
     1920                ) { 
     1921          float c = 1.0f - (*ri).GetMaxT(); 
     1922          sum += (*ri).mRay->GetSize()*c; 
     1923          samples++; 
     1924        } 
     1925  } 
     1926   
     1927  float entropy = 0.0f; 
     1928   
     1929  if (samples > 1) { 
     1930        for(RayInfoContainer::const_iterator ri = rays.begin(); 
     1931                ri != rays.end(); 
     1932                ri++) { 
     1933          int rayClass = (*ri).GetRayClass(); 
     1934          if ( 
     1935                  rayClass == RayInfo::PASSING_RAY 
     1936                  //              || 
     1937                  //              rayClass == RayInfo::SOURCE_RAY 
     1938                  // rayClass == RayInfo::TERMINATION_RAY 
     1939                  ) { 
     1940                float c = 1.0f - (*ri).GetMaxT(); 
     1941                float p = (*ri).mRay->GetSize()*c/sum; 
     1942                entropy -= p*log(p); 
     1943          } 
     1944        } 
     1945        entropy = entropy/log((float)samples); 
     1946  } else 
     1947        entropy = 1.0f; 
     1948   
     1949  return entropy; 
     1950} 
     1951   
     1952float 
     1953VssTreeLeaf::ComputeRayTerminationEntropy() 
     1954{ 
     1955 
     1956  return 0.0f; 
     1957} 
     1958 
     1959 
     1960void 
     1961VssTreeLeaf::ComputeEntropyImportance() 
     1962{ 
     1963  //  mEntropy = 1.0f - ComputeRayLengthEntropy(); 
     1964  mEntropyImportance = 1.0f - ComputePvsEntropy(); 
     1965   
     1966  //  cout<<"ei="<<mEntropyImportance<<" "; 
     1967} 

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

    r435 r438  
    4444  // totals number of rays 
    4545  int rays; 
    46         // initial size of the pvs 
     46  // initial size of the pvs 
    4747  int initialPvsSize; 
    48         // total number of query domains 
     48  // total number of query domains 
    4949  int queryDomains; 
    5050  // total number of ray references 
    5151  int rayRefs; 
    5252 
    53         // max depth nodes 
     53  // max depth nodes 
    5454  int maxDepthNodes; 
    5555  // max depth nodes 
    5656  int minPvsNodes; 
    5757  int minRaysNodes; 
    58         // max ray contribution nodes 
     58  // max ray contribution nodes 
    5959  int maxRayContribNodes; 
    60         // max depth nodes 
     60  // max depth nodes 
    6161  int minSizeNodes; 
    6262  int maxCostRatioNodes; 
    … …  
    8989    maxRayRefs = 0; 
    9090    addedRayRefs = removedRayRefs = 0; 
    91                 initialPvsSize = 0; 
    92                 maxRayContribNodes = 0; 
    93                 minSizeNodes = 0; 
    94                 maxCostRatioNodes = 0; 
     91        initialPvsSize = 0; 
     92        maxRayContribNodes = 0; 
     93        minSizeNodes = 0; 
     94        maxCostRatioNodes = 0; 
    9595  } 
    9696 
    … …  
    123123  SortableEntry() {} 
    124124  SortableEntry(const int t, const float v, void *d):type(t), 
    125                                                                                                                                                                                                                 value(v), 
    126                                                                                                                                                                                                                 data(d) {} 
     125                                                                                                        value(v), 
     126                                                                                                        data(d) {} 
    127127         
    128128  friend bool operator<(const SortableEntry &a, const SortableEntry &b) { 
    … …  
    144144#define USE_FIXEDPOINT_T 0 
    145145 
    146 struct RayInfo 
    147 { 
     146  struct RayInfo 
     147  { 
    148148        // pointer to the actual ray 
    149149        VssRay *mRay; 
    … …  
    161161#if USE_FIXEDPOINT_T 
    162162#define FIXEDPOINT_ONE 0x7FFE 
    163                                                                                 //                       mMaxT(0xFFFF) 
    164                                                                                 mMaxT(FIXEDPOINT_ONE) 
     163                                          //                     mMaxT(0xFFFF) 
     164                                          mMaxT(FIXEDPOINT_ONE) 
    165165#else 
    166                 mMaxT(1.0f) 
     166          mMaxT(1.0f) 
    167167#endif 
    168168        {} 
    169169         
    170170        RayInfo(VssRay *r, 
    171                                         const float _min, 
    172                                         const float _max 
    173                                         ):mRay(r) { 
    174                 SetMinT(_min); 
    175                 SetMaxT(_max); 
     171                        const float _min, 
     172                        const float _max 
     173                        ):mRay(r) { 
     174          SetMinT(_min); 
     175          SetMaxT(_max); 
    176176        } 
    177177         
    178178        RayInfo(VssRay *r, 
    179                                         const short _min, 
    180                                         const float _max 
    181                                         ):mRay(r), mMinT(_min) { 
    182                 SetMaxT(_max); 
     179                        const short _min, 
     180                        const float _max 
     181                        ):mRay(r), mMinT(_min) { 
     182          SetMaxT(_max); 
    183183        } 
    184184         
    185185        RayInfo(VssRay *r, 
    186                                                                                 const float _min, 
    187                                                                                 const short _max 
    188                                                                                 ):mRay(r), mMaxT(_max) { 
    189                 SetMinT(_min); 
     186                        const float _min, 
     187                        const short _max 
     188                        ):mRay(r), mMaxT(_max) { 
     189          SetMinT(_min); 
    190190        } 
    191191 
    192192        enum { 
    193                                 SOURCE_RAY = 0, 
    194                                 TERMINATION_RAY, 
    195                                 PASSING_RAY, 
    196                                 CONTAINED_RAY 
     193          SOURCE_RAY = 0, 
     194          TERMINATION_RAY, 
     195          PASSING_RAY, 
     196          CONTAINED_RAY 
    197197        }; 
    198198         
    199199        int GetRayClass() const { 
    200200                 
    201                 bool startsBefore = GetMinT() > 0.0f; 
    202                 bool terminatesAfter = GetMaxT() < 1.0f; 
     201          bool startsBefore = GetMinT() > 0.0f; 
     202          bool terminatesAfter = GetMaxT() < 1.0f; 
    203203                 
    204                 if (startsBefore && terminatesAfter) 
    205                         return PASSING_RAY; 
    206  
    207                 if (!startsBefore && !terminatesAfter) 
    208                         return CONTAINED_RAY; 
     204          if (startsBefore && terminatesAfter) 
     205                return PASSING_RAY; 
     206 
     207          if (!startsBefore && !terminatesAfter) 
     208                return CONTAINED_RAY; 
    209209                 
    210                 if (!startsBefore) 
    211                         return SOURCE_RAY; 
     210          if (!startsBefore) 
     211                return SOURCE_RAY; 
    212212                 
    213                 return TERMINATION_RAY; 
     213          return TERMINATION_RAY; 
    214214        } 
    215215         
    216216        friend bool operator<(const RayInfo &a, const RayInfo &b) { 
    217                 return a.mRay < b.mRay; 
     217          return a.mRay < b.mRay; 
    218218        } 
    219219   
    220220         
    221221        float ExtrapOrigin(const int axis) const { 
    222                 return mRay->GetOrigin(axis) + GetMinT()*mRay->GetDir(axis); 
     222          return mRay->GetOrigin(axis) + GetMinT()*mRay->GetDir(axis); 
    223223        } 
    224224         
    225225        float ExtrapTermination(const int axis) const { 
    226                 return mRay->GetOrigin(axis) + GetMaxT()*mRay->GetDir(axis); 
     226          return mRay->GetOrigin(axis) + GetMaxT()*mRay->GetDir(axis); 
    227227        } 
    228228 
    229229        Vector3 Extrap(const float t) const { 
    230                 return mRay->Extrap(t); 
     230          return mRay->Extrap(t); 
    231231        } 
    232232         
    … …  
    236236         
    237237        void SetMinT (const float t) { 
    238                 mMinT = (short) (t*(float)(FIXEDPOINT_ONE)); 
     238          mMinT = (short) (t*(float)(FIXEDPOINT_ONE)); 
    239239        } 
    240240         
    241241        void SetMaxT (const float t) { 
    242                 mMaxT = (short) (t*(float)(FIXEDPOINT_ONE)); 
    243                 mMaxT++; 
    244                 //      if (mMaxT!=0xFFFF) 
    245                 //      mMaxT++; 
     242          mMaxT = (short) (t*(float)(FIXEDPOINT_ONE)); 
     243          mMaxT++; 
     244          //      if (mMaxT!=0xFFFF) 
     245          //    mMaxT++; 
    246246        } 
    247247#else 
    … …  
    254254 
    255255 
    256   int ComputeRayIntersection(const int axis, 
    257                                                                                                                 const float position, 
    258                                                                                                                 float &t 
    259                                                                                                                 ) const { 
     256        int ComputeRayIntersection(const int axis, 
     257                                                          const float position, 
     258                                                          float &t 
     259                                                          ) const { 
    260260                 
    261                 // intersect the ray with the plane 
    262     float denom = mRay->GetDir(axis); 
     261          // intersect the ray with the plane 
     262          float denom = mRay->GetDir(axis); 
    263263     
    264     if (fabs(denom) < 1e-20) 
    265       //if (denom == 0.0f) 
    266       return (mRay->GetOrigin(axis) > position) ? 1 : -1; 
     264          if (fabs(denom) < 1e-20) 
     265                //if (denom == 0.0f) 
     266                return (mRay->GetOrigin(axis) > position) ? 1 : -1; 
    267267     
    268     t = (position - mRay->GetOrigin(axis))/denom; 
    269  
    270     if (t < GetMinT()) 
    271       return (denom > 0) ? 1 : -1; 
    272  
    273     if (t > GetMaxT()) 
    274       return (denom > 0) ? -1 : 1; 
    275  
    276                 return 0; 
    277         } 
    278  
    279  
    280 }; 
    281  
    282  
    283         typedef vector<RayInfo> RayInfoContainer; 
     268          t = (position - mRay->GetOrigin(axis))/denom; 
     269 
     270          if (t < GetMinT()) 
     271                return (denom > 0) ? 1 : -1; 
     272 
     273          if (t > GetMaxT()) 
     274                return (denom > 0) ? -1 : 1; 
     275 
     276          return 0; 
     277        } 
     278 
     279 
     280  }; 
     281 
     282 
     283  typedef vector<RayInfo> RayInfoContainer; 
    284284         
    285285  enum { EInterior, ELeaf }; 
    … …  
    346346   
    347347  VssTreeInterior(VssTreeInterior *p):VssTreeNode(p), 
    348                                         back(NULL), 
    349                                         front(NULL), 
    350                                         accesses(0), 
    351                                         lastAccessTime(-1) 
     348                                                                          back(NULL), 
     349                                                                          front(NULL), 
     350                                                                          accesses(0), 
     351                                                                          lastAccessTime(-1) 
    352352  { } 
    353353 
    … …  
    383383    else 
    384384      if (axis == 1) 
    385         s<<"y "; 
     385                s<<"y "; 
    386386      else 
    387         s<<"z "; 
     387                s<<"z "; 
    388388    s<<position<<" "; 
    389389    back->Print(s); 
    … …  
    394394         
    395395  int ComputeRayIntersection(const RayInfo &rayData, 
    396                                                                                                                 float &t 
    397                                                                                                                 ) { 
    398                 return rayData.ComputeRayIntersection(axis, position, t); 
     396                                                        float &t 
     397                                                        ) { 
     398        return rayData.ComputeRayIntersection(axis, position, t); 
    399399  } 
    400400 
    … …  
    409409{ 
    410410private: 
    411         int mPvsSize; 
     411  int mPvsSize; 
    412412public: 
    413413  static int mailID; 
    … …  
    415415   
    416416  RayInfoContainer rays; 
    417         int mPassingRays; 
    418          
    419         bool mValidPvs; 
    420          
    421          
     417  int mPassingRays; 
     418         
     419  bool mValidPvs; 
     420  float mEntropyImportance; 
     421   
    422422         
    423423  VssTreeLeaf(VssTreeInterior *p, 
    424                                                         const int nRays 
    425                                                         ):VssTreeNode(p), rays(), mPvsSize(0), mPassingRays(0), mValidPvs(false) { 
     424                          const int nRays 
     425                          ):VssTreeNode(p), rays(), mPvsSize(0), mPassingRays(0), mValidPvs(false) { 
    426426    rays.reserve(nRays); 
    427427  } 
    … …  
    436436   
    437437  void AddRay(const RayInfo &data) { 
    438                 mValidPvs = false; 
     438        mValidPvs = false; 
    439439    rays.push_back(data); 
    440440    data.mRay->Ref(); 
    441                 if (data.GetRayClass() == RayInfo::PASSING_RAY) 
    442                         mPassingRays++; 
    443   } 
    444          
    445         int GetPvsSize() const { 
    446                 return mPvsSize; 
    447         } 
    448         void SetPvsSize(const int s) { 
    449                 mPvsSize = s; 
    450                 mValidPvs = true; 
    451         } 
    452  
    453         void 
    454         UpdatePvsSize(); 
     441        if (data.GetRayClass() == RayInfo::PASSING_RAY) 
     442          mPassingRays++; 
     443  } 
     444         
     445  int GetPvsSize() const { 
     446        return mPvsSize; 
     447  } 
     448 
     449  void SetPvsSize(const int s) { 
     450        mPvsSize = s; 
     451        mValidPvs = true; 
     452  } 
     453 
     454  void 
     455  UpdatePvsSize(); 
     456 
     457  float 
     458  ComputePvsEntropy(); 
     459   
     460  float 
     461  ComputeRayLengthEntropy(); 
     462   
     463  float 
     464  ComputeRayTerminationEntropy(); 
     465   
     466  void 
     467  ComputeEntropyImportance(); 
    455468 
    456469  void Mail() { mailbox = mailID; } 
    … …  
    462475  } 
    463476 
    464         float GetAvgRayContribution() const { 
    465                 return GetPvsSize()/((float)rays.size() + Limits::Small); 
    466         } 
     477  float GetAvgRayContribution() const { 
     478        return GetPvsSize()/((float)rays.size() + Limits::Small); 
     479  } 
    467480 
    468481  float GetImportance() const; 
    469  
    470         float GetSqrRayContribution() const { 
    471                 return sqr(GetPvsSize()/((float)rays.size() + Limits::Small)); 
    472         } 
    473  
    474         // comparator for the  
    475         struct less_contribution : public 
    476         binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
    477                  
    478                 bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
    479                         return a->GetAvgRayContribution() < b->GetAvgRayContribution(); 
    480                 } 
    481         }; 
    482  
    483         struct greater_contribution : public 
    484         binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
    485                  
    486                 bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
    487                         return a->GetAvgRayContribution() > b->GetAvgRayContribution(); 
    488                 } 
    489         }; 
    490          
    491         friend bool GreaterContribution(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
    492                 return a->GetAvgRayContribution() > b->GetAvgRayContribution(); 
    493         } 
    494          
     482   
     483  float GetSqrRayContribution() const { 
     484        return sqr(GetPvsSize()/((float)rays.size() + Limits::Small)); 
     485  } 
     486   
     487  // comparator for the  
     488  struct less_contribution : public 
     489  binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
     490         
     491        bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
     492          return a->GetAvgRayContribution() < b->GetAvgRayContribution(); 
     493        } 
     494  }; 
     495   
     496  struct greater_contribution : public 
     497  binary_function<const VssTreeLeaf *, const VssTreeLeaf *, bool> { 
     498         
     499        bool operator()(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
     500          return a->GetAvgRayContribution() > b->GetAvgRayContribution(); 
     501        } 
     502  }; 
     503   
     504  friend bool GreaterContribution(const VssTreeLeaf * a, const VssTreeLeaf *b) { 
     505        return a->GetAvgRayContribution() > b->GetAvgRayContribution(); 
     506  } 
     507   
    495508}; 
    496509 
    … …  
    521534 
    522535    TraversalData(VssTreeNode *n, 
    523                    const AxisAlignedBox3 &b, 
    524                    const int d): 
     536                                  const AxisAlignedBox3 &b, 
     537                                  const int d): 
    525538      node(n), bbox(b), depth(d) {} 
    526539     
    … …  
    531544                         
    532545      bool operator()(const TraversalData a, const TraversalData b) { 
    533                                 return a.priority < b.priority; 
     546                return a.priority < b.priority; 
    534547      } 
    535548       
    … …  
    540553     
    541554    friend bool operator<(const TraversalData &a, 
    542                                                                                                         const TraversalData &b) { 
     555                                                  const TraversalData &b) { 
    543556      //      return a.node->queries.size() < b.node->queries.size(); 
    544557      VssTreeLeaf *leafa = (VssTreeLeaf *) a.node; 
    545558      VssTreeLeaf *leafb = (VssTreeLeaf *) b.node; 
    546559#if 0 
    547                         return 
    548                                 leafa->rays.size()*a.bbox.GetVolume() 
    549                                 < 
    550                                 leafb->rays.size()*b.bbox.GetVolume(); 
     560          return 
     561                leafa->rays.size()*a.bbox.GetVolume() 
     562                < 
     563                leafb->rays.size()*b.bbox.GetVolume(); 
    551564#endif 
    552565#if 0 
    553                         return 
    554                                 leafa->GetPvsSize()*a.bbox.GetVolume() 
    555                                 < 
    556                                 leafb->GetPvsSize()*b.bbox.GetVolume(); 
     566          return 
     567                leafa->GetPvsSize()*a.bbox.GetVolume() 
     568                < 
     569                leafb->GetPvsSize()*b.bbox.GetVolume(); 
    557570#endif 
    558571#if 0 
    559                         return 
    560                                 leafa->GetPvsSize() 
    561                                 < 
    562                                 leafb->GetPvsSize(); 
     572          return 
     573                leafa->GetPvsSize() 
     574                < 
     575                leafb->GetPvsSize(); 
    563576#endif 
    564577#if 0 
    565                         return 
    566                                 leafa->GetPvsSize()/(leafa->rays.size()+1) 
    567                                 > 
    568                                 leafb->GetPvsSize()/(leafb->rays.size()+1); 
     578          return 
     579                leafa->GetPvsSize()/(leafa->rays.size()+1) 
     580                > 
     581                leafb->GetPvsSize()/(leafb->rays.size()+1); 
    569582#endif 
    570583#if 1 
    571                         return 
    572                                 leafa->GetPvsSize()*leafa->rays.size() 
    573                                 < 
    574                                 leafb->GetPvsSize()*leafb->rays.size(); 
     584          return 
     585                leafa->GetPvsSize()*leafa->rays.size() 
     586                < 
     587                leafb->GetPvsSize()*leafb->rays.size(); 
    575588#endif 
    576589    } 
    … …  
    586599    RayTraversalData() {} 
    587600    RayTraversalData(VssTreeNode *n, 
    588                                                                                 const VssTreeNode::RayInfo &data): 
     601                                        const VssTreeNode::RayInfo &data): 
    589602      rayData(data), node(n) {} 
    590603  }; 
    … …  
    619632  float termMinSize; 
    620633 
    621         // minimal pvs per node to still get subdivided 
     634  // minimal pvs per node to still get subdivided 
    622635  int termMinPvs; 
    623636 
    624         // minimal ray number per node to still get subdivided 
     637  // minimal ray number per node to still get subdivided 
    625638  int termMinRays; 
    626639         
    … …  
    628641  float termMaxCostRatio; 
    629642         
    630         // maximal contribution per ray to subdivide the node 
    631         float termMaxRayContribution; 
     643  // maximal contribution per ray to subdivide the node 
     644  float termMaxRayContribution; 
    632645 
    633646         
    634647  // randomized construction 
    635648  bool randomize; 
    636  
     649   
    637650  // type of the splitting to use fo rthe tree construction 
    638651  enum {ESplitRegular, ESplitHeuristic, ESplitHybrid }; 
    639652  int splitType; 
    640653 
    641         bool mSplitUseOnlyDrivingAxis; 
    642  
    643         // use ray space subdivision instead of view space subdivision 
    644         bool mUseRss; 
    645          
     654  bool mSplitUseOnlyDrivingAxis; 
     655   
     656  // use ray space subdivision instead of view space subdivision 
     657  bool mUseRss; 
     658 
     659  // interleave directional and spatial splits based on their costs 
     660  // if false directional splits are only performed after spatial splits 
     661  bool mInterleaveDirSplits; 
     662 
     663  // depth at which directional splits are performed if mInterleaveDirSplits is false 
     664  int mDirSplitDepth; 
     665   
    646666  // maximal size of the box on which the refdir splitting can be performed 
    647667  // (relative to the scene bbox 
    … …  
    662682  int accessTimeThreshold; 
    663683 
    664         // minimal depth at which to perform collapse 
     684  // minimal depth at which to perform collapse 
    665685  int minCollapseDepth; 
    666686 
    … …  
    670690  ///////////////////////////// 
    671691 
    672         VssStatistics stat; 
     692  VssStatistics stat; 
    673693         
    674694   
    … …  
    678698  virtual void 
    679699  Construct( 
    680                                                 VssRayContainer &rays, 
    681                                                 AxisAlignedBox3 *forcedBoundingBox = NULL 
    682                                                 ); 
     700                        VssRayContainer &rays, 
     701                        AxisAlignedBox3 *forcedBoundingBox = NULL 
     702                        ); 
    683703         
    684704  // incemental construction 
    685705  virtual void UpdateRays(VssRayContainer &remove, 
    686                                                                                                         VssRayContainer &add 
    687                                                                                                         ); 
    688  
    689         virtual void AddRays( 
    690                                                                                         VssRayContainer &add 
    691                                                                                         ) 
    692         { 
    693                 VssRayContainer remove; 
    694                 UpdateRays(remove, add); 
    695         } 
     706                                                  VssRayContainer &add 
     707                                                  ); 
     708 
     709  virtual void AddRays( 
     710                                          VssRayContainer &add 
     711                                          ) 
     712  { 
     713        VssRayContainer remove; 
     714        UpdateRays(remove, add); 
     715  } 
    696716 
    697717   
    … …  
    702722  VssTreeNode * 
    703723  SubdivideNode(VssTreeLeaf *leaf, 
    704                                                                 const AxisAlignedBox3 &box, 
    705                                                                 AxisAlignedBox3 &backBox, 
    706                                                                 AxisAlignedBox3 &frontBox 
    707                                                                 ); 
     724                                const AxisAlignedBox3 &box, 
     725                                AxisAlignedBox3 &backBox, 
     726                                AxisAlignedBox3 &frontBox 
     727                                ); 
    708728         
    709729  VssTreeNode * 
    … …  
    712732  int 
    713733  SelectPlane(VssTreeLeaf *leaf, 
    714                                                         const AxisAlignedBox3 &box, 
    715                                                         float &position, 
    716                                                         int &raysBack, 
    717                                                         int &raysFront, 
    718                                                         int &pvsBack, 
    719                                                         int &pvsFront 
    720                                                         ); 
     734                          const AxisAlignedBox3 &box, 
     735                          float &position, 
     736                          int &raysBack, 
     737                          int &raysFront, 
     738                          int &pvsBack, 
     739                          int &pvsFront 
     740                          ); 
    721741 
    722742  void 
    723743  SortSplitCandidates( 
    724                                                                                         VssTreeLeaf *node, 
    725                                                                                         const int axis 
    726                                                                                         ); 
     744                                          VssTreeLeaf *node, 
     745                                          const int axis 
     746                                          ); 
    727747         
    728748   
    … …  
    742762   
    743763 
    744         float 
    745         BestCostRatio( 
    746                                                                 VssTreeLeaf *node, 
    747                                                                 int &axis, 
    748                                                                 float &position, 
    749                                                                 int &raysBack, 
    750                                                                 int &raysFront, 
    751                                                                 int &pvsBack, 
    752                                                                 int &pvsFront 
    753                                                                 ); 
    754          
    755         float 
    756         EvalCostRatio( 
    757                                                                 VssTreeLeaf *node, 
    758                                                                 const int axis, 
    759                                                                 const float position, 
    760                                                                 int &raysBack, 
    761                                                                 int &raysFront, 
    762                                                                 int &pvsBack, 
    763                                                                 int &pvsFront 
    764                                                                 ); 
    765  
    766         float 
    767         EvalCostRatioHeuristic( 
    768                                                                                                 VssTreeLeaf *node, 
    769                                                                                                 const int axis, 
    770                                                                                                 float &position, 
    771                                                                                                 int &raysBack, 
    772                                                                                                 int &raysFront, 
    773                                                                                                 int &pvsBack, 
    774                                                                                                 int &pvsFront 
    775                                                                                                 ); 
    776  
    777         float 
    778         GetCostRatio( 
    779                                                         VssTreeLeaf *leaf, 
    780                                                         const int axis, 
    781                                                         const float position, 
    782                                                         const int raysBack, 
    783                                                         const int raysFront, 
    784                                                         const int pvsBack, 
    785                                                         const int pvsFront 
    786                                                         ); 
     764  float 
     765  BestCostRatio( 
     766                                VssTreeLeaf *node, 
     767                                int &axis, 
     768                                float &position, 
     769                                int &raysBack, 
     770                                int &raysFront, 
     771                                int &pvsBack, 
     772                                int &pvsFront 
     773                                ); 
     774         
     775  float 
     776  EvalCostRatio( 
     777                                VssTreeLeaf *node, 
     778                                const int axis, 
     779                                const float position, 
     780                                int &raysBack, 
     781                                int &raysFront, 
     782                                int &pvsBack, 
     783                                int &pvsFront 
     784                                ); 
     785 
     786  float 
     787  EvalCostRatioHeuristic( 
     788                                                VssTreeLeaf *node, 
     789                                                const int axis, 
     790                                                float &position, 
     791                                                int &raysBack, 
     792                                                int &raysFront, 
     793                                                int &pvsBack, 
     794                                                int &pvsFront 
     795                                                ); 
     796 
     797  float 
     798  GetCostRatio( 
     799                          VssTreeLeaf *leaf, 
     800                          const int axis, 
     801                          const float position, 
     802                          const int raysBack, 
     803                          const int raysFront, 
     804                          const int pvsBack, 
     805                          const int pvsFront 
     806                          ); 
    787807 
    788808  AxisAlignedBox3 GetBBox(const VssTreeNode *node) const { 
    … …  
    838858  VssTreeNode * 
    839859  SubdivideLeaf( 
    840                                                                 VssTreeLeaf *leaf 
    841                                                                 ); 
     860                                VssTreeLeaf *leaf 
     861                                ); 
    842862 
    843863  void 
    844864  RemoveRay(VssRay *ray, 
    845                                                 vector<VssTreeLeaf *> *affectedLeaves, 
    846                                                 const bool removeAllScheduledRays 
    847                                                 ); 
    848  
    849         //  void 
    850         //  AddRay(VssRay *ray); 
    851         void 
    852         AddRay(VssTreeNode::RayInfo &info); 
    853  
     865                        vector<VssTreeLeaf *> *affectedLeaves, 
     866                        const bool removeAllScheduledRays 
     867                        ); 
     868 
     869  //  void 
     870  //  AddRay(VssRay *ray); 
     871  void 
     872  AddRay(VssTreeNode::RayInfo &info); 
     873   
    854874  void 
    855875  TraverseInternalNode( 
    856                                                                                         RayTraversalData &data, 
    857                                                                                         stack<RayTraversalData> &tstack); 
    858  
    859         void 
     876                                          RayTraversalData &data, 
     877                                          stack<RayTraversalData> &tstack); 
     878 
     879  void 
    860880  EvaluateLeafStats(const TraversalData &data); 
    861881 
    862882 
    863         int 
    864         GetRootPvsSize() const { 
    865                 return GetPvsSize(bbox); 
    866         } 
    867          
    868         int 
    869         GetPvsSize(const AxisAlignedBox3 &box) const; 
    870  
    871         void 
    872         GetRayContributionStatistics( 
    873                                                                                                                         float &minRayContribution, 
    874                                                                                                                         float &maxRayContribution, 
    875                                                                                                                         float &avgRayContribution 
    876                                                                                                                         ); 
    877  
    878         int 
    879         GenerateRays(const float ratioPerLeaf, 
    880                                                         SimpleRayContainer &rays); 
    881  
    882         int 
    883         GenerateRays(const int numberOfRays, 
    884                                                         const int numberOfLeaves, 
    885                                                         SimpleRayContainer &rays); 
     883  int 
     884  GetRootPvsSize() const { 
     885        return GetPvsSize(bbox); 
     886  } 
     887   
     888  int 
     889  GetPvsSize(const AxisAlignedBox3 &box) const; 
     890 
     891  void 
     892  GetRayContributionStatistics( 
     893                                                          float &minRayContribution, 
     894                                                          float &maxRayContribution, 
     895                                                          float &avgRayContribution 
     896                                                          ); 
     897 
     898  int 
     899  GenerateRays(const float ratioPerLeaf, 
     900                          SimpleRayContainer &rays); 
     901 
     902  int 
     903  GenerateRays(const int numberOfRays, 
     904                          const int numberOfLeaves, 
     905                          SimpleRayContainer &rays); 
    886906                 
    887         float 
    888         GetAvgPvsSize(); 
    889  
    890         int 
    891         UpdateSubdivision(); 
    892  
    893         bool 
    894         TerminationCriteriaSatisfied(VssTreeLeaf *leaf); 
    895  
    896         void 
    897         CollectLeaves(vector<VssTreeLeaf *> &leaves); 
    898  
    899         bool 
    900         ClipRay( 
    901                                         VssTreeNode::RayInfo &rayInfo, 
    902                                         const AxisAlignedBox3 &box 
    903                                         ); 
    904  
    905         VssTreeNode *GetRoot() const { return root; } 
    906  
    907         bool 
    908         ValidLeaf(VssTreeLeaf *leaf) const; 
    909  
    910         void 
    911         GenerateLeafRays(VssTreeLeaf *leaf, 
    912                                                                         const int numberOfRays, 
    913                                                                         SimpleRayContainer &rays); 
     907  float 
     908  GetAvgPvsSize(); 
     909 
     910  int 
     911  UpdateSubdivision(); 
     912 
     913  bool 
     914  TerminationCriteriaSatisfied(VssTreeLeaf *leaf); 
     915 
     916  void 
     917  CollectLeaves(vector<VssTreeLeaf *> &leaves); 
     918 
     919  bool 
     920  ClipRay( 
     921                  VssTreeNode::RayInfo &rayInfo, 
     922                  const AxisAlignedBox3 &box 
     923                  ); 
     924 
     925  VssTreeNode *GetRoot() const { return root; } 
     926 
     927  bool 
     928  ValidLeaf(VssTreeLeaf *leaf) const; 
     929 
     930  void 
     931  GenerateLeafRays(VssTreeLeaf *leaf, 
     932                                  const int numberOfRays, 
     933                                  SimpleRayContainer &rays); 
    914934 
    915935 

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

    r436 r438  
    725725 
    726726bool 
    727 X3dExporter::ExportVssTree(const VssTree &tree) 
     727X3dExporter::ExportVssTree(const VssTree &tree 
     728                                                   ) 
    728729{ 
    729730  stack<VssTreeNode *> tStack; 
    … …  
    763764                                         
    764765                                        Vector3 direction = VssRay::GetDirection(v.x, v.y); 
    765                                         direction.Normalize(); 
     766                                        if (Magnitude(direction) > Limits::Small) 
     767                                          direction.Normalize(); 
     768                                        else 
     769                                          direction = Vector3(0, 1, 0); 
    766770                                        float k = 100.0f*leaf->GetImportance(); 
    767771                                        // get 4 corners of the ray directions 
    … …  
    775779 
    776780  ExportMesh(mesh); 
    777         ExportRays(rays); 
    778         CLEAR_CONTAINER(rays); 
     781  ExportRays(rays); 
     782  CLEAR_CONTAINER(rays); 
    779783  delete mesh; 
     784  return true; 
     785} 
     786 
     787bool 
     788X3dExporter::ExportVssTree2(const VssTree &tree, 
     789                                                        const Vector3 direction 
     790                                                        ) 
     791{ 
     792  stack<VssTreeNode *> tStack; 
     793         
     794 
     795  mUseForcedMaterial = true; 
     796 
     797  Vector3 dirParam; 
     798 
     799  dirParam.x = VssRay::GetDirParam(0, Normalize(direction)); 
     800  dirParam.y = VssRay::GetDirParam(1, Normalize(direction)); 
     801 
     802  float maxImportance = 0.0f; 
     803  tStack.push(tree.GetRoot()); 
     804  while (!tStack.empty()) { 
     805         
     806        VssTreeNode *node = tStack.top(); 
     807    tStack.pop(); 
     808         
     809    if (!node->IsLeaf()) { 
     810      VssTreeInterior *interior = (VssTreeInterior *)node; 
     811          if (interior->axis < 3) { 
     812                tStack.push(interior->front); 
     813                tStack.push(interior->back); 
     814          } else { 
     815                if (dirParam[interior->axis-3] < interior->position) 
     816                  tStack.push(interior->back); 
     817                else 
     818                  tStack.push(interior->front); 
     819          } 
     820    } else { 
     821          VssTreeLeaf *leaf = (VssTreeLeaf *)node; 
     822          if (tree.ValidLeaf(leaf)) { 
     823                float i = leaf->GetImportance(); 
     824                if (i > maxImportance) 
     825                  maxImportance = i; 
     826          } 
     827        } 
     828  } 
     829 
     830  tStack.push(tree.GetRoot()); 
     831  while (!tStack.empty()) { 
     832 
     833        VssTreeNode *node = tStack.top(); 
     834    tStack.pop(); 
     835         
     836                         
     837    if (!node->IsLeaf()) { 
     838      VssTreeInterior *interior = (VssTreeInterior *)node; 
     839          if (interior->axis < 3) { 
     840                tStack.push(interior->front); 
     841                tStack.push(interior->back); 
     842          } else { 
     843                if (dirParam[interior->axis-3] < interior->position) 
     844                  tStack.push(interior->back); 
     845                else 
     846                  tStack.push(interior->front); 
     847          } 
     848    } else { 
     849          VssTreeLeaf *leaf = (VssTreeLeaf *)node; 
     850          if (tree.ValidLeaf(leaf)) { 
     851                AxisAlignedBox3 box; 
     852                box = tree.GetBBox(leaf); 
     853                Mesh *mesh = new Mesh; 
     854                AddBoxToMesh(box, mesh); 
     855                 
     856                // get 4 corners of the ray directions 
     857                 
     858                mForcedMaterial.mDiffuseColor.b = 1.0f; 
     859                mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance; 
     860                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r; 
     861                 
     862                ExportMesh(mesh); 
     863                delete mesh; 
     864          } 
     865        } 
     866  } 
     867 
     868  mUseForcedMaterial = false; 
     869 
    780870  return true; 
    781871} 
    … …  
    808898                        { 
    809899                                float importance =  
    810                                         vc->mPassingRays.mContributions / (float)vc->mPassingRays.mRays; 
    811  
     900                                  vc->mPassingRays.mContributions / (float)vc->mPassingRays.mRays; 
     901                                 
    812902                                mForcedMaterial.mDiffuseColor.r = importance; 
    813903                                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r; 
    814904                                ExportViewCell(vc); 
    815                         }   
     905                        } 
    816906                } else  
    817907                { 

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

    r434 r438  
    3939  ExportKdTree(const KdTree &tree); 
    4040 
    41         bool 
     41  bool 
    4242  ExportVssTree(const VssTree &tree); 
    4343 
     44  bool 
     45  ExportVssTree2(const VssTree &tree, 
     46                                 const Vector3 direction 
     47                                 ); 
     48   
    4449  bool  
    4550  ExportVspKdTree(const VspKdTree &tree, const int maxPvs); 

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

    r435 r438  
    1515# filename ../data/atlanta/atlanta2.x3d 
    1616# filename ../data/soda/soda.dat 
    17  filename ../data/soda/soda5.dat 
     17filename ../data/soda/soda5.dat 
    1818} 
    1919 
    … …  
    2525VssPreprocessor { 
    2626        samplesPerPass  100000 
    27         initialSamples 200000 
     27        initialSamples 500000 
    2828        vssSamples 1000000 
    2929        vssSamplesPerPass 50000 
    … …  
    3939        minRays         100 
    4040        minSize         0.001 
    41         maxCostRatio    0.98 
     41        maxCostRatio    2.0 
    4242        maxRayContribution 0.05 
    4343         
    4444        maxTotalMemory  200 
    45         maxStaticMemory 50 
     45        maxStaticMemory 100 
    4646 
    4747        splitType regular 
    … …  
    4949#       splitType hybrid 
    5050        splitUseOnlyDrivingAxis true 
     51 
     52        interleaveDirSplits     false 
     53    dirSplitDepth 12 
    5154 
    5255        numberOfEndPointDomains 10000 
Note: See TracChangeset for help on using the changeset viewer.