Context Navigation

source: GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.cpp @ 1281

Revision 1281, 24.2 KB checked in by bittner, 18 years ago (diff)
mlrt 16 ray tracing support

Rev	Line
[447]	1	#include "SceneGraph.h"
	2	#include "KdTree.h"
	3	#include "RssPreprocessor.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 "RssTree.h"
[451]	11	#include "ViewCellsManager.h"
[452]	12	#include "RenderSimulator.h"
[492]	13	#include "GlRenderer.h"
[447]	14
[863]	15	namespace GtpVisibilityPreprocessor {
[860]	16
	17
[549]	18	static bool useViewSpaceBox = false;
[447]	19	static bool use2dSampling = false;
[516]	20
	21
	22	// not supported anymore!
[463]	23	static bool fromBoxVisibility = false;
[447]	24
[1199]	25	#define ADD_RAYS_IN_PLACE 1
[1112]	26
[447]	27	RssPreprocessor::RssPreprocessor():
	28	mVssRays()
	29	{
	30	// this should increase coherence of the samples
[1004]	31	Environment::GetSingleton()->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
	32	Environment::GetSingleton()->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples);
	33	Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamples", mRssSamples);
	34	Environment::GetSingleton()->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass);
	35	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling);
[464]	36
[1004]	37	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.Export.pvs", mExportPvs);
	38	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.Export.rssTree", mExportRssTree);
	39	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.Export.rays", mExportRays);
	40	Environment::GetSingleton()->GetIntValue("RssPreprocessor.Export.numRays", mExportNumRays);
	41	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
	42	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.objectBasedSampling", mObjectBasedSampling);
	43	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.directionalSampling", mDirectionalSampling);
[464]	44
[1004]	45	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);
	46	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.storeInitialSamples", mStoreInitialSamples);
	47	Environment::GetSingleton()->GetBoolValue("RssPreprocessor.updateSubdivision", mUpdateSubdivision);
[464]	48
[447]	49	mStats.open("stats.log");
[563]	50	mRssTree = NULL;
	51	}
[492]	52
[563]	53
	54	bool
	55	RssPreprocessor::GenerateRays(
	56	const int number,
	57	const int sampleType,
	58	SimpleRayContainer &rays
	59	)
	60	{
	61	bool result = false;
	62
	63	switch (sampleType) {
	64	case RSS_BASED_DISTRIBUTION:
	65	case RSS_SILHOUETTE_BASED_DISTRIBUTION:
	66	if (mRssTree) {
	67	GenerateImportanceRays(mRssTree, number, rays);
	68	result = true;
	69	}
	70	break;
[752]	71
[563]	72	default:
	73	result = Preprocessor::GenerateRays(number, sampleType, rays);
	74	}
	75
[1112]	76	// rays.NormalizePdf();
	77
[563]	78	return result;
[447]	79	}
	80
[563]	81
	82
[447]	83	RssPreprocessor::~RssPreprocessor()
	84	{
[492]	85	// mVssRays get deleted in the tree
	86	// CLEAR_CONTAINER(mVssRays);
[447]	87	}
	88
	89
[1251]	90	#if 0 //matt: this moved up to preprocessor
[447]	91	int
	92	RssPreprocessor::CastRay(
	93	Vector3 &viewPoint,
	94	Vector3 &direction,
[537]	95	const float probability,
[447]	96	VssRayContainer &vssRays
	97	)
	98	{
	99	int hits = 0;
	100	static Ray ray;
[1199]	101	Intersectable objectA, objectB;
	102	Vector3 pointA, pointB;
[447]	103
[1199]	104	// AxisAlignedBox3 box = Union(mKdTree->GetBox(), mViewCellsManager->GetViewSpaceBox());
	105
[1112]	106	AxisAlignedBox3 box = mViewCellsManager->GetViewSpaceBox();
	107
[447]	108	AxisAlignedBox3 sbox = box;
	109	sbox.Enlarge(Vector3(-Limits::Small));
	110	if (!sbox.IsInside(viewPoint))
	111	return 0;
	112
	113	SetupRay(ray, viewPoint, direction);
[1199]	114	ray.mFlags &= ~Ray::CULL_BACKFACES;
[549]	115
[447]	116	// cast ray to KD tree to find intersection with other objects
	117	float bsize = Magnitude(box.Size());
	118
[1199]	119
[447]	120	if (mKdTree->CastRay(ray)) {
	121	objectA = ray.intersections[0].mObject;
	122	pointA = ray.Extrap(ray.intersections[0].mT);
[1199]	123	if (mDetectEmptyViewSpace)
	124	if (DotProd(ray.intersections[0].mNormal, direction) >= 0) {
	125	// discard the sample
	126	return 0;
	127	}
	128
[447]	129	} else {
	130	objectA = NULL;
	131	// compute intersection with the scene bounding box
	132	float tmin, tmax;
[492]	133	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
	134	pointA = ray.Extrap(tmax);
	135	else
	136	return 0;
[447]	137	}
	138
[1199]	139
	140	SetupRay(ray, viewPoint, -direction);
	141	ray.mFlags &= ~Ray::CULL_BACKFACES;
	142
[447]	143	if (mKdTree->CastRay(ray)) {
	144	objectB = ray.intersections[0].mObject;
	145	pointB = ray.Extrap(ray.intersections[0].mT);
[1199]	146	if (mDetectEmptyViewSpace)
	147	if (DotProd(ray.intersections[0].mNormal, direction) <= 0) {
	148	// discard the sample
	149	return 0;
	150	}
[447]	151	} else {
	152	objectB = NULL;
	153	float tmin, tmax;
[492]	154	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
	155	pointB = ray.Extrap(tmax);
	156	else
	157	return 0;
	158	}
	159
	160
[447]	161	VssRay *vssRay = NULL;
[492]	162	bool validSample = (objectA != objectB);
[447]	163	if (validSample) {
	164	if (objectA) {
	165	vssRay = new VssRay(pointB,
	166	pointA,
	167	objectB,
[464]	168	objectA,
[537]	169	mPass,
	170	probability
[464]	171	);
[447]	172	vssRays.push_back(vssRay);
	173	hits ++;
	174	}
	175
	176	if (objectB) {
	177	vssRay = new VssRay(pointA,
	178	pointB,
	179	objectA,
[464]	180	objectB,
[537]	181	mPass,
	182	probability
[464]	183	);
[447]	184	vssRays.push_back(vssRay);
	185	hits ++;
	186	}
	187	}
[576]	188
[447]	189	return hits;
	190	}
[1251]	191	#endif
[447]	192
[576]	193	void
	194	RssPreprocessor::ExportObjectRays(VssRayContainer &rays,
	195	const int objectId)
	196	{
	197	ObjectContainer::const_iterator oi;
[447]	198
[576]	199	Intersectable *object = NULL;
	200	for (oi = mObjects.begin(); oi != mObjects.end(); ++oi)
	201	if (objectId == (*oi)->GetId()) {
	202	object = *oi;
	203	break;
	204	}
[447]	205
[576]	206	if (object == NULL)
	207	return;
	208
	209	VssRayContainer selectedRays;
	210	VssRayContainer::const_iterator it= rays.begin(), it_end = rays.end();
	211
	212
	213	for (; it != it_end; ++it) {
	214	if ((*it)->mTerminationObject == object)
	215	selectedRays.push_back(*it);
	216	}
	217
	218
	219	Exporter *exporter = Exporter::GetExporter("object-rays.x3d");
	220	// exporter->SetWireframe();
	221	// exporter->ExportKdTree(*mKdTree);
	222	exporter->SetFilled();
	223	exporter->ExportIntersectable(object);
	224	exporter->ExportRays(selectedRays, RgbColor(1, 0, 0));
	225
	226	delete exporter;
	227
	228	}
	229
	230
[447]	231	int
	232	RssPreprocessor::GenerateImportanceRays(RssTree *rssTree,
	233	const int desiredSamples,
	234	SimpleRayContainer &rays
	235	)
	236	{
	237	int num;
[463]	238
[492]	239	rssTree->UpdateTreeStatistics();
[463]	240
[447]	241	cout<<
[492]	242	"#RSS_AVG_PVS_SIZE\n"<<rssTree->stat.avgPvsSize<<endl<<
	243	"#RSS_AVG_RAYS\n"<<rssTree->stat.avgRays<<endl<<
	244	"#RSS_AVG_RAY_CONTRIB\n"<<rssTree->stat.avgRayContribution<<endl<<
	245	"#RSS_AVG_PVS_ENTROPY\n"<<rssTree->stat.avgPvsEntropy<<endl<<
	246	"#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<rssTree->stat.avgRayLengthEntropy<<endl<<
	247	"#RSS_AVG_IMPORTANCE\n"<<rssTree->stat.avgImportance<<endl;
[447]	248
	249	if (0) {
[492]	250	float p = desiredSamples/(float)(rssTree->stat.avgRayContribution*rssTree->stat.Leaves());
[447]	251	num = rssTree->GenerateRays(p, rays);
	252	} else {
[459]	253	int leaves = rssTree->stat.Leaves()/1;
[1112]	254
[447]	255	num = rssTree->GenerateRays(desiredSamples, leaves, rays);
	256	}
	257
	258
	259	return num;
	260	}
	261
	262
	263	bool
	264	RssPreprocessor::ExportRays(const char *filename,
	265	const VssRayContainer &vssRays,
	266	const int number
	267	)
	268	{
	269	cout<<"Exporting vss rays..."<<endl<<flush;
	270
	271	Exporter *exporter = NULL;
	272	exporter = Exporter::GetExporter(filename);
[1112]	273	if (0) {
	274	exporter->SetWireframe();
	275	exporter->ExportKdTree(*mKdTree);
	276	}
[447]	277	exporter->SetFilled();
[556]	278	// $$JB temporarily do not export the scene
[752]	279	if (0)
[549]	280	exporter->ExportScene(mSceneGraph->mRoot);
[447]	281	exporter->SetWireframe();
	282
[1112]	283	if (1 \|\| mViewSpaceBox) {
[447]	284	exporter->SetForcedMaterial(RgbColor(1,0,1));
[1112]	285	exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
[447]	286	exporter->ResetForcedMaterial();
	287	}
[1112]	288
[492]	289	VssRayContainer rays;
	290
[1112]	291	vssRays.SelectRays(number, rays);
[447]	292
	293	exporter->ExportRays(rays, RgbColor(1, 0, 0));
	294
	295	delete exporter;
	296
	297	cout<<"done."<<endl<<flush;
	298
	299	return true;
	300	}
	301
[1112]	302	bool
	303	RssPreprocessor::ExportRayAnimation(const char *filename,
	304	const vector<VssRayContainer> &vssRays
	305	)
	306	{
	307	cout<<"Exporting vss rays..."<<endl<<flush;
	308
	309	Exporter *exporter = NULL;
	310	exporter = Exporter::GetExporter(filename);
	311	if (0) {
	312	exporter->SetWireframe();
	313	exporter->ExportKdTree(*mKdTree);
	314	}
	315	exporter->SetFilled();
	316	// $$JB temporarily do not export the scene
	317	if (1)
	318	exporter->ExportScene(mSceneGraph->mRoot);
	319	exporter->SetWireframe();
[447]	320
[1112]	321	if (1 \|\| mViewSpaceBox) {
	322	exporter->SetForcedMaterial(RgbColor(1,0,1));
	323	exporter->ExportBox(mViewCellsManager->GetViewSpaceBox());
	324	exporter->ResetForcedMaterial();
	325	}
	326
	327	exporter->ExportRaySets(vssRays, RgbColor(1, 0, 0));
	328
	329	delete exporter;
	330
	331	cout<<"done."<<endl<<flush;
	332
	333	return true;
	334	}
	335
	336
[447]	337	bool
	338	RssPreprocessor::ExportRssTree(char *filename,
	339	RssTree *tree,
	340	const Vector3 &dir
	341	)
	342	{
	343	Exporter *exporter = Exporter::GetExporter(filename);
	344	exporter->SetFilled();
	345	exporter->ExportScene(mSceneGraph->mRoot);
	346	// exporter->SetWireframe();
	347	bool result = exporter->ExportRssTree2( *tree, dir );
	348	delete exporter;
	349	return result;
	350	}
	351
	352	bool
	353	RssPreprocessor::ExportRssTreeLeaf(char *filename,
	354	RssTree *tree,
	355	RssTreeLeaf *leaf)
	356	{
	357	Exporter *exporter = NULL;
	358	exporter = Exporter::GetExporter(filename);
	359	exporter->SetWireframe();
	360	exporter->ExportKdTree(*mKdTree);
	361
	362	if (mViewSpaceBox) {
	363	exporter->SetForcedMaterial(RgbColor(1,0,0));
	364	exporter->ExportBox(*mViewSpaceBox);
	365	exporter->ResetForcedMaterial();
	366	}
	367
	368	exporter->SetForcedMaterial(RgbColor(0,0,1));
	369	exporter->ExportBox(tree->GetBBox(leaf));
	370	exporter->ResetForcedMaterial();
	371
	372	VssRayContainer rays[4];
	373	for (int i=0; i < leaf->rays.size(); i++) {
	374	int k = leaf->rays[i].GetRayClass();
	375	rays[k].push_back(leaf->rays[i].mRay);
	376	}
	377
	378	// SOURCE RAY
	379	exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
	380	// TERMINATION RAY
	381	exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
	382	// PASSING_RAY
	383	exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
	384	// CONTAINED_RAY
	385	exporter->ExportRays(rays[3], RgbColor(0, 0, 1));
	386
	387	delete exporter;
	388	return true;
	389	}
	390
	391	void
	392	RssPreprocessor::ExportRssTreeLeaves(RssTree *tree, const int number)
	393	{
	394	vector<RssTreeLeaf *> leaves;
	395	tree->CollectLeaves(leaves);
	396
	397	int num = 0;
	398	int i;
	399	float p = number / (float)leaves.size();
	400	for (i=0; i < leaves.size(); i++) {
	401	if (RandomValue(0,1) < p) {
	402	char filename[64];
	403	sprintf(filename, "rss-leaf-%04d.x3d", num);
	404	ExportRssTreeLeaf(filename, tree, leaves[i]);
	405	num++;
	406	}
	407	if (num >= number)
	408	break;
	409	}
	410	}
	411
	412
	413	float
	414	RssPreprocessor::GetAvgPvsSize(RssTree *tree,
	415	const vector<AxisAlignedBox3> &viewcells
	416	)
	417	{
	418	vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();
	419
	420	int sum = 0;
	421	for (it = viewcells.begin(); it != it_end; ++ it)
	422	sum += tree->GetPvsSize(*it);
	423
	424	return sum/(float)viewcells.size();
	425	}
	426
	427
	428	void
	429	RssPreprocessor::ExportPvs(char *filename,
	430	RssTree *rssTree
	431	)
	432	{
	433	ObjectContainer pvs;
	434	if (rssTree->CollectRootPvs(pvs)) {
	435	Exporter *exporter = Exporter::GetExporter(filename);
	436	exporter->SetFilled();
	437	exporter->ExportGeometry(pvs);
[459]	438	exporter->SetWireframe();
	439	exporter->ExportBox(rssTree->bbox);
	440	exporter->ExportViewpoint(rssTree->bbox.Center(), Vector3(1,0,0));
[447]	441	delete exporter;
	442	}
	443	}
	444
[492]	445
	446	void
	447	RssPreprocessor::ComputeRenderError()
	448	{
	449	// compute rendering error
[1145]	450
[752]	451	if (renderer && renderer->mPvsStatFrames) {
[496]	452	// emit EvalPvsStat();
	453	// QMutex mutex;
	454	// mutex.lock();
	455	// renderer->mRenderingFinished.wait(&mutex);
	456	// mutex.unlock();
[556]	457
[496]	458	renderer->EvalPvsStat();
[492]	459	mStats <<
	460	"#AvgPvsRenderError\n" <<renderer->mPvsStat.GetAvgError()<<endl<<
	461	"#MaxPvsRenderError\n" <<renderer->mPvsStat.GetMaxError()<<endl<<
[713]	462	"#ErrorFreeFrames\n" <<renderer->mPvsStat.GetErrorFreeFrames()<<endl<<
	463	"#AvgRenderPvs\n" <<renderer->mPvsStat.GetAvgPvs()<<endl;
[492]	464	}
	465	}
	466
[1112]	467	void
	468	NormalizeRatios(float ratios[3])
	469	{
	470	int i;
	471	float sumRatios;
	472	sumRatios = ratios[0] + ratios[1] + ratios[2];
	473	if (sumRatios == 0.0f) {
	474	ratios[0] = ratios[1] = ratios[2] = 1.0f;
	475	sumRatios = 3.0f;
	476	}
	477
	478	for (i=0 ; i < 3; i++)
	479	ratios[i]/=sumRatios;
	480	#define MIN_RATIO 0.03f
	481	for (i=0 ; i < 3; i++)
	482	if (ratios[i] < MIN_RATIO)
	483	ratios[i] = MIN_RATIO;
[563]	484
[1112]	485	sumRatios = ratios[0] + ratios[1] + ratios[2];
	486	for (i=0 ; i < 3; i++)
	487	ratios[i]/=sumRatios;
	488
	489	}
[563]	490
[447]	491	bool
	492	RssPreprocessor::ComputeVisibility()
	493	{
[556]	494
[811]	495	Debug << "type: rss" << endl;
[579]	496
[464]	497	cout<<"Rss Preprocessor started\n"<<flush;
[567]	498	// cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;
[492]	499
	500	Randomize(0);
	501
[1112]	502	vector<VssRayContainer> rayBuffer(50);
	503
[447]	504	long startTime = GetTime();
	505
	506	int totalSamples = 0;
	507
[563]	508	mViewSpaceBox = NULL;
[572]	509
[577]	510	// if not already loaded, construct view cells from file
[1112]	511	if (!mLoadViewCells)
	512	{
	513	if (1)
[577]	514	mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
[677]	515	else {
	516	AxisAlignedBox3 box = mKdTree->GetBox();
[1112]	517
	518	if (1) {
	519	// use a small box outside of the scene
	520	box.Scale(Vector3(0.1f,0.5f,0.5f));
	521	box.Translate(Vector3(Magnitude(mKdTree->GetBox().Size())*0.5, 0, 0));
	522	} else {
	523	float s = box.Size(0);
	524	box.Scale(0.1f);
	525	box.SetMin(0, box.Min(0) + s);
	526	box.SetMax(0, box.Max(0) + s);
	527	}
[1027]	528
[677]	529	mViewCellsManager->SetViewSpaceBox(box);
	530	}
[1112]	531
	532	// construct view cells using it's own set of samples
	533	mViewCellsManager->Construct(this);
	534
	535	//-- several visualizations and statistics
	536	Debug << "view cells construction finished: " << endl;
	537	mViewCellsManager->PrintStatistics(Debug);
[574]	538	}
[1112]	539
	540
[492]	541	int rssPass = 0;
	542	int rssSamples = 0;
[563]	543
[492]	544	if (mLoadInitialSamples) {
	545	cout << "Loading samples from file ... ";
	546	LoadSamples(mVssRays, mObjects);
	547	cout << "finished\n" << endl;
	548	} else {
[563]	549	SimpleRayContainer rays;
[537]	550
[871]	551	cout<<"Generating initial rays..."<<endl<<flush;
	552
[1199]	553	if (mUseImportanceSampling) {
	554	GenerateRays(mInitialSamples/3, SPATIAL_BOX_BASED_DISTRIBUTION, rays);
	555	GenerateRays(mInitialSamples/3, OBJECT_BASED_DISTRIBUTION, rays);
	556	GenerateRays(mInitialSamples/3, DIRECTION_BASED_DISTRIBUTION, rays);
	557	// GenerateRays(mInitialSamples/4, OBJECT_DIRECTION_BASED_DISTRIBUTION, rays);
	558	} else {
	559	int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
	560	if (mObjectBasedSampling)
	561	rayType = OBJECT_BASED_DISTRIBUTION;
	562	else
	563	if (mDirectionalSampling)
	564	rayType = DIRECTION_BASED_DISTRIBUTION;
	565	cout<<"Generating rays..."<<endl;
	566	GenerateRays(mRssSamplesPerPass, rayType, rays);
	567	}
	568
	569
[871]	570	cout<<"Casting initial rays..."<<endl<<flush;
[563]	571	CastRays(rays, mVssRays);
[576]	572
	573	ExportObjectRays(mVssRays, 1546);
[563]	574	}
	575
	576	cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
	577
	578	rssSamples += (int)mVssRays.size();
	579	totalSamples += mInitialSamples;
	580	mPass++;
	581
	582	if (mExportRays) {
[577]	583
[563]	584	char filename[64];
	585	sprintf(filename, "rss-rays-initial.x3d");
	586	ExportRays(filename, mVssRays, mExportNumRays);
[1112]	587
	588	mVssRays.SelectRays(mExportNumRays, rayBuffer[0], true);
[577]	589
[563]	590	}
	591
	592	if (mStoreInitialSamples) {
	593	cout << "Writing samples to file ... ";
	594	ExportSamples(mVssRays);
	595	cout << "finished\n" << endl;
	596	}
[492]	597
[563]	598	if (mUseViewcells) {
	599
[871]	600	cout<<"Computing sample contributions..."<<endl<<flush;
[563]	601	// evaluate contributions of the intitial rays
[574]	602	mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
[871]	603	cout<<"done.\n"<<flush;
[492]	604
[563]	605	mStats <<
	606	"#Pass\n" <<mPass<<endl<<
	607	"#RssPass\n" <<rssPass<<endl<<
	608	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
	609	"#TotalSamples\n" <<totalSamples<<endl<<
	610	"#RssSamples\n" <<rssSamples<<endl;
[569]	611
	612	{
	613	VssRayContainer contributingRays;
[1112]	614	mVssRays.GetContributingRays(contributingRays, 0);
[569]	615	mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
[1112]	616	if (mExportRays) {
	617	char filename[64];
	618	sprintf(filename, "rss-crays-%04d.x3d", 0);
	619	ExportRays(filename, contributingRays, mExportNumRays);
	620	}
[569]	621	}
[563]	622
	623	mVssRays.PrintStatistics(mStats);
	624	mViewCellsManager->PrintPvsStatistics(mStats);
[502]	625
[572]	626	// viewcells->UpdatePVS(newVssRays);
	627	Debug<<"Valid viewcells before set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
	628	// cull viewcells with PVS > median (0.5f)
[752]	629	//mViewCellsManager->SetValidityPercentage(0, 0.5f);
	630	mViewCellsManager->SetValidityPercentage(0, 1.0f);
[572]	631	Debug<<"Valid viewcells after set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
[563]	632
	633	ComputeRenderError();
	634	}
[492]	635
	636	rssPass++;
	637
[563]	638	mRssTree = new RssTree;
	639	mRssTree->SetPass(mPass);
[492]	640
[527]	641	/// compute view cell contribution of rays if view cells manager already constructed
[752]	642	// mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
[527]	643
[467]	644	if (mUseImportanceSampling) {
	645
[563]	646	mRssTree->Construct(mObjects, mVssRays);
[467]	647
[563]	648	mRssTree->stat.Print(mStats);
	649	cout<<"RssTree root PVS size = "<<mRssTree->GetRootPvsSize()<<endl;
	650
[467]	651	if (mExportRssTree) {
[563]	652	ExportRssTree("rss-tree-100.x3d", mRssTree, Vector3(1,0,0));
	653	ExportRssTree("rss-tree-001.x3d", mRssTree, Vector3(0,0,1));
	654	ExportRssTree("rss-tree-101.x3d", mRssTree, Vector3(1,0,1));
	655	ExportRssTree("rss-tree-101m.x3d", mRssTree, Vector3(-1,0,-1));
	656	ExportRssTreeLeaves(mRssTree, 10);
[467]	657	}
	658
	659	if (mExportPvs) {
[563]	660	ExportPvs("rss-pvs-initial.x3d", mRssTree);
[467]	661	}
[459]	662	}
[467]	663
[466]	664
[447]	665	while (1) {
	666	SimpleRayContainer rays;
	667	VssRayContainer vssRays;
[563]	668	int castRays = 0;
	669	if (mUseImportanceSampling) {
	670	VssRayContainer tmpVssRays;
[567]	671
[1112]	672	static float ratios[] = {0.9f,0.05f,0.05f};
	673	//float ratios[] = {1.0f,0.0f,0.0f};
	674
	675	int nrays[3];
	676	float contributions[3];
	677	float times[3];
	678
[1150]	679	long t1;
[567]	680
[1112]	681	t1 = GetTime();
	682
[567]	683	GenerateRays(mRssSamplesPerPass*ratios[0], RSS_BASED_DISTRIBUTION, rays);
[1112]	684
[1146]	685	rays.NormalizePdf((int)rays.size());
[1112]	686
[563]	687	CastRays(rays, tmpVssRays);
	688	castRays += rays.size();
[1112]	689	#if ADD_RAYS_IN_PLACE
	690	contributions[0] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
	691	#else
	692	contributions[0] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
	693	#endif
	694	times[0] = TimeDiff(t1, GetTime());
	695	nrays[0] = rays.size();
	696
	697	mStats<<"#RssRelContrib"<<endl<<contributions[0]/nrays[0]<<endl;
	698
[563]	699	vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
	700	rays.clear();
	701	tmpVssRays.clear();
[567]	702	if (ratios[1]!=0.0f) {
[1112]	703	t1 = GetTime();
[567]	704	GenerateRays(mRssSamplesPerPass*ratios[1], SPATIAL_BOX_BASED_DISTRIBUTION, rays);
	705	CastRays(rays, tmpVssRays);
	706	castRays += rays.size();
[1112]	707	#if ADD_RAYS_IN_PLACE
	708	contributions[1] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
	709	#else
	710	contributions[1] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
	711	#endif
	712	times[1] = TimeDiff(t1, GetTime());
	713	nrays[1] = rays.size();
	714
	715	mStats<<"#SpatialRelContrib"<<endl<<contributions[1]/nrays[1]<<endl;
[567]	716
	717	vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
	718
	719	rays.clear();
	720	tmpVssRays.clear();
	721	}
[563]	722
	723
[567]	724	if (ratios[2]!=0.0f) {
[1112]	725	t1 = GetTime();
[567]	726	GenerateRays(mRssSamplesPerPass*ratios[2], DIRECTION_BASED_DISTRIBUTION, rays);
	727	CastRays(rays, tmpVssRays);
	728	castRays += rays.size();
[1112]	729	#if ADD_RAYS_IN_PLACE
	730	contributions[2] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, true, false);
	731	#else
	732	contributions[2] = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
	733	#endif
	734	times[2] = TimeDiff(t1, GetTime());
	735	nrays[2] = rays.size();
[567]	736
[1112]	737	mStats<<"#DirectionalRelContrib"<<endl<<contributions[2]/nrays[2]<<endl;
	738
[567]	739	vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
	740
	741	rays.clear();
	742	tmpVssRays.clear();
	743	}
[563]	744
[1112]	745
	746	// now evaluate the ratios for the next pass
	747	#define TIMES 0
	748
	749	#if TIMES
	750	ratios[0] = sqr(contributions[0]/times[0]);
	751	ratios[1] = sqr(contributions[1]/times[1]);
	752	ratios[2] = sqr(contributions[2]/times[2]);
	753	#else
	754	ratios[0] = sqr(contributions[0]/nrays[0]);
	755	ratios[1] = sqr(contributions[1]/nrays[1]);
	756	ratios[2] = sqr(contributions[2]/nrays[2]);
	757	#endif
	758	NormalizeRatios(ratios);
	759
	760	cout<<"New ratios: "<<ratios[0]<<" "<<ratios[1]<<" "<<ratios[2]<<endl;
	761
[563]	762	// add contributions of all rays at once...
[1112]	763	#if !ADD_RAYS_IN_PLACE
[563]	764	mViewCellsManager->AddSampleContributions(vssRays);
[1112]	765	#endif
[563]	766	}
	767	else {
	768	int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
	769	if (mObjectBasedSampling)
	770	rayType = OBJECT_BASED_DISTRIBUTION;
	771	else
	772	if (mDirectionalSampling)
	773	rayType = DIRECTION_BASED_DISTRIBUTION;
[752]	774
	775	cout<<"Generating rays..."<<endl;
	776
[563]	777	GenerateRays(mRssSamplesPerPass, rayType, rays);
[752]	778	cout<<"done."<<endl;
	779
	780	cout<<"Casting rays..."<<endl;
[563]	781	CastRays(rays, vssRays);
[752]	782	cout<<"done."<<endl;
[563]	783	castRays += rays.size();
	784	if (mUseViewcells) {
	785	/// compute view cell contribution of rays
[752]	786	cout<<"Computing sample contributions..."<<endl;
[574]	787	mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
[752]	788	cout<<"done."<<endl;
[447]	789	}
[563]	790
	791
[447]	792	}
[563]	793	totalSamples += castRays;
[503]	794	rssSamples += (int)vssRays.size();
[467]	795
[884]	796	cout<<"Generated "<<castRays<<" rays, progress "<<100.0f*totalSamples/((float) mRssSamples +
	797	mInitialSamples)<<"%\n";
[492]	798
	799
[467]	800	mStats <<
	801	"#Pass\n" <<mPass<<endl<<
	802	"#RssPass\n" <<rssPass<<endl<<
	803	"#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
	804	"#TotalSamples\n" <<totalSamples<<endl<<
	805	"#RssSamples\n" <<rssSamples<<endl;
	806
[492]	807
[466]	808	if (mUseViewcells) {
[467]	809	vssRays.PrintStatistics(mStats);
	810	mViewCellsManager->PrintPvsStatistics(mStats);
[466]	811	}
[576]	812
	813	if (0 && mPass > 0) {
[1145]	814	char buf[100];
[576]	815	if (mUseImportanceSampling)
[1145]	816	{
	817	sprintf(buf, "snap/i-%02d-", mPass);
	818
[1151]	819	renderer->SetSnapPrefix(buf);
[1145]	820	}
[576]	821	else
[1145]	822	{
	823	sprintf(buf, "snap/r-%02d-", mPass);
	824
[1151]	825	renderer->SetSnapPrefix(buf);
[1145]	826	}
	827
[1151]	828	renderer->SetSnapErrorFrames(true);
[576]	829	}
	830
[492]	831	ComputeRenderError();
	832
	833	// epxort rays before adding them to the tree -> some of them can be deleted
	834
	835	if (mExportRays) {
	836	char filename[64];
	837	if (mUseImportanceSampling)
	838	sprintf(filename, "rss-rays-i%04d.x3d", rssPass);
	839	else
	840	sprintf(filename, "rss-rays-%04d.x3d", rssPass);
	841
[1112]	842
	843
	844	vssRays.SelectRays(mExportNumRays, rayBuffer[mPass], true);
	845
[492]	846	ExportRays(filename, vssRays, mExportNumRays);
[1112]	847
[492]	848	// now export all contributing rays
	849	VssRayContainer contributingRays;
	850	vssRays.GetContributingRays(contributingRays, mPass);
[508]	851	mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
[492]	852	sprintf(filename, "rss-crays-%04d.x3d", rssPass);
	853	ExportRays(filename, contributingRays, mExportNumRays);
[1112]	854
[492]	855	}
	856
	857
[467]	858	// add rays to the tree after the viewcells have been cast to have their contributions
	859	// already when adding into the tree
	860	// do not add those rays which have too low or no contribution....
[466]	861
[467]	862	if (mUseImportanceSampling) {
[563]	863	mRssTree->AddRays(vssRays);
[467]	864
	865	if (mUpdateSubdivision) {
[492]	866	int updatePasses = 1;
	867	if (mPass % updatePasses == 0) {
[563]	868	int subdivided = mRssTree->UpdateSubdivision();
[492]	869	cout<<"subdivided leafs = "<<subdivided<<endl;
[563]	870	cout<<"#total leaves = "<<mRssTree->stat.Leaves()<<endl;
[492]	871	}
[467]	872	}
[447]	873	}
[467]	874
[464]	875	if (mExportPvs) {
[447]	876	char filename[64];
[467]	877	sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
[563]	878	ExportPvs(filename, mRssTree);
[447]	879	}
[492]	880
[563]	881
[1199]	882	if (!mUseImportanceSampling)
[492]	883	CLEAR_CONTAINER(vssRays);
[563]	884	// otherwise the rays get deleted by the rss tree update according to RssTree.maxRays ....
[492]	885
[467]	886	if (totalSamples >= mRssSamples + mInitialSamples)
[447]	887	break;
	888
	889
[467]	890	rssPass++;
	891	mPass++;
[563]	892	mRssTree->SetPass(mPass);
[447]	893	}
	894
[464]	895	if (mUseViewcells) {
[466]	896
[1199]	897	if(0)
[574]	898	{
[1199]	899	VssRayContainer selectedRays;
	900	int desired = mViewCellsManager->GetVisualizationSamples();
	901
	902	mVssRays.SelectRays(desired, selectedRays);
	903
	904	mViewCellsManager->Visualize(mObjects, selectedRays);
[574]	905	}
[556]	906
[1199]	907	// view cells after sampling
	908	mViewCellsManager->PrintStatistics(Debug);
	909
	910	//-- render simulation after merge
	911	cout << "\nevaluating bsp view cells render time after sampling ... ";
	912
	913	mRenderSimulator->RenderScene();
	914	SimulationStatistics ss;
	915	mRenderSimulator->GetStatistics(ss);
	916
	917	cout << " finished" << endl;
	918	cout << ss << endl;
	919	Debug << ss << endl;
	920
[466]	921	}
[1112]	922
	923
	924	if (mExportRays && mUseImportanceSampling) {
	925	char filename[64];
	926	sprintf(filename, "rss-rays-i.x3d");
	927
	928	rayBuffer.resize(mPass);
	929	ExportRayAnimation(filename, rayBuffer);
	930	}
	931
[563]	932	Debug<<"Deleting RSS tree...\n";
	933	delete mRssTree;
	934	Debug<<"Done.\n";
[466]	935
[859]	936
[1199]	937	//mViewCellsManager->ExportViewCells("visibility.xml",
[871]	938	// true);
[447]	939
[871]	940
[447]	941	return true;
	942	}
	943
[871]	944	}

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

Download in other formats: