Changeset 2001 for GTP/trunk/Lib/Vis/Preprocessing/src/Mutation.cpp

Timestamp:

01/20/07 14:03:37 (17 years ago)

Author:

bittner

Message:

mutation updates

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/Mutation.cpp (modified) (15 diffs)

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

@@ -9 +9 @@
 #include "RndGauss.h"
 #include "Mutation.h"
+#include "Exporter.h"
 
 #ifdef GTP_INTERNAL
@@ -20 +21 @@
 
 #define USE_SIL_TERMINATION_MUTATION 1
+#define MUTATE_ORIGIN 1
 
 #define EVALUATE_MUTATION_STATS 1
+
+#define Q_SEARCH_STEPS 2
 
 void
@@ -51 +55 @@
   int dummyNcMutations = 0;
   int dummyCMutations = 0;
+
+  int reverseCandidates = 0;
   
   for (int i=0; i < vssRays.size(); i++) {
@@ -86 +92 @@
                 *mRays[mBufferStart].mRay = *vssRays[i];
                 mRays[mBufferStart].mMutations = 0;
+                mRays[mBufferStart].ResetReverseMutation();
                 //              mRays[mBufferStart] = RayEntry(newRay);
                 mBufferStart++;
                 if (mBufferStart >= mMaxRays)
                   mBufferStart = 0;
+                
+
           }
         } else {
-#if EVALUATE_MUTATION_STATS 
           if (vssRays[i]->mDistribution == MUTATION_BASED_DISTRIBUTION &&
                   vssRays[i]->mGeneratorId != -1
                   ) {
+                // check whether not to store a new backward mutation candidate
+                VssRay *oldRay = mRays[vssRays[i]->mGeneratorId].mRay;
+                VssRay *newRay = vssRays[i];
+
+#define DIST_THRESHOLD 3.0f
+
+                Intersectable *oldObject =
+                  mPreprocessor.mViewCellsManager->GetIntersectable(
+                                                                                                                        *oldRay,
+                                                                                                                        true);
+                
+
+                if (!mRays[newRay->mGeneratorId].HasReverseMutation()) {
+                  if (DotProd(oldRay->GetDir(), newRay->GetDir()) > 0.0f) {
+                  float oldDist = Magnitude(oldRay->mTermination - newRay->mOrigin);
+                  float newDist = Magnitude(newRay->mTermination - newRay->mOrigin);
+                  
+                  if (newDist < oldDist - oldObject->GetBox().Radius()*DIST_THRESHOLD) {
+                        Vector3 origin, termination;
+                        if (ComputeReverseMutation(*oldRay, *newRay, origin, termination)) {
+                          mRays[newRay->mGeneratorId].SetReverseMutation(origin, termination);
+                        }
+                        
+                        reverseCandidates++;
+                        //mReverseCandidates
+                  }
+                  }
+                }
+#if EVALUATE_MUTATION_STATS 
                 mutationRays++;
-
+                
                 Intersectable *newObject =
                   mPreprocessor.mViewCellsManager->GetIntersectable(
@@ -103 +140 @@
                                                                                                                         true);
 
-                Intersectable *oldObject =
-                  mPreprocessor.mViewCellsManager->GetIntersectable(
-                                                                                                                        *mRays[vssRays[i]->mGeneratorId].mRay,
-                                                                                                                        true);
 
                 if (oldObject == newObject)
                   dummyNcMutations++;
+#endif
           }
-#endif
         }
   }
-
+  
   if (mutationRays) {
         cout<<"Mutated rays:"<<mutationRays<<endl;
@@ -121 +154 @@
         cout<<"Dummy NC mutations ratio:"<<100.0f*dummyNcMutations/(float)mutationRays<<"%"<<endl;
         cout<<"Dummy C mutations ratio:"<<100.0f*dummyCMutations/(float)mutationRays<<"%"<<endl;
+        cout<<"Reverse candidates:"<<reverseCandidates<<endl;
   }
 
@@ -259 +293 @@
 }
 
+bool
+MutationBasedDistribution::ComputeReverseMutation(
+                                                                                                  const VssRay &oldRay,
+                                                                                                  const VssRay &newRay,
+                                                                                                  Vector3 &origin,
+                                                                                                  Vector3 &termination
+                                                                                                  )
+{
+  // first reconstruct the termination point
+  Vector3 oldDir = Normalize(oldRay.GetDir());
+  Plane3 oldPlane(oldDir, oldRay.mTermination);
+  
+  termination = oldPlane.FindIntersection(newRay.mOrigin,
+                                                                                  newRay.mTermination);
+  
+  // now find the new origin of the ray by casting ray backward from the termination and termining
+  // silhouette point with respect to the occluding object (object containing the newRay termination)
+
+  Plane3 newPlane(oldDir, newRay.mTermination);
+
+  Vector3 oldPivot = newPlane.FindIntersection(oldRay.mOrigin,
+                                                                                           oldRay.mTermination);
+
+  Vector3 newPivot = newRay.mTermination;
+  Vector3 line = 2.0f*(oldPivot - newPivot);
+
+  Intersectable *occluder = mPreprocessor.mViewCellsManager->GetIntersectable(
+                                                                                                                                                          newRay,
+                                                                                                                                                          true);
+  
+  AxisAlignedBox3 box = occluder->GetBox();
+  box.Scale(2.0f);
+  
+  const int packetSize = 4;
+  static int hit_triangles[packetSize];
+  static float dist[packetSize];
+  static Vector3 dirs[packetSize];
+  static Vector3 shifts[packetSize];
+  // now find the silhouette along the line
+  int i;
+  float left = 0.0f;
+  float right = 1.0f;
+  // cast rays to find silhouette ray
+  for (int j=0; j < Q_SEARCH_STEPS; j++) {
+        for (i=0; i < packetSize; i++) {
+          float r = left + (i+1)*(right-left)/(packetSize+1);
+          shifts[i] = r*line;
+          dirs[i] = Normalize(newPivot + shifts[i] - termination );
+          mlrtaStoreRayASEye4(&termination.x,
+                                                  &dirs[i].x,
+                                                  i);
+        }
+        
+        mlrtaTraverseGroupASEye4(&box.Min().x,
+                                                         &box.Max().x,
+                                                         hit_triangles,
+                                                         dist);
+        
+        for (i=0; i < packetSize; i++) {
+          if (hit_triangles[i] == -1) {
+                // break on first passing ray
+                break;
+          }
+        }
+        float rr = left + (i+1)*(right-left)/(packetSize+1);
+        float rl = left + i*(right-left)/(packetSize+1);
+        left = rl;
+        right = rr;
+  }
+
+  float t = right;
+  if (right==1.0f)
+        return false;
+  
+  if (i == packetSize)
+        origin = newPivot + right*line;
+  else
+        origin = newPivot + shifts[i];
+
+  if (0) {
+        
+        static VssRayContainer rRays;
+        static int counter = 0;
+        char filename[256];
+
+        if (counter < 50) {
+          sprintf(filename, "reverse_rays_%03d.x3d", counter++);
+          
+          VssRay tRay(origin, termination, NULL, NULL);
+          rRays.push_back((VssRay *)&oldRay);
+          rRays.push_back((VssRay *)&newRay);
+          rRays.push_back(&tRay);
+          
+          Exporter *exporter = NULL;
+          exporter = Exporter::GetExporter(filename);
+          
+          exporter->SetFilled();
+          
+          Intersectable *occludee = mPreprocessor.mViewCellsManager->GetIntersectable(
+                                                                                                                                                                  oldRay,
+                                                                                                                                                                  true);
+          
+          exporter->SetForcedMaterial(RgbColor(0,0,1));
+          exporter->ExportIntersectable(occluder);
+          exporter->SetForcedMaterial(RgbColor(0,1,0));
+          exporter->ExportIntersectable(occludee);
+          exporter->ResetForcedMaterial();
+          
+          exporter->SetWireframe();
+          
+          
+          exporter->ExportRays(rRays, RgbColor(1, 0, 0));
+          delete exporter;
+          rRays.clear();
+        }
+  }
+
+
+  
+  return true;
+  
+  // now the origin and termination is swapped compred to the generator ray
+  // swap(origin, termination);???
+  // -> perhaps not neccessary as the reverse mutation wil only be used once!
+}
 
 Vector3
@@ -270 +429 @@
                                                                                                                                 )
 {
-  const int packetSize = 16;
-
+  const int packetSize = 4;
   static int hit_triangles[packetSize];
   static float dist[packetSize];
   static Vector3 dirs[packetSize];
+  static Vector3 shifts[packetSize];
   // mutate the 
   float alpha = RandomValue(0.0f, 2.0f*M_PI);
+  //float alpha = vr2.x*2.0f*M_PI;
   
   // direction along which we will mutate the ray
@@ -283 +443 @@
   //  cout<<line<<endl;
   // create 16 rays along the selected dir
-  
+  int i;
+  float left = 0.0f;
+  float right = radius;
   // cast rays to find silhouette ray
-  for (int i=0; i < packetSize; i++) {
-        dirs[i] = Normalize(ray.mTermination + ((radius/(packetSize - i))*line) - origin );
-        mlrtaStoreRayAS16(&origin.x,
-                                          &dirs[i].x,
-                                          i);
-  }
-  
-  mlrtaTraverseGroupAS16(&box.Min().x,
-                                                 &box.Max().x,
-                                                 hit_triangles,
-                                                 dist);
-  
-  for (int i=0; i < packetSize; i++) {
-        if (hit_triangles[i] == -1 || !box.IsInside(origin + dist[i]*dirs[i])) {
-          // break on first passing ray
-          break;
+  for (int j=0; j < Q_SEARCH_STEPS; j++) {
+        for (i=0; i < packetSize; i++) {
+          float r = left + (i+1)*(right-left)/(packetSize+1);
+          shifts[i] = r*line;
+          dirs[i] = Normalize(ray.mTermination + shifts[i] - origin );
+          mlrtaStoreRayASEye4(&origin.x,
+                                                  &dirs[i].x,
+                                                  i);
         }
+        
+        mlrtaTraverseGroupASEye4(&box.Min().x,
+                                                         &box.Max().x,
+                                                         hit_triangles,
+                                                         dist);
+        
+        for (i=0; i < packetSize; i++) {
+          if (hit_triangles[i] == -1) {
+                //        if (hit_triangles[i] == -1 || !box.IsInside(origin + dist[i]*dirs[i])) {
+                // break on first passing ray
+                break;
+          }
+        }
+        float rr = left + (i+1)*(right-left)/(packetSize+1);
+        float rl = left + i*(right-left)/(packetSize+1);
+        left = rl;
+        right = rr;
   }
   
@@ -307 +478 @@
         //      cerr<<"Warning: hit the same box here should never happen!"<<endl;
         // shift the ray even a bit more
-        //      cout<<"W"<<i<<endl;
-        return ray.mTermination + (RandomValue(1.0f, 2.0f)*radius)*line;
-  }
-
+        //cout<<"W"<<i<<endl;
+        //      return (RandomValue(1.0f, 1.5f)*radius)*line;
+        return right*line;
+  }
+  
   //  cout<<i<<endl;
-  return dirs[i];
+  return shifts[i];
 }
 
@@ -386 +558 @@
   mLastIndex = index;
 
+  if (mRays[index].HasReverseMutation()) {
+        //cout<<"R "<<mRays[index].mutatedOrigin<<" "<<mRays[index].mutatedTermination<<endl;
+        sray = SimpleRay(mRays[index].mutatedOrigin,
+                                         Normalize(mRays[index].mutatedTermination - mRays[index].mutatedOrigin),
+                                         MUTATION_BASED_DISTRIBUTION, 1.0f);
+        sray.mGeneratorId = index;
+        mRays[index].ResetReverseMutation();
+        mRays[index].mMutations++;
+        return true;
+  }
+  
 #if USE_SILHOUETTE_MUTATIONS
   return GenerateSilhouetteMutation(index, sray);
@@ -391 +574 @@
   return GenerateMutation(index, sray);
 #endif
-  
 }
 
@@ -410 +592 @@
 
   mRays[index].mHalton.GetNext(4, rr);
+  //  rr[0] = RandomValue(0.0f,0.99999f);
+  //  rr[1] = RandomValue(0.0f,0.99999f);
+  //  rr[2] = RandomValue(0.0f,0.99999f);
+  //  rr[3] = RandomValue(0.0f,0.99999f);
   
   // mutate the origin
@@ -430 +616 @@
   // optimal for Vienna 0.5f
   
-  float radiusExtension = 0.05f;
+  float radiusExtension = 0.5f;
   //  + mRays[index].mMutations/50.0f;
-
+  
   float mutationRadius = objectRadius*radiusExtension;
-
+  
   // tmp for pompeii
-  mutationRadius = 0.22f;
-  
+  //  mutationRadius = 0.22f;
+
+#if MUTATE_ORIGIN
   origin += ComputeOriginMutation(*ray, U, V,
                                                                   Vector2(rr[0], rr[1]),
                                                                   mutationRadius);
+#endif
   
 #if USE_SIL_TERMINATION_MUTATION
@@ -448 +636 @@
                                                                                                           U, V,
                                                                                                           Vector2(rr[2], rr[3]),
-                                                                                                          3.0f*objectRadius);
+                                                                                                          2.0f*objectRadius);
 #else
   termination += ComputeTerminationMutation(*ray, U, V,