提交scripts
This commit is contained in:
hesuicong committed
1 parent
82caf72036
commit
07dabbd186
224 files changed
+130146
No files matched your search
@@ -0,0 +1,823 @@
|
||||
/*
|
||||
* 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; }
|
||||
}
|
||||
}
|
||||
/*----------------------------------------------------------------*/
|
||||
Reference in new issue
Block a user