Ignore:
Timestamp:
01/23/08 00:21:50 (17 years ago)
Author:
bittner
Message:

commit after merge with vlastimil

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

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/configh.h

    r2610 r2629  
    1313#ifndef __CONFIGH_H__ 
    1414#define __CONFIGH_H__ 
    15  
    16  
    17 #if defined(_MSC_VER) 
    18 // use perftimer only on msvc 
    19 // define __SSE__ macro as it is not defined under MSVC 
    20 #define __SSE__ 
    21 // If we support the use of SSE instructions for ray shooting 
    22 //#define _USE_HAVRAN_SSE 
    23 #endif 
    2415 
    2516#ifndef USE_GOLEM_NAMESPACE 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbai.cpp

    r2592 r2629  
    218218 
    219219  // Maximum depth of the tree is set and stack is allocated 
    220   maxTreeDepth = 50; 
    221   stackDepth = 2*maxTreeDepth; 
     220  maxTreeDepth = MAX_HEIGHT; 
     221  stackDepth = maxTreeDepth + 2; 
    222222  stackID = new GALIGN16 SInputData[stackDepth]; 
    223223  assert(stackID); 
    … …  
    11491149      int estHeight = (int)(log((float)initcnt)/log((float)2.0) + 0.9); 
    11501150      // cout << "EstHeight=" << estHeight << endl; 
    1151       maxDepthAllowed = (int)((float)estHeight * 1.2 + 2.0); 
     1151      maxDepthAllowed = (int)((float)estHeight * 1.2f + 2.0f); 
    11521152 
    11531153      // maximum number of trials to further subdivide 
    … …  
    12051205    } 
    12061206  } 
     1207  else { 
     1208    if (maxDepthAllowed >= MAX_HEIGHT) 
     1209      maxDepthAllowed = MAX_HEIGHT - 1; 
     1210  } 
    12071211 
    12081212  if (verbose) 
    … …  
    12211225  if (objlist.size() == 0) 
    12221226    return 0; // nothing 
     1227 
     1228  // --------------------------------------------------- 
     1229  // Rewriting the triangles to the just wrappers to save 
     1230  // the memory during building!!!! 
     1231  bool useWrappers = false; 
     1232  if (useWrappers) { 
     1233    cout << "WARNING: using only wrappers, not objects to save the memory!" 
     1234         << endl; 
     1235    cout << "Size of(AxisAlignedBox3Intersectable) = " << sizeof(AxisAlignedBox3Intersectable) << endl; 
     1236    cout << "Size of(TriangleIntersectable) = " << sizeof(TriangleIntersectable) << endl; 
     1237    for (ObjectContainer::iterator it = objlist.begin(); 
     1238         it != objlist.end(); it++) { 
     1239      // take the triangle 
     1240      Intersectable *i = *it; 
     1241      // store the properties to new variables 
     1242      AxisAlignedBox3 b = i->GetBox(); 
     1243      int mId = i->mId; 
     1244      // delete the triangle 
     1245      delete i; 
     1246      // create the wrapper with the same box as triangle 
     1247      AxisAlignedBox3Intersectable *a = new AxisAlignedBox3Intersectable(b); 
     1248      a->mId = mId; 
     1249      // and put it back to the list of objects 
     1250      *it = a; 
     1251    } // for     
     1252    cout << "Rewriting to wrappers is finished!" << endl; 
     1253  } // if 
     1254  // --------------------------------------------------- 
     1255   
    12231256  // cerr<<"hh44"<<endl; 
    12241257  // initialize the whole box of the kd-tree and sort 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbai.h

    r2582 r2629  
    2020#include "ktb8b.h" 
    2121#include "Containers.h" 
     22#include "IntersectableWrapper.h" 
    2223 
    2324namespace GtpVisibilityPreprocessor { 
    … …  
    4243#endif 
    4344 
     45class AxisAlignedBox3Intersectable: 
     46    public IntersectableWrapper<AxisAlignedBox3> 
     47{ 
     48public: 
     49  AxisAlignedBox3Intersectable(const AxisAlignedBox3 &item): 
     50    IntersectableWrapper<AxisAlignedBox3>(item) { } 
     51 
     52  AxisAlignedBox3 GetBox() const { return mItem;} 
     53 
     54  int Type() const 
     55  { 
     56    // This is not ture, but for our purposes it is OK 
     57    return Intersectable::TRIANGLE_INTERSECTABLE; 
     58  } 
     59 
     60}; 
     61 
     62// ---------------------------------------------------------------   
    4463// The base class for KD-tree with irregular change of axes, where 
    4564// the splitting plane can be positioned. 
    … …  
    216235  void Check1List(SInputData *data, int axis, int countExpected); 
    217236     
    218   //---------------------------------------------------------------------- 
     237  //---------------------------------------------------------------- 
    219238  // Termination criteria and fixing the splitting plane orientation 
    220239 
    … …  
    230249    CKTBAxes::Axes reqAxis; 
    231250 
    232     // -------------- AUTOMATIC TERMINATION CRITERIA --------------------- 
     251    // -------------- AUTOMATIC TERMINATION CRITERIA ---------------- 
    233252    // the ratio of improvement for the cost by subdivision and not-subdividing 
    234253    // for the previous subdivision 
    … …  
    578597  int startEmptyCutDepth; 
    579598 
     599  // Biasing the empty cuts (no objects are split). The cost is multiplied 
     600  // by the coefficient which is assumed to be 0.8-0.9 
     601  float  biasFreeCuts; 
     602   
    580603  // ---------- Special improvements on the kd-tree construction -------- 
    581604  // flag if to split bounding boxes during splitting 
    … …  
    588611  int     minObjectsToCreateMinBox, minDepthDistanceBetweenMinBoxes; 
    589612  float   minSA2ratioMinBoxes; 
    590   // Biasing the empty cuts (no objects are split). The cost is multiplied 
    591   // by the coefficient which is assumed to be 0.8-0.9 
    592   float  biasFreeCuts; 
    593613  // Make min box here 
    594614  bool   makeMinBoxHere; 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktball.cpp

    r2608 r2629  
    1111 
    1212// GOLEM library 
    13 #include "ktbconf.h" 
    1413#include "ktb.h" 
    1514#include "ktbai.h" 
     15#include "ktbs.h" 
    1616#include "ktball.h" 
    1717#include "ktbtrav.h" 
    … …  
    6161{ 
    6262  CKTBAllocManPredecessor *bc = 0; 
    63   bool useArray = true; 
     63  bool useArray = false; 
    6464   
    6565  // this should be already initialised, but we want to be sure 
    6666  if (useArray) { 
     67    cout << "Using kbt-tree based on arrays" << endl; 
    6768    // the implementation based on arrays 
    6869    bc = new CKTBABuildUp(); // file ktbai.cpp 
    6970  } 
    7071  else { 
    71     // the implementation based on lists 
    72     // bc = new CKTBBuildUp(); // file ktbi.cpp 
     72    cout << "Using kbt-tree based on sampling" << endl; 
     73    // the implementation based on sampling 
     74    bc = new CKTBSBuildUp(); // file ktbs.cpp 
    7375  } 
    7476     
    … …  
    425427void 
    426428CKTB::FindNearestI(RayPacket2x2 &raypack, 
    427                                    const Vector3 &boxmin, 
    428                                    const Vector3 &boxmax) 
     429                   const Vector3 &boxmin, 
     430                   const Vector3 &boxmax) 
    429431{ 
    430432  if (!makeMinBoxes) 
    … …  
    766768} 
    767769 
    768    
     770 
     771static int 
     772cntInterior = 0; 
     773 
     774static int 
     775cntInteriorA[4] = {0, 0, 0, 0}; 
     776 
     777static int 
     778cntLeaves = 0; 
     779 
     780static int 
     781cntEmptyLeaves = 0; 
     782 
     783static int 
     784objReferences = 0; 
     785 
    769786SKTBNodeT* 
    770787CKTB::ImportBinLeaf(IN_STREAM &stream,  
    … …  
    775792  int objId = leafId; 
    776793  int size; 
     794 
     795  cntLeaves++; 
    777796   
    778797  stream.read(reinterpret_cast<char *>(&size), sizeof(int)); 
    … …  
    782801    SKTBNodeT* leaf = buildClass->AllocLeaf(0); 
    783802    *nodeToLink = buildClass->nodeToLink; 
     803    cntEmptyLeaves++; 
    784804    return leaf; 
    785805  } 
    … …  
    790810 
    791811  ObjectContainer *newobjlist = new ObjectContainer; 
     812 
     813  objReferences += size; 
    792814   
    793815  // read object ids 
    … …  
    826848} 
    827849 
    828  
    829850SKTBNodeT * 
    830851CKTB::ImportBinInterior(IN_STREAM  &stream, SKTBNodeT **nodeToLink) 
    … …  
    839860    buildClass->AllocInteriorNode(axis, pos, 0, 0); 
    840861  *nodeToLink = buildClass->nodeToLink; 
    841          
     862 
     863  cntInterior++; 
     864  assert( (axis >= 0) && (axis < 3)); 
     865  cntInteriorA[axis]++; 
     866   
    842867  return interiorNode; 
    843868} 
    … …  
    928953 
    929954  if (!stream.is_open()) { 
    930     cerr << "Kd-tree description file (.kdh) cannot be opened for reading\n"; 
     955    cerr << "Kd-tree description file (.kbt) cannot be opened for reading\n"; 
    931956    return true; // error 
    932957  } 
    … …  
    963988  bc->InitAux(0, CKTBNodeAbstract::MAX_HEIGHT - 1, maxItemsAtOnce);   
    964989 
     990  for(int i = 0; i < 4; i++) 
     991    cntInteriorA[i] = 0; 
     992   
    965993  // Compute the box from all objects 
    966994  bbox.Initialize(); 
    … …  
    10401068  builtUp = true;   
    10411069 
     1070  cout << "Importing ktb-tree cntInterior = " 
     1071       << cntInterior << " cntLeaves = " << cntLeaves 
     1072       << " cntEmptyLeaves = " << cntEmptyLeaves << endl; 
     1073 
     1074  cout << "X-splits = " << cntInteriorA[0] << " Y-splits = " << cntInteriorA[1]  
     1075       << " Z-splits = " << cntInteriorA[2] << "\nref_to_objs/full_leaf = " 
     1076       << (float)objReferences/(cntLeaves - cntEmptyLeaves) << endl; 
     1077   
    10421078  return false; // OK 
    10431079} 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktball.h

    r2608 r2629  
    1616// GOLEM headers 
    1717#include "configh.h" 
    18 #include "ktbconf.h" 
    1918//#include "ktbi.h" 
    2019#include "ktbai.h" 
    … …  
    155154   
    156155  // allocate new build class and return it 
    157   static CKTBAllocManPredecessor* AllocBuildClass(); 
     156  CKTBAllocManPredecessor* AllocBuildClass(); 
    158157   
    159158  CKTBNodeIteratorPredecessor* GetTraversalClass() { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbconf.h

    r2608 r2629  
    2323#endif 
    2424 
     25// If we support the use of SSE instructions for ray shooting 
     26#define _USE_HAVRAN_SSE 
    2527 
    2628namespace GtpVisibilityPreprocessor { 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbf2trv.cpp

    r2608 r2629  
    5757      results[i].intersectable; 
    5858    SimpleRay::IntersectionRes[i + copyOffset].tdist = 
     59    SimpleRay::IntersectionRes[i + copyOffset].maxt = 
    5960      results[i].tdist; 
    6061  } // for i 
    … …  
    204205    FindNearestI(ray); 
    205206    rp.SetObject(i, SimpleRay::IntersectionRes[0].intersectable); 
    206     rp.SetT(i, SimpleRay::IntersectionRes[0].tdist); 
     207    rp.SetT(i, SimpleRay::IntersectionRes[0].maxt); 
    207208    // SimpleRay::IntersectionRes[0].intersectable->GetNormal(0); 
    208209  } // for 
    … …  
    403404    FindNearestI(ray); 
    404405    rp.SetObject(i, SimpleRay::IntersectionRes[0].intersectable); 
    405     rp.SetT(i, SimpleRay::IntersectionRes[0].tdist); 
     406    rp.SetT(i, SimpleRay::IntersectionRes[0].maxt); 
    406407    // SimpleRay::IntersectionRes[0].intersectable->GetNormal(0); 
    407408  } // for 
    … …  
    414415void 
    415416CKTBTraversal::FindNearestI(RayPacket2x2 &rp, 
    416                                                         const Vector3 &boxmin, 
    417                                                         const Vector3 &boxmax) 
     417                            const Vector3 &boxmin, 
     418                            const Vector3 &boxmax) 
    418419{ 
    419420  static AxisAlignedBox3 localbox; 
    … …  
    606607    FindNearestI(ray, localbox); 
    607608    rp.SetObject(i, SimpleRay::IntersectionRes[0].intersectable); 
    608     rp.SetT(i, SimpleRay::IntersectionRes[0].tdist); 
     609    rp.SetT(i, SimpleRay::IntersectionRes[0].maxt); 
    609610    // SimpleRay::IntersectionRes[0].intersectable->GetNormal(0); 
    610611  } // for 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbftrav.cpp

    r2602 r2629  
    166166            cout << "Full leaf HIT " << endl;  
    167167#endif   
    168                
     168            SimpleRay::IntersectionRes[0].tdist = 
     169              SimpleRay::IntersectionRes[0].maxt; 
    169170#ifdef __TRAVERSAL_STATISTICS 
    170171            _allNodesTraversed += allNodesTraversed; 
    … …  
    372373            cout << "Full leaf HIT " << endl;  
    373374#endif   
     375            SimpleRay::IntersectionRes[0].tdist = 
     376              SimpleRay::IntersectionRes[0].maxt; 
    374377               
    375378#ifdef __TRAVERSAL_STATISTICS 
    … …  
    381384            // We have to add the distance from the original ray origin 
    382385            SimpleRay::IntersectionRes[0].tdist += tminOffset; 
     386            SimpleRay::IntersectionRes[0].maxt = SimpleRay::IntersectionRes[0].tdist; 
    383387             
    384388            // signed distance should be already set in TestFullLeaf 
    … …  
    592596              tmax + Limits::Small; 
    593597            if (TestFullLeaf(rays[indexR+offset], currNode, indexR)) { 
     598              // copy the result to tdist 
     599              SimpleRay::IntersectionRes[indexR + rayOffset].tdist = 
     600                SimpleRay::IntersectionRes[indexR + rayOffset].maxt; 
    594601 
    595602              // we remove the ray from the calculation 
    … …  
    599606#ifdef _DEBUGKTB 
    600607              cout << "Full leaf HIT " << endl;  
    601 #endif   
     608#endif 
    602609               
    603610#ifdef __TRAVERSAL_STATISTICS 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/ktbtrav.h

    r2602 r2629  
    150150  // of a packet to individual rays and traced individually. 
    151151  virtual void FindNearestI(RayPacket2x2 &raypack) { } 
    152   virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, const Vector3 &boxMax) { } 
     152  virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, 
     153                            const Vector3 &boxMax) { } 
    153154#endif 
    154155   
    … …  
    328329  // of a packet to individual rays and traced individually. 
    329330  virtual void FindNearestI(RayPacket2x2 &raypack); 
    330   virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, const Vector3 &boxMax); 
     331  virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, 
     332                            const Vector3 &boxMax); 
    331333#endif // __SSE__ 
    332334#endif // _USE_HAVRAN_SSE   
    … …  
    421423  // of a packet to individual rays and traced individually. 
    422424  virtual void FindNearestI(RayPacket2x2 &raypack); 
    423   virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, const Vector3 &boxMax); 
     425  virtual void FindNearestI(RayPacket2x2 &raypack, const Vector3 &boxMin, 
     426                            const Vector3 &boxMax); 
    424427#endif // __SSE__ 
    425428#endif // _USE_HAVRAN_SSE   

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/raypack.h

    r2592 r2629  
    1010// 
    1111// Initial coding by Vlastimil Havran, 2006. The data design is in fact 
    12 // Jakko Biker layout as propose in the article on Intel Web Site in year 2005 
     12// Jakko Biker layout as proposed in the article on Intel Web Site in year 2005 
    1313// http://www.intel.com/cd/ids/developer/asmo-na/eng/245711.htm?page=1 
    1414 
    … …  
    2121 
    2222#include "Vector3.h" 
     23#include "Matrix4x4.h" 
    2324#include "ktbconf.h" 
    2425   
    … …  
    8889    // and also for shadow rays finish at the same object 
    8990    const Intersectable *_stopObject = NULL 
    90   ) 
    91   { 
     91  ) { 
    9292    // location 
    9393    ox[0] = orf[0].x; ox[1] = orf[1].x; ox[2] = orf[2].x; ox[3] = orf[3].x; 
    … …  
    182182  int GetType() const { return ttype; } 
    183183 
     184  void ApplyTransform(const Matrix4x4 &tform) { 
     185    for (int i = 0; i < 4; i++) { 
     186      Vector3 o_orig(ox[i], oy[i], oz[i]); 
     187      Vector3 t_orig = tform * o_orig; 
     188      ox[i] = t_orig.x; oy[i] = t_orig.y; oz[i] = t_orig.z; 
     189      Vector3 o_dir(dx[i], dy[i], dz[i]); 
     190      Vector3 t_dir = RotateOnly(tform, o_dir); 
     191      dx[i] = t_dir.x; dy[i] = t_dir.y; dz[i] = t_dir.z; 
     192 
     193      // ?? note that normalization to the unit size of the direction 
     194      // ?? is NOT computed -- this is what we want. 
     195    } 
     196    Precompute(); 
     197  } 
     198   
    184199  // Reading and Setting origin of the ray and direction 
    185200  // Ray origin 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/sbbox.h

    r2582 r2629  
    146146 
    147147  inline bool Equal(const SBBox &b, float eps = 0.f) const; 
    148      
     148 
     149  // Returns the intersection of two axis-aligned boxes. 
     150  friend inline SBBox Intersect(const SBBox &x, const SBBox &y); 
     151   
    149152  // Test if the box is really sensefull 
    150153  bool IsCorrect(); 
    … …  
    278281DescribeXYZ(const SBBox &b, std::ostream &app, int indent); 
    279282 
     283inline SBBox 
     284Intersect(const SBBox &x, const SBBox &y) 
     285{ 
     286  SBBox ret = x; 
     287  if (OverlapS(ret, y)) { 
     288    Maximize(ret.pp[0], y.pp[0]); 
     289    Minimize(ret.pp[1], y.pp[1]); 
     290    return ret; 
     291  } 
     292 
     293  // Null intersection. 
     294  return SBBox(Vector3(0), Vector3(0)); 
     295} 
     296 
     297 
    280298#if 1 
    281299// The implementation I, the first version implemented by Vlastimil 
    … …  
    425443#endif 
    426444 
     445 
    427446} 
    428447 

  • GTP/trunk/Lib/Vis/Preprocessing/src/havran/testrt.cpp

    r2602 r2629  
    2626#include "GlobalLinesRenderer.h" 
    2727#include "RayCaster.h" 
     28#include "Triangle3.h" 
     29#include "IntersectableWrapper.h" 
    2830#include "timer.h" 
    2931#include "raypack.h" 
    … …  
    6466extern void Cleanup(); 
    6567 
    66 static string ReplaceSuffix(const string &filename, const string &a, const string &b) 
     68void 
     69_SortRays2(SimpleRayContainer &rays, 
     70           const int l, 
     71           const int r, 
     72           const int depth, 
     73           float box[12]) 
    6774{ 
    68         string result = filename; 
    69  
    70         int pos = (int)filename.rfind(a, (int)filename.size() - 1); 
    71         if (pos == filename.size() - a.size())  
    72         { 
    73                 result.replace(pos, a.size(), b); 
     75  // pick-up a pivot 
     76  int axis; 
     77   
     78  float maxDiff = -1.0f; 
     79  // get the largest axis 
     80  int offset = 0; 
     81  int i; 
     82 
     83  //const int batchsize = 16384; 
     84  //const int batchsize = 8192; 
     85  //const int batchsize = 128; 
     86  const int batchsize = 4; 
     87 
     88  //if (r - l < 16*batchsize) 
     89  //    offset = 3; 
     90         
     91  //  if (depth%2==0) 
     92  //    offset = 3; 
     93   
     94  for (i=offset; i < offset + 6; i++) { 
     95    float diff = box[i + 6] - box[i]; 
     96    assert(diff >= 0.f); 
     97    if (diff > maxDiff) { 
     98      // Find the maximum 
     99      maxDiff = diff; 
     100      axis = i; 
     101    } 
     102  } 
     103 
     104  //  cout<<depth<<" "<<axis<<" "<<l<<" "<<r<<endl; 
     105   
     106  i=l; 
     107  int j=r; 
     108 
     109  float x = (box[axis] + box[axis+6])*0.5f; 
     110  //  float x = rays[(l+r)/2].GetParam(axis); 
     111  do { 
     112        while(i<j && rays[i].GetParam(axis) < x) 
     113          i++; 
     114        while(i<j && x < rays[j].GetParam(axis)) 
     115          j--; 
     116         
     117        if (i <= j) { 
     118          swap(rays[i], rays[j]); 
     119          i++; 
     120          j--; 
    74121        } 
    75  
    76         return result; 
     122  } while (i<=j); 
     123 
     124   
     125  if (l + batchsize < j ) { 
     126        // set new max 
     127        float save = box[axis+6]; 
     128        box[axis+6] = x; 
     129        _SortRays2(rays, l, j, depth+1, box); 
     130        box[axis+6] = save; 
     131  } else { 
     132        //      for (int k=0; k < 6; k++) 
     133        //        cout<<k<<" "<<box[k]<<" - "<<box[k+6]<<endl; 
     134  } 
     135   
     136  if (i + batchsize < r) { 
     137    // set new min 
     138    box[axis] = x; 
     139    _SortRays2(rays, i, r, depth+1, box); 
     140  } else { 
     141        //      for (int k=0; k < 6; k++) 
     142        //        cout<<k<<" "<<box[k]<<" - "<<box[k+6]<<endl; 
     143  }      
    77144} 
    78145 
    79  
    80 static int SplitFilenames(const string &str, vector<string> &filenames) 
     146void 
     147SortRays2(SimpleRayContainer &rays, const AxisAlignedBox3 &box) 
    81148{ 
    82         int pos = 0; 
    83  
    84         while(1) { 
    85                 int npos = (int)str.find(';', pos); 
    86                  
    87                 if (npos < 0 || npos - pos < 1) 
    88                         break; 
    89                 filenames.push_back(string(str, pos, npos - pos)); 
    90                 pos = npos + 1; 
    91         } 
    92          
    93         filenames.push_back(string(str, pos, str.size() - pos)); 
    94         return (int)filenames.size(); 
    95 } 
     149  const float sizeBox = Magnitude(box.Diagonal()); 
     150  // This is some size of the  
     151  const float sizeDir = 0.1f * sizeBox; 
     152   
     153  float b[12]={ 
     154    box.Min().x, 
     155    box.Min().y, 
     156    box.Min().z, 
     157    -sizeDir, 
     158    -sizeDir, 
     159    -sizeDir, 
     160    box.Max().x, 
     161    box.Max().y, 
     162    box.Max().z, 
     163    sizeDir, 
     164    sizeDir, 
     165    sizeDir 
     166  }; 
     167 
     168   
     169  _SortRays2(rays, 0, (int)rays.size()-1, 0, b); 
     170 
     171  return; 
     172}                                        
    96173 
    97174 
    … …  
    254331  AxisAlignedBox3 bboxOrig = preprocessor->mSceneGraph->GetBox(); 
    255332  AxisAlignedBox3 bbox = bboxOrig; 
    256   int sizeDiag = Magnitude(bbox.Diagonal()); 
     333  float sizeDiag = Magnitude(bbox.Diagonal()); 
    257334  bbox.Enlarge(sizeDiag * 1.5f); 
    258335 
    259336  Vector3 origin, dir; 
    260337 
    261 //#define WIEN1 
    262 #define WIEN2 
     338#define WIEN1 
     339//#define WIEN2 
    263340//#define ARENA1 
    264341     
    … …  
    267344  origin = Vector3(1099.9f, 183.0f, -387.0f); 
    268345  dir = Vector3(-0.6f, 0.0001f, -0.8f); 
     346  //dir = -dir; 
    269347#define DIREXISTS 
    270348#endif   
    … …  
    292370  cout << "Computing image\n" << endl; 
    293371 
     372  int id = preprocessor->mObjects.size() + 1; 
     373     
     374  //We add here a few objects 
     375  ObjectContainer dynObjects; 
     376  Vector3 baseVec = origin + dir * 2.0f; 
     377  Triangle3 tr1(baseVec, baseVec + Vector3(1, 0, 0), 
     378                baseVec + Vector3(0, 1, 0));            
     379  TriangleIntersectable ti1(tr1); 
     380  dynObjects.push_back(&ti1); 
     381  ti1.mId = id+1; 
     382   
     383  tr1.Init(baseVec, baseVec + Vector3(1, 0, 0), 
     384           baseVec + Vector3(0, 0, 1));         
     385  TriangleIntersectable ti2(tr1); 
     386  dynObjects.push_back(&ti2); 
     387  ti2.mId = id+2; 
     388 
     389  tr1.Init(baseVec, baseVec + Vector3(0, 1, 0), 
     390           baseVec + Vector3(0, 0, 1));         
     391  TriangleIntersectable ti3(tr1); 
     392  dynObjects.push_back(&ti3); 
     393  ti3.mId = id+3; 
     394 
    294395#if 1 
    295   // ray by ray 
    296   cam.SnapImage("test-rays.tga", 
    297                 preprocessor->mRayCaster, 
    298                 bboxOrig, 
    299                 preprocessor->mSceneGraph); 
    300 #endif 
     396  // This is required for cam.SnapImagePacket2 
     397  // otherwise dynamic object cannot be identified! 
     398  preprocessor->mObjects.push_back(&ti1); 
     399  preprocessor->mObjects.push_back(&ti2); 
     400  preprocessor->mObjects.push_back(&ti3); 
     401#endif 
     402 
     403  if (0) { 
     404    Matrix4x4 mat; 
     405    mat = IdentityMatrix(); 
     406    mat = mat * TranslationMatrix(Vector3(-1, 0, 0)); 
     407    preprocessor->mRayCaster->AddDynamicObjecs(dynObjects, mat); 
     408   
    301409#if 1 
    302   // using ray packets 
    303   cam.SnapImagePacket("test-packet.tga", 
    304                       preprocessor->mRayCaster, 
    305                       bboxOrig, 
    306                       preprocessor->mSceneGraph); 
     410    // ray by ray 
     411    cam.SnapImage("test-rays.tga", 
     412                  preprocessor->mRayCaster, 
     413                  bboxOrig, 
     414                  preprocessor->mSceneGraph); 
    307415#endif 
    308416#if 1 
    309   // using ray packets 
    310   cam.SnapImage2("test-oneDir.tga", 
    311                  preprocessor->mRayCaster, 
    312                  bboxOrig, 
    313                  preprocessor->mSceneGraph); 
    314 #endif 
     417    // using ray packets 
     418    cam.SnapImage2("test-oneDir.tga", 
     419                   preprocessor->mRayCaster, 
     420                   bboxOrig, 
     421                   preprocessor->mSceneGraph); 
     422#endif 
     423     
     424#if 1 
     425#ifdef _USE_HAVRAN_SSE 
     426    // using ray packets 
     427    cam.SnapImagePacket("test-packet.tga", 
     428                        preprocessor->mRayCaster, 
     429                        bboxOrig, 
     430                        preprocessor->mSceneGraph); 
     431#endif 
     432#endif     
     433#if 1 
     434    // using ray packets 
     435    cam.SnapImagePacket2("test-packet4.tga", 
     436                         preprocessor->mRayCaster, 
     437                         bboxOrig, 
     438                         preprocessor->mSceneGraph); 
     439#endif 
     440  } 
     441  else { 
     442    cout << "Computing animation" << endl;     
     443    for (int i = 0; i < 20; i++) { 
     444      preprocessor->mRayCaster->DeleteDynamicObjects(); 
     445      Matrix4x4 mat; 
     446      mat = IdentityMatrix(); 
     447      mat = mat * TranslationMatrix(Vector3(-0.1*(float)i, 0, 0)); 
     448      preprocessor->mRayCaster->AddDynamicObjecs(dynObjects, mat); 
     449      char name[200];       
     450#if 1 
     451    // ray by ray 
     452      sprintf(name, "test-rays-%03d.tga", i); 
     453      cam.SnapImage(name, 
     454                    preprocessor->mRayCaster, 
     455                    bboxOrig, 
     456                    preprocessor->mSceneGraph); 
     457#endif 
     458#if 1 
     459      // using ray packets 
     460      sprintf(name, "test-oneDir-%03d.tga", i); 
     461      cam.SnapImage2(name, 
     462                     preprocessor->mRayCaster, 
     463                     bboxOrig, 
     464                     preprocessor->mSceneGraph); 
     465#endif 
     466 
     467#if 1 
     468#ifdef _USE_HAVRAN_SSE   
     469      // using ray packets 
     470      sprintf(name, "test-packet-%03d.tga", i); 
     471      cam.SnapImagePacket(name, 
     472                          preprocessor->mRayCaster, 
     473                          bboxOrig, 
     474                          preprocessor->mSceneGraph); 
     475#endif 
     476#endif 
     477#if 1 
     478      // using ray packets 
     479      sprintf(name, "test-packet4-%03d.tga", i); 
     480      cam.SnapImagePacket2(name, 
     481                           preprocessor->mRayCaster, 
     482                           bboxOrig, 
     483                           preprocessor->mSceneGraph); 
     484#endif 
     485    } // for 
     486  } // animation 
     487 
    315488   
    316489  cout << "Done\n" << endl; 
    … …  
    327500}; 
    328501 
     502 
    329503// This is for testing RT implementation 
    330504void 
    … …  
    427601  int cntMaxRays = 100000; 
    428602  Environment::GetSingleton()->GetIntValue("Rays.cnt", cntMaxRays); 
    429   vector<SimpleRay> rays; 
     603  SimpleRayContainer rays; 
    430604  SimpleRay rayTest; 
    431605  vector<RESult> results; 
    … …  
    475649  if (castDoubleRays) 
    476650    mult = 2.0; 
    477    
     651 
     652  cout << "Press a key to start ray shooting" << endl; 
     653  getchar(); 
     654  cout << "Ray shooting " << cntRays << " rays started - " 
     655       << (castDoubleRays ? " double " : " single ") 
     656       << " dir " << endl; 
     657   
     658  AxisAlignedBox3 bboxOrig = preprocessor->mSceneGraph->GetBox(); 
     659   
     660  cout << "Sorting rays " << endl; 
     661 
     662  CTimer timer; 
     663  timer.Reset(); 
     664  timer.Start(); 
     665  long t1 = GetTime(); 
     666 
     667  //SortRays2(rays, bboxOrig); 
     668 
     669  timer.Stop(); 
     670  long t2 = GetTime(); 
     671  cout<<"\n#SORTING_TIME = "; 
     672  cout << TimeDiff(t1, t2)<<" [mikrosec]" 
     673       << " userTime = " << timer.UserTime() << " realTime = " 
     674       << timer.RealTime() << endl; 
     675 
    478676  cout << "Starting to shoot " << cntRays * mult << " rays" << endl; 
     677  timer.Start(); 
    479678   
    480679  RayCaster *raycaster = preprocessor->mRayCaster; 
    481680  VssRayContainer vssRays; 
    482   AxisAlignedBox3 bboxOrig = preprocessor->mSceneGraph->GetBox(); 
    483681 
    484682//#define DEBUGRESULTS 
    … …  
    494692#endif 
    495693 
    496   cout << "Press a key to start ray shooting" << endl; 
    497   getchar(); 
    498   cout << "Ray shooting " << cntRays << " rays started - " 
    499        << (castDoubleRays ? " double " : " single ") 
    500        << " dir " << endl; 
    501  
    502   long t1 = GetTime(); 
    503   CTimer timer; 
    504   timer.Reset(); 
    505   timer.Start(); 
    506    
    507694  SimpleRayContainer raysToTest; 
    508695  for (int i = 0; i < cntRays - 16; i++) { 
     696 
    509697#if 0 
    510698    int res = raycaster->CastRay(rays[i], 
    … …  
    573761 
    574762  timer.Stop(); 
    575   long t2 = GetTime(); 
    576   cout<<"\n#RAY_CAST_TIME = "; 
     763  t2 = GetTime(); 
     764  cout<<"\n#SORTING + RAY_CAST_TIME = "; 
    577765  cout << TimeDiff(t1, t2)<<" [mikrosec]" 
    578766       << " userTime = " << timer.UserTime() << " realTime = " 
    … …  
    695883  int cntMaxRays = 100000; 
    696884  Environment::GetSingleton()->GetIntValue("Rays.cnt", cntMaxRays); 
    697   vector<SimpleRay> rays; 
     885  SimpleRayContainer rays; 
    698886  SimpleRay rayTest; 
    699887  vector<RESult> results; 
    … …  
    9571145  int cntMaxRays = 100000; 
    9581146  Environment::GetSingleton()->GetIntValue("Rays.cnt", cntMaxRays); 
    959   vector<SimpleRay> rays; 
     1147  SimpleRayContainer rays; 
    9601148  SimpleRay rayTest; 
    9611149  vector<RESult> results; 
    … …  
    10381226  timer.Start(); 
    10391227  Vector3 boxMin, boxMax; 
     1228 
     1229  bool printOut = false; 
    10401230   
    10411231  SimpleRayContainer raysToTest; 
    … …  
    10561246                               origin4, direction4, 
    10571247                               result4, dist4); 
    1058     printf("I %4.7f %4.7f %4.7f %4.7f %4.7f %4.7f\n", 
    1059            boxMin.x, boxMin.y, boxMin.z, boxMax.x, boxMax.y, boxMax.z); 
     1248    if (printOut) { 
     1249      printf("I %4.7f %4.7f %4.7f %4.7f %4.7f %4.7f\n", 
     1250             boxMin.x, boxMin.y, boxMin.z, boxMax.x, boxMax.y, boxMax.z); 
     1251    } 
    10601252 
    10611253    for (int j = 0; j < 4; j++) { 
    1062       printf("%d %4.7f %4.7f %4.7f %4.7f %4.7f %4.7f %d %4.7f\n", 
    1063              i+j, 
    1064              origin4[j].x, 
    1065              origin4[j].y, 
    1066              origin4[j].z, 
    1067              direction4[j].x, 
    1068              direction4[j].y, 
    1069              direction4[j].z, 
    1070              (result4[j] != -1) ? 1 : 0, 
    1071              (result4[j] != -1) ? dist4[j] : 0);       
     1254#if 0 
     1255      if (result4[j] == 0) { 
     1256        int res = raycaster->CastRay(rays[i+j], 
     1257                                     vssRays, 
     1258                                     bboxOrig, 
     1259                                     false, 
     1260                                     true); 
     1261        if (res) { 
     1262          float tdist = SimpleRay::IntersectionRes[0].tdist; 
     1263          Vector3 point = rays[i+j].Extrap(tdist); 
     1264          AxisAlignedBox3 testbox(boxMin, boxMax); 
     1265           
     1266          if (testbox.IsInside(point)) { 
     1267            cout << "Error in the algorithm - computed not in the box, but" 
     1268                 << " it is later found in the box" << endl; 
     1269            cout << " j = " << j << endl; 
     1270            cout << " box = " << testbox << endl; 
     1271            cout << " point = " << point << endl; 
     1272            raycaster->CastRaysPacket4(boxMin, boxMax, 
     1273                               origin4, direction4, 
     1274                               result4, dist4); 
     1275          } 
     1276        } 
     1277      } 
     1278#endif       
     1279       
     1280      if (printOut) { 
     1281        printf("%d %4.7f %4.7f %4.7f %4.7f %4.7f %4.7f %d %4.7f\n", 
     1282               i+j, 
     1283               origin4[j].x, 
     1284               origin4[j].y, 
     1285               origin4[j].z, 
     1286               direction4[j].x, 
     1287               direction4[j].y, 
     1288               direction4[j].z, 
     1289               (result4[j] != -1) ? 1 : 0, 
     1290               (result4[j] != -1) ? dist4[j] : 0); 
     1291      } 
    10721292    } // for j     
    10731293  } // for i 
Note: See TracChangeset for help on using the changeset viewer.