Context Navigation

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

Revision 2002, 20.0 KB checked in by bittner, 18 years ago (diff)
renderer code updates for pixel error measurements

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
17	namespace 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 1
24
25	#define EVALUATE_MUTATION_STATS 1
26
27	#define Q_SEARCH_STEPS 2
28
29	void
30	MutationBasedDistribution::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
191	Vector3
192	MutationBasedDistribution::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(2radius);
209	#endif
210	#if 0
211	return (U(r[0] - 0.5f) + V(r[1] - 0.5f))(2radius);
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
235	Vector3
236	MutationBasedDistribution::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 = nvsize + vsize;
262
263	return v(4.0fradius);
264	#endif
265	#if 0
266	return (U(vr2.xx - 0.5f) + V(vr2.yy - 0.5f))(4.0fradius);
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
296	bool
297	MutationBasedDistribution::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
422	Vector3
423	MutationBasedDistribution::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.x2.0fM_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
491	bool
492	MutationBasedDistribution::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
585	bool
586	MutationBasedDistribution::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
664	bool
665	MutationBasedDistribution::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
684	bool
685	MutationBasedDistribution::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
754	MutationBasedDistribution::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.

Download in other formats: