C++ Octree::Build方法代码示例

void TestOctree()
{
	std::vector<vgl_point_3d<double> > Points;
	Points.push_back(vgl_point_3d<double>(1.0, 0.0, 0.0));
	Points.push_back(vgl_point_3d<double>(0.0, 0.0, 0.0));
	Points.push_back(vgl_point_3d<double>(0.0, 1.0, 0.0));
	
	std::vector<std::vector<unsigned int> > VertexLists;
	std::vector<unsigned int> VertexList;
	VertexList.push_back(0);
	VertexList.push_back(1);
	VertexList.push_back(2);
	VertexLists.push_back(VertexList);
	
	Octree Tree;
	Tree.Build(Points, VertexLists);
	
	OrientedPoint Intersection;
	Ray R(vgl_point_3d<double>(0.5, 0.5, -1.0), vgl_vector_3d<double> (0.0, 0.0, 1.0));
	bool intersect = Tree.IntersectRay(R, Intersection);
	
	std::cout << "Intersect? " << intersect << std::endl;
	if(intersect)
		std::cout << "Intersection: " << Intersection << std::endl;
}

void Processor::Process(void)
{
	for (int n = 0 ; n < 1 && this->ProcessFrame() ; ++n)
	{
		std::cout << "Computing visible voxels..." << std::endl;

		// Update the visible voxels
		this->m_Reconstructor.Update();

		std::cout << "Computed visible voxels" << std::endl;

		const unsigned int numVisibleVoxels = this->m_Reconstructor.GetNumVisibleVoxels();
		VisibleVoxel* visibleVoxels = this->m_Reconstructor.GetVisibleVoxels();

		std::cout << "Number of visible voxels: " << numVisibleVoxels << std::endl;
		std::cout << "Memory usage: " << (numVisibleVoxels * sizeof(VisibleVoxel)) / 1000000 << "MB" << std::endl;

		std::cout << "Determining boundaries..." << std::endl;

		// Find bounds
		glm::vec3 min = {0.0f, 0.0f, 0.0f};
		glm::vec3 max = {0.0f, 0.0f, 0.0f};
		glm::vec3 cellSize = {1.0f, 1.0f, 1.0f};
		for (int i = 0 ; i < numVisibleVoxels ; ++i)
		{
			VisibleVoxel &v = visibleVoxels[i];

			min[0] = v.X < min[0] ? v.X : min[0]; max[0] = v.X > max[0] ? v.X : max[0];
			min[1] = v.X < min[1] ? v.X : min[1]; max[1] = v.X > max[1] ? v.X : max[1];
			min[2] = v.X < min[2] ? v.X : min[2]; max[2] = v.X > max[2] ? v.X : max[2];
		}

		std::cout << "Boundaries are: (" << min[0] << ", " << min[1] << ", " << min[2] << ") -> (" << max[0] << ", " << max[1] << ", " << max[2] << ")" << std::endl;

		std::cout << "Adding voxels to octree..." << std::endl;

		Octree *octree = new Octree(glm::vec3(0, 0, 0), max);
		octree->SetVoxels(visibleVoxels);
		octree->SetNumVoxels(numVisibleVoxels);

		std::cout << "Building octree..." << std::endl;

		std::chrono::system_clock::time_point start = std::chrono::high_resolution_clock::now();
		octree->Build();
		std::chrono::duration<float> b = std::chrono::system_clock::now().time_since_epoch();
		std::chrono::system_clock::time_point end = std::chrono::high_resolution_clock::now();
		std::chrono::duration<double> diff = end - start;
		std::cout << "Spent " << diff.count() * 1000 << " milliseconds" << std::endl;

		std::cout << "Number of nodes: " << octree->GetNumNodes() << std::endl;
		std::cout << "Memory usage: " << float(octree->GetNumNodes() * sizeof(OctreeNode)) / 1000000 << "MB" << std::endl;

		std::cout << "Compressing..." << std::endl;
		this->m_Compressor->Compress(octree);

		delete octree;
		
		std::cout << "Done, next frame!" << std::endl;
	}

	std::cout << "Done processing!" << std::endl;
}

void AmbientOcclusionApp::BuildVertexAmbientOcclusion(
	std::vector<Vertex::AmbientOcclusion>& vertices,
	const std::vector<UINT>& indices)
{
	UINT vcount = vertices.size();
	UINT tcount = indices.size()/3;

	std::vector<XMFLOAT3> positions(vcount);
	for(UINT i = 0; i < vcount; ++i)
		positions[i] = vertices[i].Pos;

	Octree octree;
	octree.Build(positions, indices);

	// For each vertex, count how many triangles contain the vertex.
	std::vector<int> vertexSharedCount(vcount);
	for(UINT i = 0; i < tcount; ++i)
	{
		UINT i0 = indices[i*3+0];
		UINT i1 = indices[i*3+1];
		UINT i2 = indices[i*3+2];

		XMVECTOR v0 = XMLoadFloat3(&vertices[i0].Pos);
		XMVECTOR v1 = XMLoadFloat3(&vertices[i1].Pos);
		XMVECTOR v2 = XMLoadFloat3(&vertices[i2].Pos);

		XMVECTOR edge0 = v1 - v0;
		XMVECTOR edge1 = v2 - v0;

		XMVECTOR normal = XMVector3Normalize(XMVector3Cross(edge0, edge1));

		XMVECTOR centroid = (v0 + v1 + v2)/3.0f;

		// Offset to avoid self intersection.
		centroid += 0.001f*normal;

		const int NumSampleRays = 32;
		float numUnoccluded = 0;
		for(int j = 0; j < NumSampleRays; ++j)
		{
			XMVECTOR randomDir = MathHelper::RandHemisphereUnitVec3(normal);

			// TODO: Technically we should not count intersections that are far 
			// away as occluding the triangle, but this is OK for demo.
			if( !octree.RayOctreeIntersect(centroid, randomDir) )
			{
				numUnoccluded++;
			}
		}
		
		float ambientAccess = numUnoccluded / NumSampleRays;

		// Average with vertices that share this face.
		vertices[i0].AmbientAccess += ambientAccess;
		vertices[i1].AmbientAccess += ambientAccess;
		vertices[i2].AmbientAccess += ambientAccess;

		vertexSharedCount[i0]++;
		vertexSharedCount[i1]++;
		vertexSharedCount[i2]++;
	}

	// Finish average by dividing by the number of samples we added.
	for(UINT i = 0; i < vcount; ++i)
	{
		vertices[i].AmbientAccess /= vertexSharedCount[i];
	}
}