Context Navigation

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

Revision 540, 20.2 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	if (mUseViewSpaceBox)
509	{
510	mViewSpaceBox = box;
511	mViewCellsManager->SetViewSpaceBox(*box);
512	}
513	else
514	{
515	mViewSpaceBox = NULL;
516	mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
517	}
518
519	//-- load view cells from file if requested
520	if (mLoadViewCells)
521	{
522	// load now because otherwise bounding box not correct
523	mViewCellsManager->LoadViewCells(mViewCellsFilename, &mObjects);
524	}
525
526
527	VssTree *vssTree = NULL;
528
529	mSceneGraph->CollectObjects(&mObjects);
530
531	long initialTime = GetTime();
532
533	if (mLoadInitialSamples)
534	{
535	cout << "Loading samples from file ... ";
536	LoadSamples(mVssRays, mObjects);
537	cout << "finished\n" << endl;
538	totalSamples = (int)mVssRays.size();
539	}
540	else
541	{
542
543	while (totalSamples < mInitialSamples) {
544	int passContributingSamples = 0;
545	int passSampleContributions = 0;
546	int passSamples = 0;
547
548	int index = 0;
549
550	int sampleContributions;
551
552	int s = Min(mSamplesPerPass, mInitialSamples);
553	for (int k=0; k < s; k++) {
554	// changed by matt
555	Vector3 viewpoint;
556	// viewpoint = GetViewpoint(mViewSpaceBox);
557	mViewCellsManager->GetViewPoint(viewpoint);
558	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
559
560	sampleContributions = CastRay(viewpoint, direction, mVssRays);
561
562	if (sampleContributions) {
563	passContributingSamples ++;
564	passSampleContributions += sampleContributions;
565	}
566	passSamples++;
567	totalSamples++;
568	}
569
570	mPass++;
571	int pvsSize = 0;
572	float avgRayContrib = (passContributingSamples > 0) ?
573	passSampleContributions/(float)passContributingSamples : 0;
574
575	cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
576	cout << "#TotalSamples=" << totalSamples/1000
577	<< "k #SampleContributions=" << passSampleContributions << " ("
578	<< 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
579	<< pvsSize/(float)mObjects.size() << endl
580	<< "avg ray contrib=" << avgRayContrib << endl;
581
582	mStats <<
583	"#Pass\n" <<mPass<<endl<<
584	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
585	"#TotalSamples\n" << totalSamples<< endl<<
586	"#SampleContributions\n" << passSampleContributions << endl <<
587	"#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
588	"#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
589	"#AvgRayContrib\n" << avgRayContrib << endl;
590	}
591
592	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
593
594
595
596	}
597
598	cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl << flush;
599	Debug << (int)mVssRays.size() << " rays generated in "
600	<< TimeDiff(initialTime, GetTime()) * 1e-3 << " seconds" << endl;
601
602	if (mStoreInitialSamples)
603	{
604	cout << "Writing " << (int)mVssRays.size() << " samples to file ... ";
605	ExportSamples(mVssRays);
606	cout << "finished\n" << endl;
607
608	/*VssRayContainer dummyRays;
609	LoadSamples(dummyRays, mObjects);
610	Debug << "rays " << (int)mVssRays.size() << " " << dummyRays.size() << endl;
611
612	for (int i = 0; i < (int)mVssRays.size(); ++ i)
613	{
614	Debug << mVssRays[i]->GetOrigin() << " " << mVssRays[i]->GetTermination() << " " << mVssRays[i]->mOriginObject << " " << mVssRays[i]->mTerminationObject << endl;
615	Debug << dummyRays[i]->GetOrigin() << " " << dummyRays[i]->GetTermination() << " " << dummyRays[i]->mOriginObject << " " << dummyRays[i]->mTerminationObject << endl << endl;
616	}*/
617	}
618
619
620	//int numExportRays = 5000;
621	int numExportRays = 0;
622
623	if (numExportRays) {
624	char filename[64];
625	sprintf(filename, "vss-rays-initial.x3d");
626	ExportRays(filename, mVssRays, numExportRays);
627	}
628
629	/// compute view cell contribution of rays if view cells manager already constructed
630	mViewCellsManager->ComputeSampleContributions(mVssRays);
631
632	// construct view cells
633	if (!mDelayedViewCellsConstruction)
634	mViewCellsManager->Construct(mObjects, mVssRays);
635
636	vssTree = new VssTree;
637	// viewcells = Construct(mVssRays);
638
639	vssTree->Construct(mVssRays, mViewSpaceBox);
640	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
641
642	if (0)
643	{
644	ExportVssTree("vss-tree-100.x3d", vssTree, Vector3(1,0,0));
645	ExportVssTree("vss-tree-001.x3d", vssTree, Vector3(0,0,1));
646	ExportVssTree("vss-tree-101.x3d", vssTree, Vector3(1,0,1));
647	ExportVssTree("vss-tree-101m.x3d", vssTree, Vector3(-1,0,-1));
648	ExportVssTreeLeaves(vssTree, 10);
649	}
650
651	// viewcells->UpdatePVS(newVssRays);
652	// get viewcells as kd tree boxes
653	vector<AxisAlignedBox3> kdViewcells;
654	if (0) {
655	vector<KdLeaf *> leaves;
656	mKdTree->CollectLeaves(leaves);
657	vector<KdLeaf *>::const_iterator it;
658	int targetLeaves = 50;
659	float prob = targetLeaves/(float)leaves.size();
660	for (it = leaves.begin(); it != leaves.end(); ++it)
661	if (RandomValue(0.0f,1.0f) < prob)
662	kdViewcells.push_back(mKdTree->GetBox(*it));
663
664	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
665	cout<<"Initial average PVS size = "<<avgPvs<<endl;
666	}
667
668
669	int samples = 0;
670	int pass = 0;
671
672
673	// cast view cell samples
674	while (1) {
675	int num = mVssSamplesPerPass;
676	SimpleRayContainer rays;
677	VssRayContainer vssRays;
678
679	if (!mUseImportanceSampling) {
680	for (int j=0; j < num; j++) {
681	// changed by matt
682	//Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
683	Vector3 viewpoint;
684	mViewCellsManager->GetViewPoint(viewpoint);
685	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
686	rays.push_back(SimpleRay(viewpoint, direction));
687	}
688	} else {
689	num = GenerateImportanceRays(vssTree, num, rays);
690	}
691
692	for (int i=0; i < rays.size(); i++)
693	CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
694
695	vssTree->AddRays(vssRays);
696
697	if (0) {
698	int subdivided = vssTree->UpdateSubdivision();
699	cout<<"subdivided leafs = "<<subdivided<<endl;
700	}
701
702	float avgPvs = GetAvgPvsSize(vssTree, kdViewcells);
703	cout<<"Average PVS size = "<<avgPvs<<endl;
704
705	//Debug << "samples: " << samples << " construction samples " << mViewCellsManager->GetConstructionSamples() << endl;
706	// construct view cells after vss
707	if (!mViewCellsManager->ViewCellsConstructed() &&
708	(samples + mInitialSamples > mViewCellsManager->GetConstructionSamples()))
709	{
710	VssRayContainer constructionRays;
711	vssTree->CollectRays(constructionRays,
712	mViewCellsManager->GetConstructionSamples());
713	mViewCellsManager->Construct(mObjects, constructionRays);
714	}
715
716	/// compute view cell contribution of rays
717	mViewCellsManager->ComputeSampleContributions(vssRays);
718
719	if (numExportRays) {
720	char filename[64];
721	if (mUseImportanceSampling)
722	sprintf(filename, "vss-rays-i%04d.x3d", pass);
723	else
724	sprintf(filename, "vss-rays-%04d.x3d", pass);
725
726	ExportRays(filename, vssRays, numExportRays);
727	}
728
729	samples+=num;
730	float pvs = vssTree->GetAvgPvsSize();
731	cout<<"*****************************\n";
732	cout<<samples<<" avgPVS ="<<pvs<<endl;
733	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
734	cout<<"*****************************\n";
735	if (samples >= mVssSamples)
736	break;
737	pass++;
738	}
739
740	Debug << vssTree->stat << endl;
741	VssRayContainer viewCellRays;
742
743	// compute rays used for view cells construction
744	int numRays = Max(mViewCellsManager->GetPostProcessSamples(),
745	mViewCellsManager->GetVisualizationSamples());
746
747	vssTree->CollectRays(viewCellRays, numRays);
748
749	//-- post process view cells
750	mViewCellsManager->PostProcess(mObjects, viewCellRays);
751
752	if (mTestBeamSampling && mUseGlRenderer)
753	{
754	TestBeamCasting(vssTree, mViewCellsManager, mObjects);
755	}
756
757	//-- several visualizations and statistics
758	Debug << "\nview cells after post processing: " << endl;
759	mViewCellsManager->PrintStatistics(Debug);
760
761	mViewCellsManager->Visualize(mObjects, viewCellRays);
762
763	//-- render simulation after merge
764	cout << "\nevaluating bsp view cells render time after merge ... ";
765	mRenderSimulator->RenderScene();
766	SimulationStatistics ss;
767	mRenderSimulator->GetStatistics(ss);
768
769	cout << " finished" << endl;
770	cout << ss << endl;
771	Debug << ss << endl;
772
773	delete vssTree;
774
775	return true;
776	}

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

Download in other formats: