Merge branch 'releases/CGAL-4.14-branch'

Installation/CMakeLists.txt

@@ -910,7 +910,7 @@ install(PROGRAMS ${scripts} DESTINATION ${CGAL_INSTALL_BIN_DIR})
 install(DIRECTORY ${CGAL_MODULES_REL_DIR}/                DESTINATION ${CGAL_INSTALL_CMAKE_DIR} )
 install(FILES     ${CGAL_MODULES_REL_DIR}/UseCGAL.cmake   DESTINATION ${CGAL_INSTALL_CMAKE_DIR} )
 
-if ( GMP_IN_CGAL_AUXILIARY OR MPFR_IN_CGAL_AUXILIARY )
+if ( IS_DIRECTORY auxiliary/gmp/include AND IS_DIRECTORY auxiliary/gmp/lib )
   install(DIRECTORY auxiliary/gmp/include/ DESTINATION ${CGAL_INSTALL_INC_DIR} )
   install(DIRECTORY auxiliary/gmp/lib/     DESTINATION ${CGAL_INSTALL_LIB_DIR} )
 endif()

Installation/cmake/modules/CGAL_SetupGMP.cmake

@@ -56,14 +56,14 @@ function(use_CGAL_GMP_support target)
     return()
   endif()
 
-  if(NOT GMP_IN_CGAL_AUXILIARY)
+  if(NOT GMP_INCLUDE_DIR STREQUAL "${CGAL_INSTALLATION_PACKAGE_DIR}/auxiliary/gmp/include")
     target_include_directories(${target} SYSTEM ${keyword} ${GMP_INCLUDE_DIR})
   else()
     target_include_directories(${target} SYSTEM ${keyword}
       $<BUILD_INTERFACE:${GMP_INCLUDE_DIR}>
       $<INSTALL_INTERFACE:include>)
   endif()
-  if(NOT MPFR_IN_CGAL_AUXILIARY)
+  if(NOT MPFR_INCLUDE_DIR STREQUAL "${CGAL_INSTALLATION_PACKAGE_DIR}/auxiliary/gmp/include")
     target_include_directories(${target} SYSTEM ${keyword} ${MPFR_INCLUDE_DIR})
   else()
     target_include_directories(${target} SYSTEM ${keyword}

Installation/cmake/modules/CGAL_enable_end_of_configuration_hook.cmake

@@ -14,11 +14,47 @@ if(PROPERTY_CGAL_run_at_the_end_of_configuration_INCLUDED)
 endif()
 
 function(CGAL_run_at_the_end_of_configuration variable access value current_list_file stack)
-  if(NOT access STREQUAL "MODIFIED_ACCESS" OR value)
+  if(NOT access STREQUAL "MODIFIED_ACCESS")
-    # Only do something at the end of the CMake process, when the value of
-    # variable CMAKE_CURRENT_LIST_DIR is changed to the empty string.
     return()
   endif()
+  if(CGAL_CHECK_UNUSED_CPP_FILES
+      AND NOT current_list_file STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt"
+      AND stack STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt")
+    file(GLOB _cppfiles ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+    get_property(_targets DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY BUILDSYSTEM_TARGETS)
+    if(_targets AND _cppfiles)
+      set(_sources)
+      foreach(_target ${_targets})
+        get_property(_target_type TARGET ${_target} PROPERTY TYPE)
+        if(_target_type STREQUAL INTERFACE_LIBRARY)
+          continue()
+        endif()
+        get_property(_target_sources TARGET ${_target} PROPERTY SOURCES)
+        list(APPEND _sources ${_target_sources})
+      endforeach()
+      if(_sources)
+        list(REMOVE_ITEM _cppfiles ${_sources})
+      endif()
+      if(_cppfiles)
+        set(_warning "In ${CMAKE_CURRENT_SOURCE_DIR}, the following files are unused:")
+        foreach(_cppfile ${_cppfiles})
+          set(_warning "${_warning}
+  ${_cppfile}")
+        endforeach()
+        set(_warning  "${_warning}
+")
+        message(AUTHOR_WARNING "${_warning}")
+      endif()
+    endif()
+  endif()
+
+  if(value)
+    # Only do the following at the end of the CMake process, when the
+    # value of variable CMAKE_CURRENT_LIST_DIR is changed to the empty
+    # string.
+    return()
+  endif()
+
   # Warn when CMAKE_BUILD_TYPE is empty or Debug
   if(DEFINED CMAKE_BUILD_TYPE AND ( NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "Debug") )
     set(keyword WARNING)

Installation/cmake/modules/FindGMP.cmake

@@ -4,7 +4,6 @@
 #  GMP_INCLUDE_DIR       - the GMP include directory
 #  GMP_LIBRARIES_DIR     - directory where the GMP libraries are located
 #  GMP_LIBRARIES         - Link these to use GMP
-#  GMP_IN_CGAL_AUXILIARY - TRUE if the GMP found is the one distributed with CGAL in the auxiliary folder
 
 # TODO: support MacOSX
 
@@ -52,8 +51,3 @@ if( NOT GMP_in_cache )
 endif()
 
 find_package_handle_standard_args(GMP "DEFAULT_MSG" GMP_LIBRARIES GMP_INCLUDE_DIR)
-
-if ( GMP_INCLUDE_DIR STREQUAL "${CGAL_INSTALLATION_PACKAGE_DIR}/auxiliary/gmp/include" )
-  cache_set( GMP_IN_CGAL_AUXILIARY TRUE )
-endif()
-

Installation/cmake/modules/FindMPFR.cmake

@@ -3,7 +3,6 @@
 # MPFR_INCLUDE_DIR - the MPFR include directory
 # MPFR_LIBRARIES_DIR - Directory where the MPFR libraries are located
 # MPFR_LIBRARIES - the MPFR libraries
-# MPFR_IN_CGAL_AUXILIARY - TRUE if the MPFR found is the one distributed with CGAL in the auxiliary folder
 
 # TODO: support MacOSX
 
@@ -51,7 +50,3 @@ if (NOT MPFR_in_cache)
 endif()
 
 find_package_handle_standard_args(MPFR "DEFAULT_MSG" MPFR_LIBRARIES MPFR_INCLUDE_DIR)
-
-if ( MPFR_INCLUDE_DIR STREQUAL "${CGAL_INSTALLATION_PACKAGE_DIR}/auxiliary/gmp/include" )
-  cache_set( MPFR_IN_CGAL_AUXILIARY TRUE )
-endif()

Installation/src/CGAL_libs_verinfo.rc.in

@@ -25,7 +25,7 @@
 #define CGAL_VER_str(s) CGAL_VER_xstr(s)
 
 #define CGAL_VER_VERSION CGAL_VERSION_MAJOR,CGAL_VERSION_MINOR,CGAL_VERSION_PATCH,CGAL_VERSION_BUILD
-#define CGAL_VER_VERSION_STR CGAL_VER_str(CGAL_VERSION)
+#define CGAL_VER_VERSION_STR CGAL_VER_str(CGAL_VERSION_MAJOR) "." CGAL_VER_str(CGAL_VERSION_MINOR) "." CGAL_VER_str(CGAL_VERSION_PATCH) "." CGAL_VER_str(CGAL_VERSION_BUILD)
 #define CGAL_VER_COMPANYNAME_STR "The CGAL Project, https://www.cgal.org/\0"
 #define CGAL_VER_FILEDESCRIPTION_STR "@LIBRARY_NAME@ Library\0"
 #define CGAL_VER_FILEVERSION_STR CGAL_VER_VERSION_STR

Installation/test/Installation/CMakeLists.txt

@@ -79,10 +79,13 @@ if ( CGAL_FOUND )
     endif()
   endif()
 
-  if(WIN32) 
+  if(WIN32 OR CMAKE_SYSTEM_NAME STREQUAL Windows)
+    add_executable(display_dll_version_info display_dll_version_info.cpp)
+    target_link_libraries(display_dll_version_info version)
     add_executable(test_gmp_mpfr_dll test_gmp_mpfr_dll.cpp)
-    target_link_libraries(test_gmp_mpfr_dll Version)
+    target_link_libraries(test_gmp_mpfr_dll version)
-  endif(WIN32)
+    CGAL_add_test(test_gmp_mpfr_dll)
+  endif()
 
   find_package( LEDA QUIET)
   if(LEDA_FOUND)

Installation/test/Installation/display_dll_version_info.cpp

@@ -49,7 +49,7 @@ int main(int argc, char** argv) {
   } else {
     std::cerr << "Usage:\n"
               << "  display_dll_version_info /path/to/a.dll\n";
-    return 0;
   }
+  return 0;
 }
 #endif

Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features.cpp

@@ -6,6 +6,7 @@
 
 #include <CGAL/Polyhedral_mesh_domain_with_features_3.h>
 #include <CGAL/make_mesh_3.h>
+#include <CGAL/IO/output_to_vtu.h>
 
 // Domain 
 typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
@@ -62,8 +63,10 @@ int main(int argc, char*argv[])
   C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria);
 
   // Output
-  std::ofstream medit_file("out.mesh");
+  std::ofstream file("out.vtu");
-  c3t3.output_to_medit(medit_file);
+  CGAL::output_to_vtu(file, c3t3);
+  // Could be replaced by:
+  // c3t3.output_to_medit(file);
 
   return EXIT_SUCCESS;
 }

Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features_sm.cpp

@@ -7,6 +7,7 @@
 #include <CGAL/Surface_mesh.h>
 #include <CGAL/Polyhedral_mesh_domain_with_features_3.h>
 #include <CGAL/make_mesh_3.h>
+#include <CGAL/IO/output_to_vtu.h>
 
 // Domain
 typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
@@ -63,8 +64,10 @@ int main(int argc, char*argv[])
   C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria);
 
   // Output
-  std::ofstream medit_file("out.mesh");
+  std::ofstream file("out-sm.vtu");
-  c3t3.output_to_medit(medit_file);
+  CGAL::output_to_vtu(file, c3t3, CGAL::IO::ASCII);
+  // Could be replaced by:
+  // c3t3.output_to_medit(file);
 
   return EXIT_SUCCESS;
 }

Mesh_3/include/CGAL/IO/Complex_3_in_triangulation_3_to_vtk.h

@@ -35,10 +35,12 @@
 
 namespace CGAL {
 
+//if export_complex is false, there must be no far point.
 template <typename C3T3>
 vtkUnstructuredGrid* 
 output_c3t3_to_vtk_unstructured_grid(const C3T3& c3t3, 
-                                     vtkUnstructuredGrid* grid = 0)
+                                     vtkUnstructuredGrid* grid = 0,
+                                     bool export_complex = true)
 {
   typedef typename C3T3::Triangulation                      Triangulation;
   typedef typename Triangulation::Vertex_handle             Vertex_handle;
@@ -52,7 +54,7 @@ output_c3t3_to_vtk_unstructured_grid(const C3T3& c3t3,
 
   vtk_points->Allocate(c3t3.triangulation().number_of_vertices()- c3t3.number_of_far_points());
   vtk_facets->Allocate(c3t3.number_of_facets_in_complex());
-  vtk_cells->Allocate(c3t3.number_of_cells_in_complex());
+  vtk_cells->Allocate(export_complex ? c3t3.number_of_cells_in_complex() : tr.number_of_finite_cells());
 
   boost::unordered_map<Vertex_handle, vtkIdType, Hash_fct> V;
   vtkIdType inum = 0;
@@ -63,10 +65,10 @@ output_c3t3_to_vtk_unstructured_grid(const C3T3& c3t3,
       vit != end;
       ++vit)
   {
-    typedef typename Triangulation::Weighted_point Weighted_point;
+    typedef typename Triangulation::Point Point;
     if(vit->in_dimension() > -1)
     {
-      const Weighted_point& p = tr.point(vit);
+      const Point& p = tr.point(vit);
       vtk_points->InsertNextPoint(CGAL::to_double(p.x()),
                                   CGAL::to_double(p.y()),
                                   CGAL::to_double(p.z()));
@@ -86,18 +88,34 @@ output_c3t3_to_vtk_unstructured_grid(const C3T3& c3t3,
     CGAL_assertion(j==3);
     vtk_facets->InsertNextCell(3, cell);
   }
-
+  if(export_complex)
-  for(typename C3T3::Cells_in_complex_iterator 
+  {
+    for(typename C3T3::Cells_in_complex_iterator 
         cit = c3t3.cells_in_complex_begin(),
         end = c3t3.cells_in_complex_end();
-      cit != end; ++cit) 
+        cit != end; ++cit) 
-  {
+    {
-    vtkIdType cell[4];
+      vtkIdType cell[4];
-    for (int i = 0; i < 4; ++i)
+      for (int i = 0; i < 4; ++i)
-      cell[i] =  V[cit->vertex(i)];
+        cell[i] =  V[cit->vertex(i)];
-    vtk_cells->InsertNextCell(4, cell);
+      vtk_cells->InsertNextCell(4, cell);
+    }
+  }
+  else
+  {
+    for(auto cit = tr.finite_cells_begin(),
+        end = tr.finite_cells_end();
+        cit != end; ++cit) 
+    {
+      if(!c3t3.is_in_complex(cit))
+      {
+        vtkIdType cell[4];
+        for (int i = 0; i < 4; ++i)
+          cell[i] =  V[cit->vertex(i)];
+        vtk_cells->InsertNextCell(4, cell);
+      }
+    }
   }
-
   if(!grid) {
     grid = vtkUnstructuredGrid::New();
   }

Mesh_3/include/CGAL/IO/output_to_vtu.h

@@ -32,6 +32,7 @@
 #include <CGAL/assertions.h>
 #include <CGAL/IO/io.h>
 #include <CGAL/IO/write_vtk.h>
+#include <boost/variant.hpp>
 
 //todo try to factorize with functors
 namespace CGAL{
@@ -66,7 +67,7 @@ write_cells_tag(std::ostream& os,
     // 4 indices (size_t) per cell + length of the encoded data (size_t)
   }
   else {
-    os << "\">\n";   
+    os << ">\n";
     for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
          cit != c3t3.cells_in_complex_end() ;
          ++cit )
@@ -74,7 +75,7 @@ write_cells_tag(std::ostream& os,
       for (int i=0; i<4; i++)
         os << V[cit->vertex(i)] << " ";
     }
-    os << "      </DataArray>\n";
+    os << "\n      </DataArray>\n";
   }
   
   // Write offsets
@@ -87,7 +88,7 @@ write_cells_tag(std::ostream& os,
     // 1 offset (size_t) per cell + length of the encoded data (size_t)
   }
   else {
-    os << "\">\n";  
+    os << ">\n";
     std::size_t cells_offset = 0;
     for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
 	 cit != c3t3.cells_in_complex_end() ;
@@ -96,7 +97,7 @@ write_cells_tag(std::ostream& os,
 	cells_offset += 4;
 	os << cells_offset << " ";
       }  
-    os << "      </DataArray>\n";
+    os << "\n      </DataArray>\n";
   }
 
   // Write cell type (tetrahedra == 10)
@@ -109,12 +110,12 @@ write_cells_tag(std::ostream& os,
     // 1 unsigned char per cell + length of the encoded data (size_t)
   }
   else {
-    os << "\">\n";  
+    os << ">\n";
     for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
 	 cit != c3t3.cells_in_complex_end() ;
 	 ++cit )
       os << "10 ";
-    os << "      </DataArray>\n";
+    os << "\n      </DataArray>\n";
   }
   os << "    </Cells>\n";
 }
@@ -188,7 +189,7 @@ write_c3t3_points_tag(std::ostream& os,
       else
         os << 0.0 << " ";
     }
-    os << "      </DataArray>\n";
+    os << "\n      </DataArray>\n";
   }
   os << "    </Points>\n";
 }
@@ -231,7 +232,20 @@ write_attribute_tag(std::ostream& os,
 		    std::size_t& offset)
 {
   std::string format = binary ? "appended" : "ascii";
-  std::string type = (sizeof(T) == 8) ? "Float64" : "Float32";
+  std::string type = "";
+  if(std::is_floating_point<T>::value)
+  {
+    type = (sizeof(T) == 8) ? "Float64" : "Float32";
+  }
+  else
+  {
+    if(sizeof(T) == 1)
+      type =  "UInt8";
+    else if(sizeof(T) == 4)
+      type = "UInt32";
+    else
+      type = "UInt64";
+  }
   os << "      <DataArray type=\"" << type << "\" Name=\"" << attr_name << "\" format=\"" << format; 
 
   if (binary) {
@@ -245,7 +259,7 @@ write_attribute_tag(std::ostream& os,
 	 it != attribute.end();
 	 ++it )
       os << *it << " ";
-    os << "      </DataArray>\n";
+    os << "\n      </DataArray>\n";
   }
 }
 
@@ -258,12 +272,21 @@ write_attributes(std::ostream& os,
   write_vector(os,att);
 }
 
+enum VTU_ATTRIBUTE_TYPE{
+  DOUBLE=0,
+  UNIT_8,
+  SIZE_TYPE
+};
+
+typedef boost::variant<const std::vector<double>*, const std::vector<uint8_t>*, const std::vector<std::size_t>* > Vtu_attributes;
+
 template <class C3T3>
 void output_to_vtu_with_attributes(std::ostream& os,
                                    const C3T3& c3t3,
-                                   std::vector<std::pair<const char*, const std::vector<double>*> >& attributes,
+                                   std::vector<std::pair<const char*, const Vtu_attributes> >&attributes,
                                    IO::Mode mode = IO::BINARY)
 {
+  //CGAL_assertion(attributes.size() == attribute_types.size());
   typedef typename C3T3::Triangulation Tr;
   typedef typename Tr::Vertex_handle Vertex_handle;
   const Tr& tr = c3t3.triangulation();
@@ -296,7 +319,17 @@ void output_to_vtu_with_attributes(std::ostream& os,
   os << "    <CellData Scalars=\""<<attributes.front().first<<"\">\n";
   for(std::size_t i = 0; i< attributes.size(); ++i)
   {
-    write_attribute_tag(os,attributes[i].first, *attributes[i].second, binary,offset);
+    switch(attributes[i].second.which()){
+    case 0:
+      write_attribute_tag(os,attributes[i].first, *boost::get<const std::vector<double>* >(attributes[i].second), binary,offset);
+      break;
+    case 1:
+      write_attribute_tag(os,attributes[i].first, *boost::get<const std::vector<uint8_t>* >(attributes[i].second), binary,offset);
+      break;
+    default:
+      write_attribute_tag(os,attributes[i].first, *boost::get<const std::vector<std::size_t>* >(attributes[i].second), binary,offset);
+      break;
+    }
   }
   os << "    </CellData>\n";
   os << "   </Piece>\n"
@@ -306,7 +339,17 @@ void output_to_vtu_with_attributes(std::ostream& os,
     write_c3t3_points(os,tr,V); // fills V if the mode is BINARY
     write_cells(os,c3t3,V);
     for(std::size_t i = 0; i< attributes.size(); ++i)
-      write_attributes(os, *attributes[i].second);
+      switch(attributes[i].second.which()){
+      case 0:
+        write_attributes(os, *boost::get<const std::vector<double>* >(attributes[i].second));
+        break;
+      case 1:
+        write_attributes(os, *boost::get<const std::vector<uint8_t>* >(attributes[i].second));
+        break;
+      default:
+        write_attributes(os, *boost::get<const std::vector<std::size_t>* >(attributes[i].second));
+        break;
+      }
   }
   os << "</VTKFile>\n";
 }
@@ -324,11 +367,14 @@ void output_to_vtu(std::ostream& os,
   for( Cell_iterator cit = c3t3.cells_in_complex_begin() ;
        cit != c3t3.cells_in_complex_end() ;
        ++cit )
-    {
+  {
-      mids.push_back(cit->subdomain_index());
+    double v = cit->subdomain_index();
-    }
+    mids.push_back(v);
-  std::vector<std::pair<const char*, const std::vector<double>* > > atts;
+  }
-  atts.push_back(std::make_pair("MeshDomain", &mids));
+  
+  std::vector<std::pair<const char*, const Vtu_attributes > > atts;
+  Vtu_attributes v = &mids;
+  atts.push_back(std::make_pair("MeshDomain", v));
   output_to_vtu_with_attributes(os, c3t3, atts, mode);
 }
 

Polyhedron/demo/Polyhedron/CMakeLists.txt

@@ -148,9 +148,10 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND AND OPENGL_FOUND )
 
   qt5_add_resources ( CGAL_Qt5_RESOURCE_FILES Polyhedron_3.qrc )
   find_path(CGAL_THREE_HEADERS_PATH
-    NAME CGAL/Three/Scene_item.h
+    NAMES CGAL/Three/Scene_item.h
     HINTS ${CGAL_INCLUDE_DIRS}
     NO_DEFAULT_PATH
+    NO_CMAKE_FIND_ROOT_PATH
     DOC "Path to CGAL/Three/Scene_item.h")
   
   if(CGAL_THREE_HEADERS_PATH)
@@ -165,7 +166,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND AND OPENGL_FOUND )
     qt5_generate_moc( "${CGAL_THREE_HEADERS_PATH}/CGAL/Three/TextRenderer.h"
       "${CMAKE_CURRENT_BINARY_DIR}/TextRenderer_moc.cpp" )
   else()
-    message(FATAL_ERROR "Cannot find <CGAL/Three/Viewer_interface.h>")
+    message(FATAL_ERROR "Cannot find <CGAL/Three/Scene_item.h>")
   endif()
 
   unset(CGAL_THREE_HEADERS_PATH CACHE)

STL_Extension/include/CGAL/Compact_container.h

@@ -28,6 +28,7 @@
 #include <CGAL/Default.h>
 
 #include <cmath>
+#include <cstddef>
 #include <iterator>
 #include <algorithm>
 #include <vector>
@@ -815,7 +816,8 @@ private:
 
   static char * clean_pointer(char * p)
   {
-    return ((p - (char *) NULL) & ~ (std::ptrdiff_t) START_END) + (char *) NULL;
+    return reinterpret_cast<char*>(reinterpret_cast<std::ptrdiff_t>(p) &
+                                   ~ (std::ptrdiff_t) START_END);
   }
 
   // Returns the pointee, cleaned up from the squatted bits.
@@ -828,7 +830,8 @@ private:
   static Type type(const_pointer ptr)
   {
     char * p = (char *) Traits::pointer(*ptr);
-    return (Type) (p - clean_pointer(p));
+    return (Type) (reinterpret_cast<std::ptrdiff_t>(p) -
+                   reinterpret_cast<std::ptrdiff_t>(clean_pointer(p)));
   }
 
   // Sets the pointer part and the type of the pointee.
@@ -837,7 +840,8 @@ private:
     // This out of range compare is always true and causes lots of
     // unnecessary warnings.
     // CGAL_precondition(0 <= t && t < 4);
-    Traits::pointer(*ptr) = (void *) ((clean_pointer((char *) p)) + (int) t);
+    Traits::pointer(*ptr) = reinterpret_cast<void *>
+      (reinterpret_cast<std::ptrdiff_t>(clean_pointer((char *) p)) + (int) t);
   }
 
 public:

STL_Extension/include/CGAL/Iterator_range.h

@@ -77,6 +77,18 @@ namespace CGAL {
   {
     return begin()==end();
   }
+#ifndef CGAL_CFG_NO_CPP0X_TUPLE
+
+  operator std::tuple<I&, I&>()
+  {
+    return std::tuple<I&, I&>{this->first, this->second};
+  }
+
+  operator std::tuple<const I&, const I&>() const 
+  {
+    return std::tuple<const I&, const I&>{this->first, this->second};
+  }
+#endif
 
 };