Context Navigation

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

Revision 429, 13.8 KB checked in by mattausch, 19 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
12
13	bool useViewSpaceBox = true;
14	bool use2dSampling = false;
15	bool useViewspacePlane = false;
16
17	VssPreprocessor::VssPreprocessor():
18	mPass(0),
19	mVssRays()
20	{
21	// this should increase coherence of the samples
22	environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
23	environment->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
24	environment->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
25	environment->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
26	environment->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
27	environment->GetIntValue("BspTree.Construction.samples", mBspConstructionSamples);
28
29	mStats.open("stats.log");
30	}
31
32	VssPreprocessor::~VssPreprocessor()
33	{
34	CLEAR_CONTAINER(mVssRays);
35	}
36
37	void
38	VssPreprocessor::SetupRay(Ray &ray,
39	const Vector3 &point,
40	const Vector3 &direction
41	)
42	{
43	ray.intersections.clear();
44	// do not store anything else then intersections at the ray
45	ray.Init(point, direction, Ray::LOCAL_RAY);
46	}
47
48	int
49	VssPreprocessor::CastRay(
50	Vector3 &viewPoint,
51	Vector3 &direction,
52	VssRayContainer &vssRays
53	)
54	{
55	int hits = 0;
56	static Ray ray;
57	AxisAlignedBox3 box = mKdTree->GetBox();
58
59	AxisAlignedBox3 sbox = box;
60	sbox.Enlarge(Vector3(-Limits::Small));
61	if (!sbox.IsInside(viewPoint))
62	return 0;
63
64	SetupRay(ray, viewPoint, direction);
65	// cast ray to KD tree to find intersection with other objects
66	Intersectable objectA, objectB;
67	Vector3 pointA, pointB;
68	float bsize = Magnitude(box.Size());
69	if (mKdTree->CastRay(ray)) {
70	objectA = ray.intersections[0].mObject;
71	pointA = ray.Extrap(ray.intersections[0].mT);
72	} else {
73	objectA = NULL;
74	// compute intersection with the scene bounding box
75	float tmin, tmax;
76	box.ComputeMinMaxT(ray, &tmin, &tmax);
77	if (tmax > bsize) {
78	// cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
79	// cerr<<"ray"<<ray<<endl;
80	}
81	pointA = ray.Extrap(tmax);
82
83	}
84
85	bool detectEmptyViewSpace = true;
86
87	if (detectEmptyViewSpace) {
88	SetupRay(ray, pointA, -direction);
89	} else
90	SetupRay(ray, viewPoint, -direction);
91
92
93	if (mKdTree->CastRay(ray)) {
94
95	objectB = ray.intersections[0].mObject;
96	pointB = ray.Extrap(ray.intersections[0].mT);
97
98	} else {
99	objectB = NULL;
100	float tmin, tmax;
101	box.ComputeMinMaxT(ray, &tmin, &tmax);
102	if (tmax > bsize) {
103	// cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
104	// cerr<<"ray"<<ray<<endl;
105	}
106
107	pointB = ray.Extrap(tmax);
108	}
109
110	VssRay *vssRay = NULL;
111
112	bool validSample = true;
113	if (detectEmptyViewSpace) {
114	if (Distance(pointA, pointB) <
115	Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) {
116	validSample = false;
117	}
118	}
119
120	if (validSample) {
121	if (objectA) {
122	vssRay = new VssRay(pointB,
123	pointA,
124	objectB,
125	objectA);
126	vssRays.push_back(vssRay);
127	hits ++;
128	}
129
130	if (objectB) {
131	vssRay = new VssRay(pointA,
132	pointB,
133	objectA,
134	objectB);
135	vssRays.push_back(vssRay);
136	hits ++;
137	}
138	}
139
140	return hits;
141	}
142
143
144	Vector3
145	VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
146	{
147	AxisAlignedBox3 box;
148
149	if (viewSpaceBox)
150	box =*viewSpaceBox;
151	else
152	box = mKdTree->GetBox();
153
154	// shrink the box in the y direction
155	return box.GetRandomPoint();
156	}
157
158	Vector3
159	VssPreprocessor::GetDirection(const Vector3 &viewpoint,
160	AxisAlignedBox3 *viewSpaceBox
161	)
162	{
163	Vector3 point;
164	if (!use2dSampling) {
165	Vector3 normal;
166	int i = RandomValue(0, mObjects.size()-1);
167	Intersectable *object = mObjects[i];
168	object->GetRandomSurfacePoint(point, normal);
169	} else {
170	AxisAlignedBox3 box;
171
172	if (viewSpaceBox)
173	box =*viewSpaceBox;
174	else
175	box = mKdTree->GetBox();
176
177	point = box.GetRandomPoint();
178	point.y = viewpoint.y;
179	}
180
181	return point - viewpoint;
182	}
183
184	int
185	VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
186	const int desiredSamples,
187	SimpleRayContainer &rays
188	)
189	{
190	int num;
191	if (0) {
192	float minRayContribution;
193	float maxRayContribution;
194	float avgRayContribution;
195
196	vssTree->GetRayContributionStatistics(minRayContribution,
197	maxRayContribution,
198	avgRayContribution);
199
200	cout<<
201	"#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
202	"#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
203	"#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
204
205	float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
206	num = vssTree->GenerateRays(p, rays);
207	} else {
208	int leaves = vssTree->stat.Leaves()/2;
209	num = vssTree->GenerateRays(desiredSamples, leaves, rays);
210	}
211
212	cout<<"Generated "<<num<<" rays."<<endl;
213
214	return num;
215	}
216
217
218	bool
219	VssPreprocessor::ExportRays(const char *filename,
220	const VssRayContainer &vssRays,
221	const int number
222	)
223	{
224	cout<<"Exporting vss rays..."<<endl<<flush;
225
226	float prob = number/(float)vssRays.size();
227
228
229	Exporter *exporter = NULL;
230	exporter = Exporter::GetExporter(filename);
231	// exporter->SetWireframe();
232	// exporter->ExportKdTree(*mKdTree);
233	exporter->SetFilled();
234	exporter->ExportScene(mSceneGraph->mRoot);
235	exporter->SetWireframe();
236
237	if (mViewSpaceBox) {
238	exporter->SetForcedMaterial(RgbColor(1,0,0));
239	exporter->ExportBox(*mViewSpaceBox);
240	exporter->ResetForcedMaterial();
241	}
242
243	VssRayContainer rays; for (int i=0; i < vssRays.size(); i++)
244	if (RandomValue(0,1) < prob)
245	rays.push_back(vssRays[i]);
246
247	exporter->ExportRays(rays, RgbColor(1, 0, 0));
248
249	delete exporter;
250
251	cout<<"done."<<endl<<flush;
252
253	return true;
254	}
255
256
257	bool
258	VssPreprocessor::ExportVssTreeLeaf(char *filename,
259	VssTree *tree,
260	VssTreeLeaf *leaf)
261	{
262	Exporter *exporter = NULL;
263	exporter = Exporter::GetExporter(filename);
264	exporter->SetWireframe();
265	exporter->ExportKdTree(*mKdTree);
266
267	if (mViewSpaceBox) {
268	exporter->SetForcedMaterial(RgbColor(1,0,0));
269	exporter->ExportBox(*mViewSpaceBox);
270	exporter->ResetForcedMaterial();
271	}
272
273	exporter->SetForcedMaterial(RgbColor(0,0,1));
274	exporter->ExportBox(tree->GetBBox(leaf));
275	exporter->ResetForcedMaterial();
276
277	VssRayContainer rays[4];
278	for (int i=0; i < leaf->rays.size(); i++) {
279	int k = leaf->rays[i].GetRayClass();
280	rays[k].push_back(leaf->rays[i].mRay);
281	}
282
283	// SOURCE RAY
284	exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
285	// TERMINATION RAY
286	exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
287	// PASSING_RAY
288	exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
289	// CONTAINED_RAY
290	exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
291
292	delete exporter;
293	return true;
294	}
295
296	void
297	VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
298	{
299	vector<VssTreeLeaf *> leaves;
300	tree->CollectLeaves(leaves);
301
302	int num = 0;
303	int i;
304	float p = number / (float)leaves.size();
305	for (i=0; i < leaves.size(); i++) {
306	if (RandomValue(0,1) < p) {
307	char filename[64];
308	sprintf(filename, "vss-leaf-%04d.x3d", num);
309	ExportVssTreeLeaf(filename, tree, leaves[i]);
310	num++;
311	}
312	if (num >= number)
313	break;
314	}
315	}
316
317	bool
318	VssPreprocessor::ComputeVisibility()
319	{
320
321	mSceneGraph->CollectObjects(&mObjects);
322
323	long startTime = GetTime();
324
325	int totalSamples = 0;
326
327
328	AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());
329
330	if (!useViewspacePlane) {
331	float size = 0.01f;
332	float s = 0.5f - size;
333	float olds = Magnitude(box->Size());
334	box->Enlarge(box->Size()*Vector3(-s));
335	Vector3 translation = Vector3(-olds*0.1f, 0, 0);
336	box->SetMin(box->Min() + translation);
337	box->SetMax(box->Max() + translation);
338	} else {
339
340	// sample city like heights
341	box->SetMin(1, box->Min(1) + box->Size(1)*0.1);
342	box->SetMax(1, box->Min(1) + box->Size(1)*0.2);
343	}
344
345	if (use2dSampling)
346	box->SetMax(1, box->Min(1));
347
348	if (useViewSpaceBox)
349	mViewSpaceBox = box;
350	else
351	mViewSpaceBox = NULL;
352
353
354	VssTree *vssTree = NULL;
355
356	RayContainer bspRays;
357
358	while (totalSamples < mInitialSamples) {
359	int passContributingSamples = 0;
360	int passSampleContributions = 0;
361	int passSamples = 0;
362	int index = 0;
363
364	int sampleContributions;
365
366	int s = Min(mSamplesPerPass, mInitialSamples);
367	for (int k=0; k < s; k++) {
368
369	Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
370	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
371
372	sampleContributions = CastRay(viewpoint, direction, mVssRays);
373
374
375	//-- CORR matt: put block inside loop
376	if (sampleContributions) {
377	passContributingSamples ++;
378	passSampleContributions += sampleContributions;
379	}
380	passSamples++;
381	totalSamples++;
382	}
383
384	mPass++;
385
386	int pvsSize = 0;
387	float avgRayContrib = (passContributingSamples > 0) ?
388	passSampleContributions/(float)passContributingSamples : 0;
389
390	cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
391	cout << "#TotalSamples=" << totalSamples/1000
392	<< "k #SampleContributions=" << passSampleContributions << " ("
393	<< 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
394	<< pvsSize/(float)mObjects.size() << endl
395	<< "avg ray contrib=" << avgRayContrib << endl;
396
397	mStats <<
398	"#Pass\n" <<mPass<<endl<<
399	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
400	"#TotalSamples\n" << totalSamples<< endl<<
401	"#SampleContributions\n" << passSampleContributions << endl <<
402	"#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
403	"#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
404	"#AvgRayContrib\n" << avgRayContrib << endl;
405
406
407
408
409	}
410
411	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
412	cout << "#totalRayStackSize=" << mVssRays.size() << endl <<flush;
413
414
415	// int numExportRays = 10000;
416
417	int numExportRays = 0;
418
419	if (numExportRays) {
420	char filename[64];
421	sprintf(filename, "vss-rays-initial.x3d");
422	ExportRays(filename, mVssRays, numExportRays);
423	}
424
425
426
427	vssTree = new VssTree;
428
429	const int bspSamples = min((int)mVssRays.size(), mBspConstructionSamples);
430
431	for (int i = 0; i < bspSamples; ++ i)
432	bspRays.push_back(new Ray(*mVssRays[i]));
433
434	mBspTree = new BspTree(&mUnbounded);
435
436	mBspTree->SetGenerateViewCells(true);
437	mBspTree->Construct(bspRays);
438
439	for (int i = bspSamples; i < (int)mVssRays.size(); ++ i)
440	{
441	CastRay(mBspTree, mVssRays[i]);
442	}
443
444	vssTree->Construct(mVssRays, mViewSpaceBox);
445
446	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
447
448	ExportVssTreeLeaves(vssTree, 10);
449
450	int samples = 0;
451	int pass = 0;
452	while (1) {
453	int num = mVssSamplesPerPass;
454	SimpleRayContainer rays;
455	VssRayContainer vssRays;
456
457	if (!mUseImportanceSampling) {
458	for (int j=0; j < num; j++) {
459	Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
460	Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
461	rays.push_back(SimpleRay(viewpoint, direction));
462	}
463	} else {
464	num = GenerateImportanceRays(vssTree, num, rays);
465	}
466
467
468	for (int i=0; i < rays.size(); i++)
469	CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
470
471	vssTree->AddRays(vssRays);
472
473	if (1) {
474	int subdivided = vssTree->UpdateSubdivision();
475	cout<<"subdivided leafs = "<<subdivided<<endl;
476	}
477
478	if (numExportRays) {
479	char filename[64];
480	if (mUseImportanceSampling)
481	sprintf(filename, "vss-rays-i%04d.x3d", pass);
482	else
483	sprintf(filename, "vss-rays-%04d.x3d", pass);
484
485	ExportRays(filename, vssRays, numExportRays);
486	}
487
488
489	for (int i = 0; i < (int)vssRays.size(); ++ i)
490	{
491	CastRay(mBspTree, mVssRays[i]);
492	}
493
494	samples+=num;
495	float pvs = vssTree->GetAvgPvsSize();
496	cout<<"*****************************\n";
497	cout<<samples<<" avgPVS ="<<pvs<<endl;
498	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
499	cout<<"*****************************\n";
500	if (samples >= mVssSamples)
501	break;
502	pass++;
503	}
504
505	delete vssTree;
506
507	ObjectContainer objects;
508	ExportSplits(objects, bspRays, 10000);
509	ExportBspPvs(objects, bspRays, 10000);
510
511	CLEAR_CONTAINER(bspRays);
512
513	return true;
514	}
515
516	void VssPreprocessor::CastRay(const BspTree &tree, const VssRay & vssRay)
517	{
518	//-- cast ray to BSP tree to get intersection with view cells
519	Ray ray(vssRay);
520
521	mBspTree->CastRay(ray);
522
523	if (ray.sourceObject.mObject)
524	//sampleContributions +=
525	AddObjectSamples(ray.sourceObject.mObject, ray);
526
527	if (!ray.intersections.empty()) // second intersection found
528	{
529	//sampleContributions +=
530	AddObjectSamples(ray.intersections[0].mObject, ray);
531	}
532	}
533
534	int VssPreprocessor::AddObjectSamples(Intersectable *obj, const Ray &ray)
535	{
536	int contributingSamples = 0;
537	int j;
538
539	// object can be seen from the view cell => add to view cell pvs
540	for (j=0; j < ray.bspIntersections.size(); ++ j)
541	{
542	BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
543	// if ray not in unbounded space
544	if (leaf->GetViewCell() != &mUnbounded)
545	contributingSamples +=
546	leaf->GetViewCell()->GetPvs().AddSample(obj);
547	}
548
549	// rays passing through this viewcell
550	if (mPass > 1)
551	for (j=1; j < ((int)ray.bspIntersections.size() - 1); ++ j)
552	{
553	BspLeaf *leaf = ray.bspIntersections[j].mLeaf;
554
555	if (leaf->GetViewCell() != &mUnbounded)
556	leaf->GetViewCell()->
557	AddPassingRay(ray, contributingSamples ? 1 : 0);
558	}
559
560	return contributingSamples;
561	}

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

Download in other formats: