Context Navigation

source: trunk/VUT/GtpVisibilityPreprocessor/src/VssPreprocessor.cpp @ 538

Revision 538, 19.6 KB checked in by mattausch, 18 years ago (diff)

Line
1	#include "SceneGraph.h"
2	#include "KdTree.h"
3	#include "VssPreprocessor.h"
4	#include "X3dExporter.h"
5	#include "Environment.h"
6	#include "MutualVisibility.h"
7	#include "Polygon3.h"
8	#include "ViewCell.h"
9	#include "VssRay.h"
10	#include "VssTree.h"
11	#include "ViewCellsManager.h"
12	#include "RenderSimulator.h"
13	#include "Beam.h"
14	#include "GlRenderer.h"
15
16	bool use2dSampling = false;
17	bool useViewspacePlane = false;
18
19	VssPreprocessor::VssPreprocessor():
20	mPass(0),
21	mVssRays()
22	{
23	// this should increase coherence of the samples
24	environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
25	environment->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
26	environment->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
27	environment->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
28	environment->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
29	environment->GetBoolValue("ViewCells.delayedConstruction", mDelayedViewCellsConstruction);
30
31	environment->GetBoolValue("VssPreprocessor.loadInitialSamples", mLoadInitialSamples);
32	environment->GetBoolValue("VssPreprocessor.storeInitialSamples", mStoreInitialSamples);
33	environment->GetBoolValue("VssPreprocessor.useViewSpaceBox", mUseViewSpaceBox);
34	environment->GetBoolValue("VssPreprocessor.testBeamSampling", mTestBeamSampling);
35
36	useViewspacePlane = mUseViewSpaceBox; //hack
37
38	mStats.open("stats.log");
39	}
40
41	VssPreprocessor::~VssPreprocessor()
42	{
43	CLEAR_CONTAINER(mVssRays);
44	}
45
46	void
47	VssPreprocessor::SetupRay(Ray &ray,
48	const Vector3 &point,
49	const Vector3 &direction
50	)
51	{
52	ray.Clear();
53	// do not store anything else then intersections at the ray
54	ray.Init(point, direction, Ray::LOCAL_RAY);
55	}
56
57	int
58	VssPreprocessor::CastRay(
59	Vector3 &viewPoint,
60	Vector3 &direction,
61	VssRayContainer &vssRays
62	)
63	{
64
65	int hits = 0;
66	static Ray ray;
67	AxisAlignedBox3 box = mKdTree->GetBox();
68
69	AxisAlignedBox3 sbox = box;
70	sbox.Enlarge(Vector3(-Limits::Small));
71	if (!sbox.IsInside(viewPoint))
72	return 0;
73
74	SetupRay(ray, viewPoint, direction);
75	// cast ray to KD tree to find intersection with other objects
76	Intersectable objectA, objectB;
77	Vector3 pointA, pointB;
78	float bsize = Magnitude(box.Size());
79
80
81	if (!mDetectEmptyViewSpace)
82	ray.mFlags &= ~Ray::CULL_BACKFACES;
83
84	if (mKdTree->CastRay(ray)) {
85	objectA = ray.intersections[0].mObject;
86	pointA = ray.Extrap(ray.intersections[0].mT);
87	} else {
88	objectA = NULL;
89	// compute intersection with the scene bounding box
90	float tmin, tmax;
91	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
92	pointA = ray.Extrap(tmax);
93	else
94	return 0;
95	}
96
97
98	if (mDetectEmptyViewSpace) {
99	SetupRay(ray, pointA, -direction);
100	} else
101	SetupRay(ray, viewPoint, -direction);
102
103	if (!mDetectEmptyViewSpace)
104	ray.mFlags &= ~Ray::CULL_BACKFACES;
105
106	if (mKdTree->CastRay(ray)) {
107	objectB = ray.intersections[0].mObject;
108	pointB = ray.Extrap(ray.intersections[0].mT);
109	} else {
110	objectB = NULL;
111	float tmin, tmax;
112	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
113	pointB = ray.Extrap(tmax);
114	else
115	return 0;
116	}
117
118	// if (objectA == NULL && objectB != NULL) {
119	if (mDetectEmptyViewSpace) {
120	// cast again to ensure that there is no objectA
121	SetupRay(ray, pointB, direction);
122	if (mKdTree->CastRay(ray)) {
123	objectA = ray.intersections[0].mObject;
124	pointA = ray.Extrap(ray.intersections[0].mT);
125	}
126	}
127
128
129	VssRay *vssRay = NULL;
130
131	bool validSample = (objectA != objectB);
132	if (0 && mDetectEmptyViewSpace) { // consider all samples valid
133	// check if the viewpoint lies on the line segment AB
134	if (Distance(pointA, pointB) <
135	Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) {
136	validSample = false;
137	}
138	}
139
140	if (validSample) {
141	if (objectA) {
142	vssRay = new VssRay(pointB,
143	pointA,
144	objectB,
145	objectA,
146	mPass
147	);
148	vssRays.push_back(vssRay);
149	hits ++;
150	}
151
152	if (objectB) {
153	vssRay = new VssRay(pointA,
154	pointB,
155	objectA,
156	objectB,
157	mPass
158	);
159	vssRays.push_back(vssRay);
160	hits ++;
161	}
162	}
163
164	return hits;
165	}
166
167
168	Vector3
169	VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
170	{
171	AxisAlignedBox3 box;
172
173	if (viewSpaceBox)
174	box =*viewSpaceBox;
175	else
176	box = mKdTree->GetBox();
177
178	// shrink the box in the y direction
179	return box.GetRandomPoint();
180	}
181
182	Vector3
183	VssPreprocessor::GetDirection(const Vector3 &viewpoint,
184	AxisAlignedBox3 *viewSpaceBox
185	)
186	{
187	Vector3 point;
188	if (!use2dSampling) {
189	if (0) {
190	Vector3 normal;
191	int i = Random((int)mObjects.size());
192	Intersectable *object = mObjects[i];
193	object->GetRandomSurfacePoint(point, normal);
194	} else
195	point = mKdTree->GetBox().GetRandomPoint();
196	// point = viewpoint + UniformRandomVector();
197
198	} else {
199	AxisAlignedBox3 box;
200
201	if (viewSpaceBox)
202	box =*viewSpaceBox;
203	else
204	box = mKdTree->GetBox();
205
206	point = box.GetRandomPoint();
207	point.y = viewpoint.y;
208	}
209
210	return point - viewpoint;
211	}
212
213	int
214	VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
215	const int desiredSamples,
216	SimpleRayContainer &rays
217	)
218	{
219	int num;
220	if (0) {
221	float minRayContribution;
222	float maxRayContribution;
223	float avgRayContribution;
224
225	vssTree->GetRayContributionStatistics(minRayContribution,
226	maxRayContribution,
227	avgRayContribution);
228
229	cout<<
230	"#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
231	"#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
232	"#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
233
234	float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
235	num = vssTree->GenerateRays(p, rays);
236	} else {
237	int leaves = vssTree->stat.Leaves();
238	num = vssTree->GenerateRays(desiredSamples, leaves, rays);
239	}
240
241	cout<<"Generated "<<num<<" rays."<<endl;
242
243	return num;
244	}
245
246
247	bool
248	VssPreprocessor::ExportRays(const char *filename,
249	const VssRayContainer &vssRays,
250	const int number
251	)
252	{
253	cout<<"Exporting vss rays..."<<endl<<flush;
254
255	Exporter *exporter = NULL;
256	exporter = Exporter::GetExporter(filename);
257	// exporter->SetWireframe();
258	// exporter->ExportKdTree(*mKdTree);
259	exporter->SetFilled();
260	exporter->ExportScene(mSceneGraph->mRoot);
261	exporter->SetWireframe();
262
263	if (mViewSpaceBox) {
264	exporter->SetForcedMaterial(RgbColor(1,0,1));
265	exporter->ExportBox(*mViewSpaceBox);
266	exporter->ResetForcedMaterial();
267	}
268
269	VssRayContainer rays;
270	vssRays.SelectRays(number, rays);
271
272	exporter->ExportRays(rays, RgbColor(1, 0, 0));
273
274	delete exporter;
275
276	cout<<"done."<<endl<<flush;
277
278	return true;
279	}
280
281
282	bool
283	VssPreprocessor::ExportVssTree(char *filename,
284	VssTree *tree,
285	const Vector3 &dir
286	)
287	{
288	Exporter *exporter = Exporter::GetExporter(filename);
289	exporter->SetFilled();
290	exporter->ExportScene(mSceneGraph->mRoot);
291	// exporter->SetWireframe();
292	bool result = exporter->ExportVssTree2( *tree, dir );
293	delete exporter;
294	return result;
295	}
296
297	bool
298	VssPreprocessor::ExportVssTreeLeaf(char *filename,
299	VssTree *tree,
300	VssTreeLeaf *leaf)
301	{
302	Exporter *exporter = NULL;
303	exporter = Exporter::GetExporter(filename);
304	exporter->SetWireframe();
305	exporter->ExportKdTree(*mKdTree);
306
307	if (mViewSpaceBox) {
308	exporter->SetForcedMaterial(RgbColor(1,0,0));
309	exporter->ExportBox(*mViewSpaceBox);
310	exporter->ResetForcedMaterial();
311	}
312
313	exporter->SetForcedMaterial(RgbColor(0,0,1));
314	exporter->ExportBox(tree->GetBBox(leaf));
315	exporter->ResetForcedMaterial();
316
317	VssRayContainer rays[4];
318	for (int i=0; i < leaf->rays.size(); i++) {
319	int k = leaf->rays[i].GetRayClass();
320	rays[k].push_back(leaf->rays[i].mRay);
321	}
322
323	// SOURCE RAY
324	exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
325	// TERMINATION RAY
326	exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
327	// PASSING_RAY
328	exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
329	// CONTAINED_RAY
330	exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
331
332	delete exporter;
333	return true;
334	}
335
336	void
337	VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
338	{
339	vector<VssTreeLeaf *> leaves;
340	tree->CollectLeaves(leaves);
341
342	int num = 0;
343	int i;
344	float p = number / (float)leaves.size();
345	for (i=0; i < leaves.size(); i++) {
346	if (RandomValue(0,1) < p) {
347	char filename[64];
348	sprintf(filename, "vss-leaf-%04d.x3d", num);
349	ExportVssTreeLeaf(filename, tree, leaves[i]);
350	num++;
351	}
352	if (num >= number)
353	break;
354	}
355	}
356	#include "ViewCellBsp.h"
357
358	void VssPreprocessor::TestBeamCasting(VssTree *tree,
359	ViewCellsManager *vm,
360	const ObjectContainer &objects)
361	{
362	vector<VssTreeLeaf *> leaves;
363	tree->CollectLeaves(leaves);
364
365	Exporter *exporter = Exporter::GetExporter("shafts.x3d");
366
367	exporter->SetWireframe();
368	//exporter->ExportGeometry(objects);
369	exporter->SetFilled();
370	//Randomize();
371	for (int i = 0; i < 1; ++ i)
372	{
373	const int index = (int)RandomValue(0, (Real)((int)leaves.size() - 1));
374	VssTreeLeaf *leaf = leaves[index];
375
376	Beam beam;
377	AxisAlignedBox3 dirBox = tree->GetDirBBox(leaf);
378	AxisAlignedBox3 box = tree->GetBBox(leaf);
379
380	beam.Construct(box, dirBox);
381
382	// collect kd leaves and view cells
383	mKdTree->CastBeam(beam);
384	vm->CastBeam(beam);
385
386	Debug << "found " << beam.mViewCells.size() << " view cells and "
387	<< beam.mKdNodes.size() << " kd nodes" << endl;
388
389	Intersectable *sourceObj = mObjects[5];
390	BeamSampleStatistics stats;
391
392	renderer->SampleBeamContributions(sourceObj,
393	beam,
394	10000,
395	stats);
396
397	Debug << "beam statistics: " << stats << endl << endl;
398
399	AxisAlignedBox3 sbox = mSceneGraph->GetBox();
400	Vector3 bmin = sbox.Min() - 150.0f;
401	Vector3 bmax = sbox.Max() + 150.0f;
402	AxisAlignedBox3 vbox(bmin, bmax);
403
404	exporter->ExportBeam(beam, vbox);
405
406	bool exportViewCells = true;
407
408	if (exportViewCells)
409	{
410	ViewCellContainer::const_iterator it, it_end = beam.mViewCells.end();
411
412	for (it = beam.mViewCells.begin(); it != beam.mViewCells.end(); ++ it)
413	{
414	BspNodeGeometry geom;
415	AxisAlignedBox3 vbox;
416	vbox.Initialize();
417	vbox.Include((*it)->GetMesh());
418
419	exporter->SetWireframe();
420	exporter->ExportBox(vbox);
421	exporter->SetFilled();
422	exporter->ExportViewCell(*it);
423	}
424
425	/vector<KdNode >::const_iterator it, it_end = beam.mKdNodes.end();
426
427	for (it = beam.mKdNodes.begin(); it != beam.mKdNodes.end(); ++ it)
428	{
429	exporter->ExportBox(mKdTree->GetBox((*it)));
430	}*/
431	}
432	}
433	delete exporter;
434	}
435
436	float
437	VssPreprocessor::GetAvgPvsSize(VssTree *tree,
438	const vector<AxisAlignedBox3> &viewcells
439	)
440	{
441	vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
442
443	int sum = 0;
444	for (it = viewcells.begin(); it != it_end; ++ it)
445	sum += tree->GetPvsSize(*it);
446
447	return sum/(float)viewcells.size();
448	}
449
450	bool
451	VssPreprocessor::ComputeVisibility()
452	{
453
454
455	long startTime = GetTime();
456
457	int totalSamples = 0;
458
459
460	AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());
461
462	if (!useViewspacePlane) {
463	float size = 0.05f;
464	float s = 0.5f - size;
465	float olds = Magnitude(box->Size());
466	box->Enlarge(box->Size()*Vector3(-s));
467	Vector3 translation = Vector3(-olds*0.1f, 0, 0);
468	box->SetMin(box->Min() + translation);
469	box->SetMax(box->Max() + translation);
470	} else {
471
472	// sample city like heights
473	box->SetMin(1, box->Min(1) + box->Size(1)*0.2f);
474	box->SetMax(1, box->Min(1) + box->Size(1)*0.3f);
475	}
476
477	if (use2dSampling)
478	box->SetMax(1, box->Min(1));
479
480	cout<<"mUseViewSpaceBox="<<mUseViewSpaceBox<<endl;
481	if (mUseViewSpaceBox)
482	{
483	mViewSpaceBox = box;
484	mViewCellsManager->SetViewSpaceBox(*box);
485	}
486	else
487	{
488	mViewSpaceBox = NULL;
489	mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
490	}
491
492	//-- load view cells from file if requested
493	if (mLoadViewCells)
494	{
495	// load now because otherwise bounding box not correct
496	mViewCellsManager->LoadViewCells(mViewCellsFilename, &mObjects);
497	}
498
499
500	VssTree *vssTree = NULL;
501
502	mSceneGraph->CollectObjects(&mObjects);
503
504	long initialTime = GetTime();
505
506	if (mLoadInitialSamples)
507	{
508	cout << "Loading samples from file ... ";
509	LoadSamples(mVssRays, mObjects);
510	cout << "finished\n" << endl;
511	totalSamples = (int)mVssRays.size();
512	}
513	else
514	{
515
516	while (totalSamples < mInitialSamples) {
517	int passContributingSamples = 0;
518	int passSampleContributions = 0;
519	int passSamples = 0;
520
521	int index = 0;
522
523	int sampleContributions;
524
525	int s = Min(mSamplesPerPass, mInitialSamples);
526	for (int k=0; k < s; k++) {
527	// changed by matt
528	Vector3 viewpoint;
529	// viewpoint = GetViewpoint(mViewSpaceBox);
530	mViewCellsManager->GetViewPoint(viewpoint);
531	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
532
533	sampleContributions = CastRay(viewpoint, direction, mVssRays);
534
535	if (sampleContributions) {
536	passContributingSamples ++;
537	passSampleContributions += sampleContributions;
538	}
539	passSamples++;
540	totalSamples++;
541	}
542
543	mPass++;
544	int pvsSize = 0;
545	float avgRayContrib = (passContributingSamples > 0) ?
546	passSampleContributions/(float)passContributingSamples : 0;
547
548	cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
549	cout << "#TotalSamples=" << totalSamples/1000
550	<< "k #SampleContributions=" << passSampleContributions << " ("
551	<< 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
552	<< pvsSize/(float)mObjects.size() << endl
553	<< "avg ray contrib=" << avgRayContrib << endl;
554
555	mStats <<
556	"#Pass\n" <<mPass<<endl<<
557	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
558	"#TotalSamples\n" << totalSamples<< endl<<
559	"#SampleContributions\n" << passSampleContributions << endl <<
560	"#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
561	"#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
562	"#AvgRayContrib\n" << avgRayContrib << endl;
563	}
564
565	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
566
567
568
569	}
570
571	cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
572	Debug << (int)mVssRays.size() << " rays generated in "
573	<< TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;
574
575	if (mStoreInitialSamples)
576	{
577	cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
578	ExportSamples(mVssRays);
579	cout << "finished\n" << endl;
580
581	/*VssRayContainer dummyRays;
582	LoadSamples(dummyRays, mObjects);
583	Debug << "rays " << (int)mVssRays.size() << " " << dummyRays.size() << endl;
584
585	for (int i = 0; i < (int)mVssRays.size(); ++ i)
586	{
587	Debug << mVssRays[i]->GetOrigin() << " " << mVssRays[i]->GetTermination() << " " << mVssRays[i]->mOriginObject << " " << mVssRays[i]->mTerminationObject << endl;
588	Debug << dummyRays[i]->GetOrigin() << " " << dummyRays[i]->GetTermination() << " " << dummyRays[i]->mOriginObject << " " << dummyRays[i]->mTerminationObject << endl << endl;
589	}*/
590	}
591
592
593	int numExportRays = 5000;
594	//int numExportRays = 0;
595
596	if (numExportRays) {
597	char filename[64];
598	sprintf(filename, "vss-rays-initial.x3d");
599	ExportRays(filename, mVssRays, numExportRays);
600	}
601
602	/// compute view cell contribution of rays if view cells manager already constructed
603	mViewCellsManager->ComputeSampleContributions(mVssRays);
604
605	// construct view cells
606	if (!mDelayedViewCellsConstruction)
607	mViewCellsManager->Construct(mObjects, mVssRays);
608
609	vssTree = new VssTree;
610	// viewcells = Construct(mVssRays);
611
612	vssTree->Construct(mVssRays, mViewSpaceBox);
613	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
614
615	if (0)
616	{
617	ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
618	ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
619	ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
620	ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
621	ExportVssTreeLeaves(vssTree, 10);
622	}
623
624	// viewcells->UpdatePVS(newVssRays);
625	// get viewcells as kd tree boxes
626	vector<AxisAlignedBox3> kdViewcells;
627	if (0) {
628	vector<KdLeaf *> leaves;
629	mKdTree->CollectLeaves(leaves);
630	vector<KdLeaf *>::const_iterator it;
631	int targetLeaves = 50;
632	float prob = targetLeaves/(float)leaves.size();
633	for (it = leaves.begin(); it != leaves.end(); ++it)
634	if (RandomValue(0.0f,1.0f) < prob)
635	kdViewcells.push_back(mKdTree->GetBox(*it));
636
637	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
638	cout<<"Initial average PVS size = "<<avgPvs<<endl;
639	}
640
641
642	int samples = 0;
643	int pass = 0;
644
645
646	// cast view cell samples
647	while (1) {
648	int num = mVssSamplesPerPass;
649	SimpleRayContainer rays;
650	VssRayContainer vssRays;
651
652	if (!mUseImportanceSampling) {
653	for (int j=0; j < num; j++) {
654	// changed by matt
655	//Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
656	Vector3 viewpoint;
657	mViewCellsManager->GetViewPoint(viewpoint);
658	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
659	rays.push_back(SimpleRay(viewpoint, direction));
660	}
661	} else {
662	num = GenerateImportanceRays(vssTree, num, rays);
663	}
664
665	for (int i=0; i < rays.size(); i++)
666	CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
667
668	vssTree->AddRays(vssRays);
669
670	if (0) {
671	int subdivided = vssTree->UpdateSubdivision();
672	cout<<"subdivided leafs = "<<subdivided<<endl;
673	}
674
675	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
676	cout<<"Average PVS size = "<<avgPvs<<endl;
677
678	//Debug << "samples: " << samples << " construction samples " << mViewCellsManager->GetConstructionSamples() << endl;
679	// construct view cells after vss
680	if (!mViewCellsManager->ViewCellsConstructed() &&
681	(samples + mInitialSamples > mViewCellsManager->GetConstructionSamples()))
682	{
683	VssRayContainer constructionRays;
684	vssTree->CollectRays(constructionRays,
685	mViewCellsManager->GetConstructionSamples());
686	mViewCellsManager->Construct(mObjects, constructionRays);
687	}
688
689	/// compute view cell contribution of rays
690	mViewCellsManager->ComputeSampleContributions(vssRays);
691
692	if (numExportRays) {
693	char filename[64];
694	if (mUseImportanceSampling)
695	sprintf(filename, "vss-rays-i%04d.x3d", pass);
696	else
697	sprintf(filename, "vss-rays-%04d.x3d", pass);
698
699	ExportRays(filename, vssRays, numExportRays);
700	}
701
702	samples+=num;
703	float pvs = vssTree->GetAvgPvsSize();
704	cout<<"*****************************\n";
705	cout<<samples<<" avgPVS ="<<pvs<<endl;
706	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
707	cout<<"*****************************\n";
708	if (samples >= mVssSamples)
709	break;
710	pass++;
711	}
712
713	Debug << vssTree->stat << endl;
714	VssRayContainer viewCellRays;
715
716	// compute rays used for view cells construction
717	int numRays = Max(mViewCellsManager->GetPostProcessSamples(),
718	mViewCellsManager->GetVisualizationSamples());
719
720	vssTree->CollectRays(viewCellRays, numRays);
721
722	//-- post process view cells
723	mViewCellsManager->PostProcess(mObjects, viewCellRays);
724
725	if (mTestBeamSampling)
726	TestBeamCasting(vssTree, mViewCellsManager, mObjects);
727
728	//-- several visualizations and statistics
729	Debug << "\nview cells after post processing: " << endl;
730	mViewCellsManager->PrintStatistics(Debug);
731
732	mViewCellsManager->Visualize(mObjects, viewCellRays);
733
734	//-- render simulation after merge
735	cout << "\nevaluating bsp view cells render time after merge ... ";
736	mRenderSimulator->RenderScene();
737	SimulationStatistics ss;
738	mRenderSimulator->GetStatistics(ss);
739
740	cout << " finished" << endl;
741	cout << ss << endl;
742	Debug << ss << endl;
743
744	delete vssTree;
745
746	return true;
747	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: