openMVS/apps/Viewer/Scene.cpp

/*
 * Scene.cpp
 *
 * Copyright (c) 2014-2015 SEACAVE
 *
 * Author(s):
 *
 *      cDc <cdc.seacave@gmail.com>
 *
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Additional Terms:
 *
 *      You are required to preserve legal notices and author attributions in
 *      that material or in the Appropriate Legal Notices displayed by works
 *      containing it.
 */

#include "Common.h"
#include "Scene.h"

using namespace VIEWER;


// D E F I N E S ///////////////////////////////////////////////////

#define IMAGE_MAX_RESOLUTION 1024


// S T R U C T S ///////////////////////////////////////////////////

enum EVENT_TYPE {
	EVT_JOB = 0,
	EVT_CLOSE,
};

class EVTClose : public Event
{
public:
	EVTClose() : Event(EVT_CLOSE) {}
};
class EVTLoadImage : public Event
{
public:
	Scene* pScene;
	MVS::IIndex idx;
	unsigned nMaxResolution;
	bool Run(void*) {
		Image& image = pScene->images[idx];
		ASSERT(image.idx != NO_ID);
		MVS::Image& imageData = pScene->scene.images[image.idx];
		ASSERT(imageData.IsValid());
		if (imageData.image.empty() && !imageData.ReloadImage(nMaxResolution))
			return false;
		imageData.UpdateCamera(pScene->scene.platforms);
		image.AssignImage(imageData.image);
		imageData.ReleaseImage();
		glfwPostEmptyEvent();
		return true;
	}
	EVTLoadImage(Scene* _pScene, MVS::IIndex _idx, unsigned _nMaxResolution=0)
		: Event(EVT_JOB), pScene(_pScene), idx(_idx), nMaxResolution(_nMaxResolution) {}
};
class EVTComputeOctree : public Event
{
public:
	Scene* pScene;
	bool Run(void*) {
		MVS::Scene& scene = pScene->scene;
		if (!scene.mesh.IsEmpty()) {
			Scene::OctreeMesh octMesh(scene.mesh.vertices, [](Scene::OctreeMesh::IDX_TYPE size, Scene::OctreeMesh::Type /*radius*/) {
				return size > 256;
			});
			scene.mesh.ListIncidenteFaces();
			pScene->octMesh.Swap(octMesh);
		} else
		if (!scene.pointcloud.IsEmpty()) {
			Scene::OctreePoints octPoints(scene.pointcloud.points, [](Scene::OctreePoints::IDX_TYPE size, Scene::OctreePoints::Type /*radius*/) {
				return size > 512;
			});
			pScene->octPoints.Swap(octPoints);
		}
		return true;
	}
	EVTComputeOctree(Scene* _pScene)
		: Event(EVT_JOB), pScene(_pScene) {}
};

void* Scene::ThreadWorker(void*) {
	while (true) {
		CAutoPtr<Event> evt(events.GetEvent());
		switch (evt->GetID()) {
		case EVT_JOB:
			evt->Run();
			break;
		case EVT_CLOSE:
			return NULL;
		default:
			ASSERT("Should not happen!" == NULL);
		}
	}
	return NULL;
}
/*----------------------------------------------------------------*/


// S T R U C T S ///////////////////////////////////////////////////

SEACAVE::EventQueue Scene::events;
SEACAVE::Thread Scene::thread;

Scene::Scene(ARCHIVE_TYPE _nArchiveType)
	:
	nArchiveType(_nArchiveType),
	listPointCloud(0)
{
}
Scene::~Scene()
{
	Release();
}

void Scene::Empty()
{
	ReleasePointCloud();
	ReleaseMesh();
	obbPoints.Release();
	if (window.IsValid()) {
		window.ReleaseClbk();
		window.Reset();
		window.SetName(_T("(empty)"));
	}
	textures.Release();
	images.Release();
	scene.Release();
	sceneName.clear();
	geometryName.clear();
}
void Scene::Release()
{
	if (window.IsValid())
		window.SetVisible(false);
	if (!thread.isRunning()) {
		events.AddEvent(new EVTClose());
		thread.join();
	}
	Empty();
	window.Release();
	glfwTerminate();
}
void Scene::ReleasePointCloud()
{
	if (listPointCloud) {
		glDeleteLists(listPointCloud, 1);
		listPointCloud = 0;
	}
}
void Scene::ReleaseMesh()
{
	if (!listMeshes.empty()) {
		for (GLuint listMesh: listMeshes)
			glDeleteLists(listMesh, 1);
		listMeshes.Release();
	}
}

bool Scene::Init(const cv::Size& size, LPCTSTR windowName, LPCTSTR fileName, LPCTSTR geometryFileName)
{
	ASSERT(scene.IsEmpty());

	// init window
	if (glfwInit() == GL_FALSE)
		return false;
	if (!window.Init(size, windowName))
		return false;
	if (glewInit() != GLEW_OK)
		return false;
	name = windowName;
	window.clbkOpenScene = DELEGATEBINDCLASS(Window::ClbkOpenScene, &Scene::Open, this);

	// init OpenGL
	glPolygonMode(GL_FRONT, GL_FILL);
	glEnable(GL_DEPTH_TEST);
	glClearColor(0.f, 0.5f, 0.9f, 1.f);

	static const float light0_ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
	static const float light0_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
	static const float light0_position[] = {0.0f, 0.0f, 1000.0f, 0.0f};
	static const float light0_specular[] = {0.4f, 0.4f, 0.4f, 1.0f};

	glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
	glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
	glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);

	glEnable(GL_LIGHT0);
	glDisable(GL_LIGHTING);

	// init working thread
	thread.start(ThreadWorker);

	// open scene or init empty scene
	window.SetCamera(Camera());
	if (fileName != NULL)
		Open(fileName, geometryFileName);
	window.SetVisible(true);
	return true;
}
bool Scene::Open(LPCTSTR fileName, LPCTSTR geometryFileName)
{
	ASSERT(fileName);
	DEBUG_EXTRA("Loading: '%s'", Util::getFileNameExt(fileName).c_str());
	Empty();
	sceneName = fileName;

	// load the scene
	WORKING_FOLDER = Util::getFilePath(fileName);
	INIT_WORKING_FOLDER;
	if (!scene.Load(fileName, true))
		return false;
	if (geometryFileName) {
		// try to load given mesh
		MVS::Mesh mesh;
		MVS::PointCloud pointcloud;
		if (mesh.Load(geometryFileName)) {
			scene.mesh.Swap(mesh);
			geometryName = geometryFileName;
			geometryMesh = true;
		} else
		// try to load as a point-cloud
		if (pointcloud.Load(geometryFileName)) {
			scene.pointcloud.Swap(pointcloud);
			geometryName = geometryFileName;
			geometryMesh = false;
		}
	}
	if (!scene.pointcloud.IsEmpty())
		scene.pointcloud.PrintStatistics(scene.images.data(), &scene.obb);

	#if 1
	// create octree structure used to accelerate selection functionality
	if (!scene.IsEmpty())
		events.AddEvent(new EVTComputeOctree(this));
	#endif

	// init scene
	AABB3d bounds(true);
	Point3d center(Point3d::INF);
	if (scene.IsBounded()) {
		bounds = AABB3d(scene.obb.GetAABB());
		center = bounds.GetCenter();
	} else {
		if (!scene.pointcloud.IsEmpty()) {
			bounds = scene.pointcloud.GetAABB(MINF(3u,scene.nCalibratedImages));
			if (bounds.IsEmpty())
				bounds = scene.pointcloud.GetAABB();
			center = scene.pointcloud.GetCenter();
		}
		if (!scene.mesh.IsEmpty()) {
			scene.mesh.ComputeNormalFaces();
			bounds.Insert(scene.mesh.GetAABB());
			center = scene.mesh.GetCenter();
		}
	}

	// init images
	AABB3d imageBounds(true);
	images.Reserve(scene.images.size());
	FOREACH(idxImage, scene.images) {
		const MVS::Image& imageData = scene.images[idxImage];
		if (!imageData.IsValid())
			continue;
		images.emplace_back(idxImage);
		imageBounds.InsertFull(imageData.camera.C);
	}
	if (imageBounds.IsEmpty())
		imageBounds.Enlarge(0.5);
	if (bounds.IsEmpty())
		bounds = imageBounds;

	// init and load texture
	if (scene.mesh.HasTexture()) {
		FOREACH(i, scene.mesh.texturesDiffuse) {
			Image& image = textures.emplace_back();
			ASSERT(image.idx == NO_ID);
			#if 0
			Image8U3& textureDiffuse = scene.mesh.texturesDiffuse[i];
			cv::flip(textureDiffuse, textureDiffuse, 0);
			image.SetImage(textureDiffuse);
			textureDiffuse.release();
			#else // preserve texture, used only to be able to export the mesh
			Image8U3 textureDiffuse;
			cv::flip(scene.mesh.texturesDiffuse[i], textureDiffuse, 0);
			image.SetImage(textureDiffuse);
			#endif
			image.GenerateMipmap();
		}
	}

	// init display lists
	// compile point-cloud
	CompilePointCloud();
	// compile mesh
	CompileMesh();
	// compile bounding-box
	CompileBounds();

	// init camera
	window.SetCamera(Camera(bounds,
		center == Point3d::INF ? Point3d(bounds.GetCenter()) : center,
		images.size()<2?1.f:(float)imageBounds.EnlargePercent(REAL(1)/images.size()).GetSize().norm()));
	window.camera.maxCamID = images.size();
	window.SetName(String::FormatString((name + _T(": %s")).c_str(), Util::getFileName(fileName).c_str()));
	window.clbkSaveScene = DELEGATEBINDCLASS(Window::ClbkSaveScene, &Scene::Save, this);
	window.clbkExportScene = DELEGATEBINDCLASS(Window::ClbkExportScene, &Scene::Export, this);
	window.clbkCenterScene = DELEGATEBINDCLASS(Window::ClbkCenterScene, &Scene::Center, this);
	window.clbkCompilePointCloud = DELEGATEBINDCLASS(Window::ClbkCompilePointCloud, &Scene::CompilePointCloud, this);
	window.clbkCompileMesh = DELEGATEBINDCLASS(Window::ClbkCompileMesh, &Scene::CompileMesh, this);
	window.clbkTogleSceneBox = DELEGATEBINDCLASS(Window::ClbkTogleSceneBox, &Scene::TogleSceneBox, this);
	window.clbkCropToBounds = DELEGATEBINDCLASS(Window::ClbkCropToBounds, &Scene::CropToBounds, this);
	if (scene.IsBounded())
		window.clbkCompileBounds = DELEGATEBINDCLASS(Window::ClbkCompileBounds, &Scene::CompileBounds, this);
	if (!scene.IsEmpty())
		window.clbkRayScene = DELEGATEBINDCLASS(Window::ClbkRayScene, &Scene::CastRay, this);
	window.Reset(!scene.pointcloud.IsEmpty()&&!scene.mesh.IsEmpty()?Window::SPR_NONE:Window::SPR_ALL,
		MINF(2u,images.size()));
	return true;
}

// export the scene
bool Scene::Save(LPCTSTR _fileName, bool bRescaleImages)
{
	if (!IsOpen())
		return false;
	REAL imageScale = 0;
	if (bRescaleImages) {
		window.SetVisible(false);
		std::cout << "Enter image resolution scale: ";
		String strScale;
		std::cin >> strScale;
		window.SetVisible(true);
		imageScale = strScale.From<REAL>(0);
	}
	const String fileName(_fileName != NULL ? String(_fileName) : Util::insertBeforeFileExt(sceneName, _T("_new")));
	MVS::Mesh mesh;
	if (!scene.mesh.IsEmpty() && !geometryName.empty() && geometryMesh)
		mesh.Swap(scene.mesh);
	MVS::PointCloud pointcloud;
	if (!scene.pointcloud.IsEmpty() && !geometryName.empty() && !geometryMesh)
		pointcloud.Swap(scene.pointcloud);
	if (imageScale > 0 && imageScale < 1) {
		// scale and save images
		const String folderName(Util::getFilePath(MAKE_PATH_FULL(WORKING_FOLDER_FULL, fileName)) + String::FormatString("images%d" PATH_SEPARATOR_STR, ROUND2INT(imageScale*100)));
		if (!scene.ScaleImages(0, imageScale, folderName)) {
			DEBUG("error: can not scale scene images to '%s'", folderName.c_str());
			return false;
		}
	}
	if (!scene.Save(fileName, nArchiveType)) {
		DEBUG("error: can not save scene to '%s'", fileName.c_str());
		return false;
	}
	if (!mesh.IsEmpty())
		scene.mesh.Swap(mesh);
	if (!pointcloud.IsEmpty())
		scene.pointcloud.Swap(pointcloud);
	sceneName = fileName;
	return true;
}

// export the scene
bool Scene::Export(LPCTSTR _fileName, LPCTSTR exportType) const
{
	if (!IsOpen())
		return false;
	ASSERT(!sceneName.IsEmpty());
	String lastFileName;
	const String fileName(_fileName != NULL ? String(_fileName) : sceneName);
	const String baseFileName(Util::getFileFullName(fileName));
	const bool bPoints(scene.pointcloud.Save(lastFileName=(baseFileName+_T("_pointcloud.ply")), nArchiveType==ARCHIVE_MVS));
	const bool bMesh(scene.mesh.Save(lastFileName=(baseFileName+_T("_mesh")+(exportType?exportType:(Util::getFileExt(fileName)==_T(".obj")?_T(".obj"):_T(".ply")))), cList<String>(), true));
	#if TD_VERBOSE != TD_VERBOSE_OFF
	if (VERBOSITY_LEVEL > 2 && (bPoints || bMesh))
		scene.ExportCamerasMLP(Util::getFileFullName(lastFileName)+_T(".mlp"), lastFileName);
	#endif
	AABB3f aabb(true);
	if (scene.IsBounded()) {
		std::ofstream fs(baseFileName+_T("_roi.txt"));
		if (fs)
			fs << scene.obb;
		aabb = scene.obb.GetAABB();
	} else
	if (!scene.pointcloud.IsEmpty()) {
		aabb = scene.pointcloud.GetAABB();
	} else
	if (!scene.mesh.IsEmpty()) {
		aabb = scene.mesh.GetAABB();
	}
	if (!aabb.IsEmpty()) {
		std::ofstream fs(baseFileName+_T("_roi_box.txt"));
		if (fs)
			fs << aabb;
	}
	return bPoints || bMesh;
}

void Scene::CompilePointCloud()
{
	if (scene.pointcloud.IsEmpty())
		return;
	ReleasePointCloud();
	listPointCloud = glGenLists(1);
	glNewList(listPointCloud, GL_COMPILE);
	ASSERT((window.sparseType&(Window::SPR_POINTS|Window::SPR_LINES)) != 0);
	// compile point-cloud
	if ((window.sparseType&Window::SPR_POINTS) != 0) {
		ASSERT_ARE_SAME_TYPE(float, MVS::PointCloud::Point::Type);
		glBegin(GL_POINTS);
		glColor3f(1.f,1.f,1.f);
		FOREACH(i, scene.pointcloud.points) {
			if (!scene.pointcloud.pointViews.empty() &&
				scene.pointcloud.pointViews[i].size() < window.minViews)
				continue;
			if (!scene.pointcloud.colors.empty()) {
				const MVS::PointCloud::Color& c = scene.pointcloud.colors[i];
				glColor3ub(c.r,c.g,c.b);
			}
			const MVS::PointCloud::Point& X = scene.pointcloud.points[i];
			glVertex3fv(X.ptr());
		}
		glEnd();
	}
	glEndList();
}

void Scene::CompileMesh()
{
	if (scene.mesh.IsEmpty())
		return;
	ReleaseMesh();
	if (scene.mesh.faceNormals.empty())
		scene.mesh.ComputeNormalFaces();
	// translate, normalize and flip Y axis of the texture coordinates
	MVS::Mesh::TexCoordArr normFaceTexcoords;
	if (scene.mesh.HasTexture() && window.bRenderTexture)
		scene.mesh.FaceTexcoordsNormalize(normFaceTexcoords, true);
	MVS::Mesh::TexIndex texIdx(0);
	do {
		GLuint& listMesh = listMeshes.emplace_back(glGenLists(1));
		listMesh = glGenLists(1);
		glNewList(listMesh, GL_COMPILE);
		// compile mesh
		ASSERT_ARE_SAME_TYPE(float, MVS::Mesh::Vertex::Type);
		ASSERT_ARE_SAME_TYPE(float, MVS::Mesh::Normal::Type);
		ASSERT_ARE_SAME_TYPE(float, MVS::Mesh::TexCoord::Type);
		glColor3f(1.f, 1.f, 1.f);
		glBegin(GL_TRIANGLES);
		FOREACH(idxFace, scene.mesh.faces) {
			if (!scene.mesh.faceTexindices.empty() && scene.mesh.faceTexindices[idxFace] != texIdx)
				continue;
			const MVS::Mesh::Face& face = scene.mesh.faces[idxFace];
			const MVS::Mesh::Normal& n = scene.mesh.faceNormals[idxFace];
			glNormal3fv(n.ptr());
			for (int j = 0; j < 3; ++j) {
				if (!normFaceTexcoords.empty()) {
					const MVS::Mesh::TexCoord& t = normFaceTexcoords[idxFace*3 + j];
					glTexCoord2fv(t.ptr());
				}
				const MVS::Mesh::Vertex& p = scene.mesh.vertices[face[j]];
				glVertex3fv(p.ptr());
			}
		}
		glEnd();
		glEndList();
	} while (++texIdx < scene.mesh.texturesDiffuse.size());
}

void Scene::CompileBounds()
{
	obbPoints.Release();
	if (!scene.IsBounded()) {
		window.bRenderBounds = false;
		return;
	}
	window.bRenderBounds = !window.bRenderBounds;
	if (window.bRenderBounds) {
		static const uint8_t indices[12*2] = {
			0,2, 2,3, 3,1, 1,0,
			0,6, 2,4, 3,5, 1,7,
			6,4, 4,5, 5,7, 7,6
		};
		OBB3f::POINT corners[OBB3f::numCorners];
		scene.obb.GetCorners(corners);
		for (int i=0; i<12; ++i) {
			obbPoints.emplace_back(corners[indices[i*2+0]]);
			obbPoints.emplace_back(corners[indices[i*2+1]]);
		}
	}
}

void Scene::CropToBounds()
{
	if (!IsOpen())
		return;
	if (!scene.IsBounded())
		return;
	scene.pointcloud.RemovePointsOutside(scene.obb);
	scene.mesh.RemoveFacesOutside(scene.obb);
	Center();
}

void Scene::Draw()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPointSize(window.pointSize);

	// render point-cloud
	if (listPointCloud) {
		glDisable(GL_TEXTURE_2D);
		glCallList(listPointCloud);
	}
	// render mesh
	if (!listMeshes.empty()) {
		glEnable(GL_DEPTH_TEST);
		glEnable(GL_CULL_FACE);
		if (!scene.mesh.faceTexcoords.empty() && window.bRenderTexture) {
			glEnable(GL_TEXTURE_2D);
			FOREACH(i, listMeshes) {
				textures[i].Bind();
				glCallList(listMeshes[i]);
			}
			glDisable(GL_TEXTURE_2D);
		} else {
			glEnable(GL_LIGHTING);
			for (GLuint listMesh: listMeshes)
				glCallList(listMesh);
			glDisable(GL_LIGHTING);
		}
	}
	// render cameras
	if (window.bRenderCameras) {
		glDisable(GL_CULL_FACE);
		const Point3* ptrPrevC(NULL);
		FOREACH(idx, images) {
			Image& image = images[idx];
			const MVS::Image& imageData = scene.images[image.idx];
			const MVS::Camera& camera = imageData.camera;
			// cache image corner coordinates
			const double scaleFocal(window.camera.scaleF);
			const Point2d pp(camera.GetPrincipalPoint());
			const double focal(camera.GetFocalLength()/scaleFocal);
			const double cx(-pp.x/focal);
			const double cy(-pp.y/focal);
			const double px((double)imageData.width/focal+cx);
			const double py((double)imageData.height/focal+cy);
			const Point3d ic1(cx, cy, scaleFocal);
			const Point3d ic2(cx, py, scaleFocal);
			const Point3d ic3(px, py, scaleFocal);
			const Point3d ic4(px, cy, scaleFocal);
			// change coordinates system to the camera space
			glPushMatrix();
			glMultMatrixd((GLdouble*)TransL2W((const Matrix3x3::EMat)camera.R, -(const Point3::EVec)camera.C).data());
			glPointSize(window.pointSize+1.f);
			glDisable(GL_TEXTURE_2D);
			// draw camera position and image center
			glBegin(GL_POINTS);
			glColor3f(1,0,0); glVertex3f(0,0,0); // camera position
			glColor3f(0,1,0); glVertex3f(0,0,(float)scaleFocal); // image center
			glColor3f(0,0,1); glVertex3d((0.5*imageData.width-pp.x)/focal, cy, scaleFocal); // image up
			glEnd();
			// draw image thumbnail
			const bool bSelectedImage(idx == window.camera.currentCamID);
			if (bSelectedImage) {
				if (image.IsValid()) {
					// render image
					glEnable(GL_TEXTURE_2D);
					image.Bind();
					glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
					glEnable(GL_BLEND);
					glDisable(GL_DEPTH_TEST);
					glColor4f(1,1,1,window.cameraBlend);
					glBegin(GL_QUADS);
					glTexCoord2d(0,0); glVertex3dv(ic1.ptr());
					glTexCoord2d(0,1); glVertex3dv(ic2.ptr());
					glTexCoord2d(1,1); glVertex3dv(ic3.ptr());
					glTexCoord2d(1,0); glVertex3dv(ic4.ptr());
					glEnd();
					glDisable(GL_TEXTURE_2D);
					glDisable(GL_BLEND);
					glEnable(GL_DEPTH_TEST);
				} else {
					// start and wait to load the image
					if (image.IsImageEmpty()) {
						// start loading
						image.SetImageLoading();
						events.AddEvent(new EVTLoadImage(this, idx, IMAGE_MAX_RESOLUTION));
					} else {
						// check if the image is available and set it
						image.TransferImage();
					}
				}
			}
			// draw camera frame
			glColor3f(bSelectedImage ? 0.f : 1.f, 1.f, 0.f);
			glBegin(GL_LINES);
			glVertex3d(0,0,0); glVertex3dv(ic1.ptr());
			glVertex3d(0,0,0); glVertex3dv(ic2.ptr());
			glVertex3d(0,0,0); glVertex3dv(ic3.ptr());
			glVertex3d(0,0,0); glVertex3dv(ic4.ptr());
			glVertex3dv(ic1.ptr()); glVertex3dv(ic2.ptr());
			glVertex3dv(ic2.ptr()); glVertex3dv(ic3.ptr());
			glVertex3dv(ic3.ptr()); glVertex3dv(ic4.ptr());
			glVertex3dv(ic4.ptr()); glVertex3dv(ic1.ptr());
			glEnd();
			// restore coordinate system
			glPopMatrix();
			// render image visibility info
			if (window.bRenderImageVisibility && idx != NO_ID && idx==window.camera.currentCamID) {
				if (scene.pointcloud.IsValid()) {
					const Image& image = images[idx];
					glPointSize(window.pointSize*1.1f);
					glDisable(GL_DEPTH_TEST);
					glBegin(GL_POINTS);
					glColor3f(1.f,0.f,0.f);
					FOREACH(i, scene.pointcloud.points) {
						ASSERT(!scene.pointcloud.pointViews[i].empty());
						if (scene.pointcloud.pointViews[i].size() < window.minViews)
							continue;
						if (scene.pointcloud.pointViews[i].FindFirst(image.idx) == MVS::PointCloud::ViewArr::NO_INDEX)
							continue;
						glVertex3fv(scene.pointcloud.points[i].ptr());
					}
					glEnd();
					glEnable(GL_DEPTH_TEST);
					glPointSize(window.pointSize);
				}
			}
			// render camera trajectory
			if (window.bRenderCameraTrajectory && ptrPrevC) {
				glBegin(GL_LINES);
				glColor3f(1.f,0.5f,0.f);
				glVertex3dv(ptrPrevC->ptr());
				glVertex3dv(camera.C.ptr());
				glEnd();
			}
			ptrPrevC = &camera.C;
		}
	}
	// render selection
	if (window.selectionType != Window::SEL_NA) {
		glPointSize(window.pointSize+4);
		glDisable(GL_DEPTH_TEST);
		glBegin(GL_POINTS);
		glColor3f(1,0,0); glVertex3fv(window.selectionPoints[0].ptr());
		if (window.selectionType == Window::SEL_TRIANGLE) {
		glColor3f(0,1,0); glVertex3fv(window.selectionPoints[1].ptr());
		glColor3f(0,0,1); glVertex3fv(window.selectionPoints[2].ptr());
		}
		glEnd();
		if (window.bRenderViews && window.selectionType == Window::SEL_POINT) {
			if (!scene.pointcloud.pointViews.empty()) {
				glBegin(GL_LINES);
				const MVS::PointCloud::ViewArr& views = scene.pointcloud.pointViews[(MVS::PointCloud::Index)window.selectionIdx];
				ASSERT(!views.empty());
				for (MVS::PointCloud::View idxImage: views) {
					const MVS::Image& imageData = scene.images[idxImage];
					glVertex3dv(imageData.camera.C.ptr());
					glVertex3fv(window.selectionPoints[0].ptr());
				}
				glEnd();
			}
		}
		glEnable(GL_DEPTH_TEST);
		glPointSize(window.pointSize);
	}
	// render oriented-bounding-box
	if (!obbPoints.empty()) {
		glDepthMask(GL_FALSE);
		glBegin(GL_LINES);
		glColor3f(0.5f,0.1f,0.8f);
		for (IDX i=0; i<obbPoints.size(); i+=2) {
			glVertex3fv(obbPoints[i+0].ptr());
			glVertex3fv(obbPoints[i+1].ptr());
		}
		glEnd();
		glDepthMask(GL_TRUE);
	}
	glfwSwapBuffers(window.GetWindow());
}

void Scene::Loop()
{
	while (!glfwWindowShouldClose(window.GetWindow())) {
		window.UpdateView(images, scene.images);
		Draw();
		glfwWaitEvents();
	}
}


void Scene::Center()
{
	if (!IsOpen())
		return;
	scene.Center();
	CompilePointCloud();
	CompileMesh();
	if (scene.IsBounded()) {
		window.bRenderBounds = false;
		CompileBounds();
	}
	events.AddEvent(new EVTComputeOctree(this));
}

void Scene::TogleSceneBox()
{
	if (!IsOpen())
		return;
	const auto EnlargeAABB = [](AABB3f aabb) {
		return aabb.Enlarge(aabb.GetSize().maxCoeff()*0.03f);
	};
	if (scene.IsBounded())
		scene.obb = OBB3f(true);
	else if (!scene.mesh.IsEmpty())
		scene.obb.Set(EnlargeAABB(scene.mesh.GetAABB()));
	else if (!scene.pointcloud.IsEmpty())
		scene.obb.Set(EnlargeAABB(scene.pointcloud.GetAABB(window.minViews)));
	CompileBounds();
}


void Scene::CastRay(const Ray3& ray, int action)
{
	if (!IsOctreeValid())
		return;
	const double timeClick(0.2);
	const double timeDblClick(0.3);
	const double now(glfwGetTime());
	switch (action) {
	case GLFW_PRESS: {
		// remember when the click action started
		window.selectionTimeClick = now;
	break; }
	case GLFW_RELEASE: {
	if (now-window.selectionTimeClick > timeClick) {
		// this is a long click, ignore it
		break;
	} else
	if (window.selectionType != Window::SEL_NA &&
		now-window.selectionTime < timeDblClick) {
		// this is a double click, center scene at the selected point
		window.CenterCamera(window.selectionPoints[3]);
		window.selectionTime = now;
	} else
	if (!octMesh.IsEmpty()) {
		// find ray intersection with the mesh
		const MVS::IntersectRayMesh intRay(octMesh, ray, scene.mesh);
		if (intRay.pick.IsValid()) {
			const MVS::Mesh::Face& face = scene.mesh.faces[(MVS::Mesh::FIndex)intRay.pick.idx];
			window.selectionPoints[0] = scene.mesh.vertices[face[0]];
			window.selectionPoints[1] = scene.mesh.vertices[face[1]];
			window.selectionPoints[2] = scene.mesh.vertices[face[2]];
			window.selectionPoints[3] = ray.GetPoint(intRay.pick.dist).cast<float>();
			window.selectionType = Window::SEL_TRIANGLE;
			window.selectionTime = now;
			window.selectionIdx = intRay.pick.idx;
			DEBUG("Face selected:\n\tindex: %u\n\tvertex 1: %u (%g %g %g)\n\tvertex 2: %u (%g %g %g)\n\tvertex 3: %u (%g %g %g)",
				intRay.pick.idx,
				face[0], window.selectionPoints[0].x, window.selectionPoints[0].y, window.selectionPoints[0].z,
				face[1], window.selectionPoints[1].x, window.selectionPoints[1].y, window.selectionPoints[1].z,
				face[2], window.selectionPoints[2].x, window.selectionPoints[2].y, window.selectionPoints[2].z
			);
		} else {
			window.selectionType = Window::SEL_NA;
		}
	} else
	if (!octPoints.IsEmpty()) {
		// find ray intersection with the points
		const MVS::IntersectRayPoints intRay(octPoints, ray, scene.pointcloud, window.minViews);
		if (intRay.pick.IsValid()) {
			window.selectionPoints[0] = window.selectionPoints[3] = scene.pointcloud.points[intRay.pick.idx];
			window.selectionType = Window::SEL_POINT;
			window.selectionTime = now;
			window.selectionIdx = intRay.pick.idx;
			DEBUG("Point selected:\n\tindex: %u (%g %g %g)%s",
				intRay.pick.idx,
				window.selectionPoints[0].x, window.selectionPoints[0].y, window.selectionPoints[0].z,
				[&]() {
					if (scene.pointcloud.pointViews.empty())
						return String();
					const MVS::PointCloud::ViewArr& views = scene.pointcloud.pointViews[intRay.pick.idx];
					ASSERT(!views.empty());
					String strViews(String::FormatString("\n\tviews: %u", views.size()));
					for (MVS::PointCloud::View idxImage: views) {
						const MVS::Image& imageData = scene.images[idxImage];
						const Point2 x(imageData.camera.TransformPointW2I(Cast<REAL>(window.selectionPoints[0])));
						strViews += String::FormatString("\n\t\t%s (%.2f %.2f)", Util::getFileNameExt(imageData.name).c_str(), x.x, x.y);
					}
					return strViews;
				}().c_str()
			);
		} else {
			window.selectionType = Window::SEL_NA;
		}
	}
	break; }
	}
}
/*----------------------------------------------------------------*/