Context Navigation

source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp @ 610

Revision 610, 80.8 KB checked in by mattausch, 18 years ago (diff)

Line
1	#include "ViewCellsManager.h"
2	#include "RenderSimulator.h"
3	#include "Mesh.h"
4	#include "Triangle3.h"
5	#include "ViewCell.h"
6	#include "Environment.h"
7	#include "X3dParser.h"
8	#include "ViewCellBsp.h"
9	#include "KdTree.h"
10	#include "VspKdTree.h"
11	#include "Exporter.h"
12	#include "VspBspTree.h"
13	#include "ViewCellsParser.h"
14	#include "Beam.h"
15	#include "VssPreprocessor.h"
16	#include "RssPreprocessor.h"
17
18	#define SAMPLE_AFTER_SUBDIVISION 1
19
20
21	ViewCellsManager::ViewCellsManager():
22	mRenderer(NULL),
23	mInitialSamples(0),
24	mConstructionSamples(0),
25	mPostProcessSamples(0),
26	mVisualizationSamples(0),
27	mTotalAreaValid(false),
28	mTotalArea(0.0f),
29	mViewCellsFinished(false),
30	mMaxPvsSize(9999999),
31	mMinPvsSize(0), // one means only empty view cells are invalid
32	mMaxPvsRatio(1.0)
33	{
34	mViewSpaceBox.Initialize();
35	ParseEnvironment();
36
37	mViewCellsTree = new ViewCellsTree(this);
38	}
39
40
41	void ViewCellsManager::ParseEnvironment()
42	{
43	// visualization stuff
44	environment->GetBoolValue("ViewCells.Visualization.exportRays", mExportRays);
45	environment->GetBoolValue("ViewCells.Visualization.exportGeometry", mExportGeometry);
46	environment->GetFloatValue("ViewCells.maxPvsRatio", mMaxPvsRatio);
47	bool emptyViewCells = false;
48	environment->GetBoolValue("ViewCells.pruneEmptyViewCells", emptyViewCells);
49	environment->GetBoolValue("ViewCells.processOnlyValidViewCells", mOnlyValidViewCells);
50
51	environment->GetIntValue("ViewCells.Construction.samples", mConstructionSamples);
52	environment->GetIntValue("ViewCells.PostProcess.samples", mPostProcessSamples);
53	environment->GetBoolValue("ViewCells.PostProcess.useRaysForMerge", mUseRaysForMerge);
54
55	environment->GetIntValue("ViewCells.Visualization.samples", mVisualizationSamples);
56
57	environment->GetIntValue("ViewCells.Construction.samplesPerPass", mSamplesPerPass);
58	environment->GetBoolValue("ViewCells.exportToFile", mExportViewCells);
59
60
61	environment->GetIntValue("ViewCells.active", mNumActiveViewCells);
62	environment->GetBoolValue("ViewCells.PostProcess.compress", mCompressViewCells);
63	environment->GetBoolValue("ViewCells.Visualization.useCuttingPlane", mUseCuttingPlaneForViz);
64
65	environment->GetBoolValue("ViewCells.PostProcess.merge", mMergeViewCells);
66
67	mMinPvsSize = emptyViewCells ? 1 : 0;
68
69	char buf[50];
70	environment->GetStringValue("ViewCells.Visualization.colorCode", buf);
71
72	if (strcmp(buf, "PVS") == 0)
73	mColorCode = 1;
74	else if (strcmp(buf, "MergedLeaves") == 0)
75	mColorCode = 2;
76	else if (strcmp(buf, "MergedTreeDiff") == 0)
77	mColorCode = 3;
78	else
79	mColorCode = 0;
80
81	Debug << "colorCode: " << mColorCode << endl;
82	}
83
84
85	ViewCellsManager::~ViewCellsManager()
86	{
87	DEL_PTR(mRenderer);
88
89	if (!ViewCellsTreeConstructed())
90	CLEAR_CONTAINER(mViewCells);
91	else
92	DEL_PTR(mViewCellsTree);
93
94	CLEAR_CONTAINER(mMeshContainer);
95	}
96
97
98	int ViewCellsManager::CastPassSamples(const int samplesPerPass,
99	const int sampleType,
100	VssRayContainer &passSamples) const
101	{
102	SimpleRayContainer simpleRays;
103
104	preprocessor->GenerateRays(samplesPerPass,
105	sampleType,
106	simpleRays);
107
108	// shoot simple ray and add it to importance samples
109	preprocessor->CastRays(simpleRays, passSamples);
110
111	return (int)passSamples.size();
112	}
113
114
115
116	/// helper function which destroys rays or copies them into the output ray container
117	inline void addOutRays(VssRayContainer &rays, VssRayContainer *outRays)
118	{
119	cout << "disposing samples ... ";
120	long startTime = GetTime();
121	int n = (int)rays.size();
122
123	if (outRays)
124	{
125	VssRayContainer::const_iterator it, it_end = rays.end();
126
127	for (it = rays.begin(); it != it_end; ++ it)
128	{
129	outRays->push_back(*it);
130	}
131	}
132	else
133	{
134	CLEAR_CONTAINER(rays);
135	}
136	cout << "finished" << endl;
137	Debug << "disposed " << n << " samples in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;
138	}
139
140
141	int ViewCellsManager::Construct(Preprocessor preprocessor, VssRayContainer outRays)
142	{
143	int numSamples = 0;
144	SimpleRayContainer simpleRays;
145
146	VssRayContainer initialSamples;
147
148	cout << "view cell construction: casting " << mInitialSamples << " initial samples ... ";
149	//-- construction rays => we use uniform samples for this
150	CastPassSamples(mInitialSamples,
151	//Preprocessor::DIRECTION_BASED_DISTRIBUTION,
152	Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION,
153	initialSamples);
154
155	cout << "finished" << endl;
156
157	// construct view cells
158	const int numInitialSamples =
159	ConstructSubdivision(preprocessor->mObjects, initialSamples);
160
161	numSamples += numInitialSamples;
162
163	// rays can be passed or deleted
164	addOutRays(initialSamples, outRays);
165
166
167	//-- guided rays are used for further sampling
168	const int n = mConstructionSamples; //+initialSamples;
169
170	bool dirSamples = false;
171
172	while (numSamples < n)
173	{
174	cout << "casting " << mSamplesPerPass << " samples of " << n << " ... ";
175	VssRayContainer constructionSamples;
176
177	const int samplingType =
178	dirSamples ?
179	Preprocessor::DIRECTION_BASED_DISTRIBUTION :
180	Preprocessor::SPATIAL_BOX_BASED_DISTRIBUTION;
181
182	if (0)
183	dirSamples = !dirSamples; // toggle sampling method
184	numSamples += CastPassSamples(mSamplesPerPass,
185	samplingType,
186	constructionSamples);
187
188	cout << "finished" << endl;
189
190	cout << "computing sample contribution for " << (int)constructionSamples.size() << " samples ... ";
191
192	// TODO: leak?
193	if (SAMPLE_AFTER_SUBDIVISION)
194	ComputeSampleContributions(constructionSamples, true, false);
195	cout << "finished" << endl;
196
197
198	addOutRays(constructionSamples, outRays);
199
200	cout << "total samples: " << numSamples << endl;
201	}
202
203
204	//-- post processing
205	VssRayContainer postProcessSamples;
206
207	//-- construction rays => we use uniform samples for this
208	CastPassSamples(mPostProcessSamples,
209	Preprocessor::DIRECTION_BASED_DISTRIBUTION,
210	postProcessSamples);
211
212	cout << "starting post processing and visualization" << endl;
213
214	// store viewCells for postprocessing
215	const bool storeViewCells = true;
216
217	if (SAMPLE_AFTER_SUBDIVISION)
218	ComputeSampleContributions(postProcessSamples, true, storeViewCells);
219	// merge the view cells
220	PostProcess(preprocessor->mObjects, postProcessSamples);
221
222
223	//-- visualization
224	VssRayContainer visualizationSamples;
225
226	//-- construction rays => we use uniform samples for this
227	CastPassSamples(mVisualizationSamples,
228	Preprocessor::DIRECTION_BASED_DISTRIBUTION,
229	visualizationSamples);
230
231	if (SAMPLE_AFTER_SUBDIVISION)
232	ComputeSampleContributions(visualizationSamples, true, storeViewCells);
233
234	//Debug << "visualizationsamples: " << mVisualizationSamples << " " << visualizationSamples.size() << endl;
235	// different visualizations
236	Visualize(preprocessor->mObjects, visualizationSamples);
237
238	addOutRays(visualizationSamples, outRays);
239
240	return numSamples;
241	}
242
243
244	bool ViewCellsManager::CheckValidity(ViewCell *vc,
245	int minPvsSize,
246	int maxPvsSize) const
247	{
248
249	if ((vc->GetPvs().GetSize() > maxPvsSize) \|\|
250	(vc->GetPvs().GetSize() < minPvsSize))
251	{
252	return false;
253	}
254
255	return true;
256	}
257
258
259	bool ViewCellsManager::ViewCellsTreeConstructed() const
260	{
261	return mViewCellsTree->GetRoot();
262	}
263
264
265	void ViewCellsManager::SetValidity(ViewCell *vc,
266	int minPvs,
267	int maxPvs) const
268	{
269	vc->SetValid(CheckValidity(vc, minPvs, maxPvs));
270	}
271
272
273	void
274	ViewCellsManager::SetValidity(
275	int minPvsSize,
276	int maxPvsSize) const
277	{
278	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
279
280	for (it = mViewCells.begin(); it != it_end; ++ it) {
281	SetValidity(*it, minPvsSize, maxPvsSize);
282	}
283	}
284
285	void
286	ViewCellsManager::SetValidityPercentage(
287	const float minValid,
288	const float maxValid
289	)
290	{
291	sort(mViewCells.begin(), mViewCells.end(), ViewCell::SmallerPvs);
292
293	int start = mViewCells.size()*minValid;
294	int end = mViewCells.size()*maxValid;
295
296	for (int i=0; i < mViewCells.size(); i++)
297	mViewCells[i]->SetValid(i >= start && i <= end);
298	}
299
300	int
301	ViewCellsManager::CountValidViewcells() const
302	{
303	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
304	int valid = 0;
305	for (it = mViewCells.begin(); it != it_end; ++ it) {
306	if ((*it)->GetValid())
307	valid++;
308	}
309	return valid;
310	}
311
312
313	bool ViewCellsManager::LoadViewCellsGeometry(const string filename)
314	{
315	X3dParser parser;
316
317	environment->GetFloatValue("ViewCells.height", parser.mViewCellHeight);
318
319	bool success = parser.ParseFile(filename, *this);
320	Debug << (int)mViewCells.size() << " view cells loaded" << endl;
321
322	return success;
323	}
324
325
326	bool ViewCellsManager::GetViewPoint(Vector3 &viewPoint) const
327	{
328	viewPoint = mViewSpaceBox.GetRandomPoint();
329
330	return true;
331	}
332
333
334	float ViewCellsManager::GetViewSpaceVolume()
335	{
336	return mViewSpaceBox.GetVolume() * (2.0f * sqr((float)M_PI));
337	}
338
339
340	bool ViewCellsManager::ViewPointValid(const Vector3 &viewPoint) const
341	{
342	if (!ViewCellsConstructed())
343	return mViewSpaceBox.IsInside(viewPoint);
344	else {
345	if (!mViewSpaceBox.IsInside(viewPoint))
346	return false;
347	ViewCell *viewcell = GetViewCell(viewPoint);
348	if (!viewcell \|\| !viewcell->GetValid())
349	return false;
350	}
351	return true;
352	}
353
354
355	float
356	ViewCellsManager::ComputeSampleContributions(const VssRayContainer &rays,
357	const bool addRays,
358	const bool storeViewCells
359	)
360	{
361	// view cells not yet constructed
362	if (!ViewCellsConstructed())
363	return 0.0f;
364
365	VssRayContainer::const_iterator it, it_end = rays.end();
366
367	float sum = 0.0f;
368	for (it = rays.begin(); it != it_end; ++ it) {
369	sum += ComputeSampleContributions((it), addRays, storeViewCells);
370	//ComputeSampleContributions((it), addRays);
371	// sum += (*it)->mPvsContribution;
372	}
373	return sum;
374	}
375
376
377	void ViewCellsManager::EvaluateViewCellsStats()
378	{
379	mViewCellsStats.Reset();
380
381	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
382
383	for (it = mViewCells.begin(); it != it_end; ++ it)
384	{
385	mViewCellsTree->UpdateViewCellsStats(*it, mViewCellsStats);
386	}
387	}
388
389
390	void ViewCellsManager::EvaluateRenderStatistics(float &totalRenderCost,
391	float &expectedRenderCost,
392	float &deviation,
393	float &variance,
394	int &totalPvs,
395	float &avgRenderCost)
396	{
397	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
398
399
400	//-- compute expected value
401
402	totalRenderCost = 0;
403	totalPvs = 0;
404
405	for (it = mViewCells.begin(); it != it_end; ++ it)
406	{
407	ViewCell vc = it;
408	totalRenderCost += vc->GetPvs().GetSize() * vc->GetVolume();
409	totalPvs += (int)vc->GetPvs().GetSize();
410	}
411
412	// normalize with view space box
413	totalRenderCost /= mViewSpaceBox.GetVolume();
414	expectedRenderCost = totalRenderCost / (float)mViewCells.size();
415	avgRenderCost = totalPvs / (float)mViewCells.size();
416
417
418	//-- compute standard defiation
419	variance = 0;
420	deviation = 0;
421
422	for (it = mViewCells.begin(); it != it_end; ++ it)
423	{
424	ViewCell vc = it;
425
426	float renderCost = vc->GetPvs().GetSize() * vc->GetVolume();
427	float dev;
428
429	if (1)
430	dev = fabs(avgRenderCost - (float)vc->GetPvs().GetSize());
431	else
432	dev = fabs(expectedRenderCost - renderCost);
433
434	deviation += dev;
435	variance += dev * dev;
436	}
437
438	variance /= (float)mViewCells.size();
439	deviation /= (float)mViewCells.size();
440	}
441
442
443
444	void ViewCellsManager::AddViewCell(ViewCell *viewCell)
445	{
446	mViewCells.push_back(viewCell);
447	}
448
449
450	float ViewCellsManager::GetArea(ViewCell *viewCell) const
451	{
452	return viewCell->GetArea();
453	}
454
455
456	float ViewCellsManager::GetVolume(ViewCell *viewCell) const
457	{
458	return viewCell->GetVolume();
459	}
460
461
462	void ViewCellsManager::DeriveViewCells(const ObjectContainer &objects,
463	ViewCellContainer &viewCells,
464	const int maxViewCells) const
465	{
466	// maximal max viewcells
467	int limit = maxViewCells > 0 ?
468	Min((int)objects.size(), maxViewCells) : (int)objects.size();
469
470	for (int i = 0; i < limit; ++ i)
471	{
472	Intersectable *object = objects[i];
473
474	// extract the mesh instances
475	if (object->Type() == Intersectable::MESH_INSTANCE)
476	{
477	MeshInstance inst = dynamic_cast<MeshInstance >(object);
478
479	ViewCell *viewCell = GenerateViewCell(inst->GetMesh());
480	viewCells.push_back(viewCell);
481	}
482	//TODO: transformed meshes
483	}
484	}
485
486
487	ViewCell *ViewCellsManager::ExtrudeViewCell(const Triangle3 &baseTri,
488	const float height) const
489	{
490	// one mesh per view cell
491	Mesh *mesh = new Mesh();
492
493	//-- construct prism
494
495	// bottom
496	mesh->mFaces.push_back(new Face(2,1,0));
497	// top
498	mesh->mFaces.push_back(new Face(3,4,5));
499	// sides
500	mesh->mFaces.push_back(new Face(1, 4, 3, 0));
501	mesh->mFaces.push_back(new Face(2, 5, 4, 1));
502	mesh->mFaces.push_back(new Face(3, 5, 2, 0));
503
504	//--- extrude new vertices for top of prism
505	Vector3 triNorm = baseTri.GetNormal();
506
507	Triangle3 topTri;
508
509	// add base vertices and calculate top vertices
510	for (int i = 0; i < 3; ++ i)
511	mesh->mVertices.push_back(baseTri.mVertices[i]);
512
513	// add top vertices
514	for (int i = 0; i < 3; ++ i)
515	mesh->mVertices.push_back(baseTri.mVertices[i] + height * triNorm);
516
517	mesh->Preprocess();
518
519	return GenerateViewCell(mesh);
520	}
521
522
523	void ViewCellsManager::FinalizeViewCells(const bool createMesh)
524	{
525	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
526	for (it = mViewCells.begin(); it != it_end; ++ it)
527	{
528	Finalize(*it, createMesh);
529	}
530
531	mTotalAreaValid = false;
532	}
533
534
535	void ViewCellsManager::Finalize(ViewCell *viewCell, const bool createMesh)
536	{
537	// implemented in subclasses
538	}
539
540
541	ViewCellInterior ViewCellsManager::MergeViewCells(ViewCell left, ViewCell *right) const
542	{
543	// generate parent view cell
544	ViewCellInterior *vc = new ViewCellInterior();//GenerateViewCell();
545
546	vc->GetPvs() = left->GetPvs();
547	// merge pvs
548	vc->GetPvs().Merge(right->GetPvs());
549
550	//-- merge ray sets
551	if (0)
552	{
553	stable_sort(left->mPiercingRays.begin(), left->mPiercingRays.end());
554	stable_sort(right->mPiercingRays.begin(), right->mPiercingRays.end());
555
556	std::merge(left->mPiercingRays.begin(), left->mPiercingRays.end(),
557	right->mPiercingRays.begin(), right->mPiercingRays.end(),
558	vc->mPiercingRays.begin());
559	}
560
561
562	vc->SetupChildLink(left);
563	vc->SetupChildLink(right);
564
565
566	return vc;
567	}
568
569
570	ViewCellInterior *ViewCellsManager::MergeViewCells(ViewCellContainer &children) const
571	{
572	ViewCellInterior *vc = new ViewCellInterior();//GenerateViewCell();
573
574	ViewCellContainer::const_iterator it, it_end = children.end();
575
576	for (it = children.begin(); it != it_end; ++ it)
577	{
578	// merge pvs
579	vc->GetPvs().Merge((*it)->GetPvs());
580
581	vc->SetupChildLink(*it);
582	}
583
584	return vc;
585	}
586
587
588	void ViewCellsManager::SetRenderer(Renderer *renderer)
589	{
590	mRenderer = renderer;
591	}
592
593
594	ViewCellsTree *ViewCellsManager::GetViewCellsTree()
595	{
596	return mViewCellsTree;
597	}
598
599
600	void ViewCellsManager::SetVisualizationSamples(const int visSamples)
601	{
602	mVisualizationSamples = visSamples;
603	}
604
605
606	void ViewCellsManager::SetConstructionSamples(const int constructionSamples)
607	{
608	mConstructionSamples = constructionSamples;
609	}
610
611
612	void ViewCellsManager::SetInitialSamples(const int initialSamples)
613	{
614	mInitialSamples = initialSamples;
615	}
616
617
618	void ViewCellsManager::SetPostProcessSamples(const int postProcessSamples)
619	{
620	mPostProcessSamples = postProcessSamples;
621	}
622
623
624	int ViewCellsManager::GetVisualizationSamples() const
625	{
626	return mVisualizationSamples;
627	}
628
629
630	int ViewCellsManager::GetConstructionSamples() const
631	{
632	return mConstructionSamples;
633	}
634
635
636	int ViewCellsManager::GetPostProcessSamples() const
637	{
638	return mPostProcessSamples;
639	}
640
641
642	void ViewCellsManager::GetPvsStatistics(PvsStatistics &stat)
643	{
644	ViewCellContainer::const_iterator it = mViewCells.begin();
645	stat.viewcells = 0;
646	stat.minPvs = 100000000;
647	stat.maxPvs = 0;
648	stat.avgPvs = 0.0f;
649
650	for (; it != mViewCells.end(); ++it) {
651	ViewCell viewcell = it;
652	int pvsSize = viewcell->GetPvs().GetSize();
653	if ( pvsSize < stat.minPvs)
654	stat.minPvs = pvsSize;
655	if (pvsSize > stat.maxPvs)
656	stat.maxPvs = pvsSize;
657	stat.avgPvs += pvsSize;
658	stat.viewcells++;
659	}
660	if (stat.viewcells)
661	stat.avgPvs/=stat.viewcells;
662	}
663
664
665	void ViewCellsManager::PrintPvsStatistics(ostream &s)
666	{
667	s<<"############# Viewcell PVS STAT ##################\n";
668	PvsStatistics pvsStat;
669	GetPvsStatistics(pvsStat);
670	s<<"#AVG_PVS\n"<<pvsStat.avgPvs<<endl;
671	s<<"#MAX_PVS\n"<<pvsStat.maxPvs<<endl;
672	s<<"#MIN_PVS\n"<<pvsStat.minPvs<<endl;
673	}
674
675
676	int ViewCellsManager::CastBeam(Beam &beam)
677	{
678	return 0;
679	}
680
681
682	ViewCellContainer &ViewCellsManager::GetViewCells()
683	{
684	return mViewCells;
685	}
686
687
688	void ViewCellsManager::SetViewSpaceBox(const AxisAlignedBox3 &box)
689	{
690	mViewSpaceBox = box;
691
692	CreateCuttingPlane();
693
694	mTotalAreaValid = false;
695	}
696
697
698	void ViewCellsManager::CreateCuttingPlane()
699	{
700	int axis = 0;
701
702	const float factor = 0.65;
703	Vector3 point = mViewSpaceBox.Min() + mViewSpaceBox.Size() * factor;
704
705	if (mUseCuttingPlaneForViz)
706	environment->GetIntValue("ViewCells.Visualization.cuttingPlaneAxis", axis);
707
708	Vector3 normal(0,0,0);
709	normal[axis] = 1;
710
711	mCuttingPlane = Plane3(normal, point);
712	}
713
714
715	AxisAlignedBox3 ViewCellsManager::GetViewSpaceBox() const
716	{
717	return mViewSpaceBox;
718	}
719
720
721	void ViewCellsManager::ResetViewCells()
722	{
723	mViewCells.clear();
724
725	CollectViewCells();
726
727	mViewCellsStats.Reset();
728	EvaluateViewCellsStats();
729
730	// has to be recomputed
731	mTotalAreaValid = false;
732	}
733
734
735	int ViewCellsManager::GetMaxPvsSize() const
736	{
737	return mMaxPvsSize;
738	}
739
740
741	void
742	ViewCellsManager::AddSampleContributions(const VssRayContainer &rays)
743	{
744	if (!ViewCellsConstructed())
745	return;
746
747	VssRayContainer::const_iterator it, it_end = rays.end();
748
749	for (it = rays.begin(); it != it_end; ++ it) {
750	AddSampleContributions((it));
751	}
752	}
753
754
755	int ViewCellsManager::GetMinPvsSize() const
756	{
757	return mMinPvsSize;
758	}
759
760
761
762	float ViewCellsManager::GetMaxPvsRatio() const
763	{
764	return mMaxPvsRatio;
765	}
766
767
768	void
769	ViewCellsManager::AddSampleContributions(VssRay &ray)
770	{
771	// assumes viewcells have been stored...
772	ViewCellContainer *viewcells = &ray.mViewCells;
773	ViewCellContainer::const_iterator it;
774	for (it = viewcells->begin(); it != viewcells->end(); ++it) {
775	ViewCell viewcell = it;
776	if (viewcell->GetValid()) {
777	// if ray not outside of view space
778	viewcell->GetPvs().AddSample(ray.mTerminationObject, ray.mPdf);
779	}
780	}
781	}
782
783
784	float ViewCellsManager::ComputeSampleContributions(VssRay &ray,
785	const bool addRays,
786	const bool storeViewCells)
787	{
788	ViewCellContainer viewcells;
789
790	ray.mPvsContribution = 0;
791	ray.mRelativePvsContribution = 0.0f;
792
793	static Ray hray;
794	hray.Init(ray);
795	//hray.mFlags \|= Ray::CULL_BACKFACES;
796	//Ray hray(ray);
797
798	float tmin = 0, tmax = 1.0;
799
800	if (!GetViewSpaceBox().GetRaySegment(hray, tmin, tmax) \|\| (tmin > tmax))
801	return 0;
802
803	Vector3 origin = hray.Extrap(tmin);
804	Vector3 termination = hray.Extrap(tmax);
805
806	CastLineSegment(origin, termination, viewcells);
807	//Debug << "constribution: " << (int)viewcells.size() << endl;
808
809	// copy viewcells memory efficiently
810	//const bool storeViewcells = !addRays;
811
812	if (storeViewCells)
813	{
814	ray.mViewCells.reserve(viewcells.size());
815	ray.mViewCells = viewcells;
816	}
817
818	ViewCellContainer::const_iterator it = viewcells.begin();
819
820
821	for (; it != viewcells.end(); ++it) {
822	ViewCell viewcell = it;
823	if (viewcell->GetValid()) {
824	// if ray not outside of view space
825	float contribution;
826	if (viewcell->GetPvs().GetSampleContribution(ray.mTerminationObject,
827	ray.mPdf,
828	contribution
829	))
830	ray.mPvsContribution++;
831	ray.mRelativePvsContribution += contribution;
832	}
833	}
834
835	if (addRays)
836	for (it = viewcells.begin(); it != viewcells.end(); ++it) {
837	ViewCell viewcell = it;
838	if (viewcell->GetValid()) {
839	// if ray not outside of view space
840	viewcell->GetPvs().AddSample(ray.mTerminationObject, ray.mPdf);
841	}
842	}
843
844	return ray.mRelativePvsContribution;
845	}
846
847
848	void ViewCellsManager::GetRaySets(const VssRayContainer &sourceRays,
849	const int maxSize,
850	VssRayContainer &usedRays,
851	VssRayContainer *savedRays) const
852	{
853	const int limit = min(maxSize, (int)sourceRays.size());
854	const float prop = (float)limit / ((float)sourceRays.size() + Limits::Small);
855
856	VssRayContainer::const_iterator it, it_end = sourceRays.end();
857	for (it = sourceRays.begin(); it != it_end; ++ it)
858	{
859	if (Random(1.0f) < prop)
860	usedRays.push_back(*it);
861	else if (savedRays)
862	savedRays->push_back(*it);
863	}
864	}
865
866
867	float ViewCellsManager::GetRendercost(ViewCell *viewCell, float objRendercost) const
868	{
869	return mViewCellsTree->GetPvsSize(viewCell) * objRendercost;
870	}
871
872
873	float ViewCellsManager::GetAccVcArea()
874	{
875	// if already computed
876	if (mTotalAreaValid)
877	return mTotalArea;
878
879	mTotalArea = 0;
880	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
881
882	for (it = mViewCells.begin(); it != it_end; ++ it)
883	{
884	//Debug << "area: " << GetArea(*it);
885	mTotalArea += GetArea(*it);
886	}
887
888	mTotalAreaValid = true;
889
890	return mTotalArea;
891	}
892
893
894	void ViewCellsManager::PrintStatistics(ostream &s) const
895	{
896	s << mViewCellsStats << endl;
897	}
898
899
900	void ViewCellsManager::CreateUniqueViewCellIds()
901	{
902	for (int i = 0; i < (int)mViewCells.size(); ++ i)
903	mViewCells[i]->SetId(i);
904	}
905
906
907	void ViewCellsManager::ExportViewCellsForViz(Exporter *exporter) const
908	{
909	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
910
911	for (it = mViewCells.begin(); it != it_end; ++ it)
912	{
913	if (!mOnlyValidViewCells \|\| (*it)->GetValid())
914	{
915	ExportColor(exporter, *it);
916	ExportViewCellGeometry(exporter, *it,
917	mUseCuttingPlaneForViz ? &mCuttingPlane : NULL);
918	}
919	}
920
921	}
922
923
924	void ViewCellsManager::CreateViewCellMeshes()
925	{
926	// convert to meshes
927	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
928
929	for (it = mViewCells.begin(); it != it_end; ++ it)
930	{
931	if (!(*it)->GetMesh())
932	CreateMesh(*it);
933	}
934	}
935
936
937	bool ViewCellsManager::ExportViewCells(const string filename)
938	{
939	return false;
940	}
941
942
943	void ViewCellsManager::CollectViewCells(const int n)
944	{
945	mNumActiveViewCells = n;
946	mViewCells.clear();
947	CollectViewCells();
948	}
949
950
951
952	/**********************************************************************/
953	/* BspViewCellsManager implementation */
954	/**********************************************************************/
955
956
957	BspViewCellsManager::BspViewCellsManager(BspTree *bspTree):
958	ViewCellsManager(), mBspTree(bspTree)
959	{
960	environment->GetIntValue("BspTree.Construction.samples", mInitialSamples);
961	mBspTree->SetViewCellsManager(this);
962	mBspTree->mViewCellsTree = mViewCellsTree;
963	}
964
965
966	bool BspViewCellsManager::ViewCellsConstructed() const
967	{
968	return mBspTree->GetRoot() != NULL;
969	}
970
971
972	ViewCell BspViewCellsManager::GenerateViewCell(Mesh mesh) const
973	{
974	return new BspViewCell(mesh);
975	}
976
977
978	int BspViewCellsManager::ConstructSubdivision(const ObjectContainer &objects,
979	const VssRayContainer &rays)
980	{
981	// if view cells were already constructed
982	if (ViewCellsConstructed())
983	return 0;
984
985	int sampleContributions = 0;
986
987	// construct view cells using the collected samples
988	RayContainer constructionRays;
989	VssRayContainer savedRays;
990
991	const int limit = min(mInitialSamples, (int)rays.size());
992
993	VssRayContainer::const_iterator it, it_end = rays.end();
994
995	const float prop = (float)limit / ((float)rays.size() + Limits::Small);
996
997	for (it = rays.begin(); it != it_end; ++ it)
998	{
999	if (Random(1.0f) < prop)
1000	constructionRays.push_back(new Ray((it)));
1001	else
1002	savedRays.push_back(*it);
1003	}
1004
1005	if (mViewCells.empty())
1006	{
1007	// no view cells loaded
1008	mBspTree->Construct(objects, constructionRays, &mViewSpaceBox);
1009	// collect final view cells
1010	mBspTree->CollectViewCells(mViewCells);
1011	}
1012	else
1013	{
1014	mBspTree->Construct(mViewCells);
1015	}
1016
1017	// destroy rays created only for construction
1018	CLEAR_CONTAINER(constructionRays);
1019
1020	Debug << mBspTree->GetStatistics() << endl;
1021
1022	//EvaluateViewCellsStats();
1023	Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
1024
1025	// recast rest of the rays
1026	ComputeSampleContributions(savedRays, true, false);
1027
1028
1029	ResetViewCells();
1030
1031	Debug << "\nView cells after " << (int)savedRays.size()
1032	<< " samples:\n" << mViewCellsStats << endl;
1033
1034	if (1) // export initial view cells
1035	{
1036	cout << "exporting initial view cells (=leaves) ... ";
1037	Exporter *exporter = Exporter::GetExporter("view_cells.x3d");
1038
1039	if (exporter)
1040	{
1041
1042	if (0 && mExportRays)
1043	exporter->ExportRays(rays, RgbColor(1, 1, 1));
1044
1045
1046	if (mExportGeometry)
1047	exporter->ExportGeometry(objects);
1048
1049	//exporter->SetWireframe();
1050	exporter->SetFilled();
1051	ExportViewCellsForViz(exporter);
1052
1053
1054	delete exporter;
1055	}
1056	cout << "finished" << endl;
1057	}
1058
1059
1060	return sampleContributions;
1061	}
1062
1063
1064	void BspViewCellsManager::CollectViewCells()
1065	{
1066	// view cells tree constructed
1067	if (!ViewCellsTreeConstructed())
1068	{
1069	mBspTree->CollectViewCells(mViewCells);
1070	}
1071	else
1072	{
1073	// we can use the view cells tree hierarchy to get the right set
1074	mViewCellsTree->CollectBestViewCellSet(mViewCells,
1075	mNumActiveViewCells);
1076	}
1077	}
1078
1079
1080	float BspViewCellsManager::GetProbability(ViewCell *viewCell)
1081	{
1082	// compute view cell area as subsititute for probability
1083	if (1)
1084	return GetVolume(viewCell) / GetViewSpaceBox().GetVolume();
1085	else
1086	return GetArea(viewCell) / GetAccVcArea();
1087	}
1088
1089
1090
1091	int BspViewCellsManager::CastLineSegment(const Vector3 &origin,
1092	const Vector3 &termination,
1093	ViewCellContainer &viewcells)
1094	{
1095	return mBspTree->CastLineSegment(origin, termination, viewcells);
1096	}
1097
1098
1099	int BspViewCellsManager::PostProcess(const ObjectContainer &objects,
1100	const VssRayContainer &rays)
1101	{
1102	if (!ViewCellsConstructed())
1103	{
1104	Debug << "view cells not constructed" << endl;
1105	return 0;
1106	}
1107
1108
1109	// view cells already finished before post processing step (i.e. because they were loaded)
1110	if (mViewCellsFinished)
1111	{
1112	FinalizeViewCells(true);
1113	EvaluateViewCellsStats();
1114
1115	return 0;
1116	}
1117
1118	//-- post processing of bsp view cells
1119
1120	int vcSize = 0;
1121	int pvsSize = 0;
1122
1123	EvaluateViewCellsStats();
1124	Debug << "\noriginal view cell partition:\n" << mViewCellsStats << endl;
1125
1126	mRenderer->RenderScene();
1127	SimulationStatistics ss;
1128	dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
1129
1130	Debug << ss << endl;
1131
1132
1133
1134	//-- merge view cells
1135	int merged;
1136
1137	if (mMergeViewCells)
1138	{
1139	cout << "starting post processing using " << mPostProcessSamples << " samples ... ";
1140	long startTime = GetTime();
1141
1142	VssRayContainer postProcessRays;
1143	GetRaySets(rays, mPostProcessSamples, postProcessRays);
1144
1145	merged = mViewCellsTree->ConstructMergeTree(rays, objects);
1146
1147	//-- stats and visualizations
1148	cout << "finished" << endl;
1149	cout << "merged " << merged << " view cells in "
1150	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl;
1151
1152	Debug << "Postprocessing: Merged " << merged << " view cells in "
1153	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs"
1154	<< "using " << (int)rays.size() << " samples" << endl << endl;
1155	}
1156
1157	// reset view cells and stats
1158	ResetViewCells();
1159	Debug << "\nView cells after merge:\n" << mViewCellsStats << endl;
1160
1161	int savedColorCode = mColorCode;
1162
1163	//BspLeaf::NewMail();
1164	if (1) // export merged view cells
1165	{
1166	mColorCode = 0;
1167
1168	Exporter *exporter = Exporter::GetExporter("merged_view_cells.x3d");
1169
1170
1171	cout << "exporting view cells after merge ... ";
1172
1173	if (exporter)
1174	{
1175	if (mExportGeometry)
1176	exporter->ExportGeometry(objects);
1177
1178	//exporter->SetWireframe();
1179	exporter->SetFilled();
1180	ExportViewCellsForViz(exporter);
1181
1182
1183	delete exporter;
1184	}
1185	cout << "finished" << endl;
1186	}
1187
1188	if (1) // export merged view cells
1189	{
1190	mColorCode = 1;
1191
1192	Exporter *exporter = Exporter::GetExporter("merged_view_cells_pvs.x3d");
1193
1194	cout << "exporting view cells after merge (pvs size) ... ";
1195
1196	if (exporter)
1197	{
1198	//exporter->SetWireframe();
1199
1200	if (mExportGeometry)
1201	exporter->ExportGeometry(objects);
1202
1203	//exporter->SetWireframe();
1204	exporter->SetFilled();
1205	ExportViewCellsForViz(exporter);
1206
1207	delete exporter;
1208	}
1209	cout << "finished" << endl;
1210	}
1211
1212	mColorCode = savedColorCode;
1213
1214	FinalizeViewCells(true);
1215
1216	// write view cells to disc
1217	if (mExportViewCells)
1218	{
1219	char buff[100];
1220	environment->GetStringValue("ViewCells.filename", buff);
1221	string vcFilename(buff);
1222
1223	ExportViewCells(buff);
1224	}
1225
1226	return merged;
1227	}
1228
1229
1230	BspViewCellsManager::~BspViewCellsManager()
1231	{
1232	}
1233
1234
1235	int BspViewCellsManager::GetType() const
1236	{
1237	return BSP;
1238	}
1239
1240
1241	void BspViewCellsManager::Visualize(const ObjectContainer &objects,
1242	const VssRayContainer &sampleRays)
1243	{
1244	if (!ViewCellsConstructed())
1245	return;
1246
1247	int savedColorCode = mColorCode;
1248
1249
1250
1251	if (1) // export final view cells
1252	{
1253	mColorCode = 1;
1254
1255	Exporter *exporter = Exporter::GetExporter("final_view_cells.x3d");
1256
1257	cout << "exporting view cells after merge (pvs size) ... ";
1258
1259	if (exporter)
1260	{
1261	//exporter->SetWireframe();
1262
1263	if (mExportGeometry)
1264	exporter->ExportGeometry(objects);
1265
1266	//exporter->SetWireframe();
1267	exporter->SetFilled();
1268	ExportViewCellsForViz(exporter);
1269
1270	delete exporter;
1271	}
1272	cout << "finished" << endl;
1273	}
1274
1275	mColorCode = savedColorCode;
1276
1277	//-- visualization of the BSP splits
1278	bool exportSplits = false;
1279	environment->GetBoolValue("BspTree.Visualization.exportSplits", exportSplits);
1280
1281	if (exportSplits)
1282	{
1283	cout << "exporting splits ... ";
1284	ExportSplits(objects);
1285	cout << "finished" << endl;
1286	}
1287
1288	// export single view cells
1289	ExportBspPvs(objects);
1290	}
1291
1292
1293	inline bool vc_gt(ViewCell a, ViewCell b)
1294	{
1295	return a->GetPvs().GetSize() > b->GetPvs().GetSize();
1296	}
1297
1298
1299	void BspViewCellsManager::ExportSplits(const ObjectContainer &objects)
1300	{
1301	Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
1302
1303	if (exporter)
1304	{
1305	//exporter->SetFilled();
1306
1307	if (mExportGeometry)
1308	exporter->ExportGeometry(objects);
1309
1310	Material m;
1311	m.mDiffuseColor = RgbColor(1, 0, 0);
1312	exporter->SetForcedMaterial(m);
1313	exporter->SetWireframe();
1314
1315	exporter->ExportBspSplits(*mBspTree, true);
1316
1317	//NOTE: take forced material, else big scenes cannot be viewed
1318	m.mDiffuseColor = RgbColor(0, 1, 0);
1319	exporter->SetForcedMaterial(m);
1320	//exporter->ResetForcedMaterial();
1321
1322	delete exporter;
1323	}
1324	}
1325
1326
1327	void BspViewCellsManager::ExportBspPvs(const ObjectContainer &objects)
1328	{
1329	const int leafOut = 10;
1330
1331	ViewCell::NewMail();
1332
1333	//-- some rays for output
1334	const int raysOut = min((int)mBspRays.size(), mVisualizationSamples);
1335
1336	cout << "visualization using " << mVisualizationSamples << " samples" << endl;
1337	Debug << "\nOutput view cells: " << endl;
1338
1339	// sort view cells to get largest view cells
1340	if (0)
1341	stable_sort(mViewCells.begin(), mViewCells.end(), vc_gt);
1342
1343	int limit = min(leafOut, (int)mViewCells.size());
1344
1345	for (int i = 0; i < limit; ++ i)
1346	{
1347	cout << "creating output for view cell " << i << " ... ";
1348	VssRayContainer vcRays;
1349	Intersectable::NewMail();
1350	ViewCell *vc;
1351
1352	if (0)
1353	vc = mViewCells[i];
1354	else
1355	vc = mViewCells[Random((int)mViewCells.size())];
1356
1357	cout << "creating output for view cell " << i << " ... ";
1358
1359	if(0)
1360	{
1361	// check whether we can add the current ray to the output rays
1362	for (int k = 0; k < raysOut; ++ k)
1363	{
1364	BspRay *ray = mBspRays[k];
1365	for (int j = 0; j < (int)ray->intersections.size(); ++ j)
1366	{
1367	BspLeaf *leaf = ray->intersections[j].mLeaf;
1368	if (vc == leaf->GetViewCell())
1369	vcRays.push_back(ray->vssRay);
1370	}
1371	}
1372	}
1373
1374	//bspLeaves[j]->Mail();
1375	char s[64]; sprintf(s, "bsp-pvs%04d.x3d", i);
1376
1377	Exporter *exporter = Exporter::GetExporter(s);
1378
1379	exporter->SetWireframe();
1380
1381	Material m;//= RandomMaterial();
1382	m.mDiffuseColor = RgbColor(0, 1, 0);
1383	exporter->SetForcedMaterial(m);
1384
1385	ExportViewCellGeometry(exporter, vc);
1386
1387	// export rays piercing this view cell
1388	exporter->ExportRays(vcRays, RgbColor(0, 1, 0));
1389
1390	m.mDiffuseColor = RgbColor(1, 0, 0);
1391	exporter->SetForcedMaterial(m);
1392
1393	ObjectPvsMap::const_iterator it,
1394	it_end = vc->GetPvs().mEntries.end();
1395
1396	exporter->SetFilled();
1397
1398	// output PVS of view cell
1399	for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
1400	{
1401	Intersectable intersect = (it).first;
1402
1403	if (!intersect->Mailed())
1404	{
1405	Material m = RandomMaterial();
1406	exporter->SetForcedMaterial(m);
1407
1408	exporter->ExportIntersectable(intersect);
1409	intersect->Mail();
1410	}
1411	}
1412
1413	DEL_PTR(exporter);
1414	cout << "finished" << endl;
1415	}
1416
1417	Debug << endl;
1418	}
1419
1420
1421	void BspViewCellsManager::ExportColor(Exporter *exporter,
1422	ViewCell *vc) const
1423	{
1424	const bool vcValid = CheckValidity(vc, mMinPvsSize, mMaxPvsSize);
1425
1426	float importance = 0;
1427	static Material m;
1428
1429	switch (mColorCode)
1430	{
1431	case 0: // Random
1432	{
1433	if (vcValid)
1434	{
1435	m.mDiffuseColor.r = 0.5f + RandomValue(0.0f, 0.5f);
1436	m.mDiffuseColor.g = 0.5f + RandomValue(0.0f, 0.5f);
1437	m.mDiffuseColor.b = 0.5f + RandomValue(0.0f, 0.5f);
1438	}
1439	else
1440	{
1441	m.mDiffuseColor.r = 0.0f;
1442	m.mDiffuseColor.g = 1.0f;
1443	m.mDiffuseColor.b = 0.0f;
1444	}
1445
1446	exporter->SetForcedMaterial(m);
1447	return;
1448	}
1449
1450	case 1: // pvs
1451	{
1452	importance = (float)vc->GetPvs().GetSize() /
1453	(float)mViewCellsStats.maxPvs;
1454
1455	}
1456	break;
1457	case 2: // merges
1458	{
1459	int lSize = mViewCellsTree->GetSize(vc);
1460	importance = (float)lSize / (float)mViewCellsStats.maxLeaves;
1461	}
1462	//break;
1463	case 3: // merge tree differene
1464	{
1465	// TODO
1466	//importance = (float)GetMaxTreeDiff(vc) /
1467	// (float)(mVspBspTree->GetStatistics().maxDepth * 2);
1468
1469	}
1470	break;
1471	default:
1472	break;
1473	}
1474
1475	// special color code for invalid view cells
1476	m.mDiffuseColor.r = importance;
1477	m.mDiffuseColor.g = 1.0f - m.mDiffuseColor.r;
1478	m.mDiffuseColor.b = vcValid ? 1.0f : 0.0f;
1479
1480	//Debug << "importance: " << importance << endl;
1481	exporter->SetForcedMaterial(m);
1482	}
1483
1484
1485	void BspViewCellsManager::ExportViewCellGeometry(Exporter *exporter,
1486	ViewCell *vc,
1487	const Plane3 *cuttingPlane) const
1488	{
1489	if (vc->GetMesh())
1490	{
1491	exporter->ExportMesh(vc->GetMesh());
1492	return;
1493	}
1494
1495	BspNodeGeometry geom;
1496	mBspTree->ConstructGeometry(vc, geom);
1497
1498
1499	if (cuttingPlane)
1500	{
1501	BspNodeGeometry front;
1502	BspNodeGeometry back;
1503
1504	geom.SplitGeometry(front,
1505	back,
1506	*cuttingPlane,
1507	mViewSpaceBox,
1508	0.0001f);
1509
1510	if ((int)back.mPolys.size() >= 3)
1511	exporter->ExportPolygons(back.mPolys);
1512	}
1513	else
1514	{
1515
1516	exporter->ExportPolygons(geom.mPolys);
1517	}
1518	}
1519
1520
1521	void BspViewCellsManager::CreateMesh(ViewCell *vc)
1522	{
1523	if (vc->GetMesh())
1524	delete vc->GetMesh();
1525
1526	BspNodeGeometry geom;
1527
1528	mBspTree->ConstructGeometry(vc, geom);
1529
1530	Mesh *mesh = new Mesh();
1531	geom.AddToMesh(*mesh);
1532	vc->SetMesh(mesh);
1533	mMeshContainer.push_back(mesh);
1534	}
1535
1536
1537	void BspViewCellsManager::Finalize(ViewCell *viewCell,
1538	const bool createMesh)
1539	{
1540	CreateMesh(viewCell);
1541
1542	float area = 0;
1543	float volume = 0;
1544
1545	ViewCellContainer leaves;
1546	mViewCellsTree->CollectLeaves(viewCell, leaves);
1547
1548	ViewCellContainer::const_iterator it, it_end = leaves.end();
1549
1550	for (it = leaves.begin(); it != it_end; ++ it)
1551	{
1552	BspNodeGeometry geom;
1553	BspLeaf leaf = dynamic_cast<BspViewCell >(*it)->mLeaf;
1554	mBspTree->ConstructGeometry(leaf, geom);
1555
1556	area += geom.GetArea();
1557	volume += geom.GetVolume();
1558	}
1559
1560	viewCell->SetVolume(volume);
1561	viewCell->SetArea(area);
1562	}
1563
1564
1565	ViewCell *BspViewCellsManager::GetViewCell(const Vector3 &point) const
1566	{
1567	if (!mBspTree)
1568	return NULL;
1569
1570	if (!mViewSpaceBox.IsInside(point))
1571	return NULL;
1572
1573	return mBspTree->GetViewCell(point);
1574	}
1575
1576
1577	void BspViewCellsManager::CollectMergeCandidates(const VssRayContainer &rays,
1578	vector<MergeCandidate> &candidates)
1579	{
1580	cout << "collecting merge candidates ... " << endl;
1581
1582	if (mUseRaysForMerge)
1583	{
1584	mBspTree->CollectMergeCandidates(rays, candidates);
1585	}
1586	else
1587	{
1588	vector<BspLeaf *> leaves;
1589	mBspTree->CollectLeaves(leaves);
1590	mBspTree->CollectMergeCandidates(leaves, candidates);
1591	}
1592
1593	cout << "fininshed collecting candidates" << endl;
1594	}
1595
1596
1597
1598	bool BspViewCellsManager::ExportViewCells(const string filename)
1599	{
1600	cout << "exporting view cells to xml ... ";
1601	std::ofstream stream;
1602
1603	// for output we need unique ids for each view cell
1604	CreateUniqueViewCellIds();
1605
1606
1607	stream.open(filename.c_str());
1608	stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"<<endl;
1609	stream << "<Visibility_Solution>" << endl;
1610
1611	//-- the view space bounding box
1612	stream << "<ViewSpaceBox"
1613	<< " min=\"" << mViewSpaceBox.Min().x << " " << mViewSpaceBox.Min().y << " " << mViewSpaceBox.Min().z << "\""
1614	<< " max=\"" << mViewSpaceBox.Max().x << " " << mViewSpaceBox.Max().y << " " << mViewSpaceBox.Max().z << "\" />" << endl;
1615
1616	//-- the type of the view cells hierarchy
1617	//stream << "<Hierarchy name=\"bspTree\" />" << endl;
1618	stream << "<Hierarchy name=\"vspBspTree\" />" << endl; // write vsp bsp here because can use same tree and is bug free
1619	//-- load the view cells itself, i.e., the ids and the pvs
1620	stream << "<ViewCells>" << endl;
1621
1622	#if 0
1623
1624	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
1625
1626	for (it = mViewCells.begin(); it != it_end; ++ it)
1627	ExportViewCell(*it, stream);
1628	#else
1629	mViewCellsTree->Export(stream);
1630	#endif
1631
1632	stream << "</ViewCells>" << endl;
1633
1634	//-- load the hierarchy
1635	stream << "<Hierarchy>" << endl;
1636	mBspTree->Export(stream);
1637	stream << endl << "</Hierarchy>" << endl;
1638
1639	stream << "</Visibility_Solution>" << endl;
1640	stream.close();
1641
1642	cout << "finished" << endl;
1643
1644	return true;
1645	}
1646
1647
1648	void BspViewCellsManager::AddCurrentViewCellsToHierarchy()
1649	{
1650	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
1651	for (it = mViewCells.begin(); it != it_end; ++ it)
1652	{
1653	ViewCell vc = it;
1654	ViewCellContainer leaves;
1655	mViewCellsTree->CollectLeaves(vc, leaves);
1656
1657	ViewCellContainer::const_iterator lit, lit_end = leaves.end();
1658
1659	for (lit = leaves.begin(); lit != lit_end; ++ lit)
1660	{
1661	BspViewCell bspVc = dynamic_cast<BspViewCell >(*lit);
1662	bspVc->mLeaf->SetViewCell(vc);
1663	}
1664	}
1665	}
1666
1667
1668	void BspViewCellsManager::CreateMergeHierarchy()
1669	{
1670	TraversalQueue tQueue;
1671
1672	tQueue.push(TraversalData(mBspTree->GetRoot(), NULL));
1673
1674	while (!tQueue.empty())
1675	{
1676	TraversalData tData = tQueue.top();
1677	tQueue.pop();
1678
1679	if (tData.mNode->IsLeaf())
1680	{
1681	ViewCell viewCell = dynamic_cast<BspLeaf >(tData.mNode)->GetViewCell();
1682	viewCell->SetMergeCost((float)tData.mNode->mTimeStamp);
1683
1684	if (tData.mParentViewCell)
1685	{
1686	tData.mParentViewCell->SetupChildLink(viewCell);
1687	// probagate up pvs
1688	mViewCellsTree->PropagateUpPvs(viewCell);
1689	}
1690	}
1691	else
1692	{
1693	BspInterior interior = dynamic_cast<BspInterior >(tData.mNode);
1694	ViewCellInterior *viewCellInterior = new ViewCellInterior();
1695	viewCellInterior->SetMergeCost((float)tData.mNode->mTimeStamp);
1696
1697
1698	tQueue.push(TraversalData(interior->GetBack(), viewCellInterior));
1699	tQueue.push(TraversalData(interior->GetFront(), viewCellInterior));
1700
1701	if (tData.mParentViewCell)
1702	tData.mParentViewCell->SetupChildLink(viewCellInterior);
1703	}
1704	}
1705	}
1706
1707	/************************************************************************/
1708	/* KdViewCellsManager implementation */
1709	/************************************************************************/
1710
1711
1712
1713	KdViewCellsManager::KdViewCellsManager(KdTree *kdTree):
1714	ViewCellsManager(), mKdTree(kdTree), mKdPvsDepth(100)
1715	{
1716	}
1717
1718
1719	float KdViewCellsManager::GetProbability(ViewCell *viewCell)
1720	{
1721	// compute view cell area / volume as subsititute for probability
1722	if (0)
1723	return GetArea(viewCell) / GetViewSpaceBox().SurfaceArea();
1724	else
1725	return GetVolume(viewCell) / GetViewSpaceBox().GetVolume();
1726	}
1727
1728
1729
1730
1731	void KdViewCellsManager::CollectViewCells()
1732	{
1733	//mKdTree->CollectViewCells(mViewCells); TODO
1734	}
1735
1736
1737	int KdViewCellsManager::ConstructSubdivision(const ObjectContainer &objects,
1738	const VssRayContainer &rays)
1739	{
1740	// if view cells already constructed
1741	if (ViewCellsConstructed())
1742	return 0;
1743
1744	mKdTree->Construct();
1745
1746	mTotalAreaValid = false;
1747	// create the view cells
1748	mKdTree->CreateAndCollectViewCells(mViewCells);
1749
1750	// cast rays
1751	ComputeSampleContributions(rays, true, false);
1752
1753	EvaluateViewCellsStats();
1754	Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
1755
1756	return 0;
1757	}
1758
1759
1760	bool KdViewCellsManager::ViewCellsConstructed() const
1761	{
1762	return mKdTree->GetRoot() != NULL;
1763	}
1764
1765	int KdViewCellsManager::PostProcess(const ObjectContainer &objects,
1766	const VssRayContainer &rays)
1767	{
1768	return 0;
1769	}
1770
1771	void KdViewCellsManager::Visualize(const ObjectContainer &objects,
1772	const VssRayContainer &sampleRays)
1773	{
1774	if (!ViewCellsConstructed())
1775	return;
1776
1777	// using view cells instead of the kd PVS of objects
1778	const bool useViewCells = true;
1779	bool exportRays = false;
1780
1781	int limit = min(mVisualizationSamples, (int)sampleRays.size());
1782	const int pvsOut = min((int)objects.size(), 10);
1783	VssRayContainer *rays = new VssRayContainer[pvsOut];
1784
1785	if (useViewCells)
1786	{
1787	const int leafOut = 10;
1788
1789	ViewCell::NewMail();
1790
1791	//-- some rays for output
1792	const int raysOut = min((int)sampleRays.size(), mVisualizationSamples);
1793	Debug << "visualization using " << raysOut << " samples" << endl;
1794
1795	//-- some random view cells and rays for output
1796	vector<KdLeaf *> kdLeaves;
1797
1798	for (int i = 0; i < leafOut; ++ i)
1799	kdLeaves.push_back(dynamic_cast<KdLeaf *>(mKdTree->GetRandomLeaf()));
1800
1801	for (int i = 0; i < kdLeaves.size(); ++ i)
1802	{
1803	KdLeaf *leaf = kdLeaves[i];
1804	RayContainer vcRays;
1805
1806	cout << "creating output for view cell " << i << " ... ";
1807	#if 0
1808	// check whether we can add the current ray to the output rays
1809	for (int k = 0; k < raysOut; ++ k)
1810	{
1811	Ray *ray = sampleRays[k];
1812
1813	for (int j = 0; j < (int)ray->bspIntersections.size(); ++ j)
1814	{
1815	BspLeaf *leaf2 = ray->bspIntersections[j].mLeaf;
1816
1817	if (leaf->GetViewCell() == leaf2->GetViewCell())
1818	{
1819	vcRays.push_back(ray);
1820	}
1821	}
1822	}
1823	#endif
1824	Intersectable::NewMail();
1825
1826	ViewCell *vc = leaf->mViewCell;
1827
1828	//bspLeaves[j]->Mail();
1829	char s[64]; sprintf(s, "kd-pvs%04d.x3d", i);
1830
1831	Exporter *exporter = Exporter::GetExporter(s);
1832	exporter->SetFilled();
1833
1834	exporter->SetWireframe();
1835	//exporter->SetFilled();
1836
1837	Material m;//= RandomMaterial();
1838	m.mDiffuseColor = RgbColor(1, 1, 0);
1839	exporter->SetForcedMaterial(m);
1840
1841	AxisAlignedBox3 box = mKdTree->GetBox(leaf);
1842	exporter->ExportBox(box);
1843
1844	// export rays piercing this view cell
1845	exporter->ExportRays(vcRays, 1000, RgbColor(0, 1, 0));
1846
1847	m.mDiffuseColor = RgbColor(1, 0, 0);
1848	exporter->SetForcedMaterial(m);
1849
1850	// exporter->SetWireframe();
1851	exporter->SetFilled();
1852
1853	ObjectPvsMap::iterator it, it_end = vc->GetPvs().mEntries.end();
1854	// output PVS of view cell
1855	for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
1856	{
1857	Intersectable intersect = (it).first;
1858	if (!intersect->Mailed())
1859	{
1860	exporter->ExportIntersectable(intersect);
1861	intersect->Mail();
1862	}
1863	}
1864
1865	DEL_PTR(exporter);
1866	cout << "finished" << endl;
1867	}
1868
1869	DEL_PTR(rays);
1870	}
1871	else // using kd PVS of objects
1872	{
1873	for (int i = 0; i < limit; ++ i)
1874	{
1875	VssRay *ray = sampleRays[i];
1876
1877	// check whether we can add this to the rays
1878	for (int j = 0; j < pvsOut; j++)
1879	{
1880	if (objects[j] == ray->mTerminationObject)
1881	{
1882	rays[j].push_back(ray);
1883	}
1884	}
1885	}
1886
1887	if (exportRays)
1888	{
1889	Exporter *exporter = NULL;
1890	exporter = Exporter::GetExporter("sample-rays.x3d");
1891	exporter->SetWireframe();
1892	exporter->ExportKdTree(*mKdTree);
1893
1894	for (i=0; i < pvsOut; i++)
1895	exporter->ExportRays(rays[i], RgbColor(1, 0, 0));
1896
1897	exporter->SetFilled();
1898
1899	delete exporter;
1900	}
1901
1902	for (int k=0; k < pvsOut; k++)
1903	{
1904	Intersectable *object = objects[k];
1905	char s[64];
1906	sprintf(s, "sample-pvs%04d.x3d", k);
1907
1908	Exporter *exporter = Exporter::GetExporter(s);
1909	exporter->SetWireframe();
1910
1911	KdPvsMap::iterator i = object->mKdPvs.mEntries.begin();
1912	Intersectable::NewMail();
1913
1914	// avoid adding the object to the list
1915	object->Mail();
1916	ObjectContainer visibleObjects;
1917
1918	for (; i != object->mKdPvs.mEntries.end(); i++)
1919	{
1920	KdNode node = (i).first;
1921	exporter->ExportBox(mKdTree->GetBox(node));
1922
1923	mKdTree->CollectObjects(node, visibleObjects);
1924	}
1925
1926	exporter->ExportRays(rays[k], RgbColor(0, 1, 0));
1927	exporter->SetFilled();
1928
1929	for (int j = 0; j < visibleObjects.size(); j++)
1930	exporter->ExportIntersectable(visibleObjects[j]);
1931
1932	Material m;
1933	m.mDiffuseColor = RgbColor(1, 0, 0);
1934	exporter->SetForcedMaterial(m);
1935	exporter->ExportIntersectable(object);
1936
1937	delete exporter;
1938	}
1939	}
1940	}
1941
1942
1943	void KdViewCellsManager::ExportColor(Exporter *exporter,
1944	ViewCell *vc) const
1945	{
1946	// TODO
1947	}
1948
1949	ViewCell KdViewCellsManager::GenerateViewCell(Mesh mesh) const
1950	{
1951	return new KdViewCell(mesh);
1952	}
1953
1954
1955	void KdViewCellsManager::ExportViewCellGeometry(Exporter *exporter,
1956	ViewCell *vc,
1957	const Plane3 *cuttingPlane) const
1958	{
1959	ViewCellContainer leaves;
1960
1961	mViewCellsTree->CollectLeaves(vc, leaves);
1962	ViewCellContainer::const_iterator it, it_end = leaves.end();
1963
1964	for (it = leaves.begin(); it != it_end; ++ it)
1965	{
1966	KdViewCell kdVc = dynamic_cast<KdViewCell >(*it);
1967
1968	exporter->ExportBox(mKdTree->GetBox(kdVc->mLeaf));
1969	}
1970	}
1971
1972
1973	int KdViewCellsManager::GetType() const
1974	{
1975	return ViewCellsManager::KD;
1976	}
1977
1978
1979
1980	KdNode KdViewCellsManager::GetNodeForPvs(KdLeaf leaf)
1981	{
1982	KdNode *node = leaf;
1983
1984	while (node->mParent && node->mDepth > mKdPvsDepth)
1985	node = node->mParent;
1986	return node;
1987	}
1988
1989	int KdViewCellsManager::CastLineSegment(const Vector3 &origin,
1990	const Vector3 &termination,
1991	ViewCellContainer &viewcells)
1992	{
1993	return mKdTree->CastLineSegment(origin, termination, viewcells);
1994	}
1995
1996
1997	void KdViewCellsManager::CreateMesh(ViewCell *vc)
1998	{
1999	// TODO
2000	}
2001
2002
2003
2004	void KdViewCellsManager::CollectMergeCandidates(const VssRayContainer &rays,
2005	vector<MergeCandidate> &candidates)
2006	{
2007	// TODO
2008	}
2009
2010
2011	/**********************************************************************/
2012	/* VspKdViewCellsManager implementation */
2013	/**********************************************************************/
2014
2015
2016	VspKdViewCellsManager::VspKdViewCellsManager(VspKdTree *vspKdTree):
2017	ViewCellsManager(), mVspKdTree(vspKdTree)
2018	{
2019	environment->GetIntValue("VspKdTree.Construction.samples", mInitialSamples);
2020	mVspKdTree->SetViewCellsManager(this);
2021	}
2022
2023	float VspKdViewCellsManager::GetProbability(ViewCell *viewCell)
2024	{
2025	// compute view cell area / volume as subsititute for probability
2026	if (0)
2027	return GetArea(viewCell) / GetViewSpaceBox().SurfaceArea();
2028	else
2029	return GetVolume(viewCell) / GetViewSpaceBox().GetVolume();
2030	}
2031
2032
2033
2034
2035	void VspKdViewCellsManager::CollectViewCells()
2036	{
2037	mVspKdTree->CollectViewCells(mViewCells);
2038	}
2039
2040
2041	int VspKdViewCellsManager::ConstructSubdivision(const ObjectContainer &objects,
2042	const VssRayContainer &rays)
2043	{
2044	// if view cells already constructed
2045	if (ViewCellsConstructed())
2046	return 0;
2047
2048	VssRayContainer constructionRays;
2049	VssRayContainer savedRays;
2050
2051	GetRaySets(rays,
2052	mInitialSamples,
2053	constructionRays,
2054	&savedRays);
2055
2056	Debug << "constructing vsp kd tree using "
2057	<< (int)constructionRays.size() << " samples" << endl;
2058
2059	mVspKdTree->Construct(constructionRays, &mViewSpaceBox);
2060	Debug << mVspKdTree->GetStatistics() << endl;
2061
2062	// export leaf building blocks
2063	ExportLeaves(objects, rays);
2064
2065	// finally merge kd leaf building blocks to view cells
2066	const int merged = mVspKdTree->MergeViewCells(rays);
2067
2068	// collapse siblings belonging to the same view cell
2069	mVspKdTree->RefineViewCells(rays);
2070
2071	// collapse siblings belonging to the same view cell
2072	mVspKdTree->CollapseTree();
2073
2074	// evaluale view cell stats
2075	ResetViewCells();
2076
2077	Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
2078
2079	long startTime = GetTime();
2080	// recast rest of rays
2081	ComputeSampleContributions(savedRays, true, false);
2082
2083	Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
2084	<< " secs" << endl;
2085
2086	return merged;
2087	}
2088
2089	bool VspKdViewCellsManager::ViewCellsConstructed() const
2090	{
2091	return mVspKdTree->GetRoot() != NULL;
2092	}
2093
2094
2095	ViewCell VspKdViewCellsManager::GenerateViewCell(Mesh mesh) const
2096	{
2097	return new VspKdViewCell(mesh);
2098	}
2099
2100	int VspKdViewCellsManager::PostProcess(const ObjectContainer &objects,
2101	const VssRayContainer &rays)
2102	{
2103	if (!ViewCellsConstructed())
2104	return 0;
2105
2106	// recalculate stats
2107	EvaluateViewCellsStats();
2108
2109	return 0;
2110	}
2111
2112
2113	void VspKdViewCellsManager::ExportLeaves(const ObjectContainer &objects,
2114	const VssRayContainer &sampleRays)
2115	{
2116	if (!ViewCellsConstructed())
2117	return;
2118
2119	//-- export leaf building blocks
2120	Exporter *exporter = Exporter::GetExporter("vspkdtree.x3d");
2121	if (!exporter)
2122	return;
2123
2124	if (mExportGeometry)
2125	exporter->ExportGeometry(objects);
2126
2127	//exporter->SetWireframe();
2128	//exporter->ExportVspKdTree(*mVspKdTree, mVspKdTree->GetStatistics().maxPvsSize);
2129	exporter->ExportVspKdTree(*mVspKdTree);
2130
2131	if (mExportRays)
2132	{
2133	const float prob = (float)mVisualizationSamples
2134	/ ((float)sampleRays.size() + Limits::Small);
2135
2136	exporter->SetWireframe();
2137
2138	//-- collect uniformly distributed rays
2139	VssRayContainer rays;
2140
2141	for (int i = 0; i < sampleRays.size(); ++ i)
2142	{
2143	if (RandomValue(0,1) < prob)
2144	rays.push_back(sampleRays[i]);
2145	}
2146	exporter->ExportRays(rays, RgbColor(1, 0, 0));
2147	}
2148
2149	delete exporter;
2150	}
2151
2152	void VspKdViewCellsManager::Visualize(const ObjectContainer &objects,
2153	const VssRayContainer &sampleRays)
2154	{
2155	if (!ViewCellsConstructed())
2156	return;
2157
2158	//-- export single view cells
2159	for (int i = 0; i < 10; ++ i)
2160	{
2161	char s[64];
2162	sprintf(s, "vsp_viewcell%04d.x3d", i);
2163	Exporter *exporter = Exporter::GetExporter(s);
2164	const int idx =
2165	(int)RandomValue(0.0, (Real)((int)mViewCells.size() - 1));
2166
2167	VspKdViewCell vc = dynamic_cast<VspKdViewCell >(mViewCells[idx]);
2168
2169	//-- export geometry
2170	Material m;
2171	m.mDiffuseColor = RgbColor(0, 1, 1);
2172
2173	exporter->SetForcedMaterial(m);
2174	exporter->SetWireframe();
2175
2176	ExportViewCellGeometry(exporter, vc);
2177
2178	//-- export stored rays
2179
2180	if (mExportRays)
2181	{
2182	ViewCellContainer leaves;
2183	mViewCellsTree->CollectLeaves(vc, leaves);
2184
2185	ViewCellContainer::const_iterator it,
2186	it_end = leaves.end();
2187
2188	for (it = leaves.begin(); it != it_end; ++ it)
2189	{
2190	VspKdViewCell vspKdVc = dynamic_cast<VspKdViewCell >(*it);
2191	VspKdLeaf *leaf = vspKdVc->mLeaf;
2192	AxisAlignedBox3 box = mVspKdTree->GetBBox(leaf);
2193
2194	VssRayContainer vssRays;
2195
2196	VssRayContainer castRays;
2197	VssRayContainer initRays;
2198
2199	leaf->GetRays(vssRays);
2200
2201	VssRayContainer::const_iterator it, it_end = vssRays.end();
2202	const float prop = 200.0f / (float)vssRays.size();
2203
2204	for (it = vssRays.begin(); it != it_end; ++ it)
2205	{
2206	if (Random(1) < prop)
2207	if ((*it)->mTerminationObject == NULL)
2208	castRays.push_back(*it);
2209	else
2210	initRays.push_back(*it);
2211	}
2212
2213	exporter->ExportRays(castRays, RgbColor(1, 0, 0));
2214	exporter->ExportRays(initRays, RgbColor(0, 1, 0));
2215	}
2216	}
2217
2218	//-- output PVS of view cell
2219	m.mDiffuseColor = RgbColor(1, 0, 0);
2220	exporter->SetForcedMaterial(m);
2221
2222	Intersectable::NewMail();
2223
2224	ObjectPvsMap::const_iterator it,
2225	it_end = vc->GetPvs().mEntries.end();
2226
2227	exporter->SetFilled();
2228
2229	for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
2230	{
2231	Intersectable intersect = (it).first;
2232
2233	if (!intersect->Mailed())
2234	{
2235	Material m = RandomMaterial();
2236	exporter->SetForcedMaterial(m);
2237
2238	exporter->ExportIntersectable(intersect);
2239	intersect->Mail();
2240	}
2241	}
2242
2243	delete exporter;
2244	}
2245
2246	//-- export final view cells
2247	Exporter *exporter = Exporter::GetExporter("vspkdtree_merged.x3d");
2248
2249	//if (exportGeometry) exporter->SetWireframe();
2250	//else exporter->SetFilled();
2251
2252	ExportViewCellsForViz(exporter);
2253
2254	if (mExportGeometry)
2255	{
2256	exporter->SetFilled();
2257	exporter->ExportGeometry(objects);
2258	}
2259
2260	if (mExportRays)
2261	{
2262	const float prob = (float)mVisualizationSamples
2263	/ ((float)sampleRays.size() + Limits::Small);
2264
2265	exporter->SetWireframe();
2266
2267	VssRayContainer rays;
2268
2269	for (int i = 0; i < sampleRays.size(); ++ i)
2270	{
2271	if (RandomValue(0,1) < prob)
2272	rays.push_back(sampleRays[i]);
2273	}
2274	exporter->ExportRays(rays, RgbColor(1, 0, 0));
2275	}
2276
2277	delete exporter;
2278	}
2279
2280	int VspKdViewCellsManager::GetType() const
2281	{
2282	return VSP_KD;
2283	}
2284
2285
2286	int VspKdViewCellsManager::CastLineSegment(const Vector3 &origin,
2287	const Vector3 &termination,
2288	ViewCellContainer &viewcells)
2289	{
2290	return mVspKdTree->CastLineSegment(origin, termination, viewcells);
2291	}
2292
2293
2294	void VspKdViewCellsManager::ExportColor(Exporter *exporter,
2295	ViewCell *vc) const
2296	{
2297	if (mColorCode == 0) // Random color
2298	return;
2299
2300	float importance = 0;
2301
2302	switch (mColorCode)
2303	{
2304	case 1: // pvs
2305	{
2306	importance = (float)vc->GetPvs().GetSize() /
2307	(float)mViewCellsStats.maxPvs;
2308	}
2309	break;
2310	case 2: // merged leaves
2311	{
2312	int lSize = mViewCellsTree->GetSize(vc);
2313	importance = (float)lSize /
2314	(float)mViewCellsStats.maxLeaves;
2315	}
2316	break;
2317	case 3: // merged tree depth difference
2318	{
2319	//importance = (float)GetMaxTreeDiff(vc) /
2320	// (float)(mVspBspTree->GetStatistics().maxDepth * 2);
2321	}
2322	break;
2323	default:
2324	break;
2325	}
2326
2327	Material m;
2328	m.mDiffuseColor.b = 1.0f;
2329	m.mDiffuseColor.r = importance;
2330	m.mDiffuseColor.g = 1.0f - m.mDiffuseColor.r;
2331	//Debug << "importance: " << importance << endl;
2332	exporter->SetForcedMaterial(m);
2333	}
2334
2335
2336	void VspKdViewCellsManager::ExportViewCellGeometry(Exporter *exporter,
2337	ViewCell *vc,
2338	const Plane3 *cuttingPlane) const
2339	{
2340	VspKdViewCell kdVc = dynamic_cast<VspKdViewCell >(vc);
2341
2342	Mesh m;
2343
2344	ViewCellContainer leaves;
2345	mViewCellsTree->CollectLeaves(vc, leaves);
2346
2347	ViewCellContainer::const_iterator it, it_end = leaves.end();
2348
2349	for (it = leaves.begin(); it != it_end; ++ it)
2350	{
2351	VspKdLeaf l = dynamic_cast<VspKdViewCell >(*it)->mLeaf;
2352	mVspKdTree->GetBBox(l).AddBoxToMesh(&m);
2353	}
2354
2355	exporter->ExportMesh(&m);
2356	}
2357
2358
2359	void VspKdViewCellsManager::CreateMesh(ViewCell *vc)
2360	{
2361	//TODO
2362	}
2363
2364
2365	void VspKdViewCellsManager::CollectMergeCandidates(const VssRayContainer &rays,
2366	vector<MergeCandidate> &candidates)
2367	{
2368	// TODO
2369	}
2370
2371
2372	/**************************************************************************/
2373	/* VspBspViewCellsManager implementation */
2374	/**************************************************************************/
2375
2376
2377	VspBspViewCellsManager::VspBspViewCellsManager(VspBspTree *vspBspTree):
2378	ViewCellsManager(), mVspBspTree(vspBspTree)
2379	{
2380	environment->GetIntValue("VspBspTree.Construction.samples", mInitialSamples);
2381	mVspBspTree->SetViewCellsManager(this);
2382	mVspBspTree->mViewCellsTree = mViewCellsTree;
2383	}
2384
2385
2386	VspBspViewCellsManager::~VspBspViewCellsManager()
2387	{
2388	}
2389
2390
2391	float VspBspViewCellsManager::GetProbability(ViewCell *viewCell)
2392	{
2393	if (0 && mVspBspTree->mUseAreaForPvs)
2394	return GetArea(viewCell) / GetAccVcArea();
2395	else
2396	return GetVolume(viewCell) / mViewSpaceBox.GetVolume();
2397	}
2398
2399
2400	void VspBspViewCellsManager::CollectViewCells()
2401	{
2402	// view cells tree constructed
2403	if (!ViewCellsTreeConstructed())
2404	{
2405	mVspBspTree->CollectViewCells(mViewCells, false);
2406	}
2407	else
2408	{
2409	// we can use the view cells tree hierarchy to get the right set
2410	mViewCellsTree->CollectBestViewCellSet(mViewCells, mNumActiveViewCells);
2411	}
2412
2413	}
2414
2415
2416
2417	bool VspBspViewCellsManager::ViewCellsConstructed() const
2418	{
2419	return mVspBspTree->GetRoot() != NULL;
2420	}
2421
2422
2423	ViewCell VspBspViewCellsManager::GenerateViewCell(Mesh mesh) const
2424	{
2425	return new BspViewCell(mesh);
2426	}
2427
2428
2429	/void VspBspViewCellsManager::CollectNodes(ViewCell vc, vector<BspNode *>nodes)
2430	{
2431	void ViewCellsTree::CollectLeaves(ViewCell vc, vector<BspNode > &nodes) const
2432
2433	if (vc->IsLeaf())
2434	{
2435	BspViewCell bvc = dynamic_cast<BspViewCell >(vc);
2436	nodes->push_back(bvc->mLeaf);
2437	}
2438	else
2439	{
2440	ViewCellContainer::const_iterator it, it_end = interior->mChildren.end();
2441
2442	for (it = interior->mChildren.begin; it != it_end; ++ it)
2443	{
2444	vector<BspNode *> mynodes;
2445	CollectNodes(*it, mynodes);
2446
2447	if (mynodes[0]->GetParent() && (mynodes[0]->GetParent() == mynodes[1]->GetParent()))
2448	{
2449	nodes.push_back(nodes[0]->GetParent());
2450	}
2451
2452	}
2453	}
2454	}*/
2455
2456
2457	int VspBspViewCellsManager::ConstructSubdivision(const ObjectContainer &objects,
2458	const VssRayContainer &rays)
2459	{
2460	// if view cells were already constructed
2461	if (ViewCellsConstructed())
2462	return 0;
2463
2464	Debug << "Constructing bsp view cells" << endl;
2465
2466	int sampleContributions = 0;
2467
2468	VssRayContainer sampleRays;
2469
2470	int limit = min (mInitialSamples, (int)rays.size());
2471
2472	VssRayContainer constructionRays;
2473	VssRayContainer savedRays;
2474
2475	Debug << "samples used for subdivision: " << mInitialSamples
2476	<< " rays: " << (int)rays.size() << endl;
2477
2478	GetRaySets(rays, mInitialSamples, constructionRays, &savedRays);
2479
2480	Debug << "initial rays: " << (int)constructionRays.size() << endl;
2481	Debug << "saved rays: " << (int)savedRays.size() << endl;
2482
2483	mMaxPvsSize = (int)(mMaxPvsRatio * (float)objects.size());
2484
2485	mVspBspTree->Construct(constructionRays, &mViewSpaceBox);
2486
2487	Debug << mVspBspTree->GetStatistics() << endl;
2488
2489	// collapse invalid regions
2490	cout << "collapsing invalid tree regions ... ";
2491	long startTime = GetTime();
2492	int collapsedLeaves = mVspBspTree->CollapseTree();
2493	Debug << "collapsed in " << TimeDiff(startTime, GetTime()) * 1e-3
2494	<< " seconds" << endl;
2495
2496	cout << "finished" << endl;
2497
2498	cout << "reseting view cell stats ... ";
2499	ResetViewCells();
2500	cout << "finished" << endl;
2501
2502	Debug << "\nView cells after construction:\n" << mViewCellsStats << endl;
2503
2504	if (1) // export initial view cells
2505	{
2506	cout << "exporting initial view cells (=leaves) ... ";
2507	Exporter *exporter = Exporter::GetExporter("view_cells.x3d");
2508
2509	if (exporter)
2510	{
2511	if (0 && mExportRays)
2512	exporter->ExportRays(rays, RgbColor(1, 1, 1));
2513
2514	if (mExportGeometry)
2515	exporter->ExportGeometry(objects);
2516
2517	//exporter->SetWireframe();
2518	exporter->SetFilled();
2519	ExportViewCellsForViz(exporter);
2520
2521	delete exporter;
2522	}
2523	cout << "finished" << endl;
2524	}
2525
2526	startTime = GetTime();
2527
2528	// reset view cells and stats
2529	ResetViewCells();
2530
2531	cout << "Computing remaining ray contributions ... ";
2532
2533	// recast rest of rays
2534	if (SAMPLE_AFTER_SUBDIVISION)
2535	ComputeSampleContributions(savedRays, true, false);
2536	cout << "finished" << endl;
2537
2538	Debug << "Computed remaining ray contribution in " << TimeDiff(startTime, GetTime()) * 1e-3
2539	<< " secs" << endl;
2540
2541	cout << "construction finished" << endl;
2542
2543	return sampleContributions;
2544	}
2545
2546
2547	void VspBspViewCellsManager::MergeViewCells(const VssRayContainer &rays,
2548	const ObjectContainer &objects)
2549	{
2550	//-- post processing of bsp view cells
2551	int vcSize = 0;
2552	int pvsSize = 0;
2553
2554	mRenderer->RenderScene();
2555	SimulationStatistics ss;
2556	dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
2557	Debug << ss << endl;
2558
2559	//-- merge or subdivide view cells
2560	int merged = 0;
2561	if (mMergeViewCells)
2562	{
2563	cout << "starting merge using " << mPostProcessSamples << " samples ... " << endl;
2564	long startTime = GetTime();
2565
2566
2567	// TODO: should be done BEFORE the ray casting
2568	merged = mViewCellsTree->ConstructMergeTree(rays, objects);
2569
2570	//-- stats and visualizations
2571	cout << "finished merging" << endl;
2572	cout << "merged " << merged << " view cells in "
2573	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl;
2574
2575	Debug << "Postprocessing: Merged " << merged << " view cells in "
2576	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl << endl;
2577	}
2578
2579	int savedColorCode = mColorCode;
2580
2581	//BspLeaf::NewMail();
2582	if (1) // export merged view cells
2583	{
2584	mColorCode = 0;
2585	cout << "reseting view cells ... ";
2586	ResetViewCells();
2587
2588	cout << "finished" << endl;
2589
2590	Exporter *exporter = Exporter::GetExporter("merged_view_cells.x3d");
2591	Debug << "\nView cells after merge:\n" << mViewCellsStats << endl;
2592
2593	cout << "exporting view cells after merge ... ";
2594
2595	if (exporter)
2596	{
2597	if (0)
2598	exporter->SetWireframe();
2599	else
2600	exporter->SetFilled();
2601
2602	ExportViewCellsForViz(exporter);
2603
2604	if (mExportGeometry)
2605	{
2606	Material m;
2607	m.mDiffuseColor = RgbColor(0, 1, 0);
2608	exporter->SetForcedMaterial(m);
2609	exporter->SetFilled();
2610
2611	exporter->ExportGeometry(objects);
2612	}
2613
2614	delete exporter;
2615	}
2616	cout << "finished" << endl;
2617	}
2618
2619	if (1) // export merged view cells
2620	{
2621	mColorCode = 1;
2622
2623	Exporter *exporter = Exporter::GetExporter("merged_view_cells_pvs.x3d");
2624
2625	cout << "exporting view cells after merge (pvs size) ... ";
2626
2627	if (exporter)
2628	{
2629	if (0)
2630	exporter->SetWireframe();
2631	else
2632	exporter->SetFilled();
2633
2634	ExportViewCellsForViz(exporter);
2635
2636	if (mExportGeometry)
2637	{
2638	Material m;
2639	m.mDiffuseColor = RgbColor(0, 1, 0);
2640	exporter->SetForcedMaterial(m);
2641	exporter->SetFilled();
2642
2643	exporter->ExportGeometry(objects);
2644	}
2645
2646	delete exporter;
2647	}
2648	cout << "finished" << endl;
2649	}
2650
2651	mColorCode = savedColorCode;
2652
2653	}
2654
2655
2656	bool VspBspViewCellsManager::EqualToSpatialNode(ViewCell *viewCell) const
2657	{
2658	return GetSpatialNode(viewCell) != NULL;
2659	}
2660
2661
2662	BspNode VspBspViewCellsManager::GetSpatialNode(ViewCell viewCell) const
2663	{
2664	if (!viewCell->IsLeaf())
2665	{
2666	BspViewCell bspVc = dynamic_cast<BspViewCell >(viewCell);
2667
2668	return bspVc->mLeaf;
2669	}
2670	else
2671	{
2672	ViewCellInterior interior = dynamic_cast<ViewCellInterior >(viewCell);
2673
2674	// cannot be node of binary tree
2675	if (interior->mChildren.size() != 2)
2676	return NULL;
2677
2678	ViewCell *left = interior->mChildren[0];
2679	ViewCell *right = interior->mChildren[1];
2680
2681	BspNode *leftNode = GetSpatialNode(left);
2682	BspNode *rightNode = GetSpatialNode(right);
2683
2684	if (leftNode && rightNode && leftNode->IsSibling(rightNode))
2685	{
2686	return leftNode->GetParent();
2687	}
2688	}
2689
2690	return NULL;
2691	}
2692
2693
2694	void VspBspViewCellsManager::RefineViewCells(const VssRayContainer &rays,
2695	const ObjectContainer &objects)
2696	{
2697	Debug << "render time before refine:" << endl;
2698	mRenderer->RenderScene();
2699	SimulationStatistics ss;
2700	dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
2701	Debug << ss << endl;
2702
2703	cout << "Refining the merged view cells ... ";
2704	long startTime = GetTime();
2705
2706	// refining the merged view cells
2707	const int refined = mViewCellsTree->RefineViewCells(rays, objects);
2708
2709	//-- stats and visualizations
2710	cout << "finished" << endl;
2711	cout << "refined " << refined << " view cells in "
2712	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl;
2713
2714	Debug << "Postprocessing: refined " << refined << " view cells in "
2715	<< TimeDiff(startTime, GetTime()) *1e-3 << " secs" << endl << endl;
2716	}
2717
2718
2719	int VspBspViewCellsManager::PostProcess(const ObjectContainer &objects,
2720	const VssRayContainer &rays)
2721	{
2722	if (!ViewCellsConstructed())
2723	{
2724	Debug << "postprocess error: no view cells constructed" << endl;
2725	return 0;
2726	}
2727
2728
2729	// view cells already finished before post processing step
2730	// (i.e. because they were loaded)
2731	if (mViewCellsFinished)
2732	{
2733	FinalizeViewCells(true);
2734	EvaluateViewCellsStats();
2735
2736	return 0;
2737	}
2738
2739
2740	// check if new view cells turned invalid
2741	SetValidity(mMinPvsSize, mMaxPvsSize);
2742	// update valid view space according to valid view cells
2743	mVspBspTree->ValidateTree();
2744
2745	// recompute view cell statistics
2746	mViewCellsStats.Reset();
2747	EvaluateViewCellsStats();
2748
2749	// has to be recomputed
2750	mTotalAreaValid = false;
2751
2752
2753	VssRayContainer postProcessRays;
2754
2755	GetRaySets(rays, mPostProcessSamples, postProcessRays);
2756
2757	Debug << "post processing using " << (int)postProcessRays.size() << " samples" << endl;
2758
2759	Debug << "\nview cell partition after sampling:\n" << mViewCellsStats << endl << endl;
2760
2761	// should maybe be done here to allow merge working with area or volume
2762	// and to correct the rendering statistics
2763	if (0)
2764	{
2765	FinalizeViewCells(false);
2766	}
2767
2768	//-- merge the individual view cells
2769	MergeViewCells(postProcessRays, objects);
2770
2771
2772	//-- refines the merged view cells
2773	if (0)
2774	RefineViewCells(postProcessRays, objects);
2775
2776	//-- render simulation after merge
2777	cout << "\nevaluating bsp view cells render time before compress ... ";
2778	dynamic_cast<RenderSimulator *>(mRenderer)->RenderScene();
2779	SimulationStatistics ss;
2780	dynamic_cast<RenderSimulator *>(mRenderer)->GetStatistics(ss);
2781
2782
2783	cout << " finished" << endl;
2784	cout << ss << endl;
2785	Debug << ss << endl;
2786
2787
2788
2789	//-- compression
2790
2791	if (ViewCellsTreeConstructed() && mCompressViewCells)
2792	{
2793	int pvsEntries = mViewCellsTree->GetNumPvsEntries(mViewCellsTree->GetRoot());
2794	Debug << "number of entries before compress: " << pvsEntries << endl;
2795
2796	mViewCellsTree->CompressViewCellsPvs();
2797
2798	pvsEntries = mViewCellsTree->GetNumPvsEntries(mViewCellsTree->GetRoot());
2799	Debug << "number of entries after compress: " << pvsEntries << endl;
2800	}
2801
2802	// collapse sibling leaves that share the same view cell
2803	if (0)
2804	mVspBspTree->CollapseTree();
2805
2806	// recompute view cell list and statistics
2807	ResetViewCells();
2808
2809	// real meshes are only contructed only at this stage
2810	FinalizeViewCells(true);
2811
2812	// write view cells to disc
2813	if (mExportViewCells)
2814	{
2815	char buff[100];
2816	environment->GetStringValue("ViewCells.filename", buff);
2817	string vcFilename(buff);
2818
2819	ExportViewCells(buff);
2820	}
2821
2822	return 0;
2823	}
2824
2825
2826	int VspBspViewCellsManager::GetType() const
2827	{
2828	return VSP_BSP;
2829	}
2830
2831
2832	void VspBspViewCellsManager::CreateMergeHierarchy()
2833	{
2834	TraversalQueue tQueue;
2835
2836	tQueue.push(TraversalData(mVspBspTree->GetRoot(), NULL));
2837
2838	while (!tQueue.empty())
2839	{
2840	TraversalData tData = tQueue.top();
2841	tQueue.pop();
2842
2843	if (tData.mNode->IsLeaf())
2844	{
2845	ViewCell viewCell = dynamic_cast<BspLeaf >(tData.mNode)->GetViewCell();
2846
2847	if (tData.mParentViewCell)
2848	{
2849	tData.mParentViewCell->SetupChildLink(viewCell);
2850	// probagate up pvs
2851	mViewCellsTree->PropagateUpPvs(viewCell);
2852	}
2853	}
2854	else
2855	{
2856	BspInterior interior = dynamic_cast<BspInterior >(tData.mNode);
2857	ViewCellInterior *viewCellInterior = new ViewCellInterior();
2858
2859	tQueue.push(TraversalData(interior->GetBack(), viewCellInterior));
2860	tQueue.push(TraversalData(interior->GetFront(), viewCellInterior));
2861
2862	if (tData.mParentViewCell)
2863	tData.mParentViewCell->SetupChildLink(viewCellInterior);
2864	}
2865	}
2866	}
2867
2868
2869	bool VspBspViewCellsManager::GetViewPoint(Vector3 &viewPoint) const
2870	{
2871	if (!ViewCellsConstructed())
2872	return ViewCellsManager::GetViewPoint(viewPoint);
2873
2874	// TODO: set reasonable limit
2875	const int limit = 20;
2876
2877	for (int i = 0; i < limit; ++ i)
2878	{
2879	viewPoint = mViewSpaceBox.GetRandomPoint();
2880	if (mVspBspTree->ViewPointValid(viewPoint))
2881	{
2882	return true;
2883	}
2884	}
2885	Debug << "failed to find valid view point, taking " << viewPoint << endl;
2886	return false;
2887	}
2888
2889
2890	bool VspBspViewCellsManager::ViewPointValid(const Vector3 &viewPoint) const
2891	{
2892	// $$JB -> implemented in viewcellsmanager (slower, but allows dynamic
2893	// validy update in preprocessor for all managers)
2894	return ViewCellsManager::ViewPointValid(viewPoint);
2895
2896	// return mViewSpaceBox.IsInside(viewPoint) &&
2897	// mVspBspTree->ViewPointValid(viewPoint);
2898	}
2899
2900
2901	void VspBspViewCellsManager::Visualize(const ObjectContainer &objects,
2902	const VssRayContainer &sampleRays)
2903	{
2904	if (!ViewCellsConstructed())
2905	return;
2906
2907	VssRayContainer visRays;
2908	GetRaySets(sampleRays, mVisualizationSamples, visRays);
2909
2910
2911	if (1) // export view cells
2912	{// hack pvs
2913	int savedColorCode = mColorCode;
2914	mColorCode = 1;
2915	Exporter *exporter = Exporter::GetExporter("final_view_cells.x3d");
2916
2917	if (exporter)
2918	{
2919	cout << "exporting view cells after post process ... ";
2920
2921	if (0)
2922	{
2923	exporter->SetWireframe();
2924	exporter->ExportBox(mViewSpaceBox);
2925	exporter->SetFilled();
2926	}
2927
2928	if (mExportGeometry)
2929	{
2930	exporter->ExportGeometry(objects);
2931	}
2932
2933	// export rays
2934	if (mExportRays)
2935	{
2936	exporter->ExportRays(visRays, RgbColor(0, 1, 0));
2937	}
2938
2939	ExportViewCellsForViz(exporter);
2940	delete exporter;
2941	cout << "finished" << endl;
2942	}
2943
2944	mColorCode = savedColorCode;
2945	}
2946
2947	if (0)
2948	{
2949	cout << "exporting depth map ... ";
2950
2951	Exporter *exporter = Exporter::GetExporter("depth_map.x3d");
2952	if (exporter)
2953	{
2954	if (1)
2955	{
2956	exporter->SetWireframe();
2957	exporter->ExportBox(mViewSpaceBox);
2958	exporter->SetFilled();
2959	}
2960
2961	if (mExportGeometry)
2962	{
2963	exporter->ExportGeometry(objects);
2964	}
2965
2966	const int maxDepth = mVspBspTree->mBspStats.maxDepth;
2967
2968	ViewCellContainer::const_iterator vit, vit_end = mViewCells.end();
2969
2970	for (vit = mViewCells.begin(); vit != mViewCells.end(); ++ vit)
2971	{
2972	ViewCell vc = vit;
2973
2974	ViewCellContainer leaves;
2975	mViewCellsTree->CollectLeaves(vc, leaves);
2976
2977	ViewCellContainer::const_iterator lit, lit_end = leaves.end();
2978
2979	for (lit = leaves.begin(); lit != lit_end; ++ lit)
2980	{
2981	BspLeaf leaf = dynamic_cast<BspViewCell >(*lit)->mLeaf;
2982
2983	Material m;
2984
2985	float relDepth = (float)leaf->GetDepth() / (float)maxDepth;
2986	m.mDiffuseColor.r = relDepth;
2987	m.mDiffuseColor.g = 0.0f;
2988	m.mDiffuseColor.b = 1.0f - relDepth;
2989
2990	exporter->SetForcedMaterial(m);
2991
2992
2993	BspNodeGeometry geom;
2994	mVspBspTree->ConstructGeometry(leaf, geom);
2995	exporter->ExportPolygons(geom.mPolys);
2996	}
2997	}
2998
2999	delete exporter;
3000	}
3001
3002
3003	cout << "finished" << endl;
3004	}
3005
3006	//-- visualization of the BSP splits
3007	bool exportSplits = false;
3008	environment->GetBoolValue("VspBspTree.Visualization.exportSplits", exportSplits);
3009
3010	if (exportSplits)
3011	{
3012	cout << "exporting splits ... ";
3013	ExportSplits(objects, visRays);
3014	cout << "finished" << endl;
3015	}
3016
3017	//-- export single view cells
3018	ExportBspPvs(objects, visRays);
3019	}
3020
3021
3022	void VspBspViewCellsManager::ExportSplits(const ObjectContainer &objects,
3023	const VssRayContainer &rays)
3024	{
3025	Exporter *exporter = Exporter::GetExporter("bsp_splits.x3d");
3026
3027	if (exporter)
3028	{
3029	Material m;
3030	m.mDiffuseColor = RgbColor(1, 0, 0);
3031	exporter->SetForcedMaterial(m);
3032	exporter->SetWireframe();
3033
3034	exporter->ExportBspSplits(*mVspBspTree, true);
3035
3036	// take forced material, else big scenes cannot be viewed
3037	m.mDiffuseColor = RgbColor(0, 1, 0);
3038	exporter->SetForcedMaterial(m);
3039	exporter->SetFilled();
3040
3041	exporter->ResetForcedMaterial();
3042
3043	// export rays
3044	if (mExportRays)
3045	exporter->ExportRays(rays, RgbColor(1, 1, 0));
3046
3047	if (mExportGeometry)
3048	exporter->ExportGeometry(objects);
3049
3050	delete exporter;
3051	}
3052	}
3053
3054
3055	void VspBspViewCellsManager::ExportBspPvs(const ObjectContainer &objects,
3056	const VssRayContainer &rays)
3057	{
3058	const int leafOut = 10;
3059
3060	ViewCell::NewMail();
3061
3062	cout << "visualization using " << mVisualizationSamples << " samples" << endl;
3063	Debug << "\nOutput view cells: " << endl;
3064
3065	// sort view cells to visualize the largest view cells
3066	if (0)
3067	stable_sort(mViewCells.begin(), mViewCells.end(), vc_gt);
3068
3069	int limit = min(leafOut, (int)mViewCells.size());
3070
3071	int raysOut;
3072
3073	//-- some rays for output
3074	if (1)
3075	raysOut = min((int)rays.size(), mVisualizationSamples);
3076
3077	for (int i = 0; i < limit; ++ i)
3078	{
3079	cout << "creating output for view cell " << i << " ... ";
3080
3081	VssRayContainer vcRays;
3082	Intersectable::NewMail();
3083	ViewCell *vc;
3084
3085	if (0) // largest view cell pvs first
3086	vc = mViewCells[i];
3087	else
3088	vc = mViewCells[Random((int)mViewCells.size())];
3089
3090	vector<ViewCell *> leaves;
3091	mViewCellsTree->CollectLeaves(vc, leaves);
3092
3093	if (1)
3094	{
3095	// check whether we can add the current ray to the output rays
3096	for (int k = 0; k < raysOut; ++ k)
3097	{
3098	VssRay *ray = rays[k];
3099	for (int j = 0; j < (int)ray->mViewCells.size(); ++ j)
3100	{
3101	ViewCell *rayvc = ray->mViewCells[j];
3102
3103	if (leaves[0] == rayvc)
3104	vcRays.push_back(ray);
3105	}
3106	}
3107	}
3108
3109	//bspLeaves[j]->Mail();
3110	char s[64]; sprintf(s, "bsp-pvs%04d.x3d", i);
3111	Exporter *exporter = Exporter::GetExporter(s);
3112	exporter->SetWireframe();
3113
3114	Material m;//= RandomMaterial();
3115	m.mDiffuseColor = RgbColor(0, 1, 0);
3116	exporter->SetForcedMaterial(m);
3117
3118	ExportViewCellGeometry(exporter, vc);
3119
3120
3121	Debug << i << ": pvs size=" << (int)mViewCellsTree->GetPvsSize(vc)
3122	<< ", piercing rays=" << (int)vcRays.size() << endl;
3123	// << ", leaves=" << (int)vc->mLeaves.size() << endl;
3124
3125
3126	//-- export rays piercing this view cell
3127	if (1)
3128	{
3129	exporter->ExportRays(vcRays, RgbColor(1, 1, 1));
3130	}
3131	else
3132	{
3133
3134	ViewCellContainer leaves;
3135	mViewCellsTree->CollectLeaves(vc, leaves);
3136
3137	ViewCellContainer::const_iterator lit, lit_end = leaves.end();
3138
3139	for (lit = leaves.begin(); lit != lit_end; ++ lit)
3140	{
3141	BspLeaf l = dynamic_cast<BspViewCell >(*lit)->mLeaf;
3142	exporter->ExportRays(l->mVssRays);
3143	}
3144	}
3145
3146
3147	m.mDiffuseColor = RgbColor(1, 0, 0);
3148	exporter->SetForcedMaterial(m);
3149
3150	ObjectPvsMap::const_iterator it,
3151	it_end = vc->GetPvs().mEntries.end();
3152
3153	exporter->SetFilled();
3154
3155
3156	// output PVS of view cell
3157	for (it = vc->GetPvs().mEntries.begin(); it != it_end; ++ it)
3158	{
3159
3160	Intersectable intersect = (it).first;
3161
3162	if (!intersect->Mailed())
3163	{
3164	Material m = RandomMaterial();
3165	exporter->SetForcedMaterial(m);
3166
3167	exporter->ExportIntersectable(intersect);
3168	intersect->Mail();
3169	}
3170	}
3171
3172
3173	DEL_PTR(exporter);
3174	cout << "finished" << endl;
3175	}
3176
3177	Debug << endl;
3178	}
3179
3180
3181	int VspBspViewCellsManager::CastLineSegment(const Vector3 &origin,
3182	const Vector3 &termination,
3183	ViewCellContainer &viewcells)
3184	{
3185	return mVspBspTree->CastLineSegment(origin, termination, viewcells);
3186	}
3187
3188
3189	void VspBspViewCellsManager::ExportColor(Exporter *exporter,
3190	ViewCell *vc) const
3191	{
3192	const bool vcValid = CheckValidity(vc, mMinPvsSize, mMaxPvsSize);
3193
3194	float importance = 0;
3195	static Material m;
3196
3197	switch (mColorCode)
3198	{
3199	case 0: // Random
3200	{
3201	if (vcValid)
3202	{
3203	m.mDiffuseColor.r = 0.5f + RandomValue(0.0f, 0.5f);
3204	m.mDiffuseColor.g = 0.5f + RandomValue(0.0f, 0.5f);
3205	m.mDiffuseColor.b = 0.5f + RandomValue(0.f, 0.5f);
3206	}
3207	else
3208	{
3209	m.mDiffuseColor.r = 0.0f;
3210	m.mDiffuseColor.g = 1.0f;
3211	m.mDiffuseColor.b = 0.0f;
3212	}
3213
3214	exporter->SetForcedMaterial(m);
3215	return;
3216	}
3217
3218	case 1: // pvs
3219	{
3220	importance = (float)vc->GetPvs().GetSize() /
3221	(float)mViewCellsStats.maxPvs;
3222
3223	}
3224	break;
3225	case 2: // merges
3226	{
3227	int lSize = mViewCellsTree->GetSize(vc);
3228	importance = (float)lSize / (float)mViewCellsStats.maxLeaves;
3229	}
3230	break;
3231	case 3: // merge tree differene
3232	{
3233	importance = (float)GetMaxTreeDiff(vc) /
3234	(float)(mVspBspTree->GetStatistics().maxDepth * 2);
3235
3236	}
3237	break;
3238	default:
3239	break;
3240	}
3241
3242	// special color code for invalid view cells
3243	m.mDiffuseColor.r = importance;
3244	m.mDiffuseColor.g = 1.0f - m.mDiffuseColor.r;
3245	m.mDiffuseColor.b = vcValid ? 1.0f : 0.0f;
3246
3247	//Debug << "importance: " << importance << endl;
3248	exporter->SetForcedMaterial(m);
3249	}
3250
3251
3252	void VspBspViewCellsManager::ExportViewCellGeometry(Exporter *exporter,
3253	ViewCell *vc,
3254	const Plane3 *cuttingPlane) const
3255	{
3256	if (vc->GetMesh())
3257	{
3258	exporter->ExportMesh(vc->GetMesh());
3259
3260	return;
3261	}
3262
3263
3264	if (cuttingPlane)
3265	{
3266	ViewCellContainer leaves;
3267	mViewCellsTree->CollectLeaves(vc, leaves);
3268	ViewCellContainer::const_iterator it, it_end = leaves.end();
3269
3270	for (it = leaves.begin(); it != it_end; ++ it)
3271	{
3272	BspNodeGeometry geom;
3273
3274	BspNodeGeometry front;
3275	BspNodeGeometry back;
3276
3277
3278	BspLeaf leaf = dynamic_cast<BspViewCell >(*it)->mLeaf;
3279
3280	mVspBspTree->ConstructGeometry(leaf, geom);
3281
3282	geom.SplitGeometry(front,
3283	back,
3284	*cuttingPlane,
3285	mViewSpaceBox,
3286	0.0001f);
3287
3288	if ((int)back.mPolys.size() >= 3)
3289	exporter->ExportPolygons(back.mPolys);
3290	}
3291	}
3292	else
3293	{
3294	BspNodeGeometry geom;
3295	mVspBspTree->ConstructGeometry(vc, geom);
3296
3297	exporter->ExportPolygons(geom.mPolys);
3298	}
3299	}
3300
3301
3302	int VspBspViewCellsManager::GetMaxTreeDiff(ViewCell *vc) const
3303	{
3304	ViewCellContainer leaves;
3305	mViewCellsTree->CollectLeaves(vc, leaves);
3306
3307	int maxDist = 0;
3308
3309	// compute max height difference
3310	for (int i = 0; i < (int)leaves.size(); ++ i)
3311	for (int j = 0; j < (int)leaves.size(); ++ j)
3312	{
3313	BspLeaf leaf = dynamic_cast<BspViewCell >(leaves[i])->mLeaf;
3314
3315	if (i != j)
3316	{
3317	BspLeaf leaf2 =dynamic_cast<BspViewCell >(leaves[j])->mLeaf;
3318	int dist = mVspBspTree->TreeDistance(leaf, leaf2);
3319	if (dist > maxDist)
3320	maxDist = dist;
3321	}
3322	}
3323
3324	return maxDist;
3325	}
3326
3327
3328	ViewCell *VspBspViewCellsManager::GetViewCell(const Vector3 &point) const
3329	{
3330	if (!mVspBspTree)
3331	return NULL;
3332
3333	if (!mViewSpaceBox.IsInside(point))
3334	return NULL;
3335
3336	return mVspBspTree->GetViewCell(point);
3337	}
3338
3339
3340	void VspBspViewCellsManager::CreateMesh(ViewCell *vc)
3341	{
3342	if (vc->GetMesh())
3343	delete vc->GetMesh();
3344
3345
3346	BspNodeGeometry geom;
3347
3348	mVspBspTree->ConstructGeometry(vc, geom);
3349
3350	Mesh *mesh = new Mesh();
3351	geom.AddToMesh(*mesh);
3352	vc->SetMesh(mesh);
3353	mMeshContainer.push_back(mesh);
3354	}
3355
3356
3357	ViewCellsManager *ViewCellsManager::LoadViewCells(const string filename,
3358	ObjectContainer *objects)
3359	{
3360	ViewCellsParser parser;
3361
3362	ViewCellsManager *vm = NULL;
3363
3364	if (parser.ParseFile(filename, &vm, objects))
3365	{
3366	//vm->PrepareLoadedViewCells();
3367	vm->ResetViewCells();
3368
3369	vm->mViewCellsFinished = true;
3370	vm->mMaxPvsSize = (int)objects->size();
3371
3372	vm->FinalizeViewCells(true);
3373
3374	Debug << (int)vm->mViewCells.size() << " view cells loaded" << endl;
3375	}
3376	else
3377	{
3378	Debug << "failed loading view cells" << endl;
3379	DEL_PTR(vm);
3380	}
3381
3382
3383	return vm;
3384	}
3385
3386
3387	inline bool ilt(Intersectable obj1, Intersectable obj2)
3388	{
3389	return obj1->mId < obj2->mId;
3390	}
3391
3392
3393	bool VspBspViewCellsManager::ExportViewCells(const string filename)
3394	{
3395	cout << "exporting view cells to xml ... ";
3396	std::ofstream stream;
3397
3398	// for output we need unique ids for each view cell
3399	CreateUniqueViewCellIds();
3400
3401
3402	stream.open(filename.c_str());
3403	stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"<<endl;
3404	stream << "<Visibility_Solution>" << endl;
3405
3406	//-- the view space bounding box
3407	stream << "<ViewSpaceBox"
3408	<< " min=\"" << mViewSpaceBox.Min().x << " " << mViewSpaceBox.Min().y << " " << mViewSpaceBox.Min().z << "\""
3409	<< " max=\"" << mViewSpaceBox.Max().x << " " << mViewSpaceBox.Max().y << " " << mViewSpaceBox.Max().z << "\" />" << endl;
3410
3411	//-- the type of the view cells hierarchy
3412	stream << "<Hierarchy name=\"vspBspTree\" />" << endl;
3413
3414	//-- load the view cells itself, i.e., the ids and the pvs
3415	stream << "<ViewCells>" << endl;
3416
3417	#if 0
3418
3419	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
3420
3421	for (it = mViewCells.begin(); it != it_end; ++ it)
3422	ExportViewCell(*it, stream);
3423	#else
3424	mViewCellsTree->Export(stream);
3425	#endif
3426
3427	stream << "</ViewCells>" << endl;
3428
3429	//-- load the hierarchy
3430	stream << "<Hierarchy>" << endl;
3431	mVspBspTree->Export(stream);
3432	stream << endl << "</Hierarchy>" << endl;
3433
3434	stream << "</Visibility_Solution>" << endl;
3435	stream.close();
3436
3437	cout << "finished" << endl;
3438
3439	return true;
3440	}
3441
3442
3443	int VspBspViewCellsManager::CastBeam(Beam &beam)
3444	{
3445	return mVspBspTree->CastBeam(beam);
3446	}
3447
3448
3449	void VspBspViewCellsManager::Finalize(ViewCell *viewCell,
3450	const bool createMesh)
3451	{
3452	CreateMesh(viewCell);
3453
3454	float area = 0;
3455	float volume = 0;
3456
3457	ViewCellContainer leaves;
3458	mViewCellsTree->CollectLeaves(viewCell, leaves);
3459
3460	ViewCellContainer::const_iterator it, it_end = leaves.end();
3461
3462	for (it = leaves.begin(); it != it_end; ++ it)
3463	{
3464	BspNodeGeometry geom;
3465	BspLeaf leaf = dynamic_cast<BspViewCell >(*it)->mLeaf;
3466	mVspBspTree->ConstructGeometry(leaf, geom);
3467
3468	area += geom.GetArea();
3469	volume += geom.GetVolume();
3470	}
3471
3472	viewCell->SetVolume(volume);
3473	viewCell->SetArea(area);
3474	}
3475
3476
3477	void VspBspViewCellsManager::PrepareLoadedViewCells()
3478	{
3479	// TODO: do I still need this here?
3480	if (0)
3481	mVspBspTree->RepairViewCellsLeafLists();
3482	}
3483
3484
3485
3486	void VspBspViewCellsManager::CollectMergeCandidates(const VssRayContainer &rays,
3487	vector<MergeCandidate> &candidates)
3488	{
3489	cout << "collecting merge candidates ... " << endl;
3490
3491	if (mUseRaysForMerge)
3492	{
3493	mVspBspTree->CollectMergeCandidates(rays, candidates);
3494	}
3495	else
3496	{
3497	vector<BspLeaf *> leaves;
3498	mVspBspTree->CollectLeaves(leaves);
3499	mVspBspTree->CollectMergeCandidates(leaves, candidates);
3500	}
3501
3502	cout << "fininshed collecting candidates" << endl;
3503	}
3504
3505
3506	void VspBspViewCellsManager::AddCurrentViewCellsToHierarchy()
3507	{
3508	ViewCellContainer::const_iterator it, it_end = mViewCells.end();
3509	for (it = mViewCells.begin(); it != it_end; ++ it)
3510	{
3511	}
3512	}
3513
3514	//////////////////////////////////
3515	ViewCellsManager *ViewCellsManagerFactory::Create(const string mName)
3516	{
3517	//TODO
3518	return NULL;// new VspBspViewCellsManager();
3519	}
3520

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

Download in other formats: