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

Timestamp:

08/21/06 18:39:49 (18 years ago)

Author:

mattausch

Message:

 

File:

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

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

@@ -16 +16 @@
 #include "OspTree.h"
 #include "ObjParser.h"
-#ifdef INTEL_COMPILER
+#ifdef GTP_INTERNAL
 #include "ArchModeler2MLRT.hxx"
 #endif
@@ -123 +123 @@
 mVspBspTree(NULL),
 mViewCellsManager(NULL),
-mRenderSimulator(NULL)
+mRenderSimulator(NULL),
+mPass(0)
 {
         Environment::GetSingleton()->GetBoolValue("Preprocessor.useGlRenderer", mUseGlRenderer);
@@ -757 +758 @@
         {
         case INTEL_RAYCASTER:
-#ifdef INTEL_COMPILER
+#ifdef GTP_INTERNAL
                 return mlrtaLoadAS(externKdTree.c_str());
 #endif
@@ -768 +769 @@
 }
 
-}
+
+int Preprocessor::CastIntelDoubleRay(
+                                                                         const Vector3 &viewPoint,
+                                                                         const Vector3 &direction,
+                                                                         const float probability,
+                                                                         VssRayContainer &vssRays,
+                                                                         const AxisAlignedBox3 &box
+                                                                         )
+{
+        VssRay *vssRay  = NULL;
+        int hits = 0;
+
+        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,
+                                                                probability,
+                                                                mPass);
+
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+
+                if (objectB) 
+                {
+                        vssRay = new VssRay(pointA,
+                                                                pointB,
+                                                                objectA,
+                                                                objectB,
+                                                                probability,
+                                                                mPass);
+
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+                //Debug << "intel ray: " << *vssRay << endl;
+        }
+        //cout << "a";
+        return hits;
+}
+
+
+Intersectable *Preprocessor::CastIntelSingleRay(const Vector3 &viewPoint,
+                                                                                                const Vector3 &direction,
+                                                                                                //const float probability,
+                                                                                                Vector3 &tPoint,
+                                                                                                const AxisAlignedBox3 &box
+                                                                                                )
+{
+        AxisAlignedBox3 sbox = box;
+        sbox.Enlarge(Vector3(-Limits::Small));
+
+        if (!sbox.IsInside(viewPoint))
+                return 0;
+        
+        float pforg[3];
+        float pfdir[3];
+        double pfnorm[3];
+
+        pforg[0] = viewPoint[0]; pforg[1] = viewPoint[1]; pforg[2] = viewPoint[2];
+        pfdir[0] = direction[0]; pfdir[1] = direction[1]; pfdir[2] = direction[2];
+
+        float dist = 0;
+#ifdef GTP_INTERNAL
+        const int hittriangle = mlrtaIntersectAS(pforg, pfdir, pfnorm, dist);
+#else
+        const int hittriangle = -1;
+#endif
+
+        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
+        {
+                tPoint[0] = pforg[0] + pfdir[0] * dist;
+                tPoint[1] = pforg[1] + pfdir[1] * dist;
+                tPoint[2] = pforg[2] + pfdir[2] * dist;
+
+                return mFaceParents[hittriangle];
+        }
+}
+
+
+int Preprocessor::CastInternalRay(
+                                                                  const Vector3 &viewPoint,
+                                                                  const Vector3 &direction,
+                                                                  const float probability,
+                                                                  VssRayContainer &vssRays,
+                                                                  const AxisAlignedBox3 &box
+                                                                  )
+{
+    int hits = 0;
+        static Ray ray;
+
+        AxisAlignedBox3 sbox = box;
+        sbox.Enlarge(Vector3(-Limits::Small));
+
+        if (!sbox.IsInside(viewPoint))
+                return 0;
+        
+        SetupRay(ray, viewPoint, direction);
+        
+        // cast ray to KD tree to find intersection with other objects
+        Intersectable *objectA, *objectB;
+        
+        Vector3 pointA;
+        Vector3 pointB;
+
+        //float bsize = Magnitude(box.Size());
+        if (!mDetectEmptyViewSpace)
+                ray.mFlags &= ~Ray::CULL_BACKFACES;
+        else
+                ray.mFlags |= Ray::CULL_BACKFACES;
+
+        if (mKdTree->CastRay(ray)) 
+        {
+                objectA = ray.intersections[0].mObject;
+                pointA = ray.Extrap(ray.intersections[0].mT);
+        } 
+        else 
+        {
+                objectA = NULL;
+                // compute intersection with the scene bounding box
+                float tmin, tmax;
+                if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+                        pointA = ray.Extrap(tmax);
+                else
+                        return 0;
+        }
+
+        // matt: point A could be undefined?
+
+        // cast ray into opposite direction
+        if (1 && mDetectEmptyViewSpace) {
+                SetupRay(ray, pointA, -direction);
+        } else
+                SetupRay(ray, viewPoint, -direction);
+  
+        if (!mDetectEmptyViewSpace)
+                ray.mFlags &= ~Ray::CULL_BACKFACES;
+        else
+                ray.mFlags |= Ray::CULL_BACKFACES;
+
+        if (mKdTree->CastRay(ray)) 
+        {
+                objectB = ray.intersections[0].mObject;
+                pointB = ray.Extrap(ray.intersections[0].mT);
+        } 
+        else 
+        {
+                objectB = NULL;
+                float tmin, tmax;
+                
+                if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
+                        pointB = ray.Extrap(tmax);
+                else
+                        return 0;
+        }
+  
+        //bool thesame = objectA && (objectA == objectB);
+        
+        //  if (objectA == NULL && objectB != NULL) {
+        if (1 && mDetectEmptyViewSpace) 
+        {
+                // cast again to ensure that there is no objectA
+                SetupRay(ray, pointB, direction);
+                ray.mFlags |= Ray::CULL_BACKFACES;
+                
+                if (mKdTree->CastRay(ray)) 
+                {
+                        objectA = ray.intersections[0].mObject;
+                        pointA = ray.Extrap(ray.intersections[0].mT);
+                }
+        }
+
+  
+        VssRay *vssRay  = NULL;
+
+        bool validSample = (objectA != objectB);
+        
+        //if (validSample && thesame) Debug << "warning!!" << endl;
+
+        if (0 && mDetectEmptyViewSpace) 
+        {   
+                // consider all samples valid
+                // check if the viewpoint lies on the line segment AB
+                if (Distance(pointA, pointB) <
+                        Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) 
+                {
+                        validSample = false;
+                }
+        }
+        
+        if (validSample) 
+        {       
+                if (objectA) 
+                {
+                        vssRay = new VssRay(pointB,
+                                                                pointA,
+                                                                objectB,
+                                                                objectA,
+                                                                probability,
+                                                                mPass);
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+
+                if (objectB) 
+                {
+                        vssRay = new VssRay(pointA,
+                                                                pointB,
+                                                                objectA,
+                                                                objectB,
+                                                                probability,
+                                                                mPass);
+                        vssRays.push_back(vssRay);
+                        hits ++;
+                }
+                //Debug << "internal ray: " << *vssRay << endl << endl;
+        }
+//cout << "b";
+        return hits;
+}
+
+
+int Preprocessor::CastRay(
+                                                  const Vector3 &viewPoint,
+                                                  const Vector3 &direction,
+                                                  const float probability,
+                                                  VssRayContainer &vssRays,
+                                                  const AxisAlignedBox3 &box
+                                                  )
+{
+        switch (mRayCastMethod)
+        {
+        case INTEL_RAYCASTER:
+                return CastIntelDoubleRay(viewPoint, direction, probability, vssRays, box);
+        case INTERNAL_RAYCASTER:
+        default:
+                return CastInternalRay(viewPoint, direction, probability, vssRays, box);
+        }
+}
+
+
+void Preprocessor::SetupRay(Ray &ray,
+                                                        const Vector3 &point,
+                                                        const Vector3 &direction
+                                                        )
+{
+        ray.Clear();
+        // do not store anything else then intersections at the ray
+        ray.Init(point, direction, Ray::LOCAL_RAY);
+}
+
+}