Context Navigation

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

Revision 551, 20.3 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	//debuggerWidget = new GlDebuggerWidget(renderer);
363	// renderer->resize(640, 480);
364	//debuggerWidget->resize(640, 480);
365
366	vector<VssTreeLeaf *> leaves;
367	tree->CollectLeaves(leaves);
368
369	Exporter *exporter = Exporter::GetExporter("shafts.x3d");
370
371	exporter->SetWireframe();
372	exporter->ExportGeometry(objects);
373	exporter->SetFilled();
374	//Randomize();
375	debuggerWidget = new GlDebuggerWidget(renderer);
376
377	/*debuggerWidget->mBeam = beam;
378	debuggerWidget->mSourceObject = sourceObj;
379	debuggerWidget->mSamples = 10000;
380
381	Debug << "showing window" << endl;
382	debuggerWidget->show();*/
383
384	renderer->makeCurrent();
385
386	for (int i = 0; i < 10; ++ i)
387	{
388	Beam beam;
389	Intersectable *sourceObj = mObjects[5];
390
391	const int index = (int)RandomValue(0, (Real)((int)leaves.size() - 1));
392	VssTreeLeaf *leaf = leaves[index];
393
394	AxisAlignedBox3 dirBox = tree->GetDirBBox(leaf);
395	AxisAlignedBox3 box = tree->GetBBox(leaf);
396
397	beam.Construct(box, dirBox);
398
399	// collect kd leaves and view cells
400	mKdTree->CastBeam(beam);
401	vm->CastBeam(beam);
402
403	Debug << "found " << beam.mViewCells.size() << " view cells and "
404	<< beam.mKdNodes.size() << " kd nodes" << endl;
405
406	BeamSampleStatistics stats;
407
408	renderer->SampleBeamContributions(sourceObj,
409	beam,
410	200000,
411	stats);
412
413	char s[64]; sprintf(s, "shaft%04d.png", i);
414
415	QImage image = renderer->toImage();
416	image.save(s, "PNG");
417	Debug << "beam statistics: " << stats << endl << endl;
418
419	if (1)
420	{
421	AxisAlignedBox3 sbox = mSceneGraph->GetBox();
422	Vector3 bmin = sbox.Min() - 150.0f;
423	Vector3 bmax = sbox.Max() + 150.0f;
424	AxisAlignedBox3 vbox(bmin, bmax);
425
426	exporter->ExportBeam(beam, vbox);
427	}
428
429	bool exportViewCells = false;
430
431	if (exportViewCells)
432	{
433	ViewCellContainer::const_iterator it, it_end = beam.mViewCells.end();
434
435	for (it = beam.mViewCells.begin(); it != beam.mViewCells.end(); ++ it)
436	{
437	BspNodeGeometry geom;
438	AxisAlignedBox3 vbox;
439	vbox.Initialize();
440	vbox.Include((*it)->GetMesh());
441
442	exporter->SetWireframe();
443	exporter->ExportBox(vbox);
444	exporter->SetFilled();
445	exporter->ExportViewCell(*it);
446	}
447
448	/vector<KdNode >::const_iterator it, it_end = beam.mKdNodes.end();
449
450	for (it = beam.mKdNodes.begin(); it != beam.mKdNodes.end(); ++ it)
451	{
452	exporter->ExportBox(mKdTree->GetBox((*it)));
453	}*/
454	}
455	}
456	/*while (1)
457	{ debuggerWidget->repaint();
458	};*/
459	delete exporter;
460	}
461
462
463	float
464	VssPreprocessor::GetAvgPvsSize(VssTree *tree,
465	const vector<AxisAlignedBox3> &viewcells
466	)
467	{
468	vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
469
470	int sum = 0;
471	for (it = viewcells.begin(); it != it_end; ++ it)
472	sum += tree->GetPvsSize(*it);
473
474	return sum/(float)viewcells.size();
475	}
476
477	bool
478	VssPreprocessor::ComputeVisibility()
479	{
480
481
482	long startTime = GetTime();
483
484	int totalSamples = 0;
485
486
487	AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());
488
489	if (!useViewspacePlane) {
490	float size = 0.05f;
491	float s = 0.5f - size;
492	float olds = Magnitude(box->Size());
493	box->Enlarge(box->Size()*Vector3(-s));
494	Vector3 translation = Vector3(-olds*0.1f, 0, 0);
495	box->SetMin(box->Min() + translation);
496	box->SetMax(box->Max() + translation);
497	} else {
498
499	// sample city like heights
500	box->SetMin(1, box->Min(1) + box->Size(1)*0.2f);
501	box->SetMax(1, box->Min(1) + box->Size(1)*0.3f);
502	}
503
504	if (use2dSampling)
505	box->SetMax(1, box->Min(1));
506
507	cout<<"mUseViewSpaceBox="<<mUseViewSpaceBox<<endl;
508	Debug << "use view space box=" << mUseViewSpaceBox << endl;
509	if (mUseViewSpaceBox)
510	{
511	mViewSpaceBox = box;
512	mViewCellsManager->SetViewSpaceBox(*box);
513	}
514	else
515	{
516	mViewSpaceBox = NULL;
517	mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
518	}
519
520	//-- load view cells from file if requested
521	if (mLoadViewCells)
522	{
523	// load now because otherwise bounding box not correct
524	mViewCellsManager->LoadViewCells(mViewCellsFilename, &mObjects);
525	}
526
527
528	VssTree *vssTree = NULL;
529
530	mSceneGraph->CollectObjects(&mObjects);
531
532	long initialTime = GetTime();
533
534	if (mLoadInitialSamples)
535	{
536	cout << "Loading samples from file ... ";
537	LoadSamples(mVssRays, mObjects);
538	cout << "finished\n" << endl;
539	totalSamples = (int)mVssRays.size();
540	}
541	else
542	{
543
544	while (totalSamples < mInitialSamples) {
545	int passContributingSamples = 0;
546	int passSampleContributions = 0;
547	int passSamples = 0;
548
549	int index = 0;
550
551	int sampleContributions;
552
553	int s = Min(mSamplesPerPass, mInitialSamples);
554	for (int k=0; k < s; k++) {
555	// changed by matt
556	Vector3 viewpoint;
557	// viewpoint = GetViewpoint(mViewSpaceBox);
558	mViewCellsManager->GetViewPoint(viewpoint);
559	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
560
561	sampleContributions = CastRay(viewpoint, direction, mVssRays);
562
563	if (sampleContributions) {
564	passContributingSamples ++;
565	passSampleContributions += sampleContributions;
566	}
567	passSamples++;
568	totalSamples++;
569	}
570
571	mPass++;
572	int pvsSize = 0;
573	float avgRayContrib = (passContributingSamples > 0) ?
574	passSampleContributions/(float)passContributingSamples : 0;
575
576	cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
577	cout << "#TotalSamples=" << totalSamples/1000
578	<< "k #SampleContributions=" << passSampleContributions << " ("
579	<< 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
580	<< pvsSize/(float)mObjects.size() << endl
581	<< "avg ray contrib=" << avgRayContrib << endl;
582
583	mStats <<
584	"#Pass\n" <<mPass<<endl<<
585	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
586	"#TotalSamples\n" << totalSamples<< endl<<
587	"#SampleContributions\n" << passSampleContributions << endl <<
588	"#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
589	"#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
590	"#AvgRayContrib\n" << avgRayContrib << endl;
591	}
592
593	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
594
595
596
597	}
598
599	cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
600	Debug << (int)mVssRays.size() << " rays generated in "
601	<< TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;
602
603	if (mStoreInitialSamples)
604	{
605	cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
606	ExportSamples(mVssRays);
607	cout << "finished\n" << endl;
608
609	/*VssRayContainer dummyRays;
610	LoadSamples(dummyRays, mObjects);
611	Debug << "rays " << (int)mVssRays.size() << " " << dummyRays.size() << endl;
612
613	for (int i = 0; i < (int)mVssRays.size(); ++ i)
614	{
615	Debug << mVssRays[i]->GetOrigin() << " " << mVssRays[i]->GetTermination() << " " << mVssRays[i]->mOriginObject << " " << mVssRays[i]->mTerminationObject << endl;
616	Debug << dummyRays[i]->GetOrigin() << " " << dummyRays[i]->GetTermination() << " " << dummyRays[i]->mOriginObject << " " << dummyRays[i]->mTerminationObject << endl << endl;
617	}*/
618	}
619
620
621	//int numExportRays = 5000;
622	int numExportRays = 0;
623
624	if (numExportRays) {
625	char filename[64];
626	sprintf(filename, "vss-rays-initial.x3d");
627	ExportRays(filename, mVssRays, numExportRays);
628	}
629
630	/// compute view cell contribution of rays if view cells manager already constructed
631	mViewCellsManager->ComputeSampleContributions(mVssRays);
632
633	// construct view cells
634	if (!mDelayedViewCellsConstruction)
635	mViewCellsManager->Construct(mObjects, mVssRays);
636
637	vssTree = new VssTree;
638	// viewcells = Construct(mVssRays);
639
640	vssTree->Construct(mVssRays, mViewSpaceBox);
641	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
642
643	if (0)
644	{
645	ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
646	ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
647	ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
648	ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
649	ExportVssTreeLeaves(vssTree, 10);
650	}
651
652	// viewcells->UpdatePVS(newVssRays);
653	// get viewcells as kd tree boxes
654	vector<AxisAlignedBox3> kdViewcells;
655	if (0) {
656	vector<KdLeaf *> leaves;
657	mKdTree->CollectLeaves(leaves);
658	vector<KdLeaf *>::const_iterator it;
659	int targetLeaves = 50;
660	float prob = targetLeaves/(float)leaves.size();
661	for (it = leaves.begin(); it != leaves.end(); ++it)
662	if (RandomValue(0.0f,1.0f) < prob)
663	kdViewcells.push_back(mKdTree->GetBox(*it));
664
665	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
666	cout<<"Initial average PVS size = "<<avgPvs<<endl;
667	}
668
669
670	int samples = 0;
671	int pass = 0;
672
673
674	// cast view cell samples
675	while (1) {
676	int num = mVssSamplesPerPass;
677	SimpleRayContainer rays;
678	VssRayContainer vssRays;
679
680	if (!mUseImportanceSampling) {
681	for (int j=0; j < num; j++) {
682	// changed by matt
683	//Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
684	Vector3 viewpoint;
685	mViewCellsManager->GetViewPoint(viewpoint);
686	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
687	rays.push_back(SimpleRay(viewpoint, direction));
688	}
689	} else {
690	num = GenerateImportanceRays(vssTree, num, rays);
691	}
692
693	for (int i=0; i < rays.size(); i++)
694	CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
695
696	vssTree->AddRays(vssRays);
697
698	if (0) {
699	int subdivided = vssTree->UpdateSubdivision();
700	cout<<"subdivided leafs = "<<subdivided<<endl;
701	}
702
703	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
704	cout<<"Average PVS size = "<<avgPvs<<endl;
705
706	//Debug << "samples: " << samples << " construction samples " << mViewCellsManager->GetConstructionSamples() << endl;
707	// construct view cells after vss
708	if (!mViewCellsManager->ViewCellsConstructed() &&
709	(samples + mInitialSamples > mViewCellsManager->GetConstructionSamples()))
710	{
711	VssRayContainer constructionRays;
712	vssTree->CollectRays(constructionRays,
713	mViewCellsManager->GetConstructionSamples());
714	mViewCellsManager->Construct(mObjects, constructionRays);
715	}
716
717	/// compute view cell contribution of rays
718	mViewCellsManager->ComputeSampleContributions(vssRays);
719
720	if (numExportRays) {
721	char filename[64];
722	if (mUseImportanceSampling)
723	sprintf(filename, "vss-rays-i%04d.x3d", pass);
724	else
725	sprintf(filename, "vss-rays-%04d.x3d", pass);
726
727	ExportRays(filename, vssRays, numExportRays);
728	}
729
730	samples+=num;
731	float pvs = vssTree->GetAvgPvsSize();
732	cout<<"*****************************\n";
733	cout<<samples<<" avgPVS ="<<pvs<<endl;
734	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
735	cout<<"*****************************\n";
736	if (samples >= mVssSamples)
737	break;
738	pass++;
739	}
740
741	Debug << vssTree->stat << endl;
742	VssRayContainer viewCellRays;
743
744	// compute rays used for view cells construction
745	int numRays = Max(mViewCellsManager->GetPostProcessSamples(),
746	mViewCellsManager->GetVisualizationSamples());
747
748	vssTree->CollectRays(viewCellRays, numRays);
749
750	//-- post process view cells
751	mViewCellsManager->PostProcess(mObjects, viewCellRays);
752
753	if (mTestBeamSampling && mUseGlRenderer)
754	{
755	TestBeamCasting(vssTree, mViewCellsManager, mObjects);
756	}
757
758	//-- several visualizations and statistics
759	Debug << "\nview cells after post processing: " << endl;
760	mViewCellsManager->PrintStatistics(Debug);
761
762	mViewCellsManager->Visualize(mObjects, viewCellRays);
763
764	//-- render simulation after merge
765	cout << "\nevaluating bsp view cells render time after merge ... ";
766	mRenderSimulator->RenderScene();
767	SimulationStatistics ss;
768	mRenderSimulator->GetStatistics(ss);
769
770	cout << " finished" << endl;
771	cout << ss << endl;
772	Debug << ss << endl;
773
774	delete vssTree;
775
776	return true;
777	}

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

Download in other formats: