How do I install minizip with zlib? - c++

I have the following cmake file to download, build and install zlib:
cmake_minimum_required ( VERSION 2.8.7 )
include (ExternalProject)
if(UNIX)
# An external project for zlib
SET (GIT_URL https://github.com/madler/zlib.git)
SET (ZLIB_INSTALL ${CMAKE_CURRENT_BINARY_DIR})
SET (ZLIB_INCLUDE ${CMAKE_BINARY_DIR}/include/zlib)
SET (ZLIB_STATIC ${CMAKE_BINARY_DIR}/lib/libz.a )
ExternalProject_Add(zlib
PREFIX zlib
GIT_REPOSITORY ${GIT_URL}
INSTALL_DIR ${ZLIB_INSTALL}
PATCH_COMMAND ${CMAKE_COMMAND} -E remove <SOURCE_DIR>/zconf.h
BUILD_IN_SOURCE 1
PATCH_COMMAND ""
CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=<INSTALL_DIR> --includedir=${ZLIB_INCLUDE}
)
SET (ZLIB_INCLUDE_DIR ${ZLIB_INSTALL}/include/zlib)
SET (ZLIB_LIBRARY "${ZLIB_INSTALL}")
ADD_LIBRARY (ZLIB_LIB STATIC IMPORTED DEPENDS zlib)
SET_TARGET_PROPERTIES (ZLIB_LIB PROPERTIES IMPORTED_LOCATION "${ZLIB_STATIC}")
endif(UNIX)
But this cmake file only install zlib. I want also install minizip. Minizip is "part of zlib". In the zlib repository has a directory that has minizip.
How can I also install minizip in the same cmake file? Is it possible?
The minizip is inside zlib repository:
- zlib
- contrib
- minizip
- ....
- ...
- ...
I have cmake file to install minizip:
cmake_minimum_required(VERSION 2.8)
project(minizip)
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
set(BUILD_SHARED_LIBS OFF)
find_package (ZLIB REQUIRED)
if (ZLIB_FOUND)
set(ZLIB_LIBRARY ${CMAKE_BINARY_DIR}/ZLIB/src/ZLIB/contrib)
SET (minizip ${CMAKE_BINARY_DIR}/lib/minizip)
if(CMAKE_HOST_APPLE)
set(PLATFORM __APPLE__)
elseif(CMAKE_HOST_UNIX)
set(PLATFORM unix)
elseif(CMAKE_HOST_WIN32)
set(PLATFORM _WIN32)
else(CMAKE_HOST_APPLE)
message(FATAL_ERROR "Not supported Platform")
endif(CMAKE_HOST_APPLE)
add_definitions(-D${PLATFORM})
set(SOURCE
${ZLIB_LIBRARY}/minizip/ioapi.c
${ZLIB_LIBRARY}/minizip/miniunz.c
${ZLIB_LIBRARY}/minizip/minizip.c
${ZLIB_LIBRARY}/minizip/unzip.c
${ZLIB_LIBRARY}/minizip/zip.c
)
if(WIN32)
set(SOURCE ${SOURCE} ${ZLIB_LIBRARY}/minizip/iowin32.c)
endif(WIN32)
set(HEADERS
${ZLIB_LIBRARY}/minizip/crypt.h
${ZLIB_LIBRARY}/minizip/ioapi.h
${ZLIB_LIBRARY}/minizip/miniunz.h
${ZLIB_LIBRARY}/minizip/unzip.h
)
if(WIN32)
set(HEADERS ${HEADERS} ${ZLIB_LIBRARY}/minizip/iowin32.h)
endif(WIN32)
add_library(minizip ${SOURCE} ${HEADERS})
target_link_libraries(minizip PUBLIC "-static" ZLIB_STATIC)
add_dependencies ( minizip zlib)
install(
TARGETS minizip EXPORT minizip-exports
INCLUDES DESTINATION "include"
RUNTIME DESTINATION "bin"
LIBRARY DESTINATION "lib"
ARCHIVE DESTINATION "lib"
)
install(
FILES ${HEADERS}
DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/include/minizip"
)
ADD_LIBRARY (MINIZIP_LIB STATIC IMPORTED DEPENDS minizip)
SET_TARGET_PROPERTIES (MINIZIP_LIB PROPERTIES IMPORTED_LOCATION ${minizip})
endif()
I want before install minizip, install zlib.
But when I run
cmake ..
I have the following error:
Make Error at modules/minizip.cmake:50 (add_library):
Cannot find source file:
/home/lais/Imagens/agent/build/ZLIB/src/ZLIB/contrib/minizip/ioapi.c
Tried extensions .c .C .c++ .cc .cpp .cxx .m .M .mm .h .hh .h++ .hm .hpp
.hxx .in .txx
Call Stack (most recent call first):
CMakeLists.txt:59 (include)
CMake Error: Cannot determine link language for target "minizip".
CMake Error: CMake can not determine linker language for target: minizip
And I have a top level cmake, that call for this two modules:
cmake_minimum_required( VERSION 2.8.7 )
project( project )
# version number
set ( VERSION_MAJOR 0 )
set ( VERSION_MINOR 0 )
# cpr requires c++11
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc")
# src : main + jsoncpp library
file ( GLOB SOURCES src/project/*.cpp )
# src : collect functions - depend on OS
if ( WIN32 )
file ( GLOB SOURCES ${SOURCES} src/project/windows/*.cpp )
else () # if( UNIX )
file ( GLOB SOURCES ${SOURCES} src/project/linux/*.cpp )
endif ()
# src : curl requests
# options for cpr
# avoid experimental use of openssl
option( CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" OFF )
# avoid building tests
option( BUILD_CPR_TESTS "Set to ON to build cpr tests." OFF )
# options for curl
# avoid building tests
option( BUILD_CURL_TESTS "Set to ON to build cURL tests." OFF )
# avoid running tests - set ON again in download version or if errors occur
option( RUN_CURL_TESTS "Set to ON to run cURL tests." OFF )
add_subdirectory ( lib/cpr )
include_directories ( ${CPR_INCLUDE_DIRS} )
include_directories ( ${CURL_INCLUDE_DIRS} )
# src : DtWinVer - Windows Version/Edition class
if ( WIN32 )
add_subdirectory ( lib/dtwinver )
endif ()
# headers
include_directories ( "include" )
include_directories ( "${CMAKE_BINARY_DIR}/include" )
# scr = libboost
include ( "modules/boost.cmake" )
# src = zlib
include ( "modules/zlib.cmake" )
# src = minizip
include ( "modules/minizip.cmake" )
# compile
set ( CMAKE_RUNTIME_OUTPUT_DIRECTORY "../bin" )
add_executable ( project-v${VERSION_MAJOR}.${VERSION_MINOR} ${SOURCES} )
target_link_libraries ( project-v${VERSION_MAJOR}.${VERSION_MINOR} ${CPR_LIBRARIES} ${CURL_LIBRARIES} ${FILESYSTEM_LIB} ${SYSTEM_LIB} ${REGEX_LIB} ${PROGRAM_OPTIONS_LIB} ${ZLIB_STATIC} ${minizip})
add_dependencies ( project-v${VERSION_MAJOR}.${VERSION_MINOR} Boost)
add_dependencies ( project-v${VERSION_MAJOR}.${VERSION_MINOR} zlib)
add_dependencies ( project-v${VERSION_MAJOR}.${VERSION_MINOR} minizip)
if ( WIN32 )
target_link_libraries ( project-v${VERSION_MAJOR}.${VERSION_MINOR} dtwinver )
else ()
# libudev
target_link_libraries ( project-v${VERSION_MAJOR}.${VERSION_MINOR} udev )
endif ()

Looks your source package is not complete.
minizip is just simple a single file minizip.c. Why do you need cmake? Just compile it and link with zlib and everything will be fine.

Related

how to link re2 library in my project like a static library with cmake

My question: in this moment I'm linking the libre2 dinamically, but I want to do this statically. I installed the library in my pc (sudo apt-get install libre2-dev), got the "binary" and linked this binary "libre2.so" in my executable. But I want to git clone the repository or to do this by git submodule, then build this repository and link it in my project statically.
I'm new here and sorry for my bad English rss'
1) my project structure
- bin
- build
- external
- re2
- main.cpp
- CMakeLists.txt
- README.md
2) CMakeLists.txt
cmake_minimum_required( VERSION 2.6 )
project( simmc-agent )
# version number
set ( VERSION_MAJOR 0 )
set ( VERSION_MINOR 0 )
# cpr requires c++11
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
# src : main
file ( GLOB SOURCES *.cpp )
# linking res library dinamically
set(RE2_LIBRARIES -L${RE2_LIBRARY_DIR} -l libre2.so)
# src : collect functions - depend on OS
if ( WIN32 )
file ( GLOB SOURCES ${SOURCES} src/windows/*.cpp )
else () # if( UNIX )
file ( GLOB SOURCES ${SOURCES} src/linux/*.cpp )
endif ()
# headers
include_directories ( "include" )
# test
option( PRINT_JSON "Set to ON to print json objects before sending" OFF )
message(STATUS "${PRINT_JSON}: ${${PRINT_JSON}}")
if ( PRINT_JSON )
add_definitions ( -DPRINT_JSON )
endif ()
# compile
set ( CMAKE_RUNTIME_OUTPUT_DIRECTORY "../bin" )
add_executable ( agent-v${VERSION_MAJOR}.${VERSION_MINOR} ${SOURCES} )
target_link_libraries ( agent-v${VERSION_MAJOR}.${VERSION_MINOR} ${RE2_LIBRARY} )
3) main.cpp
#include <iostream>
#include <re2/re2.h>
using namespace std;
using namespace re2;
int main (int argc, char **argv) {
cout << "hello world" << endl;
int matchResult;
matchResult = RE2::FullMatch("hello", "h.*o");
cout << "matchResult = " << matchResult << endl;
return 0;
}
EDIT - (26.01.17) : Hello, guys. I'm here to talk how I resolve it.
Following some tips gave here, I create a file called re2.cmake:
cmake_minimum_required ( VERSION 2.8.7 )
if (NOT RE2_NAME)
include (ExternalProject)
SET (RE2_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/re2/src/re2/)
SET (RE2_EXTRA_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}/re2/src/re2/)
SET (RE2_URL https://github.com/google/re2.git)
SET (RE2_BUILD ${CMAKE_BINARY_DIR}/re2/src/re2)
SET (RE2_LIBRARIES ${RE2_BUILD}/obj/so/libre2.so)
get_filename_component(RE2_STATIC_LIBRARIES ${RE2_BUILD}/libre2.a ABSOLUTE)
SET (RE2_INCLUDES ${RE2_BUILD})
if ( WIN32 )
SET (RE2_STATIC_LIBRARIES ${RE2_BUILD}/${CMAKE_BUILD_TYPE}/re2.lib)
else ()
SET (RE2_STATIC_LIBRARIES ${RE2_BUILD}/libre2.a)
endif ()
ExternalProject_Add(RE2
PREFIX RE2
GIT_REPOSITORY ${RE2_URL}
# GIT_TAG ${RE2_TAG}
DOWNLOAD_DIR "${DOWNLOAD_LOCATION}"
BUILD_IN_SOURCE 1
INSTALL_COMMAND sudo make install
CMAKE_CACHE_ARGS
-DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
)
## put re2 includes in the directory where they are expected
add_custom_target(re2_create_destination_dir COMMAND ${CMAKE_COMMAND} -E make_directory ${RE2_INCLUDE_DIR}/re2 DEPENDS re2)
add_custom_target(re2_copy_headers_to_destination DEPENDS re2_create_destination_dir)
foreach(header_file ${RE2_HEADERS})
add_custom_command(TARGET re2_copy_headers_to_destination PRE_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${header_file} ${RE2_INCLUDE_DIR}/re2)
endforeach ()
ADD_LIBRARY(RE2_LIB STATIC IMPORTED DEPENDS RE2)
SET_TARGET_PROPERTIES(RE2_LIB PROPERTIES IMPORTED_LOCATION ${RE2_STATIC_LIBRARIES})
endif (NOT RE2_NAME)
This file download the repository, building and install the library libre2 in my computer. This library has a dependency for Thread library* (I thinks all linux operation system come with this library).
But, has a problem: I only do this, if I'm a root user. Because the library used the "make install" command and to do it, you need to be a root user.
my project structure:
- bin
- build
- src
- include
- modules
- re2.cmake
- CMakeLists.txt
FOllowing my CMakeLists.txt:
cmake_minimum_required ( VERSION 2.8.7 )
project ( project C CXX)
# version number
SET ( VERSION_MAJOR 0 )
SET ( VERSION_MINOR 0 )
SET ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
# src : main
file ( GLOB SOURCES src/main.cpp )
# headers
include_directories ( "include" )
# src : libre2 - Download, build and install the library
find_package (Threads)
include ( "modules/re2.cmake" )
set(RE2_STATIC_LIBRARIES -L${RE2_LIBRARY_DIR} -l libre2.a )
# compile
set ( CMAKE_RUNTIME_OUTPUT_DIRECTORY "../bin" )
add_executable ( project-v${VERSION_MAJOR}.${VERSION_MINOR} ${SOURCES})
target_link_libraries ( project-v${VERSION_MAJOR}.${VERSION_MINOR} ${RE2_STATIC_LIBRARIES})
add_dependencies(project-v${VERSION_MAJOR}.${VERSION_MINOR} RE2)
target_link_libraries (project-v${VERSION_MAJOR}.${VERSION_MINOR} ${CMAKE_THREAD_LIBS_INIT})
My new CmakeLists.txt
cmake_minimum_required( VERSION 2.8.7 )
project( simmc-agent )
# version number
set ( VERSION_MAJOR 0 )
set ( VERSION_MINOR 0 )
# cpr requires c++11
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11" )
# src : main
file ( GLOB SOURCES *.cpp )
# libre2
if (NOT RE2_NAME)
include (ExternalProject)
set(ABBREV "RE2")
set(EXT_PREFIX "external/re2" )
set(${ABBREV}_NAME ${ABBREV})
set(${ABBREV}_INCLUDE_DIRS ${EXT_PREFIX}/src/re2/)
set(APP_DEPENDENCIES ${APP_DEPENDENCIES} ${ABBREV})
message("Installing ${RE2_NAME} into ext build area: ${EXT_PREFIX} ...")
ExternalProject_Add(RE2
PREFIX ${EXT_PREFIX}
URL https://re2.googlecode.com/files/re2-20130115.tgz
URL_MD5 "ef66646926e6cb8f11f277b286eac579"
PATCH_COMMAND ""
CONFIGURE_COMMAND ""
BUILD_COMMAND make
INSTALL_COMMAND ""
BUILD_IN_SOURCE 1
)
set(CXXFLAGS CMAKE_CXX_FLAGS)
set(${ABBREV}_LIBRARIES ${EXT_PREFIX}/src/RE2/obj/so/libre2.so)
set(${ABBREV}_STATIC_LIBRARIES ${EXT_PREFIX}/src/RE2/obj/libre2.a)
set_target_properties(${RE2_NAME} PROPERTIES EXCLUDE_FROM_ALL ON)
endif (NOT RE2_NAME)
if(RE2_INCLUDE_DIRS AND RE2_LIBRARIES)
set(RE2_FOUND TRUE)
endif(RE2_INCLUDE_DIRS AND RE2_LIBRARIES)
if(RE2_FOUND)
message(STATUS "Found RE2: ${RE2_LIBRARIES}")
else(RE2_FOUND)
message(FATAL_ERROR "Could not find RE2 library.")
endif(RE2_FOUND)
set(INCLUDES ${INCLUDES} ${RE2_INCLUDE_DIRS} )
# set(LIBS ${LIBS} ${RE2_STATIC_LIBRARIES} )
# headers
include_directories ( "include" )
# test
option( PRINT_JSON "Set to ON to print json objects before sending" OFF )
message(STATUS "${PRINT_JSON}: ${${PRINT_JSON}}")
if ( PRINT_JSON )
add_definitions ( -DPRINT_JSON )
endif ()
# compile
set ( CMAKE_RUNTIME_OUTPUT_DIRECTORY "../bin" )
add_executable ( agent-v${VERSION_MAJOR}.${VERSION_MINOR} ${SOURCES} )
target_link_libraries ( agent-v${VERSION_MAJOR}.${VERSION_MINOR} ${RE2_LIBRARIES})

Linker error using restbed

so, i'm trying to compile my program which has restbed as dependency.
I already compiled restbed with the following command:
cmake -DBUILD_TESTS=NO -DBUILD_SSL=YES -DBUILD_SHARED=NO
make -j4 install
Compiling restbed does not result in any errors.
Now the Problem:
I'm using the example source code from here: https://github.com/Corvusoft/restbed
This is my CMakeLists:
cmake_minimum_required (VERSION 2.6)
project(FDRService CXX)
# Setup
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_BINARY_DIR "./build")
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
# FD Variables
set(FDRService_VERSION_MAJOR 1)
set(FDRService_VERSION_MINOR 0)
set(FDRService_INCLUDE_DIR "./include")
set(FDRService_SOURCE_DIR "./src")
# RestBED
set(RESTBED_ROOT "dependency/restbed/distribution")
set(RESTBED_INCLUDE_DIR "${RESTBED_ROOT}/include")
set(RESTBED_LIBRARY_DIR "${RESTBED_ROOT}/library")
# find all libraries
file(GLOB_RECURSE RESTBED_LIBRARY_FILES
"${RESTBED_LIBRARY_DIR}/*.a"
)
include_directories(${RESTBED_INCLUDE_DIR})
# find project source files
file(GLOB_RECURSE FDRService_FILES
"${FDRService_INCLUDE_DIR}/*.h"
"${FDRService_INCLUDE_DIR}/*.hpp"
"${FDRService_SOURCE_DIR}/*.c"
"${FDRService_SOURCE_DIR}/*.cpp"
)
add_executable(FDRService ${FDRService_FILES})
target_link_libraries(FDRService ${RESTBED_LIBRARY_FILES})
When i try to compile my project i get the following linker errors:
http://pastebin.com/hXPmAV2W (too much text for StackOverflow...)
My guess is that the OpenSSL library is not linked into the static .a file of restbed, but i put -DBUILD_SSL in the build command.
I hope anyone of you can help me with this problem. It's driving me crazy.
If you need more information, just tell me and i'll edit this post.
We use the following cmake modules to locate the necessary dependencies for projects reliant on Restbed.
Findrestbed.cmake
find_path( restbed_SOURCE CMakeLists.txt HINTS "${CMAKE_SOURCE_DIR}/dependency/restbed" )
if ( restbed_SOURCE )
set( restbed_FOUND TRUE )
set( restbed_BUILD "${CMAKE_CURRENT_BINARY_DIR}/restbed_build" )
set( restbed_DISTRIBUTION "${CMAKE_CURRENT_BINARY_DIR}/distribution" )
include( ExternalProject )
ExternalProject_Add( restbed SOURCE_DIR ${restbed_SOURCE}
PREFIX restbed_build
INSTALL_DIR ${restbed_DISTRIBUTION}
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${restbed_DISTRIBUTION} -DBUILD_SSL=${BUILD_SSL} -DBUILD_SHARED=NO )
set( restbed_INCLUDE "${restbed_DISTRIBUTION}/include" )
set( restbed_LIBRARY "${restbed_DISTRIBUTION}/library/${CMAKE_STATIC_LIBRARY_PREFIX}restbed${CMAKE_STATIC_LIBRARY_SUFFIX}" )
message( STATUS "${Green}Found Restbed include at: ${restbed_SOURCE}${Reset}" )
else ( )
message( FATAL_ERROR "${Red}Failed to locate Restbed dependency.${Reset}" )
endif ( )
Findopenssl.cmake
find_library( ssl_LIBRARY ssl ssleay32 HINTS "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl/out32dll" "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl" "/usr/lib" "/usr/local/lib" "/opt/local/lib" )
find_library( crypto_LIBRARY crypto libeay32 HINTS "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl/out32dll" "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl" "/usr/lib" "/usr/local/lib" "/opt/local/lib" )
find_path( ssl_INCLUDE openssl/ssl.h HINTS "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl/inc32" "${CMAKE_SOURCE_DIR}/dependency/restbed/dependency/openssl/include" "/usr/include" "/usr/local/include" "/opt/local/include" )
if ( ssl_INCLUDE AND ssl_LIBRARY AND crypto_LIBRARY )
set( OPENSSL_FOUND TRUE )
add_definitions( -DBUILD_SSL=TRUE )
if ( APPLE AND BUILD_SSL )
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations" )
endif( )
message( STATUS "${Green}Found OpenSSL library at: ${ssl_LIBRARY}${Reset}" )
message( STATUS "${Green}Found OpenSSL include at: ${ssl_INCLUDE}${Reset}" )
message( STATUS "${Green}Found Crypto library at: ${crypto_LIBRARY}${Reset}" )
else ( )
message( FATAL_ERROR "${Red}Failed to locate OpenSSL dependency. see dependency/restbed/dependency/openssl; ./config shared; make all${Reset}" )
endif ( )
You can see an example of this in action at the RestQ GIT repository.

CMaker Missing DLL Windows

I'm trying to build a project using CMake 3.4.0-rc3 on 64-bit Windows 8.
When I click "generate", I get an error saying:
Thing is, when I go to C:\MinGW\bin I do have a dll called libmpc-3.dll. By looking at a similar answer I tried running mingw-get install mpc which ran successfully but didn't fix the problem. Any advice? :)
EDIT: CMakeLists.txt
#
# Root vxl
#
# vxl-maintainers#lists.sf.net
CMAKE_MINIMUM_REQUIRED(VERSION 2.5)
# Support for CMake 2.6
IF( COMMAND CMAKE_POLICY )
CMAKE_POLICY(SET CMP0003 NEW)
ENDIF( COMMAND CMAKE_POLICY )
# CMake 2.8 stuff
SET( CMAKE_LEGACY_CYGWIN_WIN32 0 ) # Remove when CMake >= 2.8.4 is required
# Use #rpath on OS X
IF( POLICY CMP0042 )
CMAKE_POLICY(SET CMP0042 NEW)
ENDIF()
PROJECT(vxl)
SET( LIBRARY_OUTPUT_PATH ${vxl_BINARY_DIR}/lib CACHE PATH
"Output directory for the vxl libraries" )
IF( NOT EXECUTABLE_OUTPUT_PATH )
SET( EXECUTABLE_OUTPUT_PATH "." )
ENDIF( NOT EXECUTABLE_OUTPUT_PATH )
# CMake support directory.
SET(VXL_CMAKE_DIR ${vxl_SOURCE_DIR}/config/cmake/Modules)
INCLUDE( ${VXL_CMAKE_DIR}/VXLStandardOptions.cmake )
INCLUDE( ${vxl_SOURCE_DIR}/config/cmake/config/vxl_utils.cmake )
# INCLUDE( ${vxl_SOURCE_DIR}/UseSTLPort.cmake )
INCLUDE(${vxl_SOURCE_DIR}/config/cmake/doxygen/doxygen.cmake)
# Copy the UseVXL.cmake file to the binary directory so that client
# projects don't need to find the source directory first. They can run
# the UseVXL.cmake from the vxl binary directory, and determine the
# vxl source directory by loading the cache.
CONFIGURE_FILE( ${VXL_CMAKE_DIR}/UseVXL.cmake
${vxl_BINARY_DIR}/UseVXL.cmake COPYONLY )
# Copy CTestCustom.cmake to top of build tree
CONFIGURE_FILE( ${VXL_CMAKE_DIR}/CTestCustom.cmake
${vxl_BINARY_DIR}/CTestCustom.cmake COPYONLY )
# Location of VXL's FindXXX.cmake CMake modules.
# This is identical to VXL_CMAKE_DIR. Perhaps we should eliminate MODULE_PATH?
SET( MODULE_PATH ${vxl_SOURCE_DIR}/config/cmake/Modules CACHE STATIC "VXL module path" )
# For use in client projects that call UseVXL.cmake
SET (VXL_LIBRARY_PATH ${LIBRARY_OUTPUT_PATH} CACHE STATIC "Where all the vxl libraries are, for clients to use." )
# Options to add extra compiler and linker flags
#
# These options allow you to specify additional flags without
# affecting the default flags for a particular platform or build type.
# This is especially useful for adding extra warning flags.
SET( VXL_EXTRA_CMAKE_C_FLAGS CACHE STRING "Extra flags appended to CMAKE_C_FLAGS" )
SET( VXL_EXTRA_CMAKE_CXX_FLAGS CACHE STRING "Extra flags appended to CMAKE_CXX_FLAGS" )
SET( VXL_EXTRA_CMAKE_EXE_LINKER_FLAGS CACHE STRING "Extra flags appended to CMAKE_EXE_LINKER_FLAGS" )
SET( VXL_EXTRA_CMAKE_MODULE_LINKER_FLAGS CACHE STRING "Extra flags appended to CMAKE_MODULE_LINKER_FLAGS" )
SET( VXL_EXTRA_CMAKE_SHARED_LINKER_FLAGS CACHE STRING "Extra flags appended to CMAKE_SHARED_LINKER_FLAGS" )
SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${VXL_EXTRA_CMAKE_C_FLAGS}" )
SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${VXL_EXTRA_CMAKE_CXX_FLAGS}" )
SET( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${VXL_EXTRA_CMAKE_EXE_LINKER_FLAGS}" )
SET( CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${VXL_EXTRA_CMAKE_MODULE_LINKER_FLAGS}" )
SET( CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${VXL_EXTRA_CMAKE_SHARED_LINKER_FLAGS}" )
# Option to specify whether this is a build for the dashboard. Each
# dashboard build should set BUILD_FOR_VXL_DASHBOARD to YES in the
# initial cache (set in the CTest script).
OPTION( BUILD_FOR_VXL_DASHBOARD "Is this a build for the dashboard?" NO )
# A variable to default some OPTIONs to YES for the dashboard, but to
# NO for other builds.
IF( BUILD_FOR_VXL_DASHBOARD )
SET( YES_FOR_DASHBOARD "YES" )
ELSE( BUILD_FOR_VXL_DASHBOARD )
SET( YES_FOR_DASHBOARD "NO" )
ENDIF( BUILD_FOR_VXL_DASHBOARD )
# Use this variable in vxl_config.h to tell if it is a shared build
set(VXL_BUILD_SHARED FALSE)
if(BUILD_SHARED_LIBS)
set(VXL_BUILD_SHARED TRUE)
endif()
# Do platform-specific configuration.
IF(NOT VXL_NO_CMAKE_CONFIGURE)
SUBDIRS(config/cmake/config)
ENDIF(NOT VXL_NO_CMAKE_CONFIGURE)
# Options to reduce build to just some core libraries
OPTION( BUILD_CORE_NUMERICS "Build VXL's numerics libraries" YES )
OPTION( BUILD_CORE_SERIALISATION "Build VXL's serialisation libraries" YES )
OPTION( BUILD_CORE_UTILITIES "Build VXL's utility libraries" YES )
OPTION( BUILD_CORE_GEOMETRY "Build VXL's geometry libraries" YES )
OPTION( BUILD_CORE_IMAGING "Build VXL's imaging libraries" YES )
OPTION( BUILD_NONDEPRECATED_ONLY "Build only nondeprecated libraries (Experimental)" NO )
IF(BUILD_CORE_NUMERICS)
IF( BUILD_FOR_VXL_DASHBOARD )
OPTION( BUILD_CORE_PROBABILITY "Build VXL's probability libraries (Experimental)" YES )
ELSE( BUILD_FOR_VXL_DASHBOARD )
OPTION( BUILD_CORE_PROBABILITY "Build VXL's probability libraries (Experimental)" NO )
ENDIF( BUILD_FOR_VXL_DASHBOARD )
ENDIF(BUILD_CORE_NUMERICS)
SET (BUILD_CORE_ALL OFF CACHE INTERNAL "All Core libraries are being built")
IF (BUILD_CORE_GEOMETRY AND BUILD_CORE_NUMERICS)
IF (BUILD_CORE_UTILITIES AND BUILD_CORE_SERIALISATION)
IF (BUILD_CORE_IMAGING)
SET (BUILD_CORE_ALL ON CACHE INTERNAL "All Core libraries are being built")
ENDIF (BUILD_CORE_IMAGING)
ENDIF (BUILD_CORE_UTILITIES AND BUILD_CORE_SERIALISATION)
ENDIF (BUILD_CORE_GEOMETRY AND BUILD_CORE_NUMERICS)
# Optionally use old error reporting methods, rather than exceptions.
# The main use is in vil which often uses/used null images to imply an error.
OPTION (VXL_LEGACY_ERROR_REPORTING "Use old error reporting methods rather than exceptions?" YES)
IF (VXL_LEGACY_ERROR_REPORTING)
ADD_DEFINITIONS( -DVXL_LEGACY_ERROR_REPORTING )
ENDIF (VXL_LEGACY_ERROR_REPORTING)
# Options to build no longer maintained libraries.
# It is still useful to have the dashboard check that they are correct,
# but no-one is likely to work on improving test coverage or fixing memory leaks.
OPTION( BUILD_UNMAINTAINED_LIBRARIES "Build libraries that are no longer actively maintained?" ${YES_FOR_DASHBOARD} )
# Option to build Windows Unicode support, the string
# type of which is wchar_t, each character is a 16-bit unsigned integer.
IF(WIN32)
IF(VXL_HAS_WIN_WCHAR_T)
OPTION( VXL_USE_WIN_WCHAR_T "Build overloading functions that accept Windows wide char strings?" YES )
IF(VXL_USE_WIN_WCHAR_T) # Force it to be 0/1
SET(VXL_USE_WIN_WCHAR_T 1)
ELSE(VXL_USE_WIN_WCHAR_T)
SET(VXL_USE_WIN_WCHAR_T 0)
ENDIF(VXL_USE_WIN_WCHAR_T)
ELSE(VXL_HAS_WIN_WCHAR_T)
SET(VXL_USE_WIN_WCHAR_T 0)
ENDIF(VXL_HAS_WIN_WCHAR_T)
ELSE(WIN32)
# avoid empty macro definition
SET(VXL_USE_WIN_WCHAR_T 0)
ENDIF(WIN32)
# In order to be able to link vxl libraries into shared libraries on 64 bit linux, the -fPIC
# compiler flag must be added. Only do this if we are on a x86_64 *nix platform, we're building
# static libraries, and the user has not explicitly requested position dependent code.
IF(UNIX)
IF(NOT BUILD_SHARED_LIBS AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
OPTION(BUILD_POSITION_DEPENDENT_CODE "Generate position dependent code (i.e. code cannot be used in shared library)" OFF)
MARK_AS_ADVANCED(BUILD_POSITION_DEPENDENT_CODE)
IF (NOT BUILD_POSITION_DEPENDENT_CODE)
message(STATUS "Adding -fPIC compiler flag to generate position independent code.")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}-fPIC")
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}-fPIC")
ENDIF(NOT BUILD_POSITION_DEPENDENT_CODE)
ENDIF(NOT BUILD_SHARED_LIBS AND CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
ENDIF(UNIX)
# Build the core vxl + support libraries
SUBDIRS(vcl v3p core)
# Optionally build the contributed libraries
IF( EXISTS ${vxl_SOURCE_DIR}/contrib/CMakeLists.txt )
OPTION( BUILD_CONTRIB "Build the contributed libraries?" YES )
ENDIF( EXISTS ${vxl_SOURCE_DIR}/contrib/CMakeLists.txt )
IF( BUILD_CONTRIB AND BUILD_CORE_ALL)
SUBDIRS( contrib )
ENDIF( BUILD_CONTRIB AND BUILD_CORE_ALL)
# Use the old configure script if the cache tells us to do so.
IF(VXL_NO_CMAKE_CONFIGURE)
IF(RUN_CONFIGURE)
EXEC_PROGRAM( ${vxl_SOURCE_DIR}/configure
${vxl_BINARY_DIR} )
ENDIF(RUN_CONFIGURE)
ENDIF(VXL_NO_CMAKE_CONFIGURE)
# Some types of path names can cause havoc with regular expressions,
# so avoid those.
IF( ${vxl_BINARY_DIR} MATCHES \\+ )
MESSAGE(SEND_ERROR "You cannot have a + in your binary path")
ENDIF( ${vxl_BINARY_DIR} MATCHES \\+ )
IF( ${vxl_SOURCE_DIR} MATCHES \\+ )
MESSAGE(SEND_ERROR "You cannot have a + in your source path")
ENDIF( ${vxl_SOURCE_DIR} MATCHES \\+ )
# include CMakeListsLocal.txt from source directory if it exists
# also include it from the binary dir if different from source dir
IF( ${vxl_BINARY_DIR} MATCHES ${vxl_SOURCE_DIR} )
INCLUDE( ${vxl_SOURCE_DIR}/CMakeListsLocal.txt OPTIONAL )
ELSE( ${vxl_BINARY_DIR} MATCHES ${vxl_SOURCE_DIR} )
INCLUDE( ${vxl_SOURCE_DIR}/CMakeListsLocal.txt OPTIONAL )
INCLUDE( ${vxl_BINARY_DIR}/CMakeListsLocal.txt OPTIONAL )
ENDIF( ${vxl_BINARY_DIR} MATCHES ${vxl_SOURCE_DIR} )
# Standard include directories.
SET(VXLCORE_INCLUDE_DIR ${vxl_BINARY_DIR}/core ${vxl_SOURCE_DIR}/core)
SET(VXLCORE_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/include/vxl/core)
SET(VCL_INCLUDE_DIR ${vxl_BINARY_DIR}/vcl ${vxl_SOURCE_DIR}/vcl)
SET(VCL_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/include/vxl/vcl)
# Autoconf does not work on windows. Use hardcoded results if not using
# cmake to configure.
IF(VXL_NO_CMAKE_CONFIGURE)
IF(WIN32)
IF(NOT CYGWIN)
SET(VCL_INCLUDE_DIR ${vxl_SOURCE_DIR}/vcl/config.win32 ${VCL_INCLUDE_DIR})
SET(VCL_INSTALL_INCLUDE_DIR
${CMAKE_INSTALL_PREFIX}/include/vcl/config.win32
${VCL_INSTALL_INCLUDE_DIR}
)
ENDIF(NOT CYGWIN)
ENDIF(WIN32)
ENDIF(VXL_NO_CMAKE_CONFIGURE)
INCLUDE_DIRECTORIES(${VCL_INCLUDE_DIR} ${VXLCORE_INCLUDE_DIR})
# This SUBDIRS command must be the last SUBDIRS command in this file
SUBDIRS( config/cmake/export )

Error with the CMakeLists.txt in opencv project

I'm begining an opencv project in C++ and I figure that it'll be a nice occasion to learn some cmake. This is my project hirerachy:
project/
|__include/
|__sample1.h
|__sample2.h
|__build/
|__doc/
|__src/
|__sample1.cpp
|__sample2.cpp
|__test/
|__main.cpp
|__CMakeLists.txt
The CMakeLists.txt is :
CMAKE_MINIMUM_REQUIRED( VERSION 2.8 )
SET( PROJ_NAME "Project" )
SET( PROJ_PATH ${CMAKE_SOURCE_DIR} )
SET( PROJ_OUT_PATH ${CMAKE_BINARY_DIR} )
SET( PROJ_LIBRARIES ${OpenCV_LIBS} )
SET( PROJ_INCLUDES "include" )
FILE( GLOB_RECURSE PROJ_SOURCES src/*cpp test/*cpp )
FILE( GLOB_RECURSE PROJ_HEADERS include/${PROJ_NAME}/*.h )
PROJECT( ${PROJ_NAME} )
FIND_PACKAGE( OpenCV REQUIRED )
INCLUDE_DIRECTORIES( ${PROJ_INCLUDES} )
ADD_EXECUTABLE( ${PROJ_NAME} ${PROJ_SOURCES} )
TARGET_LINK_LIBRARIES( ${PROJ_NAME} ${PROJ_LIBRARIES} )
The makefile is generated, but when I execute "make" I have some "undefined references" to opencv functions.
Any help would be appreciated, and of course if you want more information just ask :)
Thanks
SET( PROJ_LIBRARIES ${OpenCV_LIBS} )
OpenCV_LIBS will be set AFTER you search for the package with find_package().
You also need to add your headers to add_executable().

CMake FIND_LIBRARY works on Windows but not OS X

The same code ran on Cmake in windows finds the libraries, but on mac it cannot find them.The code finds the Include directories fine just not the libraries
Here is a screen of the Cmake output
And here is a Screen of the Directory structure
here is the CMakeLists.txt
cmake_minimum_required(VERSION 2.6)
project (GameCreatorEngine)
# version can be passed into the application from CMake TODO
set(cmake_test_VERSION_MAJOR 1)
set(cmake_test_VERSION_MINOR 3)
# compiler flags
add_definitions(
-c
-W4
)
# SDL LIB INCLUDES
SET( SDL2_SEARCH_PATHS
${SDL2_ROOT_DIR}
./res/lib/SDL2
)
FIND_PATH( SDL2_INCLUDE_DIRS
NAMES
SDL.h SDL2/SDL.h
PATHS
${SDL2_SEARCH_PATHS}
PATH_SUFFIXES
include
)
FIND_LIBRARY( SDL2
NAMES
SDL2.lib
PATHS
${SDL2_SEARCH_PATHS}
PATH_SUFFIXES
lib
)
FIND_LIBRARY( SDL2_MAIN
NAMES
SDL2main.lib
PATHS
${SDL2_SEARCH_PATHS}
PATH_SUFFIXES
lib
)
IF ( SDL2_INCLUDE_DIRS AND SDL2_MAIN AND SDL2)
SET( SDL2_FOUND TRUE )
MESSAGE(STATUS "Looking for SDL2 - found")
ELSE ( SDL2_INCLUDE_DIRS AND SDL2_MAIN AND SDL2 )
SET( SDL2_FOUND FALSE )
MESSAGE(STATUS "Looking for SDL2 - not found")
ENDIF ( SDL2_INCLUDE_DIRS AND SDL2_MAIN AND SDL2 )
# GLEW LIB INCLUDES
SET(GLEW_SEARCH_PATHS
${GLEW_ROOT_DIR}
./res/lib/GLEW
)
FIND_PATH( GLEW_INCLUDE_DIRS
NAMES
glew.h
PATHS
${GLEW_SEARCH_PATHS}
PATH_SUFFIXES
include
)
FIND_LIBRARY( GLEW_LIBRARIES
NAMES
glew32
PATHS
${GLEW_SEARCH_PATHS}
PATH_SUFFIXES
lib/Release/Win32
)
IF ( GLEW_INCLUDE_DIRS AND GLEW_LIBRARIES )
SET( GLEW_FOUND TRUE )
MESSAGE( STATUS "Looking for GLEW - found" )
ELSE ( GLEW_INCLUDE_DIRS AND GLEW_LIBRARIES )
SET( GLEW_FOUND FALSE )
MESSAGE( STATUS "Looking for GLEW - not found" )
ENDIF ( GLEW_INCLUDE_DIRS AND GLEW_LIBRARIES )
# ASSIMP
SET(ASSIMP_SEARCH_PATHS
${ASSIMP_ROOT_DIR}
./res/lib/assimp
)
FIND_PATH( ASSIMP_INCLUDE_DIRS
NAMES
mesh.h
PATHS
${ASSIMP_SEARCH_PATHS}
PATH_SUFFIXES
include
)
FIND_LIBRARY( ASSIMP_LIBRARIES
NAMES
assimp ASSIMP
PATHS
${ASSIMP_SEARCH_PATHS}
PATH_SUFFIXES
lib
lib/x86
lib/x64
)
IF ( ASSIMP_INCLUDE_DIRS AND ASSIMP_LIBRARIES )
SET( ASSIMP_FOUND TRUE )
MESSAGE(STATUS "Looking for ASSIMP - found")
ELSE ( ASSIMP_INCLUDE_DIRS AND ASSIMP_LIBRARIES )
SET( ASSIMP_FOUND FALSE )
MESSAGE(STATUS "Looking for ASSIMP - not found")
ENDIF ( ASSIMP_INCLUDE_DIRS AND ASSIMP_LIBRARIES )
# glm maths lib
SET( GLM_SEARCH_PATHS
${GLM_ROOT_DIR}
./res/lib/glm
)
FIND_PATH( GLM_INCLUDE_DIRS
NAMES
glm.hpp
PATHS
${GLM_SEARCH_PATHS}
PATH_SUFFIXES
include
)
IF ( GLM_INCLUDE_DIRS)
SET( GLM_FOUND TRUE )
MESSAGE(STATUS "Looking for GLM - found")
ELSE ( GLM_INCLUDE_DIRS )
SET( ASSIMP_FOUND FALSE )
MESSAGE(STATUS "Looking for GLM - not found")
ENDIF ( GLM_INCLUDE_DIRS )
# OpenGL
find_package(OpenGL REQUIRED)
# GameCreatorLibrary
file(GLOB HDRS ${ENGINE_SOURCE_DIR}src/*.h)
file(GLOB SRCS ${ENGINE_SOURCE_DIR}src/*.cpp src/*.c)
add_executable(GameCreatorEngine ${HDRS} ${SRCS})
# Define the include DIRs
include_directories(
${SDL2_INCLUDE_DIRS}
${GLEW_INCLUDE_DIRS}
${ASSIMP_INCLUDE_DIRS}
${GLM_INCLUDE_DIRS}
${OPENGL_INCLUDE_DIRS}
${ENGINE_SOURCE_DIR}/headers
${ENGINE_SOURCE_DIR}/sources
)
# Define the link libraries
target_link_libraries( GameCreatorEngine
${SDL2}
${SDL2_MAIN}
${GLEW_LIBRARIES}
${ASSIMP_LIBRARIES}
${OPENGL_LIBRARIES}
)
The proper filename extension for libraries varies on different platforms. While .lib is used for both static and dll import libraries on Windows, OS X uses different naming conventions (.a for static and .so/.dylib for dynamic libraries, possibly with a lib prefix).
In order to still allow code that works with all those different naming conventions, find_library expects you to omit any extensions or prefixes completely and just give the bare name of the library.
So instead of find_library(SDL2 NAMES SDL2.lib [...]) you should just write find_library(SDL2 NAMES SDL2 [...]).
From your question it also seems that you are trying to link your OS X build against Windows binaries (.lib and .dll file extensions). This will not work. You need a separate set of binaries compiled for OS X.