Small fixes and improvement.

CMakeLists.txt

@@ -218,26 +218,37 @@ if(RADIUM_ENABLE_TESTING)
 endif()
 
 if(RADIUM_ENABLE_COVERAGE)
+    append_coverage_compiler_flags()
     setup_target_for_coverage_lcov(
         NAME
         coverage
         EXECUTABLE
-        ctest
+        ${CMAKE_CTEST_COMMAND}
+        --output-on-failure
+        -C
+        ${CMAKE_BUILD_TYPE}
         -j
         $ENV{CMAKE_BUILD_PARALLEL_LEVEL}
+        BASE_DIRECTORY
+        "/"
         DEPENDENCIES
         RadiumLibs
         unittests
         integration
         EXCLUDE
+        "/*external*/"
+        "/*/glbinding/*"
+        "/*/globjects/*"
+        "/*/OpenMesh/*"
+        "/*/assimp/*"
+        "/*/eigen3/*"
+        "/*/nlohmann/*"
+        "/*/stb/*"
         "/usr/*"
-        "*examples*"
-        "*external*"
-        "*install*"
-        "*/Catch2/*"
-        "*_autogen/*"
-        "*build*"
-        "*mocs*"
+        "${CMAKE_SOURCE_DIR}/examples*"
+        "${CMAKE_SOURCE_DIR}/*/Catch2/*"
+        "${CMAKE_BINARY_DIR}/*_autogen/*"
+        "${CMAKE_BINARY_DIR}/*mocs*"
     )
 
     # Fastcov is not supported with gcov llvm: disabling for MacOS Source:
@@ -247,16 +258,28 @@ if(RADIUM_ENABLE_COVERAGE)
             NAME
             coverage_fastcov
             EXECUTABLE
-            ctest
+            ${CMAKE_CTEST_COMMAND}
+            --output-on-failure
+            -C
+            ${CMAKE_BUILD_TYPE}
             -j
             $ENV{CMAKE_BUILD_PARALLEL_LEVEL}
             DEPENDENCIES
             RadiumLibs
             unittests
             integration
+            BASE_DIRECTORY
+            "/"
             EXCLUDE
             "/usr/"
             "examples"
+            "glbinding"
+            "globjects"
+            "OpenMesh"
+            "assimp"
+            "eigen3"
+            "nlohmann"
+            "stb"
             "external"
             "install"
             "/Catch2/"

cmake/CodeCoverage.cmake

@@ -166,11 +166,19 @@ foreach(LANG ${LANGUAGES})
 endforeach()
 
 set(COVERAGE_COMPILER_FLAGS "-g --coverage" CACHE INTERNAL "")
+
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
-    check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path)
-    if(HAVE_fprofile_abs_path)
-        set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+endif()
+if(CMAKE_C_COMPILER_ID MATCHES "(GNU|Clang)")
+    include(CheckCCompilerFlag)
+    check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
     endif()
 endif()
 
@@ -239,8 +247,7 @@ function(setup_target_for_coverage_lcov)
     set(LCOV_EXCLUDES "")
     foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES})
         if(CMAKE_VERSION VERSION_GREATER 3.4)
-            # this don't support regexp get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR
-            # ${BASEDIR})
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
         endif()
         list(APPEND LCOV_EXCLUDES "${EXCLUDE}")
     endforeach()
@@ -340,36 +347,36 @@ function(setup_target_for_coverage_lcov)
         message(STATUS "Executed command report")
         message(STATUS "Command to clean up lcov: ")
         string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}")
-        message(STATUS "${LCOV_CLEAN_CMD_SPACED}")
+        message("${LCOV_CLEAN_CMD_SPACED}")
 
         message(STATUS "Command to create baseline: ")
         string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}")
-        message(STATUS "${LCOV_BASELINE_CMD_SPACED}")
+        message("${LCOV_BASELINE_CMD_SPACED}")
 
         message(STATUS "Command to run the tests: ")
         string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}")
-        message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}")
+        message("${LCOV_EXEC_TESTS_CMD_SPACED}")
 
         message(STATUS "Command to capture counters and generate report: ")
         string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}")
-        message(STATUS "${LCOV_CAPTURE_CMD_SPACED}")
+        message("${LCOV_CAPTURE_CMD_SPACED}")
 
         message(STATUS "Command to add baseline counters: ")
         string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}")
-        message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}")
+        message("${LCOV_BASELINE_COUNT_CMD_SPACED}")
 
         message(STATUS "Command to filter collected data: ")
         string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}")
-        message(STATUS "${LCOV_FILTER_CMD_SPACED}")
+        message("${LCOV_FILTER_CMD_SPACED}")
 
         message(STATUS "Command to generate lcov HTML output: ")
         string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}")
-        message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}")
+        message("${LCOV_GEN_HTML_CMD_SPACED}")
 
         if(${Coverage_SONARQUBE})
             message(STATUS "Command to generate SonarQube XML output: ")
             string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
-            message(STATUS "${GCOVR_XML_CMD_SPACED}")
+            message("${GCOVR_XML_CMD_SPACED}")
         endif()
     endif()
 
@@ -440,7 +447,7 @@ function(setup_target_for_coverage_gcovr_xml)
     set(GCOVR_EXCLUDES "")
     foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
         if(CMAKE_VERSION VERSION_GREATER 3.4)
-            # get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
         endif()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
     endforeach()
@@ -466,11 +473,11 @@ function(setup_target_for_coverage_gcovr_xml)
 
         message(STATUS "Command to run tests: ")
         string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}")
-        message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")
+        message("${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")
 
         message(STATUS "Command to generate gcovr XML coverage data: ")
         string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
-        message(STATUS "${GCOVR_XML_CMD_SPACED}")
+        message("${GCOVR_XML_CMD_SPACED}")
     endif()
 
     add_custom_target(
@@ -523,7 +530,7 @@ function(setup_target_for_coverage_gcovr_html)
     set(GCOVR_EXCLUDES "")
     foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
         if(CMAKE_VERSION VERSION_GREATER 3.4)
-            # get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
+            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
         endif()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
     endforeach()
@@ -560,15 +567,15 @@ function(setup_target_for_coverage_gcovr_html)
 
         message(STATUS "Command to run tests: ")
         string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}")
-        message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")
+        message("${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")
 
         message(STATUS "Command to create a folder: ")
         string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}")
-        message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}")
+        message("${GCOVR_HTML_FOLDER_CMD_SPACED}")
 
         message(STATUS "Command to generate gcovr HTML coverage data: ")
         string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}")
-        message(STATUS "${GCOVR_HTML_CMD_SPACED}")
+        message("${GCOVR_HTML_CMD_SPACED}")
     endif()
 
     add_custom_target(
@@ -648,7 +655,7 @@ function(setup_target_for_coverage_fastcov)
         --gcov
         ${GCOV_PATH}
         --search-directory
-        ${BASEDIR}
+        ${CMAKE_BINARY_DIR}
         --process-gcno
         --output
         ${Coverage_NAME}.json
@@ -705,7 +712,7 @@ function(setup_target_for_coverage_fastcov)
         ${Coverage_NAME}
         # Cleanup fastcov
         COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH} --search-directory
-                ${BASEDIR} --zerocounters
+                ${CMAKE_BINARY_DIR} --zerocounters
         COMMAND ${FASTCOV_EXEC_TESTS_CMD}
         COMMAND ${FASTCOV_CAPTURE_CMD}
         COMMAND ${FASTCOV_CONVERT_CMD}
@@ -749,7 +756,9 @@ endfunction() # append_coverage_compiler_flags
 function(append_coverage_compiler_flags_to_target name)
     separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
     target_compile_options(${name} PRIVATE ${_flag_list})
-    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
+       OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU"
+    )
         target_link_libraries(${name} PRIVATE gcov)
     endif()
 endfunction()

cmake/CompilerOptions.cmake

@@ -120,7 +120,6 @@ if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHE
         -Wmissing-braces
         -Wreturn-type
         -Wswitch
-        -Wswitch-default
         -Wuninitialized
         -Wmissing-field-initializers
         $<$<CXX_COMPILER_ID:GNU>:

examples/HeadlessExample/main.cpp

@@ -39,9 +39,9 @@ int main( int argc, const char* argv[] ) {
     //! [Configuring the viewer : initialize OpenGL and the Engine]
 
     //! [Verifying the OpenGL version available to the engine]
-    if ( glVersion != viewer.m_engine->getOpenGLVersion() ) {
+    if ( glVersion != viewer.getEngine()->getOpenGLVersion() ) {
         std::cout << "OpenGL version mismatch : requested " << glVersion.toString()
-                  << " -- available " << viewer.m_engine->getOpenGLVersion().toString()
+                  << " -- available " << viewer.getEngine()->getOpenGLVersion().toString()
                   << std::endl;
     }
     //! [Verifying the OpenGL version available to the engine]

src/Core/Geometry/MeshPrimitives.cpp

@@ -277,7 +277,7 @@
         for ( uint i = 0; i < indices.size(); ++i ) {
             const Vector3ui& tri               = indices[i];
             std::array<Vector3, 3> triVertices = {
-                vertices[tri[0]], vertices[tri[1]], vertices[tri[2]] };
+                { vertices[tri[0]], vertices[tri[1]], vertices[tri[2]] } };
             std::array<uint, 3> middles;
 
             for ( uint v = 0; v < 3; ++v ) {

src/Core/Geometry/OpenMesh.hpp

@@ -1,3 +1,4 @@
+
 #pragma once
 
 #include <Core/RaCore.hpp>

src/Core/Math/LinearAlgebra.hpp

@@ -374,6 +374,33 @@ bool checkInvalidNumbers( Eigen::Ref<const Matrix_> matrix, const bool FAIL_ON_A
     return !invalid;
 }
 
+/// \brief Returns True if two arrays are element-wise equal within a tolerance.
+
+/// The tolerance values are positive, typically very small numbers. The relative difference (\b
+/// rtol * abs(\b b)) and the absolute difference \b atol are added together to compare against the
+/// absolute difference between \b a and \b b.
+///
+/// Parameters:
+///
+/// \param a,b Input Matrix to compare
+/// \param rtol The relative tolerance parameter (see Notes).
+/// \param atol The absolute tolerance parameter (see Notes).
+/// \see
+/// https://stackoverflow.com/questions/15051367/how-to-compare-vectors-approximately-in-eigen,
+/// https://numpy.org/doc/stable/reference/generated/numpy.allclose.html
+template <typename DerivedA, typename DerivedB>
+bool allClose( const Eigen::DenseBase<DerivedA>& a,
+               const Eigen::DenseBase<DerivedB>& b,
+               const typename DerivedA::RealScalar& rtol =
+                   Eigen::NumTraits<typename DerivedA::RealScalar>::dummy_precision(),
+               const typename DerivedA::RealScalar& atol =
+                   Eigen::NumTraits<typename DerivedA::RealScalar>::epsilon() ) {
+
+    return ( ( a.derived() - b.derived() ).array().abs() <=
+             ( atol + rtol * a.derived().array().abs().max( b.derived().array().abs() ) ) )
+        .all();
+}
+
 } // namespace Math
 } // namespace Core
 } // namespace Ra

src/Engine/Data/EnvironmentTexture.cpp

@@ -145,7 +145,7 @@ using namespace Ra::Core;
 // -------------------------------------------------------------------
 EnvironmentTexture::EnvironmentTexture( const std::string& mapName, bool isSkybox ) :
     m_name( mapName ),
-    m_skyData { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr },
+    m_skyData { { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr } },
     m_isSkyBox( isSkybox ) {
     m_type = ( mapName.find( ';' ) != mapName.npos ) ? EnvironmentTexture::EnvMapType::ENVMAP_CUBE
                                                      : EnvironmentTexture::EnvMapType::ENVMAP_PFM;
@@ -175,7 +175,7 @@ void EnvironmentTexture::initializeTexture() {
 
     // proper convert shared ptr float[] to void
     std::array<std::shared_ptr<void>, 6> cubeMap = {
-        m_skyData[0], m_skyData[1], m_skyData[2], m_skyData[3], m_skyData[4], m_skyData[5] };
+        { m_skyData[0], m_skyData[1], m_skyData[2], m_skyData[3], m_skyData[4], m_skyData[5] } };
     Ra::Engine::Data::TextureParameters params { m_name,
                                                  {
                                                      GL_CLAMP_TO_EDGE,
@@ -435,18 +435,17 @@ void EnvironmentTexture::setupTexturesFromSphericalEquiRectangular() {
                 Vector2 st { w * sphericalPhi( d ) / ( 2 * M_PI ), h * sphericalTheta( d ) / M_PI };
                 // TODO : use st to access and filter the original envmap
                 // for now, no filtering is done. (eq to GL_NEAREST)
-                int s  = int( st.x() );
-                int t  = int( st.y() );
-                int cu = int( ( u / 2 + 0.5 ) * textureSize );
-                int cv = int( ( v / 2 + 0.5 ) * textureSize );
-
-                m_skyData[imgIdx][4 * ( cv * textureSize + cu ) + 0] =
-                    latlonPix[4 * ( t * w + s ) + 0];
-                m_skyData[imgIdx][4 * ( cv * textureSize + cu ) + 1] =
-                    latlonPix[4 * ( t * w + s ) + 1];
-                m_skyData[imgIdx][4 * ( cv * textureSize + cu ) + 2] =
-                    latlonPix[4 * ( t * w + s ) + 2];
-                m_skyData[imgIdx][4 * ( cv * textureSize + cu ) + 3] = 1;
+                int s  = std::clamp( int( st.x() ), 0, w - 1 );
+                int t  = std::clamp( int( st.y() ), 0, h - 1 );
+                int cu = std::clamp( int( ( u / 2 + 0.5 ) * textureSize ), 0, textureSize - 1 );
+                int cv = std::clamp( int( ( v / 2 + 0.5 ) * textureSize ), 0, textureSize - 1 );
+                int skyIndex    = 4 * ( cv * textureSize + cu );
+                int latlonIndex = 4 * ( t * w + s );
+
+                m_skyData[imgIdx][skyIndex + 0] = latlonPix[latlonIndex + 0];
+                m_skyData[imgIdx][skyIndex + 1] = latlonPix[latlonIndex + 1];
+                m_skyData[imgIdx][skyIndex + 2] = latlonPix[latlonIndex + 2];
+                m_skyData[imgIdx][skyIndex + 3] = 1;
             }
         }
     }