songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4636 from sgiraudot/CMake-Third_party_imported_targets-GF 

CMake: Use Imported Targets for 3rd Party Libs
This commit is contained in:
Laurent Rineau 2020-06-05 17:54:14 +02:00
parent a52a52dd3b 7d5c8e2558
commit 9b8ecd720b
111 changed files with 766 additions and 767 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Bounding_volumes/examples/Approximate_min_ellipsoid_d/CMakeLists.txt
View File

@ -8,15 +8,18 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
if(NOT (${cppfile} STREQUAL "ellipsoid.cpp") OR EIGEN3_FOUND)
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
if(NOT (${cppfile} STREQUAL "ellipsoid.cpp") OR TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
add_executable(${target} ${cppfile})
if (TARGET CGAL::Eigen_support)
target_link_libraries(${target} CGAL::CGAL CGAL::Eigen_support)
else()
target_link_libraries(${target} CGAL::CGAL)
endif()
endif()
endforeach()
@ -26,4 +29,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

14
Bounding_volumes/test/Bounding_volumes/CMakeLists.txt
View File

@ -14,15 +14,18 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
if(NOT (${cppfile} STREQUAL "Approximate_min_ellipsoid_d.cpp") OR EIGEN3_FOUND)
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
if(NOT (${cppfile} STREQUAL "Approximate_min_ellipsoid_d.cpp") OR TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
add_executable(${target} ${cppfile})
if (TARGET CGAL::Eigen_support)
target_link_libraries(${target} CGAL::CGAL CGAL::Eigen_support)
else()
target_link_libraries(${target} CGAL::CGAL)
endif()
endif()
endforeach()
@ -32,4 +35,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

6
Box_intersection_d/test/Box_intersection_d/CMakeLists.txt
View File

@ -8,6 +8,7 @@ project( Box_intersection_d_Tests )
find_package( CGAL QUIET )
find_package( TBB )
include(CGAL_TBB_support)
if ( CGAL_FOUND )
@ -16,12 +17,11 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "random_set_test.cpp" )
create_single_source_cgal_program( "test_box_grid.cpp" )
if( TBB_FOUND )
CGAL_target_use_TBB( test_box_grid )
if(TARGET CGAL::TBB_support)
target_link_libraries(test_box_grid PUBLIC CGAL::TBB_support)
else()
message( STATUS "NOTICE: Intel TBB was not found. Sequential code will be used." )
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

12
CGAL_ipelets/demo/CGAL_ipelets/CMakeLists.txt
View File

@ -27,7 +27,8 @@ if ( CGAL_FOUND )
include(${CGAL_USE_FILE})
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -140,8 +141,7 @@ if ( CGAL_FOUND )
foreach(IPELET ${CGAL_IPELETS})
add_library(CGAL_${IPELET} MODULE ${IPELET}.cpp)
add_to_cached_list(CGAL_EXECUTABLE_TARGETS CGAL_${IPELET})
target_link_libraries(CGAL_${IPELET} PRIVATE CGAL::CGAL ${IPE_LIBRARIES})
CGAL_target_use_Eigen(CGAL_${IPELET})
target_link_libraries(CGAL_${IPELET} PRIVATE CGAL::CGAL CGAL::Eigen_support ${IPE_LIBRARIES})
if ( IPELET_INSTALL_DIR )
install(TARGETS CGAL_${IPELET} DESTINATION ${IPELET_INSTALL_DIR})
if (WITH_IPE_7)
@ -151,14 +151,12 @@ if ( CGAL_FOUND )
cgal_add_compilation_test(CGAL_${IPELET})
endforeach(IPELET)
if(CGAL_Core_FOUND)
target_link_libraries(CGAL_cone_spanners PRIVATE CGAL::CGAL_Core)
CGAL_target_use_Eigen(CGAL_cone_spanners)
target_link_libraries(CGAL_cone_spanners PRIVATE CGAL::CGAL_Core CGAL::Eigen_support)
endif()
#example in doc not installed
add_library(simple_triangulation MODULE simple_triangulation.cpp)
add_to_cached_list(CGAL_EXECUTABLE_TARGETS simple_triangulation)
target_link_libraries(simple_triangulation ${IPE_LIBRARIES})
CGAL_target_use_Eigen(simple_triangulation)
target_link_libraries(simple_triangulation CGAL::Eigen_support ${IPE_LIBRARIES})
cgal_add_compilation_test(simple_triangulation)
else()

36
Classification/examples/Classification/CMakeLists.txt
View File

@ -24,32 +24,39 @@ endif()
set(Classification_dependencies_met TRUE)
find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
if (NOT Boost_SERIALIZATION_FOUND)
include(CGAL_Boost_serialization_support)
include(CGAL_Boost_iostreams_support)
if (NOT TARGET CGAL::Boost_serialization_support)
message(STATUS "NOTICE: This project requires Boost Serialization, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
if (NOT Boost_IOSTREAMS_FOUND)
if (NOT TARGET CGAL::Boost_iostreams_support)
message(STATUS "NOTICE: This project requires Boost IO Streams, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
find_package(OpenCV QUIET COMPONENTS core ml) # Need core + machine learning
if (NOT OpenCV_FOUND)
include(CGAL_OpenCV_support)
if (NOT TARGET CGAL::OpenCV_support)
message(STATUS "NOTICE: OpenCV was not found. OpenCV random forest predicate for classification won't be available.")
endif()
find_package(TensorFlow QUIET)
if (NOT TensorFlow_FOUND)
include(CGAL_TensorFlow_support)
if (NOT TARGET CGAL::TensorFlow_support)
message(STATUS "NOTICE: TensorFlow was not found. TensorFlow neural network predicate for classification won't be available.")
endif()
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
find_package(TBB QUIET)
include(CGAL_TBB_support)
if (NOT Classification_dependencies_met)
return()
@ -63,14 +70,14 @@ create_single_source_cgal_program( "example_mesh_classification.cpp" )
create_single_source_cgal_program( "example_cluster_classification.cpp" )
create_single_source_cgal_program( "gis_tutorial_example.cpp" )
if (OpenCV_FOUND)
if (TARGET CGAL::OpenCV_support)
create_single_source_cgal_program( "example_opencv_random_forest.cpp" )
CGAL_target_use_OpenCV(example_opencv_random_forest)
target_link_libraries(example_opencv_random_forest PUBLIC CGAL::OpenCV_support)
endif()
if (TensorFlow_FOUND)
if (TARGET CGAL::TensorFlow_support)
create_single_source_cgal_program( "example_tensorflow_neural_network.cpp" )
CGAL_target_use_TensorFlow(example_tensorflow_neural_network)
target_link_libraries(example_opencv_random_forest PUBLIC CGAL::TensorFlow_support)
endif()
foreach(target
@ -84,11 +91,12 @@ foreach(target
example_tensorflow_neural_network
gis_tutorial_example)
if(TARGET ${target})
CGAL_target_use_Eigen(${target})
CGAL_target_use_Boost_IOStreams(${target})
CGAL_target_use_Boost_Serialization(${target})
if(TBB_FOUND)
CGAL_target_use_TBB(${target})
target_link_libraries(${target} PUBLIC
CGAL::Eigen_support
CGAL::Boost_iostreams_support
CGAL::Boost_serialization_support)
if(TARGET CGAL::TBB_support)
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endif()
endif()
endforeach()

23
Classification/test/Classification/CMakeLists.txt
View File

@ -24,22 +24,27 @@ endif()
set(Classification_dependencies_met TRUE)
find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
if (NOT Boost_SERIALIZATION_FOUND)
include(CGAL_Boost_serialization_support)
include(CGAL_Boost_iostreams_support)
if (NOT TARGET CGAL::Boost_serialization_support)
message(STATUS "NOTICE: This project requires Boost Serialization, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
if (NOT Boost_IOSTREAMS_FOUND)
if (NOT TARGET CGAL::Boost_iostreams_support)
message(STATUS "NOTICE: This project requires Boost IO Streams, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
set(Classification_dependencies_met FALSE)
endif()
find_package(TBB QUIET)
include(CGAL_TBB_support)
if (NOT Classification_dependencies_met)
return()
@ -49,11 +54,11 @@ create_single_source_cgal_program( "test_classification_point_set.cpp" )
create_single_source_cgal_program( "test_classification_io.cpp" )
foreach(target test_classification_point_set test_classification_io)
CGAL_target_use_Eigen(${target})
CGAL_target_use_Boost_IOStreams(${target})
CGAL_target_use_Boost_Serialization(${target})
if(TBB_FOUND)
CGAL_target_use_TBB(${target})
target_link_libraries(${target} PUBLIC
CGAL::Eigen_support
CGAL::Boost_iostreams_support
CGAL::Boost_serialization_support)
if(TARGET CGAL::TBB_support)
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endif()
endforeach()

2
Documentation/doc/Documentation/Developer_manual/create_and_use_a_cmakelist.txt
View File

@ -18,7 +18,7 @@ find_package(CGAL REQUIRED COMPONENTS Core)
target_link_libraries(my_executable CGAL::CGAL CGAL::CGAL_Core)
\endcode
There are also some cmake macros to link with \cgal dependencies that can be found in
There are also imported targets to link with \cgal dependencies that can be found in
the section \subpage thirdparty.
\note The \cgal targets define the following compiler flags:

46
Documentation/doc/Documentation/Third_party.txt
View File

@ -132,8 +132,8 @@ sparse linear solvers and singular value decompositions. A package
dependency over \sc{Eigen} is marked on the <a
href="https://doc.cgal.org/latest/Manual/packages.html">Package
Overview</a> page. In order to use Eigen in \cgal programs, the
provided CMake function `CGAL_target_use_Eigen(<target>)` should be
used.
executables should be linked with the CMake imported target
`CGAL::Eigen_support` provided in `CGAL_Eigen_support.cmake`.
The \sc{Eigen} web site is <A HREF="http://eigen.tuxfamily.org/index.php?title=Main_Page">`http://eigen.tuxfamily.org`</A>.
@ -142,8 +142,7 @@ The \sc{Eigen} web site is <A HREF="http://eigen.tuxfamily.org/index.php?title=M
\sc{OpenGR} is a set C++ libraries for 3D Global Registration released under the terms of the APACHE V2 licence.
\cgal provides wrappers for the Super4PCS algorithm of \sc{OpenGR} in the \ref PkgPointSetProcessing3Ref
packages. In order to use \sc{OpenGR} in \cgal programs, the provided CMake function
`CGAL_target_use_OpenGR(<target>)` should be used.
packages. In order to use \sc{OpenGR} in \cgal programs, the executables should be linked with the CMake imported target `CGAL::OpenGR_support` provided in `CGAL_OpenGR_support.cmake`.
The \sc{OpenGR} web site is <A HREF="https://github.com/STORM-IRIT/OpenGR">`https://github.com/STORM-IRIT/OpenGR`</A>.
@ -152,8 +151,10 @@ The \sc{OpenGR} web site is <A HREF="https://github.com/STORM-IRIT/OpenGR">`http
\sc{libpointmatcher} is a modular library implementing the Iterative Closest Point (ICP) algorithm for aligning point clouds, released under a permissive BSD license.
\cgal provides wrappers for the ICP algorithm of \sc{libpointmatcher} in the \ref PkgPointSetProcessing3Ref
packages. In order to use \sc{libpointmatcher} in \cgal programs, the provided CMake function
`CGAL_target_use_pointmatcher(<target>)` should be used.
packages. In order to use \sc{libpointmatcher} in \cgal programs, the
executables should be linked with the CMake imported target
`CGAL::pointmatcher_support` provided in
`CGAL_pointmatcher_support.cmake`.
The \sc{libpointmatcher} web site is <A
HREF="https://github.com/ethz-asl/libpointmatcher">`https://github.com/ethz-asl/libpointmatcher`</A>.
@ -220,8 +221,9 @@ It can be downloaded from <A HREF="http://esbtl.sourceforge.net/">`http://esbtl.
programs that take advantage of multi-core processors.
In \cgal, \sc{Tbb} is used by the packages that offer parallel
code. In order to use \sc{Tbb} in \cgal programs, the provided CMake
function `CGAL_target_use_TBB(<target>)` should be used.
code. In order to use \sc{Tbb} in \cgal programs, the executables
should be linked with the CMake imported target `CGAL::TBB_support`
provided in `CGAL_TBB_support.cmake`.
The \sc{Tbb} web site is <A HREF="https://www.threadingbuildingblocks.org">`https://www.threadingbuildingblocks.org`</A>.
@ -231,9 +233,10 @@ The \sc{Tbb} web site is <A HREF="https://www.threadingbuildingblocks.org">`http
the LAS format (or the compressed LAZ format).
In \cgal, \sc{LASlib} is used to provide input and output functions in
the \ref PkgPointSetProcessing3 package. In order to use \sc{LASlib} in
\cgal programs, the provided CMake function
`CGAL_target_use_LASLIB(<target>)` should be used.
the \ref PkgPointSetProcessing3 package. In order to use \sc{LASlib}
in \cgal programs, the executables should be linked with the CMake
imported target `CGAL::LASLIB_support` provided in
`CGAL_LASLIB_support.cmake`.
The \sc{LASlib} web site is <a
href="https://rapidlasso.com/lastools/">`https://rapidlasso.com/lastools/`</a>. \sc{LASlib}
@ -247,8 +250,9 @@ CMake based install procedure</a>.
vision, computer graphics and machine learning.
In \cgal, \sc{OpenCV} is used by the \ref PkgClassification
package. In order to use \sc{OpenCV} in \cgal programs, the provided
CMake function `CGAL_target_use_OpenCV(<target>)` should be used.
package. In order to use \sc{OpenCV} in \cgal programs, the
executables should be linked with the CMake imported target
`CGAL::OpenCV_support` provided in `CGAL_OpenCV_support.cmake`.
The \sc{OpenCV} web site is <A HREF="https://opencv.org/">`https://opencv.org/`</A>.
@ -266,8 +270,10 @@ enable and compile the following targets:
- `tensorflow_BUILD_PYTHON_BINDINGS`
- `tensorflow_BUILD_SHARED_LIB`.
In order to use \sc{TensorFlow} in \cgal programs, the provided CMake
function `CGAL_target_use_TensorFlow(<target>)` should be used.
In order to use \sc{TensorFlow} in \cgal programs, the executables
should be linked with the CMake imported target
`CGAL::TensorFlow_support` provided in
`CGAL_TensorFlow_support.cmake`.
The \sc{TensorFlow} web site is <A HREF="https://www.tensorflow.org/">`https://www.tensorflow.org/`</A>.
@ -310,8 +316,9 @@ for more information.
In \cgal, \sc{GLPK} provides an optional linear integer program solver
in the \ref PkgPolygonalSurfaceReconstruction package. In order to use
\sc{GLPK} in \cgal programs, the provided CMake function
`CGAL_target_use_GLPK(<target>)` should be used.
\sc{GLPK} in \cgal programs, the executables should be linked with the
CMake imported target `CGAL::GLPK_support` provided in
`CGAL_GLPK_support.cmake`.
The \sc{GLPK} web site is <A HREF="https://www.gnu.org/software/glpk/">`https://www.gnu.org/software/glpk/`</A>.
@ -321,8 +328,9 @@ The \sc{GLPK} web site is <A HREF="https://www.gnu.org/software/glpk/">`https://
In \cgal, \sc{SCIP} provides an optional linear integer program solver
in the \ref PkgPolygonalSurfaceReconstruction package. In order to use
\sc{SCIP} in \cgal programs, the provided CMake function
`CGAL_target_use_SCIP(<target>)` should be used.
\sc{SCIP} in \cgal programs, the executables should be linked with the
CMake imported target `CGAL::SCIP_support` provided in
`CGAL_SCIP_support.cmake`.
The \sc{SCIP} web site is <A HREF="http://scip.zib.de/">`http://scip.zib.de/`</A>.

8
Generator/examples/Generator/CMakeLists.txt
View File

@ -12,17 +12,18 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
if(NOT (${cppfile} STREQUAL "random_points_in_tetrahedral_mesh_3.cpp")
OR NOT (${cppfile} STREQUAL "random_points_on_tetrahedral_mesh_3.cpp")
OR EIGEN3_FOUND)
OR TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endif()
endif()
endforeach()
@ -32,4 +33,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

8
Generator/test/Generator/CMakeLists.txt
View File

@ -12,15 +12,16 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
if(NOT (${cppfile} STREQUAL "generic_random_test.cpp") OR EIGEN3_FOUND)
if(NOT (${cppfile} STREQUAL "generic_random_test.cpp") OR TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endif()
endif()
endforeach()
@ -30,4 +31,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

6
GraphicsView/demo/Polygon/CMakeLists.txt
View File

@ -16,7 +16,8 @@ endif()
find_package(CGAL COMPONENTS Qt5 Core)
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -46,12 +47,11 @@ if ( CGAL_FOUND AND CGAL_Qt5_FOUND AND Qt5_FOUND )
# The executable itself.
add_executable ( Polygon_2 Polygon_2.cpp ${DT_UI_FILES} ${DT_RESOURCE_FILES} ${CGAL_Qt5_RESOURCE_FILES} ${CGAL_Qt5_MOC_FILES} )
CGAL_target_use_Eigen(Polygon_2)
add_to_cached_list( CGAL_EXECUTABLE_TARGETS Polygon_2 )
target_link_libraries( Polygon_2 PRIVATE
CGAL::CGAL CGAL::CGAL_Qt5 Qt5::Gui )
CGAL::CGAL CGAL::CGAL_Qt5 CGAL::Eigen_support Qt5::Gui )
include(${CGAL_MODULES_DIR}/CGAL_add_test.cmake)
cgal_add_compilation_test(Polygon_2)

11
Heat_method_3/examples/Heat_method_3/CMakeLists.txt
View File

@ -33,8 +33,9 @@ endif()
find_package(Eigen3 3.3.0)
include(CGAL_Eigen_support)
if (NOT EIGEN3_FOUND)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library (3.3 or greater), and will not be compiled.")
return()
endif()
@ -51,10 +52,10 @@ include_directories( BEFORE include )
include( CGAL_CreateSingleSourceCGALProgram )
create_single_source_cgal_program( "heat_method.cpp" )
CGAL_target_use_Eigen(heat_method)
target_link_libraries(heat_method PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "heat_method_polyhedron.cpp" )
CGAL_target_use_Eigen(heat_method_polyhedron)
target_link_libraries(heat_method_polyhedron PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "heat_method_surface_mesh.cpp" )
CGAL_target_use_Eigen(heat_method_surface_mesh)
target_link_libraries(heat_method_surface_mesh PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "heat_method_surface_mesh_direct.cpp" )
CGAL_target_use_Eigen(heat_method_surface_mesh_direct)
target_link_libraries(heat_method_surface_mesh_direct PUBLIC CGAL::Eigen_support)

9
Heat_method_3/test/Heat_method_3/CMakeLists.txt
View File

@ -33,8 +33,9 @@ endif()
find_package(Eigen3 3.3.0)
include(CGAL_Eigen_support)
if (NOT EIGEN3_FOUND)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library (3.3 or greater), and will not be compiled.")
return()
endif()
@ -49,8 +50,8 @@ include_directories( BEFORE include )
include( CGAL_CreateSingleSourceCGALProgram )
create_single_source_cgal_program( "heat_method_concept.cpp" )
CGAL_target_use_Eigen(heat_method_concept)
target_link_libraries(heat_method_concept PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "heat_method_surface_mesh_test.cpp" )
CGAL_target_use_Eigen(heat_method_surface_mesh_test)
target_link_libraries(heat_method_surface_mesh_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "heat_method_surface_mesh_direct_test.cpp" )
CGAL_target_use_Eigen(heat_method_surface_mesh_direct_test)
target_link_libraries(heat_method_surface_mesh_direct_test PUBLIC CGAL::Eigen_support)

44
Installation/cmake/modules/CGAL_Boost_iostreams_support.cmake Normal file
View File

@ -0,0 +1,44 @@
if(Boost_IOSTREAMS_FOUND AND NOT TARGET CGAL::Boost_iostreams_support)
if( WIN32 )
# to avoid a warning with old cmake
set(_Boost_BZIP2_HEADERS "boost/iostreams/filter/bzip2.hpp")
set(_Boost_ZLIB_HEADERS "boost/iostreams/filter/zlib.hpp")
find_package( Boost OPTIONAL_COMPONENTS bzip2 zlib)
if (Boost_ZLIB_FOUND AND Boost_BZIP2_FOUND)
set(ZLIB_LIBS ${Boost_ZLIB_LIBRARY} ${Boost_BZIP2_LIBRARY})
else()
message(STATUS "NOTICE: This project requires Boost ZLIB and Boost BZIP2, and will not be compiled.")
return()
endif()
else()
find_package(ZLIB QUIET)
if(ZLIB_FOUND)
set(ZLIB_LIBS ZLIB::ZLIB)
else()
message(STATUS "NOTICE: This project requires ZLIB, and will not be compiled.")
return()
endif()
endif()
if(TARGET Boost::iostreams)
set(Boost_LIB Boost::iostreams)
else()
set(Boost_LIB ${Boost_IOSTREAMS_LIBRARY})
endif()
add_library(CGAL::Boost_iostreams_support INTERFACE IMPORTED)
if(CMAKE_VERSION VERSION_LESS 3.11)
set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS"
INTERFACE_LINK_LIBRARIES ${Boost_LIB} ${ZLIB_LIBS})
else()
set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS")
target_link_libraries(CGAL::Boost_iostreams_support INTERFACE ${Boost_LIB} ${ZLIB_LIBS})
endif()
endif()

12
Installation/cmake/modules/CGAL_Boost_serialization_support.cmake Normal file
View File

@ -0,0 +1,12 @@
if(Boost_SERIALIZATION_FOUND AND NOT TARGET CGAL::Boost_serialization_support)
if(TARGET Boost::serialization)
set(Boost_LIB Boost::serialization)
else()
set(Boost_LIB ${Boost_SERIALIZATION_LIBRARY})
endif()
add_library(CGAL::Boost_serialization_support INTERFACE IMPORTED)
set_target_properties(CGAL::Boost_serialization_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_SERIALIZATION"
INTERFACE_LINK_LIBRARIES ${Boost_LIB})
endif()

15
Installation/cmake/modules/CGAL_Common.cmake
View File

@ -23,7 +23,7 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
else()
set( CMAKE_2_6_3_OR_ABOVE FALSE )
endif()
if ( CGAL_BUILDING_LIBS )
option(BUILD_SHARED_LIBS "Build shared libraries" ON)
set(CGAL_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
@ -34,7 +34,7 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
message( STATUS "Building static libraries" )
endif()
endif()
if ( WIN32 )
find_program(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin )
if(CMAKE_UNAME)
@ -61,15 +61,4 @@ if( NOT CGAL_COMMON_FILE_INCLUDED )
# set use-file for Eigen3 (needed to have default solvers)
set(EIGEN3_USE_FILE "UseEigen3")
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Boost_IOStreams.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Boost_Serialization.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_Eigen.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_GLPK.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_LASLIB.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_OpenCV.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_OpenGR.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_pointmatcher.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_SCIP.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_TBB.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_target_use_TensorFlow.cmake)
endif()

9
Installation/cmake/modules/CGAL_Eigen_support.cmake Normal file
View File

@ -0,0 +1,9 @@
if(EIGEN3_FOUND AND NOT TARGET CGAL::Eigen_support)
if(NOT TARGET Threads::Threads)
find_package(Threads REQUIRED)
endif()
add_library(CGAL::Eigen_support INTERFACE IMPORTED)
set_target_properties(CGAL::Eigen_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_EIGEN3_ENABLED"
INTERFACE_INCLUDE_DIRECTORIES "${EIGEN3_INCLUDE_DIR}")
endif()

7
Installation/cmake/modules/CGAL_GLPK_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(GLPK_FOUND AND NOT TARGET CGAL::GLPK_support)
add_library(CGAL::GLPK_support INTERFACE IMPORTED)
set_target_properties(CGAL::GLPK_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_USE_GLPK"
INTERFACE_INCLUDE_DIRECTORIES "${GLPK_INCLUDE_DIR}"
INTERFACE_LINK_LIBRARIES "${GLPK_LIBRARIES}")
endif()

7
Installation/cmake/modules/CGAL_LASLIB_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(LASLIB_FOUND AND NOT TARGET CGAL::LASLIB_support)
add_library(CGAL::LASLIB_support INTERFACE IMPORTED)
set_target_properties(CGAL::LASLIB_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_LASLIB"
INTERFACE_INCLUDE_DIRECTORIES "${LASLIB_INCLUDE_DIR};${LASZIP_INCLUDE_DIR}"
INTERFACE_LINK_LIBRARIES "${LASLIB_LIBRARIES}")
endif()

7
Installation/cmake/modules/CGAL_OpenCV_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(OpenCV_FOUND AND NOT TARGET CGAL::OpenCV_support)
add_library(CGAL::OpenCV_support INTERFACE IMPORTED)
set_target_properties(CGAL::OpenCV_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_OPENCV"
INTERFACE_INCLUDE_DIRECTORIES "${OpenCV_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${OpenCV_LIBS}")
endif()

6
Installation/cmake/modules/CGAL_OpenGR_support.cmake Normal file
View File

@ -0,0 +1,6 @@
if(OpenGR_FOUND AND NOT TARGET CGAL::OpenGR_support)
add_library(CGAL::OpenGR_support INTERFACE IMPORTED)
set_target_properties(CGAL::OpenGR_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_OPENGR"
INTERFACE_INCLUDE_DIRECTORIES "${OpenGR_INCLUDE_DIR}")
endif()

7
Installation/cmake/modules/CGAL_SCIP_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(SCIP_FOUND AND NOT TARGET CGAL::SCIP_support)
add_library(CGAL::SCIP_support INTERFACE IMPORTED)
set_target_properties(CGAL::SCIP_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_USE_SCIP"
INTERFACE_INCLUDE_DIRECTORIES "${SCIP_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "${SCIP_LIBRARIES}")
endif()

10
Installation/cmake/modules/CGAL_TBB_support.cmake Normal file
View File

@ -0,0 +1,10 @@
if(TBB_FOUND AND NOT TARGET CGAL::TBB_support)
if(NOT TARGET Threads::Threads)
find_package(Threads REQUIRED)
endif()
add_library(CGAL::TBB_support INTERFACE IMPORTED)
set_target_properties(CGAL::TBB_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_TBB;NOMINMAX"
INTERFACE_INCLUDE_DIRECTORIES "${TBB_INCLUDE_DIRS}"
INTERFACE_LINK_LIBRARIES "TBB::tbb;TBB::tbbmalloc;Threads::Threads")
endif()

7
Installation/cmake/modules/CGAL_TensorFlow_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(TensorFlow_FOUND AND NOT TARGET CGAL::TensorFlow_support)
add_library(CGAL::TensorFlow_support INTERFACE IMPORTED)
set_target_properties(CGAL::TensorFlow_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_TENSORFLOW"
INTERFACE_INCLUDE_DIRECTORIES "${TensorFlow_INCLUDE_DIR}"
INTERFACE_LINK_LIBRARIES "${TensorFlow_LIBRARY}")
endif()

7
Installation/cmake/modules/CGAL_pointmatcher_support.cmake Normal file
View File

@ -0,0 +1,7 @@
if(libpointmatcher_FOUND AND NOT TARGET CGAL::pointmatcher_support)
add_library(CGAL::pointmatcher_support INTERFACE IMPORTED)
set_target_properties(CGAL::pointmatcher_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_POINTMATCHER"
INTERFACE_INCLUDE_DIRECTORIES "${libpointmatcher_INCLUDE_DIR}"
INTERFACE_LINK_LIBRARIES "${libpointmatcher_LIBRARIES}")
endif()

41
Installation/cmake/modules/CGAL_target_use_Boost_IOStreams.cmake
View File

@ -1,41 +0,0 @@
if (CGAL_target_use_Boost_IOStreams_included)
return()
endif()
set(CGAL_target_use_Boost_IOStreams_included TRUE)
function(CGAL_target_use_Boost_IOStreams target)
if( WIN32 )
# to avoid a warning with old cmake
set(_Boost_BZIP2_HEADERS "boost/iostreams/filter/bzip2.hpp")
set(_Boost_ZLIB_HEADERS "boost/iostreams/filter/zlib.hpp")
find_package( Boost OPTIONAL_COMPONENTS bzip2 zlib)
else()
find_package(ZLIB QUIET)
endif()
if(TARGET Boost::iostreams)
target_link_libraries(${target} PUBLIC Boost::iostreams)
else()
target_link_libraries(${target} PUBLIC ${Boost_IOSTREAMS_LIBRARY})
endif()
if( WIN32 )
if (Boost_ZLIB_FOUND AND Boost_BZIP2_FOUND)
target_link_libraries(${target} PUBLIC ${Boost_ZLIB_LIBRARY} ${Boost_BZIP2_LIBRARY})
else()
message(STATUS "NOTICE: This project requires Boost ZLIB and Boost BZIP2, and will not be compiled.")
return()
endif()
else()
if(ZLIB_FOUND)
target_link_libraries(${target} PUBLIC ZLIB::ZLIB)
else()
message(STATUS "NOTICE: This project requires ZLIB, and will not be compiled.")
return()
endif()
endif()
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_BOOST_IOSTREAMS)
endfunction()

16
Installation/cmake/modules/CGAL_target_use_Boost_Serialization.cmake
View File

@ -1,16 +0,0 @@
if (CGAL_target_use_Boost_Serialization_included)
return()
endif()
set(CGAL_target_use_Boost_Serialization_included TRUE)
function(CGAL_target_use_Boost_Serialization target)
if(TARGET Boost::serialization)
target_link_libraries(${target} PUBLIC Boost::serialization)
else()
target_link_libraries(${target} PUBLIC ${Boost_SERIALIZATION_LIBRARY})
endif()
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_BOOST_SERIALIZATION)
endfunction()

13
Installation/cmake/modules/CGAL_target_use_Eigen.cmake
View File

@ -1,13 +0,0 @@
if (CGAL_target_use_Eigen_included)
return()
endif()
set(CGAL_target_use_Eigen_included TRUE)
set( Eigen3_FIND_VERSION "3.1.0")
set(EIGEN3_USE_FILE "UseEigen3")
function(CGAL_target_use_Eigen target)
target_include_directories(${target} PUBLIC ${EIGEN3_INCLUDE_DIR})
target_compile_options( ${target} PUBLIC -DCGAL_EIGEN3_ENABLED)
endfunction()

11
Installation/cmake/modules/CGAL_target_use_GLPK.cmake
View File

@ -1,11 +0,0 @@
if (CGAL_target_use_GLPK_included)
return()
endif()
set(CGAL_target_use_GLPK_included TRUE)
function(CGAL_target_use_GLPK target)
target_include_directories(${target} PUBLIC ${GLPK_INCLUDE_DIR})
target_compile_options(${target} PUBLIC -DCGAL_USE_GLPK)
target_link_libraries(${target} PUBLIC ${GLPK_LIBRARIES})
endfunction()

11
Installation/cmake/modules/CGAL_target_use_LASLIB.cmake
View File

@ -1,11 +0,0 @@
if (CGAL_target_use_LASLIB_included)
return()
endif()
set(CGAL_target_use_LASLIB_included TRUE)
function(CGAL_target_use_LASLIB target)
target_include_directories(${target} PUBLIC ${LASLIB_INCLUDE_DIR})
target_include_directories(${target} PUBLIC ${LASZIP_INCLUDE_DIR})
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_LASLIB)
target_link_libraries(${target} PUBLIC ${LASLIB_LIBRARIES})
endfunction()

10
Installation/cmake/modules/CGAL_target_use_OpenCV.cmake
View File

@ -1,10 +0,0 @@
if (CGAL_target_use_OpenCV_included)
return()
endif()
set(CGAL_target_use_OpenCV_included TRUE)
function(CGAL_target_use_OpenCV target)
target_include_directories(${target} PUBLIC ${OpenCV_INCLUDE_DIRS})
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_OPENCV)
target_link_libraries(${target} PUBLIC ${OpenCV_LIBS})
endfunction()

9
Installation/cmake/modules/CGAL_target_use_OpenGR.cmake
View File

@ -1,9 +0,0 @@
if (CGAL_target_use_OpenGR_included)
return()
endif()
set(CGAL_target_use_OpenGR_included TRUE)
function(CGAL_target_use_OpenGR target)
target_include_directories(${target} PUBLIC ${OpenGR_INCLUDE_DIR})
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_OPENGR)
endfunction()

11
Installation/cmake/modules/CGAL_target_use_SCIP.cmake
View File

@ -1,11 +0,0 @@
if (CGAL_target_use_SCIP_included)
return()
endif()
set(CGAL_target_use_SCIP_included TRUE)
function(CGAL_target_use_SCIP target)
target_include_directories(${target} PUBLIC ${SCIP_INCLUDE_DIRS})
target_compile_options(${target} PUBLIC -DCGAL_USE_SCIP)
target_link_libraries(${target} PUBLIC ${SCIP_LIBRARIES})
endfunction()

4
Installation/cmake/modules/CGAL_target_use_TBB.cmake
View File

@ -6,7 +6,9 @@ set(CGAL_target_use_TBB_included TRUE)
set(TBB_USE_FILE "UseTBB")
function(CGAL_target_use_TBB target)
if(NOT TARGET Threads::Threads)
message(DEPRECATION "This file CGAL_target_use_TBB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_TBB_support.cmake should be used instead.")
if(NOT TARGET
Threads::Threads)
find_package(Threads REQUIRED)
endif()
target_link_libraries( ${target} PUBLIC TBB::tbb TBB::tbbmalloc Threads::Threads)

10
Installation/cmake/modules/CGAL_target_use_TensorFlow.cmake
View File

@ -1,10 +0,0 @@
if (CGAL_target_use_TensorFlow_included)
return()
endif()
set(CGAL_target_use_TensorFlow_included TRUE)
function(CGAL_target_use_TensorFlow target)
target_include_directories(${target} PUBLIC ${TensorFlow_INCLUDE_DIR})
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_TENSORFLOW)
target_link_libraries(${target} PUBLIC ${TensorFlow_LIBRARU})
endfunction()

10
Installation/cmake/modules/CGAL_target_use_pointmatcher.cmake
View File

@ -1,10 +0,0 @@
if (CGAL_target_use_pointmatcher_included)
return()
endif()
set(CGAL_target_use_pointmatcher_included TRUE)
function(CGAL_target_use_pointmatcher target)
target_include_directories(${target} PUBLIC ${libpointmatcher_INCLUDE_DIR})
target_compile_options( ${target} PUBLIC -DCGAL_LINKED_WITH_POINTMATCHER)
target_link_libraries(${target} PUBLIC ${libpointmatcher_LIBRARIES})
endfunction()

2
Installation/cmake/modules/UseEigen3.cmake
View File

@ -8,4 +8,4 @@ add_definitions(-DCGAL_EIGEN3_ENABLED)
set (EIGEN3_SETUP TRUE)
message(DEPRECATION "This file UseEigen.cmake is deprecated, and the function `CGAL_target_use_Eigen` from CGAL_target_use_Eigen.cmake should be used instead.")
message(DEPRECATION "This file UseEigen.cmake is deprecated, and the imported target `CGAL::Eigen_support` from CGAL_Eigen_support.cmake should be used instead.")

3
Installation/cmake/modules/UseLASLIB.cmake
View File

@ -3,5 +3,4 @@
add_definitions(-DCGAL_LINKED_WITH_LASLIB)
message(DEPRECATION "This file UseLASLIB.cmake is deprecated, and the function `CGAL_target_use_LASLIB` from CGAL_target_use_LASLIB.cmake should be used instead.")
message(DEPRECATION "This file UseLASLIB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_LASLIB_support.cmake should be used instead.")

2
Installation/cmake/modules/UseTBB.cmake
View File

@ -5,4 +5,4 @@ include_directories ( ${TBB_INCLUDE_DIRS} )
link_directories( ${TBB_LIBRARY_DIRS} )
add_definitions( -DNOMINMAX -DCGAL_LINKED_WITH_TBB )
message(DEPRECATION "This file UseTBB.cmake is deprecated, and the function `CGAL_target_use_TBB` from CGAL_target_use_TBB.cmake should be used instead.")
message(DEPRECATION "This file UseTBB.cmake is deprecated, and the imported target `CGAL::TBB_support` from CGAL_TBB_support.cmake should be used instead.")

4
Installation/include/CGAL/config.h
View File

@ -105,6 +105,10 @@
// <boost/type_traits/detail/has_postfix_operator.hpp> fails as well
# define BOOST_TT_HAS_POST_DECREMENT_HPP_INCLUDED
# define BOOST_TT_HAS_POST_INCREMENT_HPP_INCLUDED
//work around for moc bug : https://bugreports.qt.io/browse/QTBUG-80990
#if defined(CGAL_LINKED_WITH_TBB)
#undef CGAL_LINKED_WITH_TBB
#endif
#endif
// Macro used by Boost Parameter. Mesh_3 needs at least 12, before the

10
Installation/lib/cmake/CGAL/CGALConfig.cmake
View File

@ -159,17 +159,7 @@ endforeach()
cgal_setup_module_path()
set(CGAL_USE_FILE ${CGAL_MODULES_DIR}/UseCGAL.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_Boost_IOStreams.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_Boost_Serialization.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_Eigen.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_GLPK.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_LASLIB.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_OpenCV.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_OpenGR.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_SCIP.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_TBB.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_TensorFlow.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_pointmatcher.cmake)
include("${CGAL_MODULES_DIR}/CGAL_parse_version_h.cmake")
cgal_parse_version_h( "${CGAL_INSTALLATION_PACKAGE_DIR}/include/CGAL/version.h"

5
Installation/test/Installation/CMakeLists.txt
View File

@ -48,9 +48,10 @@ if ( CGAL_FOUND )
endif()
find_package( TBB QUIET )
include(CGAL_TBB_support)
create_single_source_cgal_program( "test_TBB.cpp" )
if(TBB_FOUND)
CGAL_target_use_TBB(test_TBB)
if(TARGET CGAl::TBB_support)
target_link_libraries(test_TBB PUBLIC CGAL::TBB_support)
endif()
create_link_to_program(CGAL)

8
Jet_fitting_3/examples/Jet_fitting_3/CMakeLists.txt
View File

@ -13,7 +13,8 @@ if ( CGAL_FOUND )
# use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
# Link with Boost.ProgramOptions (optional)
find_package(Boost QUIET COMPONENTS program_options)
if(Boost_PROGRAM_OPTIONS_FOUND)
@ -30,9 +31,9 @@ if ( CGAL_FOUND )
endif()
create_single_source_cgal_program( "Mesh_estimation.cpp" )
CGAL_target_use_Eigen(Mesh_estimation)
target_link_libraries(Mesh_estimation PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "Single_estimation.cpp" )
CGAL_target_use_Eigen(Single_estimation)
target_link_libraries(Single_estimation PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
@ -43,4 +44,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

6
Jet_fitting_3/test/Jet_fitting_3/CMakeLists.txt
View File

@ -13,9 +13,10 @@ if ( CGAL_FOUND )
# use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "blind_1pt.cpp" )
CGAL_target_use_Eigen(blind_1pt)
target_link_libraries(blind_1pt PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
endif()
@ -25,4 +26,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

9
Mesh_3/benchmark/Mesh_3/CMakeLists.txt
View File

@ -57,12 +57,14 @@ if ( CGAL_FOUND )
if( CGAL_ACTIVATE_CONCURRENT_MESH_3 )
add_definitions( -DCGAL_CONCURRENT_MESH_3 )
find_package( TBB REQUIRED )
include(CGAL_TBB_support)
else()
option( LINK_WITH_TBB
"Link with TBB anyway so we can use TBB timers for profiling"
ON)
if( LINK_WITH_TBB )
find_package( TBB )
include(CGAL_TBB_support)
endif( LINK_WITH_TBB )
endif()
@ -81,11 +83,11 @@ if ( CGAL_FOUND )
if ( Boost_FOUND AND Boost_VERSION GREATER 103400 )
# Compilable benchmark
set (BENCHMARK_SOURCE_FILES "concurrency.cpp")
if(TBB_FOUND)
CGAL_target_use_TBB(concurrency)
endif()
ADD_MSVC_PRECOMPILED_HEADER("StdAfx.h" "StdAfx.cpp" BENCHMARK_SOURCE_FILES)
create_single_source_cgal_program( ${BENCHMARK_SOURCE_FILES} )
if(TARGET CGAL::TBB_support)
target_link_libraries(concurrency PUBLIC CGAL::TBB_support)
endif()
else()
message(STATUS "NOTICE: This program requires Boost >= 1.34.1, and will not be compiled.")
@ -94,4 +96,3 @@ if ( CGAL_FOUND )
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

95
Mesh_3/examples/Mesh_3/CMakeLists.txt
View File

@ -34,18 +34,21 @@ if ( CGAL_FOUND )
if( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
add_definitions( -DCGAL_CONCURRENT_MESH_3 )
find_package( TBB REQUIRED )
include(CGAL_TBB_support)
else( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
option( LINK_WITH_TBB
"Link with TBB anyway so we can use TBB timers for profiling"
ON)
if( LINK_WITH_TBB )
find_package( TBB )
include(CGAL_TBB_support)
endif( LINK_WITH_TBB )
endif()
# Use Eigen
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -70,92 +73,91 @@ if ( CGAL_FOUND )
# Compilable examples
create_single_source_cgal_program( "mesh_hybrid_mesh_domain.cpp" )
CGAL_target_use_Eigen(mesh_hybrid_mesh_domain)
target_link_libraries(mesh_hybrid_mesh_domain PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_implicit_sphere.cpp" )
CGAL_target_use_Eigen(mesh_implicit_sphere)
target_link_libraries(mesh_implicit_sphere PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_implicit_sphere_variable_size.cpp" )
CGAL_target_use_Eigen(mesh_implicit_sphere_variable_size)
target_link_libraries(mesh_implicit_sphere_variable_size PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_two_implicit_spheres_with_balls.cpp" )
CGAL_target_use_Eigen(mesh_two_implicit_spheres_with_balls)
target_link_libraries(mesh_two_implicit_spheres_with_balls PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_implicit_domains_2.cpp" "implicit_functions.cpp" )
CGAL_target_use_Eigen(mesh_implicit_domains_2)
target_link_libraries(mesh_implicit_domains_2 PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_cubes_intersection.cpp" )
CGAL_target_use_Eigen(mesh_cubes_intersection)
target_link_libraries(mesh_cubes_intersection PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_cubes_intersection_with_features.cpp" )
CGAL_target_use_Eigen(mesh_cubes_intersection_with_features)
target_link_libraries(mesh_cubes_intersection_with_features PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_implicit_domains.cpp" "implicit_functions.cpp" )
CGAL_target_use_Eigen(mesh_implicit_domains)
target_link_libraries(mesh_implicit_domains PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain)
target_link_libraries(mesh_polyhedral_domain PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain_sm.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain_sm)
target_link_libraries(mesh_polyhedral_domain_sm PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain_with_surface_inside.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain_with_surface_inside)
target_link_libraries(mesh_polyhedral_domain_with_surface_inside PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "remesh_polyhedral_surface.cpp" )
CGAL_target_use_Eigen(remesh_polyhedral_surface)
target_link_libraries(remesh_polyhedral_surface PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "remesh_polyhedral_surface_sm.cpp" )
CGAL_target_use_Eigen(remesh_polyhedral_surface_sm)
target_link_libraries(remesh_polyhedral_surface_sm PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain_with_features.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain_with_features)
target_link_libraries(mesh_polyhedral_domain_with_features PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain_with_features_sm.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain_with_features_sm)
target_link_libraries(mesh_polyhedral_domain_with_features_sm PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_domain_with_lipschitz_sizing.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_domain_with_lipschitz_sizing)
target_link_libraries(mesh_polyhedral_domain_with_lipschitz_sizing PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_complex.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_complex)
target_link_libraries(mesh_polyhedral_complex PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_polyhedral_complex_sm.cpp" )
CGAL_target_use_Eigen(mesh_polyhedral_complex_sm)
target_link_libraries(mesh_polyhedral_complex_sm PUBLIC CGAL::Eigen_support)
if( WITH_CGAL_ImageIO )
if( VTK_FOUND AND ("${VTK_VERSION_MAJOR}" GREATER "5" OR VTK_VERSION VERSION_GREATER 5) )
add_executable ( mesh_3D_gray_vtk_image mesh_3D_gray_vtk_image.cpp )
CGAL_target_use_Eigen(mesh_3D_gray_vtk_image)
target_link_libraries( mesh_3D_gray_vtk_image ${CGAL_LIBRARIES} ${CGAL_3RD_PARTY_LIBRARIES} ${VTK_LIBRARIES})
target_link_libraries( mesh_3D_gray_vtk_image PUBLIC CGAL::Eigen_support ${CGAL_LIBRARIES} ${CGAL_3RD_PARTY_LIBRARIES} ${VTK_LIBRARIES})
cgal_add_test( mesh_3D_gray_vtk_image )
add_to_cached_list( CGAL_EXECUTABLE_TARGETS mesh_3D_gray_vtk_image )
endif()
create_single_source_cgal_program( "mesh_3D_gray_image.cpp" )
CGAL_target_use_Eigen(mesh_3D_gray_image)
target_link_libraries(mesh_3D_gray_image PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_3D_gray_image_multiple_values.cpp" )
CGAL_target_use_Eigen(mesh_3D_gray_image_multiple_values)
target_link_libraries(mesh_3D_gray_image_multiple_values PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_3D_image_with_features.cpp" )
CGAL_target_use_Eigen(mesh_3D_image_with_features)
target_link_libraries(mesh_3D_image_with_features PUBLIC CGAL::Eigen_support)
if( CGAL_ImageIO_USE_ZLIB )
create_single_source_cgal_program( "mesh_optimization_example.cpp" )
CGAL_target_use_Eigen(mesh_optimization_example)
target_link_libraries(mesh_optimization_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_optimization_lloyd_example.cpp" )
CGAL_target_use_Eigen(mesh_optimization_lloyd_example)
target_link_libraries(mesh_optimization_lloyd_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_3D_image.cpp" )
CGAL_target_use_Eigen(mesh_3D_image)
target_link_libraries(mesh_3D_image PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_3D_image_with_custom_initialization.cpp" )
CGAL_target_use_Eigen(mesh_3D_image_with_custom_initialization)
target_link_libraries(mesh_3D_image_with_custom_initialization PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mesh_3D_image_variable_size.cpp" )
CGAL_target_use_Eigen(mesh_3D_image_variable_size)
target_link_libraries(mesh_3D_image_variable_size PUBLIC CGAL::Eigen_support)
else()
message( STATUS "NOTICE: The examples mesh_3D_image.cpp, mesh_3D_image_variable_size.cpp, mesh_optimization_example.cpp and mesh_optimization_lloyd_example.cpp need CGAL_ImageIO to be configured with ZLIB support, and will not be compiled." )
endif()
@ -167,28 +169,27 @@ if ( CGAL_FOUND )
# create_single_source_cgal_program( "mesh_polyhedral_surface_tolerance_region.cpp" )
# create_single_source_cgal_program( "mesh_polyhedral_edge_tolerance_region.cpp" )
if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TBB_FOUND AND TARGET ${target})
if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support AND TARGET ${target})
foreach(target
mesh_3D_image_with_features
mesh_3D_image
mesh_polyhedral_domain
mesh_3D_image_with_custom_initialization
mesh_two_implicit_spheres_with_balls
mesh_optimization_lloyd_example
mesh_optimization_example
mesh_implicit_sphere
mesh_polyhedral_complex_sm
mesh_implicit_sphere_variable_size
mesh_polyhedral_domain_sm
mesh_polyhedral_domain_with_lipschitz_sizing
mesh_polyhedral_complex
mesh_polyhedral_domain_with_features
mesh_3D_image_variable_size)
CGAL_target_use_TBB(${target})
mesh_3D_image_with_features
mesh_3D_image
mesh_polyhedral_domain
mesh_3D_image_with_custom_initialization
mesh_two_implicit_spheres_with_balls
mesh_optimization_lloyd_example
mesh_optimization_example
mesh_implicit_sphere
mesh_polyhedral_complex_sm
mesh_implicit_sphere_variable_size
mesh_polyhedral_domain_sm
mesh_polyhedral_domain_with_lipschitz_sizing
mesh_polyhedral_complex
mesh_polyhedral_domain_with_features
mesh_3D_image_variable_size)
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endforeach()
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

45
Mesh_3/test/Mesh_3/CMakeLists.txt
View File

@ -16,10 +16,12 @@ if ( CGAL_FOUND )
include( ${CGAL_USE_FILE} )
find_package( TBB QUIET )
include(CGAL_TBB_support)
# Use Eigen
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -91,32 +93,33 @@ if ( CGAL_FOUND )
test_mesh_polyhedral_domain_with_features_deprecated
test_meshing_with_one_step.cpp)
if(TARGET ${target})
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endif()
endforeach()
foreach(target
test_meshing_verbose
test_meshing_polyhedron_with_features
test_meshing_utilities.h
test_meshing_implicit_function
test_meshing_3D_image
test_meshing_3D_gray_image
test_meshing_unit_tetrahedron
test_meshing_polyhedron
test_meshing_polyhedral_complex
test_mesh_capsule_var_distance_bound
test_mesh_3_issue_1554
test_mesh_polyhedral_domain_with_features_deprecated
)
if(TBB_FOUND AND TARGET ${target})
CGAL_target_use_TBB(${target})
endif()
endforeach()
if(TARGET CGAL::TBB_support)
foreach(target
test_meshing_verbose
test_meshing_polyhedron_with_features
test_meshing_utilities.h
test_meshing_implicit_function
test_meshing_3D_image
test_meshing_3D_gray_image
test_meshing_unit_tetrahedron
test_meshing_polyhedron
test_meshing_polyhedral_complex
test_mesh_capsule_var_distance_bound
test_mesh_3_issue_1554
test_mesh_polyhedral_domain_with_features_deprecated
)
if(TARGET ${target})
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endif()
endforeach()
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

6
NewKernel_d/test/NewKernel_d/CMakeLists.txt
View File

@ -17,9 +17,10 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package(Eigen3)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "Epick_d.cpp" )
CGAL_target_use_Eigen(Epick_d)
target_link_libraries(Epick_d PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires the Eigen3 library, and will not be compiled.")
@ -31,4 +32,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

5
Number_types/test/Number_types/CMakeLists.txt
View File

@ -83,8 +83,9 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "eigen.cpp" )
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
if (EIGEN3_FOUND)
cgal_target_use_Eigen(eigen)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
target_link_libraries(eigen PUBLIC CGAL::Eigen_support)
endif()
else( CGAL_FOUND )

5
Optimal_bounding_box/benchmarks/Optimal_bounding_box/CMakeLists.txt
View File

@ -16,10 +16,11 @@ endif()
include( ${CGAL_USE_FILE} )
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
create_single_source_cgal_program("bench_obb.cpp")
CGAL_target_use_Eigen(bench_obb)
target_link_libraries(bench_obb PUBLIC CGAL::Eigen_support)

5
Optimal_bounding_box/examples/Optimal_bounding_box/CMakeLists.txt
View File

@ -14,7 +14,8 @@ endif()
include( ${CGAL_USE_FILE} )
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -27,5 +28,5 @@ foreach(target
obb_example
obb_with_point_maps_example
rotated_aabb_tree_example)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()

5
Optimal_bounding_box/test/Optimal_bounding_box/CMakeLists.txt
View File

@ -14,7 +14,8 @@ endif()
include( ${CGAL_USE_FILE} )
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -27,5 +28,5 @@ foreach(target
test_OBB_traits
test_nelder_mead
test_optimization_algorithms)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()

5
Periodic_3_mesh_3/examples/Periodic_3_mesh_3/CMakeLists.txt
View File

@ -23,7 +23,8 @@ endif()
# Use Eigen
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -52,5 +53,5 @@ foreach(target
mesh_implicit_shape_with_subdomains
mesh_implicit_shape_with_optimizers
mesh_implicit_shape_with_features)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()

10
Periodic_3_mesh_3/test/Periodic_3_mesh_3/CMakeLists.txt
View File

@ -16,21 +16,21 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
create_single_source_cgal_program( "test_implicit_shapes_bunch.cpp" )
CGAL_target_use_Eigen(test_implicit_shapes_bunch)
target_link_libraries(test_implicit_shapes_bunch PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "test_implicit_shapes_with_features.cpp" )
CGAL_target_use_Eigen(test_implicit_shapes_with_features)
target_link_libraries(test_implicit_shapes_with_features PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "test_triply_periodic_minimal_surfaces.cpp" )
CGAL_target_use_Eigen(test_triply_periodic_minimal_surfaces)
target_link_libraries(test_triply_periodic_minimal_surfaces PUBLIC CGAL::Eigen_support)
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

3
Point_set_3/examples/Point_set_3/CMakeLists.txt
View File

@ -44,9 +44,10 @@ set(needed_cxx_features cxx_rvalue_references cxx_variadic_templates)
create_single_source_cgal_program( "point_set_read_ply.cpp" CXX_FEATURES ${needed_cxx_features} )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
include(CGAL_Eigen_support)
if (EIGEN3_FOUND)
create_single_source_cgal_program( "point_set_algo.cpp" )
CGAL_target_use_Eigen(point_set_algo)
target_link_libraries(point_set_algo PUBLIC CGAL::Eigen_support)
endif()
create_single_source_cgal_program("draw_point_set_3.cpp" )

134
Point_set_processing_3/examples/Point_set_processing_3/CMakeLists.txt
View File

@ -31,117 +31,101 @@ if ( CGAL_FOUND )
"Enable concurrency"
OFF)
set(CGAL_libs CGAL::CGAL)
if( CGAL_ACTIVATE_CONCURRENT_PSP3 OR ENV{CGAL_ACTIVATE_CONCURRENT_PSP3} )
find_package( TBB REQUIRED )
include(CGAL_TBB_support)
if (TARGET CGAL::TBB_support)
set(CGAL_TBB_target ${CGAL_libs} CGAL::TBB_support)
endif()
endif()
# Executables that do *not* require EIGEN
create_single_source_cgal_program( "average_spacing_example.cpp" )
create_single_source_cgal_program( "bilateral_smooth_point_set_example.cpp" )
create_single_source_cgal_program( "grid_simplification_example.cpp" )
create_single_source_cgal_program( "grid_simplify_indices.cpp" )
create_single_source_cgal_program( "property_map.cpp" )
create_single_source_cgal_program( "random_simplification_example.cpp" )
create_single_source_cgal_program( "read_write_xyz_point_set_example.cpp" )
create_single_source_cgal_program( "remove_outliers_example.cpp" )
create_single_source_cgal_program( "wlop_simplify_and_regularize_point_set_example.cpp" )
create_single_source_cgal_program( "edge_aware_upsample_point_set_example.cpp" )
create_single_source_cgal_program( "structuring_example.cpp" )
create_single_source_cgal_program( "read_ply_points_with_colors_example.cpp" )
create_single_source_cgal_program( "write_ply_points_example.cpp" )
foreach(target
average_spacing_example
bilateral_smooth_point_set_example
grid_simplification_example
grid_simplify_indices
property_map
random_simplification_example
read_write_xyz_point_set_example
remove_outliers_example
wlop_simplify_and_regularize_point_set_example
edge_aware_upsample_point_set_example
structuring_example
read_ply_points_with_colors_example
write_ply_points_example)
add_executable(${target} "${target}.cpp")
target_link_libraries(${target} ${CGAL_libs})
endforeach()
find_package(LASLIB)
if (LASLIB_FOUND)
create_single_source_cgal_program( "read_las_example.cpp" )
CGAL_target_use_LASLIB(read_las_example)
include(CGAL_LASLIB_support)
if (TARGET CGAL::LASLIB_support)
add_executable( read_las_example "read_las_example.cpp" )
target_link_libraries(read_las_example ${CGAL_libs} CGAL::LASLIB_support)
else()
message(STATUS "NOTICE : the LAS reader test requires LASlib and will not be compiled.")
endif()
# Use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
set(CGAL_libs ${CGAL_libs} CGAL::Eigen_support)
# Executables that require Eigen
create_single_source_cgal_program( "jet_smoothing_example.cpp" )
CGAL_target_use_Eigen(jet_smoothing_example)
create_single_source_cgal_program( "normal_estimation.cpp" )
CGAL_target_use_Eigen(normal_estimation)
create_single_source_cgal_program( "clustering_example.cpp" )
CGAL_target_use_Eigen(clustering_example)
create_single_source_cgal_program( "edges_example.cpp" )
CGAL_target_use_Eigen(edges_example)
foreach(target
jet_smoothing_example
normal_estimation
clustering_example
edges_example
callback_example
scale_estimation_example
scale_estimation_2d_example
hierarchy_simplification_example
normals_example)
add_executable(${target} "${target}.cpp")
target_link_libraries(${target} ${CGAL_libs})
endforeach()
# Executables that require libpointmatcher
find_package(libpointmatcher QUIET)
if (libpointmatcher_FOUND)
create_single_source_cgal_program( "registration_with_pointmatcher.cpp" )
CGAL_target_use_pointmatcher(registration_with_pointmatcher)
CGAL_target_use_Eigen(registration_with_pointmatcher)
include(CGAL_pointmatcher_support)
if (TARGET CGAL::pointmatcher_support)
add_executable(registration_with_pointmatcher "registration_with_pointmatcher.cpp")
target_link_libraries(registration_with_pointmatcher
${CGAL_libs} CGAL::pointmatcher_support)
else()
message(STATUS "NOTICE : the registration_with_pointmatcher test requires libpointmatcher and will not be compiled.")
endif()
# Executables that require OpenGR
find_package(OpenGR QUIET)
if (OpenGR_FOUND)
create_single_source_cgal_program( "registration_with_OpenGR.cpp" )
CGAL_target_use_OpenGR(registration_with_OpenGR)
CGAL_target_use_Eigen(registration_with_OpenGR)
include(CGAL_OpenGR_support)
if (TARGET CGAL::OpenGR_support)
add_executable(registration_with_OpenGR "registration_with_OpenGR.cpp" )
target_link_libraries(registration_with_OpenGR
${CGAL_libs} CGAL::OpenGR_support)
else()
message(STATUS "NOTICE : registration_with_OpenGR requires OpenGR, and will not be compiled.")
endif()
# Executables that require both libpointmatcher and OpenGR
if (libpointmatcher_FOUND AND OpenGR_FOUND)
create_single_source_cgal_program( "registration_with_opengr_pointmatcher_pipeline.cpp" )
CGAL_target_use_OpenGR(registration_with_opengr_pointmatcher_pipeline)
CGAL_target_use_pointmatcher(registration_with_opengr_pointmatcher_pipeline)
CGAL_target_use_Eigen(registration_with_opengr_pointmatcher_pipeline)
if (TARGET CGAL::pointmatcher_support AND
TARGET CGAL::OpenGR_support)
add_executable(registration_with_opengr_pointmatcher_pipeline
"registration_with_opengr_pointmatcher_pipeline.cpp" )
target_link_libraries(registration_with_opengr_pointmatcher_pipeline
${CGAL_libs} CGAL::pointmatcher_support CGAL::OpenGR_support)
else()
message(STATUS "NOTICE : registration_with_opengr_pointmatcher_pipeline requires libpointmatcher and OpenGR, and will not be compiled.")
endif()
create_single_source_cgal_program( "callback_example.cpp" )
CGAL_target_use_Eigen(callback_example)
create_single_source_cgal_program( "scale_estimation_example.cpp" )
CGAL_target_use_Eigen(scale_estimation_example)
create_single_source_cgal_program( "scale_estimation_2d_example.cpp" )
CGAL_target_use_Eigen(scale_estimation_2d_example)
create_single_source_cgal_program( "hierarchy_simplification_example.cpp" )
CGAL_target_use_Eigen(hierarchy_simplification_example)
create_single_source_cgal_program( "normals_example.cpp" )
CGAL_target_use_Eigen(normals_example)
else()
message(STATUS "NOTICE: Some of the executables in this directory need Eigen 3.1 (or greater) and will not be compiled.")
endif()
if (TBB_FOUND)
foreach(target
scale_estimation_example
wlop_simplify_and_regularize_point_set_example
bilateral_smooth_point_set_example
edge_aware_upsample_point_set_example
average_spacing_example
normals_example
jet_smoothing_example
normal_estimation
callback_example
clustering_example)
if(TARGET ${target})
CGAL_target_use_TBB(${target})
endif()
endforeach()
endif()
else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

19
Point_set_processing_3/test/Point_set_processing_3/CMakeLists.txt
View File

@ -27,6 +27,7 @@ if ( CGAL_FOUND )
ADD_DEFINITIONS( "-DDEBUG_TRACE" )
find_package( TBB QUIET )
include(CGAL_TBB_support)
# Executables that do *not* require Eigen
create_single_source_cgal_program( "read_test.cpp" )
@ -40,30 +41,31 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
include(CGAL_Eigen_support)
if (EIGEN3_FOUND)
# Executables that require Eigen
create_single_source_cgal_program( "normal_estimation_test.cpp" )
CGAL_target_use_Eigen(normal_estimation_test)
target_link_libraries(normal_estimation_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "hierarchy_simplification_test.cpp" )
CGAL_target_use_Eigen(hierarchy_simplification_test)
target_link_libraries(hierarchy_simplification_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "smoothing_test.cpp" )
CGAL_target_use_Eigen(smoothing_test)
target_link_libraries(smoothing_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vcm_plane_test.cpp" )
CGAL_target_use_Eigen(vcm_plane_test)
target_link_libraries(vcm_plane_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vcm_all_test.cpp" )
CGAL_target_use_Eigen(vcm_all_test)
target_link_libraries(vcm_all_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "jet_pointer_as_property_map.cpp" )
CGAL_target_use_Eigen(jet_pointer_as_property_map)
target_link_libraries(jet_pointer_as_property_map PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
endif()
if (TBB_FOUND)
if (TARGET CGAL::TBB_support)
foreach(target
analysis_test
smoothing_test
@ -72,7 +74,7 @@ if ( CGAL_FOUND )
edge_aware_upsample_test
normal_estimation_test)
if(TARGET ${target})
CGAL_target_use_TBB(${target})
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endif()
endforeach()
endif()
@ -82,4 +84,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

12
Poisson_surface_reconstruction_3/examples/Poisson_surface_reconstruction_3/CMakeLists.txt
View File

@ -23,16 +23,17 @@ if ( CGAL_FOUND )
# Find Eigen3 (requires 3.1.0 or greater)
find_package(Eigen3 3.1.0)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
# Executables that require Eigen 3
create_single_source_cgal_program( "poisson_reconstruction_example.cpp" )
CGAL_target_use_Eigen(poisson_reconstruction_example)
target_link_libraries(poisson_reconstruction_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "poisson_reconstruction.cpp" )
CGAL_target_use_Eigen(poisson_reconstruction)
target_link_libraries(poisson_reconstruction PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "poisson_reconstruction_function.cpp" )
CGAL_target_use_Eigen(poisson_reconstruction_function)
target_link_libraries(poisson_reconstruction_function PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "tutorial_example.cpp" )
CGAL_target_use_Eigen(tutorial_example)
target_link_libraries(tutorial_example PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: The examples need Eigen 3.1 (or greater) will not be compiled.")
endif()
@ -43,4 +44,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

6
Poisson_surface_reconstruction_3/test/Poisson_surface_reconstruction_3/CMakeLists.txt
View File

@ -24,10 +24,11 @@ if ( CGAL_FOUND )
# Temporary debugging stuff
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if(EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(TARGET CGAL::Eigen_support)
# Executables that require Eigen 3.1
create_single_source_cgal_program( "poisson_reconstruction_test.cpp" )
CGAL_target_use_Eigen(poisson_reconstruction_test)
target_link_libraries(poisson_reconstruction_test PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: Some of the executables in this directory need Eigen 3.1 (or greater) and will not be compiled.")
@ -39,4 +40,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

8
Polygon_mesh_processing/benchmark/Polygon_mesh_processing/CMakeLists.txt
View File

@ -29,6 +29,7 @@ endif()
# include for local package
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
# Creating entries for all .cpp/.C files with "main" routine
# ##########################################################
@ -37,8 +38,7 @@ create_single_source_cgal_program( "polygon_mesh_slicer.cpp" )
create_single_source_cgal_program( "hole_filling.cpp" )
if (EIGEN3_FOUND)
CGAL_target_use_Eigen(polygon_mesh_slicer)
CGAL_target_use_Eigen(hole_filling)
if (TARGET CGAL::Eigen_support)
target_link_libraries(polygon_mesh_slicer PUBLIC CGAL::Eigen_support)
target_link_libraries(hole_filling PUBLIC CGAL::Eigen_support)
endif()

27
Polygon_mesh_processing/examples/Polygon_mesh_processing/CMakeLists.txt
View File

@ -38,6 +38,7 @@ endif()
# include for local package
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
# Creating entries for all .cpp/.C files with "main" routine
@ -45,18 +46,18 @@ find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
create_single_source_cgal_program( "hausdorff_distance_remeshing_example.cpp")
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "hole_filling_example.cpp" )
CGAL_target_use_Eigen(hole_filling_example)
target_link_libraries(hole_filling_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "hole_filling_example_SM.cpp" )
CGAL_target_use_Eigen(hole_filling_example_SM)
target_link_libraries(hole_filling_example_SM PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "refine_fair_example.cpp")
CGAL_target_use_Eigen(refine_fair_example)
target_link_libraries(refine_fair_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "shape_smoothing_example.cpp")
CGAL_target_use_Eigen(shape_smoothing_example)
target_link_libraries(shape_smoothing_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "hole_filling_example_LCC.cpp" )
CGAL_target_use_Eigen(hole_filling_example_LCC)
endif(EIGEN3_FOUND)
target_link_libraries(hole_filling_example_LCC PUBLIC CGAL::Eigen_support)
endif()
create_single_source_cgal_program( "self_intersections_example.cpp" )
create_single_source_cgal_program( "stitch_borders_example.cpp" )
@ -98,10 +99,9 @@ if(OpenMesh_FOUND)
create_single_source_cgal_program( "compute_normals_example_OM.cpp" )
target_link_libraries( compute_normals_example_OM PRIVATE ${OPENMESH_LIBRARIES} )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "hole_filling_example_OM.cpp" )
target_link_libraries( hole_filling_example_OM PRIVATE ${OPENMESH_LIBRARIES} )
CGAL_target_use_Eigen( hole_filling_example_OM )
target_link_libraries( hole_filling_example_OM PRIVATE CGAL::Eigen_support ${OPENMESH_LIBRARIES} )
endif()
create_single_source_cgal_program( "point_inside_example_OM.cpp")
@ -118,9 +118,10 @@ target_link_libraries( triangulate_faces_example_OM PRIVATE ${OPENMESH_LIBRARIES
endif(OpenMesh_FOUND)
find_package( TBB )
if( TBB_FOUND )
CGAL_target_use_TBB(self_intersections_example)
CGAL_target_use_TBB(hausdorff_distance_remeshing_example)
include(CGAL_TBB_support)
if( TARGET CGAL::TBB_support )
target_link_libraries(self_intersections_example PUBLIC CGAL::TBB_support)
target_link_libraries(hausdorff_distance_remeshing_example PUBLIC CGAL::TBB_support)
else()
message( STATUS "NOTICE: Intel TBB was not found. Sequential code will be used." )
endif()

23
Polygon_mesh_processing/test/Polygon_mesh_processing/CMakeLists.txt
View File

@ -31,22 +31,24 @@ endif()
# include for local package
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
find_package( TBB )
include(CGAL_TBB_support)
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
# Creating entries for all .cpp/.C files with "main" routine
# ##########################################################
create_single_source_cgal_program("fairing_test.cpp")
CGAL_target_use_Eigen(fairing_test)
target_link_libraries(fairing_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program("triangulate_hole_Polyhedron_3_no_delaunay_test.cpp" )
CGAL_target_use_Eigen(triangulate_hole_Polyhedron_3_no_delaunay_test)
target_link_libraries(triangulate_hole_Polyhedron_3_no_delaunay_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program("triangulate_hole_Polyhedron_3_test.cpp")
CGAL_target_use_Eigen(triangulate_hole_Polyhedron_3_test)
target_link_libraries(triangulate_hole_Polyhedron_3_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program("test_shape_smoothing.cpp")
CGAL_target_use_Eigen(test_shape_smoothing)
target_link_libraries(test_shape_smoothing PUBLIC CGAL::Eigen_support)
endif(EIGEN3_FOUND)
endif()
find_package( OpenMesh QUIET )
if ( OpenMesh_FOUND )
@ -103,11 +105,10 @@ endif()
create_single_source_cgal_program("test_remove_caps_needles.cpp")
# create_single_source_cgal_program("test_pmp_repair_self_intersections.cpp")
if( TBB_FOUND )
include(CGAL_target_use_TBB)
CGAL_target_use_TBB(test_pmp_distance)
CGAL_target_use_TBB(orient_polygon_soup_test)
CGAL_target_use_TBB(self_intersection_surface_mesh_test)
if( TARGET CGAL::TBB_support )
target_link_libraries(test_pmp_distance PUBLIC CGAL::TBB_support)
target_link_libraries(orient_polygon_soup_test PUBLIC CGAL::TBB_support)
target_link_libraries(self_intersection_surface_mesh_test PUBLIC CGAL::TBB_support)
else()
message( STATUS "NOTICE: Intel TBB was not found. test_pmp_distance will use sequential code." )
endif()

17
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/CMakeLists.txt
View File

@ -37,15 +37,18 @@ endif()
include( CGAL_CreateSingleSourceCGALProgram )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if(NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: This project requires Eigen 3.1 (or greater) and will not be compiled.")
return()
endif()
find_package(SCIP QUIET)
if (NOT SCIP_FOUND )
include(CGAL_SCIP_support)
if (NOT TARGET CGAL::SCIP_support )
find_package( GLPK QUIET)
if ( NOT GLPK_FOUND )
include(CGAL_GLPK_support)
if (NOT TARGET CGAL::GLPK_support )
message( STATUS "NOTICE: This project requires either SCIP or GLPK, and will not be compiled.")
return()
endif()
@ -61,10 +64,10 @@ foreach(target
polyfit_example_user_provided_planes
polyfit_example_model_complexty_control
polyfit_example_with_region_growing)
CGAL_target_use_Eigen(${target})
if (SCIP_FOUND)
CGAL_target_use_SCIP(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
if (TARGET CGAL::SCIP_support)
target_link_libraries(${target} PUBLIC CGAL::SCIP_support)
else()
CGAL_target_use_GLPK(${target})
target_link_libraries(${target} PUBLIC CGAL::GLPK_support)
endif()
endforeach()

19
Polygonal_surface_reconstruction/test/Polygonal_surface_reconstruction/CMakeLists.txt
View File

@ -38,24 +38,27 @@ include( CGAL_CreateSingleSourceCGALProgram )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if(NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: This project requires Eigen 3.1 (or greater) and will not be compiled.")
return()
endif()
find_package(SCIP QUIET)
if (NOT SCIP_FOUND )
include(CGAL_SCIP_support)
if (NOT TARGET CGAL::SCIP_support )
find_package( GLPK QUIET)
if ( NOT GLPK_FOUND )
message( STATUS "NOTICE : This project requires either SCIP or GLPK, and will not be compiled.")
include(CGAL_GLPK_support)
if (NOT TARGET CGAL::GLPK_support )
message( STATUS "NOTICE: This project requires either SCIP or GLPK, and will not be compiled.")
return()
endif()
endif()
create_single_source_cgal_program( "polygonal_surface_reconstruction_test.cpp")
CGAL_target_use_Eigen(polygonal_surface_reconstruction_test)
if (SCIP_FOUND)
CGAL_target_use_SCIP(polygonal_surface_reconstruction_test)
target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::Eigen_support)
if (TARGET CGAL::SCIP_support)
target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::SCIP_support)
else()
CGAL_target_use_GLPK(polygonal_surface_reconstruction_test)
target_link_libraries(polygonal_surface_reconstruction_test PUBLIC CGAL::GLPK_support)
endif()

36
Polyhedron/demo/Polyhedron/CMakeLists.txt
View File

@ -73,6 +73,7 @@ if(Qt5_FOUND)
endif(Qt5_FOUND)
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
find_package( METIS )
@ -87,7 +88,8 @@ option(POLYHEDRON_DEMO_ACTIVATE_CONCURRENCY
if( POLYHEDRON_DEMO_ACTIVATE_CONCURRENCY )
find_package( TBB )
if( NOT TBB_FOUND )
include(CGAL_TBB_support)
if( NOT TARGET CGAL::TBB_support )
message( STATUS "NOTICE: Intel TBB was not found. Bilateral smoothing and WLOP plugins are faster if TBB is linked." )
endif()
endif()
@ -108,7 +110,8 @@ if( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
add_definitions( -DCGAL_CONCURRENT_MESH_3 )
if(NOT TBB_FOUND)
find_package( TBB REQUIRED )
if( NOT TBB_FOUND )
include( CGAL_TBB_support)
if( NOT TARGET CGAL::TBB_support )
message(STATUS "NOTICE: Intel TBB was not found. Mesh_3 is faster if TBB is linked.")
endif()
endif()
@ -119,6 +122,7 @@ else( CGAL_ACTIVATE_CONCURRENT_MESH_3 OR ENV{CGAL_ACTIVATE_CONCURRENT_MESH_3} )
ON)
if( LINK_WITH_TBB )
find_package( TBB )
include( CGAL_TBB_support)
endif( LINK_WITH_TBB )
endif()
@ -248,8 +252,8 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
add_item(scene_c3t3_item Scene_c3t3_item.cpp)
target_link_libraries(scene_c3t3_item PUBLIC scene_surface_mesh_item scene_polygon_soup_item scene_basic_objects ${TBB_LIBRARIES})
if(TBB_FOUND)
CGAL_target_use_TBB(scene_c3t3_item)
if(TARGET CGAL::TBB_support)
target_link_libraries(scene_c3t3_item PUBLIC CGAL::TBB_support)
endif()
if(COMMAND target_precompile_headers)
# Support for precompiled headers, for Mesh_3 (since CMake 3.16)
@ -261,7 +265,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
add_item(scene_surface_mesh_item Scene_surface_mesh_item.cpp)
if(TBB_FOUND)
CGAL_target_use_TBB(scene_surface_mesh_item)
target_link_libraries(scene_surface_mesh_item PUBLIC CGAL::TBB_support)
endif()
# special
@ -274,7 +278,7 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
add_item(scene_selection_item Scene_polyhedron_selection_item.cpp)
target_link_libraries(scene_selection_item PUBLIC scene_item_decorator scene_k_ring_selection)
if(TBB_FOUND)
CGAL_target_use_TBB(scene_selection_item)
target_link_libraries(scene_selection_item PUBLIC CGAL::TBB_support)
endif()
add_item(scene_shortest_path_item Plugins/Surface_mesh/Scene_polyhedron_shortest_path_item.cpp)
@ -282,17 +286,16 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
add_item(scene_movable_sm_item Plugins/AABB_tree/Scene_movable_sm_item.cpp)
if(EIGEN3_FOUND )
if(TARGET CGAL::Eigen_support )
add_item(scene_textured_item Scene_textured_surface_mesh_item.cpp texture.cpp)
CGAL_target_use_Eigen(scene_textured_item)
target_link_libraries(scene_textured_item PUBLIC CGAL::Eigen_support)
qt5_wrap_ui( editionUI_FILES Plugins/Surface_mesh_deformation/Deform_mesh.ui )
add_item(scene_edit_item Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.cpp
${editionUI_FILES})
CGAL_target_use_Eigen(scene_edit_item)
target_link_libraries(scene_edit_item PUBLIC scene_surface_mesh_item scene_k_ring_selection
target_link_libraries(scene_edit_item PUBLIC CGAL::Eigen_support scene_surface_mesh_item scene_k_ring_selection
scene_basic_objects)
add_item(scene_mcf_item Plugins/PMP/Scene_mcf_item.cpp)
CGAL_target_use_Eigen(scene_mcf_item)
target_link_libraries(scene_mcf_item PUBLIC CGAL::Eigen_support)
endif()
add_item(scene_implicit_function_item Scene_implicit_function_item.cpp )
@ -305,20 +308,21 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND)
target_link_libraries(scene_nef_polyhedron_item PUBLIC scene_surface_mesh_item)
add_item(scene_points_with_normal_item Scene_points_with_normal_item.cpp)
if (EIGEN3_FOUND)
CGAL_target_use_Eigen(scene_points_with_normal_item)
if (TARGET CGAL::Eigen_support)
target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::Eigen_support)
endif()
find_package(LASLIB)
if (LASLIB_FOUND)
CGAL_target_use_LASLIB(scene_points_with_normal_item)
include(CGAL_LASLIB_support)
if (TARGET CGAL::LASLIB_support)
target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::LASLIB_support)
if (MSVC)
target_compile_definitions( scene_points_with_normal_item PUBLIC "-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS")
endif()
endif()
if(TBB_FOUND)
CGAL_target_use_TBB(scene_points_with_normal_item)
target_link_libraries(scene_points_with_normal_item PUBLIC CGAL::TBB_support)
endif()
add_item(scene_polylines_item Scene_polylines_item.cpp)

4
Polyhedron/demo/Polyhedron/Plugins/AABB_tree/CMakeLists.txt
View File

@ -5,6 +5,6 @@ target_link_libraries(do_trees_intersect_plugin PUBLIC scene_surface_mesh_item s
polyhedron_demo_plugin(cut_plugin Cut_plugin )
target_link_libraries(cut_plugin PUBLIC scene_surface_mesh_item scene_basic_objects scene_color_ramp)
if(TBB_FOUND)
CGAL_target_use_TBB(cut_plugin)
if(TARGET CGAL::TBB_support)
target_link_libraries(cut_plugin PUBLIC CGAL::TBB_support)
endif()

39
Polyhedron/demo/Polyhedron/Plugins/Classification/CMakeLists.txt
View File

@ -1,54 +1,61 @@
include( polyhedron_demo_macros )
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
set(Classification_dependencies_met TRUE)
find_package( Boost OPTIONAL_COMPONENTS serialization iostreams )
if (NOT Boost_SERIALIZATION_FOUND)
include(CGAL_Boost_serialization_support)
include(CGAL_Boost_iostreams_support)
if (NOT TARGET CGAL::Boost_serialization_support)
message(STATUS "NOTICE: Boost Serialization not found. Classification plugin won't be available.")
set(Classification_dependencies_met FALSE)
endif()
if (NOT Boost_IOSTREAMS_FOUND)
if (NOT TARGET CGAL::Boost_iostreams_support)
message(STATUS "NOTICE: Boost IOStreams not found. Classification plugin won't be available.")
set(Classification_dependencies_met FALSE)
endif()
find_package(OpenCV QUIET COMPONENTS core ml) # Need core + machine learning
if (NOT OpenCV_FOUND)
include(CGAL_OpenCV_support)
if (NOT TARGET CGAL::OpenCV_support)
message(STATUS "NOTICE: OpenCV was not found. OpenCV random forest predicate for classification won't be available.")
endif()
find_package(TensorFlow QUIET)
if (NOT TensorFlow_FOUND)
include(CGAL_TensorFlow_support)
if (NOT TARGET CGAL::TensorFlow_support)
message(STATUS "NOTICE: TensorFlow not found, Neural Network predicate for classification won't be available.")
endif()
if (Classification_dependencies_met)
qt5_wrap_ui( classificationUI_FILES Classification_widget.ui Classification_advanced_widget.ui )
polyhedron_demo_plugin(classification_plugin Classification_plugin Point_set_item_classification Cluster_classification Surface_mesh_item_classification ${classificationUI_FILES} KEYWORDS Classification)
target_link_libraries(classification_plugin PUBLIC scene_points_with_normal_item
scene_polylines_item scene_polygon_soup_item scene_surface_mesh_item scene_selection_item scene_color_ramp)
target_link_libraries(classification_plugin PUBLIC
scene_points_with_normal_item
scene_polylines_item
scene_polygon_soup_item
scene_surface_mesh_item
scene_selection_item
scene_color_ramp
CGAL::Eigen_support
CGAL::Boost_serialization_support
CGAL::Boost_iostreams_support)
CGAL_target_use_Eigen(classification_plugin)
CGAL_target_use_Boost_IOStreams(classification_plugin)
CGAL_target_use_Boost_Serialization(classification_plugin)
if(OpenCV_FOUND)
CGAL_target_use_OpenCV(classification_plugin)
target_link_libraries(classification_plugin PUBLIC CGAL::OpenCV_support)
endif()
if(TensorFlow_FOUND)
CGAL_target_use_TensorFlow(classification_plugin)
target_link_libraries(classification_plugin PUBLIC CGAL::TensorFlow_support)
endif()
if(TBB_FOUND)
CGAL_target_use_TBB(classification_plugin)
target_link_libraries(classification_plugin PUBLIC CGAL::TBB_support)
endif()
add_dependencies(classification_plugin point_set_selection_plugin selection_plugin)
endif()
else(EIGEN3_FOUND)
else()
message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. Classification plugin will not be available.")
endif()

7
Polyhedron/demo/Polyhedron/Plugins/Display/CMakeLists.txt
View File

@ -1,7 +1,6 @@
include( polyhedron_demo_macros )
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
qt5_wrap_ui( display_propertyUI_FILES Display_property.ui )
polyhedron_demo_plugin(display_property_plugin Display_property_plugin ${display_propertyUI_FILES})
target_link_libraries(display_property_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_color_ramp)
CGAL_target_use_Eigen(display_property_plugin)
endif(EIGEN3_FOUND)
target_link_libraries(display_property_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_color_ramp CGAL::Eigen_support)
endif()

5
Polyhedron/demo/Polyhedron/Plugins/IO/CMakeLists.txt
View File

@ -72,11 +72,10 @@ else()
target_link_libraries(ply_plugin PUBLIC scene_points_with_normal_item scene_polygon_soup_item scene_surface_mesh_item scene_textured_item)
target_compile_features(ply_plugin PRIVATE ${needed_cxx_features})
if (LASLIB_FOUND)
if (TARGET CGAL::LASLIB_support)
polyhedron_demo_plugin(las_plugin LAS_io_plugin KEYWORDS IO PointSetProcessing Classification)
target_link_libraries(las_plugin PUBLIC scene_points_with_normal_item)
target_link_libraries(las_plugin PUBLIC scene_points_with_normal_item CGAL::LASLIB_support)
target_compile_features(las_plugin PRIVATE ${needed_cxx_features})
CGAL_target_use_LASLIB(las_plugin)
else()
message(STATUS "NOTICE : the LAS IO plugin needs LAS libraries and will not be compiled.")
endif()

13
Polyhedron/demo/Polyhedron/Plugins/Mesh_3/CMakeLists.txt
View File

@ -54,9 +54,10 @@ target_link_libraries(mesh_3_optimization_plugin PUBLIC scene_c3t3_item scene_su
# Use Eigen
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
include(CGAL_Eigen_support)
if (EIGEN3_FOUND)
CGAL_target_use_Eigen(mesh_3_optimization_plugin)
if (TARGET CGAL::Eigen_support)
target_link_libraries(mesh_3_optimization_plugin PUBLIC CGAL::Eigen_support)
else() #eigen
message(STATUS "The Mesh_3_optimization_plugin requires Eigen, which was not found, and will use a deprecated class to replace it. Warnings are to be expected.")
endif()#eigen
@ -69,8 +70,8 @@ polyhedron_demo_plugin(c3t3_rib_exporter_plugin C3t3_rib_exporter_plugin ${ribUI
target_link_libraries(c3t3_rib_exporter_plugin PUBLIC scene_c3t3_item)
if(TBB_FOUND)
CGAL_target_use_TBB(mesh_3_plugin)
CGAL_target_use_TBB(mesh_3_optimization_plugin)
CGAL_target_use_TBB(c3t3_io_plugin)
CGAL_target_use_TBB(c3t3_rib_exporter_plugin)
target_link_libraries(mesh_3_plugin PUBLIC CGAL::TBB_support)
target_link_libraries(mesh_3_optimization_plugin PUBLIC CGAL::TBB_support)
target_link_libraries(c3t3_io_plugin PUBLIC CGAL::TBB_support)
target_link_libraries(c3t3_rib_exporter_plugin PUBLIC CGAL::TBB_support)
endif()

39
Polyhedron/demo/Polyhedron/Plugins/PMP/CMakeLists.txt
View File

@ -1,33 +1,29 @@
include( polyhedron_demo_macros )
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
polyhedron_demo_plugin(jet_fitting_plugin Jet_fitting_plugin)
target_link_libraries(jet_fitting_plugin PUBLIC scene_surface_mesh_item scene_polylines_item)
CGAL_target_use_Eigen(jet_fitting_plugin)
target_link_libraries(jet_fitting_plugin PUBLIC scene_surface_mesh_item scene_polylines_item CGAL::Eigen_support)
else(EIGEN3_FOUND)
else()
message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. Jet fitting plugin will not be available.")
endif(EIGEN3_FOUND)
endif()
polyhedron_demo_plugin(extrude_plugin Extrude_plugin KEYWORDS PMP)
target_link_libraries(extrude_plugin PUBLIC scene_surface_mesh_item scene_selection_item)
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
if("${EIGEN3_VERSION}" VERSION_GREATER "3.1.90")
qt5_wrap_ui( hole_fillingUI_FILES Hole_filling_widget.ui)
polyhedron_demo_plugin(hole_filling_plugin Hole_filling_plugin ${hole_fillingUI_FILES} KEYWORDS PMP)
target_link_libraries(hole_filling_plugin PUBLIC scene_surface_mesh_item scene_polylines_item scene_selection_item)
CGAL_target_use_Eigen(hole_filling_plugin)
target_link_libraries(hole_filling_plugin PUBLIC scene_surface_mesh_item scene_polylines_item scene_selection_item CGAL::Eigen_support)
qt5_wrap_ui( fairingUI_FILES Fairing_widget.ui)
polyhedron_demo_plugin(fairing_plugin Fairing_plugin ${fairingUI_FILES} KEYWORDS PMP)
target_link_libraries(fairing_plugin PUBLIC scene_selection_item)
CGAL_target_use_Eigen(fairing_plugin)
target_link_libraries(fairing_plugin PUBLIC scene_selection_item CGAL::Eigen_support)
polyhedron_demo_plugin(hole_filling_polyline_plugin Hole_filling_polyline_plugin )
target_link_libraries(hole_filling_polyline_plugin PUBLIC scene_surface_mesh_item scene_polylines_item)
CGAL_target_use_Eigen(hole_filling_polyline_plugin)
target_link_libraries(hole_filling_polyline_plugin PUBLIC scene_surface_mesh_item scene_polylines_item CGAL::Eigen_support)
qt5_wrap_ui( Mean_curvature_flow_skeleton_pluginUI_FILES Mean_curvature_flow_skeleton_plugin.ui)
polyhedron_demo_plugin(mean_curvature_flow_skeleton_plugin Mean_curvature_flow_skeleton_plugin ${Mean_curvature_flow_skeleton_pluginUI_FILES})
@ -37,20 +33,19 @@ if(EIGEN3_FOUND)
scene_points_with_normal_item
scene_polylines_item
scene_mcf_item
demo_framework)
CGAL_target_use_Eigen(mean_curvature_flow_skeleton_plugin)
demo_framework
CGAL::Eigen_support)
# The smoothing plugin can still do some things, even if Ceres is not found
qt5_wrap_ui( smoothingUI_FILES Smoothing_plugin.ui)
polyhedron_demo_plugin(smoothing_plugin Smoothing_plugin ${smoothingUI_FILES})
target_link_libraries(smoothing_plugin PUBLIC scene_surface_mesh_item scene_selection_item)
CGAL_target_use_Eigen(smoothing_plugin)
target_link_libraries(smoothing_plugin PUBLIC scene_surface_mesh_item scene_selection_item CGAL::Eigen_support)
find_package(Ceres QUIET)
if(TARGET ceres)
target_compile_definitions( smoothing_plugin PRIVATE CGAL_PMP_USE_CERES_SOLVER )
target_link_libraries(smoothing_plugin PUBLIC ceres)
endif()
CGAL_target_use_Eigen(extrude_plugin)
target_link_libraries(extrude_plugin PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: The hole filling and fairing plugins require Eigen 3.2 (or higher) and will not be available.")
endif()
@ -106,17 +101,16 @@ qt5_wrap_ui( isotropicRemeshingUI_FILES Isotropic_remeshing_dialog.ui)
polyhedron_demo_plugin(isotropic_remeshing_plugin Isotropic_remeshing_plugin ${isotropicRemeshingUI_FILES} KEYWORDS PMP)
target_link_libraries(isotropic_remeshing_plugin PUBLIC scene_surface_mesh_item scene_selection_item)
if(TBB_FOUND)
CGAL_target_use_TBB(isotropic_remeshing_plugin)
if(TARGET CGAL::TBB_support)
target_link_libraries(isotropic_remeshing_plugin PUBLIC CGAL::TBB_support)
endif()
polyhedron_demo_plugin(distance_plugin Distance_plugin KEYWORDS PMP)
target_link_libraries(distance_plugin PUBLIC scene_surface_mesh_item scene_color_ramp)
if(TBB_FOUND)
CGAL_target_use_TBB(distance_plugin)
if(TARGET CGAL::TBB_support)
target_link_libraries(distance_plugin PUBLIC CGAL::TBB_support)
endif()
polyhedron_demo_plugin(detect_sharp_edges_plugin Detect_sharp_edges_plugin KEYWORDS IO Mesh_3 PMP)
target_link_libraries(detect_sharp_edges_plugin PUBLIC scene_surface_mesh_item)
@ -130,4 +124,3 @@ target_link_libraries(degenerated_faces_plugin PUBLIC scene_surface_mesh_item sc
qt5_wrap_ui( engravUI_FILES Engrave_dock_widget.ui )
polyhedron_demo_plugin(engrave_text_plugin Engrave_text_plugin ${engravUI_FILES})
target_link_libraries(engrave_text_plugin PUBLIC scene_surface_mesh_item scene_selection_item scene_polylines_item)

52
Polyhedron/demo/Polyhedron/Plugins/Point_set/CMakeLists.txt
View File

@ -1,62 +1,60 @@
include( polyhedron_demo_macros )
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
find_package(SCIP QUIET)
if(NOT SCIP_FOUND)
include(CGAL_SCIP_support)
if(NOT TARGET CGAL::SCIP_support)
find_package(GLPK QUIET)
include(CGAL_GLPK_support)
endif()
if(NOT SCIP_FOUND AND NOT GLPK_FOUND)
if(NOT TARGET CGAL::SCIP_support AND NOT TARGET CGAL::GLPK_support)
message(STATUS "NOTICE: SCIP and GLPK were not found. Polygonal surface reconstruction will not be available.")
endif()
qt5_wrap_ui( surface_reconstructionUI_FILES Surface_reconstruction_plugin.ui)
polyhedron_demo_plugin(surface_reconstruction_plugin Surface_reconstruction_plugin Surface_reconstruction_poisson_impl Surface_reconstruction_advancing_front_impl Surface_reconstruction_scale_space_impl Surface_reconstruction_polygonal_impl ${surface_reconstructionUI_FILES} KEYWORDS PointSetProcessing)
target_link_libraries(surface_reconstruction_plugin PUBLIC scene_polygon_soup_item scene_surface_mesh_item scene_points_with_normal_item)
CGAL_target_use_Eigen(surface_reconstruction_plugin)
target_link_libraries(surface_reconstruction_plugin PUBLIC scene_polygon_soup_item scene_surface_mesh_item scene_points_with_normal_item CGAL::Eigen_support)
if (SCIP_FOUND)
CGAL_target_use_SCIP(surface_reconstruction_plugin)
elseif(GLPK_FOUND)
CGAL_target_use_GLPK(surface_reconstruction_plugin)
if (TARGET CGAL::SCIP_support)
target_link_libraries(surface_reconstruction_plugin PUBLIC CGAL::SCIP_support)
elseif(TARGET CGAL::GLPK_support)
target_link_libraries(surface_reconstruction_plugin PUBLIC CGAL::GLPK_support)
endif()
qt5_wrap_ui( point_set_normal_estimationUI_FILES Point_set_normal_estimation_plugin.ui)
polyhedron_demo_plugin(point_set_normal_estimation_plugin Point_set_normal_estimation_plugin ${point_set_normal_estimationUI_FILES} KEYWORDS PointSetProcessing Classification)
target_link_libraries(point_set_normal_estimation_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
CGAL_target_use_Eigen(point_set_normal_estimation_plugin)
target_link_libraries(point_set_normal_estimation_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)
qt5_wrap_ui( features_detection_pluginUI_FILES Features_detection_plugin.ui)
polyhedron_demo_plugin(features_detection_plugin Features_detection_plugin ${features_detection_pluginUI_FILES} KEYWORDS PointSetProcessing)
target_link_libraries(features_detection_plugin PUBLIC scene_points_with_normal_item)
CGAL_target_use_Eigen(features_detection_plugin)
target_link_libraries(features_detection_plugin PUBLIC scene_points_with_normal_item CGAL::Eigen_support)
polyhedron_demo_plugin(point_set_smoothing_plugin Point_set_smoothing_plugin KEYWORDS PointSetProcessing)
target_link_libraries(point_set_smoothing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
CGAL_target_use_Eigen(point_set_smoothing_plugin)
target_link_libraries(point_set_smoothing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)
polyhedron_demo_plugin(point_set_average_spacing_plugin Point_set_average_spacing_plugin KEYWORDS PointSetProcessing Classification)
target_link_libraries(point_set_average_spacing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler)
CGAL_target_use_Eigen(point_set_average_spacing_plugin)
target_link_libraries(point_set_average_spacing_plugin PUBLIC scene_points_with_normal_item scene_callback_signaler CGAL::Eigen_support)
qt5_wrap_ui(point_set_shape_detectionUI_FILES Point_set_shape_detection_plugin.ui)
polyhedron_demo_plugin(point_set_shape_detection_plugin Point_set_shape_detection_plugin ${point_set_shape_detectionUI_FILES} KEYWORDS PointSetProcessing Classification)
target_link_libraries(point_set_shape_detection_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_polygon_soup_item scene_callback_signaler)
CGAL_target_use_Eigen(point_set_shape_detection_plugin)
target_link_libraries(point_set_shape_detection_plugin PUBLIC scene_surface_mesh_item scene_points_with_normal_item scene_polygon_soup_item scene_callback_signaler CGAL::Eigen_support)
find_package(OpenGR QUIET)
include(CGAL_OpenGR_support)
find_package(libpointmatcher QUIET)
include(CGAL_pointmatcher_support)
if (OpenGR_FOUND OR libpointmatcher_FOUND)
if (TARGET CGAL::OpenGR_support OR CGAL::pointmatcher_support)
qt5_wrap_ui(register_point_setsUI_FILES Register_point_sets_plugin.ui)
polyhedron_demo_plugin(register_point_sets_plugin Register_point_sets_plugin ${register_point_setsUI_FILES} KEYWORDS PointSetProcessing)
target_link_libraries(register_point_sets_plugin PUBLIC scene_points_with_normal_item)
CGAL_target_use_Eigen(register_point_sets_plugin)
if (OpenGR_FOUND)
CGAL_target_use_OpenGR(register_point_sets_plugin)
target_link_libraries(register_point_sets_plugin PUBLIC CGAL::Eigen_support)
if (TARGET CGAL::OpenGR_support)
target_link_libraries(register_point_sets_plugin PUBLIC CGAL::OpenGR_support)
endif()
if (libpointmatcher_FOUND)
CGAL_target_use_pointmatcher(register_point_sets_plugin)
if (TARGET CGAL::pointmatcher_support)
target_link_libraries(register_point_sets_plugin PUBLIC CGAL::pointmatcher_support)
endif()
else()
message(STATUS "NOTICE: OpenGR and libpointmatcher were not found. Registration plugin will not be available.")
@ -111,7 +109,7 @@ endif()
polyhedron_demo_plugin(point_set_to_mesh_distance_plugin Point_set_to_mesh_distance_plugin ${distanceUI_FILES} KEYWORDS PointSetProcessing)
target_link_libraries(point_set_to_mesh_distance_plugin PUBLIC scene_points_with_normal_item scene_surface_mesh_item scene_color_ramp)
if(TBB_FOUND)
if(TARGET CGAL::TBB_support)
foreach(plugin
surface_reconstruction_plugin
point_set_normal_estimation_plugin
@ -130,7 +128,7 @@ endif()
alpha_shape_plugin
point_set_to_mesh_distance_plugin)
if(TARGET ${plugin})
CGAL_target_use_TBB(${plugin})
target_link_libraries(${plugin} PUBLIC CGAL::TBB_support)
endif()
endforeach()
endif()

17
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/CMakeLists.txt
View File

@ -4,18 +4,17 @@ if(POLICY CMP0074)
cmake_policy(SET CMP0074 NEW)
endif()
if(EIGEN3_FOUND)
if(TARGET CGAL::Eigen_support)
find_package(CGAL COMPONENTS Core)
include(${CGAL_USE_FILE})
qt5_wrap_ui(parameterizationUI_FILES Parameterization_widget.ui OTE_dialog.ui)
polyhedron_demo_plugin(parameterization_plugin Parameterization_plugin ${parameterizationUI_FILES})
target_link_libraries(parameterization_plugin PUBLIC scene_surface_mesh_item scene_textured_item scene_selection_item)
CGAL_target_use_Eigen(parameterization_plugin)
else(EIGEN3_FOUND)
target_link_libraries(parameterization_plugin PUBLIC scene_surface_mesh_item scene_textured_item scene_selection_item CGAL::Eigen_support)
else()
message(STATUS "NOTICE: Eigen 3.1 (or greater) was not found. The Parameterization plugin will not be available.")
endif(EIGEN3_FOUND)
endif()
qt5_wrap_ui( segmentationUI_FILES Mesh_segmentation_widget.ui)
polyhedron_demo_plugin(mesh_segmentation_plugin Mesh_segmentation_plugin ${segmentationUI_FILES})
@ -32,11 +31,11 @@ target_link_libraries(mesh_simplification_plugin PUBLIC scene_surface_mesh_item
qt5_wrap_ui( remeshingUI_FILES Remeshing_dialog.ui)
polyhedron_demo_plugin(offset_meshing_plugin Offset_meshing_plugin ${remeshingUI_FILES})
target_link_libraries(offset_meshing_plugin PUBLIC scene_surface_mesh_item scene_polygon_soup_item)
if(EIGEN3_FOUND)
CGAL_target_use_Eigen(offset_meshing_plugin)
if(TARGET CGAL::Eigen_support)
target_link_libraries(offset_meshing_plugin PUBLIC CGAL::Eigen_support)
endif()
if(TBB_FOUND)
CGAL_target_use_TBB(offset_meshing_plugin)
if(TARGET CGAL::TBB_support)
target_link_libraries(offset_meshing_plugin PUBLIC CGAL::TBB_support)
endif()
qt5_wrap_ui( shortestPathUI_FILES Shortest_path_widget.ui )

6
Principal_component_analysis/demo/Principal_component_analysis/CMakeLists.txt
View File

@ -19,7 +19,8 @@ include_directories( ./ )
find_package(CGAL COMPONENTS Qt5)
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -45,10 +46,9 @@ if(CGAL_Qt5_FOUND AND Qt5_FOUND )
add_file_dependencies( PCA_demo.cpp "${CMAKE_CURRENT_BINARY_DIR}/MainWindow_moc.cpp"
"${CMAKE_CURRENT_BINARY_DIR}/Viewer_moc.cpp" )
add_executable ( PCA_demo PCA_demo.cpp ${UI_FILES} ${CGAL_Qt5_RESOURCE_FILES} ${CGAL_Qt5_MOC_FILES})
CGAL_target_use_Eigen(PCA_demo)
target_link_libraries( PCA_demo PRIVATE
CGAL::CGAL CGAL::CGAL_Qt5 Qt5::Gui)
CGAL::CGAL CGAL::CGAL_Qt5 CGAL::Eigen_support Qt5::Gui)
add_to_cached_list( CGAL_EXECUTABLE_TARGETS PCA_demo )

6
Principal_component_analysis/examples/Principal_component_analysis/CMakeLists.txt
View File

@ -12,14 +12,15 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endif()
endforeach()
@ -28,4 +29,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

6
Principal_component_analysis/test/Principal_component_analysis/CMakeLists.txt
View File

@ -12,14 +12,15 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
include(CGAL_Eigen_support)
# create a target per cppfile
file(GLOB cppfiles RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
foreach(cppfile ${cppfiles})
create_single_source_cgal_program( "${cppfile}" )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
get_filename_component(target ${cppfile} NAME_WE)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endif()
endforeach()
@ -28,4 +29,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

7
Property_map/examples/Property_map/CMakeLists.txt
View File

@ -33,9 +33,8 @@ endif()
create_single_source_cgal_program( "dynamic_properties.cpp" )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "custom_property_map.cpp" )
CGAL_target_use_Eigen(custom_property_map)
target_link_libraries(custom_property_map PUBLIC CGAL::Eigen_support)
endif()

9
Ridges_3/examples/Ridges_3/CMakeLists.txt
View File

@ -10,7 +10,8 @@ if ( CGAL_FOUND )
# use either Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
# Link with Boost.ProgramOptions (optional)
find_package(Boost QUIET COMPONENTS program_options)
@ -28,11 +29,11 @@ if ( CGAL_FOUND )
endif()
create_single_source_cgal_program( Compute_Ridges_Umbilics.cpp)
CGAL_target_use_Eigen(Compute_Ridges_Umbilics)
target_link_libraries(Compute_Ridges_Umbilics PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( Ridges_Umbilics_SM.cpp)
CGAL_target_use_Eigen(Ridges_Umbilics_SM)
target_link_libraries(Ridges_Umbilics_SM PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( Ridges_Umbilics_LCC.cpp)
CGAL_target_use_Eigen(Ridges_Umbilics_LCC)
target_link_libraries(Ridges_Umbilics_LCC PUBLIC CGAL::Eigen_support)
else()

6
Ridges_3/test/Ridges_3/CMakeLists.txt
View File

@ -13,9 +13,10 @@ if ( CGAL_FOUND )
# use either Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "ridge_test.cpp" )
CGAL_target_use_Eigen(ridge_test)
target_link_libraries(ridge_test PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires Eigen 3.1 (or greater) and will not be compiled.")
@ -27,4 +28,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

5
STL_Extension/benchmark/compact_container_benchmark/CMakeLists.txt
View File

@ -6,9 +6,10 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package( TBB )
include(CGAL_TBB_support)
create_single_source_cgal_program( "cc_benchmark.cpp" )
if(TBB_FOUND)
CGAL_target_use_TBB(cc_benchmark)
if(TARGET CGAL::TBB_support)
target_link_libraries(cc_benchmark PUBLIC CGAL::TBB_support)
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")

10
STL_Extension/test/STL_Extension/CMakeLists.txt
View File

@ -12,6 +12,7 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package( TBB QUIET )
include(CGAL_TBB_support)
create_single_source_cgal_program( "test_Boolean_tag.cpp" )
create_single_source_cgal_program( "test_Cache.cpp" )
@ -21,8 +22,8 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "test_composition.cpp" )
create_single_source_cgal_program( "test_Concatenate_iterator.cpp" )
create_single_source_cgal_program( "test_Concurrent_compact_container.cpp" )
if(TBB_FOUND)
CGAL_target_use_TBB(test_Concurrent_compact_container)
if(TARGET CGAL::TBB_support)
target_link_libraries(test_Concurrent_compact_container PUBLIC CGAL::TBB_support)
endif()
create_single_source_cgal_program( "test_dispatch_output.cpp" )
create_single_source_cgal_program( "test_Flattening_iterator.cpp" )
@ -43,12 +44,11 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "test_vector.cpp" )
create_single_source_cgal_program( "test_join_iterators.cpp" )
create_single_source_cgal_program( "test_for_each.cpp" )
if(TBB_FOUND)
CGAL_target_use_TBB(test_for_each)
if(TARGET CGAL::TBB_support)
target_link_libraries(test_for_each PUBLIC CGAL::TBB_support)
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

24
Scale_space_reconstruction_3/examples/Scale_space_reconstruction_3/CMakeLists.txt
View File

@ -13,26 +13,28 @@ if ( CGAL_FOUND )
if( ACTIVATE_CONCURRENCY )
find_package( TBB )
if( NOT TBB_FOUND )
include(CGAL_TBB_support)
if( NOT TARGET CGAL::TBB_support )
message( STATUS "NOTICE: Intel TBB NOT found! The example is faster if TBB is linked." )
endif()
endif()
find_package( Eigen3 3.1.0 )
if( EIGEN3_FOUND )
include(CGAL_Eigen_support)
if( TARGET CGAL::Eigen_support )
create_single_source_cgal_program( "scale_space.cpp" )
CGAL_target_use_Eigen(scale_space)
target_link_libraries(scale_space PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "scale_space_incremental.cpp" )
CGAL_target_use_Eigen(scale_space_incremental)
target_link_libraries(scale_space_incremental PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "scale_space_manifold.cpp" )
CGAL_target_use_Eigen(scale_space_manifold)
target_link_libraries(scale_space_manifold PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "scale_space_advancing_front.cpp" )
CGAL_target_use_Eigen(scale_space_advancing_front)
if(ACTIVATE_CONCURRENCY AND TBB_FOUND)
CGAL_target_use_TBB(scale_space)
CGAL_target_use_TBB(scale_space_incremental)
CGAL_target_use_TBB(scale_space_manifold)
CGAL_target_use_TBB(scale_space_advancing_front)
target_link_libraries(scale_space_advancing_front PUBLIC CGAL::Eigen_support)
if(ACTIVATE_CONCURRENCY AND TARGET CGAL::TBB_support)
target_link_libraries(scale_space PUBLIC CGAL::TBB_support)
target_link_libraries(scale_space_incremental PUBLIC CGAL::TBB_support)
target_link_libraries(scale_space_manifold PUBLIC CGAL::TBB_support)
target_link_libraries(scale_space_advancing_front PUBLIC CGAL::TBB_support)
endif()
else()
message( STATUS "NOTICE: The example needs Eigen 3.1 (or greater) and will not be compiled." )

7
Shape_detection/benchmark/Shape_detection/CMakeLists.txt
View File

@ -14,13 +14,14 @@ if(CGAL_FOUND)
# Use Eigen.
find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
if(EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(TARGET CGAL::Eigen_support)
create_single_source_cgal_program(
"benchmark_region_growing_on_point_set_2.cpp")
CGAL_target_use_Eigen(benchmark_region_growing_on_point_set_2)
target_link_libraries(benchmark_region_growing_on_point_set_2 PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program(
"benchmark_region_growing_on_point_set_3.cpp")
CGAL_target_use_Eigen(benchmark_region_growing_on_point_set_3)
target_link_libraries(benchmark_region_growing_on_point_set_3 PUBLIC CGAL::Eigen_support)
endif()
else()

5
Shape_detection/examples/Shape_detection/CMakeLists.txt
View File

@ -14,7 +14,8 @@ if(CGAL_FOUND)
# Use Eigen.
find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
if(EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(TARGET CGAL::Eigen_support)
create_single_source_cgal_program(
"efficient_RANSAC_basic.cpp")
create_single_source_cgal_program(
@ -43,7 +44,7 @@ if(CGAL_FOUND)
region_growing_on_polygon_mesh
region_growing_with_custom_classes
shape_detection_basic_deprecated)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()
endif()

3
Shape_detection/test/Shape_detection/CMakeLists.txt
View File

@ -14,6 +14,7 @@ if(CGAL_FOUND)
# Use Eigen.
find_package(Eigen3 3.1.0 QUIET) # (3.1.0 or greater)
include(CGAL_Eigen_support)
if(EIGEN3_FOUND)
create_single_source_cgal_program(
"test_region_growing_basic.cpp")
@ -43,7 +44,7 @@ if(CGAL_FOUND)
test_region_growing_on_point_set_3_with_sorting
test_region_growing_on_polygon_mesh_with_sorting
test_region_growing_on_degenerated_mesh)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()
endif()

22
Solver_interface/examples/Solver_interface/CMakeLists.txt
View File

@ -12,32 +12,35 @@ if ( CGAL_FOUND )
# Use Eigen
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
include(CGAL_Eigen_support)
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "singular_value_decomposition.cpp" )
CGAL_target_use_Eigen(singular_value_decomposition)
target_link_libraries(singular_value_decomposition PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "sparse_solvers.cpp" )
CGAL_target_use_Eigen(sparse_solvers)
target_link_libraries(sparse_solvers PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "diagonalize_matrix.cpp" )
CGAL_target_use_Eigen(diagonalize_matrix)
target_link_libraries(diagonalize_matrix PUBLIC CGAL::Eigen_support)
endif()
create_single_source_cgal_program( "mixed_integer_program.cpp" )
find_package( SCIP QUIET)
include(CGAL_SCIP_support)
if (SCIP_FOUND)
if (TARGET CGAL::SCIP_support)
CGAL_target_use_SCIP(mixed_integer_program)
target_link_libraries(mixed_integer_program PUBLIC CGAL::SCIP_support)
message("SCIP found and used")
else()
find_package( GLPK QUIET)
find_package( GLPK QUIET)
include(CGAL_GLPK_support)
if (GLPK_FOUND)
if (TARGET CGAL::GLPK_support)
CGAL_target_use_GLPK(mixed_integer_program)
target_link_libraries(mixed_integer_program PUBLIC CGAL::GLPK_support)
message("GLPK found and used")
else()
@ -54,4 +57,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

4
Spatial_searching/benchmark/Spatial_searching/CMakeLists.txt
View File

@ -13,6 +13,7 @@ if ( CGAL_FOUND )
include(${CGAL_USE_FILE})
find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
include_directories (BEFORE "include")
@ -45,7 +46,7 @@ find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
nn3nanoflan
sizeof
deque)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()
else()
@ -53,4 +54,3 @@ else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

12
Spatial_searching/examples/Spatial_searching/CMakeLists.txt
View File

@ -18,6 +18,7 @@ if ( NOT CGAL_FOUND )
endif()
find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
if (MSVC)
# Turn off VC++ warning
@ -62,13 +63,13 @@ create_single_source_cgal_program( "weighted_Minkowski_distance.cpp" )
if (EIGEN3_FOUND)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "fuzzy_range_query.cpp" )
CGAL_target_use_Eigen(fuzzy_range_query)
target_link_libraries(fuzzy_range_query PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "general_neighbor_searching.cpp" )
CGAL_target_use_Eigen(general_neighbor_searching)
target_link_libraries(general_neighbor_searching PUBLIC CGAL::Eigen_support)
else()
@ -78,9 +79,10 @@ else()
endif()
find_package( TBB QUIET )
if(TBB_FOUND)
include(CGAL_TBB_support)
if(TARGET CGAL::TBB_support)
create_single_source_cgal_program( "parallel_kdtree.cpp" )
cgal_target_use_TBB(parallel_kdtree)
target_link_libraries(parallel_kdtree PUBLIC CGAL::TBB_support)
else()
message(STATUS "parallel_kdtree.cpp requires TBB and will not be compiled")
endif()

7
Spatial_sorting/examples/Spatial_sorting/CMakeLists.txt
View File

@ -16,13 +16,12 @@ if ( CGAL_FOUND )
endforeach()
find_package( TBB QUIET )
if( TBB_FOUND )
include( CGAL_target_use_TBB )
CGAL_target_use_TBB( parallel_spatial_sort_3 )
include(CGAL_TBB_support)
if( TARGET CGAL::TBB_support )
target_link_libraries( parallel_spatial_sort_3 PUBLIC CGAL::TBB_support)
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

9
Spatial_sorting/test/Spatial_sorting/CMakeLists.txt
View File

@ -13,14 +13,13 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "test_multiscale.cpp" )
find_package (TBB QUIET)
if( TBB_FOUND )
include( CGAL_target_use_TBB )
CGAL_target_use_TBB( test_hilbert )
endif( TBB_FOUND )
include(CGAL_TBB_support)
if( TARGET CGAL::TBB_support )
target_link_libraries( test_hilbert PUBLIC CGAL::TBB_support )
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

16
Surface_mesh_approximation/examples/Surface_mesh_approximation/CMakeLists.txt
View File

@ -28,7 +28,8 @@ endif()
# Use Eigen (for PCA)
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -39,20 +40,19 @@ endif()
include( CGAL_CreateSingleSourceCGALProgram )
create_single_source_cgal_program( "vsa_approximation_2_example.cpp" )
CGAL_target_use_Eigen(vsa_approximation_2_example)
target_link_libraries(vsa_approximation_2_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_approximation_example.cpp" )
CGAL_target_use_Eigen(vsa_approximation_example)
target_link_libraries(vsa_approximation_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_class_interface_example.cpp" )
CGAL_target_use_Eigen(vsa_class_interface_example)
target_link_libraries(vsa_class_interface_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_isotropic_metric_example.cpp" )
CGAL_target_use_Eigen(vsa_isotropic_metric_example)
target_link_libraries(vsa_isotropic_metric_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_segmentation_example.cpp" )
CGAL_target_use_Eigen(vsa_segmentation_example)
target_link_libraries(vsa_segmentation_example PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_simple_approximation_example.cpp" )
CGAL_target_use_Eigen(vsa_simple_approximation_example)
target_link_libraries(vsa_simple_approximation_example PUBLIC CGAL::Eigen_support)

23
Surface_mesh_approximation/test/Surface_mesh_approximation/CMakeLists.txt
View File

@ -29,7 +29,8 @@ endif()
# Use Eigen (for PCA)
find_package(Eigen3 3.1.0 REQUIRED) #(3.1.0 or greater)
if (NOT EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (NOT TARGET CGAL::Eigen_support)
message(STATUS "This project requires the Eigen library, and will not be compiled.")
return()
endif()
@ -41,30 +42,28 @@ endif()
include( CGAL_CreateSingleSourceCGALProgram )
create_single_source_cgal_program( "vsa_class_interface_test.cpp" )
CGAL_target_use_Eigen(vsa_class_interface_test)
target_link_libraries(vsa_class_interface_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_correctness_test.cpp" )
CGAL_target_use_Eigen(vsa_correctness_test)
target_link_libraries(vsa_correctness_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_error_decrease_test.cpp" )
CGAL_target_use_Eigen(vsa_error_decrease_test)
target_link_libraries(vsa_error_decrease_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_kernel_test.cpp" )
CGAL_target_use_Eigen(vsa_kernel_test)
target_link_libraries(vsa_kernel_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_approximation_test.cpp" )
CGAL_target_use_Eigen(vsa_approximation_test)
target_link_libraries(vsa_approximation_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_segmentation_test.cpp" )
CGAL_target_use_Eigen(vsa_segmentation_test)
target_link_libraries(vsa_segmentation_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_meshing_manifold_test.cpp" )
CGAL_target_use_Eigen(vsa_meshing_manifold_test)
target_link_libraries(vsa_meshing_manifold_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_metric_test.cpp" )
CGAL_target_use_Eigen(vsa_metric_test)
target_link_libraries(vsa_metric_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "vsa_teleportation_test.cpp" )
CGAL_target_use_Eigen(vsa_teleportation_test)
target_link_libraries(vsa_teleportation_test PUBLIC CGAL::Eigen_support)

6
Surface_mesh_deformation/benchmark/Surface_mesh_deformation/optimal_rotation/CMakeLists.txt
View File

@ -10,13 +10,13 @@ if ( CGAL_FOUND )
include(${CGAL_USE_FILE})
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "benchmark_for_concept_models.cpp" )
CGAL_target_use_Eigen(benchmark_for_concept_models)
target_link_libraries(benchmark_for_concept_models PUBLIC CGAL::Eigen_support)
else()
message(STATUS "This program requires the Eigen library, version 3.1 or later and will not be compiled.")
endif()
else()
message(STATUS "This program requires the CGAL library, and will not be compiled.")
endif()

6
Surface_mesh_deformation/demo/Surface_mesh_deformation/CMakeLists.txt
View File

@ -17,9 +17,10 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "deform_mesh_for_botsch08_format.cpp" )
CGAL_target_use_Eigen(deform_mesh_for_botsch08_format)
target_link_libraries(deform_mesh_for_botsch08_format PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: This program requires the Eigen library, version 3.2 or later and will not be compiled.")
endif()
@ -28,4 +29,3 @@ else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

9
Surface_mesh_deformation/examples/Surface_mesh_deformation/CMakeLists.txt
View File

@ -12,7 +12,8 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "all_roi_assign_example.cpp" )
create_single_source_cgal_program( "all_roi_assign_example_custom_polyhedron.cpp" )
create_single_source_cgal_program( "all_roi_assign_example_Surface_mesh.cpp" )
@ -31,15 +32,14 @@ if ( CGAL_FOUND )
k_ring_roi_translate_rotate_example
k_ring_roi_translate_rotate_Surface_mesh
deform_mesh_for_botsch08_format_sre_arap)
CGAL_target_use_Eigen(${target})
target_link_libraries(${target} PUBLIC CGAL::Eigen_support)
endforeach()
find_package( OpenMesh QUIET )
if ( OpenMesh_FOUND )
include( UseOpenMesh )
create_single_source_cgal_program( "all_roi_assign_example_with_OpenMesh.cpp" )
target_link_libraries( all_roi_assign_example_with_OpenMesh PRIVATE ${OPENMESH_LIBRARIES} )
CGAL_target_use_Eigen(all_roi_assign_example_with_OpenMesh)
target_link_libraries( all_roi_assign_example_with_OpenMesh PRIVATE ${OPENMESH_LIBRARIES} CGAL::Eigen_support)
else()
message(STATUS "Example that use OpenMesh will not be compiled.")
endif()
@ -52,4 +52,3 @@ else()
message(STATUS "NOTICE: These exmaples require the CGAL library, and will not be compiled.")
endif()

13
Surface_mesh_deformation/test/Surface_mesh_deformation/CMakeLists.txt
View File

@ -12,20 +12,20 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package(Eigen3 3.1.91) #(requires 3.2.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "Cactus_deformation_session.cpp" )
CGAL_target_use_Eigen(Cactus_deformation_session)
target_link_libraries(Cactus_deformation_session PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "Cactus_performance_test.cpp" )
CGAL_target_use_Eigen(Cactus_performance_test)
target_link_libraries(Cactus_performance_test PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "Symmetry_test.cpp" )
CGAL_target_use_Eigen(Symmetry_test)
target_link_libraries(Symmetry_test PUBLIC CGAL::Eigen_support)
find_package( OpenMesh QUIET )
if ( OpenMesh_FOUND )
include( UseOpenMesh )
create_single_source_cgal_program( "Cactus_deformation_session_OpenMesh.cpp" )
CGAL_target_use_Eigen(Cactus_deformation_session_OpenMesh)
target_link_libraries( Cactus_deformation_session_OpenMesh PRIVATE ${OPENMESH_LIBRARIES} )
target_link_libraries( Cactus_deformation_session_OpenMesh PRIVATE ${OPENMESH_LIBRARIES} CGAL::Eigen_support)
else()
message(STATUS "Example that use OpenMesh will not be compiled.")
endif()
@ -37,4 +37,3 @@ else()
message(STATUS "NOTICE: These tests require the CGAL library, and will not be compiled.")
endif()

20
Surface_mesh_parameterization/examples/Surface_mesh_parameterization/CMakeLists.txt
View File

@ -12,7 +12,8 @@ find_package(CGAL QUIET)
if ( CGAL_FOUND )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if (EIGEN3_FOUND)
include(CGAL_Eigen_support)
if (TARGET CGAL::Eigen_support)
# Executables that require Eigen 3.1
# ------------------------------------------------------------------
@ -51,29 +52,28 @@ if ( CGAL_FOUND )
# ------------------------------------------------------------------
create_single_source_cgal_program( "discrete_authalic.cpp" )
CGAL_target_use_Eigen(discrete_authalic)
target_link_libraries(discrete_authalic PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "lscm.cpp" )
CGAL_target_use_Eigen(lscm)
target_link_libraries(lscm PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "orbifold.cpp" )
CGAL_target_use_Eigen(orbifold)
target_link_libraries(orbifold PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "seam_Polyhedron_3.cpp" )
CGAL_target_use_Eigen(seam_Polyhedron_3)
target_link_libraries(seam_Polyhedron_3 PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "simple_parameterization.cpp" )
CGAL_target_use_Eigen(simple_parameterization)
target_link_libraries(simple_parameterization PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "square_border_parameterizer.cpp" )
CGAL_target_use_Eigen(square_border_parameterizer)
target_link_libraries(square_border_parameterizer PUBLIC CGAL::Eigen_support)
if(SuiteSparse_FOUND)
target_link_libraries(orbifold PRIVATE ${SuiteSparse_LIBRARIES})
endif()
else(EIGEN3_FOUND)
else()
message(STATUS "NOTICE: The examples require Eigen 3.1 (or greater) and will not be compiled.")
endif(EIGEN3_FOUND)
endif()
else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

10
Surface_mesh_parameterization/test/Surface_mesh_parameterization/CMakeLists.txt
View File

@ -13,16 +13,16 @@ if ( CGAL_FOUND )
find_package(Eigen3 3.1.0) #(requires 3.1.0 or greater)
if(EIGEN3_FOUND)
include(CGAL_Eigen_support)
if(TARGET CGAL::Eigen_support)
create_single_source_cgal_program( "extensive_parameterization_test.cpp" )
CGAL_target_use_Eigen(extensive_parameterization_test)
else(EIGEN3_FOUND)
target_link_libraries(extensive_parameterization_test PUBLIC CGAL::Eigen_support)
else()
message(STATUS "NOTICE: The tests require Eigen 3.1 (or greater) and will not be compiled.")
endif(EIGEN3_FOUND)
endif()
else()
message(STATUS "NOTICE: This program requires the CGAL library, and will not be compiled.")
endif()

5
Surface_mesh_simplification/examples/Surface_mesh_simplification/CMakeLists.txt
View File

@ -43,9 +43,10 @@ create_single_source_cgal_program( "edge_collapse_bounded_normal_change.cpp" )
create_single_source_cgal_program( "edge_collapse_visitor_surface_mesh.cpp" )
find_package(Eigen3 3.1.0 QUIET) #(3.1.0 or greater)
if( Eigen3_FOUND )
include(CGAL_Eigen_support)
if( TARGET CGAL::Eigen_support )
create_single_source_cgal_program( "edge_collapse_garland_heckbert.cpp" )
CGAL_target_use_Eigen(edge_collapse_garland_heckbert)
target_link_libraries(edge_collapse_garland_heckbert PUBLIC CGAL::Eigen_support)
else ()
message(STATUS "Garland-Heckbert polices require the Eigen library, which has not been found; related examples will not be compiled.")
endif()

10
Surface_mesh_skeletonization/benchmark/Surface_mesh_skeletonization/CMakeLists.txt
View File

@ -35,17 +35,17 @@ endif()
# include for local package
find_package(Eigen3 3.2.0) #(requires 3.2.0 or greater)
include(CGAL_Eigen_support)
if(NOT EIGEN3_FOUND)
if(NOT TARGET CGAL::Eigen_support)
message(STATUS "NOTICE: Eigen 3.2 (or greater) is not found.")
endif(NOT EIGEN3_FOUND)
endif()
# Creating entries for all .cpp/.C files with "main" routine
# ##########################################################
create_single_source_cgal_program( "solver_benchmark.cpp" )
CGAL_target_use_Eigen(solver_benchmark)
target_link_libraries(solver_benchmark PUBLIC CGAL::Eigen_support)
create_single_source_cgal_program( "mcf_scale_invariance.cpp" )
CGAL_target_use_Eigen(mcf_scale_invariance)
target_link_libraries(mcf_scale_invariance PUBLIC CGAL::Eigen_support)

Some files were not shown because too many files have changed in this diff Show More