Merge pull request #10 from ClementPinard/generate_for_video

Use EGL whenever possible

Author: ClementPinard

CMakeLists.txt

@@ -19,6 +19,11 @@ endif()
 find_package(GMP REQUIRED)
 include_directories(${GMP_INCLUDE_DIRS})
 
+#OpenGL
+find_package(OpenGL REQUIRED)
+include_directories(${OPENGL_INCLUDE_DIRS})
+link_directories(${OPENGL_LIBRARY_DIRS})
+
 # GLEW
 find_package(GLEW REQUIRED)
 include_directories(${GLEW_INCLUDE_DIRS})
@@ -113,7 +118,7 @@ add_library(BaseLib
   src/opengl/renderer.cc
   src/opengl/mesh.cc
   src/opengl/opengl_util.cc
-  src/opengl/opengl_util_glx.cc
+  src/opengl/opengl_util_egl.cc
   src/opengl/shader_program_opengl.cc
 
   src/opt/color_optimizer.cc
@@ -131,7 +136,9 @@ add_library(BaseLib
   src/opt/visibility_estimator.cc
 )
 target_link_libraries(BaseLib
-  ${OpenCV_LIBS})
+  ${OpenCV_LIBS}
+  OpenGL::OpenGL
+  OpenGL::EGL)
 target_compile_options(BaseLib PRIVATE -Wno-sign-compare)
 set(BASE_LIB_LIBRARIES
   BaseLib
@@ -140,8 +147,8 @@ set(BASE_LIB_LIBRARIES
   ${PCL_LIBRARIES}
   glog
   ${GLEW_LIBRARIES}
-  GL
-  X11
+  OpenGL::OpenGL
+  OpenGL::EGL
 )
 
 
@@ -363,4 +370,4 @@ target_link_libraries(Test_IntrinsicsAndPoseOptimizer
 target_compile_options(Test_IntrinsicsAndPoseOptimizer PRIVATE -Wno-sign-compare)
 add_test(Test_IntrinsicsAndPoseOptimizer
   Test_IntrinsicsAndPoseOptimizer
-)
+)

Dockerfile

@@ -33,15 +33,13 @@ RUN rm -rf build \
 ENV PIPELINE_PATH=/dataset-pipeline/build
 
 # Tests
-# Test_Alignment and Test_Renderer need an X server
-# so we cannot run the tests on docker
 
-# RUN ${PIPELINE_PATH}/Test_Alignment
+RUN cd ${PIPELINE_PATH} && ./Test_Alignment
 RUN ${PIPELINE_PATH}/Test_Camera
 RUN ${PIPELINE_PATH}/Test_ICP
 RUN ${PIPELINE_PATH}/Test_Interpolation
 RUN ${PIPELINE_PATH}/Test_IntrinsicsAndPoseOptimizer
 RUN ${PIPELINE_PATH}/Test_MultiScalePointCloud
 RUN ${PIPELINE_PATH}/Test_Problem
-# RUN ${PIPELINE_PATH}/Test_Renderer
+RUN ${PIPELINE_PATH}/Test_Renderer
 

src/opengl/opengl_util.cc

@@ -28,7 +28,7 @@
 
 
 #include "opengl/opengl_util.h"
-#include "opengl/opengl_util_glx.h"
+#include "opengl/opengl_util_egl.h"
 
 #include <glog/logging.h>
 

src/opengl/opengl_util.h

@@ -53,11 +53,14 @@ struct OpenGLContext {
 // versions 1, 2, and 3. On Linux, no specific version is requested.
 bool InitializeOpenGLWindowless(int version, OpenGLContext* result);
 
-// Switches the current thread's OpenGL context to the given context, and
+// Switches the current thread's OpenGL context to the given EGL context, and
 // returns the previously active context. One context can be current to only
 // one thread at a time.
 OpenGLContext SwitchOpenGLContext(const OpenGLContext& context);
 
+// Make a void EGL context, so that a GLX context can take over, e.g. in a QOpenGLWidget
+void releaseOpenGLContext();
+
 // Tests whether a valid OpenGL context is current.
 bool IsOpenGLContextAvailable();
 

src/opengl/opengl_util_glx.cc renamed to src/opengl/opengl_util_egl.cc

@@ -28,77 +28,86 @@
 
 
 #include "opengl/opengl_util.h"
-#include "opengl/opengl_util_glx.h"
+#include "opengl/opengl_util_egl.h"
 
 #include <glog/logging.h>
 
 namespace opengl {
 
 OpenGLContext::OpenGLContext() { impl.reset(new OpenGLContextImpl()); }
 
-int XErrorHandler(Display* dsp, XErrorEvent* error) {
-  constexpr int kBufferSize = 512;
-  char error_string[kBufferSize];
-  XGetErrorText(dsp, error->error_code, error_string, kBufferSize);
+bool InitializeEGL(OpenGLContext* result) {
+  CHECK_NOTNULL(result);
 
-  LOG(FATAL) << "X Error:\n" << error_string;
-  return 0;
-}
+  //taken from
+  // https://developer.nvidia.com/blog/egl-eye-opengl-visualization-without-x-server/
+  // Note that it also works for non-nvidia backend
 
-// Code adapted from
-// http://stackoverflow.com/questions/2896879/windowless-opengl
-bool InitializeOpenGLWindowlessGLX(GLXContext sharing_context,
-                                   OpenGLContext* result) {
-  CHECK_NOTNULL(result);
-  GLint attributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, None};
+  PFNEGLQUERYDEVICESEXTPROC eglQueryDevicesEXT =
+  (PFNEGLQUERYDEVICESEXTPROC)
+  eglGetProcAddress("eglQueryDevicesEXT");
 
-  int (*old_error_handler)(Display*, XErrorEvent*) =
-      XSetErrorHandler(XErrorHandler);
+  PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT =
+  (PFNEGLGETPLATFORMDISPLAYEXTPROC)
+  eglGetProcAddress("eglGetPlatformDisplayEXT");
 
-  Display* display = XOpenDisplay(NULL);
-  if (!display) {
-    LOG(FATAL) << "Cannot connect to X server.";
-  }
+  static const int MAX_DEVICES = 4;
+  EGLDeviceEXT eglDevs[MAX_DEVICES];
+  EGLint numDevices;
 
-  Window root_window = DefaultRootWindow(display);
-  XVisualInfo* visual = glXChooseVisual(display, 0, attributes);
-  if (!visual) {
-    LOG(FATAL) << "No appropriate visual found.";
-  }
+  eglQueryDevicesEXT(MAX_DEVICES, eglDevs, &numDevices);
 
-  GLXContext glx_context =
-      glXCreateContext(display, visual, sharing_context, GL_TRUE);
-  if (!glx_context) {
-    LOG(FATAL) << "Cannot create GLX context.";
-  }
-  XFree(visual);
+  EGLDisplay eglDpy = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, 
+                                      eglDevs[0], 0);
 
-  result->impl->display = display;
-  result->impl->drawable = root_window;
-  result->impl->context = glx_context;
-  result->impl->needs_glew_initialization = true;
+  EGLint major, minor;
+
+  eglInitialize(eglDpy, &major, &minor);
+
+  // 2. Select an appropriate configuration
+  EGLint numConfigs;
+  EGLConfig eglCfg;
+
+  eglChooseConfig(eglDpy, configAttribs, &eglCfg, 1, &numConfigs);
 
-  XSetErrorHandler(old_error_handler);
+
+  // 3. Bind the API
+  eglBindAPI(EGL_OPENGL_API);
+  EGLContext eglCtx = eglCreateContext(eglDpy, eglCfg, EGL_NO_CONTEXT, 
+                                       NULL);
+
+
+  eglMakeCurrent(eglDpy, EGL_NO_SURFACE, EGL_NO_SURFACE, eglCtx);
+
+  // Note : here, don't use surface because shaders
+  // already take care of creating a Frame buffer object
+
+  result->impl->display = eglDpy;
+  result->impl->surface_draw = EGL_NO_SURFACE;
+  result->impl->surface_read = EGL_NO_SURFACE;
+  result->impl->context = eglCtx;
+  result->impl->needs_glew_initialization = true;
   return true;
 }
 
-OpenGLContext SwitchOpenGLContextGLX(const OpenGLContext& context) {
-  int (*old_error_handler)(Display*, XErrorEvent*) =
-      XSetErrorHandler(XErrorHandler);
-
+OpenGLContext SwitchOpenGLContextEGL(const OpenGLContext& context) {
+  if(glXGetCurrentContext() != NULL){
+    glXMakeCurrent(glXGetCurrentDisplay(), None, NULL);
+  }
+  
   OpenGLContext current_context;
-  current_context.impl->display = glXGetCurrentDisplay();
+  current_context.impl->display = eglGetCurrentDisplay();
   if (!current_context.impl->display) {
-    // We need a display, otherwise glXMakeCurrent() will segfault.
     current_context.impl->display = context.impl->display;
   }
-  current_context.impl->drawable = glXGetCurrentDrawable();
-  current_context.impl->context = glXGetCurrentContext();
+  current_context.impl->surface_read = eglGetCurrentSurface(EGL_READ);
+  current_context.impl->surface_draw = eglGetCurrentSurface(EGL_DRAW);
+  current_context.impl->context = eglGetCurrentContext();
   current_context.impl->needs_glew_initialization = false;
 
-  if (glXMakeCurrent(context.impl->display, context.impl->drawable,
-                     context.impl->context) == GL_FALSE) {
-    LOG(FATAL) << "Cannot make GLX context current.";
+  if (eglMakeCurrent(context.impl->display, context.impl->surface_read,
+                     context.impl->surface_draw, context.impl->context) == GL_FALSE) {
+    LOG(FATAL) << "Cannot make EGL context current.";
   }
 
   if (context.impl->needs_glew_initialization) {
@@ -110,39 +119,41 @@ OpenGLContext SwitchOpenGLContextGLX(const OpenGLContext& context) {
     context.impl->needs_glew_initialization = false;
   }
 
-  XSetErrorHandler(old_error_handler);
   return current_context;
 }
 
-bool IsOpenGLContextAvailableGLX() {
-  return (glXGetCurrentContext() != nullptr);
+bool IsOpenGLContextAvailableEGL() {
+  return (eglGetCurrentContext() != nullptr);
 }
 
-void DeinitializeOpenGLGLX(OpenGLContext* context) {
-  glXDestroyContext(context->impl->display, context->impl->context);
-  XCloseDisplay(context->impl->display);
+void DeinitializeOpenGLEGL(OpenGLContext* context) {
+  eglDestroyContext(context->impl->display, context->impl->context);
 
-  context->impl->drawable = None;
+  context->impl->surface_read = None;
+  context->impl->surface_draw = None;
   context->impl->context = nullptr;
 }
 
 bool InitializeOpenGLWindowless(int /*version*/, OpenGLContext* result) {
   CHECK_NOTNULL(result);
-  GLXContext sharing_context = nullptr;
-  return InitializeOpenGLWindowlessGLX(sharing_context, result);
+  return InitializeEGL(result);
 }
 
 OpenGLContext SwitchOpenGLContext(const OpenGLContext& context) {
-  return SwitchOpenGLContextGLX(context);
+  return SwitchOpenGLContextEGL(context);
 }
 
 bool IsOpenGLContextAvailable() {
-  return IsOpenGLContextAvailableGLX();
+  return IsOpenGLContextAvailableEGL();
+}
+
+void releaseOpenGLContext(){
+  eglMakeCurrent(eglGetCurrentDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
 void DeinitializeOpenGL(OpenGLContext* context) {
   CHECK_NOTNULL(context);
-  DeinitializeOpenGLGLX(context);
+  DeinitializeOpenGLEGL(context);
 }
 
 }  // namespace opengl

src/opengl/opengl_util_glx.h renamed to src/opengl/opengl_util_egl.h

@@ -26,17 +26,38 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // POSSIBILITY OF SUCH DAMAGE.
 
-#include <GL/glew.h>
+#define EGL_EGLEXT_PROTOTYPES
+#include <EGL/egl.h>
 #include <GL/glx.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
+#include <EGL/eglext.h>
+#include <EGL/eglplatform.h>
 
 namespace opengl {
 
+  static const EGLint configAttribs[] = {
+        EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+        EGL_BLUE_SIZE, 8,
+        EGL_GREEN_SIZE, 8,
+        EGL_RED_SIZE, 8,
+        EGL_DEPTH_SIZE, 8,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+        EGL_NONE
+  };    
+
+  static const int pbufferWidth = 9;
+  static const int pbufferHeight = 9;
+
+  static const EGLint pbufferAttribs[] = {
+        EGL_WIDTH, pbufferWidth,
+        EGL_HEIGHT, pbufferHeight,
+        EGL_NONE,
+  };
+
 struct OpenGLContextImpl {
-  Display* display;
-  GLXDrawable drawable;
-  GLXContext context;
+  EGLDisplay display;
+  EGLContext context;
+  EGLSurface surface_read;
+  EGLSurface surface_draw;
   bool needs_glew_initialization;
 };
 

src/opt/occlusion_geometry.cc

@@ -154,6 +154,7 @@ bool OcclusionGeometry::AddMesh(pcl::PolygonMesh& cpu_mesh,
       return false;
     }
     opengl_context_initialized_ = true;
+    opengl::releaseOpenGLContext();
   }
 
   // Transfer the mesh to the GPU.