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.