Changeset 1292 for GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp

Timestamp:

08/28/06 21:13:40 (18 years ago)

Author:

bittner

Message:

intel ray caster updates

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/Preprocessor.cpp (modified) (16 diffs)

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

@@ -24 +24 @@
 #include "ArchModeler2MLRT.hxx"
 #endif
+
+#define DEBUG_RAYCAST 0
+
 
 namespace GtpVisibilityPreprocessor {
@@ -454 +457 @@
 }
 
+  
+bool
+Preprocessor::ConstructViewCells()
+{
+  // if not already loaded, construct view cells from file
+  if (!mLoadViewCells) {
+        mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
+        
+        // construct view cells using it's own set of samples
+        mViewCellsManager->Construct(this);
+        
+        //-- several visualizations and statistics
+        Debug << "view cells construction finished: " << endl;
+        mViewCellsManager->PrintStatistics(Debug);
+  }
+  return true;
+}
 
 HierarchyManager *Preprocessor::CreateHierarchyManager(const char *name)
@@ -834 +854 @@
 
         Vector3 pointA, pointB;
-        
-        Intersectable *objectA = 
-                CastIntelSingleRay(viewPoint, direction, pointA, box);
-        
-        // cast ray into other direction
-        Intersectable *objectB = 
-                CastIntelSingleRay(viewPoint, -direction, pointB, box);
-
-        const bool validSample = (objectA != objectB);
-        
-        if (validSample) 
-        {       
-                if (objectA) 
-                {
-                        vssRay = new VssRay(pointB,
-                                                                pointA,
-                                                                objectB,
-                                                                objectA,
-                                                                mPass,
-                                                                probability
-                                                                );
-
-                        vssRays.push_back(vssRay);
-                        hits ++;
-                }
-
-                if (objectB) 
-                {
-                        vssRay = new VssRay(pointA,
-                                                                pointB,
-                                                                objectA,
-                                                                objectB,
-                                                                mPass,
-                                                                probability
-                                                                );
-
-                        vssRays.push_back(vssRay);
-                        hits ++;
-                }
-                //Debug << "intel ray: " << *vssRay << endl;
-        }
-
-        //cout << "a";
-        return hits;
+        Vector3 normalA, normalB;
+        Intersectable *objectA = NULL, *objectB = NULL;
+        float dist;
+        
+        int hittriangle;
+        double normal[3];
+        hittriangle = mlrtaIntersectAS(&viewPoint.x,
+                                                                   &direction.x,
+                                                                   normal,
+                                                                   dist);
+        if (hittriangle !=-1 ) {
+          if (hittriangle >= mFaceParents.size())
+                cerr<<"Warning: traingle index out of range! "<<hittriangle<<endl;
+          else {
+                objectA = mFaceParents[hittriangle].mObject;
+                normalA = Vector3(normal[0], normal[1], normal[2]);
+                // Get the normal of that face
+                //              Mesh *mesh = ((MeshInstance *)objectA)->GetMesh();
+                //              normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
+                //-rays[index+i].mDirection; // $$ temporary
+                pointA = viewPoint + direction*dist;
+          }
+        }
+
+        Vector3 dir = -direction;
+        hittriangle = mlrtaIntersectAS(&viewPoint.x,
+                                                                   &dir.x,
+                                                                   normal,
+                                                                   dist);
+        if (hittriangle !=-1 ) {
+          if (hittriangle >= mFaceParents.size())
+                cerr<<"Warning: traingle index out of range! "<<hittriangle<<endl;
+          else {
+                objectB = mFaceParents[hittriangle].mObject;
+                normalB = Vector3(normal[0], normal[1], normal[2]);
+                // Get the normal of that face
+                //              Mesh *mesh = ((MeshInstance *)objectB)->GetMesh();
+                //              normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
+                //-rays[index+i].mDirection; // $$ temporary
+                pointB = viewPoint + dir*dist;
+        }
+        }
+
+        return ProcessRay(viewPoint,
+                                          direction,
+                                          objectA, pointA, normalA,
+                                          objectB, pointB, normalB,
+                                          probability,
+                                          vssRays,
+                                          box
+                                          );
 }
 
@@ -909 +936 @@
 
         if (hittriangle == -1)
-        {
+          {
                 static Ray ray;
                 SetupRay(ray, viewPoint, direction);
-
+                
                 float tmin = 0, tmax;
                 if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
-                {
+                  {
                         tPoint = ray.Extrap(tmax);
-                }
-
+                  }
+                
                 return NULL;
-        }
-        else
-        {
+          }
+        else {
+          if (hittriangle >= mFaceParents.size()) {
+                cerr<<"Warning: traingle index out of range! "<<hittriangle<<endl;
+                return NULL;
+          }
+          else {
+                
                 tPoint[0] = pforg[0] + pfdir[0] * dist;
                 tPoint[1] = pforg[1] + pfdir[1] * dist;
                 tPoint[2] = pforg[2] + pfdir[2] * dist;
-
+                
                 return mFaceParents[hittriangle].mObject;
-        }
+          }
+        }
+        
 }
 
@@ -1050 +1084 @@
 {
   int hits=0;
-
+#if DEBUG_RAYCAST
+  Debug<<"PR ";
+#endif
   if (objectA == NULL && objectB == NULL)
         return 0;
-
+  
   AxisAlignedBox3 sbox = box;
   sbox.Enlarge(Vector3(-Limits::Small));
@@ -1123 +1159 @@
         }
   }
-  
+
+
   return hits;
 }
@@ -1135 +1172 @@
   int i;
   int num = 16;
-  
+
+#if DEBUG_RAYCAST
+  Debug<<"C16 "<<flush;
+#endif
   if (mRayCastMethod == INTEL_RAYCASTER) {
 #ifdef GTP_INTERNAL
@@ -1144 +1184 @@
   int backward_hit_triangles[16];
   float backward_dist[16];
-  
+
+
   Vector3 min = sbox.Min();
   Vector3 max = sbox.Max();
-  
   for (i=0; i < num; i++) {
         mlrtaStoreRayAS16(&rays[index + i].mOrigin.x,
@@ -1161 +1201 @@
 
   for (i=0; i < num; i++) {
-        Vector3 dir = -rays[index+i].mDirection;
+        Vector3 dir = -rays[index + i].mDirection;
         mlrtaStoreRayAS16(&rays[index+i].mOrigin.x,
                                           &dir.x,
@@ -1174 +1214 @@
   
 
+
   for (i=0; i < num; i++) {
         Intersectable *objectA = NULL, *objectB = NULL;
         Vector3 pointA, pointB;
         Vector3 normalA, normalB;
+
+
+  
         if (forward_hit_triangles[i] !=-1 ) {
-          objectA = mFaceParents[forward_hit_triangles[i]].mObject;
-          // Get the normal of that face
-          Mesh *mesh = ((MeshInstance *)objectA)->GetMesh();
-          normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
-          //-rays[index+i].mDirection; // $$ temporary
-          pointA = rays[index+i].Extrap(forward_dist[i]);
+          if (forward_hit_triangles[i] >= mFaceParents.size())
+                cerr<<"Warning: traingle index out of range! "<<forward_hit_triangles[i]<<endl;
+          else {
+                objectA = mFaceParents[forward_hit_triangles[i]].mObject;
+                // Get the normal of that face
+                Mesh *mesh = ((MeshInstance *)objectA)->GetMesh();
+                normalA = mesh->GetFacePlane(mFaceParents[forward_hit_triangles[i]].mFaceIndex).mNormal;
+                //-rays[index+i].mDirection; // $$ temporary
+                pointA = rays[index+i].Extrap(forward_dist[i]);
+          }
         }
         
         if (backward_hit_triangles[i]!=-1) {
-          objectB = mFaceParents[backward_hit_triangles[i]].mObject;
-          Mesh *mesh = ((MeshInstance *)objectB)->GetMesh();
-
-          normalB = mesh->GetFacePlane(mFaceParents[backward_hit_triangles[i]].mFaceIndex).mNormal;
-          
-          //      normalB = rays[index+i].mDirection; // $$ temporary
-          pointB = rays[index+i].Extrap(-backward_dist[i]);
-        }
-        
+          if (backward_hit_triangles[i] >= mFaceParents.size())
+                cerr<<"Warning: traingle index out of range! "<<backward_hit_triangles[i]<<endl;
+          else {
+                objectB = mFaceParents[backward_hit_triangles[i]].mObject;
+                Mesh *mesh = ((MeshInstance *)objectB)->GetMesh();
+                
+                normalB = mesh->GetFacePlane(mFaceParents[backward_hit_triangles[i]].mFaceIndex).mNormal;
+                
+                //        normalB = rays[index+i].mDirection; // $$ temporary
+                pointB = rays[index+i].Extrap(-backward_dist[i]);
+          }
+        }
+
         ProcessRay(rays[index+i].mOrigin,
                            rays[index+i].mDirection,
@@ -1207 +1259 @@
   }
 #endif
+  
   } else {
 
@@ -1217 +1270 @@
         }
   }
-  
+#if DEBUG_RAYCAST
+  Debug<<"C16F\n"<<flush;
+#endif
 }
 
@@ -1236 +1291 @@
           i += 16;
         } else {
+
           CastRay(rays[i].mOrigin,
                           rays[i].mDirection,
@@ -1241 +1297 @@
                           vssRays,
                           mViewCellsManager->GetViewSpaceBox());
+
           i++;
         }
@@ -1252 +1309 @@
 }
 
-
-int Preprocessor::CastRay(
-                                                  const Vector3 &viewPoint,
-                                                  const Vector3 &direction,
-                                                  const float probability,
-                                                  VssRayContainer &vssRays,
-                                                  const AxisAlignedBox3 &box
-                                                  )
-{
-        switch (mRayCastMethod)
+Intersectable *
+Preprocessor::CastSimpleRay(
+                                                        const Vector3 &viewPoint,
+                                                        const Vector3 &direction,
+                                                        const AxisAlignedBox3 &box,
+                                                        Vector3 &point,
+                                                        Vector3 &normal
+                                                        )
+{
+  Intersectable *result = NULL;
+  switch (mRayCastMethod)
+        {
+        case INTEL_RAYCASTER: {
+          float dist;
+          int hittriangle;
+          double n[3];
+          hittriangle = mlrtaIntersectAS(&viewPoint.x,
+                                                                         &direction.x,
+                                                                         n,
+                                                                         dist);
+          if (hittriangle !=-1 ) {
+                if (hittriangle >= mFaceParents.size())
+                  cerr<<"Warning: traingle index out of range! "<<hittriangle<<endl;
+                else {
+                  result = mFaceParents[hittriangle].mObject;
+                  normal = Vector3(n[0], n[1], n[2]);
+                  point = viewPoint + direction*dist;
+                }
+          }
+          break;
+        }
+        case INTERNAL_RAYCASTER:
+        default: {
+          static Ray ray;
+          
+          ray.intersections.clear();
+          // do not store anything else then intersections at the ray
+          ray.Init(viewPoint, direction, Ray::LOCAL_RAY);
+          
+          ray.mFlags &= ~Ray::CULL_BACKFACES;
+          
+          if (mKdTree->CastRay(ray)) {
+                result = ray.intersections[0].mObject;
+                point = ray.Extrap(ray.intersections[0].mT);
+                normal = ray.intersections[0].mNormal;
+          }
+          break;
+        }
+        }
+  return result;
+}
+
+int
+Preprocessor::CastRay(
+                                          const Vector3 &viewPoint,
+                                          const Vector3 &direction,
+                                          const float probability,
+                                          VssRayContainer &vssRays,
+                                          const AxisAlignedBox3 &box
+                                          )
+{
+#if DEBUG_RAYCAST
+  Debug<<"CR "<<flush;
+#endif
+  switch (mRayCastMethod)
         {
         case INTEL_RAYCASTER:
@@ -1269 +1381 @@
                 return CastInternalRay(viewPoint, direction, probability, vssRays, box);
         }
+#if DEBUG_RAYCAST
+  Debug<<"CRF "<<flush;
+#endif  
 }