source: GTP/trunk/Lib/Vis/Preprocessing/src/Mutation.cpp @ 2006

Revision 2006, 20.0 KB checked in by bittner, 17 years ago (diff)

merge

Line 
1#include "SamplingStrategy.h"
2#include "Ray.h"
3#include "Intersectable.h"
4#include "Preprocessor.h"
5#include "ViewCellsManager.h"
6#include "AxisAlignedBox3.h"
7#include "RssTree.h"
8#include "Vector2.h"
9#include "RndGauss.h"
10#include "Mutation.h"
11#include "Exporter.h"
12
13#ifdef GTP_INTERNAL
14#include "ArchModeler2MLRT.hxx"
15#endif
16
17namespace GtpVisibilityPreprocessor {
18
19#define MUTATION_USE_CDF 0
20#define USE_SILHOUETTE_MUTATIONS 0
21
22#define USE_SIL_TERMINATION_MUTATION 1
23#define MUTATE_ORIGIN 0
24
25#define EVALUATE_MUTATION_STATS 1
26
27#define Q_SEARCH_STEPS 3
28
29void
30MutationBasedDistribution::Update(VssRayContainer &vssRays)
31{
32  //  for (int i=0; i < mRays.size(); i++)
33  //    cout<<mRays[i].mMutations<<" ";
34  //  cout<<endl;
35  cerr<<"Muattion update..."<<endl;
36  cerr<<"rays = "<<mRays.size()<<endl;
37  if (mRays.size()) {
38        cerr<<"Oversampling factors = "<<
39          GetEntry(0).mMutations<<" "<<
40          GetEntry(1).mMutations<<" "<<
41          GetEntry(2).mMutations<<" "<<
42          GetEntry(3).mMutations<<" "<<
43          GetEntry(4).mMutations<<" "<<
44          GetEntry(5).mMutations<<" ... "<<
45          GetEntry(mRays.size()-6).mMutations<<" "<<
46          GetEntry(mRays.size()-5).mMutations<<" "<<
47          GetEntry(mRays.size()-4).mMutations<<" "<<
48          GetEntry(mRays.size()-3).mMutations<<" "<<
49          GetEntry(mRays.size()-2).mMutations<<" "<<
50          GetEntry(mRays.size()-1).mMutations<<endl;
51  }
52  int contributingRays = 0;
53
54  int mutationRays = 0;
55  int dummyNcMutations = 0;
56  int dummyCMutations = 0;
57
58  int reverseCandidates = 0;
59 
60  for (int i=0; i < vssRays.size(); i++) {
61        if (vssRays[i]->mPvsContribution) {
62          // reset the counter of unsuccsseful mutation for a generating ray (if it exists)
63          if (vssRays[i]->mDistribution == MUTATION_BASED_DISTRIBUTION &&
64                  vssRays[i]->mGeneratorId != -1
65                  ) {
66                mRays[vssRays[i]->mGeneratorId].mUnsuccessfulMutations = 0;
67#if EVALUATE_MUTATION_STATS
68                mutationRays++;
69               
70                Intersectable *newObject =
71                  mPreprocessor.mViewCellsManager->GetIntersectable(
72                                                                                                                        *vssRays[i],
73                                                                                                                        true);
74
75                Intersectable *oldObject =
76                  mPreprocessor.mViewCellsManager->GetIntersectable(
77                                                                                                                        *mRays[vssRays[i]->mGeneratorId].mRay,
78                                                                                                                        true);
79               
80                if (oldObject == newObject)
81                  dummyCMutations++;
82#endif
83          }
84          contributingRays++;
85          if (mRays.size() < mMaxRays) {
86                VssRay *newRay = new VssRay(*vssRays[i]);
87                // add this ray
88                newRay->Ref();
89                mRays.push_back(RayEntry(newRay));
90          } else {
91                // unref the old ray
92                *mRays[mBufferStart].mRay = *vssRays[i];
93                mRays[mBufferStart].mMutations = 0;
94                mRays[mBufferStart].ResetReverseMutation();
95                //              mRays[mBufferStart] = RayEntry(newRay);
96                mBufferStart++;
97                if (mBufferStart >= mMaxRays)
98                  mBufferStart = 0;
99               
100
101          }
102        } else {
103          if (vssRays[i]->mDistribution == MUTATION_BASED_DISTRIBUTION &&
104                  vssRays[i]->mGeneratorId != -1
105                  ) {
106                // check whether not to store a new backward mutation candidate
107                VssRay *oldRay = mRays[vssRays[i]->mGeneratorId].mRay;
108                VssRay *newRay = vssRays[i];
109
110#define DIST_THRESHOLD 3.0f
111
112                Intersectable *oldObject =
113                  mPreprocessor.mViewCellsManager->GetIntersectable(
114                                                                                                                        *oldRay,
115                                                                                                                        true);
116               
117
118                if (!mRays[newRay->mGeneratorId].HasReverseMutation()) {
119                  if (DotProd(oldRay->GetDir(), newRay->GetDir()) > 0.0f) {
120                  float oldDist = Magnitude(oldRay->mTermination - newRay->mOrigin);
121                  float newDist = Magnitude(newRay->mTermination - newRay->mOrigin);
122                 
123                  if (newDist < oldDist - oldObject->GetBox().Radius()*DIST_THRESHOLD) {
124                        Vector3 origin, termination;
125                        if (ComputeReverseMutation(*oldRay, *newRay, origin, termination)) {
126                          mRays[newRay->mGeneratorId].SetReverseMutation(origin, termination);
127                        }
128                       
129                        reverseCandidates++;
130                        //mReverseCandidates
131                  }
132                  }
133                }
134#if EVALUATE_MUTATION_STATS
135                mutationRays++;
136               
137                Intersectable *newObject =
138                  mPreprocessor.mViewCellsManager->GetIntersectable(
139                                                                                                                        *vssRays[i],
140                                                                                                                        true);
141
142
143                if (oldObject == newObject)
144                  dummyNcMutations++;
145#endif
146          }
147        }
148  }
149 
150  if (mutationRays) {
151        cout<<"Mutated rays:"<<mutationRays<<endl;
152        cout<<"Dummy mutations ratio:"<<100.0f*(dummyCMutations + dummyNcMutations)/
153          (float)mutationRays<<"%"<<endl;
154        cout<<"Dummy NC mutations ratio:"<<100.0f*dummyNcMutations/(float)mutationRays<<"%"<<endl;
155        cout<<"Dummy C mutations ratio:"<<100.0f*dummyCMutations/(float)mutationRays<<"%"<<endl;
156        cout<<"Reverse candidates:"<<reverseCandidates<<endl;
157  }
158
159  float pContributingRays = contributingRays/(float)vssRays.size();
160  float importance = 1.0f/(pContributingRays + 1e-5);
161  // float importance = 1.0f;
162  // set this values for last contributingRays
163  int index = mBufferStart - 1;
164 
165  for (int i=0; i < contributingRays; i++, index--) {
166        if (index < 0)
167          index = mRays.size()-1;
168        mRays[index].mImportance = importance;
169  }
170
171#if MUTATION_USE_CDF
172  // compute cdf
173  mRays[0].mCdf = mRays[0].mImportance/(mRays[0].mMutations+1);
174  for (int i=1; i < mRays.size(); i++)
175        mRays[i].mCdf = mRays[i-1].mCdf + mRays[i].mImportance/(mRays[i].mMutations+1);
176 
177  float scale = 1.0f/mRays[i-1].mCdf;
178  for (i=0; i < mRays.size(); i++) {
179        mRays[i].mCdf *= scale;
180  }
181#endif
182 
183  cout<<"Importance = "<<
184        GetEntry(0).mImportance<<" "<<
185        GetEntry(mRays.size()-1).mImportance<<endl;
186 
187  cerr<<"Mutation update done."<<endl;
188}
189
190
191Vector3
192MutationBasedDistribution::ComputeOriginMutation(const VssRay &ray,
193                                                                                                 const Vector3 &U,
194                                                                                                 const Vector3 &V,
195                                                                                                 const Vector2 vr2,
196                                                                                                 const float radius
197                                                                                                 )
198{
199#if 0
200  Vector3 v;
201  if (d.DrivingAxis() == 0)
202        v = Vector3(0, r[0]-0.5f, r[1]-0.5f);
203  else
204        if (d.DrivingAxis() == 1)
205          v = Vector3(r[0]-0.5f, 0, r[1]-0.5f);
206        else
207          v = Vector3(r[0]-0.5f, r[1]-0.5f, 0);
208  return v*(2*radius);
209#endif
210#if 0
211  return (U*(r[0] - 0.5f) + V*(r[1] - 0.5f))*(2*radius);
212#endif
213
214
215  // Output random variable
216  Vector2 gaussvec2;
217 
218  // Here we apply transform to gaussian, so 2D bivariate
219  // normal distribution
220  //  float sigma = ComputeSigmaFromRadius(radius);
221  float sigma = radius;
222  GaussianOn2D(vr2,
223                           sigma, // input
224                           gaussvec2);  // output
225
226       
227    // Here we tranform the point correctly to 3D space using base
228    // vectors of the 3D space defined by the direction
229    Vector3 shift = gaussvec2.xx * U + gaussvec2.yy * V;
230       
231        //      cout<<shift<<endl;
232        return shift;
233}
234
235Vector3
236MutationBasedDistribution::ComputeTerminationMutation(const VssRay &ray,
237                                                                                                          const Vector3 &U,
238                                                                                                          const Vector3 &V,
239                                                                                                          const Vector2 vr2,
240                                                                                                          const float radius
241                                                                                                          )
242{
243#if 0
244  Vector3 v;
245  // mutate the termination
246  if (d.DrivingAxis() == 0)
247        v = Vector3(0, r[2]-0.5f, r[3]-0.5f);
248  else
249        if (d.DrivingAxis() == 1)
250          v = Vector3(r[2]-0.5f, 0, r[3]-0.5f);
251        else
252          v = Vector3(r[2]-0.5f, r[3]-0.5f, 0);
253 
254  //   Vector3 nv;
255 
256  //   if (Magnitude(v) > Limits::Small)
257  //    nv = Normalize(v);
258  //   else
259  //    nv = v;
260 
261  //  v = nv*size + v*size;
262
263  return v*(4.0f*radius);
264#endif
265#if 0
266  return (U*(vr2.xx - 0.5f) + V*(vr2.yy - 0.5f))*(4.0f*radius);
267#endif
268  Vector2 gaussvec2;
269#if 1
270  float sigma = radius;
271  GaussianOn2D(vr2,
272                           sigma, // input
273                           gaussvec2);  // output
274  Vector3 shift = gaussvec2.xx * U + gaussvec2.yy * V;
275  //    cout<<shift<<endl;
276  return shift;
277#endif
278#if 0
279  // Here we estimate standard deviation (sigma) from radius
280  float sigma = 1.1f*ComputeSigmaFromRadius(radius);
281  Vector3 vr3(vr2.xx, vr2.yy, RandomValue(0,1));
282  PolarGaussianOnDisk(vr3,
283                                          sigma,
284                                          radius, // input
285                                          gaussvec2); // output
286 
287  // Here we tranform the point correctly to 3D space using base
288  // vectors of the 3D space defined by the direction
289  Vector3 shift = gaussvec2.xx * U + gaussvec2.yy * V;
290 
291  //    cout<<shift<<endl;
292  return shift;
293#endif
294}
295
296bool
297MutationBasedDistribution::ComputeReverseMutation(
298                                                                                                  const VssRay &oldRay,
299                                                                                                  const VssRay &newRay,
300                                                                                                  Vector3 &origin,
301                                                                                                  Vector3 &termination
302                                                                                                  )
303{
304  // first reconstruct the termination point
305  Vector3 oldDir = Normalize(oldRay.GetDir());
306  Plane3 oldPlane(oldDir, oldRay.mTermination);
307 
308  termination = oldPlane.FindIntersection(newRay.mOrigin,
309                                                                                  newRay.mTermination);
310 
311  // now find the new origin of the ray by casting ray backward from the termination and termining
312  // silhouette point with respect to the occluding object (object containing the newRay termination)
313
314  Plane3 newPlane(oldDir, newRay.mTermination);
315
316  Vector3 oldPivot = newPlane.FindIntersection(oldRay.mOrigin,
317                                                                                           oldRay.mTermination);
318
319  Vector3 newPivot = newRay.mTermination;
320  Vector3 line = 2.0f*(oldPivot - newPivot);
321
322  Intersectable *occluder = mPreprocessor.mViewCellsManager->GetIntersectable(
323                                                                                                                                                          newRay,
324                                                                                                                                                          true);
325 
326  AxisAlignedBox3 box = occluder->GetBox();
327  box.Scale(2.0f);
328 
329  const int packetSize = 4;
330  static int hit_triangles[packetSize];
331  static float dist[packetSize];
332  static Vector3 dirs[packetSize];
333  static Vector3 shifts[packetSize];
334  // now find the silhouette along the line
335  int i;
336  float left = 0.0f;
337  float right = 1.0f;
338  // cast rays to find silhouette ray
339  for (int j=0; j < Q_SEARCH_STEPS; j++) {
340        for (i=0; i < packetSize; i++) {
341          float r = left + (i+1)*(right-left)/(packetSize+1);
342          shifts[i] = r*line;
343          dirs[i] = Normalize(newPivot + shifts[i] - termination );
344          mlrtaStoreRayASEye4(&termination.x,
345                                                  &dirs[i].x,
346                                                  i);
347        }
348       
349        mlrtaTraverseGroupASEye4(&box.Min().x,
350                                                         &box.Max().x,
351                                                         hit_triangles,
352                                                         dist);
353       
354        for (i=0; i < packetSize; i++) {
355          if (hit_triangles[i] == -1) {
356                // break on first passing ray
357                break;
358          }
359        }
360        float rr = left + (i+1)*(right-left)/(packetSize+1);
361        float rl = left + i*(right-left)/(packetSize+1);
362        left = rl;
363        right = rr;
364  }
365
366  float t = right;
367  if (right==1.0f)
368        return false;
369 
370  if (i == packetSize)
371        origin = newPivot + right*line;
372  else
373        origin = newPivot + shifts[i];
374
375  if (0) {
376       
377        static VssRayContainer rRays;
378        static int counter = 0;
379        char filename[256];
380
381        if (counter < 50) {
382          sprintf(filename, "reverse_rays_%03d.x3d", counter++);
383         
384          VssRay tRay(origin, termination, NULL, NULL);
385          rRays.push_back((VssRay *)&oldRay);
386          rRays.push_back((VssRay *)&newRay);
387          rRays.push_back(&tRay);
388         
389          Exporter *exporter = NULL;
390          exporter = Exporter::GetExporter(filename);
391         
392          exporter->SetFilled();
393         
394          Intersectable *occludee = mPreprocessor.mViewCellsManager->GetIntersectable(
395                                                                                                                                                                  oldRay,
396                                                                                                                                                                  true);
397         
398          exporter->SetForcedMaterial(RgbColor(0,0,1));
399          exporter->ExportIntersectable(occluder);
400          exporter->SetForcedMaterial(RgbColor(0,1,0));
401          exporter->ExportIntersectable(occludee);
402          exporter->ResetForcedMaterial();
403         
404          exporter->SetWireframe();
405         
406         
407          exporter->ExportRays(rRays, RgbColor(1, 0, 0));
408          delete exporter;
409          rRays.clear();
410        }
411  }
412
413
414 
415  return true;
416 
417  // now the origin and termination is swapped compred to the generator ray
418  // swap(origin, termination);???
419  // -> perhaps not neccessary as the reverse mutation wil only be used once!
420}
421
422Vector3
423MutationBasedDistribution::ComputeSilhouetteTerminationMutation(const VssRay &ray,
424                                                                                                                                const Vector3 &origin,
425                                                                                                                                const AxisAlignedBox3 &box,
426                                                                                                                                const Vector3 &U,
427                                                                                                                                const Vector3 &V,
428                                                                                                                                const Vector2 vr2,
429                                                                                                                                const float radius
430                                                                                                                                )
431{
432  const int packetSize = 4;
433  static int hit_triangles[packetSize];
434  static float dist[packetSize];
435  static Vector3 dirs[packetSize];
436  static Vector3 shifts[packetSize];
437  // mutate the
438  float alpha = RandomValue(0.0f, 2.0f*M_PI);
439  //float alpha = vr2.x*2.0f*M_PI;
440 
441  // direction along which we will mutate the ray
442  Vector3 line = sin(alpha)*U + cos(alpha)*V;
443 
444  //  cout<<line<<endl;
445  // create 16 rays along the selected dir
446  int i;
447  float left = 0.0f;
448  float right = radius;
449  // cast rays to find silhouette ray
450  for (int j=0; j < Q_SEARCH_STEPS; j++) {
451        for (i=0; i < packetSize; i++) {
452          float r = left + (i+1)*(right-left)/(packetSize+1);
453          shifts[i] = r*line;
454          dirs[i] = Normalize(ray.mTermination + shifts[i] - origin );
455          mlrtaStoreRayASEye4(&origin.x,
456                                                  &dirs[i].x,
457                                                  i);
458        }
459       
460        mlrtaTraverseGroupASEye4(&box.Min().x,
461                                                         &box.Max().x,
462                                                         hit_triangles,
463                                                         dist);
464       
465        for (i=0; i < packetSize; i++) {
466          if (hit_triangles[i] == -1) {
467                //        if (hit_triangles[i] == -1 || !box.IsInside(origin + dist[i]*dirs[i])) {
468                // break on first passing ray
469                break;
470          }
471        }
472        float rr = left + (i+1)*(right-left)/(packetSize+1);
473        float rl = left + i*(right-left)/(packetSize+1);
474        left = rl;
475        right = rr;
476  }
477 
478  if (i == packetSize) {
479        //      cerr<<"Warning: hit the same box here should never happen!"<<endl;
480        // shift the ray even a bit more
481        //cout<<"W"<<i<<endl;
482        //      return (RandomValue(1.0f, 1.5f)*radius)*line;
483        return right*line;
484  }
485 
486  //  cout<<i<<endl;
487  return shifts[i];
488}
489
490
491bool
492MutationBasedDistribution::GenerateSample(SimpleRay &sray)
493{
494
495  if (mRays.size() == 0) {
496        float rr[5];
497        // use direction based distribution
498        Vector3 origin, direction;
499        static HaltonSequence halton;
500       
501        halton.GetNext(5, rr);
502        mPreprocessor.mViewCellsManager->GetViewPoint(origin,
503                                                                                                  Vector3(rr[0], rr[1], rr[2]));
504       
505
506        direction = UniformRandomVector(rr[3], rr[4]);
507       
508        const float pdf = 1.0f;
509        sray = SimpleRay(origin, direction, MUTATION_BASED_DISTRIBUTION, pdf);
510        sray.mGeneratorId = -1;
511
512        return true;
513  }
514
515  int index;
516
517#if !MUTATION_USE_CDF
518  // get tail of the buffer
519  index = (mLastIndex+1)%mRays.size();
520  if (mRays[index].GetSamplingFactor() >
521          mRays[mLastIndex].GetSamplingFactor()) {
522        // search back for index where this is valid
523        index = (mLastIndex - 1 + mRays.size())%mRays.size();
524        for (int i=0; i < mRays.size(); i++) {
525         
526          //      if (mRays[index].mMutations > mRays[mLastIndex].mMutations)
527          //            break;
528          if (mRays[index].GetSamplingFactor() >
529                  mRays[mLastIndex].GetSamplingFactor() )
530                break;
531          index = (index - 1 + mRays.size())%mRays.size();
532        }
533        // go one step back
534        index = (index+1)%mRays.size();
535  }
536#else
537  static HaltonSequence iHalton;
538  iHalton.GetNext(1, rr);
539  //rr[0] = RandomValue(0,1);
540  // use binary search to find index with this cdf
541  int l=0, r=mRays.size()-1;
542  while(l<r) {
543        int i = (l+r)/2;
544        if (rr[0] < mRays[i].mCdf )
545          r = i;
546        else
547          l = i+1;
548  }
549  index = l;
550  //  if (rr[0] >= mRays[r].mCdf)
551  //    index = r;
552  //  else
553  //    index = l;
554       
555       
556#endif
557  //  cout<<index<<" "<<rr[0]<<" "<<mRays[index].mCdf<<" "<<mRays[(index+1)%mRays.size()].mCdf<<endl;
558
559  mLastIndex = index;
560
561  if (mRays[index].HasReverseMutation()) {
562        //cout<<"R "<<mRays[index].mutatedOrigin<<" "<<mRays[index].mutatedTermination<<endl;
563        sray = SimpleRay(mRays[index].mutatedOrigin,
564                                         Normalize(mRays[index].mutatedTermination - mRays[index].mutatedOrigin),
565                                         MUTATION_BASED_DISTRIBUTION, 1.0f);
566        sray.mGeneratorId = index;
567        mRays[index].ResetReverseMutation();
568        mRays[index].mMutations++;
569        mRays[index].mUnsuccessfulMutations++;
570
571        return true;
572  }
573 
574#if USE_SILHOUETTE_MUTATIONS
575  return GenerateSilhouetteMutation(index, sray);
576#else 
577  return GenerateMutation(index, sray);
578#endif
579}
580
581
582
583
584
585bool
586MutationBasedDistribution::GenerateMutationCandidate(const int index,
587                                                                                                         SimpleRay &sray,
588                                                                                                         Intersectable *object,
589                                                                                                         const AxisAlignedBox3 &box
590                                                                                                         )
591{
592  float rr[4];
593
594  VssRay *ray = mRays[index].mRay;
595
596  mRays[index].mHalton.GetNext(4, rr);
597  //  rr[0] = RandomValue(0.0f,0.99999f);
598  //  rr[1] = RandomValue(0.0f,0.99999f);
599  //  rr[2] = RandomValue(0.0f,0.99999f);
600  //  rr[3] = RandomValue(0.0f,0.99999f);
601 
602  // mutate the origin
603  Vector3 d = ray->GetDir();
604 
605  float objectRadius = 0.5f*Magnitude(box.Diagonal());
606  //  cout<<objectRadius<<endl;
607  if (objectRadius < Limits::Small)
608        return false;
609 
610  // Compute right handed coordinate system from direction
611  Vector3 U, V;
612  Vector3 nd = Normalize(d);
613  nd.RightHandedBase(U, V);
614 
615  Vector3 origin = ray->mOrigin;
616  Vector3 termination = ray->mTermination; //box.Center(); //ray->mTermination; //box.Center();
617
618  // optimal for Pompeii 0.1f
619  // optimal for Vienna 0.5f
620 
621  float radiusExtension = 0.1f;
622  //  + mRays[index].mMutations/50.0f;
623 
624  float mutationRadius = objectRadius*radiusExtension;
625 
626  // tmp for pompeii
627  //  mutationRadius = 0.22f;
628
629#if MUTATE_ORIGIN
630  origin += ComputeOriginMutation(*ray, U, V,
631                                                                  Vector2(rr[0], rr[1]),
632                                                                  mutationRadius);
633#endif
634 
635#if USE_SIL_TERMINATION_MUTATION
636  termination += ComputeSilhouetteTerminationMutation(*ray,
637                                                                                                          origin,
638                                                                                                          box,
639                                                                                                          U, V,
640                                                                                                          Vector2(rr[2], rr[3]),
641                                                                                                          2.0f*objectRadius);
642#else
643  termination += ComputeTerminationMutation(*ray, U, V,
644                                                                                        Vector2(rr[2], rr[3]),
645                                                                                        mutationRadius);
646#endif
647  Vector3 direction = termination - origin;
648 
649  if (Magnitude(direction) < Limits::Small)
650        return false;
651 
652  // shift the origin a little bit
653  origin += direction*0.5f;
654 
655  direction.Normalize();
656 
657  // $$ jb the pdf is yet not correct for all sampling methods!
658  const float pdf = 1.0f;
659 
660  sray = SimpleRay(origin, direction, MUTATION_BASED_DISTRIBUTION, pdf);
661  sray.mGeneratorId = index;
662}
663
664bool
665MutationBasedDistribution::GenerateMutation(const int index, SimpleRay &sray)
666{
667  VssRay *ray = mRays[index].mRay;
668
669  Intersectable *object = mPreprocessor.mViewCellsManager->GetIntersectable(
670                                                                                                                                                        *ray,
671                                                                                                                                                        true);
672 
673  AxisAlignedBox3 box = object->GetBox();
674 
675  if (GenerateMutationCandidate(index, sray, object, box)) {
676    mRays[index].mMutations++;
677        mRays[index].mUnsuccessfulMutations++;
678
679        return true;
680  }
681  return false;
682}
683
684bool
685MutationBasedDistribution::GenerateSilhouetteMutation(const int index, SimpleRay &sray)
686{
687#ifndef GTP_INTERNAL
688  return GenerateMutation(index, sray);
689#else
690  const int packetSize = 4;
691  const int maxTries = 8;
692 
693  static int hit_triangles[16];
694  static float dist[16];
695 
696  SimpleRay mutationCandidates[packetSize];
697  int candidates = 0;
698
699  VssRay *ray = mRays[index].mRay;
700 
701  Intersectable *object = mPreprocessor.mViewCellsManager->GetIntersectable(
702                                                                                                                                                        *ray,
703                                                                                                                                                        true);
704 
705  AxisAlignedBox3 box = object->GetBox();
706
707  int id = 0;
708  int silhouetteRays = 0;
709  int tries = 0;
710  while (silhouetteRays == 0 && tries < maxTries) {
711        for (candidates = 0; candidates < packetSize && tries < maxTries; tries++)
712          if (GenerateMutationCandidate(index, mutationCandidates[candidates], object, box))
713                candidates++;
714
715        if (candidates < packetSize)
716          break;
717       
718        //      cout<<candidates<<endl;
719        // cast rays to find silhouette edge
720        for (int i=0; i < packetSize; i++)
721          mlrtaStoreRayAS4(&mutationCandidates[i].mOrigin.x,
722                                           &mutationCandidates[i].mDirection.x,
723                                           i);
724
725        mlrtaTraverseGroupAS4(&box.Min().x,
726                                                  &box.Max().x,
727                                                  hit_triangles,
728                                                  dist);
729       
730        for (int i=0; i < packetSize; i++)
731          if (hit_triangles[i] == -1) {
732                silhouetteRays++;
733                id = i;
734                break;
735          }
736  }
737
738  if (candidates == 0)
739        return false;
740 
741  //  cout<<id<<endl;
742  // cout<<tries<<endl;
743  sray = mutationCandidates[id];
744  mRays[index].mMutations++;
745  mRays[index].mUnsuccessfulMutations++;
746
747  return true;
748#endif
749}
750
751 
752
753
754MutationBasedDistribution::MutationBasedDistribution(Preprocessor &preprocessor
755                                                                                                         ) :
756  SamplingStrategy(preprocessor)
757{
758  mType = MUTATION_BASED_DISTRIBUTION;
759  mBufferStart = 0;
760  mMaxRays = 500000;
761  mRays.reserve(mMaxRays);
762  mOriginMutationSize = 10.0f;
763  mLastIndex = 0;
764  //  mOriginMutationSize = Magnitude(preprocessor.mViewCellsManager->
765  //                                                              GetViewSpaceBox().Diagonal())*1e-3;
766 
767}
768
769
770}
Note: See TracBrowser for help on using the repository browser.