Windows build

BUILD.md

@@ -22,12 +22,13 @@ $ git clone https://github.com/alicevision/CCTag.git
 Most of the dependencies can be installed from the common repositories (apt, yum etc):
 
 - Eigen3 (libeigen3-dev)
-- Boost >= 1.53 ([core, thread, system, filesystem, serialization, thread, exception, chrono, date-time, program-options, timer]-dev)
+- Boost >= 1.53 ([accumulators, atomic, chrono, core, date-time, exception, filesystem, math, program-options, ptr-container, system, serialization, timer, thread]-dev)
 - OpenCV >= 3.1
+- tbb >= 4.0
 
 On a recent Ubuntu-like distribution (e.g. 14.04), you may want to try to run:
 ```shell
-$ sudo apt-get install g++ git-all libpng12-dev libjpeg-dev libeigen3-dev libboost-atomic-dev libboost-chrono-dev libboost-date-time-dev libboost-dev libboost-program-options-dev libboost-exception-dev libboost-filesystem-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev libboost-timer-dev
+$ sudo apt-get install g++ git-all libpng12-dev libjpeg-dev libeigen3-dev libboost-atomic-dev libboost-chrono-dev libboost-date-time-dev libboost-dev libboost-program-options-dev libboost-exception-dev libboost-filesystem-dev libboost-serialization-dev libboost-system-dev libboost-thread-dev libboost-timer-dev libtbb-dev
 ```
 
 OpenCV need to be compiled separately and installed in some `OPENCV_INSTALL` path. Then, when running cmake you need to provide the path to the location where `OpenCVConfig.cmake` is installed, usually `${OPENCV_INSTALL}/share/share/OpenCV/` (see below).
@@ -43,7 +44,7 @@ You now just need to be in the CCTag folder and run cmake:
 $ mkdir build && cd build
 $ cmake .. -DOpenCV_DIR=${OPENCV_INSTALL}/share/share/OpenCV/
 $ make -j `nproc`
-``` 
+```
 
 If you want to install the library to, say, a CCTAG_INSTALL path, just add `-DCMAKE_INSTALL_PREFIX=$CCTAG_INSTALL` at cmake command line.
 If you want to build CCTag as a shared library: `-DBUILD_SHARED_LIBS=ON`.
@@ -56,7 +57,7 @@ When you install CCTag a file `CCTagConfig.cmake` is installed in `$CCTAG_INSTAL
 In your `CMakeLists.txt` file you can add the dependency in this way:
 
 ```cmake
-# Find the package from the CCTagConfig.cmake 
+# Find the package from the CCTagConfig.cmake
 # in <prefix>/lib/cmake/CCTag/. Under the namespace CCTag::
 # it exposes the target CCTag that allows you to compile
 # and link with the library
@@ -80,4 +81,3 @@ Note 1: CCTag uses NVidia CUB (CCTag includes a copy of CUB from CUDA 7.0).
 Several CUB functions are known to fail with a few NVidia cards including our reference card,
 the GTX 980 Ti.
 The CUB that is included with CUDA 7.5 does not solve this problem.
-

CMakeLists.txt

@@ -11,6 +11,7 @@ option(CCTAG_SERIALIZE "Store all the output" OFF)
 option(VISUAL_DEBUG "Enable visual debug" OFF)
 option(CCTAG_NO_COUT "Disable output stream" ON)
 option(WITH_CUDA "Compile the library with CUDA support" ON)
+option(BUILD_APPS "Build the sample applications" ON)
 
 option(CCTAG_USE_POSITION_INDEPENDENT_CODE "Generate position independent code." ON)
 option(CCTAG_ENABLE_SIMD_AVX2 "Enable AVX2 optimizations" OFF)

appveyor.yml

@@ -0,0 +1,58 @@
+version: '1.0.{build}'
+
+image: Visual Studio 2015
+
+platform:
+  - x64
+
+configuration:
+  - Release
+
+install:
+    # - cmd: >-
+    #       call cudaInstallAppveyor.cmd
+
+    - vcpkg upgrade --no-dry-run
+    - vcpkg list
+    - vcpkg install
+          boost-accumulators
+          boost-algorithm
+          boost-container
+          boost-date-time
+          boost-exception
+          boost-filesystem
+          boost-iterator
+          boost-lexical-cast
+          boost-math
+          boost-mpl
+          boost-multi-array
+          boost-ptr-container
+          boost-program-options
+          boost-serialization
+          boost-spirit
+          boost-static-assert
+          boost-test
+          boost-thread
+          boost-throw-exception
+          boost-timer
+          boost-type-traits
+          boost-unordered
+          opencv
+          tbb
+          eigen3
+          --triplet %PLATFORM%-windows
+    - vcpkg list
+
+before_build:
+    - md build
+    - cd build
+    - cmake -G "Visual Studio 14 2015" -A x64 -T v140,host=x64 -DCMAKE_BUILD_TYPE=%configuration% -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake -DBUILD_APPS:BOOL=ON -DWITH_CUDA:BOOL=OFF -DCCTAG_SERIALIZE:BOOL=ON -DVISUAL_DEBUG:BOOL=ON ..
+    - ls -l
+
+build:
+  verbosity: detailed
+  project: $(APPVEYOR_BUILD_FOLDER)\build\CCTag.sln 
+  parallel: true
+
+cache:
+  c:\tools\vcpkg\installed\

src/CMakeLists.txt

@@ -40,7 +40,7 @@ set( CCTag_cpp
 
 if(WITH_CUDA)
 
-  set(CUDA_cpp 
+  set(CUDA_cpp
         ./cctag/cuda/debug_macros.cpp
         ./cctag/cuda/device_prop.cpp)
 
@@ -87,32 +87,36 @@ if(WITH_CUDA)
   # set(BUILD_SHARED_LIBS ON)
 
   set(CUDA_NVCC_FLAGS  "${CUDA_NVCC_FLAGS};-DSM_ARCH=${CCTAG_SM_ARCH};-DSM=${CCTAG_SM};-DCUB_CDP")
- 
+
   # this must go before CUDA_ADD_LIBRARY otherwise we won't be able to add it
   # after
   # https://github.com/Kitware/CMake/blob/master/Modules/FindCUDA.cmake#L147
-  # INCLUDE_DIRECTORIES -- "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>" 
+  # INCLUDE_DIRECTORIES -- "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>"
   include_directories(${CMAKE_CURRENT_LIST_DIR}
                       ${Boost_INCLUDE_DIRS} ${OpenCV_INCLUDE_DIRS} ${Eigen_INCLUDE_DIR}
 		      ${TBB_INCLUDE_DIRS}
                       "${CMAKE_SOURCE_DIR}/src"
                       "${CMAKE_SOURCE_DIR}/3rdparty/Cuda-7.0-cub")
- 
+
   CUDA_ADD_LIBRARY(CCTag ${CUDA_cpp} ${CUDA_cu} ${CCTag_cpp})
 
   # since we used CUDA_ADD_LIBRARY we cannot use PUBLIC or PRIVATE here
-  target_link_libraries(CCTag 
-                       ${OpenCV_LIBS} ${Boost_LIBRARIES} ${Eigen_LIBRARIES} 
-                       ${TBB_LIBRARIES} ${CUDA_CUDADEVRT_LIBRARY} pthread dl)
+  target_link_libraries(CCTag
+                       ${OpenCV_LIBS} ${Boost_LIBRARIES} ${Eigen_LIBRARIES}
+                       ${TBB_LIBRARIES} ${CUDA_CUDADEVRT_LIBRARY})
 
-  target_compile_definitions(CCTag 
-                         PUBLIC ${Boost_DEFINITIONS} 
+  if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+   target_link_libraries(CCTag pthread dl)
+  endif()
+
+  target_compile_definitions(CCTag
+                         PUBLIC ${Boost_DEFINITIONS}
                          PUBLIC -DWITH_CUDA -DSM_ARCH=${CCTAG_SM_ARCH} -DSM=${CCTAG_SM} -DCUB_CDP
-                         PRIVATE ${TBB_DEFINITIONS}) 
+                         PRIVATE ${TBB_DEFINITIONS})
 
   # This is nececessary for the CCTagConfig.cmake to correctly export the
   # includes, always because we used CUDA_ADD_LIBRARY
-  set_target_properties(CCTag PROPERTIES INTERFACE_INCLUDE_DIRECTORIES 
+  set_target_properties(CCTag PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
        "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>;${CUDA_INCLUDE_DIRS};${Boost_INCLUDE_DIRS};${Eigen_INCLUDE_DIR};${OpenCV_INCLUDE_DIRS}")
   get_target_property(testprop CCTag INTERFACE_INCLUDE_DIRECTORIES )
   message(STATUS "testprop: ${testprop}")
@@ -125,25 +129,33 @@ else(WITH_CUDA)
   add_library(CCTag ${CCTag_cpp})
   set_target_properties(CCTag PROPERTIES VERSION ${PROJECT_VERSION})
 
-  target_include_directories(CCTag 
+  target_include_directories(CCTag
                            PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>"
                                   "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
                            PUBLIC ${Boost_INCLUDE_DIRS} ${Eigen_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS}
-                           PRIVATE ${TBB_INCLUDE_DIRS}) 
+                           PRIVATE ${TBB_INCLUDE_DIRS})
 
   get_target_property(testprop CCTag INTERFACE_INCLUDE_DIRECTORIES )
   message(STATUS "testprop: ${testprop}")
 
-  target_compile_definitions(CCTag 
-                             PUBLIC ${Boost_DEFINITIONS} 
-                             PRIVATE ${TBB_DEFINITIONS}) 
-
-  target_link_libraries(CCTag 
-                        PUBLIC ${OpenCV_LIBS} ${Boost_LIBRARIES} ${Eigen_LIBRARIES} 
-                        PRIVATE ${TBB_LIBRARIES} pthread dl)
+  target_compile_definitions(CCTag
+                             PUBLIC ${Boost_DEFINITIONS}
+                             PRIVATE ${TBB_DEFINITIONS})
+
+  target_link_libraries(CCTag
+                        PUBLIC ${OpenCV_LIBS} ${Boost_LIBRARIES} ${Eigen_LIBRARIES}
+                        PRIVATE ${TBB_LIBRARIES})
+
+  if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    target_link_libraries(CCTag PRIVATE pthread dl)
+  endif()
 
 endif(WITH_CUDA)
 
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+  target_compile_definitions(CCTag PUBLIC "-DNOMINMAX")
+endif()
+
 # enable serialization
 if(CCTAG_SERIALIZE)
   target_compile_definitions(CCTag PUBLIC "-DCCTAG_SERIALIZE")
@@ -246,4 +258,6 @@ install(EXPORT "${targets_export_name}"
         NAMESPACE "${namespace}"
         DESTINATION "${config_install_dir}")
 
-add_subdirectory(applications)
+if(BUILD_APPS)
+  add_subdirectory(applications)
+endif()

src/applications/detection/CmdLine.cpp

@@ -5,37 +5,19 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
-#include <getopt.h>
 #include <iostream>
 #include <string>
+#include <memory>
+
+
 #include "CmdLine.hpp"
 
 namespace cctag {
 
-#define no_argument       0 
-#define required_argument 1 
-#define optional_argument 2
-
-
-static const struct option longopts[] =
-{
-    {"input",      required_argument, 0, 'i'},
-    {"nbrings",    required_argument, 0, 'n'},    
-    {"bank",       required_argument, 0, 'b'},
-    {"parameters", required_argument, 0, 'p'},
-    {"output",     optional_argument, 0, 'o'},   
-#ifdef WITH_CUDA
-    {"sync",       no_argument,       0, 0xd0 },
-    {"debug-dir",  required_argument, 0, 0xd1 },
-    {"use-cuda",   no_argument,       0, 0xd2 },
-    {"parallel",   required_argument, 0, 0xd3 },
-#endif
-    {0,0,0,0},
-};
 
 CmdLine::CmdLine( )
     : _filename( "" )
-    , _nCrowns( "" )
+    , _nRings( 0 )
     , _cctagBankFilename( "" )
     , _paramsFilename( "" )
     , _outputFolderName( "" )
@@ -45,52 +27,64 @@ CmdLine::CmdLine( )
     , _useCuda( false )
     , _parallel( 1 )
 #endif
-{ }
+	, _allParams("Program for detecting CCTags in images or in a video")
+{ 
+	using namespace boost::program_options;
 
-bool CmdLine::parse( int argc, char* argv[] )
-{
-  int index;
-  int iarg=0;
+	options_description required("Required input parameters");
+	required.add_options()
+		("input,i", value<std::string>(&_filename)->required(), "Path to an image (JPG, PNG) or video (avi, mov) or camera index for live capture (0, 1...)")
+		("nbrings,n", value<std::size_t>(&_nRings)->required(), "Number of rings of the CCTags to detect");
 
-  // bools to check that mandatory parameters are present
-  bool has_i = false;
-  bool has_n = false;
+	options_description optional("Optional parameters");
+	optional.add_options()
+		("bank,b", value<std::string>(&_cctagBankFilename)->default_value(_cctagBankFilename), "Path to a bank parameter file, e.g. 4Crowns/ids.txt")
+		("params,p", value<std::string>(&_paramsFilename)->default_value(_paramsFilename), "Path to configuration XML file")
+		("output,o", value<std::string>(&_outputFolderName)->default_value(_outputFolderName), "Output folder name")
+#ifdef WITH_CUDA
+		("sync", bool_switch(&_switchSync), "CUDA debug option, run all CUDA ops synchronously")
+		("use-cuda", bool_switch(&_useCuda), "Select GPU code instead of CPU code")
+		("debug-dir", value<std::string>(&_debugDir)->default_value(_debugDir), "Path storing image to debug intermediate GPU results")
+		("parallel", value<int>(&_parallel)->default_value(_parallel), "Use <n> CUDA pipes concurrently (default 1)")
+#endif
+		;
+
+	_allParams.add(required).add(optional);
+}
 
-  //turn off getopt error message
-  // opterr=1; 
+bool CmdLine::parse( int argc, char* argv[] )
+{
 
-  while(iarg != -1)
-  {
-    iarg = getopt_long(argc, argv, "i:n:b:p:o:", longopts, &index);
+	using namespace boost::program_options;
 
-    switch (iarg)
-    {
-      case 'i'  : _filename          = optarg; has_i = true; break;
-      case 'n'  : _nCrowns           = optarg; has_n = true; break;
-      case 'b'  : _cctagBankFilename = optarg; break;
-      case 'p'  : _paramsFilename    = optarg; break;
-      case 'o'  : _outputFolderName  = optarg; break;
-#ifdef WITH_CUDA
-      case 0xd0 : _switchSync        = true;   break;
-      case 0xd1 : _debugDir          = optarg; break;
-      case 0xd2 : _useCuda           = true;   break;
-      case 0xd3 : _parallel          = strtol( optarg, NULL, 0 );   break;
-#endif
-      default : break;
-    }
-  }
-  return ( has_i && has_n );
+	variables_map vm;
+	try
+	{
+		store(parse_command_line(argc, argv, _allParams), vm);
+		if (vm.count("help") || (argc == 1))
+		{
+			return false;
+		}
+		notify(vm);
+	}
+	catch (const std::exception& e)
+	{
+		std::cout << e.what() << std::endl;
+		return false;
+	}
+    return true;
 }
 
 void CmdLine::print( const char* const argv0 )
 {
     std::cout << "You called " << argv0 << " with:" << std::endl
          << "    --input     " << _filename << std::endl
-         << "    --nbrings     " << _nCrowns << std::endl
+         << "    --nbrings     " << _nRings << std::endl
          << "    --bank      " << _cctagBankFilename << std::endl
          << "    --params    " << _paramsFilename << std::endl
          << "    --output    " << _outputFolderName << std::endl;
 #ifdef WITH_CUDA
+	std::cout << "    --parallel " << _parallel << std::endl;
     if( _switchSync )
         std::cout << "    --sync " << std::endl;
     if( _debugDir != "" )
@@ -103,29 +97,7 @@ void CmdLine::print( const char* const argv0 )
 
 void CmdLine::usage( const char* const argv0 )
 {
-  std::cerr << "Usage: " << argv0 << "<parameters>\n"
-          "    Mandatory:\n"
-          "           [-i|--input] <imgpath>\n"
-          "           [-n|--nbrings] <nbrings>\n"
-          "    Optional:\n"
-          "           [-p|--params <confpath>]\n"
-          "           [-b|--bank] <bankpath>\n"
-          "           [-o|--output] <outputfoldername>\n"
-          "           [--sync]\n"
-          "           [--debug-dir <debugdir>]\n"
-          "           [--use-cuda]\n"
-          "           [--parallel <n>]\n"
-          "\n"
-          "    <imgpath>  - path to an image (JPG, PNG) or video (avi, mov) or camera index for live capture (0, 1...)\n"
-          "    <nbrings>  - number of rings of the CCTags to detect\n"
-          "    <bankpath> - path to a bank parameter file, e.g. 4Crowns/ids.txt \n"
-          "    <output>   - output folder name \n"
-          "    <confpath> - path to configuration XML file \n"
-          "    --sync     - CUDA debug option, run all CUDA ops synchronously\n"
-          "    <debugdir> - path storing image to debug intermediate GPU results\n"
-          "    --use-cuda - select GPU code instead of CPU code\n"
-          "    --parallel - use <n> CUDA pipes concurrently (default 1)\n"
-          "\n" << std::endl;
+	std::cout << _allParams << std::endl;
 }
 
 }