Sculpt: updated Mask and Face Set menu operators

Changed the menu operators:

    Expand Mask by Topology (hotkey Shift A)
    Expand Mask by Normals (hotkey Shift Alt A)
    Expand Face Set by Topology (hotkey Shift W)
    Expand Active Face Set (hotkey Shift Alt W)

so that their hotkeys would appear in their menu entries.

Resolves #104023

Co-authored-by: DisquietingFridge <30654622+DisquietingFridge@users.noreply.github.com>
Pull Request: blender/blender#104568

.clang-format

@@ -266,6 +266,7 @@ ForEachMacros:
   - SET_SLOT_PROBING_BEGIN
   - MAP_SLOT_PROBING_BEGIN
   - VECTOR_SET_SLOT_PROBING_BEGIN
+  - TGSET_ITER
   - WL_ARRAY_FOR_EACH
   - FOREACH_SPECTRUM_CHANNEL
 

CMakeLists.txt

@@ -707,6 +707,12 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
         [HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\LLVM\\LLVM;]/lib/clang/7.0.0/lib/windows
         [HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\LLVM\\LLVM;]/lib/clang/6.0.0/lib/windows
       )
+        find_library(
+          COMPILER_ASAN_LIBRARY_THUNK NAMES clang_rt.asan_dll_thunk-x86_64
+        PATHS
+        [HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\LLVM\\LLVM;]/lib/clang/7.0.0/lib/windows
+        [HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\LLVM\\LLVM;]/lib/clang/6.0.0/lib/windows
+      )
     elseif(APPLE)
       execute_process(COMMAND ${CMAKE_CXX_COMPILER}
         -print-file-name=lib
@@ -727,6 +733,7 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
       )
     endif()
 
+    mark_as_advanced(COMPILER_ASAN_LIBRARY_THUNK)
     mark_as_advanced(COMPILER_ASAN_LIBRARY)
   endif()
 endif()
@@ -784,6 +791,8 @@ if("${CMAKE_GENERATOR}" MATCHES "Ninja")
   mark_as_advanced(WITH_NINJA_POOL_JOBS)
 endif()
 
+option(WITH_INSTANT_MESHES, "Instant Meshes Quadrangulator" ON)
+
 # Installation process.
 set(POSTINSTALL_SCRIPT "" CACHE FILEPATH "Run given CMake script after installation process")
 mark_as_advanced(POSTINSTALL_SCRIPT)
@@ -1054,9 +1063,9 @@ if(NOT CMAKE_BUILD_TYPE MATCHES "Release")
       unset(_list_COMPILER_ASAN_CFLAGS)
       unset(_is_CONFIG_DEBUG)
     elseif(COMPILER_ASAN_LIBRARY)
-      set(PLATFORM_LINKLIBS "${PLATFORM_LINKLIBS};${COMPILER_ASAN_LIBRARY}")
-      set(PLATFORM_LINKFLAGS "${COMPILER_ASAN_LIBRARY} ${COMPILER_ASAN_LINKER_FLAGS}")
-      set(PLATFORM_LINKFLAGS_DEBUG "${COMPILER_ASAN_LIBRARY} ${COMPILER_ASAN_LINKER_FLAGS}")
+      set(PLATFORM_LINKLIBS "${PLATFORM_LINKLIBS};\"${COMPILER_ASAN_LIBRARY}\" \"${COMPILER_ASAN_LIBRARY_THUNK}\"")
+      set(PLATFORM_LINKFLAGS "\"${COMPILER_ASAN_LIBRARY}\" \"${COMPILER_ASAN_LIBRARY_THUNK}\" ${COMPILER_ASAN_LINKER_FLAGS}")
+      set(PLATFORM_LINKFLAGS_DEBUG "\"${COMPILER_ASAN_LIBRARY}\" \"${COMPILER_ASAN_LIBRARY_THUNK}\" ${COMPILER_ASAN_LINKER_FLAGS}")
     endif()
   endif()
 endif()

extern/Eigen3/Eigen/src/Core/util/Macros.h

@@ -389,7 +389,7 @@
 
 // Does the compiler support result_of?
 #ifndef EIGEN_HAS_STD_RESULT_OF
-#if EIGEN_MAX_CPP_VER>=11 && ((__has_feature(cxx_lambdas) || (defined(__cplusplus) && __cplusplus >= 201103L)))
+#if __cplusplus < 201703L && EIGEN_MAX_CPP_VER>=11 && ((__has_feature(cxx_lambdas) || (defined(__cplusplus) && __cplusplus >= 201103L && __cplusplus)))
 #define EIGEN_HAS_STD_RESULT_OF 1
 #else
 #define EIGEN_HAS_STD_RESULT_OF 0

extern/audaspace/bindings/C/AUD_Device.cpp

@@ -221,7 +221,7 @@ AUD_API void AUD_Device_setListenerVelocity(AUD_Device* device, const float valu
 AUD_API double AUD_Device_getRate(AUD_Device* device)
 {
 	auto dev = device ? *device : DeviceManager::getDevice();
-	return dev->getSpecs().rate;
+	return dev ? dev->getSpecs().rate : 0.0;
 }
 
 AUD_API float AUD_Device_getSpeedOfSound(AUD_Device* device)

extern/audaspace/include/util/ThreadPool.h

@@ -87,11 +87,17 @@ public:
 	* \param args The arguments of the task.
 	* \return A future of the same type as the return type of the task.
 	*/
+#if __cplusplus > 201703L
+	template<class T, class... Args>
+	std::future<typename std::invoke_result<T, Args...>::type> enqueue(T&& t, Args&&... args)
+	{
+		using pkgdTask = std::packaged_task<typename std::invoke_result<T, Args...>::type()>;
+#else
 	template<class T, class... Args>
 	std::future<typename std::result_of<T(Args...)>::type> enqueue(T&& t, Args&&... args)
 	{
 		using pkgdTask = std::packaged_task<typename std::result_of<T(Args...)>::type()>;
-
+#endif
 		std::shared_ptr<pkgdTask> task = std::make_shared<pkgdTask>(std::bind(std::forward<T>(t), std::forward<Args>(args)...));
 		auto result = task->get_future();
 

extern/quadriflow/3rd/lemon-1.3.1/CMakeLists.txt

@@ -67,7 +67,7 @@ SET(LEMON_ENABLE_ILOG YES CACHE STRING "Enable ILOG (CPLEX) solver backend.")
 SET(LEMON_ENABLE_COIN YES CACHE STRING "Enable COIN solver backend.")
 SET(LEMON_ENABLE_SOPLEX YES CACHE STRING "Enable SoPlex solver backend.")
 
-IF(LEMON_ENABLE_GLPK)
+IF(LEMON_ENABLE_GLPK) 
   FIND_PACKAGE(GLPK 4.33)
 ENDIF(LEMON_ENABLE_GLPK)
 IF(LEMON_ENABLE_ILOG)

extern/quadriflow/3rd/lemon-1.3.1/cmake/FindILOG.cmake

@@ -4,7 +4,7 @@ FIND_PATH(ILOG_ROOT_DIR
   PATHS /opt/ibm/ILOG /usr/local/ibm/ILOG /usr/local/ILOG /usr/local/ilog
   PATHS "$ENV{HOME}/ILOG" "$ENV{HOME}/.local/ILOG"
   PATHS "$ENV{HOME}/ibm/ILOG" "$ENV{HOME}/.local/ibm/ILOG"
-  PATHS "C:/Program Files/IBM/ILOG"
+  PATHS "C:/Program Files/IBM/ILOG" 
   PATH_SUFFIXES "CPLEX_Studio126" "CPLEX_Studio125"
   "CPLEX_Studio124" "CPLEX_Studio123" "CPLEX_Studio122"
   NO_DEFAULT_PATH

extern/quadriflow/3rd/lemon-1.3.1/contrib/CMakeLists.txt

@@ -16,3 +16,4 @@ LINK_DIRECTORIES(
 
 # ADD_EXECUTABLE(myprog myprog-main.cc)
 # TARGET_LINK_LIBRARIES(myprog lemon)
+

extern/quadriflow/3rd/lemon-1.3.1/lemon/CMakeLists.txt

@@ -88,3 +88,4 @@ INSTALL(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
   DESTINATION lib/pkgconfig
 )
+

extern/quadriflow/CMakeLists.txt

@@ -50,6 +50,18 @@ set(INC_SYS
   ${EIGEN3_INCLUDE_DIRS}
 )
 
+#if(WITH_TBB)
+#  add_definitions(-DWITH_TBB)
+#
+#  list(APPEND INC_SYS
+#    ${TBB_INCLUDE_DIRS}
+#  )
+#
+#  list(APPEND LIB
+#    ${TBB_LIBRARIES}
+#  )
+#endif()
+
 set(SRC
   src/adjacent-matrix.cpp
   src/adjacent-matrix.hpp

extern/quadriflow/src/loader.cpp

@@ -10,6 +10,7 @@
 
 #include <fstream>
 #include <unordered_map>
+#include <functional>
 
 namespace qflow {
 
@@ -69,7 +70,7 @@ void load(const char* filename, MatrixXd& V, MatrixXi& F)
 	};
 
 	/// Hash function for obj_vertex
-	struct obj_vertexHash {
+	struct obj_vertexHash : std::function<size_t(obj_vertex)> {
 		std::size_t operator()(const obj_vertex &v) const {
 			size_t hash = std::hash<uint32_t>()(v.p);
 			hash = hash * 37 + std::hash<uint32_t>()(v.uv);

extern/quadriflow/src/optimizer.cpp

@@ -13,6 +13,13 @@
 #include "flow.hpp"
 #include "parametrizer.hpp"
 
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
 namespace qflow {
 
 #ifdef WITH_CUDA

extern/quadriflow/src/parametrizer-int.cpp

@@ -6,6 +6,16 @@
 #include <random>
 #include "optimizer.hpp"
 
+#include <algorithm>
+
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
+
 namespace qflow {
 
 

extern/quadriflow/src/parametrizer-mesh.cpp

@@ -8,6 +8,16 @@
 #include "dedge.hpp"
 #include <queue>
 
+#include <algorithm>
+
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
+
 namespace qflow {
 
 void Parametrizer::NormalizeMesh() {

extern/quadriflow/src/parametrizer-sing.cpp

@@ -2,6 +2,14 @@
 #include "field-math.hpp"
 #include "parametrizer.hpp"
 
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
+
 namespace qflow {
 
 void Parametrizer::ComputeOrientationSingularities() {

extern/quadriflow/src/parametrizer.hpp

@@ -19,6 +19,13 @@
 #include "post-solver.hpp"
 #include "serialize.hpp"
 
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
 namespace qflow {
 
 using namespace Eigen;

extern/quadriflow/src/subdivide.cpp

@@ -8,6 +8,14 @@
 #include "field-math.hpp"
 #include "parametrizer.hpp"
 
+#include <algorithm>
+#ifdef max
+#undef max
+#endif
+#ifdef min
+#undef min
+#endif
+
 namespace qflow {
 
 void subdivide(MatrixXi &F, MatrixXd &V, VectorXd& rho, VectorXi &V2E, VectorXi &E2E, VectorXi &boundary,

intern/CMakeLists.txt

@@ -67,6 +67,10 @@ if(UNIX AND NOT APPLE)
   add_subdirectory(libc_compat)
 endif()
 
+if(WITH_INSTANT_MESHES)
+  add_subdirectory(instant-meshes)
+endif()
+
 if(UNIX AND NOT APPLE)
   # Important this comes after "ghost" as it uses includes defined by GHOST's CMake.
   if(WITH_GHOST_WAYLAND AND WITH_GHOST_WAYLAND_DYNLOAD)

intern/atomic/intern/atomic_ops_msvc.h

@@ -63,17 +63,17 @@
 /* Unsigned */
 ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-  return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x) + x;
+  return (uint64_t)(InterlockedExchangeAdd64((int64_t *)p, (int64_t)x) + (int64_t)x);
 }
 
 ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x)
 {
-  return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x)) - x;
+  return (uint64_t)(InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x)) - (int64_t)x);
 }
 
 ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new)
 {
-  return InterlockedCompareExchange64((int64_t *)v, _new, old);
+  return (uint64_t)(InterlockedCompareExchange64((int64_t *)v, _new, old));
 }
 
 ATOMIC_INLINE uint64_t atomic_load_uint64(const uint64_t *v)
@@ -88,12 +88,12 @@ ATOMIC_INLINE void atomic_store_uint64(uint64_t *p, uint64_t v)
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x)
 {
-  return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x);
+  return (uint64_t)InterlockedExchangeAdd64((int64_t *)p, (int64_t)x);
 }
 
 ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x)
 {
-  return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x));
+  return (uint64_t)InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x));
 }
 
 /* Signed */
@@ -137,17 +137,17 @@ ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x)
 /* Unsigned */
 ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-  return InterlockedExchangeAdd(p, x) + x;
+  return (uint32_t)InterlockedExchangeAdd(p, x) + x;
 }
 
 ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x)
 {
-  return InterlockedExchangeAdd(p, -((int32_t)x)) - x;
+  return (uint32_t)InterlockedExchangeAdd(p, -((int32_t)x)) - x;
 }
 
 ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new)
 {
-  return InterlockedCompareExchange((long *)v, _new, old);
+  return (uint32_t)InterlockedCompareExchange((long *)v, _new, old);
 }
 
 ATOMIC_INLINE uint32_t atomic_load_uint32(const uint32_t *v)
@@ -162,17 +162,17 @@ ATOMIC_INLINE void atomic_store_uint32(uint32_t *p, uint32_t v)
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x)
 {
-  return InterlockedExchangeAdd(p, x);
+  return (uint32_t)InterlockedExchangeAdd(p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_or_uint32(uint32_t *p, uint32_t x)
 {
-  return InterlockedOr((long *)p, x);
+  return (uint32_t)InterlockedOr((long *)p, x);
 }
 
 ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x)
 {
-  return InterlockedAnd((long *)p, x);
+  return (uint32_t)InterlockedAnd((long *)p, x);
 }
 
 /* Signed */
@@ -259,9 +259,9 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b)
 ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-  return InterlockedAnd8((char *)p, (char)b);
+  return (int8_t)InterlockedAnd8((char *)p, (char)b);
 #else
-  return _InterlockedAnd8((char *)p, (char)b);
+  return (int8_t)_InterlockedAnd8((char *)p, (char)b);
 #endif
 }
 
@@ -269,9 +269,9 @@ ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b)
 ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b)
 {
 #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8)
-  return InterlockedOr8((char *)p, (char)b);
+  return (int8_t)InterlockedOr8((char *)p, (char)b);
 #else
-  return _InterlockedOr8((char *)p, (char)b);
+  return (int8_t)_InterlockedOr8((char *)p, (char)b);
 #endif
 }
 

intern/cycles/kernel/CMakeLists.txt

@@ -409,6 +409,7 @@ if(WITH_CYCLES_CUDA_BINARIES)
   string(REGEX REPLACE ".*release ([0-9]+)\\.([0-9]+).*" "\\2" CUDA_VERSION_MINOR "${NVCC_OUT}")
   set(CUDA_VERSION "${CUDA_VERSION_MAJOR}${CUDA_VERSION_MINOR}")
 
+
   # warn for other versions
   if((CUDA_VERSION STREQUAL "101") OR
      (CUDA_VERSION STREQUAL "102") OR
@@ -451,6 +452,7 @@ if(WITH_CYCLES_CUDA_BINARIES)
       -D CCL_NAMESPACE_BEGIN=
       -D CCL_NAMESPACE_END=
       -D NVCC
+      -allow-unsupported-compiler
       -m ${CUDA_BITS}
       -I ${CMAKE_CURRENT_SOURCE_DIR}/..
       -I ${CMAKE_CURRENT_SOURCE_DIR}/device/cuda

intern/ghost/CMakeLists.txt

@@ -596,4 +596,7 @@ if(WITH_XR_OPENXR)
   unset(XR_PLATFORM_DEFINES)
 endif()
 
+remove_cc_flag("-fsanitize=address")
+remove_cc_flag("/fsanitize=address")
+
 blender_add_lib(bf_intern_ghost "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

intern/ghost/GHOST_Types.h

@@ -9,6 +9,18 @@
 
 #include <stdint.h>
 
+#ifndef ATTR_NO_OPT
+#  ifdef __clang__
+#    define ATTR_NO_OPT __attribute__((optnone))
+#  elif defined(_MSC_VER)
+#    define ATTR_NO_OPT __pragma(optimize("", off))
+#  elif defined(__GNUC__)
+#    define ATTR_NO_OPT __attribute__((optimize("O0")))
+#  else
+#    define ATTR_NO_OPT
+#  endif
+#endif
+
 #ifdef WITH_CXX_GUARDEDALLOC
 #  include "MEM_guardedalloc.h"
 #else

intern/ghost/intern/GHOST_Context.h

@@ -15,6 +15,14 @@
 
 #include <cstdlib>  // for NULL
 
+#if defined(__clang__) || defined(__GCC__)
+#  define ATTR_NO_ASAN __attribute__((no_sanitize("address")))
+#elif _MSC_VER
+#  define ATTR_NO_ASAN __declspec(no_sanitize_address)
+#else
+#  define ATTR_NO_ASAN
+#endif
+
 class GHOST_Context : public GHOST_IContext {
  public:
   /**

intern/ghost/intern/GHOST_ContextWGL.cpp

@@ -127,7 +127,8 @@ GHOST_TSuccess GHOST_ContextWGL::releaseDrawingContext()
 /* Ron Fosner's code for weighting pixel formats and forcing software.
  * See http://www.opengl.org/resources/faq/technical/weight.cpp
  */
-static int weight_pixel_format(PIXELFORMATDESCRIPTOR &pfd, PIXELFORMATDESCRIPTOR &preferredPFD)
+ATTR_NO_ASAN static int weight_pixel_format(PIXELFORMATDESCRIPTOR &pfd,
+                                            PIXELFORMATDESCRIPTOR &preferredPFD)
 {
   int weight = 0;
 
@@ -162,7 +163,7 @@ static int weight_pixel_format(PIXELFORMATDESCRIPTOR &pfd, PIXELFORMATDESCRIPTOR
  * A modification of Ron Fosner's replacement for ChoosePixelFormat
  * returns 0 on error, else returns the pixel format number to be used
  */
-static int choose_pixel_format_legacy(HDC hDC, PIXELFORMATDESCRIPTOR &preferredPFD)
+ATTR_NO_ASAN static int choose_pixel_format_legacy(HDC hDC, PIXELFORMATDESCRIPTOR &preferredPFD)
 {
   int iPixelFormat = 0;
   int weight = 0;
@@ -215,7 +216,7 @@ static int choose_pixel_format_legacy(HDC hDC, PIXELFORMATDESCRIPTOR &preferredP
  * There is no generic way to clone the lpParam parameter,
  * so the caller is responsible for cloning it themselves.
  */
-static HWND clone_window(HWND hWnd, LPVOID lpParam)
+ATTR_NO_ASAN static HWND clone_window(HWND hWnd, LPVOID lpParam)
 {
   int count;
 
@@ -478,7 +479,7 @@ int GHOST_ContextWGL::_choose_pixel_format_arb_1(bool stereoVisual, bool needAlp
   return iPixelFormat;
 }
 
-int GHOST_ContextWGL::choose_pixel_format_arb(bool stereoVisual, bool needAlpha)
+ATTR_NO_ASAN int GHOST_ContextWGL::choose_pixel_format_arb(bool stereoVisual, bool needAlpha)
 {
   int iPixelFormat;
 
@@ -505,7 +506,7 @@ static void reportContextString(const char *name, const char *dummy, const char
 }
 #endif
 
-GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext()
+ATTR_NO_ASAN GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext()
 {
   SetLastError(NO_ERROR);
 

intern/ghost/intern/GHOST_WindowWin32.cpp

@@ -39,19 +39,19 @@ extern "C" {
 __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;
 }
 
-GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system,
-                                     const char *title,
-                                     int32_t left,
-                                     int32_t top,
-                                     uint32_t width,
-                                     uint32_t height,
-                                     GHOST_TWindowState state,
-                                     GHOST_TDrawingContextType type,
-                                     bool wantStereoVisual,
-                                     bool alphaBackground,
-                                     GHOST_WindowWin32 *parentwindow,
-                                     bool is_debug,
-                                     bool dialog)
+ATTR_NO_ASAN GHOST_WindowWin32::GHOST_WindowWin32(GHOST_SystemWin32 *system,
+                                                  const char *title,
+                                                  int32_t left,
+                                                  int32_t top,
+                                                  uint32_t width,
+                                                  uint32_t height,
+                                                  GHOST_TWindowState state,
+                                                  GHOST_TDrawingContextType type,
+                                                  bool wantStereoVisual,
+                                                  bool alphaBackground,
+                                                  GHOST_WindowWin32 *parentwindow,
+                                                  bool is_debug,
+                                                  bool dialog)
     : GHOST_Window(width, height, state, wantStereoVisual, false),
       m_mousePresent(false),
       m_inLiveResize(false),
@@ -579,7 +579,7 @@ GHOST_TSuccess GHOST_WindowWin32::invalidate()
   return success;
 }
 
-GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType type)
+ATTR_NO_ASAN GHOST_Context *GHOST_WindowWin32::newDrawingContext(GHOST_TDrawingContextType type)
 {
   if (type == GHOST_kDrawingContextTypeOpenGL) {
     GHOST_Context *context;

intern/ghost/intern/GHOST_Wintab.cpp

@@ -7,12 +7,20 @@
 #define _USE_MATH_DEFINES
 
 #include "GHOST_Wintab.h"
+#include <cstdio>
+
+static void wintab_load_error(const char *func)
+{
+  fprintf(stderr, "corrupted wintab32.dll; missing %s\n", func);
+}
 
 GHOST_Wintab *GHOST_Wintab::loadWintab(HWND hwnd)
 {
   /* Load Wintab library if available. */
   auto handle = unique_hmodule(::LoadLibrary("Wintab32.dll"), &::FreeLibrary);
   if (!handle) {
+    fprintf(stderr, "Could not find wintab32.dll\n");
+
     return nullptr;
   }
 
@@ -20,51 +28,61 @@ GHOST_Wintab *GHOST_Wintab::loadWintab(HWND hwnd)
 
   auto info = (GHOST_WIN32_WTInfo)::GetProcAddress(handle.get(), "WTInfoA");
   if (!info) {
+    wintab_load_error("WTInfoA");
     return nullptr;
   }
 
   auto open = (GHOST_WIN32_WTOpen)::GetProcAddress(handle.get(), "WTOpenA");
   if (!open) {
+    wintab_load_error("WTOpenA");
     return nullptr;
   }
 
   auto get = (GHOST_WIN32_WTGet)::GetProcAddress(handle.get(), "WTGetA");
   if (!get) {
+    wintab_load_error("WTGetA");
     return nullptr;
   }
 
   auto set = (GHOST_WIN32_WTSet)::GetProcAddress(handle.get(), "WTSetA");
   if (!set) {
+    wintab_load_error("WTSetA");
     return nullptr;
   }
 
   auto close = (GHOST_WIN32_WTClose)::GetProcAddress(handle.get(), "WTClose");
   if (!close) {
+    wintab_load_error("WTClose");
     return nullptr;
   }
 
   auto packetsGet = (GHOST_WIN32_WTPacketsGet)::GetProcAddress(handle.get(), "WTPacketsGet");
   if (!packetsGet) {
+    wintab_load_error("WTPacketGet");
     return nullptr;
   }
 
   auto queueSizeGet = (GHOST_WIN32_WTQueueSizeGet)::GetProcAddress(handle.get(), "WTQueueSizeGet");
   if (!queueSizeGet) {
+    wintab_load_error("WTQueueSizeGet");
     return nullptr;
   }
 
   auto queueSizeSet = (GHOST_WIN32_WTQueueSizeSet)::GetProcAddress(handle.get(), "WTQueueSizeSet");
   if (!queueSizeSet) {
+    wintab_load_error("WTQueueSizeSet");
     return nullptr;
   }
 
   auto enable = (GHOST_WIN32_WTEnable)::GetProcAddress(handle.get(), "WTEnable");
   if (!enable) {
+    wintab_load_error("WTEnable");
     return nullptr;
   }
 
   auto overlap = (GHOST_WIN32_WTOverlap)::GetProcAddress(handle.get(), "WTOverlap");
   if (!overlap) {
+    wintab_load_error("WTOverlap");
     return nullptr;
   }
 
@@ -72,6 +90,8 @@ GHOST_Wintab *GHOST_Wintab::loadWintab(HWND hwnd)
 
   LOGCONTEXT lc = {0};
   if (!info(WTI_DEFSYSCTX, 0, &lc)) {
+    fprintf(stderr, "Failed to initialize Wintab driver\n");
+
     return nullptr;
   }
 
@@ -82,6 +102,8 @@ GHOST_Wintab *GHOST_Wintab::loadWintab(HWND hwnd)
   /* The Wintab spec says we must open the context disabled if we are using cursor masks. */
   auto hctx = unique_hctx(open(hwnd, &lc, FALSE), close);
   if (!hctx) {
+    fprintf(stderr, "Failed to open Wintab driver\n");
+
     return nullptr;
   }
 
@@ -188,7 +210,7 @@ GHOST_Wintab::GHOST_Wintab(unique_hmodule handle,
       m_context{std::move(hctx)},
       m_tabletCoord{tablet},
       m_systemCoord{system},
-      m_pkts{queueSize}
+      m_pkts{(size_t)queueSize}
 {
   m_fpInfo(WTI_INTERFACE, IFC_NDEVICES, &m_numDevices);
   WINTAB_PRINTF("Wintab Devices: %d\n", m_numDevices);

intern/guardedalloc/CMakeLists.txt

@@ -9,6 +9,7 @@ set(INC
   .
   ..
   ../atomic
+  ../../source/blender/blenlib
 )
 
 set(INC_SYS

intern/guardedalloc/MEM_guardedalloc.h

@@ -66,6 +66,12 @@ extern short (*MEM_testN)(void *vmemh);
  * NULL-safe; will return NULL when receiving a NULL pointer. */
 extern void *(*MEM_dupallocN)(const void *vmemh) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT;
 
+/**
+ * Duplicates a block of memory, and returns a pointer to the
+ * newly allocated block. */
+extern void *(*MEM_dupallocN_id)(const void *vmemh,
+                                 const char *str) /* ATTR_MALLOC */ ATTR_WARN_UNUSED_RESULT;
+
 /**
  * Reallocates a block of memory, and returns pointer to the newly
  * allocated block, the old one is freed. this is not as optimized
@@ -247,6 +253,8 @@ void MEM_use_lockfree_allocator(void);
  * NOTE: The switch between allocator types can only happen before any allocation did happen. */
 void MEM_use_guarded_allocator(void);
 
+#define MEM_dupallocN(vmemh) MEM_dupallocN_id(vmemh, __func__)
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

intern/guardedalloc/intern/mallocn.c

@@ -26,6 +26,7 @@ const char *malloc_conf = "background_thread:true,dirty_decay_ms:4000";
 size_t (*MEM_allocN_len)(const void *vmemh) = MEM_lockfree_allocN_len;
 void (*MEM_freeN)(void *vmemh) = MEM_lockfree_freeN;
 void *(*MEM_dupallocN)(const void *vmemh) = MEM_lockfree_dupallocN;
+void *(*MEM_dupallocN_id)(const void *vmemh, const char *str) = MEM_lockfree_dupallocN_id;
 void *(*MEM_reallocN_id)(void *vmemh, size_t len, const char *str) = MEM_lockfree_reallocN_id;
 void *(*MEM_recallocN_id)(void *vmemh, size_t len, const char *str) = MEM_lockfree_recallocN_id;
 void *(*MEM_callocN)(size_t len, const char *str) = MEM_lockfree_callocN;
@@ -108,6 +109,7 @@ void MEM_use_lockfree_allocator(void)
   MEM_allocN_len = MEM_lockfree_allocN_len;
   MEM_freeN = MEM_lockfree_freeN;
   MEM_dupallocN = MEM_lockfree_dupallocN;
+  MEM_dupallocN_id = MEM_lockfree_dupallocN_id;
   MEM_reallocN_id = MEM_lockfree_reallocN_id;
   MEM_recallocN_id = MEM_lockfree_recallocN_id;
   MEM_callocN = MEM_lockfree_callocN;
@@ -140,6 +142,7 @@ void MEM_use_guarded_allocator(void)
   MEM_allocN_len = MEM_guarded_allocN_len;
   MEM_freeN = MEM_guarded_freeN;
   MEM_dupallocN = MEM_guarded_dupallocN;
+  MEM_dupallocN_id = MEM_guarded_dupallocN_id;
   MEM_reallocN_id = MEM_guarded_reallocN_id;
   MEM_recallocN_id = MEM_guarded_recallocN_id;
   MEM_callocN = MEM_guarded_callocN;

intern/guardedalloc/intern/mallocn_guarded_impl.c

@@ -287,6 +287,31 @@ void *MEM_guarded_dupallocN(const void *vmemh)
   return newp;
 }
 
+void *MEM_guarded_dupallocN_id(const void *vmemh, const char *str)
+{
+  void *newp = NULL;
+
+  if (vmemh) {
+    const MemHead *memh = vmemh;
+    memh--;
+
+    if (LIKELY(memh->alignment == 0)) {
+      newp = MEM_guarded_mallocN(memh->len, str);
+    }
+    else {
+      newp = MEM_guarded_mallocN_aligned(memh->len, (size_t)memh->alignment, str);
+    }
+
+    if (newp == NULL) {
+      return NULL;
+    }
+
+    memcpy(newp, vmemh, memh->len);
+  }
+
+  return newp;
+}
+
 void *MEM_guarded_reallocN_id(void *vmemh, size_t len, const char *str)
 {
   void *newp = NULL;
@@ -1012,7 +1037,7 @@ static void MemorY_ErroR(const char *block, const char *error)
   print_error("Memoryblock %s: %s\n", block, error);
 
 #ifdef WITH_ASSERT_ABORT
-  abort();
+    abort();
 #endif
 }
 

intern/guardedalloc/intern/mallocn_intern.h

@@ -101,6 +101,8 @@ void memory_usage_peak_reset(void);
 size_t MEM_lockfree_allocN_len(const void *vmemh) ATTR_WARN_UNUSED_RESULT;
 void MEM_lockfree_freeN(void *vmemh);
 void *MEM_lockfree_dupallocN(const void *vmemh) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
+void *MEM_lockfree_dupallocN_id(const void *vmemh,
+                                const char *str) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
 void *MEM_lockfree_reallocN_id(void *vmemh,
                                size_t len,
                                const char *str) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
@@ -145,6 +147,8 @@ void MEM_lockfree_name_ptr_set(void *vmemh, const char *str);
 size_t MEM_guarded_allocN_len(const void *vmemh) ATTR_WARN_UNUSED_RESULT;
 void MEM_guarded_freeN(void *vmemh);
 void *MEM_guarded_dupallocN(const void *vmemh) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
+void *MEM_guarded_dupallocN_id(const void *vmemh,
+                               const char *str) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
 void *MEM_guarded_reallocN_id(void *vmemh,
                               size_t len,
                               const char *str) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT

intern/guardedalloc/intern/mallocn_lockfree_impl.c

@@ -15,6 +15,7 @@
 #include "MEM_guardedalloc.h"
 
 /* to ensure strict conversions */
+#include "../../source/blender/blenlib/BLI_asan.h"
 #include "../../source/blender/blenlib/BLI_strict_flags.h"
 
 #include "atomic_ops.h"
@@ -44,6 +45,21 @@ enum {
 #define MEMHEAD_IS_ALIGNED(memhead) ((memhead)->len & (size_t)MEMHEAD_ALIGN_FLAG)
 #define MEMHEAD_LEN(memhead) ((memhead)->len & ~((size_t)(MEMHEAD_ALIGN_FLAG)))
 
+#define MEM_POISON_MEMHEAD(vmemh) BLI_asan_poison(MEMHEAD_FROM_PTR(vmemh), sizeof(MemHead))
+#define MEM_UNPOISON_MEMHEAD(vmemh) BLI_asan_unpoison(MEMHEAD_FROM_PTR(vmemh), sizeof(MemHead))
+
+/* Uncomment this to have proper peak counter. */
+#define USE_ATOMIC_MAX
+
+MEM_INLINE void update_maximum(size_t *maximum_value, size_t value)
+{
+#ifdef USE_ATOMIC_MAX
+  atomic_fetch_and_update_max_z(maximum_value, value);
+#else
+  *maximum_value = value > *maximum_value ? value : *maximum_value;
+#endif
+}
+
 #ifdef __GNUC__
 __attribute__((format(printf, 1, 2)))
 #endif
@@ -66,7 +82,13 @@ print_error(const char *str, ...)
 size_t MEM_lockfree_allocN_len(const void *vmemh)
 {
   if (LIKELY(vmemh)) {
-    return MEMHEAD_LEN(MEMHEAD_FROM_PTR(vmemh));
+    size_t ret;
+
+    MEM_UNPOISON_MEMHEAD(vmemh);
+    ret = MEMHEAD_FROM_PTR(vmemh)->len & ~((size_t)(MEMHEAD_ALIGN_FLAG));
+    MEM_POISON_MEMHEAD(vmemh);
+
+    return ret;
   }
 
   return 0;
@@ -87,6 +109,8 @@ void MEM_lockfree_freeN(void *vmemh)
   }
 
   MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
+  MEM_UNPOISON_MEMHEAD(vmemh);
+
   size_t len = MEMHEAD_LEN(memh);
 
   memory_usage_block_free(len);
@@ -109,6 +133,9 @@ void *MEM_lockfree_dupallocN(const void *vmemh)
   if (vmemh) {
     MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
     const size_t prev_size = MEM_lockfree_allocN_len(vmemh);
+
+    MEM_UNPOISON_MEMHEAD(vmemh);
+
     if (UNLIKELY(MEMHEAD_IS_ALIGNED(memh))) {
       MemHeadAligned *memh_aligned = MEMHEAD_ALIGNED_FROM_PTR(vmemh);
       newp = MEM_lockfree_mallocN_aligned(
@@ -117,6 +144,31 @@ void *MEM_lockfree_dupallocN(const void *vmemh)
     else {
       newp = MEM_lockfree_mallocN(prev_size, "dupli_malloc");
     }
+
+    MEM_POISON_MEMHEAD(vmemh);
+    memcpy(newp, vmemh, prev_size);
+  }
+  return newp;
+}
+
+void *MEM_lockfree_dupallocN_id(const void *vmemh, const char *str)
+{
+  void *newp = NULL;
+  if (vmemh) {
+    MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
+    const size_t prev_size = MEM_lockfree_allocN_len(vmemh);
+
+    MEM_UNPOISON_MEMHEAD(vmemh);
+
+    if (UNLIKELY(MEMHEAD_IS_ALIGNED(memh))) {
+      MemHeadAligned *memh_aligned = MEMHEAD_ALIGNED_FROM_PTR(vmemh);
+      newp = MEM_lockfree_mallocN_aligned(prev_size, (size_t)memh_aligned->alignment, str);
+    }
+    else {
+      newp = MEM_lockfree_mallocN(prev_size, str);
+    }
+
+    MEM_POISON_MEMHEAD(vmemh);
     memcpy(newp, vmemh, prev_size);
   }
   return newp;
@@ -130,6 +182,8 @@ void *MEM_lockfree_reallocN_id(void *vmemh, size_t len, const char *str)
     MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
     size_t old_len = MEM_lockfree_allocN_len(vmemh);
 
+    MEM_UNPOISON_MEMHEAD(vmemh);
+
     if (LIKELY(!MEMHEAD_IS_ALIGNED(memh))) {
       newp = MEM_lockfree_mallocN(len, "realloc");
     }
@@ -138,6 +192,8 @@ void *MEM_lockfree_reallocN_id(void *vmemh, size_t len, const char *str)
       newp = MEM_lockfree_mallocN_aligned(len, (size_t)memh_aligned->alignment, "realloc");
     }
 
+    MEM_POISON_MEMHEAD(vmemh);
+
     if (newp) {
       if (len < old_len) {
         /* shrink */
@@ -166,6 +222,8 @@ void *MEM_lockfree_recallocN_id(void *vmemh, size_t len, const char *str)
     MemHead *memh = MEMHEAD_FROM_PTR(vmemh);
     size_t old_len = MEM_lockfree_allocN_len(vmemh);
 
+    MEM_UNPOISON_MEMHEAD(vmemh);
+
     if (LIKELY(!MEMHEAD_IS_ALIGNED(memh))) {
       newp = MEM_lockfree_mallocN(len, "recalloc");
     }
@@ -173,6 +231,7 @@ void *MEM_lockfree_recallocN_id(void *vmemh, size_t len, const char *str)
       MemHeadAligned *memh_aligned = MEMHEAD_ALIGNED_FROM_PTR(vmemh);
       newp = MEM_lockfree_mallocN_aligned(len, (size_t)memh_aligned->alignment, "recalloc");
     }
+    MEM_POISON_MEMHEAD(vmemh);
 
     if (newp) {
       if (len < old_len) {
@@ -211,6 +270,7 @@ void *MEM_lockfree_callocN(size_t len, const char *str)
     memh->len = len;
     memory_usage_block_alloc(len);
 
+    MEM_POISON_MEMHEAD(PTR_FROM_MEMHEAD(memh));
     return PTR_FROM_MEMHEAD(memh);
   }
   print_error("Calloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
@@ -254,6 +314,8 @@ void *MEM_lockfree_mallocN(size_t len, const char *str)
     memh->len = len;
     memory_usage_block_alloc(len);
 
+    MEM_POISON_MEMHEAD(PTR_FROM_MEMHEAD(memh));
+
     return PTR_FROM_MEMHEAD(memh);
   }
   print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",
@@ -323,6 +385,8 @@ void *MEM_lockfree_mallocN_aligned(size_t len, size_t alignment, const char *str
     memh->alignment = (short)alignment;
     memory_usage_block_alloc(len);
 
+    MEM_POISON_MEMHEAD(PTR_FROM_MEMHEAD(memh));
+
     return PTR_FROM_MEMHEAD(memh);
   }
   print_error("Malloc returns null: len=" SIZET_FORMAT " in %s, total %u\n",

intern/instant-meshes/CMakeLists.txt

@@ -0,0 +1,98 @@
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# The Original Code is Copyright (C) 2006, Blender Foundation
+# All rights reserved.
+# ***** END GPL LICENSE BLOCK *****
+
+set(INC
+  .
+  ../atomic
+  ../eigen
+  ../guardedalloc
+  ../../extern/Eigen3
+  ext/half
+  ext/dset
+  ext/pss
+  ext/pcg32
+  ../
+  
+)
+
+set(INC_SYS
+  ${GMP_INCLUDE_DIRS}
+)
+
+set(SRC
+  src/aabb.h
+  src/adjacency.cpp
+  src/adjacency.h
+  src/batch.cpp
+  src/batch.h
+  src/bvh.cpp
+  src/bvh.h
+  src/cleanup.cpp
+  src/cleanup.h
+  src/common.h
+  src/dedge.cpp
+  src/dedge.h
+  src/diff.cpp
+  src/extract.cpp
+  src/extract.h
+  src/field.cpp
+  src/field.h
+  src/meshstats.cpp
+  src/meshstats.h
+  src/normal.cpp
+  src/normal.h
+  src/hierarchy.cpp
+  src/hierarchy.h
+  src/reorder.cpp
+  src/reorder.h
+  src/subdivide.cpp
+  src/subdivide.h
+  src/smoothcurve.cpp
+  src/smoothcurve.h
+  src/c_api.cpp
+  instant_meshes_c_api.h
+)
+
+set(LIB
+)
+
+if(WITH_TBB)
+  add_definitions(-DWITH_TBB)
+
+  list(APPEND INC_SYS
+    ${TBB_INCLUDE_DIRS}
+  )
+
+  list(APPEND LIB
+    ${TBB_LIBRARIES}
+  )
+endif()
+
+if(WIN32 AND NOT UNIX)
+  list(APPEND INC_SYS
+    ${PTHREADS_INC}
+  )
+
+  list(APPEND LIB
+    ${PTHREADS_LIBRARIES}
+  )
+endif()
+
+blender_add_lib(bf_intern_instant_meshes "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")

intern/instant-meshes/LICENSE.txt

@@ -0,0 +1,37 @@
+Copyright (c) 2015 Wenzel Jakob, Daniele Panozzo, Marco Tarini,
+and Olga Sorkine-Hornung. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or
+upgrades to the features, functionality or performance of the source code
+("Enhancements") to anyone; however, if you choose to make your Enhancements
+available either publicly, or directly to the authors of this software, without
+imposing a separate written license agreement for such Enhancements, then you
+hereby grant the following license: a non-exclusive, royalty-free perpetual
+license to install, use, modify, prepare derivative works, incorporate into
+other computer software, distribute, and sublicense such enhancements or
+derivative works thereof, in binary and source code form.

intern/instant-meshes/README.md

@@ -0,0 +1,72 @@
+# Instant Meshes
+[![Build Status](https://travis-ci.org/wjakob/instant-meshes.svg?branch=master)](https://travis-ci.org/wjakob/instant-meshes)
+[![Build status](https://ci.appveyor.com/api/projects/status/dm4kqxhin5uxiey0/branch/master?svg=true)](https://ci.appveyor.com/project/wjakob/instant-meshes/branch/master)
+
+<img width="170" height="166" src="https://github.com/wjakob/instant-meshes/raw/master/resources/icon.png">
+
+This repository contains the interactive meshing software developed as part of the publication
+
+> **Instant Field-Aligned Meshes**<br/>
+> Wenzel Jakob, Marco Tarini, Daniele Panozzo, Olga Sorkine-Hornung<br/>
+> In *ACM Transactions on Graphics (Proceedings of SIGGRAPH Asia 2015)*<br/>
+> [PDF](http://igl.ethz.ch/projects/instant-meshes/instant-meshes-SA-2015-jakob-et-al.pdf),
+> [Video](https://www.youtube.com/watch?v=U6wtw6W4x3I),
+> [Project page](http://igl.ethz.ch/projects/instant-meshes/)
+
+
+##### In commercial software
+
+Since version 10.2, Modo uses the Instant Meshes algorithm to implement its
+automatic retopology feature. An interview discussing this technique and more
+recent projects is available [here](https://www.foundry.com/trends/design-visualisation/mitsuba-renderer-instant-meshes).
+
+## Screenshot
+
+![Instant Meshes logo](https://github.com/wjakob/instant-meshes/raw/master/resources/screenshot.jpg)
+
+## Pre-compiled binaries
+
+The following binaries (Intel, 64 bit) are automatically generated from the latest GitHub revision.
+
+> [Microsoft Windows](https://instant-meshes.s3.eu-central-1.amazonaws.com/Release/instant-meshes-windows.zip)<br/>
+> [Mac OS X](https://instant-meshes.s3.eu-central-1.amazonaws.com/instant-meshes-macos.zip)<br/>
+> [Linux](https://instant-meshes.s3.eu-central-1.amazonaws.com/instant-meshes-linux.zip)
+
+Please also fetch the following dataset ZIP file and extract it so that the
+``datasets`` folder is in the same directory as ``Instant Meshes``, ``Instant Meshes.app``,
+or ``Instant Meshes.exe``.
+
+> [Datasets](https://instant-meshes.s3.eu-central-1.amazonaws.com/instant-meshes-datasets.zip)
+
+Note: On Linux, Instant Meshes relies on the program ``zenity``, which must be installed.
+
+## Compiling
+
+Compiling from scratch requires CMake and a recent version of XCode on Mac,
+Visual Studio 2015 on Windows, and GCC on Linux. 
+
+On MacOS, compiling should be as simple as
+
+    git clone --recursive https://github.com/wjakob/instant-meshes
+    cd instant-meshes
+    cmake .
+    make -j 4
+
+To build on Linux, please install the prerequisites ``libxrandr-dev``,
+``libxinerama-dev``, ``libxcursor-dev``, and ``libxi-dev`` and then use the
+same sequence of commands shown above for MacOS.
+
+On Windows, open the generated file ``InstantMeshes.sln`` after step 3 and proceed building as usual from within Visual Studio.
+
+## Usage
+
+To get started, launch the binary and select a dataset using the "Open mesh" button on the top left (the application must be located in the same directory as the 'datasets' folder, otherwise the panel will be empty).
+
+The standard workflow is to solve for an orientation field (first blue button) and a position field (second blue button) in sequence, after which the 'Export mesh' button becomes active. Many user interface elements display a descriptive message when hovering the mouse cursor above for a second.
+
+A range of additional information about the input mesh, the computed fields,
+and the output mesh can be visualized using the check boxes accessible via the
+'Advanced' panel.
+
+Clicking the left mouse button and dragging rotates the object; right-dragging
+(or shift+left-dragging) translates, and the mouse wheel zooms. The fields can also be manipulated using brush tools that are accessible by clicking the first icon in each 'Tool' row.

intern/instant-meshes/Readme.Blender.MD

@@ -0,0 +1 @@
+This is a fork of instant-meshes, an alternative to QuadriFlow.

intern/instant-meshes/ext/dset/LICENSE.txt

@@ -0,0 +1,17 @@
+Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.

intern/instant-meshes/ext/dset/README.md

@@ -0,0 +1,11 @@
+# Lock-free parallel disjoint set data structure
+
+This is a small self-contained C++11 implementation of the UNION-FIND data
+structure with path compression and union by rank and a few extras It supports
+concurrent `find()`, `same()` and `unite()` calls as described in the paper
+
+*Wait-free Parallel Algorithms for the Union-Find Problem*
+by Richard J. Anderson and Heather Woll
+
+In addition, this class supports optimistic locking (`try_lock()`/`unlock()`)
+of disjoint sets and a *combined* unite+unlock operation for pairs of sets.

intern/instant-meshes/ext/dset/dset.h

@@ -0,0 +1,159 @@
+#if !defined(__UNIONFIND_H)
+#define __UNIONFIND_H
+
+#include <vector>
+#include <atomic>
+#include <iostream>
+
+/**
+ * Lock-free parallel disjoint set data structure (aka UNION-FIND)
+ * with path compression and union by rank
+ *
+ * Supports concurrent find(), same() and unite() calls as described
+ * in the paper
+ *
+ * "Wait-free Parallel Algorithms for the Union-Find Problem"
+ * by Richard J. Anderson and Heather Woll
+ *
+ * In addition, this class supports optimistic locking (try_lock/unlock)
+ * of disjoint sets and a combined unite+unlock operation.
+ *
+ * \author Wenzel Jakob
+ */
+class DisjointSets {
+public:
+    DisjointSets(uint32_t size) : mData(size) {
+        for (uint32_t i=0; i<size; ++i)
+            mData[i] = (uint32_t) i;
+    }
+
+    uint32_t find(uint32_t id) const {
+        while (id != parent(id)) {
+            uint64_t value = mData[id];
+            uint32_t new_parent = parent((uint32_t) value);
+            uint64_t new_value =
+                (value & 0xFFFFFFFF00000000ULL) | new_parent;
+            /* Try to update parent (may fail, that's ok) */
+            if (value != new_value)
+                mData[id].compare_exchange_weak(value, new_value);
+            id = new_parent;
+        }
+        return id;
+    }
+
+    bool same(uint32_t id1, uint32_t id2) const {
+        for (;;) {
+            id1 = find(id1);
+            id2 = find(id2);
+            if (id1 == id2)
+                return true;
+            if (parent(id1) == id1)
+                return false;
+        }
+    }
+
+    uint32_t unite(uint32_t id1, uint32_t id2) {
+        for (;;) {
+            id1 = find(id1);
+            id2 = find(id2);
+
+            if (id1 == id2)
+                return id1;
+
+            uint32_t r1 = rank(id1), r2 = rank(id2);
+
+            if (r1 > r2 || (r1 == r2 && id1 < id2)) {
+                std::swap(r1, r2);
+                std::swap(id1, id2);
+            }
+
+            uint64_t oldEntry = ((uint64_t) r1 << 32) | id1;
+            uint64_t newEntry = ((uint64_t) r1 << 32) | id2;
+
+            if (!mData[id1].compare_exchange_strong(oldEntry, newEntry))
+                continue;
+
+            if (r1 == r2) {
+                oldEntry = ((uint64_t) r2 << 32) | id2;
+                newEntry = ((uint64_t) (r2+1) << 32) | id2;
+                /* Try to update the rank (may fail, that's ok) */
+                mData[id2].compare_exchange_weak(oldEntry, newEntry);
+            }
+
+            break;
+        }
+        return id2;
+    }
+
+    /**
+     * Try to lock the a disjoint union identified by one
+     * of its elements (this can occasionally fail when there
+     * are concurrent operations). The parameter 'id' will be
+     * updated to store the current representative ID of the
+     * union
+     */
+    bool try_lock(uint32_t &id) {
+        const uint64_t lock_flag = 1ULL << 63;
+        id = find(id);
+        uint64_t value = mData[id];
+        if ((value & lock_flag) || (uint32_t) value != id)
+            return false;
+        // On IA32/x64, a PAUSE instruction is recommended for CAS busy loops
+        #if defined(__i386__) || defined(__amd64__)
+            __asm__ __volatile__ ("pause\n");
+        #endif
+        return mData[id].compare_exchange_strong(value, value | lock_flag);
+    }
+
+    void unlock(uint32_t id) {
+        const uint64_t lock_flag = 1ULL << 63;
+        mData[id] &= ~lock_flag;
+    }
+
+    /**
+     * Return the representative index of the set that results from merging
+     * locked disjoint sets 'id1' and 'id2'
+     */
+    uint32_t unite_index_locked(uint32_t id1, uint32_t id2) const {
+        uint32_t r1 = rank(id1), r2 = rank(id2);
+        return (r1 > r2 || (r1 == r2 && id1 < id2)) ? id1 : id2;
+    }
+
+    /**
+     * Atomically unite two locked disjoint sets and unlock them. Assumes
+     * that here are no other concurrent unite() involving the same sets
+     */
+    uint32_t unite_unlock(uint32_t id1, uint32_t id2) {
+        uint32_t r1 = rank(id1), r2 = rank(id2);
+
+        if (r1 > r2 || (r1 == r2 && id1 < id2)) {
+            std::swap(r1, r2);
+            std::swap(id1, id2);
+        }
+
+        mData[id1] = ((uint64_t) r1 << 32) | id2;
+        mData[id2] = ((uint64_t) (r2 + ((r1 == r2) ? 1 : 0)) << 32) | id2;
+
+        return id2;
+    }
+
+    uint32_t size() const { return (uint32_t) mData.size(); }
+
+    uint32_t rank(uint32_t id) const {
+        return ((uint32_t) (mData[id] >> 32)) & 0x7FFFFFFFu;
+    }
+
+    uint32_t parent(uint32_t id) const {
+        return (uint32_t) mData[id];
+    }
+
+    friend std::ostream &operator<<(std::ostream &os, const DisjointSets &f) {
+        for (size_t i=0; i<f.mData.size(); ++i)
+            os << i << ": parent=" << f.parent(i) << ", rank=" << f.rank(i) << std::endl;
+        return os;
+    }
+
+    mutable std::vector<std::atomic<uint64_t>> mData;
+};
+
+#endif /* __UNIONFIND_H */

intern/instant-meshes/ext/pcg32/README.md

@@ -0,0 +1,9 @@
+# pcg32
+This is a tiny self-contained C++ implementation of the PCG32 random number
+based on code by Melissa O'Neill available at http://www.pcg-random.org.
+
+I decided to make put together my own version because the official small
+implementation lacks a C++ interface and various important features (e.g.
+rewind/difference support, shuffling, floating point sample generation), and
+the big C++ version is extremely large and uses very recent language features
+that are not yet supported by all compilers.

intern/instant-meshes/ext/pcg32/pcg32-demo.cpp

@@ -0,0 +1,109 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+/*
+ * This is the original demo application from the PCG library ported to the new API
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <time.h>
+#include <string.h>
+
+#include "pcg32.h"
+
+int main(int argc, char** argv) {
+    // Read command-line options
+    int rounds = 5;
+
+    if (argc > 1)
+        rounds = atoi(argv[1]);
+
+    pcg32 rng;
+
+    // You should *always* seed the RNG.  The usual time to do it is the
+    // point in time when you create RNG (typically at the beginning of the
+    // program).
+    //
+    // pcg32::seed takes two 64-bit constants (the initial state, and the
+    // rng sequence selector; rngs with different sequence selectors will
+    // *never* have random sequences that coincide, at all)
+    rng.seed(42u, 54u);
+
+    printf("pcg32_random_r:\n"
+           "      -  result:      32-bit unsigned int (uint32_t)\n"
+           "      -  period:      2^64   (* 2^63 streams)\n"
+           "      -  state type:  pcg32_random_t (%zu bytes)\n"
+           "      -  output func: XSH-RR\n"
+           "\n",
+           sizeof(pcg32));
+
+    for (int round = 1; round <= rounds; ++round) {
+        printf("Round %d:\n", round);
+        /* Make some 32-bit numbers */
+        printf("  32bit:");
+        for (int i = 0; i < 6; ++i)
+            printf(" 0x%08x", rng.nextUInt());
+        printf("\n");
+
+        /* Toss some coins */
+        printf("  Coins: ");
+        for (int i = 0; i < 65; ++i)
+            printf("%c", rng.nextUInt(2) ? 'H' : 'T');
+        printf("\n");
+
+        /* Roll some dice */
+        printf("  Rolls:");
+        for (int i = 0; i < 33; ++i) {
+            printf(" %d", (int)rng.nextUInt(6) + 1);
+        }
+        printf("\n");
+
+        /* Deal some cards */
+        enum { SUITS = 4, NUMBERS = 13, CARDS = 52 };
+        char cards[CARDS];
+
+        for (int i = 0; i < CARDS; ++i)
+            cards[i] = i;
+
+        rng.shuffle(cards, cards + CARDS);
+
+        printf("  Cards:");
+        static const char number[] = {'A', '2', '3', '4', '5', '6', '7',
+                                      '8', '9', 'T', 'J', 'Q', 'K'};
+        static const char suit[] = {'h', 'c', 'd', 's'};
+        for (int i = 0; i < CARDS; ++i) {
+            printf(" %c%c", number[cards[i] / SUITS], suit[cards[i] % SUITS]);
+            if ((i + 1) % 22 == 0)
+                printf("\n\t");
+        }
+        printf("\n");
+
+        printf("\n");
+    }
+
+    return 0;
+}

intern/instant-meshes/ext/pcg32/pcg32-demo.out

@@ -0,0 +1,46 @@
+pcg32_random_r:
+      -  result:      32-bit unsigned int (uint32_t)
+      -  period:      2^64   (* 2^63 streams)
+      -  state type:  pcg32_random_t (16 bytes)
+      -  output func: XSH-RR
+
+Round 1:
+  32bit: 0xa15c02b7 0x7b47f409 0xba1d3330 0x83d2f293 0xbfa4784b 0xcbed606e
+  Coins: HHTTTHTHHHTHTTTHHHHHTTTHHHTHTHTHTTHTTTHHHHHHTTTTHHTTTTTHTTTTTTTHT
+  Rolls: 3 4 1 1 2 2 3 2 4 3 2 4 3 3 5 2 3 1 3 1 5 1 4 1 5 6 4 6 6 2 6 3 3
+  Cards: Qd Ks 6d 3s 3d 4c 3h Td Kc 5c Jh Kd Jd As 4s 4h Ad Th Ac Jc 7s Qs
+	 2s 7h Kh 2d 6c Ah 4d Qh 9h 6s 5s 2c 9c Ts 8d 9s 3c 8c Js 5d 2h 6h
+	 7d 8s 9d 5h 8h Qc 7c Tc
+
+Round 2:
+  32bit: 0x74ab93ad 0x1c1da000 0x494ff896 0x34462f2f 0xd308a3e5 0x0fa83bab
+  Coins: HHHHHHHHHHTHHHTHTHTHTHTTTTHHTTTHHTHHTHTTHHTTTHHHHHHTHTTHTHTTTTTTT
+  Rolls: 5 1 1 3 3 2 4 5 3 2 2 6 4 3 2 4 2 4 3 2 3 6 3 2 3 4 2 4 1 1 5 4 4
+  Cards: 7d 2s 7h Td 8s 3c 3d Js 2d Tc 4h Qs 5c 9c Th 2c Jc Qd 9d Qc 7s 3s
+	 5s 6h 4d Jh 4c Ac 4s 5h 5d Kc 8h 8d Jd 9s Ad 6s 6c Kd 2h 3h Kh Ts
+	 Qh 9h 6d As 7c Ks Ah 8c
+
+Round 3:
+  32bit: 0x39af5f9f 0x04196b18 0xc3c3eb28 0xc076c60c 0xc693e135 0xf8f63932
+  Coins: HTTHHTTTTTHTTHHHTHTTHHTTHTHHTHTHTTTTHHTTTHHTHHTTHTTHHHTHHHTHTTTHT
+  Rolls: 5 1 5 3 2 2 4 5 3 3 1 3 4 6 3 2 3 4 2 2 3 1 5 2 4 6 6 4 2 4 3 3 6
+  Cards: Kd Jh Kc Qh 4d Qc 4h 9d 3c Kh Qs 8h 5c Jd 7d 8d 3h 7c 8s 3s 2h Ks
+	 9c 9h 2c 8c Ad 7s 4s 2s 5h 6s 4c Ah 7h 5s Ac 3d 5d Qd As Tc 6h 9s
+	 2d 6c 6d Td Jc Ts Th Js
+
+Round 4:
+  32bit: 0x55ce6851 0x97a7726d 0x17e10815 0x58007d43 0x962fb148 0xb9bb55bd
+  Coins: HHTHHTTTTHTHHHHHTTHHHTTTHHTHTHTHTHHTTHTHHHHHHTHHTHHTHHTTTTHHTHHTT
+  Rolls: 6 6 3 2 3 4 2 6 4 2 6 3 2 3 5 5 3 4 4 6 6 2 6 5 4 4 6 1 6 1 3 6 5
+  Cards: Qd 8h 5d 8s 8d Ts 7h Th Qs Js 7s Kc 6h 5s 4d Ac Jd 7d 7c Td 2c 6s
+	 5h 6d 3s Kd 9s Jh Kh As Ah 9h 3c Qh 9c 2d Tc 9d 2s 3d Ks 4h Qc Ad
+	 Jc 8c 2h 3h 4s 4c 5c 6c
+
+Round 5:
+  32bit: 0xfcef7cd6 0x1b488b5a 0xd0daf7ea 0x1d9a70f7 0x241a37cf 0x9a3857b7
+  Coins: HHHHTHHTTHTTHHHTTTHHTHTHTTTTHTTHTHTTTHHHTHTHTTHTTHTHHTHTHHHTHTHTT
+  Rolls: 5 4 1 2 6 1 3 1 5 6 3 6 2 1 4 4 5 2 1 5 6 5 6 4 4 4 5 2 6 4 3 5 6
+  Cards: 4d 9s Qc 9h As Qs 7s 4c Kd 6h 6s 2c 8c 5d 7h 5h Jc 3s 7c Jh Js Ks
+	 Tc Jd Kc Th 3h Ts Qh Ad Td 3c Ah 2d 3d 5c Ac 8s 5s 9c 2h 6c 6d Kh
+	 Qd 8d 7d 2s 8h 4h 9d 4s
+

intern/instant-meshes/ext/pcg32/pcg32.h

@@ -0,0 +1,208 @@
+/*
+ * Tiny self-contained version of the PCG Random Number Generation for C++
+ * put together from pieces of the much larger C/C++ codebase.
+ * Wenzel Jakob, February 2015
+ *
+ * The PCG random number generator was developed by Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+#ifndef __PCG32_H
+#define __PCG32_H 1
+
+#define PCG32_DEFAULT_STATE  0x853c49e6748fea9bULL
+#define PCG32_DEFAULT_STREAM 0xda3e39cb94b95bdbULL
+#define PCG32_MULT           0x5851f42d4c957f2dULL
+
+#include <inttypes.h>
+#include <cmath>
+#include <cassert>
+#include <algorithm>
+
+/// PCG32 Pseudorandom number generator
+struct pcg32 {
+    /// Initialize the pseudorandom number generator with default seed
+    pcg32() : state(PCG32_DEFAULT_STATE), inc(PCG32_DEFAULT_STREAM) {}
+
+    /// Initialize the pseudorandom number generator with the \ref seed() function
+    pcg32(uint64_t initstate, uint64_t initseq = 1u) { seed(initstate, initseq); }
+
+    /**
+     * \brief Seed the pseudorandom number generator
+     *
+     * Specified in two parts: a state initializer and a sequence selection
+     * constant (a.k.a. stream id)
+     */
+    void seed(uint64_t initstate, uint64_t initseq = 1) {
+        state = 0U;
+        inc = (initseq << 1u) | 1u;
+        nextUInt();
+        state += initstate;
+        nextUInt();
+    }
+
+    /// Generate a uniformly distributed unsigned 32-bit random number
+    uint32_t nextUInt() {
+        uint64_t oldstate = state;
+        state = oldstate * PCG32_MULT + inc;
+        uint32_t xorshifted = (uint32_t) (((oldstate >> 18u) ^ oldstate) >> 27u);
+        uint32_t rot = (uint32_t) (oldstate >> 59u);
+        return (xorshifted >> rot) | (xorshifted << ((~rot + 1u) & 31));
+    }
+
+    /// Generate a uniformly distributed number, r, where 0 <= r < bound
+    uint32_t nextUInt(uint32_t bound) {
+        // To avoid bias, we need to make the range of the RNG a multiple of
+        // bound, which we do by dropping output less than a threshold.
+        // A naive scheme to calculate the threshold would be to do
+        //
+        //     uint32_t threshold = 0x100000000ull % bound;
+        //
+        // but 64-bit div/mod is slower than 32-bit div/mod (especially on
+        // 32-bit platforms).  In essence, we do
+        //
+        //     uint32_t threshold = (0x100000000ull-bound) % bound;
+        //
+        // because this version will calculate the same modulus, but the LHS
+        // value is less than 2^32.
+
+        uint32_t threshold = (~bound+1u) % bound;
+
+        // Uniformity guarantees that this loop will terminate.  In practice, it
+        // should usually terminate quickly; on average (assuming all bounds are
+        // equally likely), 82.25% of the time, we can expect it to require just
+        // one iteration.  In the worst case, someone passes a bound of 2^31 + 1
+        // (i.e., 2147483649), which invalidates almost 50% of the range.  In
+        // practice, bounds are typically small and only a tiny amount of the range
+        // is eliminated.
+        for (;;) {
+            uint32_t r = nextUInt();
+            if (r >= threshold)
+                return r % bound;
+        }
+    }
+
+    /// Generate a single precision floating point value on the interval [0, 1)
+    float nextFloat() {
+        /* Trick from MTGP: generate an uniformly distributed
+           single precision number in [1,2) and subtract 1. */
+        union {
+            uint32_t u;
+            float f;
+        } x;
+        x.u = (nextUInt() >> 9) | 0x3f800000UL;
+        return x.f - 1.0f;
+    }
+
+    /**
+     * \brief Generate a double precision floating point value on the interval [0, 1)
+     *
+     * \remark Since the underlying random number generator produces 32 bit output,
+     * only the first 32 mantissa bits will be filled (however, the resolution is still
+     * finer than in \ref nextFloat(), which only uses 23 mantissa bits)
+     */
+    double nextDouble() {
+        /* Trick from MTGP: generate an uniformly distributed
+           double precision number in [1,2) and subtract 1. */
+        union {
+            uint64_t u;
+            double d;
+        } x;
+        x.u = ((uint64_t) nextUInt() << 20) | 0x3ff0000000000000ULL;
+        return x.d - 1.0;
+    }
+
+    /**
+     * \brief Multi-step advance function (jump-ahead, jump-back)
+     *
+     * The method used here is based on Brown, "Random Number Generation
+     * with Arbitrary Stride", Transactions of the American Nuclear
+     * Society (Nov. 1994). The algorithm is very similar to fast
+     * exponentiation.
+     */
+    void advance(int64_t delta_) {
+        uint64_t
+            cur_mult = PCG32_MULT,
+            cur_plus = inc,
+            acc_mult = 1u,
+            acc_plus = 0u;
+
+        /* Even though delta is an unsigned integer, we can pass a signed
+           integer to go backwards, it just goes "the long way round". */
+        uint64_t delta = (uint64_t) delta_;
+
+        while (delta > 0) {
+            if (delta & 1) {
+                acc_mult *= cur_mult;
+                acc_plus = acc_plus * cur_mult + cur_plus;
+            }
+            cur_plus = (cur_mult + 1) * cur_plus;
+            cur_mult *= cur_mult;
+            delta /= 2;
+        }
+        state = acc_mult * state + acc_plus;
+    }
+
+    /**
+     * \brief Draw uniformly distributed permutation and permute the
+     * given STL container
+     *
+     * From: Knuth, TAoCP Vol. 2 (3rd 3d), Section 3.4.2
+     */
+    template <typename Iterator> void shuffle(Iterator begin, Iterator end) {
+        for (Iterator it = end - 1; it > begin; --it)
+            std::iter_swap(it, begin + nextUInt((uint32_t) (it - begin + 1)));
+    }
+
+    /// Compute the distance between two PCG32 pseudorandom number generators
+    int64_t operator-(const pcg32 &other) const {
+        assert(inc == other.inc);
+
+        uint64_t
+            cur_mult = PCG32_MULT,
+            cur_plus = inc,
+            cur_state = other.state,
+            the_bit = 1u,
+            distance = 0u;
+
+        while (state != cur_state) {
+            if ((state & the_bit) != (cur_state & the_bit)) {
+                cur_state = cur_state * cur_mult + cur_plus;
+                distance |= the_bit;
+            }
+            assert((state & the_bit) == (cur_state & the_bit));
+            the_bit <<= 1;
+            cur_plus = (cur_mult + 1ULL) * cur_plus;
+            cur_mult *= cur_mult;
+        }
+
+        return (int64_t) distance;
+    }
+
+    /// Equality operator
+    bool operator==(const pcg32 &other) const { return state == other.state && inc == other.inc; }
+
+    /// Inequality operator
+    bool operator!=(const pcg32 &other) const { return state != other.state || inc != other.inc; }
+
+    uint64_t state;  // RNG state.  All values are possible.
+    uint64_t inc;    // Controls which RNG sequence (stream) is selected. Must *always* be odd.
+};
+
+#endif // __PCG32_H

intern/instant-meshes/ext/pss/LICENSE.txt

@@ -0,0 +1,29 @@
+Copyright (C) 2014 Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+* Neither the name of Intel Corporation nor the names of its
+  contributors may be used to endorse or promote products derived
+  from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

intern/instant-meshes/ext/pss/README.md

@@ -0,0 +1,9 @@
+# Parallel Stable Sort
+
+This repository contains a parallel stable sort implementation using Thread
+Building Blocks. It contains the low-level TBB version (with minor
+modifications to remove warnings on various platforms) presented in Arch
+D. Robison's article [A Parallel Stable Sort Using C++11 for TBB, Cilk Plus,
+and OpenMP][1].
+
+[1] https://software.intel.com/en-us/articles/a-parallel-stable-sort-using-c11-for-tbb-cilk-plus-and-openmp

intern/instant-meshes/ext/pss/parallel_stable_sort.h

@@ -0,0 +1,140 @@
+/*
+  Copyright (C) 2014 Intel Corporation
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+  * Neither the name of Intel Corporation nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+  WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+*/
+#include <iterator>
+#include <algorithm>
+#include <tbb/task.h>
+
+#include "pss_common.h"
+
+namespace pss {
+
+namespace internal {
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename Compare>
+class merge_task: public tbb::task {
+    tbb::task* execute();
+    RandomAccessIterator1 xs, xe;
+    RandomAccessIterator2 ys, ye;
+    RandomAccessIterator3 zs;
+    Compare comp;
+    bool destroy;
+public:
+    merge_task( RandomAccessIterator1 xs_, RandomAccessIterator1 xe_, RandomAccessIterator2 ys_, RandomAccessIterator2 ye_, RandomAccessIterator3 zs_, bool destroy_, Compare comp_ ) :
+        xs(xs_), xe(xe_), ys(ys_), ye(ye_), zs(zs_), comp(comp_), destroy(destroy_)
+    {}
+};
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename RandomAccessIterator3, typename Compare>
+tbb::task* merge_task<RandomAccessIterator1,RandomAccessIterator2,RandomAccessIterator3,Compare>::execute() {
+    const size_t MERGE_CUT_OFF = 2000;
+    auto n = (xe-xs) + (ye-ys);
+    if( (size_t) n <= MERGE_CUT_OFF ) {
+        serial_move_merge( xs, xe, ys, ye, zs, comp );
+        if( destroy ) {
+            serial_destroy(xs,xe);
+            serial_destroy(ys,ye);
+        }
+        return NULL;
+    } else {
+        RandomAccessIterator1 xm;
+        RandomAccessIterator2 ym;
+        if( xe-xs < ye-ys  ) {
+            ym = ys+(ye-ys)/2;
+            xm = std::upper_bound(xs,xe,*ym,comp);
+        } else {
+            xm = xs+(xe-xs)/2;
+            ym = std::lower_bound(ys,ye,*xm,comp);
+        }
+        RandomAccessIterator3 zm = zs + ((xm-xs) + (ym-ys));
+        tbb::task* right = new( allocate_additional_child_of(*parent()) ) merge_task( xm, xe, ym, ye, zm, destroy, comp );
+        spawn(*right);
+        recycle_as_continuation();
+        xe = xm;
+        ye = ym;
+        return this;
+    }
+}
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+class stable_sort_task: public tbb::task {
+    tbb::task* execute();
+    RandomAccessIterator1 xs, xe;
+    RandomAccessIterator2 zs;
+    Compare comp;
+    signed char inplace;
+public:
+    stable_sort_task(RandomAccessIterator1 xs_, RandomAccessIterator1 xe_, RandomAccessIterator2 zs_, int inplace_, Compare comp_ ) : 
+        xs(xs_), xe(xe_), zs(zs_), comp(comp_), inplace(inplace_)
+    {}
+};
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+tbb::task* stable_sort_task<RandomAccessIterator1, RandomAccessIterator2, Compare>::execute() {
+    const size_t SORT_CUT_OFF = 500;
+    if ((size_t) (xe - xs) <= SORT_CUT_OFF) {
+        stable_sort_base_case(xs, xe, zs, inplace, comp); 
+        return NULL;
+    } else {
+        RandomAccessIterator1 xm = xs + (xe - xs) / 2;
+        RandomAccessIterator2 zm = zs + (xm - xs);
+        RandomAccessIterator2 ze = zs + (xe - xs);
+        task* m;
+        if (inplace)
+            m = new (allocate_continuation()) merge_task<RandomAccessIterator2,RandomAccessIterator2,RandomAccessIterator1,Compare>(zs, zm, zm, ze, xs, inplace==2, comp);
+        else
+            m = new (allocate_continuation()) merge_task<RandomAccessIterator1,RandomAccessIterator1,RandomAccessIterator2,Compare>(xs, xm, xm, xe, zs, false, comp);
+        m->set_ref_count(2);
+        task* right = new(m->allocate_child()) stable_sort_task(xm,xe,zm,!inplace, comp);
+        spawn(*right);
+        recycle_as_child_of(*m); 
+        xe=xm;
+        inplace=!inplace;
+        return this;
+    }
+}
+
+} // namespace internal 
+
+template<typename RandomAccessIterator, typename Compare>
+void parallel_stable_sort( RandomAccessIterator xs, RandomAccessIterator xe, Compare comp ) {
+    typedef typename std::iterator_traits<RandomAccessIterator>::value_type T;
+    if( internal::raw_buffer z = internal::raw_buffer( sizeof(T)*(xe-xs) ) ) {
+        using tbb::task;
+        typedef typename std::iterator_traits<RandomAccessIterator>::value_type T;
+        internal::raw_buffer buf( sizeof(T)*(xe-xs) );
+        task::spawn_root_and_wait(*new( task::allocate_root() ) internal::stable_sort_task<RandomAccessIterator,T*,Compare>( xs, xe, (T*)buf.get(), 2, comp ));
+    } else
+        // Not enough memory available - fall back on serial sort
+        std::stable_sort( xs, xe, comp );
+}
+
+} // namespace pss

intern/instant-meshes/ext/pss/pss_common.h

@@ -0,0 +1,106 @@
+/*
+  Copyright (C) 2014 Intel Corporation
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+  * Neither the name of Intel Corporation nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+  WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  POSSIBILITY OF SUCH DAMAGE.
+*/
+#include <utility>
+#include <iterator>
+
+namespace pss {
+
+namespace internal {
+
+//! Destroy sequence [xs,xe)
+template<class RandomAccessIterator>
+void serial_destroy( RandomAccessIterator zs, RandomAccessIterator ze ) {
+    typedef typename std::iterator_traits<RandomAccessIterator>::value_type T;
+    while( zs!=ze ) {
+        --ze;
+        (*ze).~T();
+    }
+}
+
+//! Merge sequences [xs,xe) and [ys,ye) to output sequence [zs,(xe-xs)+(ye-ys)), using std::move
+template<class RandomAccessIterator1, class RandomAccessIterator2, class RandomAccessIterator3, class Compare>
+void serial_move_merge( RandomAccessIterator1 xs, RandomAccessIterator1 xe, RandomAccessIterator2 ys, RandomAccessIterator2 ye, RandomAccessIterator3 zs, Compare comp ) {
+    if( xs!=xe ) {
+        if( ys!=ye ) {
+            for(;;) {
+                if( comp(*ys,*xs) ) {
+                    *zs = std::move(*ys);
+                    ++zs;
+                    if( ++ys==ye ) { break; }
+                } else {
+                    *zs = std::move(*xs);
+                    ++zs;
+                    if( ++xs==xe ) { goto movey; }
+                }
+            }
+        }
+        ys = xs;
+        ye = xe;
+    }
+movey:
+    std::move( ys, ye, zs );
+}
+
+template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Compare>
+void stable_sort_base_case(  RandomAccessIterator1 xs, RandomAccessIterator1 xe, RandomAccessIterator2 zs, int inplace, Compare comp) {
+    std::stable_sort( xs, xe, comp );
+    if( inplace!=2 ) {
+        RandomAccessIterator2 ze = zs + (xe-xs);
+        typedef typename std::iterator_traits<RandomAccessIterator2>::value_type T;
+        if( inplace )
+            // Initialize the temporary buffer
+            for( ; zs<ze; ++zs )
+                new(&*zs) T;
+        else
+            // Initialize the temporary buffer and move keys to it.
+            for( ; zs<ze; ++xs, ++zs )
+                new(&*zs) T(std::move(*xs));
+    }
+}
+
+//! Raw memory buffer with automatic cleanup.
+class raw_buffer {
+    void* ptr;
+public:
+    //! Try to obtain buffer of given size.
+    raw_buffer( size_t bytes ) : ptr( operator new(bytes,std::nothrow) ) {}
+    //! True if buffer was successfully obtained, zero otherwise.
+    operator bool() const {return ptr;}
+    //! Return pointer to buffer, or  NULL if buffer could not be obtained.
+    void* get() const {return ptr;}
+    //! Destroy buffer
+    ~raw_buffer() {operator delete(ptr);}
+};
+
+} // namespace internal
+
+} // namespace pss

intern/instant-meshes/ext/rply/LICENSE

@@ -0,0 +1,20 @@
+RPly 1.1.3 license
+Copyright <20> 2003-2013 Diego Nehab.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

intern/instant-meshes/ext/rply/rply.h

@@ -0,0 +1,376 @@
+#ifndef RPLY_H
+#define RPLY_H
+/* ----------------------------------------------------------------------
+ * RPly library, read/write PLY files
+ * Diego Nehab, IMPA
+ * http://www.impa.br/~diego/software/rply
+ *
+ * This library is distributed under the MIT License. See notice
+ * at the end of this file.
+ * ---------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RPLY_VERSION   "RPly 1.1.3"
+#define RPLY_COPYRIGHT "Copyright (C) 2003-2013 Diego Nehab"
+#define RPLY_AUTHORS   "Diego Nehab"
+
+/* ----------------------------------------------------------------------
+ * Types
+ * ---------------------------------------------------------------------- */
+/* structures are opaque */
+typedef struct t_ply_ *p_ply;
+typedef struct t_ply_element_ *p_ply_element;
+typedef struct t_ply_property_ *p_ply_property;
+typedef struct t_ply_argument_ *p_ply_argument;
+
+/* ply format mode type */
+typedef enum e_ply_storage_mode_ {
+    PLY_BIG_ENDIAN,
+    PLY_LITTLE_ENDIAN,
+    PLY_ASCII,   
+    PLY_DEFAULT      /* has to be the last in enum */
+} e_ply_storage_mode; /* order matches ply_storage_mode_list */
+
+/* ply data type */
+typedef enum e_ply_type {
+    PLY_INT8, PLY_UINT8, PLY_INT16, PLY_UINT16, 
+    PLY_INT32, PLY_UINT32, PLY_FLOAT32, PLY_FLOAT64,
+    PLY_CHAR, PLY_UCHAR, PLY_SHORT, PLY_USHORT,
+    PLY_INT, PLY_UINT, PLY_FLOAT, PLY_DOUBLE,
+    PLY_LIST    /* has to be the last in enum */
+} e_ply_type;   /* order matches ply_type_list */
+
+/* ----------------------------------------------------------------------
+ * Error callback prototype
+ *
+ * message: error message
+ * ply: handle returned by ply_open or ply_create
+ * ---------------------------------------------------------------------- */
+typedef void (*p_ply_error_cb)(p_ply ply, const char *message);
+
+/* ----------------------------------------------------------------------
+ * Gets user data from within an error callback 
+ *
+ * ply: handle returned by ply_open or ply_create
+ * idata,pdata: contextual information set in ply_open or ply_create
+ * ---------------------------------------------------------------------- */
+int ply_get_ply_user_data(p_ply ply, void **pdata, long *idata);
+
+/* ----------------------------------------------------------------------
+ * Opens a PLY file for reading (fails if file is not a PLY file)
+ *
+ * name: file name
+ * error_cb: error callback function
+ * idata,pdata: contextual information available to users
+ *
+ * Returns 1 if successful, 0 otherwise
+ * ---------------------------------------------------------------------- */
+p_ply ply_open(const char *name, p_ply_error_cb error_cb, long idata, 
+        void *pdata);
+
+/* ----------------------------------------------------------------------
+ * Reads and parses the header of a PLY file returned by ply_open
+ *
+ * ply: handle returned by ply_open
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_read_header(p_ply ply);
+
+/* ----------------------------------------------------------------------
+ * Property reading callback prototype
+ *
+ * argument: parameters for property being processed when callback is called
+ *
+ * Returns 1 if should continue processing file, 0 if should abort.
+ * ---------------------------------------------------------------------- */
+typedef int (*p_ply_read_cb)(p_ply_argument argument);
+
+/* ----------------------------------------------------------------------
+ * Sets up callbacks for property reading after header was parsed
+ *
+ * ply: handle returned by ply_open
+ * element_name: element where property is
+ * property_name: property to associate element with
+ * read_cb: function to be called for each property value
+ * pdata/idata: user data that will be passed to callback
+ *
+ * Returns 0 if no element or no property in element, returns the
+ * number of element instances otherwise. 
+ * ---------------------------------------------------------------------- */
+long ply_set_read_cb(p_ply ply, const char *element_name, 
+        const char *property_name, p_ply_read_cb read_cb, 
+        void *pdata, long idata);
+
+/* ----------------------------------------------------------------------
+ * Returns information about the element originating a callback
+ *
+ * argument: handle to argument 
+ * element: receives a the element handle (if non-null)
+ * instance_index: receives the index of the current element instance 
+ *     (if non-null)
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_get_argument_element(p_ply_argument argument, 
+        p_ply_element *element, long *instance_index);
+
+/* ----------------------------------------------------------------------
+ * Returns information about the property originating a callback
+ *
+ * argument: handle to argument 
+ * property: receives the property handle (if non-null)
+ * length: receives the number of values in this property (if non-null)
+ * value_index: receives the index of current property value (if non-null)
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_get_argument_property(p_ply_argument argument, 
+        p_ply_property *property, long *length, long *value_index);
+
+/* ----------------------------------------------------------------------
+ * Returns user data associated with callback 
+ *
+ * pdata: receives a copy of user custom data pointer (if non-null)
+ * idata: receives a copy of user custom data integer (if non-null)
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_get_argument_user_data(p_ply_argument argument, void **pdata, 
+        long *idata);
+
+/* ----------------------------------------------------------------------
+ * Returns the value associated with a callback
+ *
+ * argument: handle to argument 
+ *
+ * Returns the current data item
+ * ---------------------------------------------------------------------- */
+double ply_get_argument_value(p_ply_argument argument); 
+
+/* ----------------------------------------------------------------------
+ * Reads all elements and properties calling the callbacks defined with
+ * calls to ply_set_read_cb
+ *
+ * ply: handle returned by ply_open
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_read(p_ply ply);
+
+/* ----------------------------------------------------------------------
+ * Iterates over all elements by returning the next element.
+ * Call with NULL to return handle to first element.
+ *
+ * ply: handle returned by ply_open
+ * last: handle of last element returned (NULL for first element)
+ *
+ * Returns element if successfull or NULL if no more elements
+ * ---------------------------------------------------------------------- */
+p_ply_element ply_get_next_element(p_ply ply, p_ply_element last);
+
+/* ----------------------------------------------------------------------
+ * Iterates over all comments by returning the next comment.
+ * Call with NULL to return pointer to first comment.
+ *
+ * ply: handle returned by ply_open
+ * last: pointer to last comment returned (NULL for first comment)
+ *
+ * Returns comment if successfull or NULL if no more comments
+ * ---------------------------------------------------------------------- */
+const char *ply_get_next_comment(p_ply ply, const char *last);
+
+/* ----------------------------------------------------------------------
+ * Iterates over all obj_infos by returning the next obj_info.
+ * Call with NULL to return pointer to first obj_info.
+ *
+ * ply: handle returned by ply_open
+ * last: pointer to last obj_info returned (NULL for first obj_info)
+ *
+ * Returns obj_info if successfull or NULL if no more obj_infos
+ * ---------------------------------------------------------------------- */
+const char *ply_get_next_obj_info(p_ply ply, const char *last);
+
+/* ----------------------------------------------------------------------
+ * Returns information about an element
+ *
+ * element: element of interest
+ * name: receives a pointer to internal copy of element name (if non-null)
+ * ninstances: receives the number of instances of this element (if non-null)
+ *
+ * Returns 1 if successfull or 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_get_element_info(p_ply_element element, const char** name,
+        long *ninstances);
+
+/* ----------------------------------------------------------------------
+ * Iterates over all properties by returning the next property.
+ * Call with NULL to return handle to first property.
+ *
+ * element: handle of element with the properties of interest
+ * last: handle of last property returned (NULL for first property)
+ *
+ * Returns element if successfull or NULL if no more properties
+ * ---------------------------------------------------------------------- */
+p_ply_property ply_get_next_property(p_ply_element element, 
+        p_ply_property last);
+
+/* ----------------------------------------------------------------------
+ * Returns information about a property
+ *
+ * property: handle to property of interest
+ * name: receives a pointer to internal copy of property name (if non-null)
+ * type: receives the property type (if non-null)
+ * length_type: for list properties, receives the scalar type of
+ *     the length field (if non-null)
+ * value_type: for list properties, receives the scalar type of the value 
+ *     fields  (if non-null)
+ *
+ * Returns 1 if successfull or 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_get_property_info(p_ply_property property, const char** name,
+        e_ply_type *type, e_ply_type *length_type, e_ply_type *value_type);
+
+/* ----------------------------------------------------------------------
+ * Creates new PLY file
+ *
+ * name: file name
+ * storage_mode: file format mode
+ *
+ * Returns handle to PLY file if successfull, NULL otherwise
+ * ---------------------------------------------------------------------- */
+p_ply ply_create(const char *name, e_ply_storage_mode storage_mode, 
+        p_ply_error_cb error_cb, long idata, void *pdata);
+
+/* ----------------------------------------------------------------------
+ * Adds a new element to the PLY file created by ply_create
+ *
+ * ply: handle returned by ply_create
+ * name: name of new element
+ * ninstances: number of element of this time in file
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_element(p_ply ply, const char *name, long ninstances);
+
+/* ----------------------------------------------------------------------
+ * Adds a new property to the last element added by ply_add_element
+ *
+ * ply: handle returned by ply_create
+ * name: name of new property
+ * type: property type
+ * length_type: scalar type of length field of a list property 
+ * value_type: scalar type of value fields of a list property
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_property(p_ply ply, const char *name, e_ply_type type,
+        e_ply_type length_type, e_ply_type value_type);
+
+/* ----------------------------------------------------------------------
+ * Adds a new list property to the last element added by ply_add_element
+ *
+ * ply: handle returned by ply_create
+ * name: name of new property
+ * length_type: scalar type of length field of a list property 
+ * value_type: scalar type of value fields of a list property
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_list_property(p_ply ply, const char *name, 
+        e_ply_type length_type, e_ply_type value_type);
+
+/* ----------------------------------------------------------------------
+ * Adds a new property to the last element added by ply_add_element
+ *
+ * ply: handle returned by ply_create
+ * name: name of new property
+ * type: property type
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_scalar_property(p_ply ply, const char *name, e_ply_type type);
+
+/* ----------------------------------------------------------------------
+ * Adds a new comment item 
+ *
+ * ply: handle returned by ply_create
+ * comment: pointer to string with comment text
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_comment(p_ply ply, const char *comment);
+
+/* ----------------------------------------------------------------------
+ * Adds a new obj_info item 
+ *
+ * ply: handle returned by ply_create
+ * comment: pointer to string with obj_info data
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_add_obj_info(p_ply ply, const char *obj_info);
+
+/* ----------------------------------------------------------------------
+ * Writes the PLY file header after all element and properties have been
+ * defined by calls to ply_add_element and ply_add_property
+ *
+ * ply: handle returned by ply_create
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_write_header(p_ply ply);
+
+/* ----------------------------------------------------------------------
+ * Writes one property value, in the order they should be written to the
+ * file. For each element type, write all elements of that type in order.
+ * For each element, write all its properties in order. For scalar
+ * properties, just write the value. For list properties, write the length 
+ * and then each of the values.
+ *
+ * ply: handle returned by ply_create
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_write(p_ply ply, double value);
+
+/* ----------------------------------------------------------------------
+ * Closes a PLY file handle. Releases all memory used by handle
+ *
+ * ply: handle to be closed. 
+ *
+ * Returns 1 if successfull, 0 otherwise
+ * ---------------------------------------------------------------------- */
+int ply_close(p_ply ply);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* RPLY_H */
+
+/* ----------------------------------------------------------------------
+ * Copyright (C) 2003-2011 Diego Nehab. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * ---------------------------------------------------------------------- */

intern/instant-meshes/instant_meshes_c_api.h

@@ -0,0 +1,63 @@
+#pragma once
+
+//#define INSTANT_MESHES_VIS_COLOR
+
+/* clang-format off */
+//remeshedge->flag
+enum {
+  REMESH_EDGE_BOUNDARY = (1<<0),
+  REMESH_EDGE_USE_DIR = (1<<1)
+};
+/* clang-format on */
+
+typedef struct RemeshVertex {
+  float co[3], no[3];
+#ifdef INSTANT_MESHES_VIS_COLOR
+  float viscolor[3];
+#endif
+} RemeshVertex;
+
+// edge constraint
+typedef struct RemeshEdge {
+  int v1, v2, flag;
+  float dir[3];
+} RemeshEdge;
+
+typedef struct RemeshTri {
+  int v1, v2, v3;
+  int eflags[3];
+} RemeshTri;
+
+typedef struct RemeshOutFace {
+  int *verts;
+  int totvert;
+} RemeshOutFace;
+
+typedef struct RemeshMesh {
+  RemeshTri *tris;
+  RemeshVertex *verts;
+  RemeshEdge *edges;  // list of constrained edges, need not be all edges in the mesh
+
+  int tottri, totvert, totedge;
+
+  RemeshOutFace *outfaces;
+  RemeshVertex *outverts;
+  int *out_scracth;
+
+  int totoutface;
+  int totoutvert;
+
+  int goal_faces, iterations;
+} RemeshMesh;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void instant_meshes_run(RemeshMesh *mesh);
+void instant_meshes_finish(RemeshMesh *mesh);
+void instant_meshes_set_number_of_threads(int n);
+
+#ifdef __cplusplus
+}
+#endif

intern/instant-meshes/src/aabb.h

@@ -0,0 +1,124 @@
+/*
+    aabb.h -- basic axis-aligned bounding box & ray intersection code
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+struct Ray {
+    Vector3f o, d;
+    Float mint, maxt;
+
+    Ray(const Vector3f &o, const Vector3f &d) :
+        o(o), d(d), mint(0), maxt(std::numeric_limits<Float>::infinity()) { }
+
+    Ray(const Vector3f &o, const Vector3f &d, Float mint, Float maxt) :
+        o(o), d(d), mint(mint), maxt(maxt) { }
+
+    Vector3f operator()(Float t) const { return o + t*d; }
+};
+
+struct AABB {
+    Vector3f min, max;
+
+    AABB() { clear(); }
+
+    AABB(const Vector3f &min, const Vector3f &max) : min(min), max(max) {}
+
+    void clear() {
+        const Float inf = std::numeric_limits<Float>::infinity();
+        min.setConstant(inf);
+        max.setConstant(-inf);
+    }
+
+    void expandBy(const Vector3f &p) {
+        min = min.cwiseMin(p);
+        max = max.cwiseMax(p);
+    }
+
+    void expandBy(const AABB &aabb) {
+        min = min.cwiseMin(aabb.min);
+        max = max.cwiseMax(aabb.max);
+    }
+
+    bool contains(const Vector3f &p) {
+        return (p.array() >= min.array()).all() &&
+               (p.array() <= max.array()).all();
+    }
+
+    bool rayIntersect(const Ray &ray) const {
+        Float nearT = -std::numeric_limits<Float>::infinity();
+        Float farT = std::numeric_limits<Float>::infinity();
+
+        for (int i=0; i<3; i++) {
+            Float origin = ray.o[i];
+            Float minVal = min[i], maxVal = max[i];
+
+            if (ray.d[i] == 0) {
+                if (origin < minVal || origin > maxVal)
+                    return false;
+            } else {
+                Float t1 = (minVal - origin) / ray.d[i];
+                Float t2 = (maxVal - origin) / ray.d[i];
+
+                if (t1 > t2)
+                    std::swap(t1, t2);
+
+                nearT = std::max(t1, nearT);
+                farT = std::min(t2, farT);
+
+                if (!(nearT <= farT))
+                    return false;
+            }
+        }
+
+        return ray.mint <= farT && nearT <= ray.maxt;
+    }
+
+    Float squaredDistanceTo(const Vector3f &p) const {
+        Float result = 0;
+        for (int i=0; i<3; ++i) {
+            Float value = 0;
+            if (p[i] < min[i])
+                value = min[i] - p[i];
+            else if (p[i] > max[i])
+                value = p[i] - max[i];
+            result += value*value;
+        }
+        return result;
+    }
+
+    int largestAxis() const {
+        Vector3f extents = max-min;
+
+        if (extents[0] >= extents[1] && extents[0] >= extents[2])
+            return 0;
+        else if (extents[1] >= extents[0] && extents[1] >= extents[2])
+            return 1;
+        else
+            return 2;
+    }
+
+    Float surfaceArea() const {
+        Vector3f d = max - min;
+        return 2.0f * (d[0]*d[1] + d[0]*d[2] + d[1]*d[2]);
+    }
+
+    Vector3f center() const {
+        return 0.5f * (min + max);
+    }
+
+    static AABB merge(const AABB &aabb1, const AABB &aabb2) {
+        return AABB(aabb1.min.cwiseMin(aabb2.min), aabb1.max.cwiseMax(aabb2.max));
+    }
+};

intern/instant-meshes/src/adjacency.cpp

@@ -0,0 +1,339 @@
+/*
+    aabb.cpp -- functionality for creating adjacency matrices together with
+                uniform or cotangent weights. Also contains data structures
+                used to store integer variables.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "adjacency.h"
+#include "dedge.h"
+#include "bvh.h"
+#include "meshstats.h"
+#include "dset.h"
+#include <set>
+#include <map>
+
+AdjacencyMatrix generate_adjacency_matrix_uniform(
+    const MatrixXu &F, const VectorXu &V2E, const VectorXu &E2E,
+    const VectorXb &nonManifold, const ProgressCallback &progress) {
+    VectorXu neighborhoodSize(V2E.size() + 1);
+    cout << "Generating adjacency matrix .. ";
+    cout.flush();
+    Timer<> timer;
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V2E.size(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID) {
+                    neighborhoodSize[i+1] = 0;
+                    continue;
+                }
+                uint32_t nNeighbors = 0;
+                do {
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID) {
+                        nNeighbors += 2;
+                        break;
+                    }
+                    edge = dedge_next_3(opp);
+                    nNeighbors++;
+                } while (edge != stop);
+                neighborhoodSize[i+1] = nNeighbors;
+            }
+            SHOW_PROGRESS_RANGE(range, V2E.size(), "Generating adjacency matrix (1/2)");
+        }
+    );
+
+    neighborhoodSize[0] = 0;
+    for (uint32_t i=0; i<neighborhoodSize.size()-1; ++i)
+        neighborhoodSize[i+1] += neighborhoodSize[i];
+
+    AdjacencyMatrix adj = new Link*[V2E.size() + 1];
+    uint32_t nLinks = neighborhoodSize[neighborhoodSize.size()-1];
+    Link *links = new Link[nLinks];
+    for (uint32_t i=0; i<neighborhoodSize.size(); ++i)
+        adj[i] = links + neighborhoodSize[i];
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V2E.size(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID)
+                    continue;
+                Link *ptr = adj[i];
+
+                int it = 0;
+                do {
+                    uint32_t base = edge % 3, f = edge / 3;
+                    uint32_t opp = E2E[edge], next = dedge_next_3(opp);
+                    if (it == 0)
+                        *ptr++ = Link(F((base + 2)%3, f));
+                    if (opp == INVALID || next != stop) {
+                        *ptr++ = Link(F((base + 1)%3, f));
+                        if (opp == INVALID)
+                            break;
+                    }
+                    edge = next;
+                    ++it;
+                } while (edge != stop);
+            }
+            SHOW_PROGRESS_RANGE(range, V2E.size(), "Generating adjacency matrix (2/2)");
+        }
+    );
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+
+    return adj;
+}
+
+AdjacencyMatrix
+generate_adjacency_matrix_cotan(const MatrixXu &F, const MatrixXf &V,
+                                const VectorXu &V2E, const VectorXu &E2E,
+                                const VectorXb &nonManifold,
+                                const ProgressCallback &progress) {
+    VectorXu neighborhoodSize(V2E.size() + 1);
+    cout << "Computing cotangent Laplacian .. ";
+    cout.flush();
+    Timer<> timer;
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V2E.size(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID) {
+                    neighborhoodSize[i+1] = 0;
+                    continue;
+                }
+                uint32_t nNeighbors = 0;
+                do {
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID) {
+                        nNeighbors += 2;
+                        break;
+                    }
+                    edge = dedge_next_3(opp);
+                    nNeighbors++;
+                } while (edge != stop);
+                neighborhoodSize[i+1] = nNeighbors;
+            }
+            SHOW_PROGRESS_RANGE(range, V2E.size(), "Computing cotangent Laplacian (1/2)");
+        }
+    );
+
+    neighborhoodSize[0] = 0;
+    for (uint32_t i=0; i<neighborhoodSize.size()-1; ++i)
+        neighborhoodSize[i+1] += neighborhoodSize[i];
+
+    AdjacencyMatrix adj = new Link*[V2E.size() + 1];
+    uint32_t nLinks = neighborhoodSize[neighborhoodSize.size()-1];
+    Link *links = new Link[nLinks];
+    for (uint32_t i=0; i<neighborhoodSize.size(); ++i)
+        adj[i] = links + neighborhoodSize[i];
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t)V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID)
+                    continue;
+                Link *ptr = adj[i];
+
+                int it = 0;
+                do {
+                    uint32_t f = edge / 3, curr_idx = edge % 3,
+                             next_idx = (curr_idx + 1) % 3,
+                             prev_idx = (curr_idx + 2) % 3;
+
+                    if (it == 0) {
+                        Vector3f p  = V.col(F(next_idx, f)),
+                                 d0 = V.col(F(prev_idx, f)) - p,
+                                 d1 = V.col(F(curr_idx, f)) - p;
+                        Float cot_weight = 0.0f,
+                              sin_alpha = d0.cross(d1).norm();
+                        if (sin_alpha > RCPOVERFLOW)
+                            cot_weight = d0.dot(d1) / sin_alpha;
+
+                        uint32_t opp = E2E[dedge_prev_3(edge)];
+                        if (opp != INVALID) {
+                            uint32_t o_f = opp / 3, o_curr_idx = opp % 3,
+                                     o_next_idx = (o_curr_idx + 1) % 3,
+                                     o_prev_idx = (o_curr_idx + 2) % 3;
+                            p  = V.col(F(o_prev_idx, o_f));
+                            d0 = V.col(F(o_curr_idx, o_f)) - p;
+                            d1 = V.col(F(o_next_idx, o_f)) - p;
+                            sin_alpha = d0.cross(d1).norm();
+                            if (sin_alpha > RCPOVERFLOW)
+                                cot_weight += d0.dot(d1) / sin_alpha;
+                        }
+
+                        *ptr++ = Link(F(prev_idx, f), (float) cot_weight * 0.5f);
+                    }
+                    uint32_t opp = E2E[edge], next = dedge_next_3(opp);
+                    if (opp == INVALID || next != stop) {
+                        Vector3f p  = V.col(F(prev_idx, f)),
+                                 d0 = V.col(F(curr_idx, f)) - p,
+                                 d1 = V.col(F(next_idx, f)) - p;
+                        Float cot_weight = 0.0f,
+                              sin_alpha = d0.cross(d1).norm();
+                        if (sin_alpha > RCPOVERFLOW)
+                            cot_weight = d0.dot(d1) / sin_alpha;
+
+                        if (opp != INVALID) {
+                            uint32_t o_f = opp / 3, o_curr_idx = opp % 3,
+                                     o_next_idx = (o_curr_idx + 1) % 3,
+                                     o_prev_idx = (o_curr_idx + 2) % 3;
+                            p  = V.col(F(o_prev_idx, o_f));
+                            d0 = V.col(F(o_curr_idx, o_f)) - p;
+                            d1 = V.col(F(o_next_idx, o_f)) - p;
+                            sin_alpha = d0.cross(d1).norm();
+                            if (sin_alpha > RCPOVERFLOW)
+                                cot_weight += d0.dot(d1) / sin_alpha;
+                        }
+
+                        *ptr++ = Link(F(next_idx, f), (float) cot_weight * 0.5f);
+                        if (opp == INVALID)
+                            break;
+                    }
+                    edge = next;
+                    ++it;
+                } while (edge != stop);
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing cotangent Laplacian (2/2)");
+        }
+    );
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+    return adj;
+}
+
+AdjacencyMatrix generate_adjacency_matrix_pointcloud(
+    MatrixXf &V, MatrixXf &N, const BVH *bvh, MeshStats &stats, uint32_t knn_points,
+    bool deterministic, const ProgressCallback &progress) {
+    Timer<> timer;
+    cout << "Generating adjacency matrix .. ";
+    cout.flush();
+
+    stats.mAverageEdgeLength = bvh->diskRadius();
+    const Float maxQueryRadius = bvh->diskRadius() * 3;
+
+    uint32_t *adj_sets = new uint32_t[V.cols() * (size_t) knn_points];
+
+    DisjointSets dset(V.cols());
+    VectorXu adj_size(V.cols());
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            std::vector<std::pair<Float, uint32_t>> result;
+            for (uint32_t i = range.begin(); i < range.end(); ++i) {
+                uint32_t *adj_set = adj_sets + (size_t) i * (size_t) knn_points;
+                memset(adj_set, 0xFF, sizeof(uint32_t) * knn_points);
+                Float radius = maxQueryRadius;
+                bvh->findKNearest(V.col(i), N.col(i), knn_points, radius, result);
+                uint32_t ctr = 0;
+                for (auto k : result) {
+                    if (k.second == i)
+                        continue;
+                    adj_set[ctr++] = k.second;
+                    dset.unite(k.second, i);
+                }
+                adj_size[i] = ctr;
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Generating adjacency matrix");
+        }
+    );
+
+    std::map<uint32_t, uint32_t> dset_size;
+    for (uint32_t i=0; i<V.cols(); ++i) {
+        dset_size[dset.find(i)]++;
+        uint32_t *adj_set_i = adj_sets + (size_t) i * (size_t) knn_points;
+
+        for (uint32_t j=0; j<knn_points; ++j) {
+            uint32_t k = adj_set_i[j];
+            if (k == INVALID)
+                break;
+            uint32_t *adj_set_k = adj_sets + (size_t) k * (size_t) knn_points;
+            bool found = false;
+            for (uint32_t l=0; l<knn_points; ++l) {
+                uint32_t value = adj_set_k[l];
+                if (value == i) { found = true; break; }
+                if (value == INVALID) break;
+            }
+            if (!found)
+                adj_size[k]++;
+        }
+    }
+
+    size_t nLinks = 0;
+    for (uint32_t i=0; i<V.cols(); ++i) {
+        uint32_t dsetSize = dset_size[dset.find(i)];
+        if (dsetSize < V.cols() * 0.01f) {
+            adj_size[i] = INVALID;
+            V.col(i) = Vector3f::Constant(1e6);
+            continue;
+        }
+        nLinks += adj_size[i];
+    }
+
+    cout << "allocating " << memString(sizeof(Link) * nLinks) << " .. ";
+    cout.flush();
+
+    AdjacencyMatrix adj = new Link*[V.size() + 1];
+    adj[0] = new Link[nLinks];
+    for (uint32_t i=1; i<=V.cols(); ++i) {
+        uint32_t size = adj_size[i-1];
+        if (size == INVALID)
+            size = 0;
+        adj[i] = adj[i-1] + size;
+    }
+
+    VectorXu adj_offset(V.cols());
+    adj_offset.setZero();
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i < range.end(); ++i) {
+                uint32_t *adj_set_i = adj_sets + (size_t) i * (size_t) knn_points;
+                if (adj_size[i] == INVALID)
+                    continue;
+
+                for (uint32_t j=0; j<knn_points; ++j) {
+                    uint32_t k = adj_set_i[j];
+                    if (k == INVALID)
+                        break;
+                    adj[i][atomicAdd(&adj_offset.coeffRef(i), 1)-1] = Link(k);
+
+                    uint32_t *adj_set_k = adj_sets + (size_t) k * (size_t) knn_points;
+                    bool found = false;
+                    for (uint32_t l=0; l<knn_points; ++l) {
+                        uint32_t value = adj_set_k[l];
+                        if (value == i) { found = true; break; }
+                        if (value == INVALID) break;
+                    }
+                    if (!found)
+                        adj[k][atomicAdd(&adj_offset.coeffRef(k), 1)-1] = Link(i);
+                }
+            }
+        }
+    );
+
+    /* Use a heuristic to estimate some useful quantities for point clouds (this
+       is a biased estimate due to the kNN queries, but it's convenient and
+       reasonably accurate) */
+    stats.mSurfaceArea = M_PI * stats.mAverageEdgeLength*stats.mAverageEdgeLength * 0.5f * V.cols();
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+    return adj;
+}

intern/instant-meshes/src/adjacency.h

@@ -0,0 +1,77 @@
+/*
+    aabb.h -- functionality for creating adjacency matrices together with
+              uniform or cotangent weights. Also contains data structures
+              used to store integer variables.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+/* Stores integer jumps between nodes of the adjacency matrix */
+struct IntegerVariable {
+    unsigned short rot : 2;
+    signed   short translate_u : 7;
+    signed   short translate_v : 7;
+
+    Vector2i shift() const { 
+        return Vector2i(translate_u, translate_v);
+    }
+
+    void setShift(Vector2i &v) {
+        translate_u = v.x();
+        translate_v = v.y();
+    }
+};
+
+/* Stores a weighted adjacency matrix entry together with integer variables */
+struct Link {
+    uint32_t id;
+    float weight;
+    union {
+        IntegerVariable ivar[2];
+        uint32_t ivar_uint32;
+    };
+
+    inline Link() { }
+    inline Link(uint32_t id) : id(id), weight(1.0f), ivar_uint32(0u) { }
+    inline Link(uint32_t id, float weight) : id(id), weight(weight), ivar_uint32(0u) { }
+
+    inline bool operator<(const Link &link) const { return id < link.id; }
+} ;
+
+typedef Link** AdjacencyMatrix;
+
+extern AdjacencyMatrix generate_adjacency_matrix_uniform(
+    const MatrixXu &F, const VectorXu &V2E,
+    const VectorXu &E2E, const VectorXb &nonManifold,
+    const ProgressCallback &progress = ProgressCallback());
+
+extern AdjacencyMatrix generate_adjacency_matrix_cotan(
+    const MatrixXu &F, const MatrixXf &V, const VectorXu &V2E,
+    const VectorXu &E2E, const VectorXb &nonManifold,
+    const ProgressCallback &progress = ProgressCallback());
+
+inline Link &search_adjacency(AdjacencyMatrix &adj, uint32_t i, uint32_t j) {
+    for (Link* l = adj[i]; l != adj[i+1]; ++l)
+        if (l->id == j)
+            return *l;
+    throw std::runtime_error("search_adjacency: failure!");
+}
+
+class BVH;
+struct MeshStats;
+
+extern AdjacencyMatrix generate_adjacency_matrix_pointcloud(
+    MatrixXf &V, MatrixXf &N, const BVH *bvh, MeshStats &stats,
+    uint32_t knn_points, bool deterministic = false,
+    const ProgressCallback &progress = ProgressCallback());

intern/instant-meshes/src/batch.cpp

@@ -0,0 +1,214 @@
+/*
+    batch.cpp -- command line interface to Instant Meshes
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "batch.h"
+#include "meshio.h"
+#include "dedge.h"
+#include "subdivide.h"
+#include "meshstats.h"
+#include "hierarchy.h"
+#include "field.h"
+#include "normal.h"
+#include "extract.h"
+#include "bvh.h"
+
+void batch_process(const std::string &input, const std::string &output,
+                   int rosy, int posy, Float scale, int face_count,
+                   int vertex_count, Float creaseAngle, bool extrinsic,
+                   bool align_to_boundaries, int smooth_iter, int knn_points,
+                   bool pure_quad, bool deterministic) {
+    cout << endl;
+    cout << "Running in batch mode:" << endl;
+    cout << "   Input file             = " << input << endl;
+    cout << "   Output file            = " << output << endl;
+    cout << "   Rotation symmetry type = " << rosy << endl;
+    cout << "   Position symmetry type = " << (posy==3?6:posy) << endl;
+    cout << "   Crease angle threshold = ";
+    if (creaseAngle > 0)
+        cout << creaseAngle << endl;
+    else
+        cout << "disabled" << endl;
+    cout << "   Extrinsic mode         = " << (extrinsic ? "enabled" : "disabled") << endl;
+    cout << "   Align to boundaries    = " << (align_to_boundaries ? "yes" : "no") << endl;
+    cout << "   kNN points             = " << knn_points << " (only applies to point clouds)"<< endl;
+    cout << "   Fully deterministic    = " << (deterministic ? "yes" : "no") << endl;
+    if (posy == 4)
+        cout << "   Output mode            = " << (pure_quad ? "pure quad mesh" : "quad-dominant mesh") << endl;
+    cout << endl;
+
+    MatrixXu F;
+    MatrixXf V, N;
+    VectorXf A;
+    std::set<uint32_t> crease_in, crease_out;
+    BVH *bvh = nullptr;
+    AdjacencyMatrix adj = nullptr;
+
+    /* Load the input mesh */
+    load_mesh_or_pointcloud(input, F, V, N);
+
+    bool pointcloud = F.size() == 0;
+
+    Timer<> timer;
+    MeshStats stats = compute_mesh_stats(F, V, deterministic);
+
+    if (pointcloud) {
+        bvh = new BVH(&F, &V, &N, stats.mAABB);
+        bvh->build();
+        adj = generate_adjacency_matrix_pointcloud(V, N, bvh, stats, knn_points, deterministic);
+        A.resize(V.cols());
+        A.setConstant(1.0f);
+    }
+
+    if (scale < 0 && vertex_count < 0 && face_count < 0) {
+        cout << "No target vertex count/face count/scale argument provided. "
+                "Setting to the default of 1/16 * input vertex count." << endl;
+        vertex_count = V.cols() / 16;
+    }
+
+    if (scale > 0) {
+        Float face_area = posy == 4 ? (scale*scale) : (std::sqrt(3.f)/4.f*scale*scale);
+        face_count = stats.mSurfaceArea / face_area;
+        vertex_count = posy == 4 ? face_count : (face_count / 2);
+    } else if (face_count > 0) {
+        Float face_area = stats.mSurfaceArea / face_count;
+        vertex_count = posy == 4 ? face_count : (face_count / 2);
+        scale = posy == 4 ? std::sqrt(face_area) : (2*std::sqrt(face_area * std::sqrt(1.f/3.f)));
+    } else if (vertex_count > 0) {
+        face_count = posy == 4 ? vertex_count : (vertex_count * 2);
+        Float face_area = stats.mSurfaceArea / face_count;
+        scale = posy == 4 ? std::sqrt(face_area) : (2*std::sqrt(face_area * std::sqrt(1.f/3.f)));
+    }
+
+    cout << "Output mesh goals (approximate)" << endl;
+    cout << "   Vertex count           = " << vertex_count << endl;
+    cout << "   Face count             = " << face_count << endl;
+    cout << "   Edge length            = " << scale << endl;
+
+    MultiResolutionHierarchy mRes;
+
+    if (!pointcloud) {
+        /* Subdivide the mesh if necessary */
+        VectorXu V2E, E2E;
+        VectorXb boundary, nonManifold;
+        if (stats.mMaximumEdgeLength*2 > scale || stats.mMaximumEdgeLength > stats.mAverageEdgeLength * 2) {
+            cout << "Input mesh is too coarse for the desired output edge length "
+                    "(max input mesh edge length=" << stats.mMaximumEdgeLength
+                 << "), subdividing .." << endl;
+            build_dedge(F, V, V2E, E2E, boundary, nonManifold);
+            subdivide(F, V, V2E, E2E, boundary, nonManifold, std::min(scale/2, (Float) stats.mAverageEdgeLength*2), deterministic);
+        }
+
+        /* Compute a directed edge data structure */
+        build_dedge(F, V, V2E, E2E, boundary, nonManifold);
+
+        /* Compute adjacency matrix */
+        adj = generate_adjacency_matrix_uniform(F, V2E, E2E, nonManifold);
+
+        /* Compute vertex/crease normals */
+        if (creaseAngle >= 0)
+            generate_crease_normals(F, V, V2E, E2E, boundary, nonManifold, creaseAngle, N, crease_in);
+        else
+            generate_smooth_normals(F, V, V2E, E2E, nonManifold, N);
+
+        /* Compute dual vertex areas */
+        compute_dual_vertex_areas(F, V, V2E, E2E, nonManifold, A);
+
+        mRes.setE2E(std::move(E2E));
+    }
+
+    /* Build multi-resolution hierarrchy */
+    mRes.setAdj(std::move(adj));
+    mRes.setF(std::move(F));
+    mRes.setV(std::move(V));
+    mRes.setA(std::move(A));
+    mRes.setN(std::move(N));
+    mRes.setScale(scale);
+    mRes.build(deterministic);
+    mRes.resetSolution();
+
+    if (align_to_boundaries && !pointcloud) {
+        mRes.clearConstraints();
+        for (uint32_t i=0; i<3*mRes.F().cols(); ++i) {
+            if (mRes.E2E()[i] == INVALID) {
+                uint32_t i0 = mRes.F()(i%3, i/3);
+                uint32_t i1 = mRes.F()((i+1)%3, i/3);
+                Vector3f p0 = mRes.V().col(i0), p1 = mRes.V().col(i1);
+                Vector3f edge = p1-p0;
+                if (edge.squaredNorm() > 0) {
+                    edge.normalize();
+                    mRes.CO().col(i0) = p0;
+                    mRes.CO().col(i1) = p1;
+                    mRes.CQ().col(i0) = mRes.CQ().col(i1) = edge;
+                    mRes.CQw()[i0] = mRes.CQw()[i1] = mRes.COw()[i0] =
+                        mRes.COw()[i1] = 1.0f;
+                }
+            }
+        }
+        mRes.propagateConstraints(rosy, posy);
+    }
+
+    if (bvh) {
+        bvh->setData(&mRes.F(), &mRes.V(), &mRes.N());
+    } else if (smooth_iter > 0) {
+        bvh = new BVH(&mRes.F(), &mRes.V(), &mRes.N(), stats.mAABB);
+        bvh->build();
+    }
+
+    cout << "Preprocessing is done. (total time excluding file I/O: "
+         << timeString(timer.reset()) << ")" << endl;
+
+    Optimizer optimizer(mRes, false);
+    optimizer.setRoSy(rosy);
+    optimizer.setPoSy(posy);
+    optimizer.setExtrinsic(extrinsic);
+
+    cout << "Optimizing orientation field .. ";
+    cout.flush();
+    optimizer.optimizeOrientations(-1);
+    optimizer.notify();
+    optimizer.wait();
+    cout << "done. (took " << timeString(timer.reset()) << ")" << endl;
+
+    std::map<uint32_t, uint32_t> sing;
+    compute_orientation_singularities(mRes, sing, extrinsic, rosy);
+    cout << "Orientation field has " << sing.size() << " singularities." << endl;
+    timer.reset();
+
+    cout << "Optimizing position field .. ";
+    cout.flush();
+    optimizer.optimizePositions(-1);
+    optimizer.notify();
+    optimizer.wait();
+    cout << "done. (took " << timeString(timer.reset()) << ")" << endl;
+    
+    //std::map<uint32_t, Vector2i> pos_sing;
+    //compute_position_singularities(mRes, sing, pos_sing, extrinsic, rosy, posy);
+    //cout << "Position field has " << pos_sing.size() << " singularities." << endl;
+    //timer.reset();
+
+    optimizer.shutdown();
+
+    MatrixXf O_extr, N_extr, Nf_extr;
+    std::vector<std::vector<TaggedLink>> adj_extr;
+    extract_graph(mRes, extrinsic, rosy, posy, adj_extr, O_extr, N_extr,
+                  crease_in, crease_out, deterministic);
+
+    MatrixXu F_extr;
+    extract_faces(adj_extr, O_extr, N_extr, Nf_extr, F_extr, posy,
+            mRes.scale(), crease_out, true, pure_quad, bvh, smooth_iter);
+    cout << "Extraction is done. (total time: " << timeString(timer.reset()) << ")" << endl;
+
+    write_mesh(output, F_extr, O_extr, MatrixXf(), Nf_extr);
+    if (bvh)
+        delete bvh;
+}

intern/instant-meshes/src/batch.h

@@ -0,0 +1,22 @@
+/*
+    batch.h -- command line interface to Instant Meshes
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+extern void batch_process(const std::string &input, const std::string &output,
+                          int rosy, int posy, Float scale, int face_count,
+                          int vertex_count, Float creaseAngle, bool extrinsic,
+                          bool align_to_boundaries, int smooth_iter,
+                          int knn_points, bool dominant, bool deterministic);

intern/instant-meshes/src/bvh.cpp

@@ -0,0 +1,898 @@
+/*
+    bvh.cpp -- bounding volume hierarchy for fast ray-intersection queries
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "bvh.h"
+
+struct Bins {
+    static const int BIN_COUNT = 8;
+    Bins() { memset(counts, 0, sizeof(uint32_t) * BIN_COUNT); }
+    uint32_t counts[BIN_COUNT];
+    AABB bounds[BIN_COUNT];
+};
+
+struct BVHBuildTask : public tbb::task {
+    enum { SERIAL_THRESHOLD = 32 };
+    BVH &bvh;
+    uint32_t node_idx;
+    uint32_t *start, *end, *temp;
+
+    BVHBuildTask(BVH &bvh, uint32_t node_idx, uint32_t *start, uint32_t *end, uint32_t *temp)
+        : bvh(bvh), node_idx(node_idx), start(start), end(end), temp(temp) { }
+
+    task *execute() {
+        const MatrixXu &F = *bvh.mF;
+        const MatrixXf &V = *bvh.mV;
+        bool pointcloud = F.size() == 0;
+        uint32_t size = end-start, total_size = pointcloud ? V.cols() : F.cols();
+        BVHNode &node = bvh.mNodes[node_idx];
+
+        if (size < SERIAL_THRESHOLD) {
+            tbb::blocked_range<uint32_t> range(start-bvh.mIndices, end-bvh.mIndices);
+            const ProgressCallback &progress = bvh.mProgress;
+            SHOW_PROGRESS_RANGE(range, total_size, "Constructing Bounding Volume Hierarchy");
+            execute_serially(bvh, node_idx, start, end, temp);
+            return nullptr;
+        }
+
+        int axis = node.aabb.largestAxis();
+        Float min = node.aabb.min[axis], max = node.aabb.max[axis],
+              inv_bin_size = Bins::BIN_COUNT / (max-min);
+
+        Bins bins = tbb::parallel_reduce(
+            tbb::blocked_range<uint32_t>(0u, size, GRAIN_SIZE),
+            Bins(),
+            [&](const tbb::blocked_range<uint32_t> &range, Bins result) {
+                for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                    uint32_t f = start[i];
+                    Float centroid = pointcloud ? V(axis, f)
+                         : ((1.0f / 3.0f) * (V(axis, F(0, f)) +
+                                             V(axis, F(1, f)) +
+                                             V(axis, F(2, f))));
+
+                    int index = std::min(std::max(
+                        (int) ((centroid - min) * inv_bin_size), 0),
+                        (Bins::BIN_COUNT - 1));
+
+                    result.counts[index]++;
+                    AABB &bin_bounds = result.bounds[index];
+                    if (!pointcloud) {
+                        bin_bounds.expandBy(V.col(F(0, f)));
+                        bin_bounds.expandBy(V.col(F(1, f)));
+                        bin_bounds.expandBy(V.col(F(2, f)));
+                    } else {
+                        bin_bounds.expandBy(V.col(f));
+                    }
+                }
+                return result;
+            },
+            [](const Bins &b1, const Bins &b2) {
+                Bins result;
+                for (int i=0; i < Bins::BIN_COUNT; ++i) {
+                    result.counts[i] = b1.counts[i] + b2.counts[i];
+                    result.bounds[i] = AABB::merge(b1.bounds[i], b2.bounds[i]);
+                }
+                return result;
+            }
+        );
+
+        AABB bounds_left[Bins::BIN_COUNT];
+        bounds_left[0] = bins.bounds[0];
+        for (int i=1; i<Bins::BIN_COUNT; ++i) {
+            bins.counts[i] += bins.counts[i-1];
+            bounds_left[i] = AABB::merge(bounds_left[i-1], bins.bounds[i]);
+        }
+        AABB bounds_right = bins.bounds[Bins::BIN_COUNT-1];
+        int64_t best_index = -1;
+        Float best_cost = BVH::T_tri * size;
+        Float tri_factor = BVH::T_tri / node.aabb.surfaceArea();
+        AABB best_bounds_right;
+
+        for (int i=Bins::BIN_COUNT - 2; i >= 0; --i) {
+            uint32_t prims_left = bins.counts[i], prims_right = (end - start) - bins.counts[i];
+            Float sah_cost = 2.0f * BVH::T_aabb +
+                tri_factor * (prims_left * bounds_left[i].surfaceArea() +
+                              prims_right * bounds_right.surfaceArea());
+            if (sah_cost < best_cost) {
+                best_cost = sah_cost;
+                best_index = i;
+                best_bounds_right = bounds_right;
+            }
+            bounds_right = AABB::merge(bounds_right, bins.bounds[i]);
+        }
+
+        if (best_index == -1) {
+            /* Could not find a good split plane -- retry with
+               more careful serial code just to be sure.. */
+            execute_serially(bvh, node_idx, start, end, temp);
+            return nullptr;
+        }
+
+        uint32_t left_count = bins.counts[best_index];
+        int node_idx_left = node_idx+1;
+        int node_idx_right = node_idx+2*left_count;
+
+        bvh.mNodes[node_idx_left ].aabb = bounds_left[best_index];
+        bvh.mNodes[node_idx_right].aabb = best_bounds_right;
+        node.inner.rightChild = node_idx_right;
+        node.inner.unused = 0;
+
+        std::atomic<uint32_t> offset_left(0), offset_right(bins.counts[best_index]);
+        tbb::parallel_for(
+            tbb::blocked_range<uint32_t>(0u, size, GRAIN_SIZE),
+            [&](const tbb::blocked_range<uint32_t> &range) {
+                uint32_t count_left = 0, count_right = 0;
+                for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                    uint32_t f = start[i];
+                    Float centroid = pointcloud ? V(axis, f)
+                         : ((1.0f / 3.0f) * (V(axis, F(0, f)) +
+                                             V(axis, F(1, f)) +
+                                             V(axis, F(2, f))));
+                    int index = (int) ((centroid - min) * inv_bin_size);
+                    (index <= best_index ? count_left : count_right)++;
+                }
+                uint32_t idx_l = offset_left.fetch_add(count_left);
+                uint32_t idx_r = offset_right.fetch_add(count_right);
+                for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                    uint32_t f = start[i];
+                    Float centroid = pointcloud ? V(axis, f)
+                         : ((1.0f / 3.0f) * (V(axis, F(0, f)) +
+                                             V(axis, F(1, f)) +
+                                             V(axis, F(2, f))));
+                    int index = (int) ((centroid - min) * inv_bin_size);
+                    if (index <= best_index)
+                        temp[idx_l++] = f;
+                    else
+                        temp[idx_r++] = f;
+                }
+            }
+        );
+        memcpy(start, temp, size * sizeof(uint32_t));
+        assert(offset_left == left_count && offset_right == size);
+
+        /* Create an empty parent task */
+        tbb::task& c = *new (allocate_continuation()) tbb::empty_task;
+        c.set_ref_count(2);
+
+        /* Post right subtree to scheduler */
+        BVHBuildTask &b = *new (c.allocate_child())
+            BVHBuildTask(bvh, node_idx_right, start + left_count,
+                         end, temp + left_count);
+        spawn(b);
+
+        /* Directly start working on left subtree */
+        recycle_as_child_of(c);
+        node_idx = node_idx_left;
+        end = start + left_count;
+
+        return this;
+    }
+
+    static void execute_serially(BVH &bvh, uint32_t node_idx, uint32_t *start, uint32_t *end, uint32_t *temp) {
+        uint32_t size = end-start;
+        BVHNode &node = bvh.mNodes[node_idx];
+        const MatrixXu &F = *bvh.mF;
+        const MatrixXf &V = *bvh.mV;
+        Float best_cost = BVH::T_tri * size;
+        int64_t best_index = -1, best_axis = -1;
+        float *left_areas = (float *) temp;
+        bool pointcloud = F.size() == 0;
+
+        for (int axis=0; axis<3; ++axis) {
+            if (pointcloud) {
+                std::sort(start, end, [&](uint32_t f1, uint32_t f2) {
+                    return V(axis, f1) < V(axis, f2);
+                });
+            } else {
+                std::sort(start, end, [&](uint32_t f1, uint32_t f2) {
+                    return
+                        (V(axis, F(0, f1)) + V(axis, F(1, f1)) + V(axis, F(2, f1))) <
+                        (V(axis, F(0, f2)) + V(axis, F(1, f2)) + V(axis, F(2, f2)));
+                });
+            }
+
+            AABB aabb;
+            for (uint32_t i = 0; i<size; ++i) {
+                uint32_t f = *(start + i);
+                if (pointcloud) {
+                    aabb.expandBy(V.col(f));
+                } else {
+                    aabb.expandBy(V.col(F(0, f)));
+                    aabb.expandBy(V.col(F(1, f)));
+                    aabb.expandBy(V.col(F(2, f)));
+                }
+                left_areas[i] = (float) aabb.surfaceArea();
+            }
+            if (axis == 0)
+                node.aabb = aabb;
+
+            aabb.clear();
+
+            Float tri_factor = BVH::T_tri / node.aabb.surfaceArea();
+            for (uint32_t i = size-1; i>=1; --i) {
+                uint32_t f = *(start + i);
+                if (pointcloud) {
+                    aabb.expandBy(V.col(f));
+                } else {
+                    aabb.expandBy(V.col(F(0, f)));
+                    aabb.expandBy(V.col(F(1, f)));
+                    aabb.expandBy(V.col(F(2, f)));
+                }
+
+                float left_area = left_areas[i-1];
+                float right_area = aabb.surfaceArea();
+                uint32_t prims_left = i;
+                uint32_t prims_right = size-i;
+
+                Float sah_cost = 2.0f * BVH::T_aabb +
+                    tri_factor * (prims_left * left_area +
+                                  prims_right * right_area);
+                if (sah_cost < best_cost) {
+                    best_cost = sah_cost;
+                    best_index = i;
+                    best_axis = axis;
+                }
+            }
+        }
+
+        if (best_index == -1) {
+            /* Splitting does not reduce the cost, make a leaf */
+            node.leaf.flag = 1;
+            node.leaf.start = start - bvh.mIndices;
+            node.leaf.size  = size;
+            return;
+        }
+
+
+        if (pointcloud) {
+            std::sort(start, end, [&](uint32_t f1, uint32_t f2) {
+                return V(best_axis, f1) < V(best_axis, f2);
+            });
+        } else {
+            std::sort(start, end, [&](uint32_t f1, uint32_t f2) {
+                return
+                    (V(best_axis, F(0, f1)) + V(best_axis, F(1, f1)) + V(best_axis, F(2, f1))) <
+                    (V(best_axis, F(0, f2)) + V(best_axis, F(1, f2)) + V(best_axis, F(2, f2)));
+            });
+        }
+
+        uint32_t left_count = best_index;
+        int node_idx_left = node_idx+1;
+        int node_idx_right = node_idx+2*left_count;
+        node.inner.rightChild = node_idx_right;
+        node.inner.unused = 0;
+
+        execute_serially(bvh, node_idx_left, start, start + left_count, temp);
+        execute_serially(bvh, node_idx_right, start+left_count, end, temp + left_count);
+    }
+};
+
+BVH::BVH(const MatrixXu *F, const MatrixXf *V, const MatrixXf *N, const AABB &aabb)
+: mIndices(nullptr), mF(F), mV(V), mN(N), mDiskRadius(0.f) {
+    if (mF->size() > 0) {
+        mNodes.resize(2*mF->cols());
+        memset(mNodes.data(), 0, sizeof(BVHNode) * mNodes.size());
+        mNodes[0].aabb = aabb;
+        mIndices = new uint32_t[mF->cols()];
+    } else if (mV->size() > 0) {
+        mNodes.resize(2*mV->cols());
+        memset(mNodes.data(), 0, sizeof(BVHNode) * mNodes.size());
+        mNodes[0].aabb = aabb;
+        mIndices = new uint32_t[mV->cols()];
+    }
+}
+
+void BVH::build(const ProgressCallback &progress) {
+    if (mF->cols() == 0 && mV->cols() == 0)
+        return;
+    mProgress = progress;
+
+#if defined(SINGLE_PRECISION)
+    if (sizeof(BVHNode) != 32)
+        throw std::runtime_error("BVH Node is not packed! Investigate compiler settings.");
+#endif
+
+    cout << "Constructing Bounding Volume Hierarchy .. ";
+    cout.flush();
+
+    bool pointcloud = mF->size() == 0;
+    uint32_t total_size = pointcloud ? mV->cols() : mF->cols();
+
+    for (uint32_t i = 0; i < total_size; ++i)
+        mIndices[i] = i;
+
+    Timer<> timer;
+    uint32_t *temp = new uint32_t[total_size];
+    BVHBuildTask& task = *new(tbb::task::allocate_root())
+        BVHBuildTask(*this, 0u, mIndices, mIndices + total_size, temp);
+    tbb::task::spawn_root_and_wait(task);
+    delete[] temp;
+
+    std::pair<Float, uint32_t> stats = statistics();
+    cout << "done. ("
+         << "SAH cost = " << stats.first << ", "
+         << "nodes = " << stats.second << ", "
+         << "took " << timeString(timer.reset())
+         << ")" << endl;
+
+    cout.precision(4);
+    cout << "Compressing BVH node storage to "
+         << 100 * stats.second / (float) mNodes.size() << "% of its original size .. ";
+    cout.flush();
+
+    std::vector<BVHNode> compressed(stats.second);
+    std::vector<uint32_t> skipped_accum(mNodes.size());
+
+    for (int64_t i = stats.second-1, j = mNodes.size(), skipped = 0; i >= 0; --i) {
+        while (mNodes[--j].isUnused())
+            skipped++;
+        BVHNode &new_node = compressed[i];
+        new_node = mNodes[j];
+        skipped_accum[j] = skipped;
+
+        if (new_node.isInner()) {
+            new_node.inner.rightChild =
+                i + new_node.inner.rightChild - j -
+                (skipped - skipped_accum[new_node.inner.rightChild]);
+        }
+    }
+
+    mNodes = std::move(compressed);
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+
+    if (pointcloud) {
+        cout << "Assigning disk radius .. ";
+        cout.flush();
+
+        auto map = [&](const tbb::blocked_range<uint32_t> &range, double radius_sum) -> double {
+            std::vector<std::pair<Float, uint32_t>> result;
+            for (uint32_t i = range.begin(); i < range.end(); ++i) {
+                Float radius = std::numeric_limits<double>::infinity();
+                if (findNearest(mV->col(i), radius) != (uint32_t) -1)
+                    radius_sum += radius;
+            }
+
+            SHOW_PROGRESS_RANGE(range, mV->cols(), "Assigning disk radius");
+            return radius_sum;
+        };
+
+        auto reduce = [](double radius_sum1, double radius_sum2) -> double {
+            return radius_sum1 + radius_sum2;
+        };
+
+        tbb::blocked_range<uint32_t> range(0u, (uint32_t) mV->cols(), GRAIN_SIZE);
+        mDiskRadius = tbb::parallel_deterministic_reduce(range, 0, map, reduce) / (double) range.size();
+        mDiskRadius *= 3;
+        refitBoundingBoxes();
+        cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+    }
+
+    mProgress = nullptr;
+}
+
+bool BVH::rayIntersect(Ray ray, uint32_t &idx, Float &t, Vector2f *uv) const {
+    if (mNodes.empty())
+        return false;
+
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+    bool hit = false;
+    t = std::numeric_limits<Float>::infinity();
+
+    if (mF->size() > 0) {
+        while (true) {
+            const BVHNode &node = mNodes[node_idx];
+
+            if (!node.aabb.rayIntersect(ray)) {
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+
+            if (node.isInner()) {
+                stack[stack_idx++] = node.inner.rightChild;
+                node_idx++;
+                assert(stack_idx<64);
+            } else {
+                Float _t;
+                Vector2f _uv;
+                for (uint32_t i = node.start(), end = node.end(); i < end; ++i) {
+                    if (rayIntersectTri(ray, mIndices[i], _t, _uv)) {
+                        idx = mIndices[i];
+                        t = ray.maxt = _t;
+                        hit = true;
+                        if (uv)
+                            *uv = _uv;
+                    }
+                }
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+        }
+    } else {
+        if (uv)
+            *uv = Vector2f::Zero();
+        while (true) {
+            const BVHNode &node = mNodes[node_idx];
+
+            if (!node.aabb.rayIntersect(ray)) {
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+
+            if (node.isInner()) {
+                stack[stack_idx++] = node.inner.rightChild;
+                node_idx++;
+                assert(stack_idx<64);
+            } else {
+                Float _t;
+                for (uint32_t i = node.start(), end = node.end(); i < end; ++i) {
+                    if (rayIntersectDisk(ray, mIndices[i], _t)) {
+                        idx = mIndices[i];
+                        t = ray.maxt = _t;
+                        hit = true;
+                    }
+                }
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+        }
+    }
+
+    return hit;
+}
+
+bool BVH::rayIntersect(Ray ray) const {
+    if (mNodes.empty())
+        return false;
+
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+
+    if (mF->size() > 0) {
+        while (true) {
+            const BVHNode &node = mNodes[node_idx];
+
+            if (!node.aabb.rayIntersect(ray)) {
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+
+            if (node.isInner()) {
+                stack[stack_idx++] = node.inner.rightChild;
+                node_idx++;
+                assert(stack_idx<64);
+            } else {
+                Float t;
+                Vector2f uv;
+                for (uint32_t i = node.start(), end = node.end(); i < end; ++i)
+                    if (rayIntersectTri(ray, mIndices[i], t, uv))
+                        return true;
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+        }
+    } else {
+        while (true) {
+            const BVHNode &node = mNodes[node_idx];
+
+            if (!node.aabb.rayIntersect(ray)) {
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+
+            if (node.isInner()) {
+                stack[stack_idx++] = node.inner.rightChild;
+                node_idx++;
+                assert(stack_idx<64);
+            } else {
+                Float t;
+                for (uint32_t i = node.start(), end = node.end(); i < end; ++i)
+                    if (rayIntersectDisk(ray, mIndices[i], t))
+                        return true;
+                if (stack_idx == 0)
+                    break;
+                node_idx = stack[--stack_idx];
+                continue;
+            }
+        }
+    }
+
+    return false;
+}
+
+void BVH::findNearestWithRadius(const Vector3f &p, Float radius,
+                                std::vector<uint32_t> &result,
+                                bool includeSelf) const {
+    result.clear();
+
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+    Float radius2 = radius*radius;
+
+    while (true) {
+        const BVHNode &node = mNodes[node_idx];
+        if (node.aabb.squaredDistanceTo(p) > radius2) {
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+
+        if (node.isInner()) {
+            stack[stack_idx++] = node.inner.rightChild;
+            node_idx++;
+            assert(stack_idx<64);
+        } else {
+            uint32_t start = node.leaf.start, end = start + node.leaf.size;
+            for (uint32_t i = start; i < end; ++i) {
+                uint32_t f = mIndices[i];
+                Vector3f pointPos = Vector3f::Zero();
+                if (mF->size() > 0) {
+                    for (int j=0; j<3; ++j)
+                        pointPos += mV->col((*mF)(j, f));
+                    pointPos *= 1.0f / 3.0f;
+                } else {
+                    pointPos = mV->col(f);
+                }
+                Float pointDist2 = (pointPos-p).squaredNorm();
+                if (pointDist2 < radius2 && (pointDist2 != 0 || includeSelf))
+                    result.push_back(f);
+            }
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+    }
+}
+
+uint32_t BVH::findNearest(const Vector3f &p, Float &radius, bool includeSelf) const {
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+    Float radius2 = radius*radius;
+    uint32_t result = (uint32_t) -1;
+
+    while (true) {
+        const BVHNode &node = mNodes[node_idx];
+        if (node.aabb.squaredDistanceTo(p) > radius2) {
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+
+        if (node.isInner()) {
+            uint32_t left = node_idx + 1, right = node.inner.rightChild;
+            Float distLeft = mNodes[left].aabb.squaredDistanceTo(p);
+            Float distRight = mNodes[right].aabb.squaredDistanceTo(p);
+            if (distLeft < distRight) {
+                node_idx = left;
+                if (distRight < radius2)
+                    stack[stack_idx++] = right;
+            } else {
+                node_idx = right;
+                if (distLeft < radius2)
+                    stack[stack_idx++] = left;
+            }
+            assert(stack_idx<64);
+        } else {
+            uint32_t start = node.leaf.start, end = start + node.leaf.size;
+            for (uint32_t i = start; i < end; ++i) {
+                uint32_t f = mIndices[i];
+                Vector3f pointPos = Vector3f::Zero();
+                if (mF->size() > 0) {
+                    for (int j=0; j<3; ++j)
+                        pointPos += mV->col((*mF)(j, f));
+                    pointPos *= 1.0f / 3.0f;
+                } else {
+                    pointPos = mV->col(f);
+                }
+                Float pointDist2 = (pointPos-p).squaredNorm();
+
+                if (pointDist2 < radius2 && (pointDist2 != 0 || includeSelf)) {
+                    radius2 = pointDist2;
+                    result = f;
+                }
+            }
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+    }
+    radius = std::sqrt(radius2);
+    return result;
+}
+
+void BVH::findKNearest(const Vector3f &p, uint32_t k, Float &radius,
+                       std::vector<std::pair<Float, uint32_t>> &result,
+                       bool includeSelf) const {
+    result.clear();
+
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+    Float radius2 = radius*radius;
+    bool isHeap = false;
+    auto comp = [](const std::pair<Float, uint32_t> &v1, const std::pair<Float, uint32_t> &v2) {
+        return v1.first < v2.first;
+    };
+
+    while (true) {
+        const BVHNode &node = mNodes[node_idx];
+        if (node.aabb.squaredDistanceTo(p) > radius2) {
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+
+        if (node.isInner()) {
+            uint32_t left = node_idx + 1, right = node.inner.rightChild;
+            Float distLeft = mNodes[left].aabb.squaredDistanceTo(p);
+            Float distRight = mNodes[right].aabb.squaredDistanceTo(p);
+            if (distLeft < distRight) {
+                node_idx = left;
+                if (distRight < radius2)
+                    stack[stack_idx++] = right;
+            } else {
+                node_idx = right;
+                if (distLeft < radius2)
+                    stack[stack_idx++] = left;
+            }
+            assert(stack_idx<64);
+        } else {
+            uint32_t start = node.leaf.start, end = start + node.leaf.size;
+            for (uint32_t i = start; i < end; ++i) {
+                uint32_t f = mIndices[i];
+                Vector3f pointPos = Vector3f::Zero();
+                if (mF->size() > 0) {
+                    for (int j=0; j<3; ++j)
+                        pointPos += mV->col((*mF)(j, f));
+                    pointPos *= 1.0f / 3.0f;
+                } else {
+                    pointPos = mV->col(f);
+                }
+                Float pointDist2 = (pointPos-p).squaredNorm();
+
+                if (pointDist2 < radius2 && (pointDist2 != 0 || includeSelf)) {
+                    if (result.size() < k) {
+                        result.push_back(std::make_pair(pointDist2, f));
+                    } else {
+                        if (!isHeap) {
+                            /* Establish the max-heap property */
+                            std::make_heap(result.begin(), result.end(), comp);
+                            isHeap = true;
+                        }
+
+                        result.push_back(std::make_pair(pointDist2, f));
+                        std::push_heap(result.begin(), result.end(), comp);
+                        std::pop_heap(result.begin(), result.end(), comp);
+                        result.pop_back();
+
+                        /* Reduce the search radius accordingly */
+                        radius2 = result[0].first;
+                    }
+                }
+            }
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+    }
+    radius = std::sqrt(radius2);
+}
+
+void BVH::findKNearest(const Vector3f &p, const Vector3f &n, uint32_t k,
+                       Float &radius,
+                       std::vector<std::pair<Float, uint32_t> > &result,
+                       Float angleThresh, bool includeSelf) const {
+    result.clear();
+
+    uint32_t node_idx = 0, stack[64];
+    uint32_t stack_idx = 0;
+    Float radius2 = radius*radius;
+    bool isHeap = false;
+    angleThresh = std::cos(angleThresh * M_PI/180);
+    auto comp = [](const std::pair<Float, uint32_t> &v1, const std::pair<Float, uint32_t> &v2) {
+        return v1.first < v2.first;
+    };
+
+    while (true) {
+        const BVHNode &node = mNodes[node_idx];
+        if (node.aabb.squaredDistanceTo(p) > radius2) {
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+
+        if (node.isInner()) {
+            uint32_t left = node_idx + 1, right = node.inner.rightChild;
+            Float distLeft = mNodes[left].aabb.squaredDistanceTo(p);
+            Float distRight = mNodes[right].aabb.squaredDistanceTo(p);
+            if (distLeft < distRight) {
+                node_idx = left;
+                if (distRight < radius2)
+                    stack[stack_idx++] = right;
+            } else {
+                node_idx = right;
+                if (distLeft < radius2)
+                    stack[stack_idx++] = left;
+            }
+            assert(stack_idx<64);
+        } else {
+            uint32_t start = node.leaf.start, end = start + node.leaf.size;
+            for (uint32_t i = start; i < end; ++i) {
+                uint32_t f = mIndices[i];
+                Vector3f pointPos = Vector3f::Zero();
+                if (mF->size() > 0) {
+                    for (int j=0; j<3; ++j)
+                        pointPos += mV->col((*mF)(j, f));
+                    pointPos *= 1.0f / 3.0f;
+                } else {
+                    pointPos = mV->col(f);
+                }
+                Vector3f pointNormal = Vector3f::Zero();
+                if (mF->size() > 0) {
+                    for (int j=0; j<3; ++j)
+                        pointNormal += mN->col((*mF)(j, f));
+                } else {
+                    pointNormal = mN->col(f);
+                }
+                Float pointDist2 = (pointPos-p).squaredNorm();
+
+                if (pointDist2 < radius2 && (pointDist2 != 0 || includeSelf) && pointNormal.dot(n) > angleThresh) {
+                    if (result.size() < k) {
+                        result.push_back(std::make_pair(pointDist2, f));
+                    } else {
+                        if (!isHeap) {
+                            /* Establish the max-heap property */
+                            std::make_heap(result.begin(), result.end(), comp);
+                            isHeap = true;
+                        }
+
+                        result.push_back(std::make_pair(pointDist2, f));
+                        std::push_heap(result.begin(), result.end(), comp);
+                        std::pop_heap(result.begin(), result.end(), comp);
+                        result.pop_back();
+
+                        /* Reduce the search radius accordingly */
+                        radius2 = result[0].first;
+                    }
+                }
+            }
+            if (stack_idx == 0)
+                break;
+            node_idx = stack[--stack_idx];
+            continue;
+        }
+    }
+    radius = std::sqrt(radius2);
+}
+
+bool BVH::rayIntersectTri(const Ray &ray, uint32_t i, Float &t, Vector2f &uv) const {
+    const Vector3f &p0 = mV->col((*mF)(0, i)),
+                   &p1 = mV->col((*mF)(1, i)),
+                   &p2 = mV->col((*mF)(2, i));
+
+    Vector3f edge1 = p1 - p0, edge2 = p2 - p0;
+    Vector3f pvec = ray.d.cross(edge2);
+
+    Float det = edge1.dot(pvec);
+    if (det == 0.0f)
+        return false;
+    Float inv_det = 1.0f / det;
+
+    Vector3f tvec = ray.o - p0;
+    Float u = tvec.dot(pvec) * inv_det;
+    if (u < 0.0f || u > 1.0f)
+        return false;
+
+    Vector3f qvec = tvec.cross(edge1);
+    Float v = ray.d.dot(qvec) * inv_det;
+
+    if (v < 0.0f || u + v > 1.0f)
+        return false;
+
+    Float tempT = edge2.dot(qvec) * inv_det;
+    if (tempT < ray.mint || tempT > ray.maxt)
+        return false;
+
+    t = tempT;
+    uv << u, v;
+    return true;
+}
+
+bool BVH::rayIntersectDisk(const Ray &ray, uint32_t i, Float &t) const {
+    Vector3f v = mV->col(i), n = mN->col(i);
+    Float dp = ray.d.dot(n);
+
+    if (std::abs(dp) < RCPOVERFLOW)
+        return false;
+
+    t = (n.dot(v) - n.dot(ray.o)) / dp;
+
+    return (ray(t)-v).squaredNorm() < mDiskRadius*mDiskRadius;
+}
+
+void BVH::printStatistics() const {
+    cout << endl;
+    cout << "Bounding Volume Hierarchy statistics:" << endl;
+    cout << "    Tree nodes         : " << memString(sizeof(BVHNode) * mNodes.size()) << endl;
+    cout << "    Index buffer       : " << memString(sizeof(uint32_t) * mF->size()) << endl;
+    cout << "    Total              : "
+         << memString(sizeof(BVHNode) * mNodes.size() + sizeof(uint32_t) * mF->size()) << endl;
+}
+
+std::pair<Float, uint32_t> BVH::statistics(uint32_t node_idx) const {
+    const BVHNode &node = mNodes[node_idx];
+    if (node.isLeaf()) {
+        return std::make_pair(T_tri * node.leaf.size, 1u);
+    } else {
+        std::pair<Float, uint32_t> stats_left = statistics(node_idx + 1u);
+        std::pair<Float, uint32_t> stats_right = statistics(node.inner.rightChild);
+        Float saLeft = mNodes[node_idx + 1u].aabb.surfaceArea();
+        Float saRight = mNodes[node.inner.rightChild].aabb.surfaceArea();
+        Float saCur = node.aabb.surfaceArea();
+        Float sahCost = 2 * BVH::T_aabb + (saLeft * stats_left.first +
+                                           saRight * stats_right.first) / saCur;
+
+        return std::make_pair(
+            sahCost,
+            stats_left.second + stats_right.second + 1u
+        );
+    }
+}
+
+BVH::~BVH() {
+    delete[] mIndices;
+}
+
+void BVH::refitBoundingBoxes(uint32_t node_idx) {
+    BVHNode &node = mNodes[node_idx];
+    if (node.isLeaf()) {
+        for (uint32_t i=node.start(); i<node.end(); ++i) {
+            uint32_t j = mIndices[i];
+            const Vector3f &p = mV->col(j), &n = mN->col(j);
+            Vector3f s, t;
+            coordinate_system(n, s, t);
+            AABB aabb;
+            for (int k=0; k<4; ++k)
+                aabb.expandBy(p + mDiskRadius *  (
+                    ((k&1)*2 - 1) * s +
+                    ((k&2) - 1) * t));
+            node.aabb = aabb;
+        }
+    } else {
+        uint32_t left = node_idx + 1u, right = node.inner.rightChild;
+        refitBoundingBoxes(left);
+        refitBoundingBoxes(right);
+        node.aabb = AABB::merge(mNodes[left].aabb, mNodes[right].aabb);
+    }
+}
+

intern/instant-meshes/src/bvh.h

@@ -0,0 +1,108 @@
+/*
+    bvh.h -- bounding volume hierarchy for fast ray-intersection queries
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "aabb.h"
+
+/* BVH node in 32 bytes */
+struct BVHNode {
+    union {
+        struct {
+            unsigned flag : 1;
+            uint32_t size : 31;
+            uint32_t start;
+        } leaf;
+
+        struct {
+            uint32_t unused;
+            uint32_t rightChild;
+        } inner;
+    };
+    AABB aabb;
+
+    inline bool isLeaf() const {
+        return leaf.flag == 1;
+    }
+
+    inline bool isInner() const {
+        return leaf.flag == 0;
+    }
+
+    inline bool isUnused() const {
+        return inner.unused == 0 && inner.rightChild == 0;
+    }
+
+    inline uint32_t start() const {
+        return leaf.start;
+    }
+
+    inline uint32_t end() const {
+        return leaf.start + leaf.size;
+    }
+};
+
+class BVH {
+    friend struct BVHBuildTask;
+    /* Cost values for BVH surface area heuristic */
+    enum { T_aabb = 1, T_tri = 1 };
+public:
+    BVH(const MatrixXu *F, const MatrixXf *V, const MatrixXf *N, const AABB &aabb);
+
+    ~BVH();
+
+    void setData(const MatrixXu *F, const MatrixXf *V, const MatrixXf *N) { mF = F; mV = V; mN = N; }
+
+    const MatrixXu *F() const { return mF; }
+    const MatrixXf *V() const { return mV; }
+    const MatrixXf *N() const { return mN; }
+    Float diskRadius() const { return mDiskRadius; }
+
+    void build(const ProgressCallback &progress = ProgressCallback());
+
+    void printStatistics() const;
+
+    bool rayIntersect(Ray ray) const;
+
+    bool rayIntersect(Ray ray, uint32_t &idx, Float &t, Vector2f *uv = nullptr) const;
+
+    void findNearestWithRadius(const Vector3f &p, Float radius,
+                               std::vector<uint32_t> &result,
+                               bool includeSelf = false) const;
+
+    uint32_t findNearest(const Vector3f &p, Float &radius, bool includeSelf = false) const;
+
+    void findKNearest(const Vector3f &p, uint32_t k, Float &radius,
+                      std::vector<std::pair<Float, uint32_t> > &result,
+                      bool includeSelf = false) const;
+
+    void findKNearest(const Vector3f &p, const Vector3f &N, uint32_t k,
+                      Float &radius,
+                      std::vector<std::pair<Float, uint32_t> > &result,
+                      Float angleThresh = 30,
+                      bool includeSelf = false) const;
+
+protected:
+    bool rayIntersectTri(const Ray &ray, uint32_t i, Float &t, Vector2f &uv) const;
+    bool rayIntersectDisk(const Ray &ray, uint32_t i, Float &t) const;
+    void refitBoundingBoxes(uint32_t node_idx = 0);
+    std::pair<Float, uint32_t> statistics(uint32_t node_idx = 0) const;
+
+protected:
+    std::vector<BVHNode> mNodes;
+    uint32_t *mIndices;
+    const MatrixXu *mF;
+    const MatrixXf *mV, *mN;
+    ProgressCallback mProgress;
+    Float mDiskRadius;
+};

intern/instant-meshes/src/c_api.cpp

@@ -0,0 +1,427 @@
+#include "MEM_guardedalloc.h"
+
+#include "adjacency.h"
+#include "cleanup.h"
+#include "common.h"
+#include "dedge.h"
+#include "extract.h"
+#include "field.h"
+#include "hierarchy.h"
+#include "normal.h"
+#include "smoothcurve.h"
+#include "subdivide.h"
+
+#include "meshstats.h"
+
+#include "../instant_meshes_c_api.h"
+
+#include <set>
+
+int instant_meshes_nprocs = 1;
+
+static const float len_v3v3(const float *a, const float *b)
+{
+  float dx = a[0] - b[0];
+  float dy = a[1] - b[1];
+  float dz = a[2] - b[2];
+
+  float len = dx * dx + dy * dy + dz * dz;
+
+  return len > 0.0f ? sqrtf(len) : 0.0f;
+}
+
+static void cross_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
+{
+  float n1[3], n2[3];
+
+  n1[0] = v1[0] - v2[0];
+  n2[0] = v2[0] - v3[0];
+  n1[1] = v1[1] - v2[1];
+  n2[1] = v2[1] - v3[1];
+  n1[2] = v1[2] - v2[2];
+  n2[2] = v2[2] - v3[2];
+  n[0] = n1[1] * n2[2] - n1[2] * n2[1];
+  n[1] = n1[2] * n2[0] - n1[0] * n2[2];
+  n[2] = n1[0] * n2[1] - n1[1] * n2[0];
+}
+
+/* Triangles */
+static float area_tri_v3(const float v1[3], const float v2[3], const float v3[3])
+{
+  float n[3];
+  cross_tri_v3(n, v1, v2, v3);
+  return sqrtf(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]) * 0.5f;
+}
+
+static float fract(float f)
+{
+  return f - floorf(f);
+}
+
+extern "C" {
+void instant_meshes_run(RemeshMesh *mesh)
+{
+  MatrixXu F;
+  MatrixXf V;
+  MatrixXf N;
+
+  float elen = 0.0f;
+  int totlen = 0;
+  float scale = 0.1f;
+
+  std::set<uint32_t> creaseSet;
+
+  F.resize(3, mesh->tottri);
+  V.resize(3, mesh->totvert);
+  N.resize(3, mesh->totvert);
+
+  float area = 0.0f;
+
+  for (int i = 0; i < mesh->tottri; i++) {
+    RemeshTri *tri = mesh->tris + i;
+
+    float *co1 = mesh->verts[tri->v1].co;
+    float *co2 = mesh->verts[tri->v2].co;
+    float *co3 = mesh->verts[tri->v3].co;
+
+    elen += len_v3v3(co1, co2);
+    elen += len_v3v3(co2, co3);
+    elen += len_v3v3(co3, co1);
+    totlen += 3;
+
+    area += area_tri_v3(co1, co2, co3);
+
+    F(0, i) = tri->v1;
+    F(1, i) = tri->v2;
+    F(2, i) = tri->v3;
+  }
+
+  for (int i = 0; i < mesh->totvert; i++) {
+    RemeshVertex *v = mesh->verts + i;
+
+    for (int j = 0; j < 3; j++) {
+      V(j, i) = v->co[j];
+      N(j, i) = v->no[j];
+    }
+  }
+
+  if (totlen > 0) {
+    elen /= totlen;
+  }
+
+  scale = sqrt(area / (float)mesh->goal_faces);
+  if (scale == 0.0f) {
+    return;  // error
+  }
+
+  const bool extrinsic = true;
+  const bool deterministic = false;
+  const int rosy = 2, posy = 4;
+
+  printf("totarea: %.4f, scale: %.5f\n", area, scale);
+
+  VectorXu V2E, E2E;
+  VectorXb boundary;
+  VectorXb nonManifold;
+
+  nonManifold.resize(V.cols());
+
+  build_dedge(F, V, V2E, E2E, boundary, nonManifold);
+  // AdjacencyMatrix adj = generate_adjacency_matrix_cotan(F, V, V2E, E2E, nonManifold);
+  AdjacencyMatrix adj = generate_adjacency_matrix_uniform(F, V2E, E2E, nonManifold);
+
+  VectorXf A;
+
+  generate_smooth_normals(F, V, V2E, E2E, nonManifold, N);
+  compute_dual_vertex_areas(F, V, V2E, E2E, nonManifold, A);
+
+  MultiResolutionHierarchy mRes;
+
+  mRes.setF(std::move(F));
+  mRes.setV(std::move(V));
+  mRes.setN(std::move(N));
+  mRes.setE2E(std::move(E2E));
+  mRes.setAdj(std::move(adj));
+  mRes.setA(std::move(A));
+  mRes.setScale(scale);
+
+  printf("building multiresolution hierarchy\n");
+  mRes.build(deterministic);
+  mRes.resetSolution();
+
+  /* set up edge constraints */
+  mRes.clearConstraints();
+
+  for (int i = 0; i < mesh->totedge; i++) {
+    RemeshEdge *e = mesh->edges + i;
+
+    const MatrixXu &F = mRes.F();
+    const MatrixXf &N = mRes.N(), &V = mRes.V();
+    const VectorXu &E2E = mRes.E2E();
+
+    uint32_t i0 = (uint32_t)e->v1;
+    uint32_t i1 = (uint32_t)e->v2;
+    Vector3f p0 = V.col(i0), p1 = V.col(i1);
+
+    if (0 && (e->flag & REMESH_EDGE_USE_DIR)) {
+      Vector3f dir(e->dir);
+
+      if (dir.squaredNorm() > 0) {
+        mRes.CO().col(i0) = p0;
+        mRes.CO().col(i1) = p1;
+        mRes.CQ().col(i0) = mRes.CQ().col(i1) = dir;
+        mRes.CQw()[i0] = mRes.CQw()[i1] = mRes.COw()[i0] = mRes.COw()[i1] = 0.05f;
+      }
+    }
+    else if (e->flag & REMESH_EDGE_BOUNDARY) {
+      Vector3f edge = p1 - p0;
+
+      creaseSet.insert((uint32_t)e->v1);
+      creaseSet.insert((uint32_t)e->v2);
+
+      if (edge.squaredNorm() > 0) {
+        edge.normalize();
+        mRes.CO().col(i0) = p0;
+        mRes.CO().col(i1) = p1;
+        mRes.CQ().col(i0) = mRes.CQ().col(i1) = edge;
+        mRes.CQw()[i0] = mRes.CQw()[i1] = mRes.COw()[i0] = mRes.COw()[i1] = 1.0f;
+      }
+    }
+  }
+
+  mRes.propagateConstraints(rosy, posy);
+
+  Optimizer opt(mRes, false);
+
+  opt.setExtrinsic(extrinsic);
+  opt.setRoSy(rosy);
+  opt.setPoSy(posy);
+
+  const int iterations = mesh->iterations;
+
+  printf("optimizing orientation field\n");
+  for (int step = 0; step < iterations; step++) {
+    opt.optimizeOrientations(-1);
+    opt.notify();
+    opt.wait();
+  }
+
+  std::map<uint32_t, uint32_t> sing;
+  compute_orientation_singularities(mRes, sing, extrinsic, rosy);
+  cout << "Orientation field has " << sing.size() << " singularities." << endl;
+
+  printf("optimizing position field\n");
+  for (int step = 0; step < iterations; step++) {
+    opt.optimizePositions(-1);
+    opt.notify();
+    opt.wait();
+  }
+
+  std::map<uint32_t, Vector2i> pos_sing;
+  compute_position_singularities(mRes, sing, pos_sing, extrinsic, rosy, posy);
+  cout << "Position field has " << pos_sing.size() << " singularities." << endl;
+
+#ifdef INSTANT_MESHES_VIS_COLOR
+  {
+    mesh->totoutface = mesh->tottri;
+    mesh->totoutvert = mesh->totvert;
+
+    mesh->outfaces = (RemeshOutFace *)MEM_malloc_arrayN(
+        mesh->tottri, sizeof(RemeshOutFace), "RemeshOutFace");
+    mesh->outverts = (RemeshVertex *)MEM_malloc_arrayN(
+        mesh->totvert, sizeof(RemeshVertex), "RemeshVertex");
+    memcpy(mesh->outverts, mesh->verts, sizeof(*mesh->outverts) * mesh->totvert);
+    mesh->out_scracth = (int *)MEM_malloc_arrayN(mesh->tottri * 3, sizeof(int), "out_scratch");
+
+    int li = 0;
+    RemeshOutFace *f = mesh->outfaces;
+    RemeshTri *tri = mesh->tris;
+    RemeshVertex *v = mesh->outverts;
+
+    auto O = mRes.O(0);
+    printf("O size: [%d][%d]\n", (int)O.cols(), (int)O.rows());
+
+    for (int i = 0; i < mesh->totvert; i++, v++) {
+      v->viscolor[0] = O(0, i);
+      v->viscolor[1] = O(1, i);
+      // v->viscolor[2] = O(2, i);
+    }
+
+    for (int i = 0; i < mesh->tottri; i++, f++, tri++) {
+      f->verts = mesh->out_scracth + li;
+      li += 3;
+
+      f->verts[0] = tri->v1;
+      f->verts[1] = tri->v2;
+      f->verts[2] = tri->v3;
+      f->totvert = 3;
+    }
+  }
+#endif
+
+  opt.shutdown();
+
+#ifdef INSTANT_MESHES_VIS_COLOR
+  return;
+#endif
+
+  std::vector<std::vector<TaggedLink>> adj_extracted;
+
+  MatrixXu F_extracted;
+  MatrixXf V_extracted;
+  MatrixXf N_extracted;
+  MatrixXf Nf_extracted;
+
+  std::set<uint32_t> creaseOut;
+
+  printf("extracting mesh\n");
+
+  extract_graph(mRes,
+                extrinsic,
+                rosy,
+                posy,
+                adj_extracted,
+                V_extracted,
+                N_extracted,
+                creaseSet,
+                creaseOut,
+                deterministic,
+                true,
+                true,
+                true);
+
+  extract_faces(adj_extracted,
+                V_extracted,
+                N_extracted,
+                Nf_extracted,
+                F_extracted,
+                posy,
+                mRes.scale(),
+                creaseOut,
+                true,
+                true,
+                nullptr,
+                0);
+
+  // F_extracted = mRes.F();
+  // V_extracted = mRes.V();
+
+  mesh->totoutface = F_extracted.cols();
+  mesh->totoutvert = V_extracted.cols();
+
+  int sides = F_extracted.rows();
+
+  mesh->outfaces = (RemeshOutFace *)MEM_malloc_arrayN(
+      mesh->totoutface, sizeof(RemeshOutFace), "RemeshOutFaces");
+  mesh->outverts = (RemeshVertex *)MEM_malloc_arrayN(
+      mesh->totoutvert, sizeof(RemeshVertex), "RemeshOutVerts");
+  mesh->out_scracth = (int *)MEM_malloc_arrayN(
+      mesh->totoutface * sides, sizeof(int), "out_scratch");
+
+  printf(
+      "sides:%d\ntotal faces: %d\ntotal verts: %d\n", sides, mesh->totoutface, mesh->totoutvert);
+
+  RemeshOutFace *f = mesh->outfaces;
+  int totface = mesh->totoutface;
+  int i = 0, fi = 0, li = 0;
+
+  /* Check for irregular faces */
+  std::map<uint32_t, std::pair<uint32_t, std::map<uint32_t, uint32_t>>> irregular;
+  size_t nIrregular = 0;
+
+  for (; fi < totface; fi++) {
+    if (F_extracted(2, fi) == F_extracted(3, fi)) {
+      nIrregular++;
+      auto &value = irregular[F_extracted(2, fi)];
+      value.first = fi;
+      value.second[F_extracted(0, fi)] = F_extracted(1, fi);
+      continue;
+    }
+
+    f->verts = mesh->out_scracth + li;
+    li += sides;
+
+    int j = 0;
+
+    for (j = 0; j < sides; j++) {
+      f->verts[j] = F_extracted(j, fi);
+    }
+
+    //  if (j != sides) {
+    //      i--;
+    //}
+
+    f->totvert = sides;
+    i++;
+    f++;
+  }
+
+  for (auto item : irregular) {
+    auto face = item.second;
+    uint32_t v = face.second.begin()->first, first = v, k = 0;
+
+    int j = 0;
+    f->verts = mesh->out_scracth + li;
+
+    while (true) {
+      v = face.second[v];
+      f->verts[j] = (int)v;
+
+      li++;
+      j++;
+
+      if (v == first || ++k == face.second.size())
+        break;
+    }
+
+    f->totvert = j;
+
+    f++;
+    i++;
+  }
+
+  printf("final totface: %d, alloc totface: %d\n", i, mesh->totoutface);
+  printf("final totloop: %d, alloc totloop: %d\n", li, mesh->totoutface * sides);
+
+  mesh->totoutface = i;
+
+  RemeshVertex *v = mesh->outverts;
+  for (int i = 0; i < mesh->totoutvert; i++, v++) {
+    for (int j = 0; j < 3; j++) {
+      v->co[j] = V_extracted(j, i);
+      v->no[j] = N_extracted(j, i);
+    }
+  }
+}
+
+void instant_meshes_finish(RemeshMesh *mesh)
+{
+  /*
+  if (mesh->verts) {
+    MEM_freeN((void *)mesh->verts);
+  }
+
+  if (mesh->edges) {
+    MEM_freeN((void *)mesh->edges);
+  }
+
+  if (mesh->tris) {
+    MEM_freeN((void *)mesh->tris);
+  }*/
+
+  if (mesh->outverts) {
+    MEM_freeN((void *)mesh->outverts);
+  }
+  if (mesh->outfaces) {
+    MEM_freeN((void *)mesh->outfaces);
+  }
+  if (mesh->out_scracth) {
+    MEM_freeN((void *)mesh->out_scracth);
+  }
+}
+
+void instant_meshes_set_number_of_threads(int n)
+{
+  instant_meshes_nprocs = n;
+}
+};

intern/instant-meshes/src/cleanup.cpp

@@ -0,0 +1,189 @@
+/*
+    cleanup.cpp -- functionality to greedily drop non-manifold elements from a mesh
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "dedge.h"
+#include "field.h"
+#include <set>
+
+void remove_nonmanifold(MatrixXu &F, MatrixXf &V, MatrixXf &Nf) {
+    typedef std::pair<uint32_t, uint32_t> Edge;
+
+    std::map<uint32_t, std::map<uint32_t, std::pair<uint32_t, uint32_t>>> irregular;
+    std::vector<std::set<uint32_t>> E(V.cols());
+    std::vector<std::set<uint32_t>> VF(V.cols());
+
+    auto kill_face_single = [&](uint32_t f) {
+        if (F(0, f) == INVALID)
+            return;
+        for (int i=0; i<F.rows(); ++i)
+            E[F(i, f)].erase(F((i+1)%F.rows(), f));
+        F.col(f).setConstant(INVALID);
+    };
+
+    auto kill_face = [&](uint32_t f) {
+        if (F.rows() == 4 && F(2, f) == F(3, f)) {
+            auto it = irregular.find(F(2, f));
+            if (it != irregular.end()) {
+                for (auto &item : it->second) {
+                    kill_face_single(item.second.second);
+                }
+            }
+        }
+        kill_face_single(f);
+    };
+
+
+    uint32_t nm_edge = 0, nm_vert = 0;
+
+    for (uint32_t f=0; f < (uint32_t) F.cols(); ++f) {
+        if (F(0, f) == INVALID)
+            continue;
+        if (F.rows() == 4 && F(2, f) == F(3, f)) {
+            /* Special handling of irregular faces */
+            irregular[F(2, f)][F(0, f)] = std::make_pair(F(1, f), f);
+            continue;
+        }
+
+        bool nonmanifold = false;
+        for (uint32_t e=0; e<F.rows(); ++e) {
+            uint32_t v0 = F(e, f), v1 = F((e + 1) % F.rows(), f), v2 = F((e + 2) % F.rows(), f);
+            if (E[v0].find(v1) != E[v0].end() ||
+                (F.rows() == 4 && E[v0].find(v2) != E[v0].end()))
+                nonmanifold = true;
+        }
+
+        if (nonmanifold) {
+            nm_edge++;
+            F.col(f).setConstant(INVALID);
+            continue;
+        }
+
+        for (uint32_t e=0; e<F.rows(); ++e) {
+            uint32_t v0 = F(e, f), v1 = F((e + 1) % F.rows(), f), v2 = F((e + 2) % F.rows(), f);
+
+            E[v0].insert(v1);
+            if (F.rows() == 4)
+                E[v0].insert(v2);
+            VF[v0].insert(f);
+        }
+    }
+
+    std::vector<Edge> edges;
+    for (auto item : irregular) {
+        bool nonmanifold = false;
+        auto face = item.second;
+        edges.clear();
+
+        uint32_t cur = face.begin()->first, stop = cur;
+        while (true) {
+            uint32_t pred = cur;
+            cur = face[cur].first;
+            uint32_t next = face[cur].first, it = 0;
+            while (true) {
+                ++it;
+                if (next == pred)
+                    break;
+                if (E[cur].find(next) != E[cur].end() && it == 1)
+                    nonmanifold = true;
+                edges.push_back(Edge(cur, next));
+                next = face[next].first;
+            }
+            if (cur == stop)
+                break;
+        }
+
+        if (nonmanifold) {
+            nm_edge++;
+            for (auto &i : item.second)
+                F.col(i.second.second).setConstant(INVALID);
+            continue;
+        } else {
+            for (auto e : edges) {
+                E[e.first].insert(e.second);
+
+                for (auto e2 : face)
+                    VF[e.first].insert(e2.second.second);
+            }
+        }
+    }
+
+    /* Check vertices */
+    std::set<uint32_t> v_marked, v_unmarked, f_adjacent;
+
+    std::function<void(uint32_t)> dfs = [&](uint32_t i) {
+        v_marked.insert(i);
+        v_unmarked.erase(i);
+
+        for (uint32_t f : VF[i]) {
+            if (f_adjacent.find(f) == f_adjacent.end()) /* if not part of adjacent face */
+                continue;
+            for (uint32_t j = 0; j<F.rows(); ++j) {
+                uint32_t k = F(j, f);
+                if (v_unmarked.find(k) == v_unmarked.end() || /* if not unmarked OR */
+                    v_marked.find(k) != v_marked.end()) /* if already marked */
+                    continue;
+                dfs(k);
+            }
+        }
+    };
+
+    for (uint32_t i = 0; i < (uint32_t) V.cols(); ++i) {
+        v_marked.clear();
+        v_unmarked.clear();
+        f_adjacent.clear();
+
+        for (uint32_t f : VF[i]) {
+            if (F(0, f) == INVALID)
+                continue;
+
+            for (uint32_t k=0; k<F.rows(); ++k)
+                v_unmarked.insert(F(k, f));
+
+            f_adjacent.insert(f);
+        }
+
+        if (v_unmarked.empty())
+            continue;
+        v_marked.insert(i);
+        v_unmarked.erase(i);
+
+        dfs(*v_unmarked.begin());
+
+        if (v_unmarked.size() > 0) {
+            nm_vert++;
+            for (uint32_t f : f_adjacent)
+                kill_face(f);
+        }
+    }
+
+    if (nm_vert > 0 || nm_edge > 0)
+        cout << "Non-manifold elements:  vertices=" << nm_vert << ", edges=" << nm_edge << endl;
+
+    uint32_t nFaces = 0, nFacesOrig = F.cols();
+    for (uint32_t f = 0; f < (uint32_t) F.cols(); ++f) {
+        if (F(0, f) == INVALID)
+            continue;
+        if (nFaces != f) {
+            F.col(nFaces) = F.col(f);
+            Nf.col(nFaces) = Nf.col(f);
+        }
+        ++nFaces;
+    }
+
+    if (nFacesOrig != nFaces) {
+        F.conservativeResize(F.rows(), nFaces);
+        Nf.conservativeResize(Nf.rows(), nFaces);
+        cout << "Faces reduced from " << nFacesOrig << " -> " << nFaces << endl;
+    }
+}
+

intern/instant-meshes/src/cleanup.h

@@ -0,0 +1,18 @@
+/*
+    cleanup.h -- functionality to greedily drop non-manifold elements from a mesh
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+extern void remove_nonmanifold(MatrixXu &F, MatrixXf &V, MatrixXf &Nf);

intern/instant-meshes/src/common.h

@@ -0,0 +1,440 @@
+/*
+    common.h -- commonly used definitions, header files and inline functions
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#if defined(_WIN32)
+#  define NOMINMAX
+#  pragma warning(disable : 4244 4018 4100 4610 4510 4127 4512 4146 4267 4503 4800 4706)
+#endif
+/* clang-format off */
+
+#define _USE_MATH_DEFINES
+#include <cmath>
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <iomanip>
+#include <iostream>
+#include <mutex>
+#include <tbb/tbb.h>
+#include <thread>
+#include <vector>
+
+/* clang-format on */
+
+#define PARALLELIZE
+#define SINGLE_PRECISION
+#define GRAIN_SIZE 1024
+
+/* Application precision -- can be set to single or double precision */
+#if defined(SINGLE_PRECISION)
+typedef float Float;
+#else
+typedef double Float;
+#endif
+
+/* Useful Eigen typedefs based on the current precision */
+typedef Eigen::Matrix<int32_t, 2, 1> Vector2i;
+typedef Eigen::Matrix<int32_t, 3, 1> Vector3i;
+typedef Eigen::Matrix<int32_t, 4, 1> Vector4i;
+typedef Eigen::Matrix<uint32_t, 2, 1> Vector2u;
+typedef Eigen::Matrix<uint32_t, 3, 1> Vector3u;
+typedef Eigen::Matrix<uint32_t, 4, 1> Vector4u;
+typedef Eigen::Matrix<uint8_t, 4, 1> Vector4u8;
+typedef Eigen::Matrix<Float, 2, 1> Vector2f;
+typedef Eigen::Matrix<Float, 3, 1> Vector3f;
+typedef Eigen::Matrix<Float, 4, 1> Vector4f;
+typedef Eigen::Matrix<int32_t, Eigen::Dynamic, 1> VectorXi;
+typedef Eigen::Matrix<uint32_t, Eigen::Dynamic, 1> VectorXu;
+typedef Eigen::Matrix<uint8_t, Eigen::Dynamic, 1> VectorXu8;
+typedef Eigen::Matrix<bool, Eigen::Dynamic, 1> VectorXb;
+typedef Eigen::Matrix<Float, Eigen::Dynamic, 1> VectorXf;
+typedef Eigen::Matrix<int32_t, Eigen::Dynamic, Eigen::Dynamic> MatrixXi;
+typedef Eigen::Matrix<uint32_t, Eigen::Dynamic, Eigen::Dynamic> MatrixXu;
+typedef Eigen::Matrix<uint8_t, Eigen::Dynamic, Eigen::Dynamic> MatrixXu8;
+typedef Eigen::Matrix<Float, Eigen::Dynamic, Eigen::Dynamic> MatrixXf;
+typedef Eigen::Matrix<Float, 2, 2> Matrix2f;
+typedef Eigen::Matrix<Float, 3, 3> Matrix3f;
+typedef Eigen::Matrix<Float, 4, 4> Matrix4f;
+
+using std::cerr;
+using std::cout;
+using std::endl;
+using namespace std::placeholders;
+
+/* A callback to inform the GUI about progress of an operation */
+typedef std::function<void(const std::string &, Float)> ProgressCallback;
+
+#define PROGRESS_BLKSIZE (1 << 18)
+#define SHOW_PROGRESS(i, maxval, text) \
+  if (progress && (i % PROGRESS_BLKSIZE) == 0) \
+  progress(text, -PROGRESS_BLKSIZE / (Float)maxval)
+
+#define PROGRESS_SHIFT 18u
+#define SHOW_PROGRESS_RANGE(range, maxval, text) \
+  if (progress && range.begin() > 0) { \
+    uint32_t nUpdates = (range.end() >> PROGRESS_SHIFT) - \
+                        ((range.begin() - 1) >> PROGRESS_SHIFT); \
+    if (nUpdates > 0) { \
+      const uint32_t nUpdatesTotal = (uint32_t)(maxval) / (1 << PROGRESS_SHIFT); \
+      progress(text, -(float)nUpdates / (float)nUpdatesTotal); \
+    } \
+  }
+
+#if defined(_WIN32)
+#  define RCPOVERFLOW_FLT 2.93873587705571876e-39f
+#  define RCPOVERFLOW_DBL 5.56268464626800345e-309
+#else
+#  define RCPOVERFLOW_FLT 0x1p-128f
+#  define RCPOVERFLOW_DBL 0x1p-1024
+#endif
+
+#if defined(SINGLE_PRECISION)
+#  define RCPOVERFLOW RCPOVERFLOW_FLT
+#else
+#  define RCPOVERFLOW RCPOVERFLOW_DBL
+#endif
+
+template<typename TimeT = std::chrono::milliseconds> class Timer {
+ public:
+  Timer()
+  {
+    start = std::chrono::system_clock::now();
+  }
+
+  size_t value() const
+  {
+    auto now = std::chrono::system_clock::now();
+    auto duration = std::chrono::duration_cast<TimeT>(now - start);
+    return (size_t)duration.count();
+  }
+
+  size_t reset()
+  {
+    auto now = std::chrono::system_clock::now();
+    auto duration = std::chrono::duration_cast<TimeT>(now - start);
+    start = now;
+    return (size_t)duration.count();
+  }
+
+ private:
+  std::chrono::system_clock::time_point start;
+};
+
+inline std::string timeString(double time, bool precise = false)
+{
+  if (std::isnan(time) || std::isinf(time))
+    return "inf";
+
+  std::string suffix = "ms";
+  if (time > 1000) {
+    time /= 1000;
+    suffix = "s";
+    if (time > 60) {
+      time /= 60;
+      suffix = "m";
+      if (time > 60) {
+        time /= 60;
+        suffix = "h";
+        if (time > 12) {
+          time /= 12;
+          suffix = "d";
+        }
+      }
+    }
+  }
+
+  std::ostringstream os;
+  os << std::setprecision(precise ? 4 : 1) << std::fixed << time << suffix;
+
+  return os.str();
+}
+
+inline std::string memString(size_t size, bool precise = false)
+{
+  double value = (double)size;
+  const char *suffixes[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB"};
+  int suffix = 0;
+  while (suffix < 5 && value > 1024.0f) {
+    value /= 1024.0f;
+    ++suffix;
+  }
+
+  std::ostringstream os;
+  os << std::setprecision(suffix == 0 ? 0 : (precise ? 4 : 1)) << std::fixed << value << " "
+     << suffixes[suffix];
+
+  return os.str();
+}
+
+template<typename Matrix> inline size_t sizeInBytes(const Matrix &matrix)
+{
+  return matrix.size() * sizeof(typename Matrix::Scalar);
+}
+
+inline bool atomicCompareAndExchange(volatile uint32_t *v, uint32_t newValue, uint32_t oldValue)
+{
+#if defined(_WIN32)
+  return _InterlockedCompareExchange(reinterpret_cast<volatile long *>(v),
+                                     (long)newValue,
+                                     (long)oldValue) == (long)oldValue;
+#else
+  return __sync_bool_compare_and_swap(v, oldValue, newValue);
+#endif
+}
+
+inline uint32_t atomicAdd(volatile uint32_t *dst, uint32_t delta)
+{
+#if defined(_MSC_VER)
+  return _InterlockedExchangeAdd(reinterpret_cast<volatile long *>(dst), delta) + delta;
+#else
+  return __sync_add_and_fetch(dst, delta);
+#endif
+}
+
+inline float atomicAdd(volatile float *dst, float delta)
+{
+  union bits {
+    float f;
+    uint32_t i;
+  };
+  bits oldVal, newVal;
+  do {
+#if defined(__i386__) || defined(__amd64__)
+    __asm__ __volatile__("pause\n");
+#endif
+    oldVal.f = *dst;
+    newVal.f = oldVal.f + delta;
+  } while (!atomicCompareAndExchange((volatile uint32_t *)dst, newVal.i, oldVal.i));
+  return newVal.f;
+}
+
+/// Always-positive modulo function, Float precision version (assumes b > 0)
+inline Float modulo(Float a, Float b)
+{
+  Float r = std::fmod(a, b);
+  return (r < 0.0) ? r + b : r;
+}
+
+/// Always-positive modulo function (assumes b > 0)
+inline int32_t modulo(int32_t a, int32_t b)
+{
+  int32_t r = a % b;
+  return (r < 0) ? r + b : r;
+}
+
+inline float fast_acos(float x)
+{
+  float negate = float(x < 0.0f);
+  x = std::abs(x);
+  float ret = -0.0187293f;
+  ret *= x;
+  ret = ret + 0.0742610f;
+  ret *= x;
+  ret = ret - 0.2121144f;
+  ret *= x;
+  ret = ret + 1.5707288f;
+  ret = ret * std::sqrt(1.0f - x);
+  ret = ret - 2.0f * negate * ret;
+  return negate * (float)M_PI + ret;
+}
+
+template<typename T, typename U> inline T union_cast(const U &val)
+{
+  union {
+    U u;
+    T t;
+  } tmp = {val};
+  return tmp.t;
+}
+
+inline Float signum(Float value)
+{
+  return std::copysign((Float)1, value);
+}
+
+inline void coordinate_system(const Vector3f &a, Vector3f &b, Vector3f &c)
+{
+  if (std::abs(a.x()) > std::abs(a.y())) {
+    Float invLen = 1.0f / std::sqrt(a.x() * a.x() + a.z() * a.z());
+    c = Vector3f(a.z() * invLen, 0.0f, -a.x() * invLen);
+  }
+  else {
+    Float invLen = 1.0f / std::sqrt(a.y() * a.y() + a.z() * a.z());
+    c = Vector3f(0.0f, a.z() * invLen, -a.y() * invLen);
+  }
+  b = c.cross(a);
+}
+
+class ordered_lock {
+ public:
+  ordered_lock() : next_ticket(0), counter(0)
+  {
+  }
+  void lock()
+  {
+    std::unique_lock<std::mutex> acquire(cvar_lock);
+    unsigned int ticket = next_ticket++;
+    while (ticket != counter)
+      cvar.wait(acquire);
+  }
+  void unlock()
+  {
+    std::unique_lock<std::mutex> acquire(cvar_lock);
+    counter++;
+    cvar.notify_all();
+  }
+
+ protected:
+  std::condition_variable cvar;
+  std::mutex cvar_lock;
+  unsigned int next_ticket, counter;
+};
+
+inline std::string str_tolower(std::string str)
+{
+  std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+  return str;
+}
+
+inline uint32_t str_to_uint32_t(const std::string &str)
+{
+  char *end_ptr = nullptr;
+  uint32_t result = (uint32_t)strtoul(str.c_str(), &end_ptr, 10);
+  if (*end_ptr != '\0')
+    throw std::runtime_error("Could not parse unsigned integer \"" + str + "\"");
+  return result;
+}
+
+inline uint32_t str_to_int32_t(const std::string &str)
+{
+  char *end_ptr = nullptr;
+  int32_t result = (int32_t)strtol(str.c_str(), &end_ptr, 10);
+  if (*end_ptr != '\0')
+    throw std::runtime_error("Could not parse signed integer \"" + str + "\"");
+  return result;
+}
+
+inline Float str_to_float(const std::string &str)
+{
+  char *end_ptr = nullptr;
+  Float result = (Float)strtod(str.c_str(), &end_ptr);
+  if (*end_ptr != '\0')
+    throw std::runtime_error("Could not parse floating point value \"" + str + "\"");
+  return result;
+}
+
+inline std::vector<std::string> &str_tokenize(const std::string &s,
+                                              char delim,
+                                              std::vector<std::string> &elems,
+                                              bool include_empty = false)
+{
+  std::stringstream ss(s);
+  std::string item;
+  while (std::getline(ss, item, delim))
+    if (!item.empty() || include_empty)
+      elems.push_back(item);
+  return elems;
+}
+
+inline std::vector<std::string> str_tokenize(const std::string &s, char delim, bool include_empty)
+{
+  std::vector<std::string> elems;
+  str_tokenize(s, delim, elems, include_empty);
+  return elems;
+}
+
+inline void jet(float x, float &r, float &g, float &b)
+{
+  const Float rone = 0.8f, gone = 1.0f, bone = 1.0f;
+
+  x = std::max(std::min(x, 1.f), 0.f);
+
+  if (x < 1.f / 8.f) {
+    r = 0;
+    g = 0;
+    b = bone * (.5f + x / (1.f / 8.f) * 0.5f);
+  }
+  else if (x < 3.f / 8.f) {
+    r = 0;
+    g = gone * (x - 1.f / 8.f) / (3.f / 8.f - 1.f / 8.f);
+    b = bone;
+  }
+  else if (x < 5.f / 8.f) {
+    r = rone * (x - 3.f / 8.f) / (5.f / 8.f - 3.f / 8.f);
+    g = gone;
+    b = (bone - (x - 3.f / 8.f) / (5.f / 8.f - 3.f / 8.f));
+  }
+  else if (x < 7.f / 8.f) {
+    r = rone;
+    g = (gone - (x - 5.f / 8.f) / (7.f / 8.f - 5.f / 8.f));
+    b = 0;
+  }
+  else {
+    r = (rone - (x - 7.f / 8.f) / (1.f - 7.f / 8.f) * .5f);
+    g = 0;
+    b = 0;
+  }
+}
+
+inline void jet(VectorXf &X, MatrixXu8 &C, float min, float max)
+{
+  for (int i = 0; i < X.size(); ++i) {
+    float r, g, b;
+    jet((-min + X[i]) / (max - min), r, g, b);
+    C.col(i) << (uint8_t)(r * 255.f), (uint8_t)(g * 255.f), (uint8_t)(b * 255.f), (uint8_t)255;
+  }
+}
+
+inline void jet(VectorXf &X, MatrixXu8 &C)
+{
+  jet(X, C, X.minCoeff(), X.maxCoeff());
+}
+
+inline Vector3f hsv_to_rgb(Float h, Float s, Float v)
+{
+  if (s == 0.f) {  // achromatic (grey)
+    return Vector3f::Constant(v);
+  }
+  h *= 6;
+  int i = std::floor(h);
+  Float f = h - i;  // fractional part of h
+  Float p = v * (1 - s);
+  Float q = v * (1 - s * f);
+  Float t = v * (1 - s * (1 - f));
+  switch (i) {
+    case 0:
+      return Vector3f(v, t, p);
+      break;
+    case 1:
+      return Vector3f(q, v, p);
+      break;
+    case 2:
+      return Vector3f(p, v, t);
+      break;
+    case 3:
+      return Vector3f(p, q, v);
+      break;
+    case 4:
+      return Vector3f(t, p, v);
+      break;
+    default:
+      return Vector3f(v, p, q);
+      break;
+  }
+}

intern/instant-meshes/src/dedge.cpp

@@ -0,0 +1,156 @@
+/*
+    dedge.cpp: Parallel directed edge data structure builder
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "dedge.h"
+
+void build_dedge(const MatrixXu &F, const MatrixXf &V, VectorXu &V2E,
+                         VectorXu &E2E, VectorXb &boundary, VectorXb &nonManifold,
+                         const ProgressCallback &progress, bool quiet) {
+    if (!quiet) {
+        cout << "Building a directed edge data structure .. ";
+        cout.flush();
+    }
+    Timer<> timer;
+
+    if (progress && !quiet)
+        progress("Building directed edge data structure", 0.0f);
+
+    V2E.resize(V.cols());
+    V2E.setConstant(INVALID);
+
+    uint32_t deg = F.rows();
+    std::vector<std::pair<uint32_t, uint32_t>> tmp(F.size());
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) F.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                for (uint32_t i = 0; i < deg; ++i) {
+                    uint32_t idx_cur = F(i, f),
+                             idx_next = F((i+1)%deg, f),
+                             edge_id = deg * f + i;
+                    if (idx_cur >= V.cols() || idx_next >= V.cols())
+                        throw std::runtime_error("Mesh data contains an out-of-bounds vertex reference!");
+                    if (idx_cur == idx_next)
+                        continue;
+
+                    tmp[edge_id] = std::make_pair(idx_next, INVALID);
+                    if (!atomicCompareAndExchange(&V2E[idx_cur], edge_id, INVALID)) {
+                        uint32_t idx = V2E[idx_cur];
+                        while (!atomicCompareAndExchange(&tmp[idx].second, edge_id, INVALID))
+                            idx = tmp[idx].second;
+                    }
+                }
+            }
+            if (!quiet)
+                SHOW_PROGRESS_RANGE(range, F.cols(), "Building directed edge data structure (1/3)");
+        }
+    );
+
+    nonManifold.resize(V.cols());
+    nonManifold.setConstant(false);
+
+    E2E.resize(F.cols() * deg);
+    E2E.setConstant(INVALID);
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) F.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                for (uint32_t i = 0; i < deg; ++i) {
+                    uint32_t idx_cur = F(i, f),
+                             idx_next = F((i+1)%deg, f),
+                             edge_id_cur = deg * f + i;
+
+                    if (idx_cur == idx_next)
+                        continue;
+
+                    uint32_t it = V2E[idx_next], edge_id_opp = INVALID;
+                    while (it != INVALID) {
+                        if (tmp[it].first == idx_cur) {
+                            if (edge_id_opp == INVALID) {
+                                edge_id_opp = it;
+                            } else {
+                                nonManifold[idx_cur] = true;
+                                nonManifold[idx_next] = true;
+                                edge_id_opp = INVALID;
+                                break;
+                            }
+                        }
+                        it = tmp[it].second;
+                    }
+
+                    if (edge_id_opp != INVALID && edge_id_cur < edge_id_opp) {
+                        E2E[edge_id_cur] = edge_id_opp;
+                        E2E[edge_id_opp] = edge_id_cur;
+                    }
+                }
+            }
+            if (!quiet)
+                SHOW_PROGRESS_RANGE(range, F.cols(), "Building directed edge data structure (2/3)");
+        }
+    );
+
+    std::atomic<uint32_t> nonManifoldCounter(0), boundaryCounter(0), isolatedCounter(0);
+
+    boundary.resize(V.cols());
+    boundary.setConstant(false);
+
+    /* Detect boundary regions of the mesh and adjust vertex->edge pointers*/
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i];
+                if (edge == INVALID) {
+                    isolatedCounter++;
+                    continue;
+                }
+                if (nonManifold[i]) {
+                    nonManifoldCounter++;
+                    V2E[i] = INVALID;
+                    continue;
+                }
+
+                /* Walk backwards to the first boundary edge (if any) */
+                uint32_t start = edge, v2e = INVALID;
+                do {
+                    v2e  = std::min(v2e, edge);
+                    uint32_t prevEdge = E2E[dedge_prev(edge, deg)];
+                    if (prevEdge == INVALID) {
+                        /* Reached boundary -- update the vertex->edge link */
+                        v2e = edge;
+                        boundary[i] = true;
+                        boundaryCounter++;
+                        break;
+                    }
+                    edge = prevEdge;
+                } while (edge != start);
+                V2E[i] = v2e;
+            }
+            if (!quiet)
+                SHOW_PROGRESS_RANGE(range, V.cols(), "Building directed edge data structure (3/3)");
+        }
+    );
+
+    if (!quiet) {
+        cout << "done. (";
+        if (nonManifoldCounter)
+            cout << nonManifoldCounter << " non-manifold vertices, ";
+        if (boundaryCounter)
+            cout << boundaryCounter << " boundary vertices, ";
+        if (isolatedCounter)
+            cout << isolatedCounter << " isolated vertices, ";
+        cout << "took " << timeString(timer.value()) << ")" << endl;
+    }
+}

intern/instant-meshes/src/dedge.h

@@ -0,0 +1,31 @@
+/*
+    dedge.h: Parallel directed edge data structure builder
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+static const uint32_t INVALID = (uint32_t) -1;
+
+inline uint32_t dedge_prev_3(uint32_t e) { return (e % 3 == 0) ? e + 2 : e - 1; }
+inline uint32_t dedge_next_3(uint32_t e) { return (e % 3 == 2) ? e - 2 : e + 1; }
+inline uint32_t dedge_prev_4(uint32_t e) { return (e % 4 == 0) ? e + 3 : e - 1; }
+inline uint32_t dedge_next_4(uint32_t e) { return (e % 4 == 3) ? e - 3 : e + 1; }
+
+inline uint32_t dedge_prev(uint32_t e, uint32_t deg) { return (e % deg == 0u) ? e + (deg - 1) : e - 1; }
+inline uint32_t dedge_next(uint32_t e, uint32_t deg) { return (e % deg == deg - 1) ? e - (deg - 1) : e + 1; }
+
+extern void build_dedge(const MatrixXu &F, const MatrixXf &V, VectorXu &V2E,
+                         VectorXu &E2E, VectorXb &boundary, VectorXb &nonManifold,
+                         const ProgressCallback &progress = ProgressCallback(),
+                         bool quiet = false);

intern/instant-meshes/src/diff.cpp

@@ -0,0 +1,18 @@
+#include "serializer.h"
+
+int main(int argc, char **argv) {
+    if (argc < 3) {
+        cout << "Syntax: diff [application state 1.ply] [application state 2.ply]" << endl;
+        return -1;
+    }
+    Serializer s1(argv[1]);
+    cout << s1 << endl;
+    Serializer s2(argv[2]);
+    cout << s2 << endl;
+
+    bool diff = s1.diff(s2);
+    if (!diff)
+        cout << "No differences found." << endl;
+
+    return diff ? 1 : 0;
+}

intern/instant-meshes/src/extract.h

@@ -0,0 +1,43 @@
+/*
+    extract.h: Mesh extraction from existing orientation/position fields
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "hierarchy.h"
+#include <set>
+
+struct TaggedLink {
+    uint32_t id;
+    uint8_t flag;
+    TaggedLink(uint32_t id) : id(id), flag(0) { }
+    bool used() const { return flag & 1; }
+    void markUsed() { flag |= 1; }
+};
+
+class BVH;
+
+extern void
+extract_graph(const MultiResolutionHierarchy &mRes, bool extrinsic, int rosy, int posy,
+              std::vector<std::vector<TaggedLink>> &adj_new,
+              MatrixXf &O_new, MatrixXf &N_new,
+              const std::set<uint32_t> &crease_in,
+              std::set<uint32_t> &crease_out,
+              bool deterministic, bool remove_spurious_vertices = true,
+              bool remove_unnecessary_triangles = true,
+              bool snap_vertices = true);
+
+extern void extract_faces(std::vector<std::vector<TaggedLink> > &adj,
+                          MatrixXf &O, MatrixXf &N, MatrixXf &Nf, MatrixXu &F,
+                          int posy, Float scale, std::set<uint32_t> &crease,
+                          bool fill_holes = true, bool pure_quad = true,
+                          BVH *bvh = nullptr, int smooth_iterations = 2);

intern/instant-meshes/src/field.h

@@ -0,0 +1,296 @@
+/*
+    field.h: Routines for averaging orientations and directions subject
+    to various symmetry conditions. Also contains the Optimizer class which
+    uses these routines to smooth fields hierarchically.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "hierarchy.h"
+#include <map>
+
+/* Rotation helper functions */
+extern Vector3f rotate60(const Vector3f &d, const Vector3f &n);
+extern Vector3f rotate90(const Vector3f &d, const Vector3f &n);
+extern Vector3f rotate180(const Vector3f &d, const Vector3f &n);
+extern Vector3f rotate60_by(const Vector3f &d, const Vector3f &n, int amount);
+extern Vector3f rotate90_by(const Vector3f &d, const Vector3f &n, int amount);
+extern Vector3f rotate180_by(const Vector3f &d, const Vector3f &n, int amount);
+extern Vector2i rshift60(Vector2i shift, int amount);
+extern Vector2i rshift90(Vector2i shift, int amount);
+extern Vector2i rshift180(Vector2i shift, int amount);
+extern Vector3f rotate_vector_into_plane(Vector3f q,
+                                         const Vector3f &source_normal,
+                                         const Vector3f &target_normal);
+
+/* Extrinsic & intrinsic orientation symmetry functors */
+extern std::pair<Vector3f, Vector3f> compat_orientation_intrinsic_2(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_intrinsic_4(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_intrinsic_4_knoeppel(const Vector3f &q0,
+                                                                             const Vector3f &n0,
+                                                                             const Vector3f &q1,
+                                                                             const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_intrinsic_6(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_extrinsic_2(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_extrinsic_4(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<Vector3f, Vector3f> compat_orientation_extrinsic_6(const Vector3f &q0,
+                                                                    const Vector3f &n0,
+                                                                    const Vector3f &q1,
+                                                                    const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_extrinsic_index_2(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_extrinsic_index_4(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_extrinsic_index_6(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_intrinsic_index_2(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_intrinsic_index_4(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+extern std::pair<int, int> compat_orientation_intrinsic_index_6(const Vector3f &q0,
+                                                                const Vector3f &n0,
+                                                                const Vector3f &q1,
+                                                                const Vector3f &n1);
+
+/* Extrinsic & intrinsic position symmetry functors */
+extern std::pair<Vector3f, Vector3f> compat_position_extrinsic_3(const Vector3f &p0,
+                                                                 const Vector3f &n0,
+                                                                 const Vector3f &q0,
+                                                                 const Vector3f &o0,
+                                                                 const Vector3f &p1,
+                                                                 const Vector3f &n1,
+                                                                 const Vector3f &q1,
+                                                                 const Vector3f &o1,
+                                                                 Float scale,
+                                                                 Float inv_scale);
+
+extern std::pair<Vector3f, Vector3f> compat_position_extrinsic_4(const Vector3f &p0,
+                                                                 const Vector3f &n0,
+                                                                 const Vector3f &q0,
+                                                                 const Vector3f &o0,
+                                                                 const Vector3f &p1,
+                                                                 const Vector3f &n1,
+                                                                 const Vector3f &q1,
+                                                                 const Vector3f &o1,
+                                                                 Float scale,
+                                                                 Float inv_scale);
+
+extern std::pair<Vector2i, Vector2i> compat_position_extrinsic_index_3(const Vector3f &p0,
+                                                                       const Vector3f &n0,
+                                                                       const Vector3f &q0,
+                                                                       const Vector3f &o0,
+                                                                       const Vector3f &p1,
+                                                                       const Vector3f &n1,
+                                                                       const Vector3f &q1,
+                                                                       const Vector3f &o1,
+                                                                       Float scale,
+                                                                       Float inv_scale,
+                                                                       Float *error = nullptr);
+
+extern std::pair<Vector2i, Vector2i> compat_position_extrinsic_index_4(const Vector3f &p0,
+                                                                       const Vector3f &n0,
+                                                                       const Vector3f &q0,
+                                                                       const Vector3f &o0,
+                                                                       const Vector3f &p1,
+                                                                       const Vector3f &n1,
+                                                                       const Vector3f &q1,
+                                                                       const Vector3f &o1,
+                                                                       Float scale,
+                                                                       Float inv_scale,
+                                                                       Float *error = nullptr);
+
+extern std::pair<Vector3f, Vector3f> compat_position_intrinsic_3(const Vector3f &p0,
+                                                                 const Vector3f &n0,
+                                                                 const Vector3f &q0,
+                                                                 const Vector3f &o0,
+                                                                 const Vector3f &p1,
+                                                                 const Vector3f &n1,
+                                                                 const Vector3f &q1,
+                                                                 const Vector3f &o1,
+                                                                 Float scale,
+                                                                 Float inv_scale);
+
+extern std::pair<Vector3f, Vector3f> compat_position_intrinsic_4(const Vector3f &p0,
+                                                                 const Vector3f &n0,
+                                                                 const Vector3f &q0,
+                                                                 const Vector3f &o0,
+                                                                 const Vector3f &p1,
+                                                                 const Vector3f &n1,
+                                                                 const Vector3f &q1,
+                                                                 const Vector3f &o1,
+                                                                 Float scale,
+                                                                 Float inv_scale);
+
+extern std::pair<Vector2i, Vector2i> compat_position_intrinsic_index_3(const Vector3f &p0,
+                                                                       const Vector3f &n0,
+                                                                       const Vector3f &q0,
+                                                                       const Vector3f &o0,
+                                                                       const Vector3f &p1,
+                                                                       const Vector3f &n1,
+                                                                       const Vector3f &q1,
+                                                                       const Vector3f &o1,
+                                                                       Float scale,
+                                                                       Float inv_scale,
+                                                                       Float *error = nullptr);
+
+extern std::pair<Vector2i, Vector2i> compat_position_intrinsic_index_4(const Vector3f &p0,
+                                                                       const Vector3f &n0,
+                                                                       const Vector3f &q0,
+                                                                       const Vector3f &o0,
+                                                                       const Vector3f &p1,
+                                                                       const Vector3f &n1,
+                                                                       const Vector3f &q1,
+                                                                       const Vector3f &o1,
+                                                                       Float scale,
+                                                                       Float inv_scale,
+                                                                       Float *error = nullptr);
+
+/* Optimization kernels */
+
+extern Float optimize_orientations(MultiResolutionHierarchy &mRes,
+                                   int level,
+                                   bool extrinsic,
+                                   int rosy,
+                                   const std::function<void(uint32_t)> &progress);
+
+extern Float optimize_positions(MultiResolutionHierarchy &mRes,
+                                int level,
+                                bool extrinsic,
+                                int posy,
+                                const std::function<void(uint32_t)> &progress);
+
+/* Singularity computation */
+
+extern void compute_orientation_singularities(const MultiResolutionHierarchy &mRes,
+                                              std::map<uint32_t, uint32_t> &sing,
+                                              bool extrinsic,
+                                              int rosy);
+
+extern void compute_position_singularities(const MultiResolutionHierarchy &mRes,
+                                           const std::map<uint32_t, uint32_t> &orient_sing,
+                                           std::map<uint32_t, Vector2i> &pos_sing,
+                                           bool extrinsic,
+                                           int rosy,
+                                           int posy);
+
+/* Field optimizer (invokes optimization kernels in a separate thread) */
+
+class Serializer;
+class Optimizer {
+ public:
+  /* clang-format off */
+
+    Optimizer(MultiResolutionHierarchy &mRes, bool interactive);
+    void save(Serializer &state);
+    void load(const Serializer &state);
+
+    void stop() {
+        if (mOptimizeOrientations)
+            mRes.propagateSolution(mRoSy);
+        mOptimizePositions = mOptimizeOrientations = false;
+        notify(); 
+    }
+
+    void shutdown() { mRunning = false; notify(); mThread.join(); }
+
+    bool active() { return mOptimizePositions | mOptimizeOrientations; }
+    inline void notify() { mCond.notify_all(); }
+
+    void optimizeOrientations(int level);
+
+    void optimizePositions(int level);
+
+    void wait();
+
+    void setExtrinsic(bool extrinsic) { mExtrinsic = extrinsic; }
+    bool extrinsic() const { return mExtrinsic; }
+
+    void setRoSy(int rosy) { mRoSy = rosy; }
+    int rosy() const { return mRoSy; }
+    void setPoSy(int posy) { mPoSy = posy; }
+    int posy() const { return mPoSy; }
+    void setLevel(int level) { mLevel = level; }
+    int level() const { return mLevel; }
+    Float progress() const { return mProgress; }
+
+#ifdef VISUALIZE_ERROR
+    const VectorXf &error() { return mError; }
+#endif
+
+  /* clang-format on */
+
+  void moveSingularity(const std::vector<uint32_t> &path, bool orientations)
+  {
+    std::lock_guard<ordered_lock> lock(mRes.mutex());
+    mAttractorStrokes.push_back(std::make_pair(orientations, path));
+    setLevel(0);
+  }
+
+  void run();
+
+ protected:
+  MultiResolutionHierarchy &mRes;
+  std::vector<std::pair<bool, std::vector<uint32_t>>> mAttractorStrokes;
+  bool mRunning;
+  bool mOptimizeOrientations;
+  bool mOptimizePositions;
+  std::thread mThread;
+  std::condition_variable_any mCond;
+  int mLevel, mLevelIterations;
+  bool mHierarchical;
+  int mRoSy, mPoSy;
+  bool mExtrinsic;
+  bool mInteractive;
+  double mLastUpdate;
+  Float mProgress;
+#ifdef VISUALIZE_ERROR
+  VectorXf mError;
+#endif
+  Timer<> mTimer;
+};

intern/instant-meshes/src/glutil.cpp

@@ -0,0 +1,88 @@
+/*
+    glutil.cpp: Represents the state of an OpenGL shader together with attached
+    buffers. The entire state can be serialized and unserialized from a file,
+    which is useful for debugging.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "glutil.h"
+
+void SerializableGLShader::load(const Serializer &serializer) {
+    serializer.pushPrefix(mName);
+    std::vector<std::string> key_list = serializer.getKeys();
+    std::set<std::string> keys;
+    for (auto key : key_list) {
+        if (key.find(".") != std::string::npos)
+            keys.insert(key.substr(0, key.find(".")));
+    }
+    bind();
+    for (auto key : keys) {
+        if (mBufferObjects.find(key) == mBufferObjects.end()) {
+            GLuint bufferID;
+            glGenBuffers(1, &bufferID);
+            mBufferObjects[key].id = bufferID;
+        }
+        Buffer &buf = mBufferObjects[key];
+        MatrixXu8 data;
+
+        serializer.pushPrefix(key);
+        serializer.get("glType", buf.glType);
+        serializer.get("compSize", buf.compSize);
+        serializer.get("dim", buf.dim);
+        serializer.get("size", buf.size);
+        serializer.get("version", buf.version);
+        serializer.get("data", data);
+        serializer.popPrefix();
+
+        size_t totalSize = (size_t) buf.size * (size_t) buf.compSize;
+        if (key == "indices") {
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf.id);
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, totalSize,
+                         (void *) data.data(), GL_DYNAMIC_DRAW);
+        } else {
+            int attribID = attrib(key);
+            glEnableVertexAttribArray(attribID);
+            glBindBuffer(GL_ARRAY_BUFFER, buf.id);
+            glBufferData(GL_ARRAY_BUFFER, totalSize, (void *) data.data(),
+                         GL_DYNAMIC_DRAW);
+            glVertexAttribPointer(attribID, buf.dim, buf.glType,
+                                  buf.compSize == 1 ? GL_TRUE : GL_FALSE, 0, 0);
+        }
+    }
+    serializer.popPrefix();
+}
+
+void SerializableGLShader::save(Serializer &serializer) const {
+    serializer.pushPrefix(mName);
+    for (auto &item : mBufferObjects) {
+        const Buffer &buf = item.second;
+        size_t totalSize = (size_t) buf.size * (size_t) buf.compSize;
+        serializer.pushPrefix(item.first);
+        serializer.set("glType", buf.glType);
+        serializer.set("compSize", buf.compSize);
+        serializer.set("dim", buf.dim);
+        serializer.set("size", buf.size);
+        serializer.set("version", buf.version);
+        MatrixXu8 temp(1, totalSize);
+
+        if (item.first == "indices") {
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf.id);
+            glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, totalSize,
+                               temp.data());
+        } else {
+            glBindBuffer(GL_ARRAY_BUFFER, buf.id);
+            glGetBufferSubData(GL_ARRAY_BUFFER, 0, totalSize, temp.data());
+        }
+        serializer.set("data", temp);
+        serializer.popPrefix();
+    }
+    serializer.popPrefix();
+}

intern/instant-meshes/src/glutil.h

@@ -0,0 +1,34 @@
+/*
+    glutil.h: Represents the state of an OpenGL shader together with attached
+    buffers. The entire state can be serialized and unserialized from a file,
+    which is useful for debugging.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "serializer.h"
+#include <nanogui/glutil.h>
+#include <half.hpp>
+
+class SerializableGLShader : public nanogui::GLShader {
+public:
+    SerializableGLShader() : nanogui::GLShader() { }
+
+    void load(const Serializer &serializer);
+    void save(Serializer &serializer) const;
+
+     // Upload an Eigen matrix and convert to half precision
+     template <typename Matrix> void uploadAttrib_half(const std::string &name, const Matrix &_M, int version = -1) {
+         Eigen::Matrix<half_float::half, Eigen::Dynamic, Eigen::Dynamic> M = _M.template cast<half_float::half>();
+         uploadAttrib(name, M, version);
+     }
+};

intern/instant-meshes/src/gui_serializer.h

@@ -0,0 +1,263 @@
+/*
+    gui_serializer.h: Utility class for serializing the entire user interface
+    state to a file. which is useful for debugging.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+
+#pragma once
+
+#include "widgets.h"
+#include "serializer.h"
+
+class GUISerializer : public Serializer {
+public:
+    GUISerializer() : Serializer() { }
+    GUISerializer(const std::string &filename, bool compat) : Serializer(filename, compat) { }
+    GUISerializer(const std::string &filename, bool compatibilityMode = false,
+               const ProgressCallback &progress = ProgressCallback()) : Serializer(filename, compatibilityMode, progress) { }
+    using Serializer::get;
+    using Serializer::set;
+
+    bool get(const std::string &key, Widget *widget) const {
+        pushPrefix(key);
+        bool result = getRecursive(widget);
+        popPrefix();
+        return result;
+    }
+
+    void set(const std::string &key, const Widget *widget) {
+        pushPrefix(key);
+        setRecursive(widget);
+        popPrefix();
+    }
+protected:
+    void setRecursive(const Widget *widget) {
+        bool serialize = widget->id().length() > 0;
+        if (serialize) {
+            pushPrefix(widget->id());
+
+            if (dynamic_cast<const TextBox *>(widget))
+                setTextBox((const TextBox *) widget);
+            else if (dynamic_cast<const Slider *>(widget))
+                setSlider((const Slider *) widget);
+            else if (dynamic_cast<const ComboBox *>(widget))
+                setComboBox((const ComboBox *) widget);
+            else if (dynamic_cast<const CheckBox *>(widget))
+                setCheckBox((const CheckBox *) widget);
+            else if (dynamic_cast<const ProgressButton *>(widget))
+                setProgressButton((const ProgressButton *) widget);
+            else if (dynamic_cast<const Button *>(widget))
+                setButton((const Button *) widget);
+            else if (dynamic_cast<const Label *>(widget))
+                setLabel((const Label *) widget);
+            else
+                setWidget(widget);
+        }
+
+        for (const Widget *child : widget->children())
+            setRecursive(child);
+
+        if (serialize)
+            popPrefix();
+    }
+
+    bool getRecursive(Widget *widget) const {
+        bool serialize = widget->id().length() > 0;
+        bool success = true;
+        if (serialize) {
+            pushPrefix(widget->id());
+
+            if (dynamic_cast<TextBox *>(widget))
+                success &= getTextBox((TextBox *) widget);
+            else if (dynamic_cast<Slider *>(widget))
+                success &= getSlider((Slider *) widget);
+            else if (dynamic_cast<ComboBox *>(widget))
+                success &= getComboBox((ComboBox *) widget);
+            else if (dynamic_cast<CheckBox *>(widget))
+                success &= getCheckBox((CheckBox *) widget);
+            else if (dynamic_cast<ProgressButton *>(widget))
+                success &= getProgressButton((ProgressButton *) widget);
+            else if (dynamic_cast<Button *>(widget))
+                success &= getButton((Button *) widget);
+            else if (dynamic_cast<Label *>(widget))
+                success &= getLabel((Label *) widget);
+            else
+                success &= getWidget(widget);
+        }
+
+        for (Widget *child : widget->children())
+            success &= getRecursive(child);
+
+        if (serialize)
+            popPrefix();
+        return success;
+    }
+
+    void setWidget(const Widget *widget) {
+        set("position", widget->position());
+        set("size", widget->size());
+        set("fixedSize", widget->fixedSize());
+        set("visible", widget->visible());
+        set("enabled", widget->enabled());
+        set("focused", widget->focused());
+        set("tooltip", widget->tooltip());
+        set("fontSize", widget->hasFontSize() ? widget->fontSize() : -1);
+    }
+
+    #define try_get(name, ref) \
+        if (!get(name, ref)) \
+            return false;
+
+    bool getWidget(Widget *widget) const {
+        Vector2i v2i_val;
+        bool bool_val;
+        std::string str_val;
+        int int_val;
+
+        try_get("position", v2i_val); widget->setPosition(v2i_val);
+        try_get("size", v2i_val); widget->setSize(v2i_val);
+        try_get("fixedSize", v2i_val); widget->setFixedSize(v2i_val);
+        try_get("visible", bool_val); widget->setVisible(bool_val);
+        try_get("enabled", bool_val); widget->setEnabled(bool_val);
+        try_get("focused", bool_val); widget->setFocused(bool_val);
+        try_get("tooltip", str_val); widget->setTooltip(str_val);
+        try_get("fontSize", int_val); widget->setFontSize(int_val);
+        return true;
+    }
+
+    void setLabel(const Label *widget) {
+        setWidget(widget);
+
+        set("caption", widget->caption());
+        set("font", widget->font());
+        set("fontSize", widget->fontSize());
+    }
+
+    bool getLabel(Label *widget) const {
+        getWidget(widget);
+
+        std::string str_val;
+        try_get("caption", str_val); widget->setCaption(str_val);
+        try_get("font", str_val); widget->setFont(str_val);
+        return true;
+    }
+
+    void setButton(const Button *widget) {
+        setWidget(widget);
+
+        set("caption", widget->caption());
+        set("icon", widget->icon());
+        set("iconPosition", (int) widget->iconPosition());
+        set("pushed", widget->pushed());
+        set("buttonFlags", widget->flags());
+        set("backgroundColor", widget->backgroundColor());
+        set("textColor", widget->textColor());
+    }
+
+    bool getButton(Button *widget) const {
+        getWidget(widget);
+        Color col_val;
+        int int_val;
+        bool bool_val;
+        std::string str_val;
+
+        try_get("caption", str_val); widget->setCaption(str_val);
+        try_get("icon", int_val); widget->setIcon(int_val);
+        try_get("iconPosition", int_val); widget->setIconPosition((Button::IconPosition) int_val);
+        try_get("pushed", bool_val); widget->setPushed(bool_val);
+        try_get("buttonFlags", int_val); widget->setFlags(int_val);
+        try_get("backgroundColor", col_val); widget->setBackgroundColor(col_val);
+        try_get("textColor", col_val); widget->setTextColor(col_val);
+        try_get("fontSize", int_val); widget->setFontSize(int_val);
+        return true;
+    }
+
+    void setProgressButton(const ProgressButton *widget) {
+        setButton(widget);
+
+        set("progress", widget->progress());
+    }
+
+    bool getProgressButton(ProgressButton *widget) const {
+        getButton(widget);
+        Float float_val;
+        try_get("progress", float_val); widget->setProgress(float_val);
+        return true;
+    }
+
+    void setCheckBox(const CheckBox *widget) {
+        setWidget(widget);
+
+        set("caption", widget->caption());
+        set("pushed", widget->pushed());
+        set("checked", widget->checked());
+    }
+
+    bool getCheckBox(CheckBox *widget) const {
+        getWidget(widget);
+        bool bool_val;
+        std::string str_val;
+
+        try_get("caption", str_val); widget->setCaption(str_val);
+        try_get("pushed", bool_val); widget->setPushed(bool_val);
+        try_get("checked", bool_val); widget->setChecked(bool_val);
+        return true;
+    }
+
+    void setComboBox(const ComboBox *widget) {
+        setButton(widget);
+        set("selectedIndex", widget->selectedIndex());
+    }
+
+    bool getComboBox(ComboBox *widget) const {
+        getButton(widget);
+        int int_val;
+        try_get("selectedIndex", int_val); widget->setSelectedIndex(int_val);
+        return true;
+    }
+
+    void setSlider(const Slider *widget) {
+        setWidget(widget);
+        set("value", widget->value());
+        set("highlightedRange.min", widget->highlightedRange().first);
+        set("highlightedRange.max", widget->highlightedRange().second);
+    }
+
+    bool getSlider(Slider *widget) const {
+        getWidget(widget);
+        float float_val, float_val_2;
+        try_get("value", float_val); widget->setValue(float_val);
+        try_get("highlightedRange.min", float_val);
+        try_get("highlightedRange.max", float_val_2);
+        widget->setHighlightedRange(std::make_pair(float_val, float_val_2));
+        return true;
+    }
+
+    void setTextBox(const TextBox *widget) {
+        setWidget(widget);
+        set("value", widget->value());
+        set("units", widget->units());
+        set("unitsImage", widget->unitsImage());
+    }
+
+    bool getTextBox(TextBox *widget) const {
+        getWidget(widget);
+        std::string str_value;
+        int int_value;
+
+        try_get("value", str_value); widget->setValue(str_value);
+        try_get("units", str_value); widget->setUnits(str_value);
+        try_get("unitsImage", int_value); widget->setUnitsImage(int_value);
+        return true;
+    }
+    #undef try_get
+};

intern/instant-meshes/src/hierarchy.cpp

@@ -0,0 +1,873 @@
+/*
+    hierarchy.cpp: Code to generate unstructured multi-resolution hierarchies
+    from meshes or point clouds
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "hierarchy.h"
+#include "serializer.h"
+#include "dedge.h"
+#include "field.h"
+#include <parallel_stable_sort.h>
+#include <pcg32.h>
+
+AdjacencyMatrix downsample_graph(const AdjacencyMatrix adj, const MatrixXf &V,
+                                 const MatrixXf &N, const VectorXf &A,
+                                 MatrixXf &V_p, MatrixXf &N_p, VectorXf &A_p,
+                                 MatrixXu &to_upper, VectorXu &to_lower,
+                                 bool deterministic,
+                                 const ProgressCallback &progress) {
+    struct Entry {
+        uint32_t i, j;
+        float order;
+        inline Entry() { };
+        inline Entry(uint32_t i, uint32_t j, float order) : i(i), j(j), order(order) { }
+        inline bool operator<(const Entry &e) const { return order > e.order; }
+    };
+
+    uint32_t nLinks = adj[V.cols()] - adj[0];
+    Entry *entries = new Entry[nLinks];
+    Timer<> timer;
+    cout << "  Collapsing .. ";
+    cout.flush();
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t nNeighbors = adj[i + 1] - adj[i];
+                uint32_t base = adj[i] - adj[0];
+                for (uint32_t j = 0; j < nNeighbors; ++j) {
+                    uint32_t k = adj[i][j].id;
+                    Float dp = N.col(i).dot(N.col(k));
+                    Float ratio = A[i]>A[k] ? (A[i]/A[k]) : (A[k]/A[i]);
+                    entries[base + j] = Entry(i, k, dp * ratio);
+                }
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Downsampling graph (1/6)");
+        }
+    );
+
+    if (progress)
+        progress("Downsampling graph (2/6)", 0.0f);
+
+    if (deterministic)
+        pss::parallel_stable_sort(entries, entries + nLinks, std::less<Entry>());
+    else
+        tbb::parallel_sort(entries, entries + nLinks, std::less<Entry>());
+
+    std::vector<bool> mergeFlag(V.cols(), false);
+
+    uint32_t nCollapsed = 0;
+    for (uint32_t i=0; i<nLinks; ++i) {
+        const Entry &e = entries[i];
+        if (mergeFlag[e.i] || mergeFlag[e.j])
+            continue;
+        mergeFlag[e.i] = mergeFlag[e.j] = true;
+        entries[nCollapsed++] = entries[i];
+    }
+    uint32_t vertexCount = V.cols() - nCollapsed;
+
+    /* Allocate memory for coarsened graph */
+    V_p.resize(3, vertexCount);
+    N_p.resize(3, vertexCount);
+    A_p.resize(vertexCount);
+    to_upper.resize(2, vertexCount);
+    to_lower.resize(V.cols());
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) nCollapsed, GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                const Entry &e = entries[i];
+                const Float area1 = A[e.i], area2 = A[e.j], surfaceArea = area1+area2;
+                if (surfaceArea > RCPOVERFLOW)
+                    V_p.col(i) = (V.col(e.i) * area1 + V.col(e.j) * area2) / surfaceArea;
+                else
+                    V_p.col(i) = (V.col(e.i) + V.col(e.j)) * 0.5f;
+                Vector3f normal = N.col(e.i) * area1 + N.col(e.j) * area2;
+                Float norm = normal.norm();
+                N_p.col(i) = norm > RCPOVERFLOW ? Vector3f(normal / norm)
+                                                : Vector3f::UnitX();
+                A_p[i] = surfaceArea;
+                to_upper.col(i) << e.i, e.j;
+                to_lower[e.i] = i; to_lower[e.j] = i;
+            }
+            SHOW_PROGRESS_RANGE(range, nCollapsed, "Downsampling graph (3/6)");
+        }
+    );
+
+    delete[] entries;
+
+    std::atomic<int> offset(nCollapsed);
+    tbb::blocked_range<uint32_t> range(0u, (uint32_t) V.cols(), GRAIN_SIZE);
+
+    auto copy_uncollapsed = [&](const tbb::blocked_range<uint32_t> &range) {
+        for (uint32_t i = range.begin(); i != range.end(); ++i) {
+            if (!mergeFlag[i]) {
+                uint32_t idx = offset++;
+                V_p.col(idx) = V.col(i);
+                N_p.col(idx) = N.col(i);
+                A_p[idx] = A[i];
+                to_upper.col(idx) << i, INVALID;
+                to_lower[i] = idx;
+            }
+        }
+        SHOW_PROGRESS_RANGE(range, V.cols(), "Downsampling graph (4/6)");
+    };
+
+    if (deterministic)
+        copy_uncollapsed(range);
+    else
+        tbb::parallel_for(range, copy_uncollapsed);
+
+    VectorXu neighborhoodSize(V_p.cols() + 1);
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V_p.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            std::vector<Link> scratch;
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                scratch.clear();
+
+                for (int j=0; j<2; ++j) {
+                    uint32_t upper = to_upper(j, i);
+                    if (upper == INVALID)
+                        continue;
+                    for (Link *link = adj[upper]; link != adj[upper+1]; ++link)
+                        scratch.push_back(Link(to_lower[link->id], link->weight));
+                }
+
+                std::sort(scratch.begin(), scratch.end());
+                uint32_t id = INVALID, size = 0;
+                for (const auto &link : scratch) {
+                    if (id != link.id && link.id != i) {
+                        id = link.id;
+                        ++size;
+                    }
+                }
+                neighborhoodSize[i+1] = size;
+            }
+            SHOW_PROGRESS_RANGE(range, V_p.cols(), "Downsampling graph (5/6)");
+        }
+    );
+
+    neighborhoodSize[0] = 0;
+    for (uint32_t i=0; i<neighborhoodSize.size()-1; ++i)
+        neighborhoodSize[i+1] += neighborhoodSize[i];
+
+    uint32_t nLinks_p = neighborhoodSize[neighborhoodSize.size()-1];
+    AdjacencyMatrix adj_p = new Link*[V_p.size() + 1];
+    Link *links = new Link[nLinks_p];
+    for (uint32_t i=0; i<neighborhoodSize.size(); ++i)
+        adj_p[i] = links + neighborhoodSize[i];
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V_p.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            std::vector<Link> scratch;
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                scratch.clear();
+
+                for (int j=0; j<2; ++j) {
+                    uint32_t upper = to_upper(j, i);
+                    if (upper == INVALID)
+                        continue;
+                    for (Link *link = adj[upper]; link != adj[upper+1]; ++link)
+                        scratch.push_back(Link(to_lower[link->id], link->weight));
+                }
+                std::sort(scratch.begin(), scratch.end());
+                Link *dest = adj_p[i];
+                uint32_t id = INVALID;
+                for (const auto &link : scratch) {
+                    if (link.id != i) {
+                        if (id != link.id) {
+                            *dest++ = link;
+                            id = link.id;
+                        } else {
+                            dest[-1].weight += link.weight;
+                        }
+                    }
+                }
+            }
+            SHOW_PROGRESS_RANGE(range, V_p.cols(), "Downsampling graph (6/6)");
+        }
+    );
+    cout << "done. (" << V.cols() << " -> " << V_p.cols() << " vertices, took "
+         << timeString(timer.value()) << ")" << endl;
+    return adj_p;
+}
+
+void generate_graph_coloring_deterministic(const AdjacencyMatrix &adj, uint32_t size,
+                             std::vector<std::vector<uint32_t> > &phases,
+                             const ProgressCallback &progress) {
+    if (progress)
+        progress("Graph coloring", 0.0f);
+    phases.clear();
+    cout << "    Coloring .. ";
+    cout.flush();
+    Timer<> timer;
+
+    std::vector<uint32_t> perm(size);
+    for (uint32_t i=0; i<size; ++i)
+        perm[i] = i;
+    pcg32 rng;
+    rng.shuffle(perm.begin(), perm.end());
+
+    std::vector<int> color(size, -1);
+    std::vector<uint8_t> possible_colors;
+    std::vector<int> size_per_color;
+    int ncolors = 0;
+
+    for (uint32_t i=0; i<size; ++i) {
+        uint32_t ip = perm[i];
+        SHOW_PROGRESS(i, size, "Graph coloring");
+
+        std::fill(possible_colors.begin(), possible_colors.end(), 1);
+
+        for (const Link *link = adj[ip]; link != adj[ip+1]; ++link) {
+            int c = color[link->id];
+            if (c >= 0)
+                possible_colors[c] = 0;
+        }
+
+        int chosen_color = -1;
+        for (uint32_t j=0; j<possible_colors.size(); ++j) {
+            if (possible_colors[j]) {
+                chosen_color = j;
+                break;
+            }
+        }
+
+        if (chosen_color < 0) {
+            chosen_color = ncolors++;
+            possible_colors.resize(ncolors);
+            size_per_color.push_back(0);
+        }
+
+        color[ip] = chosen_color;
+        size_per_color[chosen_color]++;
+    }
+    phases.resize(ncolors);
+    for (int i=0; i<ncolors; ++i)
+        phases[i].reserve(size_per_color[i]);
+    for (uint32_t i=0; i<size; ++i)
+        phases[color[i]].push_back(i);
+
+    cout << "done. (" << phases.size() << " colors, took "
+         << timeString(timer.value()) << ")" << endl;
+}
+
+void generate_graph_coloring(const AdjacencyMatrix &adj, uint32_t size,
+                             std::vector<std::vector<uint32_t> > &phases,
+                             const ProgressCallback &progress) {
+    struct ColorData {
+        uint8_t nColors;
+        uint32_t nNodes[256];
+        ColorData() : nColors(0) { }
+    };
+
+    const uint8_t INVALID_COLOR = 0xFF;
+    if (progress)
+        progress("Graph coloring", 0.0f);
+    phases.clear();
+    cout << "    Coloring .. ";
+    cout.flush();
+
+    Timer<> timer;
+
+    /* Generate a permutation */
+    std::vector<uint32_t> perm(size);
+    std::vector<tbb::spin_mutex> mutex(size);
+    for (uint32_t i=0; i<size; ++i)
+        perm[i] = i;
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, size, GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            pcg32 rng;
+            rng.advance(range.begin());
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t j = i, k =
+                    rng.nextUInt(size - i) + i;
+                if (j == k)
+                    continue;
+                if (j > k)
+                    std::swap(j, k);
+                tbb::spin_mutex::scoped_lock l0(mutex[j]);
+                tbb::spin_mutex::scoped_lock l1(mutex[k]);
+                std::swap(perm[j], perm[k]);
+            }
+        }
+    );
+
+    std::vector<uint8_t> color(size, INVALID_COLOR);
+    ColorData colorData = tbb::parallel_reduce(
+        tbb::blocked_range<uint32_t>(0u, size, GRAIN_SIZE),
+        ColorData(),
+        [&](const tbb::blocked_range<uint32_t> &range, ColorData colorData) -> ColorData {
+            std::vector<uint32_t> neighborhood;
+            bool possible_colors[256];
+
+            for (uint32_t pidx = range.begin(); pidx != range.end(); ++pidx) {
+                uint32_t i = perm[pidx];
+
+                neighborhood.clear();
+                neighborhood.push_back(i);
+                for (const Link *link = adj[i]; link != adj[i+1]; ++link)
+                    neighborhood.push_back(link->id);
+                std::sort(neighborhood.begin(), neighborhood.end());
+                for (uint32_t j: neighborhood)
+                    mutex[j].lock();
+
+                std::fill(possible_colors, possible_colors + colorData.nColors, true);
+
+                for (const Link *link = adj[i]; link != adj[i+1]; ++link) {
+                    uint8_t c = color[link->id];
+                    if (c != INVALID_COLOR) {
+                        while (c >= colorData.nColors) {
+                            possible_colors[colorData.nColors] = true;
+                            colorData.nNodes[colorData.nColors] = 0;
+                            colorData.nColors++;
+                        }
+                        possible_colors[c] = false;
+                    }
+                }
+
+                uint8_t chosen_color = INVALID_COLOR;
+                for (uint8_t j=0; j<colorData.nColors; ++j) {
+                    if (possible_colors[j]) {
+                        chosen_color = j;
+                        break;
+                    }
+                }
+                if (chosen_color == INVALID_COLOR) {
+                    if (colorData.nColors == INVALID_COLOR-1)
+                        throw std::runtime_error("Ran out of colors during graph coloring! "
+                            "The input mesh is very likely corrupt.");
+                    colorData.nNodes[colorData.nColors] = 1;
+                    color[i] = colorData.nColors++;
+                } else {
+                    colorData.nNodes[chosen_color]++;
+                    color[i] = chosen_color;
+                }
+
+                for (uint32_t j: neighborhood)
+                    mutex[j].unlock();
+            }
+            SHOW_PROGRESS_RANGE(range, size, "Graph coloring");
+            return colorData;
+        },
+        [](ColorData c1, ColorData c2) -> ColorData {
+            ColorData result;
+            result.nColors = std::max(c1.nColors, c2.nColors);
+            memset(result.nNodes, 0, sizeof(uint32_t) * result.nColors);
+            for (uint8_t i=0; i<c1.nColors; ++i)
+                result.nNodes[i] += c1.nNodes[i];
+            for (uint8_t i=0; i<c2.nColors; ++i)
+                result.nNodes[i] += c2.nNodes[i];
+            return result;
+        }
+    );
+
+    phases.resize(colorData.nColors);
+    for (int i=0; i<colorData.nColors; ++i)
+        phases[i].reserve(colorData.nNodes[i]);
+
+    for (uint32_t i=0; i<size; ++i)
+        phases[color[i]].push_back(i);
+
+    cout << "done. (" << phases.size() << " colors, took "
+         << timeString(timer.value()) << ")" << endl;
+}
+
+MultiResolutionHierarchy::MultiResolutionHierarchy() {
+    if (sizeof(Link) != 12)
+        throw std::runtime_error("Adjacency matrix entries are not packed! Investigate compiler settings.");
+    mA.reserve(MAX_DEPTH+1);
+    mV.reserve(MAX_DEPTH+1);
+    mN.reserve(MAX_DEPTH+1);
+    mQ.reserve(MAX_DEPTH+1);
+    mO.reserve(MAX_DEPTH+1);
+    mCQ.reserve(MAX_DEPTH+1);
+    mCQw.reserve(MAX_DEPTH+1);
+    mCO.reserve(MAX_DEPTH+1);
+    mCOw.reserve(MAX_DEPTH+1);
+    mAdj.reserve(MAX_DEPTH+1);
+    mToUpper.reserve(MAX_DEPTH);
+    mToLower.reserve(MAX_DEPTH);
+    mIterationsQ = mIterationsO = -1;
+    mScale = 0;
+    mTotalSize = 0;
+    mFrozenO = mFrozenQ = false;
+}
+
+void MultiResolutionHierarchy::build(bool deterministic, const ProgressCallback &progress) {
+    std::vector<std::vector<uint32_t>> phases;
+    cout << "Processing level 0 .." << endl;
+    if (deterministic)
+        generate_graph_coloring_deterministic(mAdj[0], mV[0].cols(), phases, progress);
+    else
+        generate_graph_coloring(mAdj[0], mV[0].cols(), phases, progress);
+    mPhases.push_back(phases);
+    
+    mTotalSize = mV[0].cols();
+    mCO.push_back(MatrixXf());
+    mCOw.push_back(VectorXf());
+    mCQ.push_back(MatrixXf());
+    mCQw.push_back(VectorXf());
+
+    cout << "Building multiresolution hierarchy .." << endl;
+    Timer<> timer;
+    for (int i=0; i<MAX_DEPTH; ++i) {
+        std::vector<std::vector<uint32_t>> phases_p;
+        MatrixXf N_p, V_p;
+        VectorXf A_p;
+        MatrixXu toUpper;
+        VectorXu toLower;
+
+        AdjacencyMatrix adj_p =
+            downsample_graph(mAdj[i], mV[i], mN[i], mA[i], V_p, N_p, A_p,
+                             toUpper, toLower, deterministic, progress);
+
+        if (deterministic)
+            generate_graph_coloring_deterministic(adj_p, V_p.cols(), phases_p, progress);
+        else
+            generate_graph_coloring(adj_p, V_p.cols(), phases_p, progress);
+
+        mTotalSize += V_p.cols();
+        mPhases.push_back(std::move(phases_p));
+        mAdj.push_back(std::move(adj_p));
+        mV.push_back(std::move(V_p));
+        mN.push_back(std::move(N_p));
+        mA.push_back(std::move(A_p));
+        mToUpper.push_back(std::move(toUpper));
+        mToLower.push_back(std::move(toLower));
+        mCO.push_back(MatrixXf());
+        mCOw.push_back(VectorXf());
+        mCQ.push_back(MatrixXf());
+        mCQw.push_back(VectorXf());
+        if (mV[mV.size()-1].cols() == 1)
+            break;
+    }
+    mIterationsQ = mIterationsO = -1;
+    mFrozenO = mFrozenQ = false;
+    cout << "Hierarchy construction took " << timeString(timer.value()) << "." << endl;
+}
+
+void init_random_tangent(const MatrixXf &N, MatrixXf &Q) {
+    Q.resize(N.rows(), N.cols());
+    tbb::parallel_for(tbb::blocked_range<uint32_t>(0u, (uint32_t) N.cols()),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            pcg32 rng;
+            rng.advance(range.begin());
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                Vector3f s, t;
+                coordinate_system(N.col(i), s, t);
+                float angle = rng.nextFloat() * 2 * M_PI;
+                Q.col(i) = s * std::cos(angle) + t * std::sin(angle);
+            }
+        }
+    );
+}
+
+void init_random_position(const MatrixXf &P, const MatrixXf &N, MatrixXf &O, Float scale) {
+    O.resize(N.rows(), N.cols());
+    tbb::parallel_for(tbb::blocked_range<uint32_t>(0u, (uint32_t) N.cols()),
+            [&](const tbb::blocked_range<uint32_t> &range) {
+            pcg32 rng;
+            rng.advance(2*range.begin());
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                Vector3f s, t;
+                coordinate_system(N.col(i), s, t);
+                float x = rng.nextFloat() * 2.f - 1.f,
+                      y = rng.nextFloat() * 2.f - 1.f;
+                O.col(i) = P.col(i) + (s*x + t*y)*scale;
+            }
+        }
+    );
+}
+
+void MultiResolutionHierarchy::resetSolution() {
+    cout << "Setting to random solution .. ";
+    cout.flush();
+    Timer<> timer;
+    if (mQ.size() != mV.size()) {
+        mQ.resize(mV.size());
+        mO.resize(mV.size());
+    }
+    for (size_t i=0; i<mV.size(); ++i) {
+        init_random_tangent(mN[i], mQ[i]);
+        init_random_position(mV[i], mN[i], mO[i], mScale);
+    }
+    mFrozenO = mFrozenQ = false;
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}
+
+void MultiResolutionHierarchy::free() {
+    for (size_t i=0; i<mAdj.size(); ++i) {
+        delete[] mAdj[i][0];
+        delete[] mAdj[i];
+    }
+    mAdj.clear(); mV.clear(); mQ.clear();
+    mO.clear(); mN.clear(); mA.clear();
+    mCQ.clear(); mCO.clear();
+    mCQw.clear(); mCOw.clear();
+    mToUpper.clear(); mToLower.clear();
+    mPhases.clear();
+    mF.resize(0, 0);
+    mE2E.resize(0);
+    mTotalSize = 0;
+}
+
+void MultiResolutionHierarchy::save(Serializer &serializer) {
+    serializer.set("levels", (uint32_t) mV.size());
+    serializer.set("iterations_O", mIterationsO);
+    serializer.set("iterations_Q", mIterationsQ);
+    serializer.set("totalSize", mTotalSize);
+    serializer.set("scale", mScale);
+    serializer.set("F", mF);
+    serializer.set("E2E", mE2E);
+    serializer.set("frozenO", mFrozenO);
+    serializer.set("frozenQ", mFrozenQ);
+    for (uint32_t i=0; i<mV.size(); ++i) {
+        serializer.pushPrefix(std::to_string(i));
+        serializer.set("V", mV[i]);
+        serializer.set("N", mN[i]);
+        serializer.set("A", mA[i]);
+        serializer.set("O", mO[i]);
+        serializer.set("Q", mQ[i]);
+        if (i < mV.size() - 1) {
+            serializer.set("toLower", mToLower[i]);
+            serializer.set("toUpper", mToUpper[i]);
+        }
+        serializer.set("CQ", mCQ[i]);
+        serializer.set("CQw", mCQw[i]);
+        serializer.set("CO", mCO[i]);
+        serializer.set("COw", mCOw[i]);
+        const AdjacencyMatrix &adj = mAdj[i];
+        std::vector<std::vector<uint32_t>> link_id(size(i));
+        std::vector<std::vector<uint32_t>> link_ivar(size(i));
+        std::vector<std::vector<Float>> link_weight(size(i));
+        for (uint32_t j=0; j<size(i); ++j) {
+            size_t size = adj[j+1] - adj[j];
+            link_id[j].reserve(size);
+            link_weight[j].reserve(size);
+            link_ivar[j].reserve(size);
+            for (const Link *link = adj[j]; link != adj[j+1]; ++link) {
+                link_id[j].push_back(link->id);
+                link_weight[j].push_back(link->weight);
+                link_ivar[j].push_back(link->ivar_uint32);
+            }
+        }
+        serializer.set("phases", mPhases[i]);
+        serializer.set("adj_id", link_id);
+        serializer.set("adj_ivar", link_ivar);
+        serializer.set("adj_weight", link_weight);
+        serializer.popPrefix();
+    }
+}
+
+void MultiResolutionHierarchy::load(const Serializer &serializer) {
+    free();
+    uint32_t levels;
+    serializer.get("levels", levels);
+    serializer.get("iterations_O", mIterationsO);
+    serializer.get("iterations_Q", mIterationsQ);
+    serializer.get("totalSize", mTotalSize);
+    serializer.get("scale", mScale);
+    serializer.get("F", mF);
+    serializer.get("E2E", mE2E);
+    serializer.get("frozenO", mFrozenO);
+    serializer.get("frozenQ", mFrozenQ);
+    for (uint32_t i=0; i<levels; ++i) {
+        serializer.pushPrefix(std::to_string(i));
+        MatrixXf V, N, O, Q, CQ, CO;
+        VectorXf A, CQw, COw;
+        std::vector<std::vector<uint32_t>> phases;
+
+        serializer.get("V", V);
+        serializer.get("N", N);
+        serializer.get("A", A);
+        serializer.get("O", O);
+        serializer.get("Q", Q);
+        serializer.get("phases", phases);
+
+        serializer.get("CQ", CQ);
+        serializer.get("CQw", CQw);
+        serializer.get("CO", CO);
+        serializer.get("COw", COw);
+
+        mV.push_back(std::move(V));
+        mN.push_back(std::move(N));
+        mA.push_back(std::move(A));
+        mO.push_back(std::move(O));
+        mQ.push_back(std::move(Q));
+        mCQ.push_back(std::move(CQ));
+        mCO.push_back(std::move(CO));
+        mCQw.push_back(std::move(CQw));
+        mCOw.push_back(std::move(COw));
+        mPhases.push_back(std::move(phases));
+
+        if (i < levels - 1) {
+            MatrixXu toUpper;
+            VectorXu toLower;
+            serializer.get("toLower", toLower);
+            serializer.get("toUpper", toUpper);
+            mToLower.push_back(std::move(toLower));
+            mToUpper.push_back(std::move(toUpper));
+        }
+
+        std::vector<std::vector<uint32_t>> adj_id;
+        std::vector<std::vector<uint32_t>> adj_ivar;
+        std::vector<std::vector<Float>> adj_weight;
+        serializer.get("adj_id", adj_id);
+        serializer.get("adj_ivar", adj_ivar);
+        serializer.get("adj_weight", adj_weight);
+
+        if (adj_id.size() != adj_ivar.size() || adj_ivar.size() != adj_weight.size())
+            throw std::runtime_error("Could not unserialize data");
+        uint32_t linkCount = 0;
+
+        for (uint32_t j=0; j<adj_id.size(); ++j) {
+            if (adj_id[j].size() != adj_ivar[j].size() || adj_ivar[j].size() != adj_weight[j].size())
+                throw std::runtime_error("Could not unserialize data");
+            linkCount += adj_id[j].size();
+        }
+
+        AdjacencyMatrix adj = new Link*[adj_id.size() + 1];
+        adj[0] = new Link[linkCount];
+        for (uint32_t j=0; j<adj_id.size(); ++j)
+            adj[j+1] = adj[j] + adj_id[j].size();
+        for (uint32_t j=0; j<adj_id.size(); ++j) {
+            for (uint32_t k=0; k<adj_id[j].size(); ++k) {
+                adj[j][k].id = adj_id[j][k];
+                adj[j][k].ivar_uint32 = adj_ivar[j][k];
+                adj[j][k].weight = adj_weight[j][k];
+            }
+        }
+        mAdj.push_back(adj);
+        serializer.popPrefix();
+    }
+}
+
+void MultiResolutionHierarchy::clearConstraints() {
+    if (levels() == 0)
+        return;
+    if (mCQ[0].size() == 0)
+        cout << "Allocating memory for constraints .." << endl;
+    for (int i=0; i<levels(); ++i) {
+        mCQ[i].resize(3, size(i));
+        mCO[i].resize(3, size(i));
+        mCQw[i].resize(size(i));
+        mCOw[i].resize(size(i));
+        mCQw[i].setZero();
+        mCOw[i].setZero();
+    }
+}
+
+void MultiResolutionHierarchy::propagateSolution(int rosy) {
+    auto compat_orient = compat_orientation_extrinsic_2;
+    if (rosy == 2)
+        ;
+    else if (rosy == 4)
+        compat_orient = compat_orientation_extrinsic_4;
+    else if (rosy == 6)
+        compat_orient = compat_orientation_extrinsic_6;
+    else
+        throw std::runtime_error("Unsupported symmetry!");
+
+    cout << "Propagating updated solution.. ";
+    cout.flush();
+    Timer<> timer;
+    for (int l=0; l<levels()-1; ++l)  {
+        const MatrixXf &N = mN[l];
+        const MatrixXf &N_next = mN[l+1];
+        const MatrixXf &Q = mQ[l];
+        MatrixXf &Q_next = mQ[l+1];
+
+        tbb::parallel_for(
+            tbb::blocked_range<uint32_t>(0u, size(l+1), GRAIN_SIZE),
+            [&](const tbb::blocked_range<uint32_t> &range) {
+                for (uint32_t i=range.begin(); i != range.end(); ++i) {
+                    Vector2u upper = toUpper(l).col(i);
+                    Vector3f q0 = Q.col(upper[0]);
+                    Vector3f n0 = N.col(upper[0]);
+                    Vector3f q;
+
+                    if (upper[1] != INVALID) {
+                        Vector3f q1 = Q.col(upper[1]);
+                        Vector3f n1 = N.col(upper[1]);
+                        auto result = compat_orient(q0, n0, q1, n1);
+                        q = result.first + result.second;
+                    } else {
+                        q = q0;
+                    }
+                    Vector3f n = N_next.col(i);
+                    q -= n.dot(q) * n;
+                    if (q.squaredNorm() > RCPOVERFLOW)
+                        q.normalize();
+
+                    Q_next.col(i) = q;
+                }
+            }
+        );
+    }
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}
+
+void MultiResolutionHierarchy::propagateConstraints(int rosy, int posy) {
+    if (levels() == 0)
+        return;
+    cout << "Propagating constraints .. ";
+    cout.flush();
+    Timer<> timer;
+
+    auto compat_orient = compat_orientation_extrinsic_2;
+    if (rosy == 2)
+        ;
+    else if (rosy == 4)
+        compat_orient = compat_orientation_extrinsic_4;
+    else if (rosy == 6)
+        compat_orient = compat_orientation_extrinsic_6;
+    else
+        throw std::runtime_error("Unsupported symmetry!");
+
+    auto compat_pos = compat_position_extrinsic_4;
+    if (posy == 4)
+        ;
+    else if (posy == 3)
+        compat_pos = compat_position_extrinsic_3;
+    else
+        throw std::runtime_error("Unsupported symmetry!");
+
+    Float scale = mScale, inv_scale = 1/mScale;
+
+    for (int l=0; l<levels()-1; ++l)  {
+        const MatrixXf &N = mN[l];
+        const MatrixXf &N_next = mN[l+1];
+        const MatrixXf &V = mV[l];
+        const MatrixXf &V_next = mV[l+1];
+        const MatrixXf &CQ = mCQ[l];
+        MatrixXf &CQ_next = mCQ[l+1];
+        const VectorXf &CQw = mCQw[l];
+        VectorXf &CQw_next = mCQw[l+1];
+        const MatrixXf &CO = mCO[l];
+        MatrixXf &CO_next = mCO[l+1];
+        const VectorXf &COw = mCOw[l];
+        VectorXf &COw_next = mCOw[l+1];
+
+        tbb::parallel_for(
+            tbb::blocked_range<uint32_t>(0u, size(l+1), GRAIN_SIZE),
+            [&](const tbb::blocked_range<uint32_t> &range) {
+                for (uint32_t i=range.begin(); i != range.end(); ++i) {
+                    Vector2u upper = toUpper(l).col(i);
+                    Vector3f cq = Vector3f::Zero(), co = Vector3f::Zero();
+                    Float cqw = 0.0f, cow = 0.0f;
+
+                    bool has_cq0 = CQw[upper[0]] != 0;
+                    bool has_cq1 = upper[1] != INVALID && CQw[upper[1]] != 0;
+                    bool has_co0 = COw[upper[0]] != 0;
+                    bool has_co1 = upper[1] != INVALID && COw[upper[1]] != 0;
+
+                    if (has_cq0 && !has_cq1) {
+                        cq = CQ.col(upper[0]);
+                        cqw = CQw[upper[0]];
+                    } else if (has_cq1 && !has_cq0) {
+                        cq = CQ.col(upper[1]);
+                        cqw = CQw[upper[1]];
+                    } else if (has_cq1 && has_cq0) {
+                        auto result = compat_orient(CQ.col(upper[0]), N.col(upper[0]), CQ.col(upper[1]), N.col(upper[1]));
+                        cq = result.first * CQw[upper[0]] + result.second * CQw[upper[1]];
+                        cqw = (CQw[upper[0]] + CQw[upper[1]]);
+                    }
+                    if (cq != Vector3f::Zero()) {
+                        Vector3f n = N_next.col(i);
+                        cq -= n.dot(cq) * n;
+                        if (cq.squaredNorm() > RCPOVERFLOW)
+                            cq.normalize();
+                    }
+
+                    if (has_co0 && !has_co1) {
+                        co = CO.col(upper[0]);
+                        cow = COw[upper[0]];
+                    } else if (has_co1 && !has_co0) {
+                        co = CO.col(upper[1]);
+                        cow = COw[upper[1]];
+                    } else if (has_co1 && has_co0) {
+                        auto result = compat_pos(
+                            V.col(upper[0]), N.col(upper[0]), CQ.col(upper[0]), CO.col(upper[0]), 
+                            V.col(upper[1]), N.col(upper[1]), CQ.col(upper[1]), CO.col(upper[1]),
+                            scale, inv_scale
+                        );
+                        cow = COw[upper[0]] + COw[upper[1]];
+                        co = (result.first * COw[upper[0]] + result.second * COw[upper[1]]) / cow;
+                    }
+                    if (co != Vector3f::Zero()) {
+                        Vector3f n = N_next.col(i), v = V_next.col(i);
+                        co -= n.dot(cq - v) * n;
+                    }
+                    #if 0
+                        cqw *= 0.5f;
+                        cow *= 0.5f;
+                    #else
+                        if (cqw > 0)
+                            cqw = 1;
+                        if (cow > 0)
+                            cow = 1;
+                    #endif
+
+                    CQw_next[i] = cqw;
+                    COw_next[i] = cow;
+                    CQ_next.col(i) = cq;
+                    CO_next.col(i) = co;
+                }
+            }
+        );
+    }
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}
+
+void MultiResolutionHierarchy::printStatistics() const {
+    if (levels() == 0)
+        return;
+    std::ostringstream oss;
+    size_t field_s = 0, V_s = 0, N_s = 0, A_s = 0, adj_s = 0, tree_s = 0,
+           phases_s = 0, cedge_s = 0, cvertex_s = 0;
+    for (int i=0; i<levels(); ++i) {
+        field_s += sizeInBytes(mQ[i]) + sizeInBytes(mO[i]);
+        V_s += sizeInBytes(mV[i]);
+        N_s += sizeInBytes(mN[i]);
+        A_s += sizeInBytes(mA[i]);
+        adj_s += (mAdj[i][mV[i].cols()] - mAdj[i][0]) * sizeof(Link) + mV[i].cols() * sizeof(Link *);
+        phases_s += mPhases[i].size() * sizeof(std::vector<uint32_t>) + mV[i].cols() * sizeof(uint32_t);
+    }
+    for (int i=0; i<levels()-1; ++i) {
+        tree_s += sizeInBytes(mToUpper[i]);
+        tree_s += sizeInBytes(mToLower[i]);
+    }
+    cvertex_s = sizeInBytes(mF);
+    cedge_s = sizeInBytes(mE2E);
+
+    cout << endl;
+    cout << "Multiresolution hierarchy statistics:" << endl;
+    cout << "    Field data          : " << memString(field_s) << endl;
+    cout << "    Vertex data         : " << memString(V_s + N_s + A_s) << " (level 0: "
+        << memString(sizeInBytes(mV[0]) + sizeInBytes(mN[0]) + sizeInBytes(mA[0])) << ")" << endl;
+    cout << "    Adjacency matrices  : " << memString(adj_s) << " (level 0: "
+        << memString((mAdj[0][mV[0].cols()] - mAdj[0][0]) * sizeof(Link)) << ")" << endl;
+    cout << "    Tree connectivity   : " << memString(tree_s) << endl;
+    cout << "    Vertex indices      : " << memString(cvertex_s) << endl;
+    cout << "    Edge connectivity   : " << memString(cedge_s) << endl;
+    cout << "    Parallel phases     : " << memString(phases_s) << endl;
+    cout << "    Total               : "
+         << memString(field_s + V_s + N_s + A_s + adj_s + tree_s + cedge_s + cvertex_s + phases_s) << endl;
+}

intern/instant-meshes/src/hierarchy.h

@@ -0,0 +1,267 @@
+/*
+    hierarchy.h: Code to generate unstructured multi-resolution hierarchies
+    from meshes or point clouds
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "adjacency.h"
+
+class Serializer;
+
+extern AdjacencyMatrix downsample_graph(const AdjacencyMatrix adj,
+                                        const MatrixXf &V,
+                                        const MatrixXf &N,
+                                        const VectorXf &areas,
+                                        MatrixXf &V_p,
+                                        MatrixXf &V_n,
+                                        VectorXf &areas_p,
+                                        MatrixXu &to_upper,
+                                        VectorXu &to_lower,
+                                        bool deterministic = false,
+                                        const ProgressCallback &progress = ProgressCallback());
+
+struct MultiResolutionHierarchy {
+  enum { MAX_DEPTH = 25 };
+
+ public:
+  MultiResolutionHierarchy();
+  void free();
+  void save(Serializer &state);
+  void load(const Serializer &state);
+
+  int levels() const
+  {
+    return (int)mV.size();
+  }
+
+  void build(bool deterministic = false, const ProgressCallback &progress = ProgressCallback());
+
+  void printStatistics() const;
+  void resetSolution();
+
+  inline ordered_lock &mutex()
+  {
+    return mMutex;
+  }
+
+  inline const std::vector<std::vector<uint32_t>> &phases(int level) const
+  {
+    return mPhases[level];
+  }
+  inline const AdjacencyMatrix &adj(int level = 0) const
+  {
+    return mAdj[level];
+  }
+  inline AdjacencyMatrix &adj(int level = 0)
+  {
+    return mAdj[level];
+  }
+  inline const MatrixXf &V(int level = 0) const
+  {
+    return mV[level];
+  }
+  inline const MatrixXf &N(int level = 0) const
+  {
+    return mN[level];
+  }
+  inline const VectorXf &A(int level = 0) const
+  {
+    return mA[level];
+  }
+  inline const MatrixXu &toUpper(int level) const
+  {
+    return mToUpper[level];
+  }
+  inline const VectorXu &toLower(int level) const
+  {
+    return mToLower[level];
+  }
+  inline const MatrixXf &Q(int level = 0) const
+  {
+    return mQ[level];
+  }
+  inline const MatrixXf &O(int level = 0) const
+  {
+    return mO[level];
+  }
+  inline const MatrixXf &CQ(int level = 0) const
+  {
+    return mCQ[level];
+  }
+  inline const MatrixXf &CO(int level = 0) const
+  {
+    return mCO[level];
+  }
+  inline const VectorXf &CQw(int level = 0) const
+  {
+    return mCQw[level];
+  }
+  inline const VectorXf &COw(int level = 0) const
+  {
+    return mCOw[level];
+  }
+  inline const MatrixXu &F() const
+  {
+    return mF;
+  }
+  inline const VectorXu &E2E() const
+  {
+    return mE2E;
+  }
+  inline MatrixXf &Q(int level = 0)
+  {
+    return mQ[level];
+  }
+  inline MatrixXf &O(int level = 0)
+  {
+    return mO[level];
+  }
+  inline MatrixXf &CQ(int level = 0)
+  {
+    return mCQ[level];
+  }
+  inline MatrixXf &CO(int level = 0)
+  {
+    return mCO[level];
+  }
+  inline VectorXf &CQw(int level = 0)
+  {
+    return mCQw[level];
+  }
+  inline VectorXf &COw(int level = 0)
+  {
+    return mCOw[level];
+  }
+
+  inline void setF(MatrixXu &&F)
+  {
+    mF = std::move(F);
+  }
+  inline void setE2E(VectorXu &&E2E)
+  {
+    mE2E = std::move(E2E);
+  }
+  inline void setV(MatrixXf &&V)
+  {
+    mV.clear();
+    mV.push_back(std::move(V));
+  }
+  inline void setN(MatrixXf &&N)
+  {
+    mN.clear();
+    mN.push_back(std::move(N));
+  }
+  inline void setA(MatrixXf &&A)
+  {
+    mA.clear();
+    mA.push_back(std::move(A));
+  }
+  inline void setAdj(AdjacencyMatrix &&adj)
+  {
+    mAdj.clear();
+    mAdj.push_back(std::move(adj));
+  }
+
+  inline uint32_t size(int level = 0) const
+  {
+    return mV[level].cols();
+  }
+
+  inline Float scale() const
+  {
+    return mScale;
+  }
+  inline void setScale(Float scale)
+  {
+    mScale = scale;
+  }
+  inline int iterationsQ() const
+  {
+    return mIterationsQ;
+  }
+  inline void setIterationsQ(int iterationsQ)
+  {
+    mIterationsQ = iterationsQ;
+  }
+  inline int iterationsO() const
+  {
+    return mIterationsO;
+  }
+  inline void setIterationsO(int iterationsO)
+  {
+    mIterationsO = iterationsO;
+  }
+  inline size_t totalSize() const
+  {
+    return mTotalSize;
+  }
+
+  void clearConstraints();
+  void propagateConstraints(int rosy, int posy);
+  void propagateSolution(int rosy);
+
+  inline Vector3f faceCenter(uint32_t idx) const
+  {
+    Vector3f pos = Vector3f::Zero();
+    for (int i = 0; i < 3; ++i)
+      pos += mV[0].col(mF(i, idx));
+    return pos * (1.0f / 3.0f);
+  }
+
+  inline Vector3f faceNormal(uint32_t idx) const
+  {
+    Vector3f p0 = mV[0].col(mF(0, idx)), p1 = mV[0].col(mF(1, idx)), p2 = mV[0].col(mF(2, idx));
+    return (p1 - p0).cross(p2 - p0).normalized();
+  }
+
+  /* Flags which indicate whether the integer variables are froen */
+  bool frozenQ() const
+  {
+    return mFrozenQ;
+  }
+  bool frozenO() const
+  {
+    return mFrozenO;
+  }
+  void setFrozenQ(bool frozen)
+  {
+    mFrozenQ = frozen;
+  }
+  void setFrozenO(bool frozen)
+  {
+    mFrozenO = frozen;
+  }
+
+ public:
+  MatrixXu mF;
+  VectorXu mE2E;
+  std::vector<std::vector<std::vector<uint32_t>>> mPhases;
+  std::vector<AdjacencyMatrix> mAdj;
+  std::vector<MatrixXf> mV;
+  std::vector<MatrixXf> mN;
+  std::vector<VectorXf> mA;
+  std::vector<VectorXu> mToLower;
+  std::vector<MatrixXu> mToUpper;
+  std::vector<MatrixXf> mO;
+  std::vector<MatrixXf> mQ;
+  std::vector<MatrixXf> mCQ;
+  std::vector<MatrixXf> mCO;
+  std::vector<VectorXf> mCQw;
+  std::vector<VectorXf> mCOw;
+  bool mFrozenQ, mFrozenO;
+  ordered_lock mMutex;
+  Float mScale;
+  int mIterationsQ;
+  int mIterationsO;
+  uint32_t mTotalSize;
+};

intern/instant-meshes/src/main.cpp

@@ -0,0 +1,226 @@
+/*
+    main.cpp -- Instant Meshes application entry point
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "batch.h"
+#include "viewer.h"
+#include "serializer.h"
+#include <thread>
+#include <cstdlib>
+
+/* Force usage of discrete GPU on laptops */
+NANOGUI_FORCE_DISCRETE_GPU();
+
+int nprocs = -1;
+
+int main(int argc, char **argv) {
+    std::vector<std::string> args;
+    bool extrinsic = true, dominant = false, align_to_boundaries = false;
+    bool fullscreen = false, help = false, deterministic = false, compat = false;
+    int rosy = 4, posy = 4, face_count = -1, vertex_count = -1;
+    uint32_t knn_points = 10, smooth_iter = 2;
+    Float crease_angle = -1, scale = -1;
+    std::string batchOutput;
+    #if defined(__APPLE__)
+        bool launched_from_finder = false;
+    #endif
+
+    try {
+        for (int i=1; i<argc; ++i) {
+            if (strcmp("--fullscreen", argv[i]) == 0 || strcmp("-F", argv[i]) == 0) {
+                fullscreen = true;
+            } else if (strcmp("--help", argv[i]) == 0 || strcmp("-h", argv[i]) == 0) {
+                help = true;
+            } else if (strcmp("--deterministic", argv[i]) == 0 || strcmp("-d", argv[i]) == 0) {
+                deterministic = true;
+            } else if (strcmp("--intrinsic", argv[i]) == 0 || strcmp("-i", argv[i]) == 0) {
+                extrinsic = false;
+            } else if (strcmp("--boundaries", argv[i]) == 0 || strcmp("-b", argv[i]) == 0) {
+                align_to_boundaries = true;
+            } else if (strcmp("--threads", argv[i]) == 0 || strcmp("-t", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing thread count!" << endl;
+                    return -1;
+                }
+                nprocs = str_to_uint32_t(argv[i]);
+            } else if (strcmp("--smooth", argv[i]) == 0 || strcmp("-S", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing smoothing iteration count argument!" << endl;
+                    return -1;
+                }
+                smooth_iter = str_to_uint32_t(argv[i]);
+            } else if (strcmp("--knn", argv[i]) == 0 || strcmp("-k", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing knn point count argument!" << endl;
+                    return -1;
+                }
+                knn_points = str_to_uint32_t(argv[i]);
+            } else if (strcmp("--crease", argv[i]) == 0 || strcmp("-c", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing crease angle argument!" << endl;
+                    return -1;
+                }
+                crease_angle = str_to_float(argv[i]);
+            } else if (strcmp("--rosy", argv[i]) == 0 || strcmp("-r", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing rotation symmetry type!" << endl;
+                    return -1;
+                }
+                rosy = str_to_int32_t(argv[i]);
+            } else if (strcmp("--posy", argv[i]) == 0 || strcmp("-p", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing position symmetry type!" << endl;
+                    return -1;
+                }
+                posy = str_to_int32_t(argv[i]);
+                if (posy == 6)
+                    posy = 3;
+            } else if (strcmp("--scale", argv[i]) == 0 || strcmp("-s", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing scale argument!" << endl;
+                    return -1;
+                }
+                scale = str_to_float(argv[i]);
+            } else if (strcmp("--faces", argv[i]) == 0 || strcmp("-f", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing face count argument!" << endl;
+                    return -1;
+                }
+                face_count = str_to_int32_t(argv[i]);
+            } else if (strcmp("--vertices", argv[i]) == 0 || strcmp("-v", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing vertex count argument!" << endl;
+                    return -1;
+                }
+                vertex_count = str_to_int32_t(argv[i]);
+            } else if (strcmp("--output", argv[i]) == 0 || strcmp("-o", argv[i]) == 0) {
+                if (++i >= argc) {
+                    cerr << "Missing batch mode output file argument!" << endl;
+                    return -1;
+                }
+                batchOutput = argv[i];
+            } else if (strcmp("--dominant", argv[i]) == 0 || strcmp("-D", argv[i]) == 0) {
+                dominant = true;
+            } else if (strcmp("--compat", argv[i]) == 0 || strcmp("-C", argv[i]) == 0) {
+                compat = true;
+#if defined(__APPLE__)
+            } else if (strncmp("-psn", argv[i], 4) == 0) {
+                launched_from_finder = true;
+#endif
+            } else {
+                if (strncmp(argv[i], "-", 1) == 0) {
+                    cerr << "Invalid argument: \"" << argv[i] << "\"!" << endl;
+                    help = true;
+                }
+                args.push_back(argv[i]);
+            }
+        }
+    } catch (const std::exception &e) {
+        cout << "Error: " << e.what() << endl;
+        help = true;
+    }
+
+    if ((posy != 3 && posy != 4) || (rosy != 2 && rosy != 4 && rosy != 6)) {
+        cerr << "Error: Invalid symmetry type!" << endl;
+        help  = true;
+    }
+
+    int nConstraints = 0;
+    nConstraints += scale > 0 ? 1 : 0;
+    nConstraints += face_count > 0 ? 1 : 0;
+    nConstraints += vertex_count > 0 ? 1 : 0;
+
+    if (nConstraints > 1) {
+        cerr << "Error: Only one of the --scale, --face and --vertices parameters can be used at once!" << endl;
+        help = true;
+    }
+
+    if (args.size() > 1 || help || (!batchOutput.empty() && args.size() == 0)) {
+        cout << "Syntax: " << argv[0] << " [options] <input mesh / point cloud / application state snapshot>" << endl;
+        cout << "Options:" << endl;
+        cout << "   -o, --output <output>     Writes to the specified PLY/OBJ output file in batch mode" << endl;
+        cout << "   -t, --threads <count>     Number of threads used for parallel computations" << endl;
+        cout << "   -d, --deterministic       Prefer (slower) deterministic algorithms" << endl;
+        cout << "   -c, --crease <degrees>    Dihedral angle threshold for creases" << endl;
+        cout << "   -S, --smooth <iter>       Number of smoothing & ray tracing reprojection steps (default: 2)" << endl;
+        cout << "   -D, --dominant            Generate a tri/quad dominant mesh instead of a pure tri/quad mesh" << endl;
+        cout << "   -i, --intrinsic           Intrinsic mode (extrinsic is the default)" << endl;
+        cout << "   -b, --boundaries          Align to boundaries (only applies when the mesh is not closed)" << endl;
+        cout << "   -r, --rosy <number>       Specifies the orientation symmetry type (2, 4, or 6)" << endl;
+        cout << "   -p, --posy <number>       Specifies the position symmetry type (4 or 6)" << endl;
+        cout << "   -s, --scale <scale>       Desired world space length of edges in the output" << endl;
+        cout << "   -f, --faces <count>       Desired face count of the output mesh" << endl;
+        cout << "   -v, --vertices <count>    Desired vertex count of the output mesh" << endl;
+        cout << "   -C, --compat              Compatibility mode to load snapshots from old software versions" << endl;
+        cout << "   -k, --knn <count>         Point cloud mode: number of adjacent points to consider" << endl;
+        cout << "   -F, --fullscreen          Open a full-screen window" << endl;
+        cout << "   -h, --help                Display this message" << endl;
+        return -1;
+    }
+
+    if (args.size() == 0)
+        cout << "Running in GUI mode, start with -h for instructions on batch mode." << endl;
+
+    tbb::task_scheduler_init init(nprocs == -1 ? tbb::task_scheduler_init::automatic : nprocs);
+
+    if (!batchOutput.empty() && args.size() == 1) {
+        try {
+            batch_process(args[0], batchOutput, rosy, posy, scale, face_count,
+                          vertex_count, crease_angle, extrinsic,
+                          align_to_boundaries, smooth_iter, knn_points,
+                          !dominant, deterministic);
+            return 0;
+        } catch (const std::exception &e) {
+            cerr << "Caught runtime error : " << e.what() << endl;
+            return -1;
+        }
+    }
+
+    try {
+        nanogui::init();
+
+        #if defined(__APPLE__)
+            if (launched_from_finder)
+                nanogui::chdir_to_bundle_parent();
+        #endif
+
+        {
+            nanogui::ref<Viewer> viewer = new Viewer(fullscreen, deterministic);
+            viewer->setVisible(true);
+
+            if (args.size() == 1) {
+                if (Serializer::isSerializedFile(args[0])) {
+                    viewer->loadState(args[0], compat);
+                } else {
+                    viewer->loadInput(args[0], crease_angle,
+                            scale, face_count, vertex_count,
+                            rosy, posy, knn_points);
+                    viewer->setExtrinsic(extrinsic);
+                }
+            }
+
+            nanogui::mainloop();
+        }
+
+        nanogui::shutdown();
+    } catch (const std::runtime_error &e) {
+        std::string error_msg = std::string("Caught a fatal error: ") + std::string(e.what());
+        #if defined(_WIN32)
+            MessageBoxA(nullptr, error_msg.c_str(), NULL, MB_ICONERROR | MB_OK);
+        #else
+            std::cerr << error_msg << endl;
+        #endif
+        return -1;
+    }
+
+    return EXIT_SUCCESS;
+}

intern/instant-meshes/src/meshio.cpp

@@ -0,0 +1,618 @@
+/*
+    meshio.cpp: Mesh file input/output routines
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "meshio.h"
+#include "normal.h"
+#include <unordered_map>
+#include <fstream>
+#if !defined(_WIN32)
+#include <libgen.h>
+#endif
+
+extern "C" {
+    #include "rply.h"
+}
+
+void load_mesh_or_pointcloud(const std::string &filename, MatrixXu &F, MatrixXf &V, MatrixXf &N,
+              const ProgressCallback &progress) {
+    std::string extension;
+    if (filename.size() > 4)
+        extension = str_tolower(filename.substr(filename.size()-4));
+
+    if (extension == ".ply")
+        load_ply(filename, F, V, N, false, progress);
+    else if (extension == ".obj")
+        load_obj(filename, F, V, progress);
+    else if (extension == ".aln")
+        load_pointcloud(filename, V, N, progress);
+    else
+        throw std::runtime_error("load_mesh_or_pointcloud: Unknown file extension \"" + extension + "\" (.ply/.obj/.aln are supported)");
+}
+
+void write_mesh(const std::string &filename, const MatrixXu &F,
+                const MatrixXf &V, const MatrixXf &N, const MatrixXf &Nf,
+                const MatrixXf &UV, const MatrixXf &C,
+                const ProgressCallback &progress) {
+    std::string extension;
+    if (filename.size() > 4)
+        extension = str_tolower(filename.substr(filename.size()-4));
+
+    if (extension == ".ply")
+        write_ply(filename, F, V, N, Nf, UV, C, progress);
+    else if (extension == ".obj")
+        write_obj(filename, F, V, N, Nf, UV, C, progress);
+    else
+        throw std::runtime_error("write_mesh: Unknown file extension \"" + extension + "\" (.ply/.obj are supported)");
+}
+
+void load_ply(const std::string &filename, MatrixXu &F, MatrixXf &V,
+              MatrixXf &N, bool pointcloud, const ProgressCallback &progress) {
+    auto message_cb = [](p_ply ply, const char *msg) { cerr << "rply: " << msg << endl; };
+
+    Timer<> timer;
+    cout << "Loading \"" << filename << "\" .. ";
+    cout.flush();
+
+    p_ply ply = ply_open(filename.c_str(), message_cb, 0, nullptr);
+    if (!ply)
+        throw std::runtime_error("Unable to open PLY file \"" + filename + "\"!");
+
+    if (!ply_read_header(ply)) {
+        ply_close(ply);
+        throw std::runtime_error("Unable to open PLY header of \"" + filename + "\"!");
+    }
+
+    p_ply_element element = nullptr;
+    uint32_t vertexCount = 0, faceCount = 0;
+
+    /* Inspect the structure of the PLY file, load number of faces if avaliable */
+    while ((element = ply_get_next_element(ply, element)) != nullptr) {
+        const char *name;
+        long nInstances;
+
+        ply_get_element_info(element, &name, &nInstances);
+        if (!strcmp(name, "vertex"))
+            vertexCount = (uint32_t) nInstances;
+        else if (!strcmp(name, "face"))
+            faceCount = (uint32_t) nInstances;
+    }
+
+    if (vertexCount == 0 && faceCount == 0)
+        throw std::runtime_error("PLY file \"" + filename + "\" is invalid! No face/vertex/elements found!");
+    else if (!pointcloud && faceCount == 0)
+        throw std::runtime_error("PLY file \"" + filename + "\" is invalid! No faces found!");
+
+    F.resize(3, faceCount);
+    V.resize(3, vertexCount);
+
+    struct VertexCallbackData {
+        MatrixXf &V;
+        const ProgressCallback &progress;
+        VertexCallbackData(MatrixXf &V, const ProgressCallback &progress)
+            : V(V), progress(progress) { }
+    };
+
+    struct FaceCallbackData {
+        MatrixXu &F;
+        const ProgressCallback &progress;
+        FaceCallbackData(MatrixXu &F, const ProgressCallback &progress)
+            : F(F), progress(progress) { }
+    };
+
+    struct VertexNormalCallbackData {
+        MatrixXf &N;
+        const ProgressCallback &progress;
+        VertexNormalCallbackData(MatrixXf &_N, const ProgressCallback &progress)
+            : N(_N), progress(progress) { }
+    };
+
+    auto rply_vertex_cb = [](p_ply_argument argument) -> int {
+        VertexCallbackData *data; long index, coord;
+        ply_get_argument_user_data(argument, (void **) &data, &coord);
+        ply_get_argument_element(argument, nullptr, &index);
+        data->V(coord, index) = (Float) ply_get_argument_value(argument);
+        if (data->progress && coord == 0 && index % 500000 == 0)
+            data->progress("Loading vertex data", index / (Float) data->V.cols());
+        return 1;
+    };
+
+    auto rply_vertex_normal_cb = [](p_ply_argument argument) -> int {
+        VertexNormalCallbackData *data; long index, coord;
+        ply_get_argument_user_data(argument, (void **) &data, &coord);
+        ply_get_argument_element(argument, nullptr, &index);
+        data->N(coord, index) = (Float) ply_get_argument_value(argument);
+        if (data->progress && coord == 0 && index % 500000 == 0)
+            data->progress("Loading vertex normal data", index / (Float)data->N.cols());
+        return 1;
+    };
+
+    auto rply_index_cb = [](p_ply_argument argument) -> int {
+        FaceCallbackData *data;
+        long length, value_index, index;
+        ply_get_argument_property(argument, nullptr, &length, &value_index);
+
+        if (length != 3)
+            throw std::runtime_error("Only triangle faces are supported!");
+
+        ply_get_argument_user_data(argument, (void **) &data, nullptr);
+        ply_get_argument_element(argument, nullptr, &index);
+
+        if (value_index >= 0)
+            data->F(value_index, index) = (uint32_t) ply_get_argument_value(argument);
+
+        if (data->progress && value_index == 0 && index % 500000 == 0)
+            data->progress("Loading face data", index / (Float) data->F.cols());
+
+        return 1;
+    };
+
+    VertexCallbackData vcbData(V, progress);
+    FaceCallbackData fcbData(F, progress);
+    VertexNormalCallbackData vncbData(N, progress);
+
+    if (!ply_set_read_cb(ply, "vertex", "x", rply_vertex_cb, &vcbData, 0) ||
+        !ply_set_read_cb(ply, "vertex", "y", rply_vertex_cb, &vcbData, 1) ||
+        !ply_set_read_cb(ply, "vertex", "z", rply_vertex_cb, &vcbData, 2)) {
+        ply_close(ply);
+        throw std::runtime_error("PLY file \"" + filename + "\" does not contain vertex position data!");
+    }
+
+    if (pointcloud && faceCount == 0) {
+        N.resize(3, vertexCount);
+        if (!ply_set_read_cb(ply, "vertex", "nx", rply_vertex_normal_cb, &vncbData, 0) ||
+            !ply_set_read_cb(ply, "vertex", "ny", rply_vertex_normal_cb, &vncbData, 1) ||
+            !ply_set_read_cb(ply, "vertex", "nz", rply_vertex_normal_cb, &vncbData, 2)) {
+            ply_close(ply);
+            throw std::runtime_error("PLY file \"" + filename + "\" does not contain vertex normal or face data!");
+        }
+    } else {
+        if (!ply_set_read_cb(ply, "face", "vertex_indices", rply_index_cb, &fcbData, 0)) {
+            ply_close(ply);
+            throw std::runtime_error("PLY file \"" + filename + "\" does not contain vertex indices!");
+        }
+    }
+
+    if (!ply_read(ply)) {
+        ply_close(ply);
+        throw std::runtime_error("Error while loading PLY data from \"" + filename + "\"!");
+    }
+
+    ply_close(ply);
+    cout << "done. (V=" << vertexCount;
+    if (faceCount > 0)
+        cout << ", F=" << faceCount;
+    cout << ", took " << timeString(timer.value()) << ")" << endl;
+}
+
+void write_ply(const std::string &filename, const MatrixXu &F,
+               const MatrixXf &V, const MatrixXf &N, const MatrixXf &Nf, const MatrixXf &UV,
+               const MatrixXf &C, const ProgressCallback &progress) {
+    auto message_cb = [](p_ply ply, const char *msg) { cerr << "rply: " << msg << endl; };
+
+    Timer<> timer;
+    cout << "Writing \"" << filename << "\" (V=" << V.cols()
+         << ", F=" << F.cols() << ") .. ";
+    cout.flush();
+
+    if (N.size() > 0 && Nf.size() > 0)
+        throw std::runtime_error("Please specify either face or vertex normals but not both!");
+
+    p_ply ply = ply_create(filename.c_str(), PLY_DEFAULT, message_cb, 0, nullptr);
+    if (!ply)
+        throw std::runtime_error("Unable to write PLY file!");
+
+    ply_add_comment(ply, "Generated by Instant Meshes");
+    ply_add_element(ply, "vertex", V.cols());
+    ply_add_scalar_property(ply, "x", PLY_FLOAT);
+    ply_add_scalar_property(ply, "y", PLY_FLOAT);
+    ply_add_scalar_property(ply, "z", PLY_FLOAT);
+
+    if (N.size() > 0) {
+        ply_add_scalar_property(ply, "nx", PLY_FLOAT);
+        ply_add_scalar_property(ply, "ny", PLY_FLOAT);
+        ply_add_scalar_property(ply, "nz", PLY_FLOAT);
+        if (N.cols() != V.cols() || N.rows() != 3)
+            throw std::runtime_error("Vertex normal matrix has incorrect size");
+    }
+
+    if (UV.size() > 0) {
+        ply_add_scalar_property(ply, "u", PLY_FLOAT);
+        ply_add_scalar_property(ply, "v", PLY_FLOAT);
+        if (UV.cols() != V.cols() || UV.rows() != 2)
+            throw std::runtime_error("Texture coordinate matrix has incorrect size");
+    }
+
+    if (C.size() > 0) {
+        ply_add_scalar_property(ply, "red", PLY_FLOAT);
+        ply_add_scalar_property(ply, "green", PLY_FLOAT);
+        ply_add_scalar_property(ply, "blue", PLY_FLOAT);
+        if (C.cols() != V.cols() || (C.rows() != 3 && C.rows() != 4))
+            throw std::runtime_error("Color matrix has incorrect size");
+    }
+
+    /* Check for irregular faces */
+    std::map<uint32_t, std::pair<uint32_t, std::map<uint32_t, uint32_t>>> irregular;
+    size_t nIrregular = 0;
+    if (F.rows() == 4) {
+        for (uint32_t f=0; f<F.cols(); ++f) {
+            if (F(2, f) == F(3, f)) {
+                nIrregular++;
+                auto &value = irregular[F(2, f)];
+                value.first = f;
+                value.second[F(0, f)] = F(1, f);
+            }
+        }
+    }
+
+    ply_add_element(ply, "face", F.cols() - nIrregular + irregular.size());
+    ply_add_list_property(ply, "vertex_indices", PLY_UINT8, PLY_INT);
+    if (Nf.size() > 0) {
+        ply_add_scalar_property(ply, "nx", PLY_FLOAT);
+        ply_add_scalar_property(ply, "ny", PLY_FLOAT);
+        ply_add_scalar_property(ply, "nz", PLY_FLOAT);
+        if (Nf.cols() != F.cols() || Nf.rows() != 3)
+            throw std::runtime_error("Face normal matrix has incorrect size");
+    }
+    ply_write_header(ply);
+
+    for (uint32_t j=0; j<V.cols(); ++j) {
+        for (uint32_t i=0; i<V.rows(); ++i)
+            ply_write(ply, V(i, j));
+        if (N.size() > 0) {
+            for (uint32_t i=0; i<N.rows(); ++i)
+                ply_write(ply, N(i, j));
+        }
+        if (UV.size() > 0) {
+            for (uint32_t i=0; i<UV.rows(); ++i)
+                ply_write(ply, UV(i, j));
+        }
+        if (C.size() > 0) {
+            for (uint32_t i=0; i<std::min(3u, (uint32_t) C.rows()); ++i)
+                ply_write(ply, C(i, j));
+        }
+        if (progress && j % 500000 == 0)
+            progress("Writing vertex data", j / (Float) V.cols());
+    }
+
+    for (uint32_t f=0; f<F.cols(); ++f) {
+        if (F.rows() == 4 && F(2, f) == F(3, f))
+            continue;
+        ply_write(ply, F.rows());
+        for (uint32_t i=0; i<F.rows(); ++i)
+            ply_write(ply, F(i, f));
+        if (Nf.size() > 0) {
+            for (uint32_t i=0; i<Nf.rows(); ++i)
+                ply_write(ply, Nf(i, f));
+        }
+        if (progress && f % 500000 == 0)
+            progress("Writing face data", f / (Float) F.cols());
+    }
+
+    for (auto item : irregular) {
+        auto face = item.second;
+        uint32_t v = face.second.begin()->first, first = v, i = 0;
+        ply_write(ply, face.second.size());
+        while (true) {
+            ply_write(ply, v);
+            v = face.second[v];
+            ++i;
+            if (v == first || i == face.second.size())
+                break;
+        }
+        while (i != face.second.size()) {
+            ply_write(ply, v);
+            ++i;
+        }
+        if (Nf.size() > 0) {
+            for (uint32_t i=0; i<Nf.rows(); ++i)
+                ply_write(ply, Nf(i, face.first));
+        }
+    }
+
+    ply_close(ply);
+    cout << "done. (";
+    if (irregular.size() > 0)
+        cout << irregular.size() << " irregular faces, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}
+
+void load_obj(const std::string &filename, MatrixXu &F, MatrixXf &V,
+              const ProgressCallback &progress) {
+    /// Vertex indices used by the OBJ format
+    struct obj_vertex {
+        uint32_t p = (uint32_t) -1;
+        uint32_t n = (uint32_t) -1;
+        uint32_t uv = (uint32_t) -1;
+
+        inline obj_vertex() { }
+
+        inline obj_vertex(const std::string &string) {
+            std::vector<std::string> tokens = str_tokenize(string, '/', true);
+
+            if (tokens.size() < 1 || tokens.size() > 3)
+                throw std::runtime_error("Invalid vertex data: \"" + string + "\"");
+
+            p = str_to_uint32_t(tokens[0]);
+
+            #if 0
+                if (tokens.size() >= 2 && !tokens[1].empty())
+                    uv = str_to_uint32_t(tokens[1]);
+
+                if (tokens.size() >= 3 && !tokens[2].empty())
+                    n = str_to_uint32_t(tokens[2]);
+            #endif
+        }
+
+        inline bool operator==(const obj_vertex &v) const {
+            return v.p == p && v.n == n && v.uv == uv;
+        }
+    };
+
+    /// Hash function for obj_vertex
+    struct obj_vertexHash : std::unary_function<obj_vertex, size_t> {
+        std::size_t operator()(const obj_vertex &v) const {
+            size_t hash = std::hash<uint32_t>()(v.p);
+            hash = hash * 37 + std::hash<uint32_t>()(v.uv);
+            hash = hash * 37 + std::hash<uint32_t>()(v.n);
+            return hash;
+        }
+    };
+
+    typedef std::unordered_map<obj_vertex, uint32_t, obj_vertexHash> VertexMap;
+
+    std::ifstream is(filename);
+    if (is.fail())
+        throw std::runtime_error("Unable to open OBJ file \"" + filename + "\"!");
+    cout << "Loading \"" << filename << "\" .. ";
+    cout.flush();
+    Timer<> timer;
+
+    std::vector<Vector3f>   positions;
+    //std::vector<Vector2f>   texcoords;
+    //std::vector<Vector3f>   normals;
+    std::vector<uint32_t>   indices;
+    std::vector<obj_vertex> vertices;
+    VertexMap vertexMap;
+
+    std::string line_str;
+    while (std::getline(is, line_str)) {
+        std::istringstream line(line_str);
+
+        std::string prefix;
+        line >> prefix;
+
+        if (prefix == "v") {
+            Vector3f p;
+            line >> p.x() >> p.y() >> p.z();
+            positions.push_back(p);
+        } else if (prefix == "vt") {
+            /*
+            Vector2f tc;
+            line >> tc.x() >> tc.y();
+            texcoords.push_back(tc);
+            */
+        } else if (prefix == "vn") {
+            /*
+            Vector3f n;
+            line >> n.x() >> n.y() >> n.z();
+            normals.push_back(n);
+            */
+        } else if (prefix == "f") {
+            std::string v1, v2, v3, v4;
+            line >> v1 >> v2 >> v3 >> v4;
+            obj_vertex tri[6];
+            int nVertices = 3;
+
+            tri[0] = obj_vertex(v1);
+            tri[1] = obj_vertex(v2);
+            tri[2] = obj_vertex(v3);
+
+            if (!v4.empty()) {
+                /* This is a quad, split into two triangles */
+                tri[3] = obj_vertex(v4);
+                tri[4] = tri[0];
+                tri[5] = tri[2];
+                nVertices = 6;
+            }
+            /* Convert to an indexed vertex list */
+            for (int i=0; i<nVertices; ++i) {
+                const obj_vertex &v = tri[i];
+                VertexMap::const_iterator it = vertexMap.find(v);
+                if (it == vertexMap.end()) {
+                    vertexMap[v] = (uint32_t) vertices.size();
+                    indices.push_back((uint32_t) vertices.size());
+                    vertices.push_back(v);
+                } else {
+                    indices.push_back(it->second);
+                }
+            }
+        }
+    }
+
+    F.resize(3, indices.size()/3);
+    memcpy(F.data(), indices.data(), sizeof(uint32_t)*indices.size());
+
+    V.resize(3, vertices.size());
+    for (uint32_t i=0; i<vertices.size(); ++i)
+        V.col(i) = positions.at(vertices[i].p-1);
+
+    cout << "done. (V=" << V.cols() << ", F=" << F.cols() << ", took "
+         << timeString(timer.value()) << ")" << endl;
+}
+
+void load_pointcloud(const std::string &filename, MatrixXf &V, MatrixXf &N,
+                     const ProgressCallback &progress) {
+    std::ifstream is(filename);
+    if (is.fail())
+        throw std::runtime_error("Unable to open ALN file \"" + filename + "\"!");
+    cout.flush();
+    Timer<> timer;
+    std::istringstream line;
+
+    auto fetch_line = [&]() {
+        std::string line_str;
+        do {
+            std::getline(is, line_str);
+            if (is.eof())
+                throw std::runtime_error("Parser error while processing ALN file!");
+        } while (line_str.empty() || line_str[0] == '#');
+        line.clear();
+        line.str(std::move(line_str));
+    };
+
+    auto fetch_string = [&](std::string &value) {
+        while (!(line >> value)) {
+            if (line.eof())
+                fetch_line();
+            else
+                throw std::runtime_error("Parser error while processing ALN file!");
+        }
+    };
+    auto fetch_uint = [&](uint32_t &value) {
+        while (!(line >> value)) {
+            if (line.eof())
+                fetch_line();
+            else
+                throw std::runtime_error("Parser error while processing ALN file!");
+        }
+    };
+
+    auto fetch_float = [&](Float &value) {
+        while (!(line >> value)) {
+            if (line.eof())
+                fetch_line();
+            else
+                throw std::runtime_error("Parser error while processing ALN file!");
+        }
+    };
+
+    uint32_t nFiles;
+    fetch_uint(nFiles);
+
+#if defined(_WIN32)
+    char path_drive[_MAX_DRIVE];
+    char path_dir[_MAX_DIR];
+    char path_fname[_MAX_FNAME];
+    char path_ext[_MAX_EXT];
+    _splitpath(filename.c_str(), path_drive, path_dir, path_fname, path_ext);
+#else
+    char *path_dir = dirname((char *) filename.c_str());
+#endif
+
+    for (uint32_t i=0; i<nFiles; ++i) {
+        std::string filename_sub;
+        fetch_string(filename_sub);
+        MatrixXu F_sub;
+        MatrixXf V_sub, N_sub;
+        load_ply(std::string(path_dir) + "/" + filename_sub, F_sub, V_sub, N_sub, true);
+        Eigen::Matrix<Float, 4, 4> M;
+        for (uint32_t k=0; k<16; ++k)
+            fetch_float(M.data()[k]);
+        M.transposeInPlace();
+        for (uint32_t k=0; k<V_sub.cols(); ++k) {
+            Vector4f p;
+            p << V_sub.col(k), 1.0f;
+            p = (M*p).eval();
+            p /= p.w();
+            V_sub.col(k) = p.head<3>();
+        }
+        if (N_sub.cols() == 0)
+            generate_smooth_normals(F_sub, V_sub, N_sub, true);
+        uint32_t base = (uint32_t) V.cols();
+        V.conservativeResize(3, base + V_sub.cols());
+        V.block(0, base, 3, V_sub.cols()) = V_sub;
+        N.conservativeResize(3, base + N_sub.cols());
+        N.block(0, base, 3, N_sub.cols()) = N_sub;
+        if (progress)
+            progress("Loading point cloud", i / (Float) (nFiles-1));
+    }
+
+    cout << "Point cloud loading finished. (V=" << V.cols() << ", took "
+         << timeString(timer.value()) << ")" << endl;
+}
+
+void write_obj(const std::string &filename, const MatrixXu &F,
+                const MatrixXf &V, const MatrixXf &N, const MatrixXf &Nf,
+                const MatrixXf &UV, const MatrixXf &C,
+                const ProgressCallback &progress) {
+    Timer<> timer;
+    cout << "Writing \"" << filename << "\" (V=" << V.cols()
+         << ", F=" << F.cols() << ") .. ";
+    cout.flush();
+    std::ofstream os(filename);
+    if (os.fail())
+        throw std::runtime_error("Unable to open OBJ file \"" + filename + "\"!");
+    if (N.size() > 0 && Nf.size() > 0)
+        throw std::runtime_error("Please specify either face or vertex normals but not both!");
+
+    for (uint32_t i=0; i<V.cols(); ++i)
+        os << "v " << V(0, i) << " " << V(1, i) << " " << V(2, i) << endl;
+
+    for (uint32_t i=0; i<N.cols(); ++i)
+        os << "vn " << N(0, i) << " " << N(1, i) << " " << N(2, i) << endl;
+
+    for (uint32_t i=0; i<Nf.cols(); ++i)
+        os << "vn " << Nf(0, i) << " " << Nf(1, i) << " " << Nf(2, i) << endl;
+
+    for (uint32_t i=0; i<UV.cols(); ++i)
+        os << "vt " << UV(0, i) << " " << UV(1, i) << endl;
+
+    /* Check for irregular faces */
+    std::map<uint32_t, std::pair<uint32_t, std::map<uint32_t, uint32_t>>> irregular;
+    size_t nIrregular = 0;
+
+    for (uint32_t f=0; f<F.cols(); ++f) {
+        if (F.rows() == 4) {
+            if (F(2, f) == F(3, f)) {
+                nIrregular++;
+                auto &value = irregular[F(2, f)];
+                value.first = f;
+                value.second[F(0, f)] = F(1, f);
+                continue;
+            }
+        }
+        os << "f ";
+        for (uint32_t j=0; j<F.rows(); ++j) {
+            uint32_t idx = F(j, f);
+            idx += 1;
+            os << idx;
+            if (Nf.size() > 0)
+                idx = f + 1;
+            os << "//" << idx << " ";
+        }
+        os << endl;
+    }
+
+    for (auto item : irregular) {
+        auto face = item.second;
+        uint32_t v = face.second.begin()->first, first = v, i = 0;
+        os << "f ";
+        while (true) {
+            uint32_t idx = v + 1;
+            os << idx;
+            if (Nf.size() > 0)
+                idx = face.first + 1;
+            os << "//" << idx << " ";
+
+            v = face.second[v];
+            if (v == first || ++i == face.second.size())
+                break;
+        }
+        os << endl;
+    }
+
+    cout << "done. (";
+    if (irregular.size() > 0)
+        cout << irregular.size() << " irregular faces, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}

intern/instant-meshes/src/meshio.h

@@ -0,0 +1,56 @@
+/*
+    meshio.h: Mesh file input/output routines
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+extern void
+load_mesh_or_pointcloud(const std::string &filename, MatrixXu &F,
+                        MatrixXf &V, MatrixXf &N,
+                        const ProgressCallback &progress = ProgressCallback());
+
+extern void load_obj(const std::string &filename, MatrixXu &F, MatrixXf &V,
+                     const ProgressCallback &progress = ProgressCallback());
+
+extern void load_ply(const std::string &filename, MatrixXu &F, MatrixXf &V,
+                     MatrixXf &N, bool pointcloud = false,
+                     const ProgressCallback &progress = ProgressCallback());
+
+extern void
+load_pointcloud(const std::string &filename, MatrixXf &V, MatrixXf &N,
+                const ProgressCallback &progress = ProgressCallback());
+
+extern void write_mesh(const std::string &filename, const MatrixXu &F,
+                      const MatrixXf &V,
+                      const MatrixXf &N = MatrixXf(),
+                      const MatrixXf &Nf = MatrixXf(),
+                      const MatrixXf &UV = MatrixXf(),
+                      const MatrixXf &C = MatrixXf(),
+                      const ProgressCallback &progress = ProgressCallback());
+
+extern void write_obj(const std::string &filename, const MatrixXu &F,
+                      const MatrixXf &V,
+                      const MatrixXf &N = MatrixXf(),
+                      const MatrixXf &Nf = MatrixXf(),
+                      const MatrixXf &UV = MatrixXf(),
+                      const MatrixXf &C = MatrixXf(),
+                      const ProgressCallback &progress = ProgressCallback());
+
+extern void write_ply(const std::string &filename, const MatrixXu &F,
+                      const MatrixXf &V,
+                      const MatrixXf &N = MatrixXf(),
+                      const MatrixXf &Nf = MatrixXf(),
+                      const MatrixXf &UV = MatrixXf(),
+                      const MatrixXf &C = MatrixXf(),
+                      const ProgressCallback &progress = ProgressCallback());

intern/instant-meshes/src/meshstats.cpp

@@ -0,0 +1,151 @@
+/*
+    meshstats.cpp: Routines to efficiently compute various mesh statistics such
+    as the bounding box, surface area, etc.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "meshstats.h"
+#include "dedge.h"
+
+MeshStats compute_mesh_stats(const MatrixXu &F, const MatrixXf &V,
+                             bool deterministic,
+                             const ProgressCallback &progress) {
+    Timer<> timer;
+    MeshStats stats;
+    if (F.size() != 0) {
+        cout << "Computing mesh statistics .. ";
+        cout.flush();
+        auto map = [&](const tbb::blocked_range<uint32_t> &range, MeshStats stats) -> MeshStats {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                Vector3f v[3] = { V.col(F(0, f)), V.col(F(1, f)), V.col(F(2, f)) };
+                Vector3f face_center = Vector3f::Zero();
+
+                for (int i=0; i<3; ++i) {
+                    Float edge_length = (v[i] - v[i == 2 ? 0 : (i+1)]).norm();
+                    stats.mAverageEdgeLength += edge_length;
+                    stats.mMaximumEdgeLength = std::max(stats.mMaximumEdgeLength, (double) edge_length);
+                    stats.mAABB.expandBy(v[i]);
+                    face_center += v[i];
+                }
+                face_center *= 1.0f / 3.0f;
+
+                Float face_area = 0.5f * (v[1]-v[0]).cross(v[2]-v[0]).norm();
+                stats.mSurfaceArea += face_area;
+                stats.mWeightedCenter += face_area * face_center;
+            }
+            SHOW_PROGRESS_RANGE(range, F.cols(), "Computing mesh statistics");
+            return stats;
+        };
+
+        auto reduce = [](MeshStats s0, MeshStats s1) -> MeshStats {
+            MeshStats result;
+            result.mSurfaceArea = s0.mSurfaceArea + s1.mSurfaceArea;
+            result.mWeightedCenter = s0.mWeightedCenter + s1.mWeightedCenter;
+            result.mAverageEdgeLength = 
+                s0.mAverageEdgeLength + s1.mAverageEdgeLength;
+            result.mMaximumEdgeLength =
+                std::max(s0.mMaximumEdgeLength, s1.mMaximumEdgeLength);
+            result.mAABB = AABB::merge(s0.mAABB, s1.mAABB);
+            return result;
+        };
+
+        tbb::blocked_range<uint32_t> range(0u, (uint32_t) F.cols(), GRAIN_SIZE);
+
+        if (deterministic)
+            stats = tbb::parallel_deterministic_reduce(range, MeshStats(), map, reduce);
+        else
+            stats = tbb::parallel_reduce(range, MeshStats(), map, reduce);
+
+        stats.mAverageEdgeLength /= F.cols() * 3;
+        stats.mWeightedCenter /= stats.mSurfaceArea;
+    } else {
+        cout << "Computing point cloud statistics .. ";
+        cout.flush();
+        auto map = [&](const tbb::blocked_range<uint32_t> &range, MeshStats stats) -> MeshStats {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                const Vector3f &v = V.col(i);
+                stats.mAABB.expandBy(v);
+                stats.mWeightedCenter += v;
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing point cloud statistics");
+            return stats;
+        };
+
+        auto reduce = [](MeshStats s0, MeshStats s1) -> MeshStats {
+            MeshStats result;
+            result.mWeightedCenter = s0.mWeightedCenter + s1.mWeightedCenter;
+            result.mAABB = AABB::merge(s0.mAABB, s1.mAABB);
+            return result;
+        };
+
+        tbb::blocked_range<uint32_t> range(0u, (uint32_t) V.cols(), GRAIN_SIZE);
+
+        if (deterministic)
+            stats = tbb::parallel_deterministic_reduce(range, MeshStats(), map, reduce);
+        else
+            stats = tbb::parallel_reduce(range, MeshStats(), map, reduce);
+
+        stats.mSurfaceArea = stats.mAverageEdgeLength = stats.mMaximumEdgeLength = 0;
+        stats.mWeightedCenter /= V.cols();
+    }
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+
+    return stats;
+}
+
+void compute_dual_vertex_areas(const MatrixXu &F, const MatrixXf &V,
+                                 const VectorXu &V2E, const VectorXu &E2E,
+                                 const VectorXb &nonManifold, VectorXf &A,
+                                 const ProgressCallback &progress) {
+    A.resize(V.cols());
+    A.setZero();
+    cout << "Computing dual vertex areas .. ";
+    cout.flush();
+    Timer<> timer;
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID)
+                    continue;
+                Float vertex_area = 0;
+                do {
+                    uint32_t ep = dedge_prev_3(edge), en = dedge_next_3(edge); 
+
+                    Vector3f v = V.col(F(edge%3, edge/3));
+                    Vector3f vn = V.col(F(en%3, en/3));
+                    Vector3f vp = V.col(F(ep%3, ep/3));
+
+                    Vector3f face_center = (v + vp + vn) * (1.0f / 3.0f);
+                    Vector3f prev = (v+vp) * 0.5f;
+                    Vector3f next = (v+vn) * 0.5f;
+
+                    vertex_area +=
+                        0.5f * ((v - prev).cross(v - face_center).norm() +
+                                (v - next).cross(v - face_center).norm());
+
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID)
+                        break;
+                    edge = dedge_next_3(opp);
+                } while (edge != stop);
+
+                A[i] = vertex_area;
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing dual vertex areas");
+        }
+    );
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}

intern/instant-meshes/src/meshstats.h

@@ -0,0 +1,41 @@
+/*
+    meshstats.h: Routines to efficiently compute various mesh statistics such
+    as the bounding box, surface area, etc.
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "aabb.h"
+
+struct MeshStats {
+    AABB mAABB;
+    Vector3f mWeightedCenter;
+    double mAverageEdgeLength;
+    double mMaximumEdgeLength;
+    double mSurfaceArea;
+
+    MeshStats() :
+        mWeightedCenter(Vector3f::Zero()),
+        mAverageEdgeLength(0.0f),
+        mMaximumEdgeLength(0.0f),
+        mSurfaceArea(0.0f) { }
+};
+
+extern MeshStats
+compute_mesh_stats(const MatrixXu &F, const MatrixXf &V,
+                   bool deterministic = false,
+                   const ProgressCallback &progress = ProgressCallback());
+
+void compute_dual_vertex_areas(
+    const MatrixXu &F, const MatrixXf &V, const VectorXu &V2E,
+    const VectorXu &E2E, const VectorXb &nonManifold, VectorXf &A,
+    const ProgressCallback &progress = ProgressCallback());

intern/instant-meshes/src/normal.cpp

@@ -0,0 +1,443 @@
+/*
+    normal.cpp: Helper routines for computing vertex normals
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "normal.h"
+#include "dedge.h"
+
+extern void
+generate_smooth_normals(const MatrixXu &F, const MatrixXf &V, MatrixXf &N,
+                        bool deterministic,
+                        const ProgressCallback &progress) {
+    cout << "Computing vertex normals .. ";
+    cout.flush();
+
+    std::atomic<uint32_t> badFaces(0);
+    Timer<> timer;
+    N.resize(V.rows(), V.cols());
+    N.setZero();
+
+    auto map = [&](const tbb::blocked_range<uint32_t> &range) {
+        for (uint32_t f = range.begin(); f != range.end(); ++f) {
+            Vector3f fn = Vector3f::Zero();
+            for (int i=0; i<3; ++i) {
+                Vector3f v0 = V.col(F(i, f)),
+                         v1 = V.col(F((i+1)%3, f)),
+                         v2 = V.col(F((i+2)%3, f)),
+                         d0 = v1-v0,
+                         d1 = v2-v0;
+
+                if (i == 0) {
+                    fn = d0.cross(d1);
+                    Float norm = fn.norm();
+                    if (norm < RCPOVERFLOW) {
+                        badFaces++; /* degenerate */
+                        break;
+                    }
+                    fn /= norm;
+                }
+
+                /* "Computing Vertex Normals from Polygonal Facets"
+                    by Grit Thuermer and Charles A. Wuethrich, JGT 1998, Vol 3 */
+                Float angle = fast_acos(d0.dot(d1) / std::sqrt(d0.squaredNorm() * d1.squaredNorm()));
+                for (uint32_t k=0; k<3; ++k)
+                    atomicAdd(&N.coeffRef(k, F(i, f)), fn[k]*angle);
+            }
+        }
+        SHOW_PROGRESS_RANGE(range, F.cols(), "Computing vertex normals (1/2)");
+    };
+
+    tbb::blocked_range<uint32_t> range(0u, (uint32_t) F.cols(), GRAIN_SIZE);
+
+    if (!deterministic)
+        tbb::parallel_for(range, map);
+    else
+        map(range);
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                Float norm = N.col(i).norm();
+                if (norm < RCPOVERFLOW) {
+                    N.col(i) = Vector3f::UnitX();
+                } else {
+                    N.col(i) /= norm;
+                }
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing vertex normals (2/2)");
+        }
+    );
+
+    cout << "done. (";
+    if (badFaces > 0)
+        cout << badFaces << " degenerate faces, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}
+
+void generate_smooth_normals(const MatrixXu &F, const MatrixXf &V, const VectorXu &V2E,
+                             const VectorXu &E2E, const VectorXb &nonManifold,
+                             MatrixXf &N, const ProgressCallback &progress) {
+    cout << "Computing vertex normals .. ";
+    cout.flush();
+
+    std::atomic<uint32_t> badFaces(0);
+    Timer<> timer;
+
+    /* Compute face normals */
+    MatrixXf Nf(3, F.cols());
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) F.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                Vector3f v0 = V.col(F(0, f)),
+                         v1 = V.col(F(1, f)),
+                         v2 = V.col(F(2, f)),
+                         n = (v1-v0).cross(v2-v0);
+                Float norm = n.norm();
+                if (norm < RCPOVERFLOW) {
+                    badFaces++; /* degenerate */
+                    n = Vector3f::UnitX();
+                } else {
+                    n /= norm;
+                }
+                Nf.col(f) = n;
+            }
+            SHOW_PROGRESS_RANGE(range, F.cols(), "Computing vertex normals (1/2)");
+        }
+    );
+
+    N.resize(3, V.cols());
+
+    /* Finally, compute the normals */
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i];
+                if (nonManifold[i] || edge == INVALID) {
+                    N.col(i) = Vector3f::UnitX();
+                    continue;
+                }
+
+                uint32_t stop = edge;
+                Vector3f normal = Vector3f::Zero();
+                do {
+                    uint32_t idx = edge % 3;
+
+                    Vector3f d0 = V.col(F((idx+1)%3, edge/3)) - V.col(i);
+                    Vector3f d1 = V.col(F((idx+2)%3, edge/3)) - V.col(i);
+                    Float angle = fast_acos(d0.dot(d1) / std::sqrt(d0.squaredNorm() * d1.squaredNorm()));
+
+                    /* "Computing Vertex Normals from Polygonal Facets"
+                        by Grit Thuermer and Charles A. Wuethrich, JGT 1998, Vol 3 */
+                    if (std::isfinite(angle))
+                        normal += Nf.col(edge/3) * angle;
+
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID)
+                        break;
+
+                    edge = dedge_next_3(opp);
+                } while (edge != stop);
+                Float norm = normal.norm();
+                N.col(i) = norm > RCPOVERFLOW ? Vector3f(normal / norm)
+                                              : Vector3f::UnitX();
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing vertex normals (2/2)");
+        }
+    );
+
+    cout << "done. (";
+    if (badFaces > 0)
+        cout << badFaces << " degenerate faces, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}
+
+void generate_crease_normals(MatrixXu &F, MatrixXf &V, const VectorXu &_V2E,
+                             const VectorXu &E2E, const VectorXb boundary,
+                             const VectorXb &nonManifold, Float angleThreshold,
+                             MatrixXf &N, std::map<uint32_t, uint32_t> &creases,
+                             const ProgressCallback &progress) {
+    const Float dpThreshold = std::cos(angleThreshold * M_PI / 180);
+
+    cout << "Computing vertex & crease normals .. ";
+    cout.flush();
+    creases.clear();
+
+    std::atomic<uint32_t> badFaces(0), creaseVert(0), offset(V.cols());
+    Timer<> timer;
+    VectorXu V2E(_V2E);
+
+    /* Compute face normals */
+    MatrixXf Nf(3, F.cols());
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) F.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                Vector3f v0 = V.col(F(0, f)),
+                         v1 = V.col(F(1, f)),
+                         v2 = V.col(F(2, f)),
+                         n = (v1-v0).cross(v2-v0);
+                Float norm = n.norm();
+                if (norm < RCPOVERFLOW) {
+                    badFaces++; /* degenerate */
+                    n = Vector3f::UnitX();
+                } else {
+                    n /= norm;
+                }
+                Nf.col(f) = n;
+            }
+            SHOW_PROGRESS_RANGE(range, F.cols(), "Computing vertex & crease normals (1/3)");
+        }
+    );
+
+    /* Determine how many extra vertices are needed, and adjust
+       the vertex->edge pointers so that they are located just after
+       the first crease edge */
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID)
+                    continue;
+                uint32_t creaseEdge = INVALID, nCreaseEdges = 0;
+                bool is_boundary = boundary[i];
+                do {
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID)
+                        break;
+                    uint32_t nextEdge = dedge_next_3(opp);
+                    if (Nf.col(edge / 3).dot(Nf.col(nextEdge / 3)) < dpThreshold) {
+                        nCreaseEdges++;
+                        if (creaseEdge == INVALID || creaseEdge < nextEdge)
+                            creaseEdge = nextEdge;
+                    }
+                    edge = nextEdge;
+                } while (edge != stop);
+
+                if (creaseEdge != INVALID) {
+                    if (!is_boundary)
+                        V2E[i] = creaseEdge;
+                    creaseVert += nCreaseEdges - (is_boundary ? 0 : 1);
+                }
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing vertex & crease normals (2/3)");
+        }
+    );
+
+    uint32_t oldSize = V.cols();
+    V.conservativeResize(3, V.cols() + creaseVert);
+    N.resize(3, V.cols());
+
+    tbb::spin_mutex mutex;
+
+    /* Finally, compute the normals */
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, oldSize, GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i];
+                if (nonManifold[i] || edge == INVALID) {
+                    N.col(i) = Vector3f::UnitX();
+                    continue;
+                }
+
+                uint32_t stop = edge, vertexID = i;
+                Vector3f normal = Vector3f::Zero();
+                do {
+                    uint32_t idx = edge % 3;
+                    if (vertexID != i)
+                        F(idx, edge/3) = vertexID;
+
+                    Vector3f d0 = V.col(F((idx+1)%3, edge/3)) - V.col(i);
+                    Vector3f d1 = V.col(F((idx+2)%3, edge/3)) - V.col(i);
+                    Float angle = fast_acos(d0.dot(d1) / std::sqrt(d0.squaredNorm() * d1.squaredNorm()));
+
+                    /* "Computing Vertex Normals from Polygonal Facets"
+                        by Grit Thuermer and Charles A. Wuethrich, JGT 1998, Vol 3 */
+                    if (std::isfinite(angle))
+                        normal += Nf.col(edge/3) * angle;
+
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID) {
+                        Float norm = normal.norm();
+                        N.col(vertexID) = norm > RCPOVERFLOW ? Vector3f(normal / norm)
+                                                             : Vector3f::UnitX();
+                        break;
+                    }
+
+                    uint32_t nextEdge = dedge_next_3(opp);
+                    if (Nf.col(edge / 3).dot(Nf.col(nextEdge / 3)) < dpThreshold ||
+                        nextEdge == stop) {
+                        Float norm = normal.norm();
+                        N.col(vertexID) = norm > RCPOVERFLOW ? Vector3f(normal / norm)
+                                                             : Vector3f::UnitX();
+                        normal = Vector3f::Zero();
+                        if (nextEdge != stop) {
+                            vertexID = offset++;
+                            V.col(vertexID) = V.col(i);
+                            mutex.lock();
+                            creases[vertexID] = i;
+                            mutex.unlock();
+                        }
+                    }
+                    edge = nextEdge;
+                } while (edge != stop);
+            }
+            SHOW_PROGRESS_RANGE(range, oldSize, "Computing vertex & crease normals (3/3)");
+        }
+    );
+
+    if (offset != (uint32_t) V.cols())
+        throw std::runtime_error("Internal error (incorrect final vertex count)!");
+
+    cout << "done. (";
+    if (badFaces > 0)
+        cout << badFaces << " degenerate faces, ";
+    if (creaseVert > 0)
+        cout << creaseVert << " crease vertices, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}
+
+void generate_crease_normals(const MatrixXu &F, const MatrixXf &V,
+                             const VectorXu &_V2E, const VectorXu &E2E,
+                             const VectorXb boundary,
+                             const VectorXb &nonManifold, Float angleThreshold,
+                             MatrixXf &N, std::set<uint32_t> &creases,
+                             const ProgressCallback &progress) {
+    const Float dpThreshold = std::cos(angleThreshold * M_PI / 180);
+
+    cout << "Computing vertex & crease normals .. ";
+    cout.flush();
+    creases.clear();
+
+    Timer<> timer;
+    VectorXu V2E(_V2E);
+
+    /* Compute face normals */
+    MatrixXf Nf(3, F.cols());
+    std::atomic<uint32_t> badFaces(0);
+
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) F.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t f = range.begin(); f != range.end(); ++f) {
+                Vector3f v0 = V.col(F(0, f)),
+                         v1 = V.col(F(1, f)),
+                         v2 = V.col(F(2, f)),
+                         n = (v1-v0).cross(v2-v0);
+                Float norm = n.norm();
+                if (norm < RCPOVERFLOW) {
+                    badFaces++; /* degenerate */
+                    n = Vector3f::UnitX();
+                } else {
+                    n /= norm;
+                }
+                Nf.col(f) = n;
+            }
+            SHOW_PROGRESS_RANGE(range, F.cols(), "Computing vertex & crease normals (1/3)");
+        }
+    );
+
+    /* Determine how many extra vertices are needed, and adjust
+       the vertex->edge pointers so that they are located just after
+       the first crease edge */
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, (uint32_t) V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i], stop = edge;
+                if (nonManifold[i] || edge == INVALID)
+                    continue;
+                uint32_t creaseEdge = INVALID;
+                do {
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID)
+                        break;
+                    uint32_t nextEdge = dedge_next_3(opp);
+                    if (Nf.col(edge / 3).dot(Nf.col(nextEdge / 3)) < dpThreshold) {
+                        if (creaseEdge == INVALID || creaseEdge < nextEdge)
+                            creaseEdge = nextEdge;
+                    }
+                    edge = nextEdge;
+                } while (edge != stop);
+
+                if (creaseEdge != INVALID) {
+                    if (!boundary[i])
+                        V2E[i] = creaseEdge;
+                }
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing vertex & crease normals (2/3)");
+        }
+    );
+
+    N.resize(3, V.cols());
+
+    /* Finally, compute the normals */
+    tbb::spin_mutex mutex;
+    tbb::parallel_for(
+        tbb::blocked_range<uint32_t>(0u, V.cols(), GRAIN_SIZE),
+        [&](const tbb::blocked_range<uint32_t> &range) {
+            for (uint32_t i = range.begin(); i != range.end(); ++i) {
+                uint32_t edge = V2E[i];
+                if (nonManifold[i] || edge == INVALID) {
+                    N.col(i) = Vector3f::UnitX();
+                    continue;
+                }
+
+                uint32_t stop = edge;
+                Vector3f normal = Vector3f::Zero();
+                do {
+                    uint32_t idx = edge % 3, face = edge/3;
+
+                    Vector3f d0 = V.col(F((idx+1)%3, face)) - V.col(i);
+                    Vector3f d1 = V.col(F((idx+2)%3, face)) - V.col(i);
+                    Float angle = fast_acos(d0.dot(d1) / std::sqrt(d0.squaredNorm() * d1.squaredNorm()));
+
+                    /* "Computing Vertex Normals from Polygonal Facets"
+                        by Grit Thuermer and Charles A. Wuethrich, JGT 1998, Vol 3 */
+                    if (std::isfinite(angle))
+                        normal += Nf.col(edge/3) * angle;
+
+                    uint32_t opp = E2E[edge];
+                    if (opp == INVALID)
+                        break;
+
+                    uint32_t nextEdge = dedge_next_3(opp);
+                    if (Nf.col(edge / 3).dot(Nf.col(nextEdge / 3)) < dpThreshold) {
+                        mutex.lock();
+                        creases.insert(i);
+                        mutex.unlock();
+                        break;
+                    }
+
+                    edge = nextEdge;
+                } while (edge != stop);
+                Float norm = normal.norm();
+                N.col(i) = norm > RCPOVERFLOW ? Vector3f(normal / norm)
+                                              : Vector3f::UnitX();
+            }
+            SHOW_PROGRESS_RANGE(range, V.cols(), "Computing vertex & crease normals (3/3)");
+        }
+    );
+
+    cout << "done. (";
+    if (badFaces > 0)
+        cout << badFaces << " degenerate faces, ";
+    if (!creases.empty())
+        cout << creases.size() << " crease vertices, ";
+    cout << "took " << timeString(timer.value()) << ")" << endl;
+}

intern/instant-meshes/src/normal.h

@@ -0,0 +1,43 @@
+/*
+    normal.h: Helper routines for computing vertex normals
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+#include <map>
+#include <set>
+
+extern void
+generate_smooth_normals(const MatrixXu &F, const MatrixXf &V, MatrixXf &N,
+                        bool deterministic,
+                        const ProgressCallback &progress = ProgressCallback());
+
+extern void
+generate_smooth_normals(const MatrixXu &F, const MatrixXf &V,
+                        const VectorXu &V2E, const VectorXu &E2E,
+                        const VectorXb &nonManifold, MatrixXf &N,
+                        const ProgressCallback &progress = ProgressCallback());
+
+extern void
+generate_crease_normals(MatrixXu &F, MatrixXf &V, const VectorXu &V2E,
+                        const VectorXu &E2E, const VectorXb boundary,
+                        const VectorXb &nonManifold, Float angleThreshold,
+                        MatrixXf &N, std::map<uint32_t, uint32_t> &creases,
+                        const ProgressCallback &progress = ProgressCallback());
+
+extern void
+generate_crease_normals(
+    const MatrixXu &F, const MatrixXf &V, const VectorXu &V2E, const VectorXu &E2E,
+    const VectorXb boundary, const VectorXb &nonManifold, Float angleThreshold,
+    MatrixXf &N, std::set<uint32_t> &creases,
+    const ProgressCallback &progress = ProgressCallback());

intern/instant-meshes/src/reorder.cpp

@@ -0,0 +1,123 @@
+/*
+    reorder.cpp: Reorder mesh face/vertex indices to improve coherence in various
+    applications
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "reorder.h"
+#include "dedge.h"
+
+#include <unordered_set>
+#include <unordered_map>
+#include <queue>
+
+void reorder_mesh(MatrixXu &F, std::vector<MatrixXf> &V_vec, std::vector<MatrixXf> &F_vec,
+                  const ProgressCallback &progress) {
+    /* Build a directed edge data structure */
+    VectorXu V2E, E2E;
+    VectorXb boundary, nonManifold;
+    build_dedge(F, V_vec[0], V2E, E2E, boundary, nonManifold, progress, true);
+
+    std::unordered_set<uint32_t> unprocessed(F.cols());
+    for (uint32_t i=0; i<F.cols(); ++i)
+        unprocessed.insert(i);
+
+    std::queue<uint32_t> queue;
+    std::unordered_map<uint32_t, uint32_t> v_map(V_vec[0].cols());
+
+    uint32_t nF = 0, nV = 0;
+
+    MatrixXu Fp(F.rows(), F.cols());
+    std::vector<MatrixXf> V_new(V_vec.size()), F_new(F_vec.size());
+
+    for (uint32_t i=0; i<V_vec.size(); ++i) {
+        if (V_vec[i].cols() != V_vec[0].cols())
+            throw std::runtime_error("reorder_mesh: inconsistent input!");
+        V_new[i].resize(V_vec[i].rows(), V_vec[i].cols());
+    }
+
+    for (uint32_t i=0; i<F_vec.size(); ++i) {
+        if (F_vec[i].cols() != F.cols())
+            throw std::runtime_error("reorder_mesh: inconsistent input!");
+        F_new[i].resize(F_vec[i].rows(), F_vec[i].cols());
+    }
+
+    while (!unprocessed.empty()) {
+        if (queue.empty()) {
+            auto it = unprocessed.begin();
+            queue.push(*it);
+            unprocessed.erase(it);
+        }
+
+        while (!queue.empty()) {
+            uint32_t f_old = queue.front();
+            uint32_t f_new = nF++;
+            queue.pop();
+            for (uint32_t j=0; j<F_vec.size(); ++j)
+                F_new[j].col(f_new) = F_vec[j].col(f_old);
+
+            for (uint32_t i=0; i<F.rows(); ++i) {
+                uint32_t v_old = F(i, f_old);
+
+                uint32_t v_new;
+                auto it_v = v_map.find(v_old);
+                if (it_v != v_map.end()) {
+                    v_new = it_v->second;
+                } else {
+                    v_new = v_map[v_old] = nV++;
+                    for (uint32_t j=0; j<V_vec.size(); ++j)
+                        V_new[j].col(v_new) = V_vec[j].col(v_old);
+                }
+
+                Fp(i, f_new) = v_new;
+
+                uint32_t edge_other = E2E[f_old * F.rows() + i];
+                if (edge_other != INVALID) {
+                    uint32_t f_neighbor = edge_other / F.rows();
+                    auto it_f = unprocessed.find(f_neighbor);
+                    if (it_f != unprocessed.end()) {
+                        queue.push(f_neighbor);
+                        unprocessed.erase(f_neighbor);
+                    }
+                }
+            }
+
+            if (progress && unprocessed.size() % 10000 == 0)
+                progress("Reordering mesh indices", 1-unprocessed.size() / (Float) F.cols());
+        }
+    }
+
+    F = std::move(Fp);
+    for (uint32_t i=0; i<V_vec.size(); ++i) {
+        V_vec[i] = std::move(V_new[i]);
+        V_vec[i].conservativeResize(V_vec[i].rows(), nV);
+    }
+    for (uint32_t i=0; i<F_vec.size(); ++i) {
+        F_vec[i] = std::move(F_new[i]);
+        F_vec[i].conservativeResize(F_vec[i].rows(), nF);
+    }
+}
+
+void replicate_vertices(MatrixXu &F, std::vector<MatrixXf> &V) {
+    std::vector<MatrixXf> R(V.size());
+
+    for (uint32_t i=0; i<V.size(); ++i)
+        R[i].resize(V[i].rows(), F.size());
+
+    for (uint32_t i=0; i<F.size(); ++i) {
+        uint32_t &idx = F.data()[i];
+        for (uint32_t j=0; j<V.size(); ++j)
+            R[j].col(i) = V[j].col(idx);
+        idx = i;
+    }
+
+    V = std::move(R);
+}

intern/instant-meshes/src/reorder.h

@@ -0,0 +1,22 @@
+/*
+    reorder.h: Reorder mesh face/vertex indices to improve coherence in various
+    applications
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+extern void reorder_mesh(MatrixXu &F, std::vector<MatrixXf> &V_vec, std::vector<MatrixXf> &F_vec,
+                         const ProgressCallback &progress = ProgressCallback());
+
+extern void replicate_vertices(MatrixXu &F, std::vector<MatrixXf> &V);

intern/instant-meshes/src/serializer.cpp

@@ -0,0 +1,466 @@
+/*
+    serializer.cpp: Helper class to serialize the application state to a .PLY file
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "serializer.h"
+#include <set>
+
+extern "C" {
+    #include "rply.h"
+}
+
+Serializer::Serializer() : mCompatibilityMode(false) { mPrefixStack.push(""); }
+
+bool Serializer::isSerializedFile(const std::string &filename) {
+    auto message_cb = [](p_ply ply, const char *msg) { /* ignore */};
+    p_ply ply = ply_open(filename.c_str(), message_cb, 0, nullptr);
+    if (!ply)
+        return false;
+    if (!ply_read_header(ply)) {
+        ply_close(ply);
+        return false;
+    }
+    bool is_serialized = false;
+    const char *comment = nullptr;
+    while ((comment = ply_get_next_comment(ply, comment))) {
+        if (strcmp(comment, "Instant Meshes Application State") == 0)
+            is_serialized = true;
+    }
+    ply_close(ply);
+    return is_serialized;
+}
+
+std::vector<std::string> Serializer::getKeys() const {
+    const std::string &prefix = mPrefixStack.top();
+    std::vector<std::string> result;
+    for (auto const &kv : mData) {
+        if (kv.first.substr(0, prefix.length()) == prefix)
+            result.push_back(kv.first.substr(prefix.length()));
+    }
+    return result;
+}
+
+struct CallbackState {
+    const ProgressCallback &progress;
+    void *data;
+    std::string name;
+    size_t offset, total = 0;
+    bool visited = false;
+
+    CallbackState(const ProgressCallback &progress, void *data,
+        const std::string &name, size_t offset)
+        : progress(progress), data(data), name(name), offset(offset) {}
+};
+
+
+Serializer::Serializer(const std::string &filename, bool compatibilityMode, const ProgressCallback &progress)
+    : mCompatibilityMode(compatibilityMode) {
+    auto message_cb = [](p_ply ply, const char *msg) { cerr << "rply: " << msg << endl; };
+
+    mPrefixStack.push("");
+    Timer<> timer;
+    cout << "Unserializing application state from \"" << filename << "\" .. ";
+    cout.flush();
+
+    p_ply ply = ply_open(filename.c_str(), message_cb, 0, nullptr);
+    if (!ply)
+        throw std::runtime_error("Serializer: unable to open PLY file \"" + filename + "\"!");
+
+    if (!ply_read_header(ply)) {
+        ply_close(ply);
+        throw std::runtime_error("Serializer: unable to open PLY header of \"" + filename + "\"!");
+    }
+
+    p_ply_element element = nullptr;
+
+    #define IMPLEMENT(type) \
+        case Variant::Matrix_##type: \
+            const_cast<Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic>&>(*data->matrix_##type)(coord, index) = (type) ply_get_argument_value(argument); \
+            break; \
+        \
+        case Variant::List_##type: {\
+                ply_get_argument_property(argument, nullptr, &length, &value_index); \
+                std::vector<std::vector<type>> &vec = \
+                    const_cast<std::vector<std::vector<type>>&>(*data->list_##type); \
+                if (value_index >= 0) \
+                    vec[index][value_index] = (type) ply_get_argument_value(argument); \
+                else \
+                    vec[index].resize(length); \
+            } \
+            break;
+
+
+    auto rply_element_cb = [](p_ply_argument argument) -> int {
+        CallbackState *state; long index, coord, length, value_index;
+        ply_get_argument_user_data(argument, (void **) &state, &coord);
+        Variant *data = (Variant *) state->data;
+        ply_get_argument_element(argument, nullptr, &index);
+        switch (data->type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+            default:
+                throw std::runtime_error("Unexpected data type while unserializing! (1)");
+        }
+        if (state->progress && !state->visited) {
+            state->progress("Loading field \"" + state->name + "\"", state->offset / (float) state->total);
+            state->visited = true;
+        }
+        return 1;
+    };
+    #undef IMPLEMENT
+
+    std::vector<CallbackState *> callbackStates;
+    try {
+        /* Inspect the structure of the PLY file */
+        size_t totalSize = 0;
+        while ((element = ply_get_next_element(ply, element)) != nullptr) {
+            const char *element_name;
+            long cols = 0, rows = 0;
+
+            ply_get_element_info(element, &element_name, &cols);
+            e_ply_type type = PLY_UINT8;
+            bool fail = false, list = false;
+
+            p_ply_property property = nullptr;
+            while ((property = ply_get_next_property(element, property)) != nullptr) {
+                e_ply_type property_type, length_type, list_type;
+                const char *property_name;
+                ply_get_property_info(property, &property_name, &property_type,
+                                      &length_type, &list_type);
+                if (property_type == PLY_LIST) {
+                    property_type = list_type;
+                    list = true;
+                }
+                if (rows == 0)
+                    type = property_type;
+                else if (type != property_type)
+                    fail = true;
+                if (cols == 0)
+                    continue;
+                Variant &variant = mData[element_name];
+                CallbackState *state = new CallbackState(progress, &variant, element_name, totalSize);
+                callbackStates.push_back(state);
+                if (!ply_set_read_cb(ply, element_name, property_name, rply_element_cb, state, rows++)) {
+                    ply_close(ply);
+                    throw std::runtime_error(
+                        "Serializer: could not register read callback for " + std::string(element_name) +
+                        "." + std::string(property_name) + " in PLY file \"" + filename + "\"!");
+                }
+            }
+            if (rows == 0 && cols == 0)
+                rows = 1;
+
+            if (fail)
+                throw std::runtime_error("Serializer: unsupported data format in \"" + filename + "\"!");
+
+            Variant &variant = mData[std::string(element_name)];
+            totalSize += cols;
+
+            #define IMPLEMENT(ply_type, type) \
+                case ply_type: \
+                    if (list) { \
+                        auto l = new std::vector<std::vector<type>>(); \
+                        variant.type_id = Variant::Type::List_##type; \
+                        variant.list_##type = l; \
+                        l->resize(cols); \
+                    } else { \
+                        auto mat = new Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic>(rows, cols); \
+                        variant.type_id = Variant::Type::Matrix_##type; \
+                        variant.matrix_##type = mat; \
+                    } \
+                    break;
+
+            switch (type) {
+                IMPLEMENT(PLY_UINT8, uint8_t)
+                IMPLEMENT(PLY_UINT16, uint16_t)
+                IMPLEMENT(PLY_UINT32, uint32_t)
+                IMPLEMENT(PLY_FLOAT32, float)
+                IMPLEMENT(PLY_FLOAT64, double)
+                default:
+                    throw std::runtime_error("Unexpected data type while unserializing! (2)");
+            }
+            #undef IMPLEMENT
+        }
+        for (auto c : callbackStates)
+            c->total = totalSize;
+
+        if (!ply_read(ply)) {
+            ply_close(ply);
+            throw std::runtime_error("Error while loading application state from \"" + filename + "\"!");
+        }
+    } catch (...) {
+        for (auto c : callbackStates)
+            delete c;
+        throw;
+    }
+    ply_close(ply);
+    for (auto c : callbackStates)
+        delete c;
+
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}
+
+Serializer::~Serializer() {
+    #define IMPLEMENT(type) \
+        case Variant::Type::List_##type: delete kv.second.list_##type; break; \
+        case Variant::Type::Matrix_##type: delete kv.second.matrix_##type; break;
+
+    for (auto const &kv : mData) {
+        switch (kv.second.type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+            default: break;
+        }
+    }
+
+    #undef IMPLEMENT
+}
+
+void Serializer::write(const std::string &filename, const ProgressCallback &progress) {
+    auto message_cb = [](p_ply ply, const char *msg) { cerr << "rply: " << msg << endl; };
+
+    Timer<> timer;
+    cout << "Writing application state to \"" << filename << "\" .. ";
+    cout.flush();
+
+    p_ply ply = ply_create(filename.c_str(), PLY_DEFAULT, message_cb, 0, nullptr);
+    if (!ply)
+        throw std::runtime_error("Unable to write PLY file!");
+
+    ply_add_comment(ply, "Instant Meshes Application State");
+
+    for (auto const &kv : mData) {
+        #define IMPLEMENT(ply_type, type) \
+            case Variant::Type::Matrix_##type: \
+                ply_add_element(ply, kv.first.c_str(), kv.second.matrix_##type->cols()); \
+                if (kv.second.matrix_##type->rows() <= 1) \
+                    ply_add_scalar_property(ply, "value", ply_type); \
+            else \
+                    for (uint32_t i=0; i<kv.second.matrix_##type->rows(); ++i) \
+                        ply_add_scalar_property(ply, ("value_" + std::to_string(i)).c_str(), ply_type); \
+                break; \
+            case Variant::Type::List_##type: { \
+                    ply_add_element(ply, kv.first.c_str(), kv.second.list_##type->size()); \
+                    size_t max_size = 0; \
+                    for (size_t i=0; i<kv.second.list_##type->size(); ++i) \
+                        max_size = std::max(max_size, kv.second.list_##type->operator[](i).size()); \
+                    ply_add_list_property(ply, "value", max_size < 256 ? PLY_UINT8 : (max_size < 65536 ? PLY_UINT16 : PLY_UINT32), ply_type); \
+                } \
+                break;
+
+        switch (kv.second.type_id) {
+            IMPLEMENT(PLY_UINT8, uint8_t)
+            IMPLEMENT(PLY_UINT16, uint16_t)
+            IMPLEMENT(PLY_UINT32, uint32_t)
+            IMPLEMENT(PLY_FLOAT32, float)
+            IMPLEMENT(PLY_FLOAT64, double)
+            default:
+                throw std::runtime_error("Unexpected data type while serializing! (1)");
+                break;
+        }
+
+        #undef IMPLEMENT
+    }
+
+    ply_write_header(ply);
+
+    #define IMPLEMENT(type) \
+        case Variant::Type::Matrix_##type: \
+            for (uint32_t i=0; i<kv.second.matrix_##type->size(); ++i) \
+                ply_write(ply, kv.second.matrix_##type->data()[i]); \
+            written += kv.second.matrix_##type->size() * sizeof(type); \
+            break; \
+        case Variant::Type::List_##type: { \
+                const std::vector<std::vector<type>> &list = *kv.second.list_##type; \
+                for (uint32_t i=0; i<list.size(); ++i) { \
+                    ply_write(ply, list[i].size()); \
+                    for (uint32_t j=0; j<list[i].size(); ++j) \
+                        ply_write(ply, list[i][j]); \
+                    written += list[i].size() * sizeof(type) + sizeof(uint32_t); \
+                } \
+            } \
+            break;
+
+    size_t size = totalSize(), written = 0;
+    for (auto const &kv : mData) {
+        switch (kv.second.type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+            default:
+                throw std::runtime_error("Unexpected data type while serializing! (2)");
+                break;
+        }
+        if (progress)
+            progress("Writing \"" + kv.first  + "\"", written / (Float) size);
+    }
+
+    #undef IMPLEMENT
+
+    ply_close(ply);
+    cout << "done. (took " << timeString(timer.value()) << ")" << endl;
+}
+
+size_t Serializer::totalSize() const {
+    size_t result = 0;
+
+    #define IMPLEMENT(type) \
+        case Variant::Type::Matrix_##type: \
+            result += kv.second.matrix_##type->size() * sizeof(type); \
+            break; \
+        case Variant::Type::List_##type: {\
+                const std::vector<std::vector<type>> &list = *kv.second.list_##type; \
+                for (uint32_t i=0; i<list.size(); ++i) \
+                    result += list[i].size() * sizeof(type) + sizeof(uint32_t); \
+            } \
+            break;
+
+    for (auto const &kv : mData) {
+        switch (kv.second.type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+        }
+    }
+
+    #undef IMPLEMENT
+    return result;
+}
+
+
+bool Serializer::diff(const Serializer &other) const {
+    std::set<std::string> keys;
+    for (auto const &kv : mData)
+        keys.insert(kv.first);
+    for (auto const &kv : other.mData)
+        keys.insert(kv.first);
+
+    bool diff = false;
+
+    for (const std::string &key : keys) {
+        auto it1 = mData.find(key);
+        if (it1 == mData.end()) {
+            cout << "Element " << key << " does not exist in serializer 1." << endl;
+            diff = true;
+            continue;
+        }
+        auto it2 = other.mData.find(key);
+        if (it2 == other.mData.end()) {
+            cout << "Element " << key << " does not exist in serializer 2." << endl;
+            diff = true;
+            continue;
+        }
+        const Variant &v1 = it1->second;
+        const Variant &v2 = it2->second;
+        if (v1.type_id != v2.type_id) {
+            cout << "Element " << key << " have different types." << endl;
+            diff = true;
+            continue;
+        }
+
+        #define IMPLEMENT(type) \
+            case Variant::Type::Matrix_##type: \
+                if (v1.matrix_##type->cols() != v2.matrix_##type->cols() || \
+                    v1.matrix_##type->rows() != v2.matrix_##type->rows()) \
+                    result = true; \
+                else \
+                    result = *(v1.matrix_##type) != *(v2.matrix_##type); \
+                break; \
+            case Variant::Type::List_##type: \
+                result = *(v1.list_##type) != *(v2.list_##type); \
+                break;
+
+        bool result = false;
+        switch (v1.type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+            default:
+                throw std::runtime_error("Unexpected data type while diffing!");
+                break;
+        }
+
+        #undef IMPLEMENT
+
+        if (result) {
+            cout << "Element " << key << " differs." << endl;
+            diff = true;
+        }
+    }
+
+    return diff;
+}
+
+std::ostream &operator<<(std::ostream &os, const Serializer &state) {
+    os << "Serializer[";
+    bool first = true;
+    for (auto const &kv : state.mData) {
+        const Serializer::Variant &v = kv.second;
+        if (!first)
+            cout << ",";
+        first = false;
+        cout << endl;
+        std::string tname, value;
+
+        #define IMPLEMENT(type) \
+            case Serializer::Variant::Type::Matrix_##type: { \
+                    const Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic> &mat = *(v.matrix_##type); \
+                    if (mat.size() == 1) { \
+                        tname = #type; \
+                        value = std::to_string(mat(0, 0)); \
+                    } else if (mat.cols() == 1 && mat.rows() <= 4) { \
+                        tname = "vec<" #type ">"; \
+                        value = "["; \
+                        for (int i=0; i<mat.rows(); ++i) { \
+                            value += std::to_string(mat(i, 0)); \
+                            if (i+1<mat.rows()) \
+                                value += ", "; \
+                        } \
+                        value += "]"; \
+                    } else { \
+                        tname = std::string(mat.cols() == 1 ? "vec<" : "mat<") + #type + std::string(">"); \
+                        value = "data[" + std::to_string(mat.rows()) + "x" + \
+                                          std::to_string(mat.cols()) + "]"; \
+                    } \
+                } \
+                break; \
+            case Serializer::Variant::Type::List_##type: \
+                tname = #type "**"; \
+                value = "data[" + std::to_string(v.list_##type->size()) + "][]"; \
+                break; \
+
+        switch (v.type_id) {
+            IMPLEMENT(uint8_t);
+            IMPLEMENT(uint16_t);
+            IMPLEMENT(uint32_t);
+            IMPLEMENT(float);
+            IMPLEMENT(double);
+            default:
+                throw std::runtime_error("Unexpected type in stream operator");
+        }
+        os << "\t" << tname << " " << kv.first << " = " << value;
+    }
+    os << endl << "]";
+    return os;
+}

intern/instant-meshes/src/serializer.h

@@ -0,0 +1,324 @@
+/*
+    serializer.h: Helper class to serialize the application state to a .PLY file
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+#include <map>
+#include <set>
+#include <stack>
+
+class Serializer {
+public:
+    Serializer();
+    Serializer(const std::string &filename, bool compatibilityMode = false,
+               const ProgressCallback &progress = ProgressCallback());
+    ~Serializer();
+
+    void write(const std::string &filename,
+               const ProgressCallback &progress = ProgressCallback());
+
+    static bool isSerializedFile(const std::string &filename);
+
+    void pushPrefix(const std::string &prefix) const { mPrefixStack.push(mPrefixStack.top() + prefix + "."); }
+    void popPrefix() const { mPrefixStack.pop(); }
+
+    bool diff(const Serializer &serializer) const;
+
+    inline size_t totalSize() const;
+
+    std::vector<std::string> getKeys() const;
+
+    #define MISSING_KEY(key) \
+        if (mCompatibilityMode) {\
+            cerr << "Warning: Serializer: could not find element \"" + mPrefixStack.top() + key + "\"!" << endl; \
+            return false; \
+        } else { \
+            throw std::runtime_error("Serializer: could not find element \"" + mPrefixStack.top() + key + "\"!"); \
+        }
+
+    #define IMPLEMENT(type, btype) \
+        void set(const std::string &key, type value) { \
+            Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic> *mat = new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(1, 1); \
+            (*mat)(0, 0) = (btype) value; \
+            mData.emplace(mPrefixStack.top() + key, mat); \
+        } \
+        void set(const std::string &key, const Eigen::Matrix<type, 2, 1> &v) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(v.cast<btype>())); \
+        } \
+        \
+        void set(const std::string &key, const Eigen::Matrix<type, 3, 1> &v) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(v.cast<btype>())); \
+        } \
+        \
+        void set(const std::string &key, const Eigen::Matrix<type, 4, 1> &v) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(v.cast<btype>())); \
+        } \
+        \
+        void set(const std::string &key, const Eigen::Matrix<type, 1, Eigen::Dynamic> &v) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(v.cast<btype>())); \
+        } \
+        \
+        void set(const std::string &key, const Eigen::Matrix<type, Eigen::Dynamic, 1> &v) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(v.cast<btype>().transpose())); \
+        } \
+        \
+        void set(const std::string &key, const Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic> &m) { \
+            mData.emplace(mPrefixStack.top() + key, \
+                new Eigen::Matrix<btype, Eigen::Dynamic, Eigen::Dynamic>(m.cast<btype>())); \
+        } \
+        \
+        void set(const std::string &key, const std::vector<std::vector<type>> &v) { \
+            mData.emplace(mPrefixStack.top() + key, new std::vector<std::vector<btype>>( \
+                        reinterpret_cast<const std::vector<std::vector<btype>>&>(v))); \
+        } \
+        \
+        bool get(const std::string &key, type &value) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->size() != 1) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            value = (type) (*(it->second.matrix_##btype))(0, 0); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, 2, 1> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->cols() != 1 && it->second.matrix_##btype->rows() != 2) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            v = it->second.matrix_##btype->col(0).cast<type>(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, 3, 1> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->cols() != 1 && it->second.matrix_##btype->rows() != 3) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            v = it->second.matrix_##btype->col(0).cast<type>(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, 4, 1> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->cols() != 1 && it->second.matrix_##btype->rows() != 4) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            v = it->second.matrix_##btype->col(0).cast<type>(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, Eigen::Dynamic, 1> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->rows() != 1) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            v = it->second.matrix_##btype->row(0).cast<type>().transpose(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, 1, Eigen::Dynamic> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            if (it->second.matrix_##btype->rows() != 1) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!"); \
+            v = it->second.matrix_##btype->row(0).cast<type>(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::Matrix_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            v = it->second.matrix_##btype->cast<type>(); \
+            return true; \
+        } \
+        \
+        bool get(const std::string &key, std::vector<std::vector<type>> &v) const { \
+            auto it = mData.find(mPrefixStack.top() + key); \
+            if (it == mData.end()) { MISSING_KEY(key); } \
+            if (it->second.type_id != Variant::Type::List_##btype) \
+                throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!"); \
+            v = reinterpret_cast<const std::vector<std::vector<type>>&>(*(it->second.list_##btype)); \
+            return true; \
+        }
+
+    IMPLEMENT(bool,     uint8_t)
+    IMPLEMENT(uint8_t,  uint8_t)
+    IMPLEMENT(uint16_t, uint16_t)
+    IMPLEMENT(uint32_t, uint32_t)
+    IMPLEMENT(int32_t,  uint32_t)
+    IMPLEMENT(float,    float)
+    IMPLEMENT(double,   double)
+
+    #undef IMPLEMENT
+    #undef MISSING_KEY
+
+    template <typename Scalar, int N> inline void set(const std::string &key, const Eigen::Matrix<Eigen::Matrix<Scalar, N, 1>, 1, Eigen::Dynamic> &m) {
+        Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> temp(N, m.size());
+        for (uint32_t i=0; i<m.size(); ++i)
+            temp.col(i) = m[i];
+        set(key, temp);
+    }
+
+    template <typename Scalar, int N> inline bool get(const std::string &key, Eigen::Matrix<Eigen::Matrix<Scalar, N, 1>, 1, Eigen::Dynamic> &m) const {
+        Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> temp;
+        if (!get(key, temp))
+            return false;
+        if (temp.rows() != N && temp.cols() != 0)
+            throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": size mismatch!");
+        m.resize(temp.cols());
+        for (uint32_t i=0; i<temp.cols(); ++i)
+            m[i] = temp.col(i);
+        return true;
+    }
+
+    template <typename Key, typename Value> inline void set(const std::string &key, const std::map<Key, Value> &map) {
+        Eigen::Matrix<Key, 1, Eigen::Dynamic> keys(map.size());
+        Eigen::Matrix<Value, 1, Eigen::Dynamic> values(map.size());
+        uint32_t ctr = 0;
+        for (auto const &kv : map) {
+            keys[ctr] = kv.first;
+            values[ctr++] = kv.second;
+        }
+        set(key + ".keys", keys);
+        set(key + ".values", values);
+    }
+
+    template <typename Key, typename Value> inline bool get(const std::string &key, std::map<Key, Value> &map) const {
+        Eigen::Matrix<Key, 1, Eigen::Dynamic> keys;
+        Eigen::Matrix<Value, 1, Eigen::Dynamic> values;
+        if (!get(key + ".keys", keys) || !get(key + ".values", values))
+            return false;
+        if (keys.size() != values.size())
+            throw std::runtime_error("Serializer: element \"" + mPrefixStack.top() + key + "\": type mismatch!");
+        map.clear();
+        for (uint32_t i=0; i<values.size(); ++i)
+            map[keys[i]] = values[i];
+        return true;
+    }
+
+    template <typename Key> inline void set(const std::string &key, const std::set<Key> &value) {
+        Eigen::Matrix<Key, 1, Eigen::Dynamic> keys(value.size());
+        uint32_t ctr = 0;
+        for (auto const &k : value)
+            keys[ctr++] = k;
+        set(key + ".keys", keys);
+    }
+
+    template <typename Key> inline bool get(const std::string &key, std::set<Key> &value) const {
+        Eigen::Matrix<Key, 1, Eigen::Dynamic> keys;
+        if (!get(key + ".keys", keys))
+            return false;
+        value.clear();
+        for (uint32_t i=0; i<keys.size(); ++i)
+            value.insert(keys[i]);
+        return true;
+    }
+
+    template <typename Scalar> inline bool get(const std::string &key, Eigen::Quaternion<Scalar> &quat) const {
+        Eigen::Matrix<Scalar, 4, 1> coeffs;
+        if (!get(key, coeffs))
+            return false;
+        quat.coeffs() << coeffs;
+        return true;
+    }
+
+    template <typename Scalar> inline void set(const std::string &key, const Eigen::Quaternion<Scalar> &quat) {
+        set(key, Eigen::Matrix<Scalar, 4, 1>(quat.coeffs()));
+    }
+
+    inline void set(const std::string &key, const std::string &str) {
+        Eigen::Matrix<uint8_t, 1, Eigen::Dynamic> v(str.length());
+        memcpy(v.data(), str.c_str(), str.length());
+        set(key, v);
+    }
+
+    inline bool get(const std::string &key, std::string &str) const {
+        Eigen::Matrix<uint8_t, 1, Eigen::Dynamic> v;
+        if (!get(key, v))
+            return false;
+        v.conservativeResize(v.size() + 1);
+        v[v.size()-1] = '\0';
+        str = (const char *) v.data();
+        return true;
+    }
+
+    friend std::ostream &operator<<(std::ostream &os, const Serializer &state);
+
+protected:
+    struct Variant {
+        #define VARIANT_ENUM(type) \
+            List_##type, Matrix_##type
+
+        #define VARIANT_UNION(type) \
+            const Eigen::Matrix<type, Eigen::Dynamic, Eigen::Dynamic> *matrix_##type; \
+            const std::vector<std::vector<type>> *list_##type
+
+        #define VARIANT_CONSTR(type) \
+            inline Variant(const Eigen::Matrix<type,  Eigen::Dynamic, Eigen::Dynamic> *value) \
+                : type_id(Type::Matrix_##type), matrix_##type(value) { } \
+            inline Variant(const std::vector<std::vector<type>> *value) \
+                : type_id(Type::List_##type), list_##type(value) { }
+
+        enum Type {
+            VARIANT_ENUM(uint8_t),
+            VARIANT_ENUM(uint16_t),
+            VARIANT_ENUM(uint32_t),
+            VARIANT_ENUM(float),
+            VARIANT_ENUM(double)
+        } type_id;
+
+        union {
+            VARIANT_UNION(uint8_t);
+            VARIANT_UNION(uint16_t);
+            VARIANT_UNION(uint32_t);
+            VARIANT_UNION(float);
+            VARIANT_UNION(double);
+        };
+
+        inline Variant() { }
+        VARIANT_CONSTR(uint8_t);
+        VARIANT_CONSTR(uint16_t);
+        VARIANT_CONSTR(uint32_t);
+        VARIANT_CONSTR(float);
+        VARIANT_CONSTR(double);
+
+        #undef VARIANT_CONSTR
+        #undef VARIANT_UNION
+    };
+
+    std::map<std::string, Variant> mData;
+    mutable std::stack<std::string> mPrefixStack;
+    bool mCompatibilityMode;
+};

intern/instant-meshes/src/smoothcurve.cpp

@@ -0,0 +1,224 @@
+/*
+    smoothcurve.cpp: Helper routines to compute smooth curves on meshes to enable
+    intuitive stroke annotations
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "smoothcurve.h"
+#include "dedge.h"
+#include "bvh.h"
+#include <queue>
+#include <map>
+#include <set>
+
+bool smooth_curve(const BVH *bvh, const VectorXu &E2E, std::vector<CurvePoint> &curve, bool watertight) {
+    const MatrixXu &F = *bvh->F();
+    const MatrixXf &V = *bvh->V(), &N = *bvh->N();
+    cout << endl;
+
+    std::vector<CurvePoint> curve_new;
+    std::vector<Float> weight;
+    std::vector<uint32_t> path;
+
+    cout << "Input: " << curve.size() << " vertices" << endl;
+
+    for (int it=0;; ++it) {
+        if (curve.size() < 2)
+            return false;
+
+        for (uint32_t it2=0; it2<curve.size(); ++it2) {
+            curve_new.clear();
+            curve_new.push_back(curve[0]);
+            for (uint32_t i=1; i<curve.size()-1; ++i) {
+                Vector3f p_new = 0.5f * (curve[i-1].p + curve[i+1].p);
+                Vector3f n_new = (curve[i-1].n + curve[i+1].n).normalized();
+                Float maxlength = (curve[i-1].p - curve[i+1].p).norm()*2;
+
+                Ray ray1(p_new,  n_new, 0, maxlength);
+                Ray ray2(p_new, -n_new, 0, maxlength);
+                uint32_t idx1 = 0, idx2 = 0;
+                Float t1 = 0, t2 = 0;
+                Vector2f uv1, uv2;
+                bool hit1 = bvh->rayIntersect(ray1, idx1, t1, &uv1);
+                bool hit2 = bvh->rayIntersect(ray2, idx2, t2, &uv2);
+
+                if (!hit1 && !hit2)
+                    continue;
+
+                CurvePoint pt;
+                if (t1 < t2) {
+                    pt.p = ray1(t1);
+                    pt.f = idx1;
+                    pt.n = ((1 - uv1.sum()) * N.col(F(0, idx1)) + uv1.x() * N.col(F(1, idx1)) + uv1.y() * N.col(F(2, idx1))).normalized();
+                } else {
+                    pt.p = ray2(t2);
+                    pt.f = idx2;
+                    pt.n = ((1 - uv2.sum()) * N.col(F(0, idx2)) + uv2.x() * N.col(F(1, idx2)) + uv2.y() * N.col(F(2, idx2))).normalized();
+                }
+                curve_new.push_back(pt);
+            }
+            curve_new.push_back(curve[curve.size()-1]);
+            curve.swap(curve_new);
+        }
+
+        if (!watertight && it == 1)
+            break;
+
+        curve_new.clear();
+        curve_new.push_back(curve[0]);
+        for (uint32_t i=1; i<curve.size(); ++i) {
+            if (!astar(F, E2E, V, curve[i-1].f, curve[i].f, path))
+                return false;
+
+            auto closest = [](const Vector3f &p0, const Vector3f &p1, const Vector3f &target) -> Vector3f {
+                Vector3f d = (p1-p0).normalized();
+                return p0 + d * std::min(std::max((target-p0).dot(d), 0.0f), (p0-p1).norm());
+            };
+
+            if (path.size() > 2) {
+                uint32_t base = curve_new.size() - 1;
+                for (uint32_t j=1; j<path.size()-1; ++j) {
+                    uint32_t f = path[j];
+                    Vector3f p0 = V.col(F(0, f)), p1 = V.col(F(1, f)), p2 = V.col(F(2, f));
+                    CurvePoint pt2;
+                    pt2.f = f;
+                    pt2.n = (p1-p0).cross(p2-p0).normalized();
+                    pt2.p = (p0+p1+p2) * (1.0f / 3.0f);
+                    curve_new.push_back(pt2);
+                }
+                curve_new.push_back(curve[i]);
+
+                for (uint32_t q=1; q<path.size()-1; ++q) {
+                    for (uint32_t j=1; j<path.size()-1; ++j) {
+                        Float bestDist1 = std::numeric_limits<Float>::infinity();
+                        Float bestDist2 = std::numeric_limits<Float>::infinity();
+                        Vector3f bestPt1 = Vector3f::Zero(), bestPt2 = Vector3f::Zero();
+                        uint32_t f = path[j];
+                        for (uint32_t k=0; k<3; ++k) {
+                            Vector3f closest1 = closest(V.col(F(k, f)), V.col(F((k + 1) % 3, f)), curve_new[base+j-1].p);
+                            Vector3f closest2 = closest(V.col(F(k, f)), V.col(F((k + 1) % 3, f)), curve_new[base+j+1].p);
+                            Float dist1 = (closest1 - curve_new[base+j-1].p).norm();
+                            Float dist2 = (closest2 - curve_new[base+j+1].p).norm();
+                            if (dist1 < bestDist1) { bestDist1 = dist1; bestPt1 = closest1; }
+                            if (dist2 < bestDist2) { bestDist2 = dist2; bestPt2 = closest2; }
+                        }
+                        curve_new[base+j].p = (bestPt1 + bestPt2) * 0.5f;
+                    }
+                }
+            } else {
+                curve_new.push_back(curve[i]);
+            }
+        }
+        curve.swap(curve_new);
+
+        curve_new.clear();
+        curve_new.push_back(curve[0]);
+        weight.clear();
+        weight.push_back(1.0f);
+        for (uint32_t i=0; i<curve.size(); ++i) {
+            auto &cur = curve_new[curve_new.size()-1];
+            auto &cur_weight = weight[weight.size()-1];
+            if (cur.f == curve[i].f) {
+                cur.p += curve[i].p;
+                cur.n += curve[i].n;
+                cur_weight += 1;
+            } else {
+                curve_new.push_back(curve[i]);
+                weight.push_back(1.f);
+            }
+        }
+        for (uint32_t i=0; i<curve_new.size(); ++i) {
+            curve_new[i].p /= weight[i];
+            curve_new[i].n.normalize();
+        }
+        curve_new[0] = curve[0];
+        curve_new[curve_new.size()-1] = curve[curve.size()-1];
+        if (curve_new.size() < 2 || curve_new[0].f == curve_new[curve_new.size()-1].f)
+            return false;
+        curve_new.swap(curve);
+
+        if (it > 2)
+            break;
+    }
+    cout << "Smoothed curve: " << curve.size() << " vertices" << endl;
+
+    return true;
+}
+
+inline bool astar(const MatrixXu &F, const VectorXu &E2E, const MatrixXf &V, uint32_t start, uint32_t end, std::vector<uint32_t> &path) {
+    typedef std::pair<uint32_t, Float> Entry;
+
+    struct comp {
+        bool operator() (const Entry & lhs, const Entry & rhs) const { return lhs.second > rhs.second; }
+    };
+
+    auto eucldist = [&](uint32_t i, uint32_t j) -> Float {
+        Vector3f diff = Vector3f::Zero();
+        for (uint32_t k=0; k<3; ++k)
+            diff += V.col(F(k, i)) - V.col(F(k, j));
+        return diff.norm() * (1.0f / 3.0f);
+    };
+
+    std::map<uint32_t, Float> g_score;
+    std::map<uint32_t, uint32_t> came_from;
+    std::set<uint32_t> closed;
+    std::priority_queue<Entry, std::vector<Entry>, comp> pq;
+
+    path.clear();
+    g_score[start] = 0;
+    pq.push(Entry(start, g_score[start] + eucldist(start, end)));
+
+    uint32_t iter = 0;
+    while (true) {
+        if (pq.empty()) {
+            /* Internal error - graph disconnected? */
+            return false;
+        }
+        iter++;
+        uint32_t current = pq.top().first;
+        Float currentDist = pq.top().second;
+        if (current == end)
+            break;
+        pq.pop();
+        if (currentDist != g_score[current] + eucldist(current, end))
+            continue;
+        closed.insert(current);
+
+        for (uint32_t i=0; i<3; ++i) {
+            uint32_t neighbor = E2E[current*3+i];
+            if (neighbor == INVALID)
+                continue;
+
+            neighbor /= 3;
+            if (closed.find(neighbor) != closed.end())
+                continue;
+
+            Float tentative_g_score = g_score[current] + eucldist(current, neighbor);
+
+            bool is_open = g_score.find(neighbor) != g_score.end();
+            bool closer = is_open && tentative_g_score < g_score[neighbor];
+
+            if (!is_open || closer) {
+                g_score[neighbor] = tentative_g_score;
+                came_from[neighbor] = current;
+                pq.push(Entry(neighbor, g_score[neighbor] + eucldist(neighbor, end)));
+            }
+        }
+    }
+    uint32_t current = end;
+    path.push_back(current);
+    while (came_from.find(path[path.size()-1]) != came_from.end()) {
+        current = came_from[current];
+        path.push_back(current);
+    }
+    std::reverse(path.begin(), path.end());
+    return true;
+}

intern/instant-meshes/src/smoothcurve.h

@@ -0,0 +1,32 @@
+/*
+    smoothcurve.h: Helper routines to compute smooth curves on meshes to enable
+    intuitive stroke annotations
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+
+#pragma once
+
+#include "common.h"
+
+struct CurvePoint {
+    Vector3f p;
+    Vector3f n;
+    uint32_t f;
+};
+
+class BVH;
+
+extern bool smooth_curve(const BVH *bvh, const VectorXu &E2E,
+                         std::vector<CurvePoint> &curve, bool watertight = false);
+
+extern bool astar(const MatrixXu &F, const VectorXu &E2E, const MatrixXf &V,
+                  uint32_t start, uint32_t end, std::vector<uint32_t> &path);

intern/instant-meshes/src/subdivide.cpp

@@ -0,0 +1,181 @@
+/*
+    subdivide.cpp: Subdivides edges in a triangle mesh until all edges
+    are below a specified maximum length
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "subdivide.h"
+#include "dedge.h"
+
+void subdivide(MatrixXu &F, MatrixXf &V, VectorXu &V2E, VectorXu &E2E,
+               VectorXb &boundary, VectorXb &nonmanifold, Float maxLength,
+               bool deterministic,
+               const ProgressCallback &progress) {
+    typedef std::pair<uint32_t, Float> Edge;
+
+    struct EdgeComp {
+        bool operator()(const Edge& u, const Edge& v) const {
+            return u.second < v.second;
+        }
+    };
+
+    tbb::concurrent_priority_queue<Edge, EdgeComp> queue;
+
+    maxLength *= maxLength;
+
+    cout << "Subdividing mesh .. ";
+    cout.flush();
+    Timer<> timer;
+
+    if (progress)
+        progress("Subdividing mesh", 0.0f);
+
+    tbb::blocked_range<uint32_t> range(0u, (uint32_t) E2E.size(), GRAIN_SIZE);
+
+    auto subdiv = [&](const tbb::blocked_range<uint32_t> &range) {
+        for (uint32_t i = range.begin(); i<range.end(); ++i) {
+            uint32_t v0 = F(i%3, i/3), v1 = F((i+1)%3, i/3);
+            if (nonmanifold[v0] || nonmanifold[v1])
+                continue;
+            Float length = (V.col(v0) - V.col(v1)).squaredNorm();
+            if (length > maxLength) {
+                uint32_t other = E2E[i];
+                if (other == INVALID || other > i)
+                    queue.push(Edge(i, length));
+            }
+        }
+        SHOW_PROGRESS_RANGE(range, E2E.size(), "Subdividing mesh (1/2)");
+    };
+
+    if (!deterministic)
+        tbb::parallel_for(range, subdiv);
+    else
+        subdiv(range);
+
+    uint32_t nV = V.cols(), nF = F.cols(), nSplit = 0;
+    /*
+           /   v0  \
+         v1p 1 | 0 v0p
+           \   v1  /
+
+           /   v0  \
+          /  1 | 0  \
+         v1p - vn - v0p
+          \  2 | 3  /
+           \   v1  /
+
+        f0: vn, v0p, v0
+        f1: vn, v0, v1p
+        f2: vn, v1p, v1
+        f3: vn, v1, v0p
+   */
+
+    while (!queue.empty()) {
+        Edge edge;
+        if (!queue.try_pop(edge))
+            return;
+        uint32_t e0 = edge.first, e1 = E2E[e0];
+        bool is_boundary = e1 == INVALID;
+        uint32_t f0 = e0/3, f1 = is_boundary ? INVALID : (e1 / 3);
+        uint32_t v0 = F(e0%3, f0), v0p = F((e0+2)%3, f0), v1 = F((e0+1)%3, f0);
+        if ((V.col(v0) - V.col(v1)).squaredNorm() != edge.second)
+            continue;
+
+        uint32_t v1p = is_boundary ? INVALID : F((e1+2)%3, f1);
+        uint32_t vn = nV++;
+        nSplit++;
+
+        /* Update V */
+        if (nV > V.cols()) {
+            V.conservativeResize(V.rows(), V.cols() * 2);
+            V2E.conservativeResize(V.cols());
+            boundary.conservativeResize(V.cols());
+            nonmanifold.conservativeResize(V.cols());
+        }
+
+        /* Update V */
+        V.col(vn) = (V.col(v0) + V.col(v1)) * 0.5f;
+        nonmanifold[vn] = false;
+        boundary[vn] = is_boundary;
+
+        /* Update F and E2E */
+        uint32_t f2 = is_boundary ? INVALID : (nF++);
+        uint32_t f3 = nF++;
+
+        if (nF > F.cols()) {
+            F.conservativeResize(F.rows(), std::max(nF, (uint32_t) F.cols() * 2));
+            E2E.conservativeResize(F.cols()*3);
+        }
+
+        /* Update F */
+        F.col(f0) << vn, v0p, v0;
+        if (!is_boundary) {
+            F.col(f1) << vn, v0, v1p;
+            F.col(f2) << vn, v1p, v1;
+        }
+        F.col(f3) << vn, v1, v0p;
+
+        /* Update E2E */
+        const uint32_t e0p = E2E[dedge_prev_3(e0)],
+                       e0n = E2E[dedge_next_3(e0)];
+
+        #define sE2E(a, b) E2E[a] = b; if (b != INVALID) E2E[b] = a;
+        sE2E(3*f0+0, 3*f3+2);
+        sE2E(3*f0+1, e0p);
+        sE2E(3*f3+1, e0n);
+        if (is_boundary) {
+            sE2E(3*f0+2, INVALID);
+            sE2E(3*f3+0, INVALID);
+        } else {
+            const uint32_t e1p = E2E[dedge_prev_3(e1)],
+                           e1n = E2E[dedge_next_3(e1)];
+            sE2E(3*f0+2, 3*f1+0);
+            sE2E(3*f1+1, e1n);
+            sE2E(3*f1+2, 3*f2+0);
+            sE2E(3*f2+1, e1p);
+            sE2E(3*f2+2, 3*f3+0);
+        }
+        #undef sE2E
+
+        /* Update V2E */
+        V2E[v0]  = 3*f0 + 2;
+        V2E[vn]  = 3*f0 + 0;
+        V2E[v1]  = 3*f3 + 1;
+        V2E[v0p] = 3*f0 + 1;
+        if (!is_boundary)
+            V2E[v1p] = 3*f1 + 2;
+
+        auto schedule = [&](uint32_t f) {
+            for (int i=0; i<3; ++i) {
+                Float length = (V.col(F(i, f))-V.col(F((i+1)%3, f))).squaredNorm();
+                if (length > maxLength)
+                    queue.push(Edge(f*3+i, length));
+            }
+        };
+
+        schedule(f0);
+        if (!is_boundary) {
+            schedule(f2);
+            schedule(f1);
+        };
+        schedule(f3);
+    }
+    F.conservativeResize(F.rows(), nF);
+    V.conservativeResize(V.rows(), nV);
+    V2E.conservativeResize(nV);
+    boundary.conservativeResize(nV);
+    nonmanifold.conservativeResize(nV);
+    E2E.conservativeResize(nF*3);
+
+    cout << "done. (split " << nSplit << " edges, took "
+         << timeString(timer.value()) << ", new V=" << V.cols()
+         << ", F=" << F.cols() << ", took " << timeString(timer.value()) << ")" << endl;
+}

intern/instant-meshes/src/subdivide.h

@@ -0,0 +1,22 @@
+/*
+    subdivide.h: Subdivides edges in a triangle mesh until all edges
+    are below a specified maximum length
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+extern void subdivide(MatrixXu &F, MatrixXf &V, VectorXu &V2E, VectorXu &E2E,
+                      VectorXb &boundary, VectorXb &nonmanifold,
+                      Float maxLength, bool deterministic = false,
+                      const ProgressCallback &progress = ProgressCallback());

intern/instant-meshes/src/viewer.h

@@ -0,0 +1,239 @@
+/*
+    viewer.h: Contains the graphical user interface of Instant Meshes
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include "glutil.h"
+#include "widgets.h"
+#include "hierarchy.h"
+#include "field.h"
+#include "bvh.h"
+#include "meshstats.h"
+#include <set>
+
+using nanogui::Alignment;
+using nanogui::Arcball;
+using nanogui::BoxLayout;
+using nanogui::Button;
+using nanogui::CheckBox;
+using nanogui::Color;
+using nanogui::ComboBox;
+using nanogui::GLFramebuffer;
+using nanogui::GroupLayout;
+using nanogui::ImagePanel;
+using nanogui::Label;
+using nanogui::MessageDialog;
+using nanogui::Orientation;
+using nanogui::Popup;
+using nanogui::PopupButton;
+using nanogui::ProgressBar;
+using nanogui::Screen;
+using nanogui::Slider;
+using nanogui::TextBox;
+using nanogui::ToolButton;
+using nanogui::VScrollPanel;
+using nanogui::Widget;
+using nanogui::Window;
+using nanogui::frustum;
+using nanogui::lookAt;
+using nanogui::project;
+using nanogui::scale;
+using nanogui::translate;
+using nanogui::unproject;
+using nanogui::utf8;
+
+struct CurvePoint;
+
+class Viewer : public Screen {
+public:
+    Viewer(bool fullscreen, bool deterministic);
+    virtual ~Viewer();
+
+    bool mouseMotionEvent(const Vector2i &p, const Vector2i &rel,
+                                  int button, int modifiers);
+
+    bool mouseButtonEvent(const Vector2i &p, int button, bool down,
+                                  int modifiers);
+
+    bool keyboardEvent(int key, int scancode, int action, int modifiers);
+
+    bool scrollEvent(const Vector2i &p, const Vector2f &rel);
+
+    void loadInput(std::string filename,
+                   Float creaseAngle = std::numeric_limits<Float>::infinity(),
+                   Float scale = -1, int face_count = -1, int vertex_count = -1,
+                   int rosy = 4, int posy = 4, int knn_points = 10);
+
+    void setSymmetry(int rosy, int posy);
+    void setExtrinsic(bool extrinsic);
+
+    void resetState();
+    void loadState(std::string filename, bool compat = false);
+    void saveState(std::string filename);
+    void renderMitsuba();
+    void setFloorPosition();
+    void draw(NVGcontext *ctx);
+
+protected:
+    void extractMesh();
+    void extractConsensusGraph();
+
+    void drawContents();
+    void drawOverlay();
+
+    bool resizeEvent(const Vector2i &size);
+
+    void refreshColors();
+
+    void traceFlowLines();
+
+    void refreshStrokes();
+
+    void showProgress(const std::string &caption, Float value);
+
+    void computeCameraMatrices(Eigen::Matrix4f &model,
+                               Eigen::Matrix4f &view,
+                               Eigen::Matrix4f &proj);
+
+    void setLevel(int level);
+    void setTargetScale(Float scale);
+    void setTargetVertexCount(uint32_t v);
+    void setTargetVertexCountPrompt(uint32_t v);
+
+    bool createSmoothPath(const std::vector<Vector2i> &curve);
+
+    void repaint();
+
+    void setCreaseAnglePrompt(bool enabled, Float creaseAngle);
+    void shareGLBuffers();
+    bool refreshPositionSingularities();
+    bool refreshOrientationSingularities();
+    std::pair<Vector3f, Vector3f> singularityPositionAndNormal(uint32_t v) const;
+    bool toolActive() const;
+
+protected:
+    struct CameraParameters {
+        Arcball arcball;
+        float zoom = 1.0f, viewAngle = 45.0f;
+        float dnear = 0.05f, dfar = 100.0f;
+        Eigen::Vector3f eye = Eigen::Vector3f(0.0f, 0.0f, 5.0f);
+        Eigen::Vector3f center = Eigen::Vector3f(0.0f, 0.0f, 0.0f);
+        Eigen::Vector3f up = Eigen::Vector3f(0.0f, 1.0f, 5.0f);
+        Eigen::Vector3f modelTranslation = Eigen::Vector3f::Zero();
+        Eigen::Vector3f modelTranslation_start = Eigen::Vector3f::Zero();
+        float modelZoom = 1.0f;
+    };
+
+    std::vector<std::pair<int, std::string>> mExampleImages;
+    std::string mFilename;
+    bool mDeterministic;
+    bool mUseHalfFloats;
+
+    /* Data being processed */
+    std::map<uint32_t, uint32_t> mCreaseMap;
+    std::set<uint32_t> mCreaseSet;
+    VectorXb mNonmanifoldVertices;
+    VectorXb mBoundaryVertices;
+    MultiResolutionHierarchy mRes;
+    Optimizer mOptimizer;
+    BVH *mBVH;
+    MeshStats mMeshStats;
+    int mSelectedLevel;
+    Float mCreaseAngle;
+    Matrix4f mFloor;
+    VectorXu mE2E;
+
+    /* Painting tools */
+    std::vector<Vector2i> mScreenCurve;
+    std::vector<std::pair<uint32_t, std::vector<CurvePoint>>> mStrokes;
+
+    /* Extraction result */
+    MatrixXu mF_extracted;
+    MatrixXf mV_extracted;
+    MatrixXf mN_extracted, mNf_extracted;
+
+    /* Camera / navigation / misc */
+    CameraParameters mCamera;
+    CameraParameters mCameraSnapshots[12];
+    Vector2i mTranslateStart;
+    bool mTranslate, mDrag;
+    std::map<uint32_t, uint32_t> mOrientationSingularities;
+    std::map<uint32_t, Vector2i> mPositionSingularities;
+    bool mContinueWithPositions;
+
+    /* Colors */
+    Vector3f mSpecularColor, mBaseColor;
+    Vector3f mInteriorFactor, mEdgeFactor0;
+    Vector3f mEdgeFactor1, mEdgeFactor2;
+
+    /* OpenGL objects */
+    GLFramebuffer mFBO;
+    SerializableGLShader mPointShader63, mPointShader24, mPointShader44;
+    SerializableGLShader mMeshShader63, mMeshShader24, mMeshShader44;
+    SerializableGLShader mOrientationFieldShader;
+    SerializableGLShader mPositionFieldShader;
+    SerializableGLShader mPositionSingularityShader;
+    SerializableGLShader mOrientationSingularityShader;
+    SerializableGLShader mFlowLineShader, mStrokeShader;
+    SerializableGLShader mOutputMeshShader;
+    SerializableGLShader mOutputMeshWireframeShader;
+    bool mNeedsRepaint;
+    uint32_t mDrawIndex;
+
+    /* GUI-related */
+    enum Layers {
+        InputMesh,
+        InputMeshWireframe,
+        FaceLabels,
+        VertexLabels,
+        FlowLines,
+        OrientationField,
+        OrientationFieldSingularities,
+        PositionField,
+        PositionFieldSingularities,
+        BrushStrokes,
+        OutputMesh,
+        OutputMeshWireframe,
+        LayerCount
+    };
+
+    CheckBox *mLayers[LayerCount];
+    ComboBox *mVisualizeBox, *mSymmetryBox;
+    CheckBox *mExtrinsicBox, *mAlignToBoundariesBox;
+    CheckBox *mCreaseBox, *mPureQuadBox;
+    ProgressButton *mSolveOrientationBtn, *mSolvePositionBtn;
+    Button *mHierarchyMinusButton, *mHierarchyPlusButton;
+    Button *mSaveBtn, *mSwitchBtn;
+    PopupButton *mExportBtn;
+    ToolButton *mOrientationComb, *mOrientationAttractor, *mOrientationScareBrush;
+    ToolButton *mEdgeBrush, *mPositionAttractor, *mPositionScareBrush;
+    TextBox *mHierarchyLevelBox, *mScaleBox, *mCreaseAngleBox;
+    TextBox *mOrientationSingularityBox, *mPositionSingularityBox, *mSmoothBox;
+    Slider *mScaleSlider, *mCreaseAngleSlider, *mSmoothSlider;
+    Slider *mOrientationFieldSizeSlider, *mOrientationFieldSingSizeSlider;
+    Slider *mPositionFieldSingSizeSlider, *mFlowLineSlider;
+#ifdef VISUALIZE_ERROR
+    Graph *mGraph;
+#endif
+
+    /* Progress display */
+    std::function<void(const std::string &, Float)> mProgress;
+    Window *mProgressWindow;
+    ProgressBar *mProgressBar;
+    Label *mProgressLabel;
+    tbb::spin_mutex mProgressMutex;
+    double mLastProgressMessage;
+    double mOperationStart;
+    uint32_t mOutputMeshFaces, mOutputMeshLines;
+    uint32_t mFlowLineFaces, mStrokeFaces;
+};

intern/instant-meshes/src/widgets.cpp

@@ -0,0 +1,145 @@
+/*
+    widgets.cpp: Additional widgets that are not part of NanoGUI
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#include "widgets.h"
+#include "common.h"
+#include <nanogui/opengl.h>
+
+using nanogui::Button;
+using nanogui::utf8;
+using nanogui::nvgIsFontIcon;
+using nanogui::Color;
+    
+ProgressButton::ProgressButton(Widget *parent, const std::string &caption, int icon)
+ : Button(parent, caption, icon), mProgress(0.f) { }
+
+void ProgressButton::draw(NVGcontext *ctx) {
+    Widget::draw(ctx);
+
+    NVGcolor gradTop = mTheme->mButtonGradientTopUnfocused;
+    NVGcolor gradBot = mTheme->mButtonGradientBotUnfocused;
+
+    if (mPushed && mProgress == 1) {
+        gradTop = mTheme->mButtonGradientTopPushed;
+        gradBot = mTheme->mButtonGradientBotPushed;
+    } else if (mMouseFocus && mEnabled) {
+        gradTop = mTheme->mButtonGradientTopFocused;
+        gradBot = mTheme->mButtonGradientBotFocused;
+    }
+
+    if (mProgress != 1) {
+        nvgSave(ctx);
+        nvgScissor(ctx, mPos.x(), mPos.y(), (int) (mSize.x() * mProgress), mSize.y());
+    }
+
+    nvgBeginPath(ctx);
+    nvgRoundedRect(ctx, mPos.x() + 1, mPos.y() + 1.0f, mSize.x() - 2,
+                   mSize.y() - 2, mTheme->mButtonCornerRadius - 1);
+
+    if (mBackgroundColor.w() != 0) {
+        nvgFillColor(ctx, Color(mBackgroundColor.head<3>(), 1.f));
+        nvgFill(ctx);
+        if (mPushed && mProgress == 1) {
+            gradTop.a = gradBot.a = 0.8f;
+        } else {
+            double v = 1 - mBackgroundColor.w();
+            gradTop.a = gradBot.a = mEnabled ? v : v * .5f + .5f;
+        }
+    }
+
+    NVGpaint bg = nvgLinearGradient(ctx, mPos.x(), mPos.y(), mPos.x(),
+                                    mPos.y() + mSize.y(), gradTop, gradBot);
+
+    nvgFillPaint(ctx, bg);
+    nvgFill(ctx);
+
+    if (mProgress != 1) {
+        nvgRestore(ctx);
+    }
+
+    nvgBeginPath(ctx);
+    nvgRoundedRect(ctx, mPos.x() + 0.5f, mPos.y() + (mPushed ? 0.5f : 1.5f), mSize.x() - 1,
+                   mSize.y() - 1 - (mPushed ? 0.0f : 1.0f), mTheme->mButtonCornerRadius);
+    nvgStrokeColor(ctx, mTheme->mBorderLight);
+    nvgStroke(ctx);
+
+    nvgBeginPath(ctx);
+    nvgRoundedRect(ctx, mPos.x() + 0.5f, mPos.y() + 0.5f, mSize.x() - 1,
+                   mSize.y() - 2, mTheme->mButtonCornerRadius);
+    nvgStrokeColor(ctx, mTheme->mBorderDark);
+    nvgStroke(ctx);
+
+    nvgFontSize(ctx, mFontSize == -1 ? mTheme->mButtonFontSize : mFontSize);
+    nvgFontFace(ctx, "sans-bold");
+    float tw = nvgTextBounds(ctx, 0,0, mCaption.c_str(), nullptr, nullptr);
+
+    Vector2f center = mPos.cast<float>() + mSize.cast<float>() * 0.5f;
+    Vector2f textPos(center.x() - tw * 0.5f, center.y() - 1);
+    NVGcolor textColor =
+        mTextColor.w() == 0 ? mTheme->mTextColor : mTextColor;
+    if (!mEnabled)
+        textColor = mTheme->mDisabledTextColor;
+
+    if (mIcon) {
+        auto icon = utf8(mIcon);
+
+        float iw, ih = mFontSize == -1 ? mTheme->mButtonFontSize : mFontSize;
+        if (nvgIsFontIcon(mIcon)) {
+            ih *= 1.5f;
+            nvgFontSize(ctx, ih);
+            nvgFontFace(ctx, "icons");
+            iw = nvgTextBounds(ctx, 0, 0, icon.data(), nullptr, nullptr);
+        } else {
+            int w, h;
+            ih *= 0.9f;
+            nvgImageSize(ctx, mIcon, &w, &h);
+            iw = w * ih / h;
+        }
+        if (mCaption != "")
+            iw += mSize.y() * 0.15f;
+        nvgFillColor(ctx, textColor);
+        nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+        Vector2f iconPos = center;
+        iconPos.y() -= 1;
+
+        if (mIconPosition == IconPosition::LeftCentered) {
+            iconPos.x() -= (tw + iw) * 0.5f;
+            textPos.x() += iw * 0.5f;
+        } else if (mIconPosition == IconPosition::RightCentered) {
+            textPos.x() -= iw * 0.5f;
+            iconPos.x() += tw * 0.5f;
+        } else if (mIconPosition == IconPosition::Left) {
+            iconPos.x() = mPos.x() + 8;
+        } else if (mIconPosition == IconPosition::Right) {
+            iconPos.x() = mPos.x() + mSize.x() - iw - 8;
+        }
+
+        if (nvgIsFontIcon(mIcon)) {
+            nvgText(ctx, iconPos.x(), iconPos.y()+1, icon.data(), nullptr);
+        } else {
+            NVGpaint imgPaint = nvgImagePattern(ctx,
+                    iconPos.x(), iconPos.y() - ih/2, iw, ih, 0, mIcon, mEnabled ? 0.5f : 0.25f);
+
+            nvgFillPaint(ctx, imgPaint);
+            nvgFill(ctx);
+        }
+    }
+
+    nvgFontSize(ctx, mFontSize == -1 ? mTheme->mButtonFontSize : mFontSize);
+    nvgFontFace(ctx, "sans-bold");
+    nvgTextAlign(ctx, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
+    nvgFillColor(ctx, mTheme->mTextColorShadow);
+    nvgText(ctx, textPos.x(), textPos.y(), mCaption.c_str(), nullptr);
+    nvgFillColor(ctx, textColor);
+    nvgText(ctx, textPos.x(), textPos.y() + 1, mCaption.c_str(), nullptr);
+}

intern/instant-meshes/src/widgets.h

@@ -0,0 +1,28 @@
+/*
+    widgets.h: Additional widgets that are not part of NanoGUI
+
+    This file is part of the implementation of
+
+        Instant Field-Aligned Meshes
+        Wenzel Jakob, Daniele Panozzo, Marco Tarini, and Olga Sorkine-Hornung
+        In ACM Transactions on Graphics (Proc. SIGGRAPH Asia 2015)
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE.txt file.
+*/
+
+#pragma once
+
+#include <nanogui/nanogui.h>
+
+class ProgressButton : public nanogui::Button {
+public:
+    ProgressButton(Widget *parent, const std::string &caption = "Untitled", int icon = 0);
+
+    float progress() const { return mProgress; }
+    void setProgress(float value) { mProgress = value; }
+
+    void draw(NVGcontext *ctx);
+private:
+    float mProgress;
+};

intern/quadriflow/quadriflow_capi.cpp

@@ -65,6 +65,12 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
   /* Get remeshing parameters. */
   int faces = qrd->target_faces;
 
+  field.flag_adaptive_scale = 1;
+  field.flag_minimum_cost_flow = 1;
+  field.flag_preserve_boundary = 1;
+  field.flag_preserve_sharp = 1;
+  // field.flag_aggresive_sat = 1;
+
   if (qrd->preserve_sharp) {
     field.flag_preserve_sharp = 1;
   }
@@ -91,6 +97,7 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
   /* Copy mesh to quadriflow data structures. */
   std::vector<Vector3d> positions;
   std::vector<uint32_t> indices;
+  std::vector<uint32_t> eflags;
   std::vector<ObjVertex> vertices;
 
   for (int i = 0; i < qrd->totverts; i++) {
@@ -99,16 +106,18 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
   }
 
   for (int q = 0; q < qrd->totfaces; q++) {
-    Vector3i f(qrd->faces[q * 3], qrd->faces[q * 3 + 1], qrd->faces[q * 3 + 2]);
+    Vector3i f(qrd->faces[q].v[0], qrd->faces[q].v[1], qrd->faces[q].v[2]);
 
     ObjVertex tri[6];
-    int nVertices = 3;
+    const int nVertices = 3;
 
     tri[0] = ObjVertex(f[0]);
     tri[1] = ObjVertex(f[1]);
     tri[2] = ObjVertex(f[2]);
 
     for (int i = 0; i < nVertices; ++i) {
+      eflags.push_back(qrd->faces[q].eflag[i]);
+
       const ObjVertex &v = tri[i];
       VertexMap::const_iterator it = vertexMap.find(v);
       if (it == vertexMap.end()) {
@@ -123,7 +132,10 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
   }
 
   field.F.resize(3, indices.size() / 3);
+  // field.FF.resize(3, indices.size() / 3);
+
   memcpy(field.F.data(), indices.data(), sizeof(uint32_t) * indices.size());
+  // memcpy(field.FF.data(), eflags.data(), sizeof(uint32_t) * eflags.size());
 
   field.V.resize(3, vertices.size());
   for (uint32_t i = 0; i < vertices.size(); ++i) {
@@ -142,12 +154,17 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
     return;
   }
 
+  const int steps = 2;
+
   /* Setup mesh boundary constraints if needed */
-  if (field.flag_preserve_boundary) {
+#if 1
+  if (true) {  // field.flag_preserve_boundary) {
     Hierarchy &mRes = field.hierarchy;
     mRes.clearConstraints();
+
     for (uint32_t i = 0; i < 3 * mRes.mF.cols(); ++i) {
-      if (mRes.mE2E[i] == -1) {
+      if (qrd->faces[i / 3].eflag[i % 3] & QFLOW_CONSTRAINED) {
+        // if (mRes.mE2E[i] == -1) {
         uint32_t i0 = mRes.mF(i % 3, i / 3);
         uint32_t i1 = mRes.mF((i + 1) % 3, i / 3);
         Vector3d p0 = mRes.mV[0].col(i0), p1 = mRes.mV[0].col(i1);
@@ -157,15 +174,21 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
           mRes.mCO[0].col(i0) = p0;
           mRes.mCO[0].col(i1) = p1;
           mRes.mCQ[0].col(i0) = mRes.mCQ[0].col(i1) = edge;
-          mRes.mCQw[0][i0] = mRes.mCQw[0][i1] = mRes.mCOw[0][i0] = mRes.mCOw[0][i1] = 1.0;
+          mRes.mCQw[0][i0] = mRes.mCQw[0][i1] = mRes.mCOw[0][i0] = mRes.mCOw[0][i1] = 0.1;
         }
       }
     }
-    mRes.propagateConstraints();
+
+    for (int j = 0; j < 2; j++) {
+      mRes.propagateConstraints();
+    }
   }
+#endif
 
   /* Optimize the mesh field orientations (tangental field etc) */
-  Optimizer::optimize_orientations(field.hierarchy);
+  for (int i = 0; i < steps; i++) {
+    Optimizer::optimize_orientations(field.hierarchy);
+  }
   field.ComputeOrientationSingularities();
 
   if (check_if_canceled(0.3f, update_cb, update_cb_data)) {
@@ -180,11 +203,13 @@ void QFLOW_quadriflow_remesh(QuadriflowRemeshData *qrd,
     return;
   }
 
-  Optimizer::optimize_scale(field.hierarchy, field.rho, field.flag_adaptive_scale);
-  field.flag_adaptive_scale = 1;
-
-  Optimizer::optimize_positions(field.hierarchy, field.flag_adaptive_scale);
+  for (int i = 0; i < steps; i++) {
+    Optimizer::optimize_scale(field.hierarchy, field.rho, field.flag_adaptive_scale);
+  }
 
+  for (int i = 0; i < steps; i++) {
+    Optimizer::optimize_positions(field.hierarchy, field.flag_adaptive_scale);
+  }
   field.ComputePositionSingularities();
 
   if (check_if_canceled(0.5f, update_cb, update_cb_data)) {

intern/quadriflow/quadriflow_capi.hpp

@@ -8,9 +8,16 @@
 extern "C" {
 #endif
 
+enum { QFLOW_CONSTRAINED = 1 };
+
+typedef struct QuadriflowFace {
+  int v[3];
+  char eflag[3];
+} QuadriflowFace;
+
 typedef struct QuadriflowRemeshData {
   float *verts;
-  int *faces;
+  QuadriflowFace *faces;
   int totfaces;
   int totverts;
 

release/datafiles/blender_icons_geom.py

@@ -118,7 +118,14 @@ def object_child_map(objects):
         ob_all.sort(key=lambda ob: ob.name)
     return objects_children
 
-
+import sys
+def get_active_vcol(me):
+  vcol = me.vertex_colors.active
+  if not vcol and len(me.vertex_colors) > 0:
+    vcol = me.vertex_colors[0]
+  
+  return vcol
+  
 def mesh_data_lists_from_mesh(me, material_colors):
     me_loops = me.loops[:]
     me_verts = me.vertices[:]
@@ -130,7 +137,10 @@ def mesh_data_lists_from_mesh(me, material_colors):
         me_loops_color = None
 
     tris_data = []
-
+    
+    class white:
+        color = [1, 1, 1, 1]
+    
     for p in me_polys:
         # Note, all faces are handled, backfacing/zero area is checked just before writing.
         material_index = p.material_index