Changeset 1933 for GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp

Timestamp:

01/03/07 16:48:59 (17 years ago)

Author:

mattausch

Message:

worked on gvs reverse sampling (still in debug state)

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/GvsPreprocessor.cpp (modified) (7 diffs)

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

@@ -61 +61 @@
         
         // distance large => this is likely to be a discontinuity
+#if 1
         if ((predictedLen - len) > mThreshold)
+#else // rather use relative distance
+        if ((predictedLen / len) > mThreshold)
+#endif
         {
                 cout << "d";
+                // apply reverse sampling to find the gap
                 VssRay *newRay = ReverseSampling(currentRay, hitTriangle, oldRay);
-                
+
+                if (!newRay)
+                        return false;
+
                 // set flag for visualization
                 newRay->mFlags |= VssRay::ReverseSample;
@@ -71 +79 @@
                 // if ray is not further processed => can delete ray
                 if (!HandleRay(newRay))
+                {
                         delete newRay;
-                
+                }
+                else if (mVssRays.size() < 3)
+                {
+                        mVssRays.push_back(new VssRay(oldRay));
+                        mVssRays.push_back(new VssRay(currentRay));
+                        mVssRays.push_back(new VssRay(*newRay));
+                }
+
                 return true;
         }
@@ -84 +100 @@
         // compute the contribution to the view cells
         const bool storeRaysForViz = true;
+
         mViewCellsManager->ComputeSampleContribution(*vssRay, 
                                                                                                  true, 
@@ -317 +334 @@
 
 
-Vector3 GvsPreprocessor::GetPassingPoint(const VssRay &currentRay,
+/*Vector3 GvsPreprocessor::GetPassingPoint(const VssRay &currentRay,
                                                                                  const Triangle3 &hitTriangle,
                                                                                  const VssRay &oldRay) const
@@ -333 +350 @@
 
         return newPoint;
+}*/
+
+
+Vector3 GvsPreprocessor::GetPassingPoint(const VssRay &currentRay,
+                                                                                 const Triangle3 &occluder,
+                                                                                 const VssRay &oldRay) const
+{
+        //-- The plane p = (xp, hit(x), hit(xold)) is intersected
+        //-- with the newly found occluder (xold is the previous ray from
+        //-- which x was generated). On the intersecting line, we select a point
+        //-- pnew which lies just outside of the new triangle so the ray
+        //-- just passes through the gap
+
+        const Plane3 plane(currentRay.GetOrigin(), 
+                                           currentRay.GetTermination(), 
+                                           oldRay.GetTermination());
+        
+        Vector3 pt1, pt2;
+
+        const bool intersects = occluder.GetPlaneIntersection(plane, pt1, pt2);
+
+        cout << "triangle: " << occluder << " pt1: " << pt1 << " pt2: " << pt2 << endl;
+        if (!intersects)
+                cerr << "big error!! no intersection" << endl;
+
+        // get the intersection point on the old ray
+        const Plane3 triPlane(occluder.GetNormal(), occluder.mVertices[0]);
+
+        const float t = triPlane.FindT(oldRay.mOrigin, oldRay.mTermination);
+        const Vector3 pt3 = oldRay.mOrigin + t * (oldRay.mTermination - oldRay.mOrigin);
+
+        // Evaluate new hitpoint just outside the triangle
+        Vector3 newPoint;
+
+        const float eps = mEps;
+        // the point is chosen to be on the side closer to the original ray
+        if (Distance(pt1, pt3) < Distance(pt2, pt3))
+        {
+                newPoint = pt1 + eps * (pt1 - pt2);
+        }       
+        else
+        {
+                newPoint = pt2 + eps * (pt2 - pt1);
+        }
+
+        cout << "passing point: " << newPoint << endl << endl;
+        return newPoint;
 }
 
@@ -340 +404 @@
                                                                                  const VssRay &oldRay)
 {
-        //-- The plane p = (xp, hit(x), hit(xold)) is intersected
-        //-- with the newly found triangle (xold is the previous ray from
-        //-- which x was generated). On the intersecting line, we select a point
-        //-- pnew which lies just outside of the new triangle so the ray
-        //-- just passes by inside the gap
-    const Vector3 newPoint = GetPassingPoint(currentRay, hitTriangle, oldRay);
+        // get triangle occluding the path to the hit mesh
+        Triangle3 occluder;
+        Intersectable *tObj = currentRay.mTerminationObject;
+        // q: why can this happen?
+        if (!tObj)
+                return NULL;
+
+        // other types not implemented yet
+        if (tObj->Type() == Intersectable::TRIANGLE_INTERSECTABLE)
+                occluder = dynamic_cast<TriangleIntersectable *>(tObj)->GetItem();
+        else
+                cout << "not yet implemented" << endl;
+        
+        // get a point which is passing just outside of the occluder
+    const Vector3 newPoint = GetPassingPoint(currentRay, occluder, oldRay);
         const Vector3 predicted = CalcPredictedHitPoint(currentRay, hitTriangle, oldRay);
 
         //-- Construct the mutated ray with xnew,
         //-- dir = predicted(x)- pnew as direction vector
-        const Vector3 newDir = predicted - newPoint ;
-
-        // take xnew,p = intersect(viewcell, line(pnew, predicted(x)) as origin ?
+        const Vector3 newDir = predicted - newPoint;
+
+        // take xnew, p = intersect(viewcell, line(pnew, predicted(x)) as origin ?
         // difficult to say!!
-        const Vector3 newOrigin = newDir * -5000.0f;
-
-        ++ mReverseSamples;
-
-        return new VssRay(currentRay);
+        const Vector3 newOrigin = newPoint + newDir * -5000.0f;
+
+        const SimpleRay simpleRay(newOrigin, newDir, SamplingStrategy::GVS, 1.0f);
+
+        VssRay *reverseRay = 
+                mRayCaster->CastRay(simpleRay, mViewCellsManager->GetViewSpaceBox());
+
+    ++ mReverseSamples;
+
+        return reverseRay;
 }
 
@@ -533 +611 @@
         }
 
-        exporter->ExportRays(mVssRays);
+        VssRayContainer::const_iterator rit, rit_end = mVssRays.end();
+        for (rit = mVssRays.begin(); rit != rit_end; ++ rit)
+        {
+                Intersectable *obj = (*rit)->mTerminationObject;
+                exporter->ExportIntersectable(obj);
+        }
+
+        VssRayContainer vcRays, vcRays2, vcRays3;
+
+        // prepare some rays for output
+        for (rit = mVssRays.begin(); rit != rit_end; ++ rit)
+        {
+                const float p = RandomValue(0.0f, (float)mVssRays.size());
+                if (1)//(p < raysOut)
+                {
+                        if ((*rit)->mFlags & VssRay::BorderSample)
+                        {
+                                vcRays.push_back(*rit);
+                        }
+                        else if ((*rit)->mFlags & VssRay::ReverseSample)
+                        {
+                                vcRays2.push_back(*rit);
+                        }
+                        else
+                        {
+                                vcRays3.push_back(*rit);
+                        }       
+                }
+        }
+
+        exporter->ExportRays(vcRays, RgbColor(1, 0, 0));
+        exporter->ExportRays(vcRays2, RgbColor(0, 1, 0));
+        exporter->ExportRays(vcRays3, RgbColor(1, 1, 1));
+
+        //exporter->ExportRays(mVssRays);
         delete exporter;
 }