Merge branch 'develop' into feature/VectorValuePrint

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,35 @@
+---
+name: "Bug Report"
+about: Submit a bug report to help us improve GTSAM
+---
+
+<!--Please only submit issues/bug reports that come with enough information to reproduce them, ideally a unit test that fails, and possible ideas on what might be wrong. -->
+
+<!-- Even better yet, fix the bug and/or documentation, add a unit test, and create a pull request! -->
+
+<!-- This is a channel to report bugs/issues, not a support channel to help install/use/debug your own code. We'd love to help, but just don't have the bandwidth. Please post questions in the GTSAM Google group (https://groups.google.com/forum/#!forum/gtsam-users) -->
+
+## Description
+
+<!-- A clear description of the bug -->
+
+## Steps to reproduce
+
+1. 
+2.
+
+<!-- If you have a code sample, unit test, error messages, stack traces, etc., please provide it here as well -->
+
+## Expected behavior
+
+<!-- A clear and concise description of what you expected to happen. -->
+
+## Environment
+
+<!-- Please provide information about your code environment, things such as OS, language of use (C++, Matlab or Python), version of dependent libraries if using a custom build etc., anything to provide us more information. -->
+
+<!-- The more the information, the faster we can help resolve the issue -->
+
+## Additional information
+
+<!-- Add any other infor or context about the problem here. -->

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,24 @@
+---
+name: "Feature Request"
+about: Submit a proposal/request for a new GTSAM feature
+---
+
+## Feature
+
+<!-- A clear and concise description of the feature proposal -->
+
+## Motivation
+
+<!-- Please outline the motivation for the proposal. Is your feature request related to a problem? e.g., I'm always frustrated when [...]. If this is related to another GitHub issue, please link here too. -->
+
+## Pitch
+
+<!-- A clear and concise description of what you want to happen. -->
+
+## Alternatives
+
+<!-- A clear and concise description of any alternative solutions or features you've considered, if any. -->
+
+## Additional context
+
+<!-- Add any other context or screenshots about the feature request here. -->

.github/ISSUE_TEMPLATE/questions-help-support.md

@@ -0,0 +1,5 @@
+---
+name: "Questions/Help/Support"
+---
+
+Please post questions and support requests in the [GTSAM Google group](https://groups.google.com/forum/#!forum/gtsam-users) and not on Github.

.travis.sh

@@ -51,7 +51,7 @@ function build ()
       -DGTSAM_ALLOW_DEPRECATED_SINCE_V4=$GTSAM_ALLOW_DEPRECATED_SINCE_V4
 
   # Actual build:
-  make -j2
+  VERBOSE=1 make -j2
 
   finish
 }

.travis.yml

@@ -101,9 +101,13 @@ env:
 script:
   - bash .travis.sh -t
 
-# Exclude clang on Linux/clang in release until issue #57 is solved
 matrix:
   exclude:
+    # Exclude g++ debug on Linux as it consistently times out
+    - os: linux
+      compiler: gcc
+      env : CMAKE_BUILD_TYPE=Debug GTSAM_BUILD_UNSTABLE=OFF
+    # Exclude clang on Linux/clang in release until issue #57 is solved
     - os: linux
       compiler: clang
       env : CMAKE_BUILD_TYPE=Release

CMakeLists.txt

@@ -1,4 +1,3 @@
-
 project(GTSAM CXX C)
 cmake_minimum_required(VERSION 3.0)
 
@@ -134,11 +133,11 @@ if(MSVC)
 	# If we use Boost shared libs, disable auto linking.
 	# Some libraries, at least Boost Program Options, rely on this to export DLL symbols.
 	if(NOT Boost_USE_STATIC_LIBS)
-		list(APPEND GTSAM_COMPILE_DEFINITIONS_PUBLIC BOOST_ALL_NO_LIB BOOST_ALL_DYN_LINK)
+		list_append_cache(GTSAM_COMPILE_DEFINITIONS_PUBLIC BOOST_ALL_NO_LIB BOOST_ALL_DYN_LINK)
 	endif()
 	# Virtual memory range for PCH exceeded on VS2015
 	if(MSVC_VERSION LESS 1910) # older than VS2017
-	  list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE -Zm295)
+	  list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE -Zm295)
 	endif()
 endif()
 
@@ -147,7 +146,7 @@ endif()
 # See: https://bitbucket.org/gtborg/gtsam/issues/417/fail-to-build-on-msvc-2017
 #
 if(MSVC AND BUILD_SHARED_LIBS)
-	list(APPEND GTSAM_COMPILE_DEFINITIONS_PUBLIC EIGEN_NO_STATIC_ASSERT)
+	list_append_cache(GTSAM_COMPILE_DEFINITIONS_PUBLIC EIGEN_NO_STATIC_ASSERT)
 endif()
 
 # Store these in variables so they are automatically replicated in GTSAMConfig.cmake and such.
@@ -188,7 +187,7 @@ set(GTSAM_BOOST_LIBRARIES
 message(STATUS "GTSAM_BOOST_LIBRARIES: ${GTSAM_BOOST_LIBRARIES}")
 if (GTSAM_DISABLE_NEW_TIMERS)
     message("WARNING:  GTSAM timing instrumentation manually disabled")
-    list(APPEND GTSAM_COMPILE_DEFINITIONS_PUBLIC DGTSAM_DISABLE_NEW_TIMERS)
+    list_append_cache(GTSAM_COMPILE_DEFINITIONS_PUBLIC DGTSAM_DISABLE_NEW_TIMERS)
 else()
     if(Boost_TIMER_LIBRARY)
       list(APPEND GTSAM_BOOST_LIBRARIES
@@ -208,7 +207,7 @@ endif()
 
 if(NOT (${Boost_VERSION} LESS 105600))
 	message("Ignoring Boost restriction on optional lvalue assignment from rvalues")
-	list(APPEND GTSAM_COMPILE_DEFINITIONS_PUBLIC BOOST_OPTIONAL_ALLOW_BINDING_TO_RVALUES BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES)
+	list_append_cache(GTSAM_COMPILE_DEFINITIONS_PUBLIC BOOST_OPTIONAL_ALLOW_BINDING_TO_RVALUES BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES)
 endif()
 
 ###############################################################################
@@ -276,7 +275,7 @@ find_package(OpenMP)  # do this here to generate correct message if disabled
 if(GTSAM_WITH_EIGEN_MKL AND GTSAM_WITH_EIGEN_MKL_OPENMP AND GTSAM_USE_EIGEN_MKL)
     if(OPENMP_FOUND AND GTSAM_USE_EIGEN_MKL AND GTSAM_WITH_EIGEN_MKL_OPENMP)
         set(GTSAM_USE_EIGEN_MKL_OPENMP 1) # This will go into config.h
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+        list_append_cache(GTSAM_COMPILE_OPTIONS_PUBLIC ${OpenMP_CXX_FLAGS})
     endif()
 endif()
 
@@ -351,9 +350,9 @@ endif ()
 if (MSVC)
 	if (BUILD_SHARED_LIBS)
 		# mute eigen static assert to avoid errors in shared lib
-		list(APPEND GTSAM_COMPILE_DEFINITIONS_PUBLIC DEIGEN_NO_STATIC_ASSERT)
+		list_append_cache(GTSAM_COMPILE_DEFINITIONS_PUBLIC EIGEN_NO_STATIC_ASSERT)
 	endif()
-	list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE "/wd4244") # Disable loss of precision which is thrown all over our Eigen
+	list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE "/wd4244") # Disable loss of precision which is thrown all over our Eigen
 endif()
 
 ###############################################################################
@@ -395,28 +394,28 @@ elseif("${GTSAM_DEFAULT_ALLOCATOR}" STREQUAL "tcmalloc")
 endif()
 
 if(MSVC)
-	list(APPEND GTSAM_COMPILE_DEFINITIONS_PRIVATE _CRT_SECURE_NO_WARNINGS _SCL_SECURE_NO_WARNINGS)
+	list_append_cache(GTSAM_COMPILE_DEFINITIONS_PRIVATE _CRT_SECURE_NO_WARNINGS _SCL_SECURE_NO_WARNINGS)
-	list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE /wd4251 /wd4275 /wd4251 /wd4661 /wd4344 /wd4503) # Disable non-DLL-exported base class and other warnings
+	list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE /wd4251 /wd4275 /wd4251 /wd4661 /wd4344 /wd4503) # Disable non-DLL-exported base class and other warnings
-	list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE /bigobj) # Allow large object files for template-based code
+	list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE /bigobj) # Allow large object files for template-based code
 endif()
 
 # GCC 4.8+ complains about local typedefs which we use for shared_ptr etc.
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
-    list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE -Wno-unused-local-typedefs)
+    list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE -Wno-unused-local-typedefs)
   endif()
 endif()
 
 # As of XCode 7, clang also complains about this
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0)
-    list(APPEND GTSAM_COMPILE_OPTIONS_PRIVATE -Wno-unused-local-typedefs)
+    list_append_cache(GTSAM_COMPILE_OPTIONS_PRIVATE -Wno-unused-local-typedefs)
   endif()
 endif()
 
 if(GTSAM_ENABLE_CONSISTENCY_CHECKS)
   # This should be made PUBLIC if GTSAM_EXTRA_CONSISTENCY_CHECKS is someday used in a public .h
-  list(APPEND GTSAM_COMPILE_DEFINITIONS_PRIVATE GTSAM_EXTRA_CONSISTENCY_CHECKS)
+  list_append_cache(GTSAM_COMPILE_DEFINITIONS_PRIVATE GTSAM_EXTRA_CONSISTENCY_CHECKS)
 endif()
 
 ###############################################################################
@@ -514,6 +513,9 @@ message(STATUS "==============================================================="
 message(STATUS "================  Configuration Options  ======================")
 message(STATUS "  CMAKE_CXX_COMPILER_ID type     : ${CMAKE_CXX_COMPILER_ID}")
 message(STATUS "  CMAKE_CXX_COMPILER_VERSION     : ${CMAKE_CXX_COMPILER_VERSION}")
+message(STATUS "  CMake version                  : ${CMAKE_VERSION}")
+message(STATUS "  CMake generator                : ${CMAKE_GENERATOR}")
+message(STATUS "  CMake build tool               : ${CMAKE_BUILD_TOOL}")
 message(STATUS "Build flags                                               ")
 print_config_flag(${GTSAM_BUILD_TESTS}                 "Build Tests                    ")
 print_config_flag(${GTSAM_BUILD_EXAMPLES_ALWAYS}       "Build examples with 'make all' ")
@@ -527,13 +529,16 @@ if(GTSAM_UNSTABLE_AVAILABLE)
     print_config_flag(${GTSAM_BUILD_UNSTABLE}          "Build libgtsam_unstable        ")
 endif()
 string(TOUPPER "${CMAKE_BUILD_TYPE}" cmake_build_type_toupper)
-print_config_flag(${GTSAM_BUILD_WITH_MARCH_NATIVE}     "Build for native architecture  ")
 if(NOT MSVC AND NOT XCODE_VERSION)
+    print_config_flag(${GTSAM_BUILD_WITH_MARCH_NATIVE}     "Build for native architecture  ")
     message(STATUS "  Build type                     : ${CMAKE_BUILD_TYPE}")
-    message(STATUS "  C compilation flags            : ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${cmake_build_type_toupper}}")
     message(STATUS "  C++ compilation flags          : ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${cmake_build_type_toupper}}")
 endif()
+
+print_build_options_for_target(gtsam)
+
 message(STATUS "  Use System Eigen               : ${GTSAM_USE_SYSTEM_EIGEN} (Using version: ${GTSAM_EIGEN_VERSION})")
+
 if(GTSAM_USE_TBB)
 	message(STATUS "  Use Intel TBB                  : Yes")
 elseif(TBB_FOUND)

DEVELOP

@@ -1,19 +0,0 @@
-Information for developers
-
-Coding Conventions:
-
-* Classes are Uppercase, methods and functions lowerMixedCase
-* We use a modified K&R Style, with 2-space tabs, inserting spaces for tabs
-* Use meaningful variable names, e.g., measurement not msm
-
-
-Windows:
-
-On Windows it is necessary to explicitly export all functions from the library
-which should be externally accessible. To do this, include the macro 
-GTSAM_EXPORT in your class or function definition.
-
-For example:
-class GTSAM_EXPORT MyClass { ... };
-
-GTSAM_EXPORT myFunction();

DEVELOP.md

@@ -0,0 +1,19 @@
+# Information for Developers
+
+### Coding Conventions
+
+* Classes are Uppercase, methods and functions lowerMixedCase.
+* We use a modified K&R Style, with 2-space tabs, inserting spaces for tabs.
+* Use meaningful variable names, e.g. `measurement` not `msm`.
+
+
+### Windows
+
+On Windows it is necessary to explicitly export all functions from the library which should be externally accessible. To do this, include the macro `GTSAM_EXPORT` in your class or function definition.
+
+For example:
+```cpp
+class GTSAM_EXPORT MyClass { ... };
+
+GTSAM_EXPORT myFunction();
+```

USAGE.md

@@ -1,48 +1,42 @@
-USAGE - Georgia Tech Smoothing and Mapping library
+# GTSAM USAGE
-===================================
-What is this file?
 
-	This file explains how to make use of the library for common SLAM tasks, 
+This file explains how to make use of the library for common SLAM tasks, using a visual SLAM implementation as an example.
-	using a visual SLAM implementation as an example.
+
+## Getting Started
+
+### Install
 	
-	
+Follow the installation instructions in the README file to build and install gtsam, as well as running tests to ensure the library is working properly.
-Getting Started
----------------------------------------------------
-Install:
-	Follow the installation instructions in the README file to build and 
-	install gtsam, as well as running tests to ensure the library is working
-	properly.
 
-Compiling/Linking with gtsam:
+### Compiling/Linking with GTSAM
-  	The installation creates a binary "libgtsam" at the installation prefix,
-  	and an include folder "gtsam".  These are the only required includes, but 
-  	the library has also been designed to make use of XML serialization through
-  	the Boost.serialization library, which requires the the Boost.serialization
-  	headers and binaries to be linked.  
-  	
-  	If you use CMake for your project, you can use the CMake scripts in the 
-  	cmake folder for finding GTSAM, CppUnitLite, and Wrap.  
 
-Examples:
+The installation creates a binary `libgtsam` at the installation prefix, and an include folder `gtsam`.  These are the only required includes, but the library has also been designed to make use of XML serialization through the `Boost.serialization` library, which requires the the Boost.serialization headers and binaries to be linked.  
-	To see how the library works, examine the unit tests provided.  
+
+If you use CMake for your project, you can use the CMake scripts in the cmake folder for finding `GTSAM`, `CppUnitLite`, and `Wrap`.  
+
+### Examples
+
+To see how the library works, examine the unit tests provided.  
  
+## Overview
 
-Overview
+The GTSAM library has three primary components necessary for the construction of factor graph representation and optimization which users will need to adapt to their particular problem.  
----------------------------------------------------
+
-The GTSAM library has three primary components necessary for the construction
+* FactorGraph
-of factor graph representation and optimization which users will need to 
+
-adapt to their particular problem.  
+	A factor graph contains a set of variables to solve for (i.e., robot poses, landmark poses, etc.) and a set of constraints between these variables, which make up factors.
+
+* Values:
+
+	Values is a single object containing labeled values for all of the variables.  Currently, all variables are labeled with strings, but the type or organization of the variables can change.
+
+* Factors
 
-* FactorGraph:
-	A factor graph contains a set of variables to solve for (i.e., robot poses, landmark poses, etc.) and a set of constraints between these variables, which make up factors.  
-* Values: 
-	Values is a single object containing labeled values for all of the variables.  Currently, all variables are labeled with strings, but the type or organization of the variables can change
-* Factors:
 	A nonlinear factor expresses a constraint between variables, which in the SLAM example, is a measurement such as a visual reading on a landmark or odometry.
 
 The library is organized according to the following directory structure:
 
-    3rdparty      local copies of third party libraries - Eigen3 and CCOLAMD
+    3rdparty      local copies of third party libraries e.g. Eigen3 and CCOLAMD
     base          provides some base Math and data structures, as well as test-related utilities
     geometry      points, poses, tensors, etc
     inference     core graphical model inference such as factor graphs, junction trees, Bayes nets, Bayes trees 

bitbucket-pipelines.yml

@@ -1,15 +0,0 @@
-# Built from sample configuration for C++ – Make.
-# Check https://confluence.atlassian.com/x/5Q4SMw for more examples.
-# -----
-# Our custom docker image from Docker Hub as the build environment.
-image: dellaert/ubuntu-boost-tbb-eigen3:bionic
-
-pipelines:
-  default:
-    - step:
-        script: # Modify the commands below to build your repository.
-          - mkdir build
-          - cd build
-          - cmake -DGTSAM_USE_SYSTEM_EIGEN=OFF -DGTSAM_USE_EIGEN_MKL=OFF .. 
-          - make -j2
-          - make -j2 check

cmake/GtsamBuildTypes.cmake

@@ -1,7 +1,45 @@
 
+# function:  list_append_cache(var [new_values ...])
+# Like "list(APPEND ...)" but working for CACHE variables.
+# -----------------------------------------------------------
+function(list_append_cache var)
+  set(cur_value ${${var}})
+  list(APPEND cur_value ${ARGN})
+  get_property(MYVAR_DOCSTRING CACHE ${var} PROPERTY HELPSTRING)
+  set(${var} "${cur_value}" CACHE STRING "${MYVAR_DOCSTRING}" FORCE)
+endfunction()
+
+# function:  append_config_if_not_empty(TARGET_VARIABLE build_type)
+# Auxiliary function used to merge configuration-specific flags into the
+# global variables that will actually be send to cmake targets.
+# -----------------------------------------------------------
+function(append_config_if_not_empty TARGET_VARIABLE_ build_type)
+  string(TOUPPER "${build_type}" build_type_toupper)
+  set(flags_variable_name "${TARGET_VARIABLE_}_${build_type_toupper}")
+  set(flags_ ${${flags_variable_name}})
+  if (NOT "${flags_}" STREQUAL "")
+    if (${build_type_toupper} STREQUAL "COMMON")
+      # Special "COMMON" configuration type, just append without CMake expression:
+      list_append_cache(${TARGET_VARIABLE_} "${flags_}")
+    else()
+      # Regular configuration type:
+      list_append_cache(${TARGET_VARIABLE_} "$<$<CONFIG:${build_type}>:${flags_}>")
+    endif()
+  endif()
+endfunction()
+
+
 # Add install prefix to search path
 list(APPEND CMAKE_PREFIX_PATH "${CMAKE_INSTALL_PREFIX}")
 
+
+# Set up build types for MSVC and XCode
+set(GTSAM_CMAKE_CONFIGURATION_TYPES Debug Release Timing Profiling RelWithDebInfo MinSizeRel
+      CACHE STRING "Build types available to MSVC and XCode")
+mark_as_advanced(FORCE GTSAM_CMAKE_CONFIGURATION_TYPES)
+set(CMAKE_CONFIGURATION_TYPES ${GTSAM_CMAKE_CONFIGURATION_TYPES} CACHE STRING "Build configurations" FORCE)
+
+
 # Default to Release mode
 if(NOT CMAKE_BUILD_TYPE AND NOT MSVC AND NOT XCODE_VERSION)
     set(GTSAM_CMAKE_BUILD_TYPE "Release" CACHE STRING
@@ -13,39 +51,76 @@ endif()
 # Add option for using build type postfixes to allow installing multiple build modes
 option(GTSAM_BUILD_TYPE_POSTFIXES        "Enable/Disable appending the build type to the name of compiled libraries" ON)
 
-# Set custom compilation flags.
+# Define all cache variables, to be populated below depending on the OS/compiler:
-# NOTE: We set all the CACHE variables with a GTSAM prefix, and then set a normal local variable below
+set(GTSAM_COMPILE_OPTIONS_PRIVATE        "" CACHE STRING "(Do not edit) Private compiler flags for all build configurations." FORCE)
-# so that we don't "pollute" the global variable namespace in the cmake cache.
+set(GTSAM_COMPILE_OPTIONS_PUBLIC         "" CACHE STRING "(Do not edit) Public compiler flags (exported to user projects) for all build configurations."  FORCE)
-  # Set all CMAKE_BUILD_TYPE flags:
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE    "" CACHE STRING "(Do not edit) Private preprocessor macros for all build configurations." FORCE)
-  # (see https://cmake.org/Wiki/CMake_Useful_Variables#Compilers_and_Tools)
+set(GTSAM_COMPILE_DEFINITIONS_PUBLIC     "" CACHE STRING "(Do not edit) Public preprocessor macros for all build configurations." FORCE)
+mark_as_advanced(GTSAM_COMPILE_OPTIONS_PRIVATE)
+mark_as_advanced(GTSAM_COMPILE_OPTIONS_PUBLIC)
+mark_as_advanced(GTSAM_COMPILE_DEFINITIONS_PRIVATE)
+mark_as_advanced(GTSAM_COMPILE_DEFINITIONS_PUBLIC)
+
+foreach(build_type ${GTSAM_CMAKE_CONFIGURATION_TYPES})
+  string(TOUPPER "${build_type}" build_type_toupper)
+
+  # Define empty cache variables for "public". "private" are creaed below.
+  set(GTSAM_COMPILE_OPTIONS_PUBLIC_${build_type_toupper}      "" CACHE STRING "(User editable) Public compiler flags (exported to user projects) for `${build_type_toupper}` configuration.")
+  set(GTSAM_COMPILE_DEFINITIONS_PUBLIC_${build_type_toupper}  "" CACHE STRING "(User editable) Public preprocessor macros for `${build_type_toupper}` configuration.")
+endforeach()
+
+# Common preprocessor macros for each configuration:
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE_DEBUG           "_DEBUG;EIGEN_INITIALIZE_MATRICES_BY_NAN" CACHE STRING "(User editable) Private preprocessor macros for Debug configuration.")
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE_RELWITHDEBINFO  "NDEBUG" CACHE STRING "(User editable) Private preprocessor macros for RelWithDebInfo configuration.")
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE_RELEASE         "NDEBUG" CACHE STRING "(User editable) Private preprocessor macros for Release configuration.")
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE_PROFILING       "NDEBUG" CACHE STRING "(User editable) Private preprocessor macros for Profiling configuration.")
+set(GTSAM_COMPILE_DEFINITIONS_PRIVATE_TIMING          "NDEBUG;ENABLE_TIMING" CACHE STRING "(User editable) Private preprocessor macros for Timing configuration.")
 if(MSVC)
-    set(GTSAM_CMAKE_C_FLAGS                  "/W3 /GR /EHsc /MP /DWINDOWS_LEAN_AND_MEAN" CACHE STRING "Flags used by the compiler for all builds.")
+  # Common to all configurations:
-    set(GTSAM_CMAKE_CXX_FLAGS                "/W3 /GR /EHsc /MP /DWINDOWS_LEAN_AND_MEAN" CACHE STRING "Flags used by the compiler for all builds.")
+  list_append_cache(GTSAM_COMPILE_DEFINITIONS_PRIVATE WINDOWS_LEAN_AND_MEAN)
-    set(GTSAM_CMAKE_C_FLAGS_DEBUG            "/D_DEBUG /MDd /Zi /Ob0 /Od /RTC1 /DEIGEN_INITIALIZE_MATRICES_BY_NAN" CACHE STRING "Extra flags used by the compiler during debug builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_DEBUG          "/D_DEBUG /MDd /Zi /Ob0 /Od /RTC1 /DEIGEN_INITIALIZE_MATRICES_BY_NAN" CACHE STRING "Extra flags used by the compiler during debug builds.")
-    set(GTSAM_CMAKE_C_FLAGS_RELWITHDEBINFO   "/MD /O2 /DNDEBUG /Zi /d2Zi+" CACHE STRING "Extra flags used by the compiler during relwithdebinfo builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MD /O2 /DNDEBUG /Zi /d2Zi+" CACHE STRING "Extra flags used by the compiler during relwithdebinfo builds.")
-    set(GTSAM_CMAKE_C_FLAGS_RELEASE          "/MD /O2 /DNDEBUG" CACHE STRING "Extra flags used by the compiler during release builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_RELEASE        "/MD /O2 /DNDEBUG" CACHE STRING "Extra flags used by the compiler during release builds.")
-    set(GTSAM_CMAKE_C_FLAGS_PROFILING        "${GTSAM_CMAKE_C_FLAGS_RELEASE}   /Zi" CACHE STRING "Extra flags used by the compiler during profiling builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_PROFILING      "${GTSAM_CMAKE_CXX_FLAGS_RELEASE} /Zi" CACHE STRING "Extra flags used by the compiler during profiling builds.")
-    set(GTSAM_CMAKE_C_FLAGS_TIMING           "${GTSAM_CMAKE_C_FLAGS_RELEASE}   /DENABLE_TIMING" CACHE STRING "Extra flags used by the compiler during timing builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_TIMING         "${GTSAM_CMAKE_CXX_FLAGS_RELEASE} /DENABLE_TIMING" CACHE STRING "Extra flags used by the compiler during timing builds.")
-else()
-    set(GTSAM_CMAKE_C_FLAGS                  "-std=c11   -Wall" CACHE STRING "Flags used by the compiler for all builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS                "-std=c++11 -Wall" CACHE STRING "Flags used by the compiler for all builds.")
-    set(GTSAM_CMAKE_C_FLAGS_DEBUG            "-g -fno-inline -DEIGEN_INITIALIZE_MATRICES_BY_NAN" CACHE STRING "Extra flags used by the compiler during debug builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_DEBUG          "-g -fno-inline -DEIGEN_INITIALIZE_MATRICES_BY_NAN" CACHE STRING "Extra flags used by the compiler during debug builds.")
-    set(GTSAM_CMAKE_C_FLAGS_RELWITHDEBINFO   "-g -O3 -DNDEBUG" CACHE STRING "Extra flags used by the compiler during relwithdebinfo builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O3 -DNDEBUG" CACHE STRING "Extra flags used by the compiler during relwithdebinfo builds.")
-    set(GTSAM_CMAKE_C_FLAGS_RELEASE          "   -O3 -DNDEBUG" CACHE STRING "Extra flags used by the compiler during release builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_RELEASE        "   -O3 -DNDEBUG" CACHE STRING "Extra flags used by the compiler during release builds.")
-    set(GTSAM_CMAKE_C_FLAGS_PROFILING        "${GTSAM_CMAKE_C_FLAGS_RELEASE}" CACHE STRING "Extra flags used by the compiler during profiling builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_PROFILING      "${GTSAM_CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "Extra flags used by the compiler during profiling builds.")
-    set(GTSAM_CMAKE_C_FLAGS_TIMING           "${GTSAM_CMAKE_C_FLAGS_RELEASE} -DENABLE_TIMING" CACHE STRING "Extra flags used by the compiler during timing builds.")
-    set(GTSAM_CMAKE_CXX_FLAGS_TIMING         "${GTSAM_CMAKE_CXX_FLAGS_RELEASE} -DENABLE_TIMING" CACHE STRING "Extra flags used by the compiler during timing builds.")
 endif()
 
+# Other (non-preprocessor macros) compiler flags:
+if(MSVC)
+  # Common to all configurations, next for each configuration:
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_COMMON          /W3 /GR /EHsc /MP  CACHE STRING "(User editable) Private compiler flags for all configurations.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_DEBUG           /MDd /Zi /Ob0 /Od /RTC1  CACHE STRING "(User editable) Private compiler flags for Debug configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_RELWITHDEBINFO  /MD /O2 /D /Zi /d2Zi+  CACHE STRING "(User editable) Private compiler flags for RelWithDebInfo configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_RELEASE         /MD /O2  CACHE STRING "(User editable) Private compiler flags for Release configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_PROFILING       /MD /O2  /Zi  CACHE STRING "(User editable) Private compiler flags for Profiling configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_TIMING          /MD /O2  CACHE STRING "(User editable) Private compiler flags for Timing configuration.")
+else()
+  # Common to all configurations, next for each configuration:
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_COMMON          -Wall CACHE STRING "(User editable) Private compiler flags for all configurations.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_DEBUG           -g -fno-inline  CACHE STRING "(User editable) Private compiler flags for Debug configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_RELWITHDEBINFO  -g -O3  CACHE STRING "(User editable) Private compiler flags for RelWithDebInfo configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_RELEASE         -O3  CACHE STRING "(User editable) Private compiler flags for Release configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_PROFILING       -O3  CACHE STRING "(User editable) Private compiler flags for Profiling configuration.")
+  set(GTSAM_COMPILE_OPTIONS_PRIVATE_TIMING          -g -O3  CACHE STRING "(User editable) Private compiler flags for Timing configuration.")
+endif()
+
+# Enable C++11:
+if (NOT CMAKE_VERSION VERSION_LESS 3.8)
+    set(GTSAM_COMPILE_FEATURES_PUBLIC "cxx_std_11" CACHE STRING "CMake compile features property for all gtsam targets.")
+    # See: https://cmake.org/cmake/help/latest/prop_tgt/CXX_EXTENSIONS.html
+    # This is to enable -std=c++11 instead of -std=g++11
+    set(CMAKE_CXX_EXTENSIONS OFF)
+else()
+  # Old cmake versions:
+  if (NOT MSVC)
+    list_append_cache(GTSAM_COMPILE_OPTIONS_PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-std=c++11>)
+  endif()
+endif()
+
+# Merge all user-defined flags into the variables that are to be actually used by CMake:
+foreach(build_type "common" ${GTSAM_CMAKE_CONFIGURATION_TYPES})
+  append_config_if_not_empty(GTSAM_COMPILE_OPTIONS_PRIVATE ${build_type})
+  append_config_if_not_empty(GTSAM_COMPILE_OPTIONS_PUBLIC  ${build_type})
+  append_config_if_not_empty(GTSAM_COMPILE_DEFINITIONS_PRIVATE  ${build_type})
+  append_config_if_not_empty(GTSAM_COMPILE_DEFINITIONS_PUBLIC   ${build_type})
+endforeach()
+
+# Linker flags:
 set(GTSAM_CMAKE_SHARED_LINKER_FLAGS_TIMING  "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}" CACHE STRING "Linker flags during timing builds.")
 set(GTSAM_CMAKE_MODULE_LINKER_FLAGS_TIMING  "${CMAKE_MODULE_LINKER_FLAGS_RELEASE}" CACHE STRING "Linker flags during timing builds.")
 set(GTSAM_CMAKE_EXE_LINKER_FLAGS_TIMING     "${CMAKE_EXE_LINKER_FLAGS_RELEASE}" CACHE STRING "Linker flags during timing builds.")
@@ -54,26 +129,11 @@ set(GTSAM_CMAKE_SHARED_LINKER_FLAGS_PROFILING "${CMAKE_SHARED_LINKER_FLAGS_RELEA
 set(GTSAM_CMAKE_MODULE_LINKER_FLAGS_PROFILING "${CMAKE_MODULE_LINKER_FLAGS_RELEASE}" CACHE STRING "Linker flags during profiling builds.")
 set(GTSAM_CMAKE_EXE_LINKER_FLAGS_PROFILING    "${CMAKE_EXE_LINKER_FLAGS_RELEASE}" CACHE STRING "Linker flags during profiling builds.")
 
-mark_as_advanced(GTSAM_CMAKE_C_FLAGS_TIMING GTSAM_CMAKE_CXX_FLAGS_TIMING GTSAM_CMAKE_EXE_LINKER_FLAGS_TIMING 
+mark_as_advanced(GTSAM_CMAKE_EXE_LINKER_FLAGS_TIMING
                  GTSAM_CMAKE_SHARED_LINKER_FLAGS_TIMING GTSAM_CMAKE_MODULE_LINKER_FLAGS_TIMING
-                 GTSAM_CMAKE_C_FLAGS_PROFILING GTSAM_CMAKE_CXX_FLAGS_PROFILING GTSAM_CMAKE_EXE_LINKER_FLAGS_PROFILING 
+                 GTSAM_CMAKE_C_FLAGS_PROFILING GTSAM_ GTSAM_CMAKE_EXE_LINKER_FLAGS_PROFILING
                  GTSAM_CMAKE_SHARED_LINKER_FLAGS_PROFILING GTSAM_CMAKE_MODULE_LINKER_FLAGS_PROFILING)
 
-# Apply the gtsam specific build flags as normal variables. This makes it so that they only
-# apply to the gtsam part of the build if gtsam is built as a subproject
-set(CMAKE_C_FLAGS                  "${CMAKE_C_FLAGS} ${GTSAM_CMAKE_C_FLAGS}")
-set(CMAKE_CXX_FLAGS                "${CMAKE_CXX_FLAGS} ${GTSAM_CMAKE_CXX_FLAGS}")
-set(CMAKE_C_FLAGS_DEBUG            "${CMAKE_C_FLAGS_DEBUG} ${GTSAM_CMAKE_C_FLAGS_DEBUG}")
-set(CMAKE_CXX_FLAGS_DEBUG          "${CMAKE_CXX_FLAGS_DEBUG} ${GTSAM_CMAKE_CXX_FLAGS_DEBUG}")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO   "${CMAKE_C_FLAGS_RELWITHDEBINFO} ${GTSAM_CMAKE_C_FLAGS_RELWITHDEBINFO}")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${GTSAM_CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-set(CMAKE_C_FLAGS_RELEASE          "${CMAKE_C_FLAGS_RELEASE} ${GTSAM_CMAKE_C_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_RELEASE        "${CMAKE_CXX_FLAGS_RELEASE} ${GTSAM_CMAKE_CXX_FLAGS_RELEASE}")
-set(CMAKE_C_FLAGS_PROFILING        "${CMAKE_C_FLAGS_PROFILING} ${GTSAM_CMAKE_C_FLAGS_PROFILING}")
-set(CMAKE_CXX_FLAGS_PROFILING      "${CMAKE_CXX_FLAGS_PROFILING} ${GTSAM_CMAKE_CXX_FLAGS_PROFILING}")
-set(CMAKE_C_FLAGS_TIMING           "${CMAKE_C_FLAGS_TIMING} ${GTSAM_CMAKE_C_FLAGS_TIMING}")
-set(CMAKE_CXX_FLAGS_TIMING         "${CMAKE_CXX_FLAGS_TIMING} ${GTSAM_CMAKE_CXX_FLAGS_TIMING}")
-
 set(CMAKE_SHARED_LINKER_FLAGS_TIMING ${GTSAM_CMAKE_SHARED_LINKER_FLAGS_TIMING})
 set(CMAKE_MODULE_LINKER_FLAGS_TIMING ${GTSAM_CMAKE_MODULE_LINKER_FLAGS_TIMING})
 set(CMAKE_EXE_LINKER_FLAGS_TIMING ${GTSAM_CMAKE_EXE_LINKER_FLAGS_TIMING})
@@ -86,15 +146,16 @@ set(CMAKE_EXE_LINKER_FLAGS_PROFILING ${GTSAM_CMAKE_EXE_LINKER_FLAGS_PROFILING})
 if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
     # Apple Clang before 5.0 does not support -ftemplate-depth.
     if(NOT (APPLE AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS "5.0"))
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=1024")
+        list_append_cache(GTSAM_COMPILE_OPTIONS_PUBLIC "-ftemplate-depth=1024")
     endif()
 endif()
 
 if (NOT MSVC)
   option(GTSAM_BUILD_WITH_MARCH_NATIVE  "Enable/Disable building with all instructions supported by native architecture (binary may not be portable!)" ON)
   if(GTSAM_BUILD_WITH_MARCH_NATIVE)
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
+    # Add as public flag so all dependant projects also use it, as required
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+    # by Eigen to avid crashes due to SIMD vectorization:
+    list_append_cache(GTSAM_COMPILE_OPTIONS_PUBLIC "-march=native")
   endif()
 endif()
 
@@ -120,12 +181,6 @@ if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "")
   endif()
 endif()
 
-# Set up build types for MSVC and XCode
-set(GTSAM_CMAKE_CONFIGURATION_TYPES Debug Release Timing Profiling RelWithDebInfo MinSizeRel
-      CACHE STRING "Build types available to MSVC and XCode")
-mark_as_advanced(FORCE GTSAM_CMAKE_CONFIGURATION_TYPES)
-set(CMAKE_CONFIGURATION_TYPES ${GTSAM_CMAKE_CONFIGURATION_TYPES})
-
 # Check build types
 string(TOLOWER "${CMAKE_BUILD_TYPE}" cmake_build_type_tolower)
 if(    NOT cmake_build_type_tolower STREQUAL ""
@@ -161,3 +216,20 @@ function(gtsam_assign_all_source_folders)
   gtsam_assign_source_folders("${all_c_srcs};${all_cpp_srcs};${all_headers}")
 endfunction()
 
+# Applies the per-config build flags to the given target (e.g. gtsam, wrap_lib)
+function(gtsam_apply_build_flags target_name_)
+  # To enable C++11: the use of target_compile_features() is preferred since
+  # it will be not in conflict with a more modern C++ standard, if used in a
+  # client program.
+  if (NOT "${GTSAM_COMPILE_FEATURES_PUBLIC}" STREQUAL "")
+  	target_compile_features(${target_name_} PUBLIC ${GTSAM_COMPILE_FEATURES_PUBLIC})
+  endif()
+
+  target_compile_definitions(${target_name_} PRIVATE ${GTSAM_COMPILE_DEFINITIONS_PRIVATE})
+  target_compile_definitions(${target_name_} PUBLIC ${GTSAM_COMPILE_DEFINITIONS_PUBLIC})
+  if (NOT "${GTSAM_COMPILE_OPTIONS_PUBLIC}" STREQUAL "")
+    target_compile_options(${target_name_} PUBLIC ${GTSAM_COMPILE_OPTIONS_PUBLIC})
+  endif()
+  target_compile_options(${target_name_} PRIVATE ${GTSAM_COMPILE_OPTIONS_PRIVATE})
+
+endfunction(gtsam_apply_build_flags)

cmake/GtsamPrinting.cmake

@@ -7,4 +7,45 @@ function(print_config_flag flag msg)
     else ()
         message(STATUS "  ${msg}: Disabled")
     endif ()
-endfunction(print_config_flag)
+endfunction()
+
+# Based on https://github.com/jimbraun/XCDF/blob/master/cmake/CMakePadString.cmake
+function(string_pad RESULT_NAME DESIRED_LENGTH VALUE)
+    string(LENGTH "${VALUE}" VALUE_LENGTH)
+    math(EXPR REQUIRED_PADS "${DESIRED_LENGTH} - ${VALUE_LENGTH}")
+    set(PAD ${VALUE})
+    if(REQUIRED_PADS GREATER 0)
+        math(EXPR REQUIRED_MINUS_ONE "${REQUIRED_PADS} - 1")
+        foreach(FOO RANGE ${REQUIRED_MINUS_ONE})
+            set(PAD "${PAD} ")
+        endforeach()
+    endif()
+    set(${RESULT_NAME} "${PAD}" PARENT_SCOPE)
+endfunction()
+
+set(GTSAM_PRINT_SUMMARY_PADDING_LENGTH 50 CACHE STRING "Padding of cmake summary report lines after configuring.")
+mark_as_advanced(GTSAM_PRINT_SUMMARY_PADDING_LENGTH)
+
+# Print "  var: ${var}" padding with spaces as needed
+function(print_padded variable_name)
+  string_pad(padded_prop ${GTSAM_PRINT_SUMMARY_PADDING_LENGTH} " ${variable_name}")
+  message(STATUS "${padded_prop}: ${${variable_name}}")
+endfunction()
+
+
+# Prints all the relevant CMake build options for a given target:
+function(print_build_options_for_target target_name_)
+  print_padded(GTSAM_COMPILE_FEATURES_PUBLIC)
+  print_padded(GTSAM_COMPILE_OPTIONS_PRIVATE)
+  print_padded(GTSAM_COMPILE_OPTIONS_PUBLIC)
+  print_padded(GTSAM_COMPILE_DEFINITIONS_PRIVATE)
+  print_padded(GTSAM_COMPILE_DEFINITIONS_PUBLIC)
+
+  foreach(build_type ${GTSAM_CMAKE_CONFIGURATION_TYPES})
+    string(TOUPPER "${build_type}" build_type_toupper)
+    print_padded(GTSAM_COMPILE_OPTIONS_PRIVATE_${build_type_toupper})
+    print_padded(GTSAM_COMPILE_OPTIONS_PUBLIC_${build_type_toupper})
+    print_padded(GTSAM_COMPILE_DEFINITIONS_PRIVATE_${build_type_toupper})
+    print_padded(GTSAM_COMPILE_DEFINITIONS_PUBLIC_${build_type_toupper})
+  endforeach()
+endfunction()

cmake/GtsamTesting.cmake

@@ -169,6 +169,9 @@ macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 				add_executable(${script_name} ${script_src} ${script_headers})
 				target_link_libraries(${script_name} CppUnitLite ${linkLibraries})
 
+				# Apply user build flags from CMake cache variables:
+				gtsam_apply_build_flags(${script_name})
+
 				# Add target dependencies
 				add_test(NAME ${script_name} COMMAND ${script_name})
 				add_dependencies(check.${groupName} ${script_name})
@@ -191,7 +194,7 @@ macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 				endif()
 
 				# Add TOPSRCDIR
-				set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${PROJECT_SOURCE_DIR}\"")
+				set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${GTSAM_SOURCE_DIR}\"")
 
 				# Exclude from 'make all' and 'make install'
 				set_target_properties(${script_name} PROPERTIES EXCLUDE_FROM_ALL ON)
@@ -213,6 +216,9 @@ macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 			add_executable(${target_name} "${script_srcs}" ${script_headers})
 			target_link_libraries(${target_name} CppUnitLite ${linkLibraries})
 
+			# Apply user build flags from CMake cache variables:
+			gtsam_apply_build_flags(${target_name})
+
 			set_property(TARGET check_${groupName}_program PROPERTY FOLDER "Unit tests")
 
 			# Only have a main function in one script - use preprocessor
@@ -229,7 +235,7 @@ macro(gtsamAddTestsGlob_impl groupName globPatterns excludedFiles linkLibraries)
 			endif()
 
 			# Add TOPSRCDIR
-			set_property(SOURCE ${script_srcs} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${PROJECT_SOURCE_DIR}\"")
+			set_property(SOURCE ${script_srcs} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${GTSAM_SOURCE_DIR}\"")
 
 			# Exclude from 'make all' and 'make install'
 			set_target_properties(${target_name} PROPERTIES EXCLUDE_FROM_ALL ON)
@@ -280,6 +286,9 @@ macro(gtsamAddExesGlob_impl globPatterns excludedFiles linkLibraries groupName b
 		add_executable(${script_name} ${script_src} ${script_headers})
 		target_link_libraries(${script_name} ${linkLibraries})
 
+		# Apply user build flags from CMake cache variables:
+		gtsam_apply_build_flags(${script_name})
+
 		# Add target dependencies
 		add_dependencies(${groupName} ${script_name})
 		if(NOT MSVC AND NOT XCODE_VERSION)
@@ -287,7 +296,7 @@ macro(gtsamAddExesGlob_impl globPatterns excludedFiles linkLibraries groupName b
 		endif()
 
 		# Add TOPSRCDIR
-		set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${PROJECT_SOURCE_DIR}\"")
+		set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${GTSAM_SOURCE_DIR}\"")
 
 		# Exclude from all or not - note weird variable assignment because we're in a macro
 		set(buildWithAll_on ${buildWithAll})

cmake/README.md

@@ -1,5 +1,4 @@
-GTSAMCMakeTools
+# GTSAMCMakeTools
-===============
 
 This is the collection of GTSAM CMake tools that may be useful in external projects.  The way to use this collection is by first making a find_package call:
 
@@ -7,8 +6,7 @@ This is the collection of GTSAM CMake tools that may be useful in external proje
 
 which will add a directory containing the GTSAM CMake tools to the CMAKE_MODULE_PATH variable.  After that, you may include the files you would like to use.  These files and the functions they define are explained below.
 
-GtsamBuildTypes
+## GtsamBuildTypes
----------------
 
     include(GtsamBuildTypes)
 
@@ -17,8 +15,8 @@ Including this file immediately sets up the following build types and a drop-dow
 *   `Debug`
 *   `Release`
 *   `RelWithDebInfo`
-*   `Profiling`:  All optimizations enabled and minimal debug symbols
+*   `Profiling`: All optimizations enabled and minimal debug symbols
-*   `Timing`:  Defines the symbol GTSAM_ENABLE_TIMING for using GTSAM timing instrumentation
+*   `Timing`: Defines the symbol GTSAM_ENABLE_TIMING for using GTSAM timing instrumentation
 
 It also configures several minor details, as follows:
 
@@ -30,8 +28,7 @@ It defines the following functions:
 *   `gtsam_assign_source_folders( [files] )` Organizes files in the IDE into folders to reflect the actual directory structure of those files.  Folders will be determined relative to the current source folder when this function is called.
 *   `gtsam_assign_all_source_folders()` Calls `gtsam_assign_source_folders` on all cpp, c, and h files recursively in the current source folder.
 
-GtsamTesting
+## GtsamTesting
-------------
 
     include(GtsamTesting)
 
@@ -70,8 +67,7 @@ Defines two useful functions for creating CTest unit tests.  Also immediately cr
                        an empty string "" if nothing needs to be excluded.
         linkLibraries: The list of libraries to link to.
 
-GtsamMatlabWrap
+## GtsamMatlabWrap
----------------
 
     include(GtsamMatlabWrap)
     
@@ -97,8 +93,7 @@ Defines functions for generating MATLAB wrappers.  Also immediately creates seve
         extraMexFlags:    Any *additional* flags to pass to the compiler when building
                           the wrap code.  Normally, leave this empty.
 
-GtsamMakeConfigFile
+## GtsamMakeConfigFile
--------------------
 
     include(GtsamMakeConfigFile)
      

cmake/obsolete/GtsamTestingObsolete.cmake

@@ -1,22 +1,22 @@
 
-# Macro for adding categorized tests in a "tests" folder, with 
+# Macro for adding categorized tests in a "tests" folder, with
 # optional exclusion of tests and convenience library linking options
-#  
+#
 # By default, all tests are linked with CppUnitLite and boost
-# Arguments: 
+# Arguments:
 #   - subdir    The name of the category for this test
 #   - local_libs  A list of convenience libraries to use (if GTSAM_BUILD_CONVENIENCE_LIBRARIES is true)
 #   - full_libs   The main library to link against if not using convenience libraries
-#   - excluded_tests  A list of test files that should not be compiled - use for debugging 
+#   - excluded_tests  A list of test files that should not be compiled - use for debugging
 function(gtsam_add_subdir_tests subdir local_libs full_libs excluded_tests)
     # Subdirectory target for tests
     add_custom_target(check.${subdir} COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION> --output-on-failure)
     set(is_test TRUE)
 
 	# Put check target in Visual Studio solution folder
-	file(RELATIVE_PATH relative_path "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
+	file(RELATIVE_PATH relative_path "${GTSAM_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
 	set_property(TARGET check.${subdir} PROPERTY FOLDER "${relative_path}")
-    
+
 	# Link with CppUnitLite - pulled from gtsam installation
 	list(APPEND local_libs CppUnitLite)
 	list(APPEND full_libs CppUnitLite)
@@ -29,15 +29,15 @@ function(gtsam_add_subdir_tests subdir local_libs full_libs excluded_tests)
     ${is_test})                                         # Set all as tests
 endfunction()
 
-# Macro for adding categorized timing scripts in a "tests" folder, with 
+# Macro for adding categorized timing scripts in a "tests" folder, with
 # optional exclusion of tests and convenience library linking options
-#  
+#
 # By default, all tests are linked with boost
-# Arguments: 
+# Arguments:
 #   - subdir    The name of the category for this timing script
 #   - local_libs  A list of convenience libraries to use (if GTSAM_BUILD_CONVENIENCE_LIBRARIES is true)
 #   - full_libs   The main library to link against if not using convenience libraries
-#   - excluded_srcs  A list of timing files that should not be compiled - use for debugging 
+#   - excluded_srcs  A list of timing files that should not be compiled - use for debugging
 macro(gtsam_add_subdir_timing subdir local_libs full_libs excluded_srcs)
     # Subdirectory target for timing - does not actually execute the scripts
     add_custom_target(timing.${subdir})
@@ -60,11 +60,11 @@ endmacro()
 #   - excluded_srcs  A list of timing files that should not be compiled - use for debugging
 function(gtsam_add_executables pattern local_libs full_libs excluded_srcs)
     set(is_test FALSE)
-    
+
     if(NOT excluded_srcs)
         set(excluded_srcs "")
     endif()
-    
+
     # Build executables
     gtsam_add_grouped_scripts("" "${pattern}" "" "Executable" "${local_libs}" "${full_libs}" "${excluded_srcs}" ${is_test})
 endfunction()
@@ -73,7 +73,7 @@ endfunction()
 macro(gtsam_add_grouped_scripts group pattern target_prefix pretty_prefix_name local_libs full_libs excluded_srcs is_test)
 	# Print warning about using this obsolete function
 	message(AUTHOR_WARNING "Warning:  Please see GtsamTesting.cmake - obsolete cmake cmake macro for creating unit tests, examples, and scripts was called.  This will be removed in the future.  The new macros are much easier anyway!!")
-	
+
     # Get all script files
     set(script_files "")
     foreach(one_pattern ${pattern})
@@ -102,20 +102,20 @@ macro(gtsam_add_grouped_scripts group pattern target_prefix pretty_prefix_name l
 			list(APPEND script_srcs ${script_file})
 		endif()
 	endforeach()
-		
+
-    
+
     # Add targets and dependencies for each script
     if(NOT "${group}" STREQUAL "")
         message(STATUS "Adding ${pretty_prefix_name}s in ${group}")
     endif()
-	
+
 	# Create exe's for each script, unless we're in SINGLE_TEST_EXE mode
 	if(NOT is_test OR NOT GTSAM_SINGLE_TEST_EXE)
 		foreach(script_src ${script_srcs})
 			get_filename_component(script_base ${script_src} NAME_WE)
 			if (script_base) # Check for null filenames and headers
 				set( script_bin ${script_base} )
-				message(STATUS "Adding ${pretty_prefix_name} ${script_bin}") 
+				message(STATUS "Adding ${pretty_prefix_name} ${script_bin}")
 				add_executable(${script_bin} ${script_src} ${script_headers})
 				if(NOT "${target_prefix}" STREQUAL "")
 					if(NOT "${group}" STREQUAL "")
@@ -123,37 +123,37 @@ macro(gtsam_add_grouped_scripts group pattern target_prefix pretty_prefix_name l
 					endif()
 					add_dependencies(${target_prefix} ${script_bin})
 				endif()
-				
+
 				# Add TOPSRCDIR
-				set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${PROJECT_SOURCE_DIR}\"")
+				set_property(SOURCE ${script_src} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${GTSAM_SOURCE_DIR}\"")
 
 				# Disable building during make all/install
 				if (GTSAM_DISABLE_TESTS_ON_INSTALL)
 					set_target_properties(${script_bin} PROPERTIES EXCLUDE_FROM_ALL ON)
 				endif()
-				
+
 				if (is_test)
 					add_test(NAME ${script_base} COMMAND ${script_bin})
 				endif()
-				
+
 				# Linking and dependendencies
 				if (GTSAM_BUILD_CONVENIENCE_LIBRARIES)
 					target_link_libraries(${script_bin} ${local_libs} ${GTSAM_BOOST_LIBRARIES})
 				else()
 					target_link_libraries(${script_bin} ${full_libs} ${GTSAM_BOOST_LIBRARIES})
 				endif()
-				
+
 				# Add .run target
 				if(NOT MSVC AND NOT XCODE_VERSION)
 				  add_custom_target(${script_bin}.run ${EXECUTABLE_OUTPUT_PATH}${script_bin} ${ARGN})
 				endif()
-				
+
 				# Set up Visual Studio folders
-				file(RELATIVE_PATH relative_path "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
+				file(RELATIVE_PATH relative_path "${GTSAM_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
 				set_property(TARGET ${script_bin} PROPERTY FOLDER "${relative_path}")
 			endif()
 		endforeach(script_src)
-		
+
 		if(MSVC)
 			source_group("" FILES ${script_srcs} ${script_headers})
 		endif()
@@ -166,28 +166,28 @@ macro(gtsam_add_grouped_scripts group pattern target_prefix pretty_prefix_name l
 		else()
 			target_link_libraries(${script_bin} ${Boost_LIBRARIES} ${full_libs})
 		endif()
-		
+
 		# Only have a main function in one script
 		set(rest_script_srcs ${script_srcs})
 		list(REMOVE_AT rest_script_srcs 0)
 		set_property(SOURCE ${rest_script_srcs} APPEND PROPERTY COMPILE_DEFINITIONS "main=static no_main")
-			
+
 		# Add TOPSRCDIR
-		set_property(SOURCE ${script_srcs} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${PROJECT_SOURCE_DIR}\"")
+		set_property(SOURCE ${script_srcs} APPEND PROPERTY COMPILE_DEFINITIONS "TOPSRCDIR=\"${GTSAM_SOURCE_DIR}\"")
-			
+
 		# Add test
 		add_dependencies(${target_prefix}.${group} ${script_bin})
 		add_dependencies(${target_prefix} ${script_bin})
 		add_test(NAME ${target_prefix}.${group} COMMAND ${script_bin})
-		
+
 		# Disable building during make all/install
 		if (GTSAM_DISABLE_TESTS_ON_INSTALL)
 			set_target_properties(${script_bin} PROPERTIES EXCLUDE_FROM_ALL ON)
 		endif()
-		
+
 		# Set up Visual Studio folders
 		if(MSVC)
-		    file(RELATIVE_PATH relative_path "${PROJECT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
+		    file(RELATIVE_PATH relative_path "${GTSAM_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}")
 			set_property(TARGET ${script_bin} PROPERTY FOLDER "${relative_path}")
 			source_group("" FILES ${script_srcs} ${script_headers})
 		endif()

cython/README.md

@@ -1,7 +1,7 @@
 This is the Cython/Python wrapper around the GTSAM C++ library.
 
-INSTALL
+# INSTALL
-=======
+
 - if you want to build the gtsam python library for a specific python version (eg 2.7), use the `-DGTSAM_PYTHON_VERSION=2.7` option when running `cmake` otherwise the default interpreter will be used.
     - If the interpreter is inside an environment (such as an anaconda environment or virtualenv environment) then the environment should be active while building gtsam.
 - This wrapper needs Cython(>=0.25.2), backports_abc>=0.5, and numpy. These can be installed as follows:
@@ -27,8 +27,8 @@ export PYTHONPATH=$PYTHONPATH:<GTSAM_CYTHON_INSTALL_PATH>
     - if you run `setup.py` from the build directory rather than the installation directory, the script will warn you with the message: `setup.py is being run from an unexpected location`.
       Before `make install` is run, not all the components of the package have been copied across, so running `setup.py` from the build directory would result in an incomplete package.
 
-UNIT TESTS
+# UNIT TESTS
-==========
+
 The Cython toolbox also has a small set of unit tests located in the
 test directory. To run them:
 
@@ -37,8 +37,8 @@ test directory. To run them:
  python -m unittest discover
 ```
 
-WRITING YOUR OWN SCRIPTS
+# WRITING YOUR OWN SCRIPTS
-========================
+
 See the tests for examples.
 
 ## Some important notes:
@@ -66,8 +66,8 @@ Examples:
       noiseGaussian = dynamic_cast_noiseModel_Gaussian_noiseModel_Base(noiseBase)
 ```
 
-WRAPPING YOUR OWN PROJECT THAT USES GTSAM
+# WRAPPING YOUR OWN PROJECT THAT USES GTSAM
-=========================================
+
 - Set PYTHONPATH to include ${GTSAM_CYTHON_INSTALL_PATH}
   + so that it can find gtsam Cython header: gtsam/gtsam.pxd
 
@@ -99,63 +99,55 @@ KNOWN ISSUES
     - support these constructors by default and declare "delete" for special classes?
 
 
-TODO
+# TODO
-=====
+
-☐ allow duplication of parent' functions in child classes. Not allowed for now due to conflicts in Cython.
+- [ ] allow duplication of parent' functions in child classes. Not allowed for now due to conflicts in Cython.
-☐ a common header for boost shared_ptr? (Or wait until everything is switched to std::shared_ptr in gtsam?)
+- [ ] a common header for boost shared_ptr? (Or wait until everything is switched to std::shared_ptr in gtsam?)
-☐ inner namespaces ==> inner packages?
+- [ ] inner namespaces ==> inner packages?
-☐ Wrap fixed-size Matrices/Vectors?
+- [ ] Wrap fixed-size Matrices/Vectors?
 
 
-Completed/Cancelled:
+# Completed/Cancelled:
-=====
+
-✔ Fix Python tests: don't use " import <package> * ": Bad style!!! @done (18-03-17 19:50)
+- [x] Fix Python tests: don't use " import <package> * ": Bad style!!! (18-03-17 19:50)
-✔ Unit tests for cython wrappers @done (18-03-17 18:45) -- simply compare generated files
+- [x] Unit tests for cython wrappers @done (18-03-17 18:45) -- simply compare generated files
-✔ Wrap unstable @done (18-03-17 15:30)
+- [x] Wrap unstable @done (18-03-17 15:30)
-✔ Unify cython/gtsam.h and the original gtsam.h @done (18-03-17 15:30)
+- [x] Unify cython/gtsam.h and the original gtsam.h @done (18-03-17 15:30)
-  ✔ 18-03-17: manage to unify the two versions by removing std container stubs from the matlab version,and keeping KeyList/KeyVector/KeySet as in the matlab version. Probably Cython 0.25 fixes the casting problem.
+- [x] 18-03-17: manage to unify the two versions by removing std container stubs from the matlab version,and keeping KeyList/KeyVector/KeySet as in the matlab version. Probably Cython 0.25 fixes the casting problem.
-  ✔ 06-03-17: manage to remove the requirements for default and copy constructors
+- [x] 06-03-17: manage to remove the requirements for default and copy constructors
-  ✘ 25-11-16:
+- [ ] 25-11-16: Try to unify but failed. Main reasons are: Key/size_t, std containers, KeyVector/KeyList/KeySet. Matlab doesn't need to know about Key, but I can't make Cython to ignore Key as it couldn't cast KeyVector, i.e. FastVector<Key>, to FastVector<size_t>.
-    Try to unify but failed. Main reasons are: Key/size_t, std containers, KeyVector/KeyList/KeySet.
+- [ ] Marginal and JointMarginal: revert changes @failed (17-03-17 11:00) -- Cython does need a default constructor! It produces cpp code like this: ```gtsam::JointMarginal __pyx_t_1;```  Users don't have to wrap this constructor, however.
-    Matlab doesn't need to know about Key, but I can't make Cython to ignore Key as it couldn't cast KeyVector, i.e. FastVector<Key>, to FastVector<size_t>.
+- [x] Convert input numpy Matrix/Vector to float dtype and storage order 'F' automatically, cannot crash! @done (15-03-17 13:00)
-✘ Marginal and JointMarginal: revert changes @failed (17-03-17 11:00) -- Cython does need a default constructor! It produces cpp code like this: ```gtsam::JointMarginal __pyx_t_1;```  Users don't have to wrap this constructor, however.
+- [x] Remove requirements.txt - Frank: don't bother with only 2 packages and a special case for eigency! @done (08-03-17 10:30)
-✔ Convert input numpy Matrix/Vector to float dtype and storage order 'F' automatically, cannot crash! @done (15-03-17 13:00)
+- [x] CMake install script @done (25-11-16 02:30)
-✔ Remove requirements.txt - Frank: don't bother with only 2 packages and a special case for eigency! @done (08-03-17 10:30)
+- [ ] [REFACTOR] better name for uninstantiateClass: very vague!! @cancelled (25-11-16 02:30) -- lazy
-✔ CMake install script @done (25-11-16 02:30)
+- [ ] forward declaration? @cancelled (23-11-16 13:00) - nothing to do, seem to work?
-✘ [REFACTOR] better name for uninstantiateClass: very vague!! @cancelled (25-11-16 02:30) -- lazy
+- [x] wrap VariableIndex: why is it in inference? If need to, shouldn't have constructors to specific FactorGraphs @done (23-11-16 13:00)
-✘ forward declaration? @cancelled (23-11-16 13:00) - nothing to do, seem to work?
+- [x] Global functions @done (22-11-16 21:00)
-✔ wrap VariableIndex: why is it in inference? If need to, shouldn't have constructors to specific FactorGraphs @done (23-11-16 13:00)
+- [x] [REFACTOR] typesEqual --> isSameSignature @done (22-11-16 21:00)
-✔ Global functions @done (22-11-16 21:00)
+- [x] Proper overloads (constructors, static methods, methods) @done (20-11-16 21:00)
-✔ [REFACTOR] typesEqual --> isSameSignature @done (22-11-16 21:00)
+- [x] Allow overloading methods. The current solution is annoying!!! @done (20-11-16 21:00)
-✔ Proper overloads (constructors, static methods, methods) @done (20-11-16 21:00)
+- [x] Casting from parent and grandparents @done (16-11-16 17:00)
-✔ Allow overloading methods. The current solution is annoying!!! @done (20-11-16 21:00)
+- [x] Allow overloading constructors. The current solution is annoying!!! @done (16-11-16 17:00)
-✔ Casting from parent and grandparents @done (16-11-16 17:00)
+- [x] Support "print obj" @done (16-11-16 17:00)
-✔ Allow overloading constructors. The current solution is annoying!!! @done (16-11-16 17:00)
+- [x] methods for FastVector: at, [], ...  @done (16-11-16 17:00)
-✔ Support "print obj" @done (16-11-16 17:00)
+- [x] Cython: Key and size_t: traits<size_t> doesn't exist @done (16-09-12 18:34)
-✔ methods for FastVector: at, [], ...  @done (16-11-16 17:00)
+- [x] KeyVector, KeyList, KeySet... @done (16-09-13 17:19)
-✔ Cython: Key and size_t: traits<size_t> doesn't exist @done (16-09-12 18:34)
+- [x] [Nice to have] parse typedef @done (16-09-13 17:19)
-✔ KeyVector, KeyList, KeySet... @done (16-09-13 17:19)
+- [x] ctypedef at correct places @done (16-09-12 18:34)
-✔ [Nice to have] parse typedef @done (16-09-13 17:19)
+- [x] expand template variable type in constructor/static methods? @done (16-09-12 18:34)
-✔ ctypedef at correct places @done (16-09-12 18:34)
+- [x] NonlinearOptimizer: copy constructor deleted!!! @done (16-09-13 17:20)
-✔ expand template variable type in constructor/static methods? @done (16-09-12 18:34)
+- [x] Value: no default constructor @done (16-09-13 17:20)
-✔ NonlinearOptimizer: copy constructor deleted!!! @done (16-09-13 17:20)
+- [x] ctypedef PriorFactor[Vector] PriorFactorVector @done (16-09-19 12:25)
-✔ Value: no default constructor @done (16-09-13 17:20)
+- [x] Delete duplicate methods in derived class @done (16-09-12 13:38)
-✔ ctypedef PriorFactor[Vector] PriorFactorVector @done (16-09-19 12:25)
+- [x] Fix return properly @done (16-09-11 17:14)
-✔ Delete duplicate methods in derived class @done (16-09-12 13:38)
+- [x] handle pair @done (16-09-11 17:14)
-✔ Fix return properly @done (16-09-11 17:14)
+- [x] Eigency: ambiguous call: A(const T&) A(const Vector& v) and Eigency A(Map[Vector]& v) @done (16-09-11 07:59)
- ✔ handle pair @done (16-09-11 17:14)
+- [x] Eigency: Constructor: ambiguous construct from Vector/Matrix @done (16-09-11 07:59)
-✔ Eigency: ambiguous call: A(const T&) A(const Vector& v) and Eigency A(Map[Vector]& v) @done (16-09-11 07:59)
+- [x] Eigency: Fix method template of Vector/Matrix: template argument is [Vector] while arugment is Map[Vector] @done (16-09-11 08:22)
-✔ Eigency: Constructor: ambiguous construct from Vector/Matrix @done (16-09-11 07:59)
+- [x] Robust noise: copy assignment operator is deleted because of shared_ptr of the abstract Base class @done (16-09-10 09:05)
-✔ Eigency: Fix method template of Vector/Matrix: template argument is [Vector] while arugment is Map[Vector] @done (16-09-11 08:22)
+- [ ] Cython: Constructor: generate default constructor? (hack: if it's serializable?) @cancelled (16-09-13 17:20)
-✔ Robust noise: copy assignment operator is deleted because of shared_ptr of the abstract Base class @done (16-09-10 09:05)
+- [ ] Eigency: Map[] to Block @created(16-09-10 07:59) @cancelled (16-09-11 08:28)
-✘ Cython: Constructor: generate default constructor? (hack: if it's serializable?) @cancelled (16-09-13 17:20)
-✘ Eigency: Map[] to Block @created(16-09-10 07:59) @cancelled (16-09-11 08:28)
 
 - inference before symbolic/linear
 - what's the purpose of "virtual" ??
-
-Installation:
-  ☐ Prerequisite:
-    - Users create venv and pip install requirements before compiling
-    - Wrap cython script in gtsam/cython folder
-  ☐ Install built module into venv?

gtsam.h

@@ -1870,7 +1870,6 @@ class NonlinearFactorGraph {
 
   // FactorGraph
   void print(string s) const;
-  void printErrors(const gtsam::Values& values);
   bool equals(const gtsam::NonlinearFactorGraph& fg, double tol) const;
   size_t size() const;
   bool empty() const;
@@ -1887,6 +1886,7 @@ class NonlinearFactorGraph {
   gtsam::KeyVector keyVector() const;
 
   // NonlinearFactorGraph
+  void printErrors(const gtsam::Values& values) const;
   double error(const gtsam::Values& values) const;
   double probPrime(const gtsam::Values& values) const;
   gtsam::Ordering orderingCOLAMD() const;

gtsam/CMakeLists.txt

@@ -1,3 +1,5 @@
+project(gtsam LANGUAGES CXX)
+
 # We split the library in to separate subfolders, each containing
 # tests, timing, and an optional convenience library.
 # The following variable is the master list of subdirs to add
@@ -82,9 +84,9 @@ ENDIF(MSVC)
 # Generate and install config and dllexport files
 configure_file(config.h.in config.h)
 set(library_name GTSAM) # For substitution in dllexport.h.in
-configure_file("${PROJECT_SOURCE_DIR}/cmake/dllexport.h.in" "dllexport.h")
+configure_file("${GTSAM_SOURCE_DIR}/cmake/dllexport.h.in" "dllexport.h")
-list(APPEND gtsam_srcs "${PROJECT_BINARY_DIR}/gtsam/config.h" "${PROJECT_BINARY_DIR}/gtsam/dllexport.h")
+list(APPEND gtsam_srcs "${PROJECT_BINARY_DIR}/config.h" "${PROJECT_BINARY_DIR}/dllexport.h")
-install(FILES "${PROJECT_BINARY_DIR}/gtsam/config.h" "${PROJECT_BINARY_DIR}/gtsam/dllexport.h" DESTINATION include/gtsam)
+install(FILES "${PROJECT_BINARY_DIR}/config.h" "${PROJECT_BINARY_DIR}/dllexport.h" DESTINATION include/gtsam)
 
 if(GTSAM_SUPPORT_NESTED_DISSECTION)
     list(APPEND GTSAM_ADDITIONAL_LIBRARIES metis)
@@ -101,17 +103,16 @@ message(STATUS "Building GTSAM - shared: ${BUILD_SHARED_LIBS}")
 
 # BUILD_SHARED_LIBS automatically defines static/shared libs:
 add_library(gtsam ${gtsam_srcs})
+
 # Boost:
 target_link_libraries(gtsam PUBLIC ${GTSAM_BOOST_LIBRARIES})
 target_include_directories(gtsam PUBLIC ${Boost_INCLUDE_DIR})
 # Other deps:
 target_link_libraries(gtsam PUBLIC ${GTSAM_ADDITIONAL_LIBRARIES})
-target_compile_definitions(gtsam PRIVATE ${GTSAM_COMPILE_DEFINITIONS_PRIVATE})
+
-target_compile_definitions(gtsam PUBLIC ${GTSAM_COMPILE_DEFINITIONS_PUBLIC})
+# Apply build flags:
-if (NOT "${GTSAM_COMPILE_OPTIONS_PUBLIC}" STREQUAL "")
+gtsam_apply_build_flags(gtsam)
-  target_compile_options(gtsam PUBLIC ${GTSAM_COMPILE_OPTIONS_PUBLIC})
+
-endif()
-target_compile_options(gtsam PRIVATE ${GTSAM_COMPILE_OPTIONS_PRIVATE})
 set_target_properties(gtsam PROPERTIES
     OUTPUT_NAME         gtsam
     CLEAN_DIRECT_OUTPUT 1
@@ -171,7 +172,7 @@ if(WIN32) # Add 'lib' prefix to static library to avoid filename collision with
 		set_target_properties(gtsam PROPERTIES
 			PREFIX ""
 			DEFINE_SYMBOL GTSAM_EXPORTS
-			RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/bin")
+    RUNTIME_OUTPUT_DIRECTORY "${GTSAM_BINARY_DIR}/bin")
 	endif()
 endif()
 

gtsam/base/cholesky.cpp

@@ -111,7 +111,7 @@ bool choleskyPartial(Matrix& ABC, size_t nFrontal, size_t topleft) {
     return true;
 
   assert(ABC.cols() == ABC.rows());
-  assert(ABC.rows() >= topleft);
+  assert(size_t(ABC.rows()) >= topleft);
   const size_t n = static_cast<size_t>(ABC.rows() - topleft);
   assert(nFrontal <= size_t(n));
 

gtsam/config.h.in

@@ -25,7 +25,7 @@
 #define GTSAM_VERSION_STRING "@GTSAM_VERSION_STRING@"
 
 // Paths to example datasets distributed with GTSAM
-#define GTSAM_SOURCE_TREE_DATASET_DIR "@PROJECT_SOURCE_DIR@/examples/Data"
+#define GTSAM_SOURCE_TREE_DATASET_DIR "@GTSAM_SOURCE_DIR@/examples/Data"
 #define GTSAM_INSTALLED_DATASET_DIR "@GTSAM_TOOLBOX_INSTALL_PATH@/gtsam_examples/Data"
 
 // Whether GTSAM is compiled to use quaternions for Rot3 (otherwise uses rotation matrices)

gtsam/inference/Key.cpp

@@ -56,7 +56,7 @@ string _multirobotKeyFormatter(Key key) {
 
 /* ************************************************************************* */
 template<class CONTAINER>
-static void Print(const CONTAINER& keys, const string& s,
+void Print(const CONTAINER& keys, const string& s,
     const KeyFormatter& keyFormatter) {
   cout << s << " ";
   if (keys.empty())
@@ -83,6 +83,44 @@ void PrintKeySet(const KeySet& keys, const string& s,
     const KeyFormatter& keyFormatter) {
   Print(keys, s, keyFormatter);
 }
+
+/* ************************************************************************* */
+// Access to custom stream property.
+void *&key_formatter::property(ios_base &s) {
+  static int kUniqueIndex = ios_base::xalloc();
+  return s.pword(kUniqueIndex);
+}
+
+/* ************************************************************************* */
+// Store pointer to formatter in property.
+void key_formatter::set_property(ios_base &s, const KeyFormatter &f) {
+  property(s) = (void *)(&f);
+}
+
+/* ************************************************************************* */
+// Get pointer to formatter from property.
+KeyFormatter *key_formatter::get_property(ios_base &s) {
+  return (KeyFormatter *)(property(s));
+}
+
+/* ************************************************************************* */
+// Stream operator that will take a key_formatter and set the stream property.
+ostream &operator<<(ostream &os, const key_formatter &m) {
+  key_formatter::set_property(os, m.formatter_);
+  return os;
+}
+
+/* ************************************************************************* */
+// Stream operator that takes a StreamedKey and properly formats it
+ostream &operator<<(ostream &os, const StreamedKey &streamedKey) {
+  const KeyFormatter *formatter = key_formatter::get_property(os);
+  if (formatter == nullptr) {
+    formatter = &DefaultKeyFormatter;
+  }
+  os << (*formatter)(streamedKey.key_);
+  return (os);
+}
+
 /* ************************************************************************* */
 
 } // \namespace gtsam

gtsam/inference/Key.h

@@ -27,6 +27,8 @@
 
 #include <boost/function.hpp>
 
+#include <iosfwd>
+
 namespace gtsam {
 
 /// Typedef for a function to format a key, i.e. to convert it to a string
@@ -52,6 +54,34 @@ GTSAM_EXPORT std::string _multirobotKeyFormatter(gtsam::Key key);
 static const gtsam::KeyFormatter MultiRobotKeyFormatter =
     &_multirobotKeyFormatter;
 
+/// To use the key_formatter on Keys, they must be wrapped in a StreamedKey.
+struct StreamedKey {
+  const Key &key_;
+  explicit StreamedKey(const Key &key) : key_(key) {}
+  friend std::ostream &operator<<(std::ostream &, const StreamedKey &);
+};
+
+/**
+ * Output stream manipulator that will format gtsam::Keys according to the given
+ * KeyFormatter, as long as Key values are wrapped in a gtsam::StreamedKey.
+ * LabeledSymbol and Symbol values do not have to be wrapped.
+ * usage:
+ *   Key key = LabeledSymbol('x', 'A', 5); // cast to key type
+ *   cout << key_formatter(MultiRobotKeyFormatter) << StreamedKey(key);
+ */
+class key_formatter {
+ public:
+  explicit key_formatter(KeyFormatter v) : formatter_(v) {}
+  friend std::ostream &operator<<(std::ostream &, const key_formatter &);
+  friend std::ostream &operator<<(std::ostream &, const StreamedKey &);
+
+ private:
+  KeyFormatter formatter_;
+  static void *&property(std::ios_base &s);
+  static void set_property(std::ios_base &s, const KeyFormatter &f);
+  static KeyFormatter *get_property(std::ios_base &s);
+};
+
 /// Define collection type once and for all - also used in wrappers
 typedef FastVector<Key> KeyVector;
 

gtsam/inference/LabeledSymbol.cpp

@@ -121,6 +121,13 @@ boost::function<bool(gtsam::Key)> LabeledSymbol::TypeLabelTest(unsigned char c,
   return boost::bind(&LabeledSymbol::chr,   boost::bind(make, _1)) == c &&
       boost::bind(&LabeledSymbol::label, boost::bind(make, _1)) == label;
 }
+
+/* ************************************************************************* */
+std::ostream &operator<<(std::ostream &os, const LabeledSymbol &symbol) {
+  os << StreamedKey(symbol);
+  return os;
+}
+
 /* ************************************************************************* */
 
 } // \namespace gtsam

gtsam/inference/LabeledSymbol.h

@@ -100,10 +100,15 @@ public:
   LabeledSymbol upper() const { return LabeledSymbol(c_, toupper(label_), j_); }
   LabeledSymbol lower() const { return LabeledSymbol(c_, tolower(label_), j_); }
 
-  // Create a new symbol with a different value
+  // Create a new symbol with a different character.
   LabeledSymbol newChr(unsigned char c) const { return LabeledSymbol(c, label_, j_); }
+
+  // Create a new symbol with a different label.
   LabeledSymbol newLabel(unsigned char label) const { return LabeledSymbol(c_, label, j_); }
 
+  /// Output stream operator that can be used with key_formatter (see Key.h).
+  friend std::ostream &operator<<(std::ostream &, const LabeledSymbol &);
+
 private:
 
   /** Serialization function */

gtsam/inference/Symbol.cpp

@@ -66,5 +66,10 @@ boost::function<bool(Key)> Symbol::ChrTest(unsigned char c) {
   return bind(&Symbol::chr, bind(make, _1)) == c;
 }
 
+std::ostream &operator<<(std::ostream &os, const Symbol &symbol) {
+  os << StreamedKey(symbol);
+  return os;
+}
+
 } // namespace gtsam
 

gtsam/inference/Symbol.h

@@ -112,6 +112,9 @@ public:
    */
   static boost::function<bool(Key)> ChrTest(unsigned char c);
 
+  /// Output stream operator that can be used with key_formatter (see Key.h).
+  friend std::ostream &operator<<(std::ostream &, const Symbol &);
+
 private:
 
   /** Serialization function */

gtsam/inference/tests/testKey.cpp

@@ -22,6 +22,9 @@
 #include <CppUnitLite/TestHarness.h>
 
 #include <boost/assign/std/list.hpp> // for operator +=
+
+#include <sstream>
+
 using namespace boost::assign;
 using namespace std;
 using namespace gtsam;
@@ -41,17 +44,15 @@ TEST(Key, KeySymbolConversion) {
 template<int KeySize>
 Key KeyTestValue();
 
-template<>
+template <>
-Key KeyTestValue<8>()
+Key KeyTestValue<8>() {
-{
   return 0x6100000000000005;
-};
+}
 
-template<>
+template <>
-Key KeyTestValue<4>()
+Key KeyTestValue<4>() {
-{
   return 0x61000005;
-};
+}
 
 /* ************************************************************************* */
 TEST(Key, KeySymbolEncoding) {
@@ -68,12 +69,41 @@ TEST(Key, KeySymbolEncoding) {
 
 /* ************************************************************************* */
 TEST(Key, ChrTest) {
-  Key key = Symbol('c',3);
+  Symbol key('c', 3);
   EXPECT(Symbol::ChrTest('c')(key));
   EXPECT(!Symbol::ChrTest('d')(key));
 }
 
 /* ************************************************************************* */
-int main() { TestResult tr; return TestRegistry::runAllTests(tr); }
+// A custom (nonsensical) formatter.
+string myFormatter(Key key) {
+  return "special";
+}
+
+TEST(Key, Formatting) {
+  Symbol key('c', 3);
+  EXPECT("c3" == DefaultKeyFormatter(key));
+
+  // Try streaming keys, should be default-formatted.
+  stringstream ss;
+  ss << StreamedKey(key);
+  EXPECT("c3" == ss.str());
+
+  // use key_formatter with a function pointer
+  stringstream ss2;
+  ss2 << key_formatter(myFormatter) << StreamedKey(key);
+  EXPECT("special" == ss2.str());
+
+  // use key_formatter with a function object.
+  stringstream ss3;
+  ss3 << key_formatter(DefaultKeyFormatter) << StreamedKey(key);
+  EXPECT("c3" == ss3.str());
+}
+
+/* ************************************************************************* */
+int main() {
+  TestResult tr;
+  return TestRegistry::runAllTests(tr);
+}
 /* ************************************************************************* */
 

gtsam/inference/tests/testLabeledSymbol.cpp

@@ -80,6 +80,29 @@ TEST(LabeledSymbol, ChrTest) {
 }
 
 /* ************************************************************************* */
-int main() { TestResult tr; return TestRegistry::runAllTests(tr); }
+// A custom (nonsensical) formatter.
+string myFormatter(Key key) {
+  return "special";
+}
+
+TEST(LabeledSymbol, Formatting) {
+  LabeledSymbol symbol('c', 'A', 3);
+
+  // use key_formatter with a function pointer
+  stringstream ss2;
+  ss2 << key_formatter(myFormatter) << symbol;
+  EXPECT("special" == ss2.str());
+
+  // use key_formatter with a function object.
+  stringstream ss3;
+  ss3 << key_formatter(MultiRobotKeyFormatter) << symbol;
+  EXPECT("cA3" == ss3.str());
+}
+
+/* ************************************************************************* */
+int main() {
+  TestResult tr;
+  return TestRegistry::runAllTests(tr);
+}
 /* ************************************************************************* */
 

gtsam/inference/tests/testSymbol.cpp

@@ -0,0 +1,50 @@
+/* ----------------------------------------------------------------------------
+
+ * GTSAM Copyright 2010, Georgia Tech Research Corporation,
+ * Atlanta, Georgia 30332-0415
+ * All Rights Reserved
+ * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
+
+ * See LICENSE for the license information
+
+ * -------------------------------------------------------------------------- */
+
+/*
+ * @file testSymbol.cpp
+ * @author Frank Dellaert
+ */
+
+#include <gtsam/inference/Symbol.h>
+
+#include <CppUnitLite/TestHarness.h>
+
+using namespace std;
+using namespace gtsam;
+
+/* ************************************************************************* */
+// A custom (nonsensical) formatter.
+string myFormatter(Key key) {
+  return "special";
+}
+
+TEST(Symbol, Formatting) {
+  Symbol symbol('c', 3);
+
+  // use key_formatter with a function pointer
+  stringstream ss2;
+  ss2 << key_formatter(myFormatter) << symbol;
+  EXPECT("special" == ss2.str());
+
+  // use key_formatter with a function object.
+  stringstream ss3;
+  ss3 << key_formatter(MultiRobotKeyFormatter) << symbol;
+  EXPECT("c3" == ss3.str());
+}
+
+/* ************************************************************************* */
+int main() {
+  TestResult tr;
+  return TestRegistry::runAllTests(tr);
+}
+/* ************************************************************************* */
+

gtsam/linear/HessianFactor.cpp

@@ -505,7 +505,7 @@ VectorValues HessianFactor::solve() {
 
   // Do Cholesky Factorization
   const size_t n = size();
-  assert(info_.nBlocks() == n + 1);
+  assert(size_t(info_.nBlocks()) == n + 1);
   info_.choleskyPartial(n);
   auto R = info_.triangularView(0, n);
   auto eta = linearTerm();

gtsam/navigation/CombinedImuFactor.h

@@ -64,7 +64,7 @@ typedef ManifoldPreintegration PreintegrationType;
  *
  * @addtogroup SLAM
  */
-class PreintegratedCombinedMeasurements : public PreintegrationType {
+class GTSAM_EXPORT PreintegratedCombinedMeasurements : public PreintegrationType {
 
 public:
 
@@ -222,7 +222,7 @@ public:
  *
  * @addtogroup SLAM
  */
-class CombinedImuFactor: public NoiseModelFactor6<Pose3, Vector3, Pose3,
+class GTSAM_EXPORT CombinedImuFactor: public NoiseModelFactor6<Pose3, Vector3, Pose3,
     Vector3, imuBias::ConstantBias, imuBias::ConstantBias> {
 public:
 

gtsam/nonlinear/DoglegOptimizer.h

@@ -41,7 +41,7 @@ public:
   VerbosityDL verbosityDL; ///< The verbosity level for Dogleg (default: SILENT), see also NonlinearOptimizerParams::verbosity
 
   DoglegParams() :
-    deltaInitial(10.0), verbosityDL(SILENT) {}
+    deltaInitial(1.0), verbosityDL(SILENT) {}
 
   virtual ~DoglegParams() {}
 

gtsam/nonlinear/Values-inl.h

@@ -145,13 +145,13 @@ namespace gtsam {
                 boost::make_filter_iterator(filter,
                     ((const Values&) values).begin(),
                     ((const Values&) values).end()),
-                &ValuesCastHelper<const ValueType, ConstKeyValuePair,
+                &ValuesCastHelper<ValueType, ConstKeyValuePair,
                     Values::ConstKeyValuePair>::cast)), constEnd_(
             boost::make_transform_iterator(
                 boost::make_filter_iterator(filter,
                     ((const Values&) values).end(),
                     ((const Values&) values).end()),
-                &ValuesCastHelper<const ValueType, ConstKeyValuePair,
+                &ValuesCastHelper<ValueType, ConstKeyValuePair,
                     Values::ConstKeyValuePair>::cast)) {
     }
 

gtsam_unstable/CMakeLists.txt

@@ -1,3 +1,5 @@
+project(gtsam_unstable LANGUAGES CXX)
+
 # Build full gtsam_unstable library as a single library
 # and also build tests
 set (gtsam_unstable_subdirs
@@ -65,6 +67,10 @@ message(STATUS "Install prefix: ${CMAKE_INSTALL_PREFIX}")
 
 # BUILD_SHARED_LIBS automatically defines static/shared libs:
 add_library(gtsam_unstable ${gtsam_unstable_srcs})
+
+# Apply build flags:
+gtsam_apply_build_flags(gtsam_unstable)
+
 set_target_properties(gtsam_unstable PROPERTIES
   OUTPUT_NAME         gtsam_unstable
   CLEAN_DIRECT_OUTPUT 1

wrap/CMakeLists.txt

@@ -26,6 +26,9 @@ if (NOT GTSAM_WRAP_SERIALIZATION)
   target_compile_definitions(wrap_lib PUBLIC -DWRAP_DISABLE_SERIALIZE)
 endif()
 
+# Apply build flags:
+gtsam_apply_build_flags(wrap_lib)
+
 target_link_libraries(wrap_lib ${WRAP_BOOST_LIBRARIES})
 target_include_directories(wrap_lib PUBLIC ${Boost_INCLUDE_DIR})
 

wrap/Class.cpp

@@ -342,17 +342,21 @@ vector<Class> Class::expandTemplate(Str templateArg,
 
 /* ************************************************************************* */
 void Class::addMethod(bool verbose, bool is_const, Str methodName,
-    const ArgumentList& argumentList, const ReturnValue& returnValue,
+                      const ArgumentList& argumentList,
-    const Template& tmplate) {
+                      const ReturnValue& returnValue, const Template& tmplate) {
   // Check if templated
   if (tmplate.valid()) {
-    templateMethods_[methodName].addOverload(methodName, argumentList,
+    try {
-                                             returnValue, is_const,
+      templateMethods_[methodName].addOverload(methodName, argumentList,
-                                             tmplate.argName(), verbose);
+                                               returnValue, is_const,
+                                               tmplate.argName(), verbose);
+    } catch (const std::runtime_error& e) {
+      throw std::runtime_error("Class::addMethod: error adding " + name_ +
+                               "::" + methodName + "\n" + e.what());
+    }
     // Create method to expand
     // For all values of the template argument, create a new method
-    for(const Qualified& instName: tmplate.argValues()) {
+    for (const Qualified& instName : tmplate.argValues()) {
-
       const TemplateSubstitution ts(tmplate.argName(), instName, *this);
       // substitute template in arguments
       ArgumentList expandedArgs = argumentList.expandTemplate(ts);
@@ -361,15 +365,27 @@ void Class::addMethod(bool verbose, bool is_const, Str methodName,
       // Now stick in new overload stack with expandedMethodName key
       // but note we use the same, unexpanded methodName in overload
       string expandedMethodName = methodName + instName.name();
-      methods_[expandedMethodName].addOverload(methodName, expandedArgs,
+      try {
-          expandedRetVal, is_const, instName, verbose);
+        methods_[expandedMethodName].addOverload(methodName, expandedArgs,
+                                                 expandedRetVal, is_const,
+                                                 instName, verbose);
+      } catch (const std::runtime_error& e) {
+        throw std::runtime_error("Class::addMethod: error adding " + name_ +
+                                 "::" + expandedMethodName + "\n" + e.what());
+      }
     }
   } else {
-    // just add overload
+    try {
-    methods_[methodName].addOverload(methodName, argumentList, returnValue,
+      // just add overload
-        is_const, boost::none, verbose);
+      methods_[methodName].addOverload(methodName, argumentList, returnValue,
-    nontemplateMethods_[methodName].addOverload(methodName, argumentList, returnValue,
+                                       is_const, boost::none, verbose);
-        is_const, boost::none, verbose);
+      nontemplateMethods_[methodName].addOverload(methodName, argumentList,
+                                                  returnValue, is_const,
+                                                  boost::none, verbose);
+    } catch (const std::runtime_error& e) {
+      throw std::runtime_error("Class::addMethod: error adding " + name_ +
+                               "::" + methodName + "\n" + e.what());
+    }
   }
 }
 

wrap/FileWriter.cpp

@@ -29,7 +29,7 @@ void FileWriter::emit(bool add_header, bool force_overwrite) const {
   bool file_exists = true;
   try {
     existing_contents = file_contents(filename_.c_str(), add_header);
-  } catch (const CantOpenFile& e) {
+  } catch (const CantOpenFile& ) {
     file_exists = false;
   }
 

wrap/Method.cpp

@@ -38,12 +38,12 @@ bool Method::addOverload(Str name, const ArgumentList& args,
     is_const_ = is_const;
   else if (is_const && !is_const_)
     throw std::runtime_error(
-        "Method::addOverload now designated as const whereas before it was "
+        "Method::addOverload: " + name +
-        "not");
+        " now designated as const whereas before it was not");
   else if (!is_const && is_const_)
     throw std::runtime_error(
-        "Method::addOverload now designated as non-const whereas before it "
+        "Method::addOverload: " + name +
-        "was");
+        " now designated as non-const whereas before it was");
   return first;
 }
 

wrap/README.md

@@ -1,25 +1,21 @@
-Frank Dellaert
+# WRAP README
-October 2011
 
 The wrap library wraps the GTSAM library into a MATLAB toolbox. 
 
-It was designed to be more general than just wrapping GTSAM, but a small amount of 
+It was designed to be more general than just wrapping GTSAM, but a small amount of GTSAM specific code exists in matlab.h, the include file that is included by the mex files. The GTSAM-specific functionality consists primarily of handling of Eigen Matrix and Vector classes.  
-GTSAM specific code exists in matlab.h, the include file that is included by the
-mex files. The GTSAM-specific functionality consists primarily of handling of
-Eigen Matrix and Vector classes.  
 
-For notes on creating a wrap interface, see gtsam.h for what features can be 
+For notes on creating a wrap interface, see gtsam.h for what features can be wrapped into a toolbox, as well as the current state of the toolbox for gtsam. For more technical details on the interface, please read comments in matlab.h
-wrapped into a toolbox, as well as the current state of the toolbox for gtsam.
-For more technical details on the interface, please read comments in matlab.h
 
 Some good things to know:
 
 OBJECT CREATION
+
 - Classes are created by special constructors, e.g., new_GaussianFactorGraph_.cpp.
 	These constructors are called from the MATLAB class @GaussianFactorGraph.
 	new_GaussianFactorGraph_ calls wrap_constructed in matlab.h, see documentation there
 	
 METHOD (AND CONSTRUCTOR) ARGUMENTS
+
 - Simple argument types of methods, such as "double", will be converted in the
   mex wrappers by calling unwrap<double>, defined in matlab.h
 - Vector and Matrix arguments are normally passed by reference in GTSAM, but