support default weight

Use a for loop that always begins with the active object,
instead of moving the active object in the array,
which failed when it's data already being handled.

While the existing logic could have been fixed,
it's simpler to change the loop order.

.clang-format

@@ -161,6 +161,7 @@ PenaltyBreakString: 1000000
 # "^\s+[A-Z][A-Z0-9_]+\s*\([^\n]*\)\n\s*\{"
 ForEachMacros:
   - BEGIN_ANIMFILTER_SUBCHANNELS
+  - BKE_pbvh_vertex_iter_begin
   - BLI_FOREACH_SPARSE_RANGE
   - BLI_SMALLSTACK_ITER_BEGIN
   - BMO_ITER

GNUmakefile

@@ -506,7 +506,7 @@ check_descriptions: .FORCE
 #
 
 source_archive: .FORCE
-	./build_files/utils/make_source_archive.sh
+	python3 ./build_files/utils/make_source_archive.py
 
 INKSCAPE_BIN?="inkscape"
 icons: .FORCE

build_files/cmake/platform/platform_apple_xcode.cmake

@@ -66,7 +66,7 @@ endif()
 if(XCODE_VERSION)
   # Construct SDKs path ourselves, because xcode-select path could be ambiguous.
   # Both /Applications/Xcode.app/Contents/Developer or /Applications/Xcode.app would be allowed.
-  set(XCODE_SDK_DIR ${XCODE_DEVELOPER_DIR}/Platforms/MacOSX.platform//Developer/SDKs)
+  set(XCODE_SDK_DIR ${XCODE_DEVELOPER_DIR}/Platforms/MacOSX.platform/Developer/SDKs)
 
   # Detect SDK version to use
   if(NOT DEFINED OSX_SYSTEM)

build_files/utils/make_source_archive.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+
+import dataclasses
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Iterable, TextIO
+
+# This script can run from any location,
+# output is created in the $CWD
+#
+# NOTE: while the Python part of this script is portable,
+# it relies on external commands typically found on GNU/Linux.
+# Support for other platforms could be added by moving GNU `tar` & `md5sum` use to Python.
+
+SKIP_NAMES = {
+    ".gitignore",
+    ".gitmodules",
+    ".arcconfig",
+}
+
+
+def main() -> None:
+    output_dir = Path(".").absolute()
+    blender_srcdir = Path(__file__).absolute().parent.parent.parent
+    print(f"Source dir: {blender_srcdir}")
+
+    version = parse_blender_version(blender_srcdir)
+    manifest = output_dir / f"blender-{version}-manifest.txt"
+    tarball = output_dir / f"blender-{version}.tar.xz"
+
+    os.chdir(blender_srcdir)
+    create_manifest(version, manifest)
+    create_tarball(version, tarball, manifest)
+    create_checksum_file(tarball)
+    cleanup(manifest)
+    print("Done!")
+
+
+@dataclasses.dataclass
+class BlenderVersion:
+    version: int  # 293 for 2.93.1
+    patch: int  # 1 for 2.93.1
+    cycle: str  # 'alpha', 'beta', 'release', maybe others.
+
+    @property
+    def is_release(self) -> bool:
+        return self.cycle == "release"
+
+    def __str__(self) -> str:
+        """Convert to version string.
+
+        >>> str(BlenderVersion(293, 1, "alpha"))
+        '2.93.1-alpha'
+        >>> str(BlenderVersion(327, 0, "release"))
+        '3.27.0'
+        """
+        version_major = self.version // 100
+        version_minor = self.version % 100
+        as_string = f"{version_major}.{version_minor}.{self.patch}"
+        if self.is_release:
+            return as_string
+        return f"{as_string}-{self.cycle}"
+
+
+def parse_blender_version(blender_srcdir: Path) -> BlenderVersion:
+    version_path = blender_srcdir / "source/blender/blenkernel/BKE_blender_version.h"
+
+    version_info = {}
+    line_re = re.compile(r"^#define (BLENDER_VERSION[A-Z_]*)\s+([0-9a-z]+)$")
+
+    with version_path.open(encoding="utf-8") as version_file:
+        for line in version_file:
+            match = line_re.match(line.strip())
+            if not match:
+                continue
+            version_info[match.group(1)] = match.group(2)
+
+    return BlenderVersion(
+        int(version_info["BLENDER_VERSION"]),
+        int(version_info["BLENDER_VERSION_PATCH"]),
+        version_info["BLENDER_VERSION_CYCLE"],
+    )
+
+
+### Manifest creation
+
+
+def create_manifest(version: BlenderVersion, outpath: Path) -> None:
+    print(f'Building manifest of files:  "{outpath}"...', end="", flush=True)
+    with outpath.open("w", encoding="utf-8") as outfile:
+        main_files_to_manifest(outfile)
+        submodules_to_manifest(version, outfile)
+    print("OK")
+
+
+def main_files_to_manifest(outfile: TextIO) -> None:
+    for path in git_ls_files():
+        print(path, file=outfile)
+
+
+def submodules_to_manifest(version: BlenderVersion, outfile: TextIO) -> None:
+    skip_addon_contrib = version.is_release
+
+    for line in git_command("submodule"):
+        submodule = line.split()[1]
+
+        # Don't use native slashes as GIT for MS-Windows outputs forward slashes.
+        if skip_addon_contrib and submodule == "release/scripts/addons_contrib":
+            continue
+
+        for path in git_ls_files(Path(submodule)):
+            print(path, file=outfile)
+
+
+def create_tarball(version: BlenderVersion, tarball: Path, manifest: Path) -> None:
+    print(f'Creating archive:            "{tarball}" ...', end="", flush=True)
+    # Requires GNU `tar`, since `--transform` is used.
+    command = [
+        "tar",
+        "--transform",
+        f"s,^,blender-{version}/,g",
+        "--use-compress-program=xz -9",
+        "--create",
+        f"--file={tarball}",
+        f"--files-from={manifest}",
+        # Without owner/group args, extracting the files as root will
+        # use ownership from the tar archive:
+        "--owner=0",
+        "--group=0",
+    ]
+    subprocess.run(command, check=True, timeout=300)
+    print("OK")
+
+
+def create_checksum_file(tarball: Path) -> None:
+    md5_path = tarball.with_name(tarball.name + ".md5sum")
+    print(f'Creating checksum:           "{md5_path}" ...', end="", flush=True)
+    command = [
+        "md5sum",
+        # The name is enough, as the tarball resides in the same dir as the MD5
+        # file, and that's the current working directory.
+        tarball.name,
+    ]
+    md5_cmd = subprocess.run(
+        command, stdout=subprocess.PIPE, check=True, text=True, timeout=300
+    )
+    with md5_path.open("w", encoding="utf-8") as outfile:
+        outfile.write(md5_cmd.stdout)
+    print("OK")
+
+
+def cleanup(manifest: Path) -> None:
+    print("Cleaning up ...", end="", flush=True)
+    if manifest.exists():
+        manifest.unlink()
+    print("OK")
+
+
+## Low-level commands
+
+
+def git_ls_files(directory: Path = Path(".")) -> Iterable[Path]:
+    """Generator, yields lines of output from 'git ls-files'.
+
+    Only lines that are actually files (so no directories, sockets, etc.) are
+    returned, and never one from SKIP_NAMES.
+    """
+    for line in git_command("-C", str(directory), "ls-files"):
+        path = directory / line
+        if not path.is_file() or path.name in SKIP_NAMES:
+            continue
+        yield path
+
+
+def git_command(*cli_args) -> Iterable[str]:
+    """Generator, yields lines of output from a Git command."""
+    command = ("git", *cli_args)
+
+    # import shlex
+    # print(">", " ".join(shlex.quote(arg) for arg in command))
+
+    git = subprocess.run(
+        command, stdout=subprocess.PIPE, check=True, text=True, timeout=30
+    )
+    for line in git.stdout.split("\n"):
+        if line:
+            yield line
+
+
+if __name__ == "__main__":
+    import doctest
+
+    if doctest.testmod().failed:
+        raise SystemExit("ERROR: Self-test failed, refusing to run")
+
+    main()

build_files/utils/make_source_archive.sh

@@ -1,82 +0,0 @@
-#!/bin/sh
-
-# This script can run from any location,
-# output is created in the $CWD
-
-BASE_DIR="$PWD"
-
-blender_srcdir=$(dirname -- $0)/../..
-blender_version=$(grep "BLENDER_VERSION\s" "$blender_srcdir/source/blender/blenkernel/BKE_blender_version.h" | awk '{print $3}')
-blender_version_patch=$(grep "BLENDER_VERSION_PATCH\s" "$blender_srcdir/source/blender/blenkernel/BKE_blender_version.h" | awk '{print $3}')
-blender_version_cycle=$(grep "BLENDER_VERSION_CYCLE\s" "$blender_srcdir/source/blender/blenkernel/BKE_blender_version.h" | awk '{print $3}')
-
-VERSION=$(expr $blender_version / 100).$(expr $blender_version % 100).$blender_version_patch
-if [ "$blender_version_cycle" = "release" ] ; then
-  SUBMODULE_EXCLUDE="^\(release/scripts/addons_contrib\)$"
-else
-  VERSION=$VERSION-$blender_version_cycle
-  SUBMODULE_EXCLUDE="^$"  # dummy regex
-fi
-
-MANIFEST="blender-$VERSION-manifest.txt"
-TARBALL="blender-$VERSION.tar.xz"
-
-cd "$blender_srcdir"
-
-# not so nice, but works
-FILTER_FILES_PY=\
-"import os, sys; "\
-"[print(l[:-1]) for l in sys.stdin.readlines() "\
-"if os.path.isfile(l[:-1]) "\
-"if os.path.basename(l[:-1]) not in {"\
-"'.gitignore', "\
-"'.gitmodules', "\
-"'.arcconfig', "\
-"}"\
-"]"
-
-# Build master list
-echo -n "Building manifest of files:  \"$BASE_DIR/$MANIFEST\" ..."
-git ls-files | python3 -c "$FILTER_FILES_PY" > $BASE_DIR/$MANIFEST
-
-# Enumerate submodules
-for lcv in $(git submodule | awk '{print $2}' | grep -v "$SUBMODULE_EXCLUDE"); do
-  cd "$BASE_DIR"
-  cd "$blender_srcdir/$lcv"
-  git ls-files | python3 -c "$FILTER_FILES_PY" | awk '$0="'"$lcv"/'"$0' >> $BASE_DIR/$MANIFEST
-  cd "$BASE_DIR"
-done
-echo "OK"
-
-
-# Create the tarball
-#
-# Without owner/group args, extracting the files as root will
-# use ownership from the tar archive.
-cd "$blender_srcdir"
-echo -n "Creating archive:            \"$BASE_DIR/$TARBALL\" ..."
-tar \
-  --transform "s,^,blender-$VERSION/,g" \
-  --use-compress-program="xz -9" \
-  --create \
-  --file="$BASE_DIR/$TARBALL" \
-  --files-from="$BASE_DIR/$MANIFEST" \
-  --owner=0 \
-  --group=0
-
-echo "OK"
-
-
-# Create checksum file
-cd "$BASE_DIR"
-echo -n "Creating checksum:           \"$BASE_DIR/$TARBALL.md5sum\" ..."
-md5sum "$TARBALL" > "$TARBALL.md5sum"
-echo "OK"
-
-
-# Cleanup
-echo -n "Cleaning up ..."
-rm "$BASE_DIR/$MANIFEST"
-echo "OK"
-
-echo "Done!"

extern/mantaflow/CMakeLists.txt

@@ -32,9 +32,7 @@ if(MSVC_CLANG AND WITH_OPENMP AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "9.0.1
 endif()
 
 # Exporting functions from the blender binary gives linker warnings on Apple arm64 systems.
-# For now and until Apple arm64 is officially supported, these will just be silenced here.
-# TODO (sebbas): Check if official arm64 devices give linker warnings without this block.
-
+# Silence them here.
 if(APPLE AND ("${CMAKE_OSX_ARCHITECTURES}" STREQUAL "arm64"))
   if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
     string(APPEND CMAKE_C_FLAGS " -fvisibility=hidden")

intern/clog/clog.c

@@ -303,19 +303,27 @@ static enum eCLogColor clg_severity_to_color(enum CLG_Severity severity)
  * - `foo` exact match of `foo`.
  * - `foo.bar` exact match for `foo.bar`
  * - `foo.*` match for `foo` & `foo.bar` & `foo.bar.baz`
+ * - `*bar*` match for `foo.bar` & `baz.bar` & `foo.barbaz`
  * - `*` matches everything.
  */
 static bool clg_ctx_filter_check(CLogContext *ctx, const char *identifier)
 {
-  const int identifier_len = strlen(identifier);
+  const size_t identifier_len = strlen(identifier);
   for (uint i = 0; i < 2; i++) {
     const CLG_IDFilter *flt = ctx->filters[i];
     while (flt != NULL) {
-      const int len = strlen(flt->match);
+      const size_t len = strlen(flt->match);
       if (STREQ(flt->match, "*") || ((len == identifier_len) && (STREQ(identifier, flt->match)))) {
         return (bool)i;
       }
-      if ((len >= 2) && (STREQLEN(".*", &flt->match[len - 2], 2))) {
+      if (flt->match[0] == '*' && flt->match[len - 1] == '*') {
+        char *match = MEM_callocN(sizeof(char) * len - 1, __func__);
+        memcpy(match, flt->match + 1, len - 2);
+        if (strstr(identifier, match) != NULL) {
+          return (bool)i;
+        }
+      }
+      else if ((len >= 2) && (STREQLEN(".*", &flt->match[len - 2], 2))) {
         if (((identifier_len == len - 2) && STREQLEN(identifier, flt->match, len - 2)) ||
             ((identifier_len >= len - 1) && STREQLEN(identifier, flt->match, len - 1))) {
           return (bool)i;

intern/cycles/bvh/bvh_optix.cpp

@@ -27,8 +27,8 @@ BVHOptiX::BVHOptiX(const BVHParams &params_,
                    Device *device)
     : BVH(params_, geometry_, objects_),
       traversable_handle(0),
-      as_data(device, params_.top_level ? "optix tlas" : "optix blas"),
-      motion_transform_data(device, "optix motion transform")
+      as_data(device, params_.top_level ? "optix tlas" : "optix blas", false),
+      motion_transform_data(device, "optix motion transform", false)
 {
 }
 

intern/cycles/device/cuda/device_cuda_impl.cpp

@@ -854,7 +854,7 @@ CUDADevice::CUDAMem *CUDADevice::generic_alloc(device_memory &mem, size_t pitch_
 
   void *shared_pointer = 0;
 
-  if (mem_alloc_result != CUDA_SUCCESS && can_map_host) {
+  if (mem_alloc_result != CUDA_SUCCESS && can_map_host && mem.type != MEM_DEVICE_ONLY) {
     if (mem.shared_pointer) {
       /* Another device already allocated host memory. */
       mem_alloc_result = CUDA_SUCCESS;
@@ -877,8 +877,14 @@ CUDADevice::CUDAMem *CUDADevice::generic_alloc(device_memory &mem, size_t pitch_
   }
 
   if (mem_alloc_result != CUDA_SUCCESS) {
-    status = " failed, out of device and host memory";
-    set_error("System is out of GPU and shared host memory");
+    if (mem.type == MEM_DEVICE_ONLY) {
+      status = " failed, out of device memory";
+      set_error("System is out of GPU memory");
+    }
+    else {
+      status = " failed, out of device and host memory";
+      set_error("System is out of GPU and shared host memory");
+    }
   }
 
   if (mem.name) {

intern/cycles/device/device_cpu.cpp

@@ -396,8 +396,7 @@ class CPUDevice : public Device {
                 << string_human_readable_size(mem.memory_size()) << ")";
       }
 
-      if (mem.type == MEM_DEVICE_ONLY) {
-        assert(!mem.host_pointer);
+      if (mem.type == MEM_DEVICE_ONLY || !mem.host_pointer) {
         size_t alignment = MIN_ALIGNMENT_CPU_DATA_TYPES;
         void *data = util_aligned_malloc(mem.memory_size(), alignment);
         mem.device_pointer = (device_ptr)data;
@@ -459,7 +458,7 @@ class CPUDevice : public Device {
       tex_free((device_texture &)mem);
     }
     else if (mem.device_pointer) {
-      if (mem.type == MEM_DEVICE_ONLY) {
+      if (mem.type == MEM_DEVICE_ONLY || !mem.host_pointer) {
         util_aligned_free((void *)mem.device_pointer);
       }
       mem.device_pointer = 0;

intern/cycles/device/device_denoising.h

@@ -171,7 +171,8 @@ class DenoisingTask {
     bool gpu_temporary_mem;
 
     DenoiseBuffers(Device *device)
-        : mem(device, "denoising pixel buffer"), temporary_mem(device, "denoising temporary mem")
+        : mem(device, "denoising pixel buffer"),
+          temporary_mem(device, "denoising temporary mem", true)
     {
     }
   } buffer;

intern/cycles/device/device_memory.h

@@ -270,8 +270,8 @@ class device_memory {
 
 template<typename T> class device_only_memory : public device_memory {
  public:
-  device_only_memory(Device *device, const char *name)
-      : device_memory(device, name, MEM_DEVICE_ONLY)
+  device_only_memory(Device *device, const char *name, bool allow_host_memory_fallback = false)
+      : device_memory(device, name, allow_host_memory_fallback ? MEM_READ_WRITE : MEM_DEVICE_ONLY)
   {
     data_type = device_type_traits<T>::data_type;
     data_elements = max(device_type_traits<T>::num_elements, 1);

intern/cycles/device/device_optix.cpp

@@ -197,8 +197,8 @@ class OptiXDevice : public CUDADevice {
   OptiXDevice(DeviceInfo &info_, Stats &stats_, Profiler &profiler_, bool background_)
       : CUDADevice(info_, stats_, profiler_, background_),
         sbt_data(this, "__sbt", MEM_READ_ONLY),
-        launch_params(this, "__params"),
-        denoiser_state(this, "__denoiser_state")
+        launch_params(this, "__params", false),
+        denoiser_state(this, "__denoiser_state", true)
   {
     // Store number of CUDA streams in device info
     info.cpu_threads = DebugFlags().optix.cuda_streams;
@@ -878,8 +878,8 @@ class OptiXDevice : public CUDADevice {
       device_ptr input_ptr = rtile.buffer + pixel_offset;
 
       // Copy tile data into a common buffer if necessary
-      device_only_memory<float> input(this, "denoiser input");
-      device_vector<TileInfo> tile_info_mem(this, "denoiser tile info", MEM_READ_WRITE);
+      device_only_memory<float> input(this, "denoiser input", true);
+      device_vector<TileInfo> tile_info_mem(this, "denoiser tile info", MEM_READ_ONLY);
 
       bool contiguous_memory = true;
       for (int i = 0; i < RenderTileNeighbors::SIZE; i++) {
@@ -924,7 +924,7 @@ class OptiXDevice : public CUDADevice {
       }
 
 #  if OPTIX_DENOISER_NO_PIXEL_STRIDE
-      device_only_memory<float> input_rgb(this, "denoiser input rgb");
+      device_only_memory<float> input_rgb(this, "denoiser input rgb", true);
       input_rgb.alloc_to_device(rect_size.x * rect_size.y * 3 * task.denoising.input_passes);
 
       void *input_args[] = {&input_rgb.device_pointer,
@@ -1146,6 +1146,13 @@ class OptiXDevice : public CUDADevice {
                        const OptixBuildInput &build_input,
                        uint16_t num_motion_steps)
   {
+    /* Allocate and build acceleration structures only one at a time, to prevent parallel builds
+     * from running out of memory (since both original and compacted acceleration structure memory
+     * may be allocated at the same time for the duration of this function). The builds would
+     * otherwise happen on the same CUDA stream anyway. */
+    static thread_mutex mutex;
+    thread_scoped_lock lock(mutex);
+
     const CUDAContextScope scope(cuContext);
 
     // Compute memory usage
@@ -1170,11 +1177,12 @@ class OptiXDevice : public CUDADevice {
         optixAccelComputeMemoryUsage(context, &options, &build_input, 1, &sizes));
 
     // Allocate required output buffers
-    device_only_memory<char> temp_mem(this, "optix temp as build mem");
+    device_only_memory<char> temp_mem(this, "optix temp as build mem", true);
     temp_mem.alloc_to_device(align_up(sizes.tempSizeInBytes, 8) + 8);
     if (!temp_mem.device_pointer)
       return false;  // Make sure temporary memory allocation succeeded
 
+    // Acceleration structure memory has to be allocated on the device (not allowed to be on host)
     device_only_memory<char> &out_data = bvh->as_data;
     if (operation == OPTIX_BUILD_OPERATION_BUILD) {
       assert(out_data.device == this);
@@ -1222,7 +1230,7 @@ class OptiXDevice : public CUDADevice {
 
       // There is no point compacting if the size does not change
       if (compacted_size < sizes.outputSizeInBytes) {
-        device_only_memory<char> compacted_data(this, "optix compacted as");
+        device_only_memory<char> compacted_data(this, "optix compacted as", false);
         compacted_data.alloc_to_device(compacted_size);
         if (!compacted_data.device_pointer)
           // Do not compact if memory allocation for compacted acceleration structure fails
@@ -1242,6 +1250,7 @@ class OptiXDevice : public CUDADevice {
 
         std::swap(out_data.device_size, compacted_data.device_size);
         std::swap(out_data.device_pointer, compacted_data.device_pointer);
+        // Original acceleration structure memory is freed when 'compacted_data' goes out of scope
       }
     }
 

intern/cycles/device/device_task.cpp

@@ -45,7 +45,16 @@ DeviceTask::DeviceTask(Type type_)
       shader_filter(0),
       shader_x(0),
       shader_w(0),
-      buffers(nullptr)
+      buffers(nullptr),
+      tile_types(0),
+      denoising_from_render(false),
+      pass_stride(0),
+      frame_stride(0),
+      target_pass_stride(0),
+      pass_denoising_data(0),
+      pass_denoising_clean(0),
+      need_finish_queue(false),
+      integrator_branched(false)
 {
   last_update_time = time_dt();
 }

intern/cycles/graph/node_type.cpp

@@ -154,7 +154,7 @@ void NodeType::register_input(ustring name,
                               int struct_offset,
                               const void *default_value,
                               const NodeEnum *enum_values,
-                              const NodeType **node_type,
+                              const NodeType *node_type,
                               int flags,
                               int extra_flags)
 {

intern/cycles/graph/node_type.h

@@ -87,7 +87,7 @@ struct SocketType {
   int struct_offset;
   const void *default_value;
   const NodeEnum *enum_values;
-  const NodeType **node_type;
+  const NodeType *node_type;
   int flags;
   ustring ui_name;
   SocketModifiedFlags modified_flag_bit;
@@ -115,7 +115,7 @@ struct NodeType {
                       int struct_offset,
                       const void *default_value,
                       const NodeEnum *enum_values = NULL,
-                      const NodeType **node_type = NULL,
+                      const NodeType *node_type = NULL,
                       int flags = 0,
                       int extra_flags = 0);
   void register_output(ustring name, ustring ui_name, SocketType::Type type);
@@ -140,27 +140,38 @@ struct NodeType {
   static unordered_map<ustring, NodeType, ustringHash> &types();
 };
 
-/* Node Definition Macros */
+/* Node Definition Macros
+ *
+ * Node we use accessor to get node types to ensure correct static
+ * initialization order. */
 
 #define NODE_DECLARE \
+  static const NodeType *get_node_type(); \
   template<typename T> static const NodeType *register_type(); \
-  static Node *create(const NodeType *type); \
-  static const NodeType *node_type;
+  static Node *create(const NodeType *type);
 
 #define NODE_DEFINE(structname) \
-  const NodeType *structname::node_type = structname::register_type<structname>(); \
   Node *structname::create(const NodeType *) \
   { \
     return new structname(); \
   } \
+  const NodeType *structname::get_node_type() \
+  { \
+    static const NodeType *node_type = register_type<structname>(); \
+    return node_type; \
+  } \
   template<typename T> const NodeType *structname::register_type()
 
 #define NODE_ABSTRACT_DECLARE \
   template<typename T> static const NodeType *register_base_type(); \
-  static const NodeType *node_base_type;
+  static const NodeType *get_node_base_type();
 
 #define NODE_ABSTRACT_DEFINE(structname) \
-  const NodeType *structname::node_base_type = structname::register_base_type<structname>(); \
+  const NodeType *structname::get_node_base_type() \
+  { \
+    static const NodeType *node_base_type = register_base_type<structname>(); \
+    return node_base_type; \
+  } \
   template<typename T> const NodeType *structname::register_base_type()
 
 /* Sock Definition Macros */

intern/cycles/graph/node_xml.cpp

@@ -200,7 +200,7 @@ void xml_read_node(XMLReader &reader, Node *node, xml_node xml_node)
         map<ustring, Node *>::iterator it = reader.node_map.find(value);
         if (it != reader.node_map.end()) {
           Node *value_node = it->second;
-          if (value_node->is_a(*(socket.node_type)))
+          if (value_node->is_a(socket.node_type))
             node->set(socket, it->second);
         }
         break;
@@ -215,7 +215,7 @@ void xml_read_node(XMLReader &reader, Node *node, xml_node xml_node)
           map<ustring, Node *>::iterator it = reader.node_map.find(ustring(tokens[i]));
           if (it != reader.node_map.end()) {
             Node *value_node = it->second;
-            value[i] = (value_node->is_a(*(socket.node_type))) ? value_node : NULL;
+            value[i] = (value_node->is_a(socket.node_type)) ? value_node : NULL;
           }
           else {
             value[i] = NULL;

intern/cycles/kernel/kernel_montecarlo.h

@@ -195,108 +195,31 @@ ccl_device float2 regular_polygon_sample(float corners, float rotation, float u,
 
 ccl_device float3 ensure_valid_reflection(float3 Ng, float3 I, float3 N)
 {
-  float3 R = 2 * dot(N, I) * N - I;
+  float3 R;
+  float NI = dot(N, I);
+  float NgR, threshold;
 
-  /* Reflection rays may always be at least as shallow as the incoming ray. */
-  float threshold = min(0.9f * dot(Ng, I), 0.01f);
-  if (dot(Ng, R) >= threshold) {
-    return N;
-  }
+  /* Check if the incident ray is coming from behind normal N. */
+  if (NI > 0) {
+    /* Normal reflection */
+    R = (2 * NI) * N - I;
+    NgR = dot(Ng, R);
 
-  /* Form coordinate system with Ng as the Z axis and N inside the X-Z-plane.
-   * The X axis is found by normalizing the component of N that's orthogonal to Ng.
-   * The Y axis isn't actually needed.
-   */
-  float NdotNg = dot(N, Ng);
-  float3 X = normalize(N - NdotNg * Ng);
-
-  /* Keep math expressions. */
-  /* clang-format off */
-  /* Calculate N.z and N.x in the local coordinate system.
-   *
-   * The goal of this computation is to find a N' that is rotated towards Ng just enough
-   * to lift R' above the threshold (here called t), therefore dot(R', Ng) = t.
-   *
-   * According to the standard reflection equation,
-   * this means that we want dot(2*dot(N', I)*N' - I, Ng) = t.
-   *
-   * Since the Z axis of our local coordinate system is Ng, dot(x, Ng) is just x.z, so we get
-   * 2*dot(N', I)*N'.z - I.z = t.
-   *
-   * The rotation is simple to express in the coordinate system we formed -
-   * since N lies in the X-Z-plane, we know that N' will also lie in the X-Z-plane,
-   * so N'.y = 0 and therefore dot(N', I) = N'.x*I.x + N'.z*I.z .
-   *
-   * Furthermore, we want N' to be normalized, so N'.x = sqrt(1 - N'.z^2).
-   *
-   * With these simplifications,
-   * we get the final equation 2*(sqrt(1 - N'.z^2)*I.x + N'.z*I.z)*N'.z - I.z = t.
-   *
-   * The only unknown here is N'.z, so we can solve for that.
-   *
-   * The equation has four solutions in general:
-   *
-   * N'.z = +-sqrt(0.5*(+-sqrt(I.x^2*(I.x^2 + I.z^2 - t^2)) + t*I.z + I.x^2 + I.z^2)/(I.x^2 + I.z^2))
-   * We can simplify this expression a bit by grouping terms:
-   *
-   * a = I.x^2 + I.z^2
-   * b = sqrt(I.x^2 * (a - t^2))
-   * c = I.z*t + a
-   * N'.z = +-sqrt(0.5*(+-b + c)/a)
-   *
-   * Two solutions can immediately be discarded because they're negative so N' would lie in the
-   * lower hemisphere.
-   */
-  /* clang-format on */
-
-  float Ix = dot(I, X), Iz = dot(I, Ng);
-  float Ix2 = sqr(Ix), Iz2 = sqr(Iz);
-  float a = Ix2 + Iz2;
-
-  float b = safe_sqrtf(Ix2 * (a - sqr(threshold)));
-  float c = Iz * threshold + a;
-
-  /* Evaluate both solutions.
-   * In many cases one can be immediately discarded (if N'.z would be imaginary or larger than
-   * one), so check for that first. If no option is viable (might happen in extreme cases like N
-   * being in the wrong hemisphere), give up and return Ng. */
-  float fac = 0.5f / a;
-  float N1_z2 = fac * (b + c), N2_z2 = fac * (-b + c);
-  bool valid1 = (N1_z2 > 1e-5f) && (N1_z2 <= (1.0f + 1e-5f));
-  bool valid2 = (N2_z2 > 1e-5f) && (N2_z2 <= (1.0f + 1e-5f));
-
-  float2 N_new;
-  if (valid1 && valid2) {
-    /* If both are possible, do the expensive reflection-based check. */
-    float2 N1 = make_float2(safe_sqrtf(1.0f - N1_z2), safe_sqrtf(N1_z2));
-    float2 N2 = make_float2(safe_sqrtf(1.0f - N2_z2), safe_sqrtf(N2_z2));
-
-    float R1 = 2 * (N1.x * Ix + N1.y * Iz) * N1.y - Iz;
-    float R2 = 2 * (N2.x * Ix + N2.y * Iz) * N2.y - Iz;
-
-    valid1 = (R1 >= 1e-5f);
-    valid2 = (R2 >= 1e-5f);
-    if (valid1 && valid2) {
-      /* If both solutions are valid, return the one with the shallower reflection since it will be
-       * closer to the input (if the original reflection wasn't shallow, we would not be in this
-       * part of the function). */
-      N_new = (R1 < R2) ? N1 : N2;
+    /* Reflection rays may always be at least as shallow as the incoming ray. */
+    threshold = min(0.9f * dot(Ng, I), 0.01f);
+    if (NgR >= threshold) {
+      return N;
     }
-    else {
-      /* If only one reflection is valid (= positive), pick that one. */
-      N_new = (R1 > R2) ? N1 : N2;
-    }
-  }
-  else if (valid1 || valid2) {
-    /* Only one solution passes the N'.z criterium, so pick that one. */
-    float Nz2 = valid1 ? N1_z2 : N2_z2;
-    N_new = make_float2(safe_sqrtf(1.0f - Nz2), safe_sqrtf(Nz2));
   }
   else {
-    return Ng;
+    /* Bad incident */
+    R = -I;
+    NgR = dot(Ng, R);
+    threshold = 0.01f;
   }
 
-  return N_new.x * X + N_new.y * Ng;
+  R = R + Ng * (threshold - NgR);            /* Lift the reflection above the threshold. */
+  return normalize(I * len(R) + R * len(I)); /* Find a bisector. */
 }
 
 CCL_NAMESPACE_END

intern/cycles/kernel/kernel_volume.h

@@ -175,7 +175,8 @@ ccl_device_inline void kernel_volume_step_init(KernelGlobals *kg,
                                                const float object_step_size,
                                                float t,
                                                float *step_size,
-                                               float *step_offset)
+                                               float *step_shade_offset,
+                                               float *steps_offset)
 {
   const int max_steps = kernel_data.integrator.volume_max_steps;
   float step = min(object_step_size, t);
@@ -186,7 +187,14 @@ ccl_device_inline void kernel_volume_step_init(KernelGlobals *kg,
   }
 
   *step_size = step;
-  *step_offset = path_state_rng_1D_hash(kg, state, 0x1e31d8a4) * step;
+
+  /* Perform shading at this offset within a step, to integrate over
+   * over the entire step segment. */
+  *step_shade_offset = path_state_rng_1D_hash(kg, state, 0x1e31d8a4);
+
+  /* Shift starting point of all segment by this random amount to avoid
+   * banding artifacts from the volume bounding shape. */
+  *steps_offset = path_state_rng_1D_hash(kg, state, 0x3d22c7b3);
 }
 
 /* Volume Shadows
@@ -220,10 +228,15 @@ ccl_device void kernel_volume_shadow_heterogeneous(KernelGlobals *kg,
   float3 tp = *throughput;
   const float tp_eps = 1e-6f; /* todo: this is likely not the right value */
 
-  /* prepare for stepping */
+  /* Prepare for stepping.
+   * For shadows we do not offset all segments, since the starting point is
+   * already a random distance inside the volume. It also appears to create
+   * banding artifacts for unknown reasons. */
   int max_steps = kernel_data.integrator.volume_max_steps;
-  float step_offset, step_size;
-  kernel_volume_step_init(kg, state, object_step_size, ray->t, &step_size, &step_offset);
+  float step_size, step_shade_offset, unused;
+  kernel_volume_step_init(
+      kg, state, object_step_size, ray->t, &step_size, &step_shade_offset, &unused);
+  const float steps_offset = 1.0f;
 
   /* compute extinction at the start */
   float t = 0.0f;
@@ -232,23 +245,17 @@ ccl_device void kernel_volume_shadow_heterogeneous(KernelGlobals *kg,
 
   for (int i = 0; i < max_steps; i++) {
     /* advance to new position */
-    float new_t = min(ray->t, (i + 1) * step_size);
+    float new_t = min(ray->t, (i + steps_offset) * step_size);
+    float dt = new_t - t;
 
-    /* use random position inside this segment to sample shader, adjust
-     * for last step that is shorter than other steps. */
-    if (new_t == ray->t) {
-      step_offset *= (new_t - t) / step_size;
-    }
-
-    float3 new_P = ray->P + ray->D * (t + step_offset);
+    float3 new_P = ray->P + ray->D * (t + dt * step_shade_offset);
     float3 sigma_t = zero_float3();
 
     /* compute attenuation over segment */
     if (volume_shader_extinction_sample(kg, sd, state, new_P, &sigma_t)) {
       /* Compute expf() only for every Nth step, to save some calculations
        * because exp(a)*exp(b) = exp(a+b), also do a quick tp_eps check then. */
-
-      sum += (-sigma_t * (new_t - t));
+      sum += (-sigma_t * dt);
       if ((i & 0x07) == 0) { /* ToDo: Other interval? */
         tp = *throughput * exp3(sum);
 
@@ -567,10 +574,12 @@ kernel_volume_integrate_heterogeneous_distance(KernelGlobals *kg,
   float3 tp = *throughput;
   const float tp_eps = 1e-6f; /* todo: this is likely not the right value */
 
-  /* prepare for stepping */
+  /* Prepare for stepping.
+   * Using a different step offset for the first step avoids banding artifacts. */
   int max_steps = kernel_data.integrator.volume_max_steps;
-  float step_offset, step_size;
-  kernel_volume_step_init(kg, state, object_step_size, ray->t, &step_size, &step_offset);
+  float step_size, step_shade_offset, steps_offset;
+  kernel_volume_step_init(
+      kg, state, object_step_size, ray->t, &step_size, &step_shade_offset, &steps_offset);
 
   /* compute coefficients at the start */
   float t = 0.0f;
@@ -584,16 +593,10 @@ kernel_volume_integrate_heterogeneous_distance(KernelGlobals *kg,
 
   for (int i = 0; i < max_steps; i++) {
     /* advance to new position */
-    float new_t = min(ray->t, (i + 1) * step_size);
+    float new_t = min(ray->t, (i + steps_offset) * step_size);
     float dt = new_t - t;
 
-    /* use random position inside this segment to sample shader,
-     * for last shorter step we remap it to fit within the segment. */
-    if (new_t == ray->t) {
-      step_offset *= (new_t - t) / step_size;
-    }
-
-    float3 new_P = ray->P + ray->D * (t + step_offset);
+    float3 new_P = ray->P + ray->D * (t + dt * step_shade_offset);
     VolumeShaderCoefficients coeff ccl_optional_struct_init;
 
     /* compute segment */
@@ -771,11 +774,12 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg,
 
   /* prepare for volume stepping */
   int max_steps;
-  float step_size, step_offset;
+  float step_size, step_shade_offset, steps_offset;
 
   if (object_step_size != FLT_MAX) {
     max_steps = kernel_data.integrator.volume_max_steps;
-    kernel_volume_step_init(kg, state, object_step_size, ray->t, &step_size, &step_offset);
+    kernel_volume_step_init(
+        kg, state, object_step_size, ray->t, &step_size, &step_shade_offset, &steps_offset);
 
 #      ifdef __KERNEL_CPU__
     /* NOTE: For the branched path tracing it's possible to have direct
@@ -802,7 +806,8 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg,
   else {
     max_steps = 1;
     step_size = ray->t;
-    step_offset = 0.0f;
+    step_shade_offset = 0.0f;
+    steps_offset = 1.0f;
     segment->steps = &segment->stack_step;
   }
 
@@ -821,16 +826,10 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg,
 
   for (int i = 0; i < max_steps; i++, step++) {
     /* advance to new position */
-    float new_t = min(ray->t, (i + 1) * step_size);
+    float new_t = min(ray->t, (i + steps_offset) * step_size);
     float dt = new_t - t;
 
-    /* use random position inside this segment to sample shader,
-     * for last shorter step we remap it to fit within the segment. */
-    if (new_t == ray->t) {
-      step_offset *= (new_t - t) / step_size;
-    }
-
-    float3 new_P = ray->P + ray->D * (t + step_offset);
+    float3 new_P = ray->P + ray->D * (t + dt * step_shade_offset);
     VolumeShaderCoefficients coeff ccl_optional_struct_init;
 
     /* compute segment */
@@ -888,7 +887,7 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg,
     step->accum_transmittance = accum_transmittance;
     step->cdf_distance = cdf_distance;
     step->t = new_t;
-    step->shade_t = t + step_offset;
+    step->shade_t = t + dt * step_shade_offset;
 
     /* stop if at the end of the volume */
     t = new_t;

intern/cycles/kernel/kernels/cuda/kernel_cuda_image.h

@@ -68,8 +68,8 @@ ccl_device T kernel_tex_image_interp_bicubic(const TextureInfo &info, float x, f
   x = (x * info.width) - 0.5f;
   y = (y * info.height) - 0.5f;
 
-  float px = floor(x);
-  float py = floor(y);
+  float px = floorf(x);
+  float py = floorf(y);
   float fx = x - px;
   float fy = y - py;
 
@@ -95,9 +95,9 @@ ccl_device T kernel_tex_image_interp_tricubic(const TextureInfo &info, float x,
   y = (y * info.height) - 0.5f;
   z = (z * info.depth) - 0.5f;
 
-  float px = floor(x);
-  float py = floor(y);
-  float pz = floor(z);
+  float px = floorf(x);
+  float py = floorf(y);
+  float pz = floorf(z);
   float fx = x - px;
   float fy = y - py;
   float fz = z - pz;
@@ -127,9 +127,9 @@ ccl_device T kernel_tex_image_interp_tricubic(const TextureInfo &info, float x,
 template<typename T, typename S>
 ccl_device T kernel_tex_image_interp_tricubic_nanovdb(S &s, float x, float y, float z)
 {
-  float px = floor(x);
-  float py = floor(y);
-  float pz = floor(z);
+  float px = floorf(x);
+  float py = floorf(y);
+  float pz = floorf(z);
   float fx = x - px;
   float fy = y - py;
   float fz = z - pz;

intern/cycles/kernel/shaders/node_attribute.osl

@@ -23,7 +23,7 @@ shader node_attribute(string bump_offset = "center",
                       output float Fac = 0.0,
                       output float Alpha = 0.0)
 {
-  float data[4];
+  float data[4] = {0.0, 0.0, 0.0, 0.0};
   getattribute(name, data);
   Color = color(data[0], data[1], data[2]);
   Vector = point(Color);

intern/cycles/kernel/shaders/node_light_path.osl

@@ -42,23 +42,23 @@ shader node_light_path(output float IsCameraRay = 0.0,
 
   getattribute("path:ray_length", RayLength);
 
-  int ray_depth;
+  int ray_depth = 0;
   getattribute("path:ray_depth", ray_depth);
   RayDepth = (float)ray_depth;
 
-  int diffuse_depth;
+  int diffuse_depth = 0;
   getattribute("path:diffuse_depth", diffuse_depth);
   DiffuseDepth = (float)diffuse_depth;
 
-  int glossy_depth;
+  int glossy_depth = 0;
   getattribute("path:glossy_depth", glossy_depth);
   GlossyDepth = (float)glossy_depth;
 
-  int transparent_depth;
+  int transparent_depth = 0;
   getattribute("path:transparent_depth", transparent_depth);
   TransparentDepth = (float)transparent_depth;
 
-  int transmission_depth;
+  int transmission_depth = 0;
   getattribute("path:transmission_depth", transmission_depth);
   TransmissionDepth = (float)transmission_depth;
 }

intern/cycles/kernel/shaders/node_normal_map.osl

@@ -31,7 +31,7 @@ shader node_normal_map(normal NormalIn = N,
     vector tangent;
     vector ninterp;
     float tangent_sign;
-    float is_smooth;
+    float is_smooth = 0.0;
 
     getattribute("geom:is_smooth", is_smooth);
     if (!is_smooth) {

intern/cycles/kernel/shaders/node_tangent.osl

@@ -22,7 +22,7 @@ shader node_tangent(normal NormalIn = N,
                     string axis = "z",
                     output normal Tangent = normalize(dPdu))
 {
-  vector T;
+  vector T = vector(0.0, 0.0, 0.0);
 
   if (direction_type == "uv_map") {
     getattribute(attr_name, T);

intern/cycles/kernel/shaders/stdcycles.h

@@ -84,67 +84,30 @@ closure color principled_hair(normal N,
 closure color henyey_greenstein(float g) BUILTIN;
 closure color absorption() BUILTIN;
 
-normal ensure_valid_reflection(normal Ng, vector I, normal N)
+normal ensure_valid_reflection(normal Ng, normal I, normal N)
 {
   /* The implementation here mirrors the one in kernel_montecarlo.h,
    * check there for an explanation of the algorithm. */
+  vector R;
+  float NI = dot(N, I);
+  float NgR, threshold;
 
-  float sqr(float x)
-  {
-    return x * x;
-  }
-
-  vector R = 2 * dot(N, I) * N - I;
-
-  float threshold = min(0.9 * dot(Ng, I), 0.01);
-  if (dot(Ng, R) >= threshold) {
-    return N;
-  }
-
-  float NdotNg = dot(N, Ng);
-  vector X = normalize(N - NdotNg * Ng);
-
-  float Ix = dot(I, X), Iz = dot(I, Ng);
-  float Ix2 = sqr(Ix), Iz2 = sqr(Iz);
-  float a = Ix2 + Iz2;
-
-  float b = sqrt(Ix2 * (a - sqr(threshold)));
-  float c = Iz * threshold + a;
-
-  float fac = 0.5 / a;
-  float N1_z2 = fac * (b + c), N2_z2 = fac * (-b + c);
-  int valid1 = (N1_z2 > 1e-5) && (N1_z2 <= (1.0 + 1e-5));
-  int valid2 = (N2_z2 > 1e-5) && (N2_z2 <= (1.0 + 1e-5));
-
-  float N_new_x, N_new_z;
-  if (valid1 && valid2) {
-    float N1_x = sqrt(1.0 - N1_z2), N1_z = sqrt(N1_z2);
-    float N2_x = sqrt(1.0 - N2_z2), N2_z = sqrt(N2_z2);
-
-    float R1 = 2 * (N1_x * Ix + N1_z * Iz) * N1_z - Iz;
-    float R2 = 2 * (N2_x * Ix + N2_z * Iz) * N2_z - Iz;
-
-    valid1 = (R1 >= 1e-5);
-    valid2 = (R2 >= 1e-5);
-    if (valid1 && valid2) {
-      N_new_x = (R1 < R2) ? N1_x : N2_x;
-      N_new_z = (R1 < R2) ? N1_z : N2_z;
+  if (NI > 0) {
+    R = (2 * NI) * N - I;
+    NgR = dot(Ng, R);
+    threshold = min(0.9 * dot(Ng, I), 0.01);
+    if (NgR >= threshold) {
+      return N;
     }
-    else {
-      N_new_x = (R1 > R2) ? N1_x : N2_x;
-      N_new_z = (R1 > R2) ? N1_z : N2_z;
-    }
-  }
-  else if (valid1 || valid2) {
-    float Nz2 = valid1 ? N1_z2 : N2_z2;
-    N_new_x = sqrt(1.0 - Nz2);
-    N_new_z = sqrt(Nz2);
   }
   else {
-    return Ng;
+    R = -I;
+    NgR = dot(Ng, R);
+    threshold = 0.01;
   }
 
-  return N_new_x * X + N_new_z * Ng;
+  R = R + Ng * (threshold - NgR);
+  return normalize(I * length(R) + R * length(I));
 }
 
 #endif /* CCL_STDOSL_H */

intern/cycles/render/alembic.cpp

@@ -402,16 +402,16 @@ static void add_uvs(AlembicProcedural *proc,
     }
 
     const ISampleSelector iss = ISampleSelector(time);
-    const IV2fGeomParam::Sample sample = uvs.getExpandedValue(iss);
-
     const IV2fGeomParam::Sample uvsample = uvs.getIndexedValue(iss);
 
     if (!uvsample.valid()) {
       continue;
     }
 
-    const array<int3> *triangles = cached_data.triangles.data_for_time_no_check(time);
-    const array<int3> *triangles_loops = cached_data.triangles_loops.data_for_time_no_check(time);
+    const array<int3> *triangles =
+        cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
+    const array<int3> *triangles_loops =
+        cached_data.triangles_loops.data_for_time_no_check(time).get_data_or_null();
 
     if (!triangles || !triangles_loops) {
       continue;
@@ -458,7 +458,8 @@ static void add_normals(const Int32ArraySamplePtr face_indices,
                                                                     *normals.getTimeSampling());
       attr.std = ATTR_STD_VERTEX_NORMAL;
 
-      const array<float3> *vertices = cached_data.vertices.data_for_time_no_check(time);
+      const array<float3> *vertices =
+          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
 
       if (!vertices) {
         return;
@@ -493,7 +494,8 @@ static void add_normals(const Int32ArraySamplePtr face_indices,
                                                                     *normals.getTimeSampling());
       attr.std = ATTR_STD_VERTEX_NORMAL;
 
-      const array<float3> *vertices = cached_data.vertices.data_for_time_no_check(time);
+      const array<float3> *vertices =
+          cached_data.vertices.data_for_time_no_check(time).get_data_or_null();
 
       if (!vertices) {
         return;
@@ -597,7 +599,7 @@ NODE_DEFINE(AlembicObject)
   NodeType *type = NodeType::add("alembic_object", create);
 
   SOCKET_STRING(path, "Alembic Path", ustring());
-  SOCKET_NODE_ARRAY(used_shaders, "Used Shaders", &Shader::node_type);
+  SOCKET_NODE_ARRAY(used_shaders, "Used Shaders", Shader::get_node_type());
 
   SOCKET_INT(subd_max_level, "Max Subdivision Level", 1);
   SOCKET_FLOAT(subd_dicing_rate, "Subdivision Dicing Rate", 1.0f);
@@ -607,7 +609,7 @@ NODE_DEFINE(AlembicObject)
   return type;
 }
 
-AlembicObject::AlembicObject() : Node(node_type)
+AlembicObject::AlembicObject() : Node(get_node_type())
 {
   schema_type = INVALID;
 }
@@ -717,11 +719,15 @@ void AlembicObject::read_face_sets(SchemaType &schema,
 
 void AlembicObject::load_all_data(AlembicProcedural *proc,
                                   IPolyMeshSchema &schema,
-                                  float scale,
                                   Progress &progress)
 {
   cached_data.clear();
 
+  /* Only load data for the original Geometry. */
+  if (instance_of) {
+    return;
+  }
+
   const TimeSamplingPtr time_sampling = schema.getTimeSampling();
   cached_data.set_time_sampling(*time_sampling);
 
@@ -780,22 +786,18 @@ void AlembicObject::load_all_data(AlembicProcedural *proc,
     add_uvs(proc, uvs, cached_data, progress);
   }
 
-  if (progress.get_cancel()) {
-    return;
-  }
-
-  setup_transform_cache(scale);
-
   data_loaded = true;
 }
 
-void AlembicObject::load_all_data(AlembicProcedural *proc,
-                                  ISubDSchema &schema,
-                                  float scale,
-                                  Progress &progress)
+void AlembicObject::load_all_data(AlembicProcedural *proc, ISubDSchema &schema, Progress &progress)
 {
   cached_data.clear();
 
+  /* Only load data for the original Geometry. */
+  if (instance_of) {
+    return;
+  }
+
   AttributeRequestSet requested_attributes = get_requested_attributes();
 
   const TimeSamplingPtr time_sampling = schema.getTimeSampling();
@@ -920,19 +922,21 @@ void AlembicObject::load_all_data(AlembicProcedural *proc,
     return;
   }
 
-  setup_transform_cache(scale);
-
   data_loaded = true;
 }
 
 void AlembicObject::load_all_data(AlembicProcedural *proc,
                                   const ICurvesSchema &schema,
-                                  float scale,
                                   Progress &progress,
                                   float default_radius)
 {
   cached_data.clear();
 
+  /* Only load data for the original Geometry. */
+  if (instance_of) {
+    return;
+  }
+
   const TimeSamplingPtr time_sampling = schema.getTimeSampling();
   cached_data.set_time_sampling(*time_sampling);
 
@@ -1007,8 +1011,6 @@ void AlembicObject::load_all_data(AlembicProcedural *proc,
 
   // TODO(@kevindietrich): attributes, need example files
 
-  setup_transform_cache(scale);
-
   data_loaded = true;
 }
 
@@ -1017,6 +1019,14 @@ void AlembicObject::setup_transform_cache(float scale)
   cached_data.transforms.clear();
   cached_data.transforms.invalidate_last_loaded_time();
 
+  if (scale == 0.0f) {
+    scale = 1.0f;
+  }
+
+  if (xform_time_sampling) {
+    cached_data.transforms.set_time_sampling(*xform_time_sampling);
+  }
+
   if (xform_samples.size() == 0) {
     Transform tfm = transform_scale(make_float3(scale));
     cached_data.transforms.add_data(tfm, 0.0);
@@ -1103,9 +1113,10 @@ void AlembicObject::read_attribute(const ICompoundProperty &arb_geom_params,
         attribute.element = ATTR_ELEMENT_CORNER;
         attribute.type_desc = TypeFloat2;
 
-        const array<int3> *triangles = cached_data.triangles.data_for_time_no_check(time);
-        const array<int3> *triangles_loops = cached_data.triangles_loops.data_for_time_no_check(
-            time);
+        const array<int3> *triangles =
+            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
+        const array<int3> *triangles_loops =
+            cached_data.triangles_loops.data_for_time_no_check(time).get_data_or_null();
 
         if (!triangles || !triangles_loops) {
           return;
@@ -1158,7 +1169,8 @@ void AlembicObject::read_attribute(const ICompoundProperty &arb_geom_params,
         attribute.element = ATTR_ELEMENT_CORNER_BYTE;
         attribute.type_desc = TypeRGBA;
 
-        const array<int3> *triangles = cached_data.triangles.data_for_time_no_check(time);
+        const array<int3> *triangles =
+            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
 
         if (!triangles) {
           return;
@@ -1214,7 +1226,8 @@ void AlembicObject::read_attribute(const ICompoundProperty &arb_geom_params,
         attribute.element = ATTR_ELEMENT_CORNER_BYTE;
         attribute.type_desc = TypeRGBA;
 
-        const array<int3> *triangles = cached_data.triangles.data_for_time_no_check(time);
+        const array<int3> *triangles =
+            cached_data.triangles.data_for_time_no_check(time).get_data_or_null();
 
         if (!triangles) {
           return;
@@ -1253,7 +1266,7 @@ static void update_attributes(AttributeSet &attributes, CachedData &cached_data,
   set<Attribute *> cached_attributes;
 
   for (CachedData::CachedAttribute &attribute : cached_data.attributes) {
-    const array<char> *attr_data = attribute.data.data_for_time(frame_time);
+    const array<char> *attr_data = attribute.data.data_for_time(frame_time).get_data_or_null();
 
     Attribute *attr = nullptr;
     if (attribute.std != ATTR_STD_NONE) {
@@ -1278,6 +1291,7 @@ static void update_attributes(AttributeSet &attributes, CachedData &cached_data,
     }
 
     memcpy(attr->data(), attr_data->data(), attr_data->size());
+    attr->modified = true;
   }
 
   /* remove any attributes not in cached_attributes */
@@ -1285,6 +1299,7 @@ static void update_attributes(AttributeSet &attributes, CachedData &cached_data,
   for (it = attributes.attributes.begin(); it != attributes.attributes.end();) {
     if (cached_attributes.find(&(*it)) == cached_attributes.end()) {
       attributes.attributes.erase(it++);
+      attributes.modified = true;
       continue;
     }
 
@@ -1305,12 +1320,12 @@ NODE_DEFINE(AlembicProcedural)
   SOCKET_FLOAT(default_radius, "Default Radius", 0.01f);
   SOCKET_FLOAT(scale, "Scale", 1.0f);
 
-  SOCKET_NODE_ARRAY(objects, "Objects", &AlembicObject::node_type);
+  SOCKET_NODE_ARRAY(objects, "Objects", AlembicObject::get_node_type());
 
   return type;
 }
 
-AlembicProcedural::AlembicProcedural() : Procedural(node_type)
+AlembicProcedural::AlembicProcedural() : Procedural(get_node_type())
 {
   objects_loaded = false;
   scene_ = nullptr;
@@ -1358,11 +1373,16 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
   }
 
   bool need_shader_updates = false;
+  bool need_data_updates = false;
 
-  /* Check for changes in shaders (newly requested attributes). */
   foreach (Node *object_node, objects) {
     AlembicObject *object = static_cast<AlembicObject *>(object_node);
 
+    if (object->is_modified()) {
+      need_data_updates = true;
+    }
+
+    /* Check for changes in shaders (e.g. newly requested attributes). */
     foreach (Node *shader_node, object->get_used_shaders()) {
       Shader *shader = static_cast<Shader *>(shader_node);
 
@@ -1373,7 +1393,7 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
     }
   }
 
-  if (!is_modified() && !need_shader_updates) {
+  if (!is_modified() && !need_shader_updates && !need_data_updates) {
     return;
   }
 
@@ -1397,6 +1417,8 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
 
   const chrono_t frame_time = (chrono_t)((frame - frame_offset) / frame_rate);
 
+  build_caches(progress);
+
   foreach (Node *node, objects) {
     AlembicObject *object = static_cast<AlembicObject *>(node);
 
@@ -1405,19 +1427,19 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
     }
 
     /* skip constant objects */
-    if (object->has_data_loaded() && object->is_constant() && !object->is_modified() &&
-        !object->need_shader_update && !scale_is_modified()) {
+    if (object->is_constant() && !object->is_modified() && !object->need_shader_update &&
+        !scale_is_modified()) {
       continue;
     }
 
     if (object->schema_type == AlembicObject::POLY_MESH) {
-      read_mesh(scene, object, frame_time, progress);
+      read_mesh(object, frame_time);
     }
     else if (object->schema_type == AlembicObject::CURVES) {
-      read_curves(scene, object, frame_time, progress);
+      read_curves(object, frame_time);
     }
     else if (object->schema_type == AlembicObject::SUBD) {
-      read_subd(scene, object, frame_time, progress);
+      read_subd(object, frame_time);
     }
 
     object->clear_modified();
@@ -1471,7 +1493,7 @@ void AlembicProcedural::load_objects(Progress &progress)
   IObject root = archive.getTop();
 
   for (size_t i = 0; i < root.getNumChildren(); ++i) {
-    walk_hierarchy(root, root.getChildHeader(i), nullptr, object_map, progress);
+    walk_hierarchy(root, root.getChildHeader(i), {}, object_map, progress);
   }
 
   /* Create nodes in the scene. */
@@ -1480,22 +1502,24 @@ void AlembicProcedural::load_objects(Progress &progress)
 
     Geometry *geometry = nullptr;
 
-    if (abc_object->schema_type == AlembicObject::CURVES) {
-      geometry = scene_->create_node<Hair>();
-    }
-    else if (abc_object->schema_type == AlembicObject::POLY_MESH ||
-             abc_object->schema_type == AlembicObject::SUBD) {
-      geometry = scene_->create_node<Mesh>();
-    }
-    else {
-      continue;
-    }
+    if (!abc_object->instance_of) {
+      if (abc_object->schema_type == AlembicObject::CURVES) {
+        geometry = scene_->create_node<Hair>();
+      }
+      else if (abc_object->schema_type == AlembicObject::POLY_MESH ||
+               abc_object->schema_type == AlembicObject::SUBD) {
+        geometry = scene_->create_node<Mesh>();
+      }
+      else {
+        continue;
+      }
 
-    geometry->set_owner(this);
-    geometry->name = abc_object->iobject.getName();
+      geometry->set_owner(this);
+      geometry->name = abc_object->iobject.getName();
 
-    array<Node *> used_shaders = abc_object->get_used_shaders();
-    geometry->set_used_shaders(used_shaders);
+      array<Node *> used_shaders = abc_object->get_used_shaders();
+      geometry->set_used_shaders(used_shaders);
+    }
 
     Object *object = scene_->create_node<Object>();
     object->set_owner(this);
@@ -1504,43 +1528,44 @@ void AlembicProcedural::load_objects(Progress &progress)
 
     abc_object->set_object(object);
   }
+
+  /* Share geometries between instances. */
+  foreach (Node *node, objects) {
+    AlembicObject *abc_object = static_cast<AlembicObject *>(node);
+
+    if (abc_object->instance_of) {
+      abc_object->get_object()->set_geometry(
+          abc_object->instance_of->get_object()->get_geometry());
+      abc_object->schema_type = abc_object->instance_of->schema_type;
+    }
+  }
 }
 
-void AlembicProcedural::read_mesh(Scene *scene,
-                                  AlembicObject *abc_object,
-                                  Abc::chrono_t frame_time,
-                                  Progress &progress)
+void AlembicProcedural::read_mesh(AlembicObject *abc_object, Abc::chrono_t frame_time)
 {
-  IPolyMesh polymesh(abc_object->iobject, Alembic::Abc::kWrapExisting);
-
-  Mesh *mesh = static_cast<Mesh *>(abc_object->get_object()->get_geometry());
-
   CachedData &cached_data = abc_object->get_cached_data();
-  IPolyMeshSchema schema = polymesh.getSchema();
-
-  if (!abc_object->has_data_loaded()) {
-    abc_object->load_all_data(this, schema, scale, progress);
-  }
-  else {
-    if (abc_object->need_shader_update) {
-      abc_object->update_shader_attributes(schema.getArbGeomParams(), progress);
-    }
-
-    if (scale_is_modified()) {
-      abc_object->setup_transform_cache(scale);
-    }
-  }
 
   /* update sockets */
 
   Object *object = abc_object->get_object();
   cached_data.transforms.copy_to_socket(frame_time, object, object->get_tfm_socket());
 
+  if (object->is_modified()) {
+    object->tag_update(scene_);
+  }
+
+  /* Only update sockets for the original Geometry. */
+  if (abc_object->instance_of) {
+    return;
+  }
+
+  Mesh *mesh = static_cast<Mesh *>(object->get_geometry());
+
   cached_data.vertices.copy_to_socket(frame_time, mesh, mesh->get_verts_socket());
 
   cached_data.shader.copy_to_socket(frame_time, mesh, mesh->get_shader_socket());
 
-  array<int3> *triangle_data = cached_data.triangles.data_for_time(frame_time);
+  array<int3> *triangle_data = cached_data.triangles.data_for_time(frame_time).get_data_or_null();
   if (triangle_data) {
     array<int> triangles;
     array<bool> smooth;
@@ -1566,7 +1591,7 @@ void AlembicProcedural::read_mesh(Scene *scene,
 
   /* we don't yet support arbitrary attributes, for now add vertex
    * coordinates as generated coordinates if requested */
-  if (mesh->need_attribute(scene, ATTR_STD_GENERATED)) {
+  if (mesh->need_attribute(scene_, ATTR_STD_GENERATED)) {
     Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
     memcpy(
         attr->data_float3(), mesh->get_verts().data(), sizeof(float3) * mesh->get_verts().size());
@@ -1574,39 +1599,12 @@ void AlembicProcedural::read_mesh(Scene *scene,
 
   if (mesh->is_modified()) {
     bool need_rebuild = mesh->triangles_is_modified();
-    mesh->tag_update(scene, need_rebuild);
+    mesh->tag_update(scene_, need_rebuild);
   }
 }
 
-void AlembicProcedural::read_subd(Scene *scene,
-                                  AlembicObject *abc_object,
-                                  Abc::chrono_t frame_time,
-                                  Progress &progress)
+void AlembicProcedural::read_subd(AlembicObject *abc_object, Abc::chrono_t frame_time)
 {
-  ISubD subd_mesh(abc_object->iobject, Alembic::Abc::kWrapExisting);
-  ISubDSchema schema = subd_mesh.getSchema();
-
-  Mesh *mesh = static_cast<Mesh *>(abc_object->get_object()->get_geometry());
-
-  /* Alembic is OpenSubDiv compliant, there is no option to set another subdivision type. */
-  mesh->set_subdivision_type(Mesh::SubdivisionType::SUBDIVISION_CATMULL_CLARK);
-
-  if (!abc_object->has_data_loaded()) {
-    abc_object->load_all_data(this, schema, scale, progress);
-  }
-  else {
-    if (abc_object->need_shader_update) {
-      abc_object->update_shader_attributes(schema.getArbGeomParams(), progress);
-    }
-
-    if (scale_is_modified()) {
-      abc_object->setup_transform_cache(scale);
-    }
-  }
-
-  mesh->set_subd_max_level(abc_object->get_subd_max_level());
-  mesh->set_subd_dicing_rate(abc_object->get_subd_dicing_rate());
-
   CachedData &cached_data = abc_object->get_cached_data();
 
   if (abc_object->subd_max_level_is_modified() || abc_object->subd_dicing_rate_is_modified()) {
@@ -1614,6 +1612,22 @@ void AlembicProcedural::read_subd(Scene *scene,
     cached_data.invalidate_last_loaded_time();
   }
 
+  /* Update sockets. */
+
+  Object *object = abc_object->get_object();
+  cached_data.transforms.copy_to_socket(frame_time, object, object->get_tfm_socket());
+
+  if (object->is_modified()) {
+    object->tag_update(scene_);
+  }
+
+  /* Only update sockets for the original Geometry. */
+  if (abc_object->instance_of) {
+    return;
+  }
+
+  Mesh *mesh = static_cast<Mesh *>(object->get_geometry());
+
   /* Cycles overwrites the original triangles when computing displacement, so we always have to
    * repass the data if something is animated (vertices most likely) to avoid buffer overflows. */
   if (!cached_data.is_constant()) {
@@ -1626,10 +1640,10 @@ void AlembicProcedural::read_subd(Scene *scene,
 
   mesh->clear_non_sockets();
 
-  /* Update sockets. */
-
-  Object *object = abc_object->get_object();
-  cached_data.transforms.copy_to_socket(frame_time, object, object->get_tfm_socket());
+  /* Alembic is OpenSubDiv compliant, there is no option to set another subdivision type. */
+  mesh->set_subdivision_type(Mesh::SubdivisionType::SUBDIVISION_CATMULL_CLARK);
+  mesh->set_subd_max_level(abc_object->get_subd_max_level());
+  mesh->set_subd_dicing_rate(abc_object->get_subd_dicing_rate());
 
   cached_data.vertices.copy_to_socket(frame_time, mesh, mesh->get_verts_socket());
 
@@ -1666,7 +1680,7 @@ void AlembicProcedural::read_subd(Scene *scene,
 
   /* we don't yet support arbitrary attributes, for now add vertex
    * coordinates as generated coordinates if requested */
-  if (mesh->need_attribute(scene, ATTR_STD_GENERATED)) {
+  if (mesh->need_attribute(scene_, ATTR_STD_GENERATED)) {
     Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
     memcpy(
         attr->data_float3(), mesh->get_verts().data(), sizeof(float3) * mesh->get_verts().size());
@@ -1680,30 +1694,12 @@ void AlembicProcedural::read_subd(Scene *scene,
                         (mesh->subd_start_corner_is_modified()) ||
                         (mesh->subd_face_corners_is_modified());
 
-    mesh->tag_update(scene, need_rebuild);
+    mesh->tag_update(scene_, need_rebuild);
   }
 }
 
-void AlembicProcedural::read_curves(Scene *scene,
-                                    AlembicObject *abc_object,
-                                    Abc::chrono_t frame_time,
-                                    Progress &progress)
+void AlembicProcedural::read_curves(AlembicObject *abc_object, Abc::chrono_t frame_time)
 {
-  ICurves curves(abc_object->iobject, Alembic::Abc::kWrapExisting);
-  Hair *hair = static_cast<Hair *>(abc_object->get_object()->get_geometry());
-
-  ICurvesSchema schema = curves.getSchema();
-
-  if (!abc_object->has_data_loaded() || default_radius_is_modified() ||
-      abc_object->radius_scale_is_modified()) {
-    abc_object->load_all_data(this, schema, scale, progress, default_radius);
-  }
-  else {
-    if (scale_is_modified()) {
-      abc_object->setup_transform_cache(scale);
-    }
-  }
-
   CachedData &cached_data = abc_object->get_cached_data();
 
   /* update sockets */
@@ -1711,6 +1707,17 @@ void AlembicProcedural::read_curves(Scene *scene,
   Object *object = abc_object->get_object();
   cached_data.transforms.copy_to_socket(frame_time, object, object->get_tfm_socket());
 
+  if (object->is_modified()) {
+    object->tag_update(scene_);
+  }
+
+  /* Only update sockets for the original Geometry. */
+  if (abc_object->instance_of) {
+    return;
+  }
+
+  Hair *hair = static_cast<Hair *>(object->get_geometry());
+
   cached_data.curve_keys.copy_to_socket(frame_time, hair, hair->get_curve_keys_socket());
 
   cached_data.curve_radius.copy_to_socket(frame_time, hair, hair->get_curve_radius_socket());
@@ -1725,7 +1732,7 @@ void AlembicProcedural::read_curves(Scene *scene,
 
   /* we don't yet support arbitrary attributes, for now add first keys as generated coordinates if
    * requested */
-  if (hair->need_attribute(scene, ATTR_STD_GENERATED)) {
+  if (hair->need_attribute(scene_, ATTR_STD_GENERATED)) {
     Attribute *attr_generated = hair->attributes.add(ATTR_STD_GENERATED);
     float3 *generated = attr_generated->data_float3();
 
@@ -1735,13 +1742,13 @@ void AlembicProcedural::read_curves(Scene *scene,
   }
 
   const bool rebuild = (hair->curve_keys_is_modified() || hair->curve_radius_is_modified());
-  hair->tag_update(scene, rebuild);
+  hair->tag_update(scene_, rebuild);
 }
 
 void AlembicProcedural::walk_hierarchy(
     IObject parent,
     const ObjectHeader &header,
-    MatrixSampleMap *xform_samples,
+    MatrixSamplesData matrix_samples_data,
     const unordered_map<std::string, AlembicObject *> &object_map,
     Progress &progress)
 {
@@ -1763,7 +1770,7 @@ void AlembicProcedural::walk_hierarchy(
       MatrixSampleMap local_xform_samples;
 
       MatrixSampleMap *temp_xform_samples = nullptr;
-      if (xform_samples == nullptr) {
+      if (matrix_samples_data.samples == nullptr) {
         /* If there is no parent transforms, fill the map directly. */
         temp_xform_samples = &concatenated_xform_samples;
       }
@@ -1778,11 +1785,13 @@ void AlembicProcedural::walk_hierarchy(
         temp_xform_samples->insert({sample_time, sample.getMatrix()});
       }
 
-      if (xform_samples != nullptr) {
-        concatenate_xform_samples(*xform_samples, local_xform_samples, concatenated_xform_samples);
+      if (matrix_samples_data.samples != nullptr) {
+        concatenate_xform_samples(
+            *matrix_samples_data.samples, local_xform_samples, concatenated_xform_samples);
       }
 
-      xform_samples = &concatenated_xform_samples;
+      matrix_samples_data.samples = &concatenated_xform_samples;
+      matrix_samples_data.time_sampling = ts;
     }
 
     next_object = xform;
@@ -1798,8 +1807,9 @@ void AlembicProcedural::walk_hierarchy(
       abc_object->iobject = subd;
       abc_object->schema_type = AlembicObject::SUBD;
 
-      if (xform_samples) {
-        abc_object->xform_samples = *xform_samples;
+      if (matrix_samples_data.samples) {
+        abc_object->xform_samples = *matrix_samples_data.samples;
+        abc_object->xform_time_sampling = matrix_samples_data.time_sampling;
       }
     }
 
@@ -1816,8 +1826,9 @@ void AlembicProcedural::walk_hierarchy(
       abc_object->iobject = mesh;
       abc_object->schema_type = AlembicObject::POLY_MESH;
 
-      if (xform_samples) {
-        abc_object->xform_samples = *xform_samples;
+      if (matrix_samples_data.samples) {
+        abc_object->xform_samples = *matrix_samples_data.samples;
+        abc_object->xform_time_sampling = matrix_samples_data.time_sampling;
       }
     }
 
@@ -1834,8 +1845,9 @@ void AlembicProcedural::walk_hierarchy(
       abc_object->iobject = curves;
       abc_object->schema_type = AlembicObject::CURVES;
 
-      if (xform_samples) {
-        abc_object->xform_samples = *xform_samples;
+      if (matrix_samples_data.samples) {
+        abc_object->xform_samples = *matrix_samples_data.samples;
+        abc_object->xform_time_sampling = matrix_samples_data.time_sampling;
       }
     }
 
@@ -1844,15 +1856,92 @@ void AlembicProcedural::walk_hierarchy(
   else if (IFaceSet::matches(header)) {
     // ignore the face set, it will be read along with the data
   }
+  else if (IPoints::matches(header)) {
+    // unsupported for now
+  }
+  else if (INuPatch::matches(header)) {
+    // unsupported for now
+  }
   else {
-    // unsupported type for now (Points, NuPatch)
     next_object = parent.getChild(header.getName());
+
+    if (next_object.isInstanceRoot()) {
+      unordered_map<std::string, AlembicObject *>::const_iterator iter;
+
+      /* Was this object asked to be rendered? */
+      iter = object_map.find(next_object.getFullName());
+
+      if (iter != object_map.end()) {
+        AlembicObject *abc_object = iter->second;
+
+        /* Only try to render an instance if the original object is also rendered. */
+        iter = object_map.find(next_object.instanceSourcePath());
+
+        if (iter != object_map.end()) {
+          abc_object->iobject = next_object;
+          abc_object->instance_of = iter->second;
+
+          if (matrix_samples_data.samples) {
+            abc_object->xform_samples = *matrix_samples_data.samples;
+            abc_object->xform_time_sampling = matrix_samples_data.time_sampling;
+          }
+        }
+      }
+    }
   }
 
   if (next_object.valid()) {
     for (size_t i = 0; i < next_object.getNumChildren(); ++i) {
       walk_hierarchy(
-          next_object, next_object.getChildHeader(i), xform_samples, object_map, progress);
+          next_object, next_object.getChildHeader(i), matrix_samples_data, object_map, progress);
+    }
+  }
+}
+
+void AlembicProcedural::build_caches(Progress &progress)
+{
+  for (Node *node : objects) {
+    AlembicObject *object = static_cast<AlembicObject *>(node);
+
+    if (progress.get_cancel()) {
+      return;
+    }
+
+    if (object->schema_type == AlembicObject::POLY_MESH) {
+      if (!object->has_data_loaded()) {
+        IPolyMesh polymesh(object->iobject, Alembic::Abc::kWrapExisting);
+        IPolyMeshSchema schema = polymesh.getSchema();
+        object->load_all_data(this, schema, progress);
+      }
+      else if (object->need_shader_update) {
+        IPolyMesh polymesh(object->iobject, Alembic::Abc::kWrapExisting);
+        IPolyMeshSchema schema = polymesh.getSchema();
+        object->update_shader_attributes(schema.getArbGeomParams(), progress);
+      }
+    }
+    else if (object->schema_type == AlembicObject::CURVES) {
+      if (!object->has_data_loaded() || default_radius_is_modified() ||
+          object->radius_scale_is_modified()) {
+        ICurves curves(object->iobject, Alembic::Abc::kWrapExisting);
+        ICurvesSchema schema = curves.getSchema();
+        object->load_all_data(this, schema, progress, default_radius);
+      }
+    }
+    else if (object->schema_type == AlembicObject::SUBD) {
+      if (!object->has_data_loaded()) {
+        ISubD subd_mesh(object->iobject, Alembic::Abc::kWrapExisting);
+        ISubDSchema schema = subd_mesh.getSchema();
+        object->load_all_data(this, schema, progress);
+      }
+      else if (object->need_shader_update) {
+        ISubD subd_mesh(object->iobject, Alembic::Abc::kWrapExisting);
+        ISubDSchema schema = subd_mesh.getSchema();
+        object->update_shader_attributes(schema.getArbGeomParams(), progress);
+      }
+    }
+
+    if (scale_is_modified() || object->get_cached_data().transforms.size() == 0) {
+      object->setup_transform_cache(scale);
     }
   }
 }

intern/cycles/render/alembic.h

@@ -38,6 +38,11 @@ class Shader;
 
 using MatrixSampleMap = std::map<Alembic::Abc::chrono_t, Alembic::Abc::M44d>;
 
+struct MatrixSamplesData {
+  MatrixSampleMap *samples = nullptr;
+  Alembic::AbcCoreAbstract::TimeSamplingPtr time_sampling;
+};
+
 /* Helpers to detect if some type is a ccl::array. */
 template<typename> struct is_array : public std::false_type {
 };
@@ -45,6 +50,78 @@ template<typename> struct is_array : public std::false_type {
 template<typename T> struct is_array<array<T>> : public std::true_type {
 };
 
+/* Holds the data for a cache lookup at a given time, as well as informations to
+ * help disambiguate successes or failures to get data from the cache. */
+template<typename T> class CacheLookupResult {
+  enum class State {
+    NEW_DATA,
+    ALREADY_LOADED,
+    NO_DATA_FOR_TIME,
+  };
+
+  T *data;
+  State state;
+
+ protected:
+  /* Prevent default construction outside of the class: for a valid result, we
+   * should use the static functions below. */
+  CacheLookupResult() = default;
+
+ public:
+  static CacheLookupResult new_data(T *data_)
+  {
+    CacheLookupResult result;
+    result.data = data_;
+    result.state = State::NEW_DATA;
+    return result;
+  }
+
+  static CacheLookupResult no_data_found_for_time()
+  {
+    CacheLookupResult result;
+    result.data = nullptr;
+    result.state = State::NO_DATA_FOR_TIME;
+    return result;
+  }
+
+  static CacheLookupResult already_loaded()
+  {
+    CacheLookupResult result;
+    result.data = nullptr;
+    result.state = State::ALREADY_LOADED;
+    return result;
+  }
+
+  /* This should only be call if new data is available. */
+  const T &get_data() const
+  {
+    assert(state == State::NEW_DATA);
+    assert(data != nullptr);
+    return *data;
+  }
+
+  T *get_data_or_null() const
+  {
+    // data_ should already be null if there is no new data so no need to check
+    return data;
+  }
+
+  bool has_new_data() const
+  {
+    return state == State::NEW_DATA;
+  }
+
+  bool has_already_loaded() const
+  {
+    return state == State::ALREADY_LOADED;
+  }
+
+  bool has_no_data_for_time() const
+  {
+    return state == State::NO_DATA_FOR_TIME;
+  }
+};
+
 /* Store the data set for an animation at every time points, or at the beginning of the animation
  * for constant data.
  *
@@ -74,10 +151,10 @@ template<typename T> class DataStore {
 
   /* Get the data for the specified time.
    * Return nullptr if there is no data or if the data for this time was already loaded. */
-  T *data_for_time(double time)
+  CacheLookupResult<T> data_for_time(double time)
   {
     if (size() == 0) {
-      return nullptr;
+      return CacheLookupResult<T>::no_data_found_for_time();
     }
 
     std::pair<size_t, Alembic::Abc::chrono_t> index_pair;
@@ -85,26 +162,26 @@ template<typename T> class DataStore {
     DataTimePair &data_pair = data[index_pair.first];
 
     if (last_loaded_time == data_pair.time) {
-      return nullptr;
+      return CacheLookupResult<T>::already_loaded();
     }
 
     last_loaded_time = data_pair.time;
 
-    return &data_pair.data;
+    return CacheLookupResult<T>::new_data(&data_pair.data);
   }
 
   /* get the data for the specified time, but do not check if the data was already loaded for this
    * time return nullptr if there is no data */
-  T *data_for_time_no_check(double time)
+  CacheLookupResult<T> data_for_time_no_check(double time)
   {
     if (size() == 0) {
-      return nullptr;
+      return CacheLookupResult<T>::no_data_found_for_time();
     }
 
     std::pair<size_t, Alembic::Abc::chrono_t> index_pair;
     index_pair = time_sampling.getNearIndex(time, data.size());
     DataTimePair &data_pair = data[index_pair.first];
-    return &data_pair.data;
+    return CacheLookupResult<T>::new_data(&data_pair.data);
   }
 
   void add_data(T &data_, double time)
@@ -144,15 +221,15 @@ template<typename T> class DataStore {
    * data for this time or it was already loaded, do nothing. */
   void copy_to_socket(double time, Node *node, const SocketType *socket)
   {
-    T *data_ = data_for_time(time);
+    CacheLookupResult<T> result = data_for_time(time);
 
-    if (data_ == nullptr) {
+    if (!result.has_new_data()) {
       return;
     }
 
     /* TODO(kevindietrich): arrays are emptied when passed to the sockets, so for now we copy the
      * arrays to avoid reloading the data */
-    T value = *data_;
+    T value = result.get_data();
     node->set(*socket, value);
   }
 };
@@ -249,15 +326,12 @@ class AlembicObject : public Node {
 
   void load_all_data(AlembicProcedural *proc,
                      Alembic::AbcGeom::IPolyMeshSchema &schema,
-                     float scale,
                      Progress &progress);
   void load_all_data(AlembicProcedural *proc,
                      Alembic::AbcGeom::ISubDSchema &schema,
-                     float scale,
                      Progress &progress);
   void load_all_data(AlembicProcedural *proc,
                      const Alembic::AbcGeom::ICurvesSchema &schema,
-                     float scale,
                      Progress &progress,
                      float default_radius);
 
@@ -274,6 +348,9 @@ class AlembicObject : public Node {
 
   bool need_shader_update = true;
 
+  AlembicObject *instance_of = nullptr;
+
+  Alembic::AbcCoreAbstract::TimeSamplingPtr xform_time_sampling;
   MatrixSampleMap xform_samples;
   Alembic::AbcGeom::IObject iobject;
 
@@ -384,30 +461,23 @@ class AlembicProcedural : public Procedural {
    * way for each IObject. */
   void walk_hierarchy(Alembic::AbcGeom::IObject parent,
                       const Alembic::AbcGeom::ObjectHeader &ohead,
-                      MatrixSampleMap *xform_samples,
+                      MatrixSamplesData matrix_samples_data,
                       const unordered_map<string, AlembicObject *> &object_map,
                       Progress &progress);
 
   /* Read the data for an IPolyMesh at the specified frame_time. Creates corresponding Geometry and
    * Object Nodes in the Cycles scene if none exist yet. */
-  void read_mesh(Scene *scene,
-                 AlembicObject *abc_object,
-                 Alembic::AbcGeom::Abc::chrono_t frame_time,
-                 Progress &progress);
+  void read_mesh(AlembicObject *abc_object, Alembic::AbcGeom::Abc::chrono_t frame_time);
 
   /* Read the data for an ICurves at the specified frame_time. Creates corresponding Geometry and
    * Object Nodes in the Cycles scene if none exist yet. */
-  void read_curves(Scene *scene,
-                   AlembicObject *abc_object,
-                   Alembic::AbcGeom::Abc::chrono_t frame_time,
-                   Progress &progress);
+  void read_curves(AlembicObject *abc_object, Alembic::AbcGeom::Abc::chrono_t frame_time);
 
   /* Read the data for an ISubD at the specified frame_time. Creates corresponding Geometry and
    * Object Nodes in the Cycles scene if none exist yet. */
-  void read_subd(Scene *scene,
-                 AlembicObject *abc_object,
-                 Alembic::AbcGeom::Abc::chrono_t frame_time,
-                 Progress &progress);
+  void read_subd(AlembicObject *abc_object, Alembic::AbcGeom::Abc::chrono_t frame_time);
+
+  void build_caches(Progress &progress);
 };
 
 CCL_NAMESPACE_END

intern/cycles/render/background.cpp

@@ -47,12 +47,12 @@ NODE_DEFINE(Background)
 
   SOCKET_FLOAT(volume_step_size, "Volume Step Size", 0.1f);
 
-  SOCKET_NODE(shader, "Shader", &Shader::node_type);
+  SOCKET_NODE(shader, "Shader", Shader::get_node_type());
 
   return type;
 }
 
-Background::Background() : Node(node_type)
+Background::Background() : Node(get_node_type())
 {
   shader = NULL;
 }

intern/cycles/render/camera.cpp

@@ -163,7 +163,7 @@ NODE_DEFINE(Camera)
   return type;
 }
 
-Camera::Camera() : Node(node_type)
+Camera::Camera() : Node(get_node_type())
 {
   shutter_table_offset = TABLE_OFFSET_INVALID;
 

intern/cycles/render/film.cpp

@@ -96,7 +96,7 @@ NODE_DEFINE(Pass)
   return type;
 }
 
-Pass::Pass() : Node(node_type)
+Pass::Pass() : Node(get_node_type())
 {
 }
 
@@ -407,7 +407,7 @@ NODE_DEFINE(Film)
   return type;
 }
 
-Film::Film() : Node(node_type)
+Film::Film() : Node(get_node_type())
 {
   use_light_visibility = false;
   filter_table_offset = TABLE_OFFSET_INVALID;

intern/cycles/render/geometry.cpp

@@ -52,7 +52,7 @@ NODE_ABSTRACT_DEFINE(Geometry)
 
   SOCKET_UINT(motion_steps, "Motion Steps", 3);
   SOCKET_BOOLEAN(use_motion_blur, "Use Motion Blur", false);
-  SOCKET_NODE_ARRAY(used_shaders, "Shaders", &Shader::node_type);
+  SOCKET_NODE_ARRAY(used_shaders, "Shaders", Shader::get_node_type());
 
   return type;
 }
@@ -1367,7 +1367,7 @@ void GeometryManager::device_update_bvh(Device *device,
   dscene->data.bvh.use_bvh_steps = (scene->params.num_bvh_time_steps != 0);
   dscene->data.bvh.curve_subdivisions = scene->params.curve_subdivisions();
   /* The scene handle is set in 'CPUDevice::const_copy_to' and 'OptiXDevice::const_copy_to' */
-  dscene->data.bvh.scene = NULL;
+  dscene->data.bvh.scene = 0;
 }
 
 /* Set of flags used to help determining what data has been modified or needs reallocation, so we

intern/cycles/render/hair.cpp

@@ -283,7 +283,7 @@ void Hair::Curve::cardinal_keys_for_step(const float3 *curve_keys,
 
 NODE_DEFINE(Hair)
 {
-  NodeType *type = NodeType::add("hair", create, NodeType::NONE, Geometry::node_base_type);
+  NodeType *type = NodeType::add("hair", create, NodeType::NONE, Geometry::get_node_base_type());
 
   SOCKET_POINT_ARRAY(curve_keys, "Curve Keys", array<float3>());
   SOCKET_FLOAT_ARRAY(curve_radius, "Curve Radius", array<float>());
@@ -293,7 +293,7 @@ NODE_DEFINE(Hair)
   return type;
 }
 
-Hair::Hair() : Geometry(node_type, Geometry::HAIR)
+Hair::Hair() : Geometry(get_node_type(), Geometry::HAIR)
 {
   curvekey_offset = 0;
   curve_shape = CURVE_RIBBON;

intern/cycles/render/integrator.cpp

@@ -96,7 +96,7 @@ NODE_DEFINE(Integrator)
   return type;
 }
 
-Integrator::Integrator() : Node(node_type)
+Integrator::Integrator() : Node(get_node_type())
 {
 }
 

intern/cycles/render/light.cpp

@@ -151,12 +151,12 @@ NODE_DEFINE(Light)
   SOCKET_BOOLEAN(is_portal, "Is Portal", false);
   SOCKET_BOOLEAN(is_enabled, "Is Enabled", true);
 
-  SOCKET_NODE(shader, "Shader", &Shader::node_type);
+  SOCKET_NODE(shader, "Shader", Shader::get_node_type());
 
   return type;
 }
 
-Light::Light() : Node(node_type)
+Light::Light() : Node(get_node_type())
 {
 }
 
@@ -609,7 +609,7 @@ void LightManager::device_update_background(Device *device,
   Shader *shader = scene->background->get_shader(scene);
   int num_suns = 0;
   foreach (ShaderNode *node, shader->graph->nodes) {
-    if (node->type == EnvironmentTextureNode::node_type) {
+    if (node->type == EnvironmentTextureNode::get_node_type()) {
       EnvironmentTextureNode *env = (EnvironmentTextureNode *)node;
       ImageMetaData metadata;
       if (!env->handle.empty()) {
@@ -618,7 +618,7 @@ void LightManager::device_update_background(Device *device,
         environment_res.y = max(environment_res.y, metadata.height);
       }
     }
-    if (node->type == SkyTextureNode::node_type) {
+    if (node->type == SkyTextureNode::get_node_type()) {
       SkyTextureNode *sky = (SkyTextureNode *)node;
       if (sky->get_sky_type() == NODE_SKY_NISHITA && sky->get_sun_disc()) {
         /* Ensure that the input coordinates aren't transformed before they reach the node.
@@ -627,7 +627,7 @@ void LightManager::device_update_background(Device *device,
         const ShaderInput *vec_in = sky->input("Vector");
         if (vec_in && vec_in->link && vec_in->link->parent) {
           ShaderNode *vec_src = vec_in->link->parent;
-          if ((vec_src->type != TextureCoordinateNode::node_type) ||
+          if ((vec_src->type != TextureCoordinateNode::get_node_type()) ||
               (vec_in->link != vec_src->output("Generated"))) {
             environment_res.x = max(environment_res.x, 4096);
             environment_res.y = max(environment_res.y, 2048);

intern/cycles/render/mesh.cpp

@@ -125,7 +125,7 @@ float3 Mesh::SubdFace::normal(const Mesh *mesh) const
 
 NODE_DEFINE(Mesh)
 {
-  NodeType *type = NodeType::add("mesh", create, NodeType::NONE, Geometry::node_base_type);
+  NodeType *type = NodeType::add("mesh", create, NodeType::NONE, Geometry::get_node_base_type());
 
   SOCKET_INT_ARRAY(triangles, "Triangles", array<int>());
   SOCKET_POINT_ARRAY(verts, "Vertices", array<float3>());
@@ -202,7 +202,7 @@ Mesh::Mesh(const NodeType *node_type, Type geom_type_)
   patch_table = NULL;
 }
 
-Mesh::Mesh() : Mesh(node_type, Geometry::MESH)
+Mesh::Mesh() : Mesh(get_node_type(), Geometry::MESH)
 {
 }
 

intern/cycles/render/nodes.cpp

@@ -258,7 +258,7 @@ NODE_DEFINE(ImageTextureNode)
   return type;
 }
 
-ImageTextureNode::ImageTextureNode() : ImageSlotTextureNode(node_type)
+ImageTextureNode::ImageTextureNode() : ImageSlotTextureNode(get_node_type())
 {
   colorspace = u_colorspace_raw;
   animated = false;
@@ -309,11 +309,11 @@ void ImageTextureNode::cull_tiles(Scene *scene, ShaderGraph *graph)
   ustring attribute;
   if (vector_in->link) {
     ShaderNode *node = vector_in->link->parent;
-    if (node->type == UVMapNode::node_type) {
+    if (node->type == UVMapNode::get_node_type()) {
       UVMapNode *uvmap = (UVMapNode *)node;
       attribute = uvmap->get_attribute();
     }
-    else if (node->type == TextureCoordinateNode::node_type) {
+    else if (node->type == TextureCoordinateNode::get_node_type()) {
       if (vector_in->link != node->output("UV")) {
         return;
       }
@@ -525,7 +525,7 @@ NODE_DEFINE(EnvironmentTextureNode)
   return type;
 }
 
-EnvironmentTextureNode::EnvironmentTextureNode() : ImageSlotTextureNode(node_type)
+EnvironmentTextureNode::EnvironmentTextureNode() : ImageSlotTextureNode(get_node_type())
 {
   colorspace = u_colorspace_raw;
   animated = false;
@@ -818,7 +818,7 @@ NODE_DEFINE(SkyTextureNode)
   return type;
 }
 
-SkyTextureNode::SkyTextureNode() : TextureNode(node_type)
+SkyTextureNode::SkyTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1000,7 +1000,7 @@ NODE_DEFINE(GradientTextureNode)
   return type;
 }
 
-GradientTextureNode::GradientTextureNode() : TextureNode(node_type)
+GradientTextureNode::GradientTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1057,7 +1057,7 @@ NODE_DEFINE(NoiseTextureNode)
   return type;
 }
 
-NoiseTextureNode::NoiseTextureNode() : TextureNode(node_type)
+NoiseTextureNode::NoiseTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1150,7 +1150,7 @@ NODE_DEFINE(VoronoiTextureNode)
   return type;
 }
 
-VoronoiTextureNode::VoronoiTextureNode() : TextureNode(node_type)
+VoronoiTextureNode::VoronoiTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1229,7 +1229,7 @@ NODE_DEFINE(IESLightNode)
   return type;
 }
 
-IESLightNode::IESLightNode() : TextureNode(node_type)
+IESLightNode::IESLightNode() : TextureNode(get_node_type())
 {
   light_manager = NULL;
   slot = -1;
@@ -1321,7 +1321,7 @@ NODE_DEFINE(WhiteNoiseTextureNode)
   return type;
 }
 
-WhiteNoiseTextureNode::WhiteNoiseTextureNode() : ShaderNode(node_type)
+WhiteNoiseTextureNode::WhiteNoiseTextureNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -1386,7 +1386,7 @@ NODE_DEFINE(MusgraveTextureNode)
   return type;
 }
 
-MusgraveTextureNode::MusgraveTextureNode() : TextureNode(node_type)
+MusgraveTextureNode::MusgraveTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1484,7 +1484,7 @@ NODE_DEFINE(WaveTextureNode)
   return type;
 }
 
-WaveTextureNode::WaveTextureNode() : TextureNode(node_type)
+WaveTextureNode::WaveTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1558,7 +1558,7 @@ NODE_DEFINE(MagicTextureNode)
   return type;
 }
 
-MagicTextureNode::MagicTextureNode() : TextureNode(node_type)
+MagicTextureNode::MagicTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1611,7 +1611,7 @@ NODE_DEFINE(CheckerTextureNode)
   return type;
 }
 
-CheckerTextureNode::CheckerTextureNode() : TextureNode(node_type)
+CheckerTextureNode::CheckerTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1677,7 +1677,7 @@ NODE_DEFINE(BrickTextureNode)
   return type;
 }
 
-BrickTextureNode::BrickTextureNode() : TextureNode(node_type)
+BrickTextureNode::BrickTextureNode() : TextureNode(get_node_type())
 {
 }
 
@@ -1770,7 +1770,7 @@ NODE_DEFINE(PointDensityTextureNode)
   return type;
 }
 
-PointDensityTextureNode::PointDensityTextureNode() : ShaderNode(node_type)
+PointDensityTextureNode::PointDensityTextureNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -1887,7 +1887,7 @@ NODE_DEFINE(NormalNode)
   return type;
 }
 
-NormalNode::NormalNode() : ShaderNode(node_type)
+NormalNode::NormalNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -1934,7 +1934,7 @@ NODE_DEFINE(MappingNode)
   return type;
 }
 
-MappingNode::MappingNode() : ShaderNode(node_type)
+MappingNode::MappingNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -1989,7 +1989,7 @@ NODE_DEFINE(RGBToBWNode)
   return type;
 }
 
-RGBToBWNode::RGBToBWNode() : ShaderNode(node_type)
+RGBToBWNode::RGBToBWNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -2312,7 +2312,7 @@ NODE_DEFINE(AnisotropicBsdfNode)
   return type;
 }
 
-AnisotropicBsdfNode::AnisotropicBsdfNode() : BsdfNode(node_type)
+AnisotropicBsdfNode::AnisotropicBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_MICROFACET_GGX_ID;
 }
@@ -2370,7 +2370,7 @@ NODE_DEFINE(GlossyBsdfNode)
   return type;
 }
 
-GlossyBsdfNode::GlossyBsdfNode() : BsdfNode(node_type)
+GlossyBsdfNode::GlossyBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_MICROFACET_GGX_ID;
   distribution_orig = NBUILTIN_CLOSURES;
@@ -2463,7 +2463,7 @@ NODE_DEFINE(GlassBsdfNode)
   return type;
 }
 
-GlassBsdfNode::GlassBsdfNode() : BsdfNode(node_type)
+GlassBsdfNode::GlassBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_SHARP_GLASS_ID;
   distribution_orig = NBUILTIN_CLOSURES;
@@ -2556,7 +2556,7 @@ NODE_DEFINE(RefractionBsdfNode)
   return type;
 }
 
-RefractionBsdfNode::RefractionBsdfNode() : BsdfNode(node_type)
+RefractionBsdfNode::RefractionBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_REFRACTION_ID;
   distribution_orig = NBUILTIN_CLOSURES;
@@ -2644,7 +2644,7 @@ NODE_DEFINE(ToonBsdfNode)
   return type;
 }
 
-ToonBsdfNode::ToonBsdfNode() : BsdfNode(node_type)
+ToonBsdfNode::ToonBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_DIFFUSE_TOON_ID;
 }
@@ -2678,7 +2678,7 @@ NODE_DEFINE(VelvetBsdfNode)
   return type;
 }
 
-VelvetBsdfNode::VelvetBsdfNode() : BsdfNode(node_type)
+VelvetBsdfNode::VelvetBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_ASHIKHMIN_VELVET_ID;
 }
@@ -2709,7 +2709,7 @@ NODE_DEFINE(DiffuseBsdfNode)
   return type;
 }
 
-DiffuseBsdfNode::DiffuseBsdfNode() : BsdfNode(node_type)
+DiffuseBsdfNode::DiffuseBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_DIFFUSE_ID;
 }
@@ -2773,7 +2773,7 @@ NODE_DEFINE(PrincipledBsdfNode)
   return type;
 }
 
-PrincipledBsdfNode::PrincipledBsdfNode() : BsdfBaseNode(node_type)
+PrincipledBsdfNode::PrincipledBsdfNode() : BsdfBaseNode(get_node_type())
 {
   closure = CLOSURE_BSDF_PRINCIPLED_ID;
   distribution = CLOSURE_BSDF_MICROFACET_MULTI_GGX_GLASS_ID;
@@ -2994,7 +2994,7 @@ NODE_DEFINE(TranslucentBsdfNode)
   return type;
 }
 
-TranslucentBsdfNode::TranslucentBsdfNode() : BsdfNode(node_type)
+TranslucentBsdfNode::TranslucentBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_TRANSLUCENT_ID;
 }
@@ -3023,7 +3023,7 @@ NODE_DEFINE(TransparentBsdfNode)
   return type;
 }
 
-TransparentBsdfNode::TransparentBsdfNode() : BsdfNode(node_type)
+TransparentBsdfNode::TransparentBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_TRANSPARENT_ID;
 }
@@ -3064,7 +3064,7 @@ NODE_DEFINE(SubsurfaceScatteringNode)
   return type;
 }
 
-SubsurfaceScatteringNode::SubsurfaceScatteringNode() : BsdfNode(node_type)
+SubsurfaceScatteringNode::SubsurfaceScatteringNode() : BsdfNode(get_node_type())
 {
   closure = falloff;
 }
@@ -3106,7 +3106,7 @@ NODE_DEFINE(EmissionNode)
   return type;
 }
 
-EmissionNode::EmissionNode() : ShaderNode(node_type)
+EmissionNode::EmissionNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -3155,7 +3155,7 @@ NODE_DEFINE(BackgroundNode)
   return type;
 }
 
-BackgroundNode::BackgroundNode() : ShaderNode(node_type)
+BackgroundNode::BackgroundNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -3203,7 +3203,7 @@ NODE_DEFINE(HoldoutNode)
   return type;
 }
 
-HoldoutNode::HoldoutNode() : ShaderNode(node_type)
+HoldoutNode::HoldoutNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -3241,7 +3241,7 @@ NODE_DEFINE(AmbientOcclusionNode)
   return type;
 }
 
-AmbientOcclusionNode::AmbientOcclusionNode() : ShaderNode(node_type)
+AmbientOcclusionNode::AmbientOcclusionNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -3329,7 +3329,7 @@ NODE_DEFINE(AbsorptionVolumeNode)
   return type;
 }
 
-AbsorptionVolumeNode::AbsorptionVolumeNode() : VolumeNode(node_type)
+AbsorptionVolumeNode::AbsorptionVolumeNode() : VolumeNode(get_node_type())
 {
   closure = CLOSURE_VOLUME_ABSORPTION_ID;
 }
@@ -3360,7 +3360,7 @@ NODE_DEFINE(ScatterVolumeNode)
   return type;
 }
 
-ScatterVolumeNode::ScatterVolumeNode() : VolumeNode(node_type)
+ScatterVolumeNode::ScatterVolumeNode() : VolumeNode(get_node_type())
 {
   closure = CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID;
 }
@@ -3401,7 +3401,7 @@ NODE_DEFINE(PrincipledVolumeNode)
   return type;
 }
 
-PrincipledVolumeNode::PrincipledVolumeNode() : VolumeNode(node_type)
+PrincipledVolumeNode::PrincipledVolumeNode() : VolumeNode(get_node_type())
 {
   closure = CLOSURE_VOLUME_HENYEY_GREENSTEIN_ID;
   density_attribute = ustring("density");
@@ -3526,7 +3526,7 @@ NODE_DEFINE(PrincipledHairBsdfNode)
   return type;
 }
 
-PrincipledHairBsdfNode::PrincipledHairBsdfNode() : BsdfBaseNode(node_type)
+PrincipledHairBsdfNode::PrincipledHairBsdfNode() : BsdfBaseNode(get_node_type())
 {
   closure = CLOSURE_BSDF_HAIR_PRINCIPLED_ID;
 }
@@ -3637,7 +3637,7 @@ NODE_DEFINE(HairBsdfNode)
   return type;
 }
 
-HairBsdfNode::HairBsdfNode() : BsdfNode(node_type)
+HairBsdfNode::HairBsdfNode() : BsdfNode(get_node_type())
 {
   closure = CLOSURE_BSDF_HAIR_REFLECTION_ID;
 }
@@ -3677,7 +3677,7 @@ NODE_DEFINE(GeometryNode)
   return type;
 }
 
-GeometryNode::GeometryNode() : ShaderNode(node_type)
+GeometryNode::GeometryNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_GEOMETRY;
 }
@@ -3824,7 +3824,7 @@ NODE_DEFINE(TextureCoordinateNode)
   return type;
 }
 
-TextureCoordinateNode::TextureCoordinateNode() : ShaderNode(node_type)
+TextureCoordinateNode::TextureCoordinateNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -3971,7 +3971,7 @@ NODE_DEFINE(UVMapNode)
   return type;
 }
 
-UVMapNode::UVMapNode() : ShaderNode(node_type)
+UVMapNode::UVMapNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4060,7 +4060,7 @@ NODE_DEFINE(LightPathNode)
   return type;
 }
 
-LightPathNode::LightPathNode() : ShaderNode(node_type)
+LightPathNode::LightPathNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4160,7 +4160,7 @@ NODE_DEFINE(LightFalloffNode)
   return type;
 }
 
-LightFalloffNode::LightFalloffNode() : ShaderNode(node_type)
+LightFalloffNode::LightFalloffNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4217,7 +4217,7 @@ NODE_DEFINE(ObjectInfoNode)
   return type;
 }
 
-ObjectInfoNode::ObjectInfoNode() : ShaderNode(node_type)
+ObjectInfoNode::ObjectInfoNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4275,7 +4275,7 @@ NODE_DEFINE(ParticleInfoNode)
   return type;
 }
 
-ParticleInfoNode::ParticleInfoNode() : ShaderNode(node_type)
+ParticleInfoNode::ParticleInfoNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4382,7 +4382,7 @@ NODE_DEFINE(HairInfoNode)
   return type;
 }
 
-HairInfoNode::HairInfoNode() : ShaderNode(node_type)
+HairInfoNode::HairInfoNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4457,7 +4457,7 @@ NODE_DEFINE(VolumeInfoNode)
   return type;
 }
 
-VolumeInfoNode::VolumeInfoNode() : ShaderNode(node_type)
+VolumeInfoNode::VolumeInfoNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4538,7 +4538,7 @@ NODE_DEFINE(VertexColorNode)
   return type;
 }
 
-VertexColorNode::VertexColorNode() : ShaderNode(node_type)
+VertexColorNode::VertexColorNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4619,7 +4619,7 @@ NODE_DEFINE(ValueNode)
   return type;
 }
 
-ValueNode::ValueNode() : ShaderNode(node_type)
+ValueNode::ValueNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4653,7 +4653,7 @@ NODE_DEFINE(ColorNode)
   return type;
 }
 
-ColorNode::ColorNode() : ShaderNode(node_type)
+ColorNode::ColorNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4692,7 +4692,7 @@ NODE_DEFINE(AddClosureNode)
   return type;
 }
 
-AddClosureNode::AddClosureNode() : ShaderNode(node_type)
+AddClosureNode::AddClosureNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_COMBINE_CLOSURE;
 }
@@ -4736,7 +4736,7 @@ NODE_DEFINE(MixClosureNode)
   return type;
 }
 
-MixClosureNode::MixClosureNode() : ShaderNode(node_type)
+MixClosureNode::MixClosureNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_COMBINE_CLOSURE;
 }
@@ -4790,7 +4790,7 @@ NODE_DEFINE(MixClosureWeightNode)
   return type;
 }
 
-MixClosureWeightNode::MixClosureWeightNode() : ShaderNode(node_type)
+MixClosureWeightNode::MixClosureWeightNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4827,7 +4827,7 @@ NODE_DEFINE(InvertNode)
   return type;
 }
 
-InvertNode::InvertNode() : ShaderNode(node_type)
+InvertNode::InvertNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4903,7 +4903,7 @@ NODE_DEFINE(MixNode)
   return type;
 }
 
-MixNode::MixNode() : ShaderNode(node_type)
+MixNode::MixNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -4958,7 +4958,7 @@ NODE_DEFINE(CombineRGBNode)
   return type;
 }
 
-CombineRGBNode::CombineRGBNode() : ShaderNode(node_type)
+CombineRGBNode::CombineRGBNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5006,7 +5006,7 @@ NODE_DEFINE(CombineXYZNode)
   return type;
 }
 
-CombineXYZNode::CombineXYZNode() : ShaderNode(node_type)
+CombineXYZNode::CombineXYZNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5054,7 +5054,7 @@ NODE_DEFINE(CombineHSVNode)
   return type;
 }
 
-CombineHSVNode::CombineHSVNode() : ShaderNode(node_type)
+CombineHSVNode::CombineHSVNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5097,7 +5097,7 @@ NODE_DEFINE(GammaNode)
   return type;
 }
 
-GammaNode::GammaNode() : ShaderNode(node_type)
+GammaNode::GammaNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5153,7 +5153,7 @@ NODE_DEFINE(BrightContrastNode)
   return type;
 }
 
-BrightContrastNode::BrightContrastNode() : ShaderNode(node_type)
+BrightContrastNode::BrightContrastNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5198,7 +5198,7 @@ NODE_DEFINE(SeparateRGBNode)
   return type;
 }
 
-SeparateRGBNode::SeparateRGBNode() : ShaderNode(node_type)
+SeparateRGBNode::SeparateRGBNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5251,7 +5251,7 @@ NODE_DEFINE(SeparateXYZNode)
   return type;
 }
 
-SeparateXYZNode::SeparateXYZNode() : ShaderNode(node_type)
+SeparateXYZNode::SeparateXYZNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5304,7 +5304,7 @@ NODE_DEFINE(SeparateHSVNode)
   return type;
 }
 
-SeparateHSVNode::SeparateHSVNode() : ShaderNode(node_type)
+SeparateHSVNode::SeparateHSVNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5358,7 +5358,7 @@ NODE_DEFINE(HSVNode)
   return type;
 }
 
-HSVNode::HSVNode() : ShaderNode(node_type)
+HSVNode::HSVNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5401,7 +5401,7 @@ NODE_DEFINE(AttributeNode)
   return type;
 }
 
-AttributeNode::AttributeNode() : ShaderNode(node_type)
+AttributeNode::AttributeNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5489,7 +5489,7 @@ NODE_DEFINE(CameraNode)
   return type;
 }
 
-CameraNode::CameraNode() : ShaderNode(node_type)
+CameraNode::CameraNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5525,7 +5525,7 @@ NODE_DEFINE(FresnelNode)
   return type;
 }
 
-FresnelNode::FresnelNode() : ShaderNode(node_type)
+FresnelNode::FresnelNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5563,7 +5563,7 @@ NODE_DEFINE(LayerWeightNode)
   return type;
 }
 
-LayerWeightNode::LayerWeightNode() : ShaderNode(node_type)
+LayerWeightNode::LayerWeightNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5611,7 +5611,7 @@ NODE_DEFINE(WireframeNode)
   return type;
 }
 
-WireframeNode::WireframeNode() : ShaderNode(node_type)
+WireframeNode::WireframeNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5659,7 +5659,7 @@ NODE_DEFINE(WavelengthNode)
   return type;
 }
 
-WavelengthNode::WavelengthNode() : ShaderNode(node_type)
+WavelengthNode::WavelengthNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5689,7 +5689,7 @@ NODE_DEFINE(BlackbodyNode)
   return type;
 }
 
-BlackbodyNode::BlackbodyNode() : ShaderNode(node_type)
+BlackbodyNode::BlackbodyNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5728,7 +5728,7 @@ NODE_DEFINE(OutputNode)
   return type;
 }
 
-OutputNode::OutputNode() : ShaderNode(node_type)
+OutputNode::OutputNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_OUTPUT;
 }
@@ -5780,7 +5780,7 @@ NODE_DEFINE(MapRangeNode)
   return type;
 }
 
-MapRangeNode::MapRangeNode() : ShaderNode(node_type)
+MapRangeNode::MapRangeNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5868,7 +5868,7 @@ NODE_DEFINE(ClampNode)
   return type;
 }
 
-ClampNode::ClampNode() : ShaderNode(node_type)
+ClampNode::ClampNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -5923,7 +5923,7 @@ NODE_DEFINE(OutputAOVNode)
   return type;
 }
 
-OutputAOVNode::OutputAOVNode() : ShaderNode(node_type)
+OutputAOVNode::OutputAOVNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_OUTPUT_AOV;
   slot = -1;
@@ -6021,7 +6021,7 @@ NODE_DEFINE(MathNode)
   return type;
 }
 
-MathNode::MathNode() : ShaderNode(node_type)
+MathNode::MathNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6124,7 +6124,7 @@ NODE_DEFINE(VectorMathNode)
   return type;
 }
 
-VectorMathNode::VectorMathNode() : ShaderNode(node_type)
+VectorMathNode::VectorMathNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6213,7 +6213,7 @@ NODE_DEFINE(VectorRotateNode)
   return type;
 }
 
-VectorRotateNode::VectorRotateNode() : ShaderNode(node_type)
+VectorRotateNode::VectorRotateNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6269,7 +6269,7 @@ NODE_DEFINE(VectorTransformNode)
   return type;
 }
 
-VectorTransformNode::VectorTransformNode() : ShaderNode(node_type)
+VectorTransformNode::VectorTransformNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6317,7 +6317,7 @@ NODE_DEFINE(BumpNode)
   return type;
 }
 
-BumpNode::BumpNode() : ShaderNode(node_type)
+BumpNode::BumpNode() : ShaderNode(get_node_type())
 {
   special_type = SHADER_SPECIAL_TYPE_BUMP;
 }
@@ -6464,7 +6464,7 @@ NODE_DEFINE(RGBCurvesNode)
   return type;
 }
 
-RGBCurvesNode::RGBCurvesNode() : CurvesNode(node_type)
+RGBCurvesNode::RGBCurvesNode() : CurvesNode(get_node_type())
 {
 }
 
@@ -6501,7 +6501,7 @@ NODE_DEFINE(VectorCurvesNode)
   return type;
 }
 
-VectorCurvesNode::VectorCurvesNode() : CurvesNode(node_type)
+VectorCurvesNode::VectorCurvesNode() : CurvesNode(get_node_type())
 {
 }
 
@@ -6538,7 +6538,7 @@ NODE_DEFINE(RGBRampNode)
   return type;
 }
 
-RGBRampNode::RGBRampNode() : ShaderNode(node_type)
+RGBRampNode::RGBRampNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6611,7 +6611,7 @@ NODE_DEFINE(SetNormalNode)
   return type;
 }
 
-SetNormalNode::SetNormalNode() : ShaderNode(node_type)
+SetNormalNode::SetNormalNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6733,7 +6733,7 @@ NODE_DEFINE(NormalMapNode)
   return type;
 }
 
-NormalMapNode::NormalMapNode() : ShaderNode(node_type)
+NormalMapNode::NormalMapNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6827,7 +6827,7 @@ NODE_DEFINE(TangentNode)
   return type;
 }
 
-TangentNode::TangentNode() : ShaderNode(node_type)
+TangentNode::TangentNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6897,7 +6897,7 @@ NODE_DEFINE(BevelNode)
   return type;
 }
 
-BevelNode::BevelNode() : ShaderNode(node_type)
+BevelNode::BevelNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -6942,7 +6942,7 @@ NODE_DEFINE(DisplacementNode)
   return type;
 }
 
-DisplacementNode::DisplacementNode() : ShaderNode(node_type)
+DisplacementNode::DisplacementNode() : ShaderNode(get_node_type())
 {
 }
 
@@ -7001,7 +7001,7 @@ NODE_DEFINE(VectorDisplacementNode)
   return type;
 }
 
-VectorDisplacementNode::VectorDisplacementNode() : ShaderNode(node_type)
+VectorDisplacementNode::VectorDisplacementNode() : ShaderNode(get_node_type())
 {
 }
 

intern/cycles/render/object.cpp

@@ -82,7 +82,7 @@ NODE_DEFINE(Object)
 {
   NodeType *type = NodeType::add("object", create);
 
-  SOCKET_NODE(geometry, "Geometry", &Geometry::node_base_type);
+  SOCKET_NODE(geometry, "Geometry", Geometry::get_node_base_type());
   SOCKET_TRANSFORM(tfm, "Transform", transform_identity());
   SOCKET_UINT(visibility, "Visibility", ~0);
   SOCKET_COLOR(color, "Color", zero_float3());
@@ -98,13 +98,13 @@ NODE_DEFINE(Object)
 
   SOCKET_BOOLEAN(is_shadow_catcher, "Shadow Catcher", false);
 
-  SOCKET_NODE(particle_system, "Particle System", &ParticleSystem::node_type);
+  SOCKET_NODE(particle_system, "Particle System", ParticleSystem::get_node_type());
   SOCKET_INT(particle_index, "Particle Index", 0);
 
   return type;
 }
 
-Object::Object() : Node(node_type)
+Object::Object() : Node(get_node_type())
 {
   particle_system = NULL;
   particle_index = 0;

intern/cycles/render/particles.cpp

@@ -36,7 +36,7 @@ NODE_DEFINE(ParticleSystem)
   return type;
 }
 
-ParticleSystem::ParticleSystem() : Node(node_type)
+ParticleSystem::ParticleSystem() : Node(get_node_type())
 {
 }
 

intern/cycles/render/scene.cpp

@@ -91,6 +91,7 @@ DeviceScene::DeviceScene(Device *device)
 
 Scene::Scene(const SceneParams &params_, Device *device)
     : name("Scene"),
+      bvh(NULL),
       default_surface(NULL),
       default_volume(NULL),
       default_light(NULL),
@@ -99,37 +100,36 @@ Scene::Scene(const SceneParams &params_, Device *device)
       device(device),
       dscene(device),
       params(params_),
-      update_stats(NULL)
+      update_stats(NULL),
+      kernels_loaded(false),
+      /* TODO(sergey): Check if it's indeed optimal value for the split kernel. */
+      max_closure_global(1)
 {
   memset((void *)&dscene.data, 0, sizeof(dscene.data));
 
-  bvh = NULL;
-  camera = create_node<Camera>();
-  dicing_camera = create_node<Camera>();
-  lookup_tables = new LookupTables();
-  film = create_node<Film>();
-  background = create_node<Background>();
-  light_manager = new LightManager();
-  geometry_manager = new GeometryManager();
-  object_manager = new ObjectManager();
-  integrator = create_node<Integrator>();
-  image_manager = new ImageManager(device->info);
-  particle_system_manager = new ParticleSystemManager();
-  bake_manager = new BakeManager();
-  procedural_manager = new ProceduralManager();
-  kernels_loaded = false;
-
-  /* TODO(sergey): Check if it's indeed optimal value for the split kernel. */
-  max_closure_global = 1;
-
-  film->add_default(this);
-
   /* OSL only works on the CPU */
   if (device->info.has_osl)
     shader_manager = ShaderManager::create(params.shadingsystem);
   else
     shader_manager = ShaderManager::create(SHADINGSYSTEM_SVM);
 
+  light_manager = new LightManager();
+  geometry_manager = new GeometryManager();
+  object_manager = new ObjectManager();
+  image_manager = new ImageManager(device->info);
+  particle_system_manager = new ParticleSystemManager();
+  bake_manager = new BakeManager();
+  procedural_manager = new ProceduralManager();
+
+  /* Create nodes after managers, since create_node() can tag the managers. */
+  camera = create_node<Camera>();
+  dicing_camera = create_node<Camera>();
+  lookup_tables = new LookupTables();
+  film = create_node<Film>();
+  background = create_node<Background>();
+  integrator = create_node<Integrator>();
+
+  film->add_default(this);
   shader_manager->add_default(this);
 }
 

intern/cycles/render/shader.cpp

@@ -194,7 +194,7 @@ NODE_DEFINE(Shader)
   return type;
 }
 
-Shader::Shader() : Node(node_type)
+Shader::Shader() : Node(get_node_type())
 {
   pass_id = 0;
 
@@ -245,7 +245,7 @@ bool Shader::is_constant_emission(float3 *emission)
     return false;
   }
 
-  if (surf->link->parent->type == EmissionNode::node_type) {
+  if (surf->link->parent->type == EmissionNode::get_node_type()) {
     EmissionNode *node = (EmissionNode *)surf->link->parent;
 
     assert(node->input("Color"));
@@ -257,7 +257,7 @@ bool Shader::is_constant_emission(float3 *emission)
 
     *emission = node->get_color() * node->get_strength();
   }
-  else if (surf->link->parent->type == BackgroundNode::node_type) {
+  else if (surf->link->parent->type == BackgroundNode::get_node_type()) {
     BackgroundNode *node = (BackgroundNode *)surf->link->parent;
 
     assert(node->input("Color"));
@@ -831,7 +831,8 @@ static bool to_scene_linear_transform(OCIO::ConstConfigRcPtr &config,
 
 void ShaderManager::init_xyz_transforms()
 {
-  /* Default to ITU-BT.709 in case no appropriate transform found. */
+  /* Default to ITU-BT.709 in case no appropriate transform found.
+   * Note XYZ here is defined as having a D65 white point. */
   xyz_to_r = make_float3(3.2404542f, -1.5371385f, -0.4985314f);
   xyz_to_g = make_float3(-0.9692660f, 1.8760108f, 0.0415560f);
   xyz_to_b = make_float3(0.0556434f, -0.2040259f, 1.0572252f);
@@ -848,24 +849,27 @@ void ShaderManager::init_xyz_transforms()
 
   if (config->hasRole("aces_interchange")) {
     /* Standard OpenColorIO role, defined as ACES2065-1. */
-    const Transform xyz_to_aces = make_transform(1.0498110175f,
-                                                 0.0f,
-                                                 -0.0000974845f,
-                                                 0.0f,
-                                                 -0.4959030231f,
-                                                 1.3733130458f,
-                                                 0.0982400361f,
-                                                 0.0f,
-                                                 0.0f,
-                                                 0.0f,
-                                                 0.9912520182f,
-                                                 0.0f);
+    const Transform xyz_E_to_aces = make_transform(1.0498110175f,
+                                                   0.0f,
+                                                   -0.0000974845f,
+                                                   0.0f,
+                                                   -0.4959030231f,
+                                                   1.3733130458f,
+                                                   0.0982400361f,
+                                                   0.0f,
+                                                   0.0f,
+                                                   0.0f,
+                                                   0.9912520182f,
+                                                   0.0f);
+    const Transform xyz_D65_to_E = make_transform(
+        1.0521111f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.9184170f, 0.0f);
+
     Transform aces_to_rgb;
     if (!to_scene_linear_transform(config, "aces_interchange", aces_to_rgb)) {
       return;
     }
 
-    xyz_to_rgb = aces_to_rgb * xyz_to_aces;
+    xyz_to_rgb = aces_to_rgb * xyz_E_to_aces * xyz_D65_to_E;
   }
   else if (config->hasRole("XYZ")) {
     /* Custom role used before the standard existed. */

intern/cycles/render/volume.cpp

@@ -36,7 +36,7 @@ CCL_NAMESPACE_BEGIN
 
 NODE_DEFINE(Volume)
 {
-  NodeType *type = NodeType::add("volume", create, NodeType::NONE, Mesh::node_type);
+  NodeType *type = NodeType::add("volume", create, NodeType::NONE, Mesh::get_node_type());
 
   SOCKET_FLOAT(clipping, "Clipping", 0.001f);
   SOCKET_FLOAT(step_size, "Step Size", 0.0f);
@@ -45,7 +45,7 @@ NODE_DEFINE(Volume)
   return type;
 }
 
-Volume::Volume() : Mesh(node_type, Geometry::VOLUME)
+Volume::Volume() : Mesh(get_node_type(), Geometry::VOLUME)
 {
   clipping = 0.001f;
   step_size = 0.0f;

intern/ghost/intern/GHOST_SystemCocoa.mm

@@ -386,13 +386,11 @@ extern "C" int GHOST_HACK_getFirstFile(char buf[FIRSTFILEBUFLG])
 - (id)init
 {
   self = [super init];
-  if (self) {
-    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
-    [center addObserver:self
-               selector:@selector(windowWillClose:)
-                   name:NSWindowWillCloseNotification
-                 object:nil];
-  }
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+  [center addObserver:self
+             selector:@selector(windowWillClose:)
+                 name:NSWindowWillCloseNotification
+               object:nil];
   return self;
 }
 
@@ -563,97 +561,96 @@ GHOST_TSuccess GHOST_SystemCocoa::init()
       SetFrontProcess(&psn);
     }*/
 
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    [NSApplication sharedApplication];  // initializes   NSApp
+    @autoreleasepool {
+      [NSApplication sharedApplication];  // initializes   NSApp
 
-    if ([NSApp mainMenu] == nil) {
-      NSMenu *mainMenubar = [[NSMenu alloc] init];
-      NSMenuItem *menuItem;
-      NSMenu *windowMenu;
-      NSMenu *appMenu;
+      if ([NSApp mainMenu] == nil) {
+        NSMenu *mainMenubar = [[NSMenu alloc] init];
+        NSMenuItem *menuItem;
+        NSMenu *windowMenu;
+        NSMenu *appMenu;
 
-      // Create the application menu
-      appMenu = [[NSMenu alloc] initWithTitle:@"Blender"];
+        // Create the application menu
+        appMenu = [[NSMenu alloc] initWithTitle:@"Blender"];
 
-      [appMenu addItemWithTitle:@"About Blender"
-                         action:@selector(orderFrontStandardAboutPanel:)
-                  keyEquivalent:@""];
-      [appMenu addItem:[NSMenuItem separatorItem]];
+        [appMenu addItemWithTitle:@"About Blender"
+                           action:@selector(orderFrontStandardAboutPanel:)
+                    keyEquivalent:@""];
+        [appMenu addItem:[NSMenuItem separatorItem]];
 
-      menuItem = [appMenu addItemWithTitle:@"Hide Blender"
-                                    action:@selector(hide:)
-                             keyEquivalent:@"h"];
-      [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
+        menuItem = [appMenu addItemWithTitle:@"Hide Blender"
+                                      action:@selector(hide:)
+                               keyEquivalent:@"h"];
+        [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
 
-      menuItem = [appMenu addItemWithTitle:@"Hide Others"
-                                    action:@selector(hideOtherApplications:)
-                             keyEquivalent:@"h"];
-      [menuItem
-          setKeyEquivalentModifierMask:(NSEventModifierFlagOption | NSEventModifierFlagCommand)];
+        menuItem = [appMenu addItemWithTitle:@"Hide Others"
+                                      action:@selector(hideOtherApplications:)
+                               keyEquivalent:@"h"];
+        [menuItem
+            setKeyEquivalentModifierMask:(NSEventModifierFlagOption | NSEventModifierFlagCommand)];
 
-      [appMenu addItemWithTitle:@"Show All"
-                         action:@selector(unhideAllApplications:)
-                  keyEquivalent:@""];
+        [appMenu addItemWithTitle:@"Show All"
+                           action:@selector(unhideAllApplications:)
+                    keyEquivalent:@""];
 
-      menuItem = [appMenu addItemWithTitle:@"Quit Blender"
-                                    action:@selector(terminate:)
-                             keyEquivalent:@"q"];
-      [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
+        menuItem = [appMenu addItemWithTitle:@"Quit Blender"
+                                      action:@selector(terminate:)
+                               keyEquivalent:@"q"];
+        [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
 
-      menuItem = [[NSMenuItem alloc] init];
-      [menuItem setSubmenu:appMenu];
+        menuItem = [[NSMenuItem alloc] init];
+        [menuItem setSubmenu:appMenu];
 
-      [mainMenubar addItem:menuItem];
-      [menuItem release];
-      [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu];  // Needed for 10.5
-      [appMenu release];
+        [mainMenubar addItem:menuItem];
+        [menuItem release];
+        [NSApp performSelector:@selector(setAppleMenu:) withObject:appMenu];  // Needed for 10.5
+        [appMenu release];
 
-      // Create the window menu
-      windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
+        // Create the window menu
+        windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
 
-      menuItem = [windowMenu addItemWithTitle:@"Minimize"
-                                       action:@selector(performMiniaturize:)
-                                keyEquivalent:@"m"];
-      [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
+        menuItem = [windowMenu addItemWithTitle:@"Minimize"
+                                         action:@selector(performMiniaturize:)
+                                  keyEquivalent:@"m"];
+        [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
 
-      [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];
+        [windowMenu addItemWithTitle:@"Zoom" action:@selector(performZoom:) keyEquivalent:@""];
 
-      menuItem = [windowMenu addItemWithTitle:@"Enter Full Screen"
-                                       action:@selector(toggleFullScreen:)
-                                keyEquivalent:@"f"];
-      [menuItem
-          setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
+        menuItem = [windowMenu addItemWithTitle:@"Enter Full Screen"
+                                         action:@selector(toggleFullScreen:)
+                                  keyEquivalent:@"f"];
+        [menuItem
+            setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];
 
-      menuItem = [windowMenu addItemWithTitle:@"Close"
-                                       action:@selector(performClose:)
-                                keyEquivalent:@"w"];
-      [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
+        menuItem = [windowMenu addItemWithTitle:@"Close"
+                                         action:@selector(performClose:)
+                                  keyEquivalent:@"w"];
+        [menuItem setKeyEquivalentModifierMask:NSEventModifierFlagCommand];
 
-      menuItem = [[NSMenuItem alloc] init];
-      [menuItem setSubmenu:windowMenu];
+        menuItem = [[NSMenuItem alloc] init];
+        [menuItem setSubmenu:windowMenu];
 
-      [mainMenubar addItem:menuItem];
-      [menuItem release];
+        [mainMenubar addItem:menuItem];
+        [menuItem release];
 
-      [NSApp setMainMenu:mainMenubar];
-      [NSApp setWindowsMenu:windowMenu];
-      [windowMenu release];
+        [NSApp setMainMenu:mainMenubar];
+        [NSApp setWindowsMenu:windowMenu];
+        [windowMenu release];
+      }
+
+      if ([NSApp delegate] == nil) {
+        CocoaAppDelegate *appDelegate = [[CocoaAppDelegate alloc] init];
+        [appDelegate setSystemCocoa:this];
+        [NSApp setDelegate:appDelegate];
+      }
+
+      // AppKit provides automatic window tabbing. Blender is a single-tabbed application
+      // without a macOS tab bar, and should explicitly opt-out of this. This is also
+      // controlled by the macOS user default #NSWindowTabbingEnabled.
+      NSWindow.allowsAutomaticWindowTabbing = NO;
+
+      [NSApp finishLaunching];
     }
-
-    if ([NSApp delegate] == nil) {
-      CocoaAppDelegate *appDelegate = [[CocoaAppDelegate alloc] init];
-      [appDelegate setSystemCocoa:this];
-      [NSApp setDelegate:appDelegate];
-    }
-
-    // AppKit provides automatic window tabbing. Blender is a single-tabbed application without a
-    // macOS tab bar, and should explicitly opt-out of this. This is also controlled by the macOS
-    // user default #NSWindowTabbingEnabled.
-    NSWindow.allowsAutomaticWindowTabbing = NO;
-
-    [NSApp finishLaunching];
-
-    [pool drain];
   }
   return success;
 }
@@ -676,30 +673,26 @@ GHOST_TUns8 GHOST_SystemCocoa::getNumDisplays() const
 {
   // Note that OS X supports monitor hot plug
   // We do not support multiple monitors at the moment
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-
-  GHOST_TUns8 count = [[NSScreen screens] count];
-
-  [pool drain];
-  return count;
+  @autoreleasepool {
+    return NSScreen.screens.count;
+  }
 }
 
 void GHOST_SystemCocoa::getMainDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const
 {
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-  // Get visible frame, that is frame excluding dock and top menu bar
-  NSRect frame = [[NSScreen mainScreen] visibleFrame];
+  @autoreleasepool {
+    // Get visible frame, that is frame excluding dock and top menu bar
+    NSRect frame = [[NSScreen mainScreen] visibleFrame];
 
-  // Returns max window contents (excluding title bar...)
-  NSRect contentRect = [NSWindow
-      contentRectForFrameRect:frame
-                    styleMask:(NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
-                               NSWindowStyleMaskMiniaturizable)];
+    // Returns max window contents (excluding title bar...)
+    NSRect contentRect = [NSWindow
+        contentRectForFrameRect:frame
+                      styleMask:(NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
+                                 NSWindowStyleMaskMiniaturizable)];
 
-  width = contentRect.size.width;
-  height = contentRect.size.height;
-
-  [pool drain];
+    width = contentRect.size.width;
+    height = contentRect.size.height;
+  }
 }
 
 void GHOST_SystemCocoa::getAllDisplayDimensions(GHOST_TUns32 &width, GHOST_TUns32 &height) const
@@ -720,53 +713,52 @@ GHOST_IWindow *GHOST_SystemCocoa::createWindow(const char *title,
                                                const bool is_dialog,
                                                const GHOST_IWindow *parentWindow)
 {
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
   GHOST_IWindow *window = NULL;
+  @autoreleasepool {
 
-  // Get the available rect for including window contents
-  NSRect frame = [[NSScreen mainScreen] visibleFrame];
-  NSRect contentRect = [NSWindow
-      contentRectForFrameRect:frame
-                    styleMask:(NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
-                               NSWindowStyleMaskMiniaturizable)];
+    // Get the available rect for including window contents
+    NSRect frame = [[NSScreen mainScreen] visibleFrame];
+    NSRect contentRect = [NSWindow
+        contentRectForFrameRect:frame
+                      styleMask:(NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
+                                 NSWindowStyleMaskMiniaturizable)];
 
-  GHOST_TInt32 bottom = (contentRect.size.height - 1) - height - top;
+    GHOST_TInt32 bottom = (contentRect.size.height - 1) - height - top;
 
-  // Ensures window top left is inside this available rect
-  left = left > contentRect.origin.x ? left : contentRect.origin.x;
-  // Add contentRect.origin.y to respect docksize
-  bottom = bottom > contentRect.origin.y ? bottom + contentRect.origin.y : contentRect.origin.y;
+    // Ensures window top left is inside this available rect
+    left = left > contentRect.origin.x ? left : contentRect.origin.x;
+    // Add contentRect.origin.y to respect docksize
+    bottom = bottom > contentRect.origin.y ? bottom + contentRect.origin.y : contentRect.origin.y;
 
-  window = new GHOST_WindowCocoa(this,
-                                 title,
-                                 left,
-                                 bottom,
-                                 width,
-                                 height,
-                                 state,
-                                 type,
-                                 glSettings.flags & GHOST_glStereoVisual,
-                                 glSettings.flags & GHOST_glDebugContext,
-                                 is_dialog,
-                                 (GHOST_WindowCocoa *)parentWindow);
+    window = new GHOST_WindowCocoa(this,
+                                   title,
+                                   left,
+                                   bottom,
+                                   width,
+                                   height,
+                                   state,
+                                   type,
+                                   glSettings.flags & GHOST_glStereoVisual,
+                                   glSettings.flags & GHOST_glDebugContext,
+                                   is_dialog,
+                                   (GHOST_WindowCocoa *)parentWindow);
 
-  if (window->getValid()) {
-    // Store the pointer to the window
-    GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");
-    m_windowManager->addWindow(window);
-    m_windowManager->setActiveWindow(window);
-    /* Need to tell window manager the new window is the active one
-     * (Cocoa does not send the event activate upon window creation). */
-    pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window));
-    pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
+    if (window->getValid()) {
+      // Store the pointer to the window
+      GHOST_ASSERT(m_windowManager, "m_windowManager not initialized");
+      m_windowManager->addWindow(window);
+      m_windowManager->setActiveWindow(window);
+      /* Need to tell window manager the new window is the active one
+       * (Cocoa does not send the event activate upon window creation). */
+      pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window));
+      pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
+    }
+    else {
+      GHOST_PRINT("GHOST_SystemCocoa::createWindow(): window invalid\n");
+      delete window;
+      window = NULL;
+    }
   }
-  else {
-    GHOST_PRINT("GHOST_SystemCocoa::createWindow(): window invalid\n");
-    delete window;
-    window = NULL;
-  }
-
-  [pool drain];
   return window;
 }
 
@@ -841,29 +833,28 @@ GHOST_TSuccess GHOST_SystemCocoa::setMouseCursorPosition(GHOST_TInt32 x, GHOST_T
   if (!window)
     return GHOST_kFailure;
 
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-  NSScreen *windowScreen = window->getScreen();
-  NSRect screenRect = [windowScreen frame];
+  @autoreleasepool {
+    NSScreen *windowScreen = window->getScreen();
+    NSRect screenRect = [windowScreen frame];
 
-  // Set position relative to current screen
-  xf -= screenRect.origin.x;
-  yf -= screenRect.origin.y;
+    // Set position relative to current screen
+    xf -= screenRect.origin.x;
+    yf -= screenRect.origin.y;
 
-  // Quartz Display Services uses the old coordinates (top left origin)
-  yf = screenRect.size.height - yf;
+    // Quartz Display Services uses the old coordinates (top left origin)
+    yf = screenRect.size.height - yf;
 
-  CGDisplayMoveCursorToPoint((CGDirectDisplayID)[[[windowScreen deviceDescription]
-                                 objectForKey:@"NSScreenNumber"] unsignedIntValue],
-                             CGPointMake(xf, yf));
+    CGDisplayMoveCursorToPoint((CGDirectDisplayID)[[[windowScreen deviceDescription]
+                                   objectForKey:@"NSScreenNumber"] unsignedIntValue],
+                               CGPointMake(xf, yf));
 
-  // See https://stackoverflow.com/a/17559012. By default, hardware events
-  // will be suppressed for 500ms after a synthetic mouse event. For unknown
-  // reasons CGEventSourceSetLocalEventsSuppressionInterval does not work,
-  // however calling CGAssociateMouseAndMouseCursorPosition also removes the
-  // delay, even if this is undocumented.
-  CGAssociateMouseAndMouseCursorPosition(true);
-
-  [pool drain];
+    // See https://stackoverflow.com/a/17559012. By default, hardware events
+    // will be suppressed for 500ms after a synthetic mouse event. For unknown
+    // reasons CGEventSourceSetLocalEventsSuppressionInterval does not work,
+    // however calling CGAssociateMouseAndMouseCursorPosition also removes the
+    // delay, even if this is undocumented.
+    CGAssociateMouseAndMouseCursorPosition(true);
+  }
   return GHOST_kSuccess;
 }
 
@@ -928,42 +919,40 @@ bool GHOST_SystemCocoa::processEvents(bool waitForEvent)
     }
 #endif
   do {
-    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
-    event = [NSApp nextEventMatchingMask:NSEventMaskAny
-                               untilDate:[NSDate distantPast]
-                                  inMode:NSDefaultRunLoopMode
-                                 dequeue:YES];
-    if (event == nil) {
-      [pool drain];
-      break;
-    }
+    @autoreleasepool {
+      event = [NSApp nextEventMatchingMask:NSEventMaskAny
+                                 untilDate:[NSDate distantPast]
+                                    inMode:NSDefaultRunLoopMode
+                                   dequeue:YES];
+      if (event == nil) {
+        break;
+      }
 
-    anyProcessed = true;
+      anyProcessed = true;
 
-    // Send event to NSApp to ensure Mac wide events are handled,
-    // this will send events to CocoaWindow which will call back
-    // to handleKeyEvent, handleMouseEvent and handleTabletEvent
+      // Send event to NSApp to ensure Mac wide events are handled,
+      // this will send events to CocoaWindow which will call back
+      // to handleKeyEvent, handleMouseEvent and handleTabletEvent
 
-    // There is on special exception for ctrl+(shift)+tab. We do not
-    // get keyDown events delivered to the view because they are
-    // special hotkeys to switch between views, so override directly
+      // There is on special exception for ctrl+(shift)+tab. We do not
+      // get keyDown events delivered to the view because they are
+      // special hotkeys to switch between views, so override directly
 
-    if ([event type] == NSEventTypeKeyDown && [event keyCode] == kVK_Tab &&
-        ([event modifierFlags] & NSEventModifierFlagControl)) {
-      handleKeyEvent(event);
-    }
-    else {
-      // For some reason NSApp is swallowing the key up events when modifier
-      // key is pressed, even if there seems to be no apparent reason to do
-      // so, as a workaround we always handle these up events.
-      if ([event type] == NSEventTypeKeyUp &&
-          ([event modifierFlags] & (NSEventModifierFlagCommand | NSEventModifierFlagOption)))
+      if ([event type] == NSEventTypeKeyDown && [event keyCode] == kVK_Tab &&
+          ([event modifierFlags] & NSEventModifierFlagControl)) {
         handleKeyEvent(event);
+      }
+      else {
+        // For some reason NSApp is swallowing the key up events when modifier
+        // key is pressed, even if there seems to be no apparent reason to do
+        // so, as a workaround we always handle these up events.
+        if ([event type] == NSEventTypeKeyUp &&
+            ([event modifierFlags] & (NSEventModifierFlagCommand | NSEventModifierFlagOption)))
+          handleKeyEvent(event);
 
-      [NSApp sendEvent:event];
+        [NSApp sendEvent:event];
+      }
     }
-
-    [pool drain];
   } while (event != nil);
 #if 0
   } while (waitForEvent && !anyProcessed); // Needed only for timer implementation
@@ -1677,10 +1666,8 @@ GHOST_TSuccess GHOST_SystemCocoa::handleMouseEvent(void *eventPtr)
       NSEventPhase momentumPhase = NSEventPhaseNone;
       NSEventPhase phase = NSEventPhaseNone;
 
-      if ([event respondsToSelector:@selector(momentumPhase)])
-        momentumPhase = [event momentumPhase];
-      if ([event respondsToSelector:@selector(phase)])
-        phase = [event phase];
+      momentumPhase = [event momentumPhase];
+      phase = [event phase];
 
       /* when pressing a key while momentum scrolling continues after
        * lifting fingers off the trackpad, the action can unexpectedly
@@ -1953,78 +1940,48 @@ GHOST_TUns8 *GHOST_SystemCocoa::getClipboard(bool selection) const
   GHOST_TUns8 *temp_buff;
   size_t pastedTextSize;
 
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  @autoreleasepool {
 
-  NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
+    NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
 
-  if (pasteBoard == nil) {
-    [pool drain];
-    return NULL;
-  }
+    NSString *textPasted = [pasteBoard stringForType:NSStringPboardType];
 
-  NSArray *supportedTypes = [NSArray arrayWithObjects:NSStringPboardType, nil];
+    if (textPasted == nil) {
+      return NULL;
+    }
 
-  NSString *bestType = [[NSPasteboard generalPasteboard] availableTypeFromArray:supportedTypes];
+    pastedTextSize = [textPasted lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 
-  if (bestType == nil) {
-    [pool drain];
-    return NULL;
-  }
+    temp_buff = (GHOST_TUns8 *)malloc(pastedTextSize + 1);
 
-  NSString *textPasted = [pasteBoard stringForType:NSStringPboardType];
+    if (temp_buff == NULL) {
+      return NULL;
+    }
 
-  if (textPasted == nil) {
-    [pool drain];
-    return NULL;
-  }
+    strncpy(
+        (char *)temp_buff, [textPasted cStringUsingEncoding:NSUTF8StringEncoding], pastedTextSize);
 
-  pastedTextSize = [textPasted lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
+    temp_buff[pastedTextSize] = '\0';
 
-  temp_buff = (GHOST_TUns8 *)malloc(pastedTextSize + 1);
-
-  if (temp_buff == NULL) {
-    [pool drain];
-    return NULL;
-  }
-
-  strncpy(
-      (char *)temp_buff, [textPasted cStringUsingEncoding:NSUTF8StringEncoding], pastedTextSize);
-
-  temp_buff[pastedTextSize] = '\0';
-
-  [pool drain];
-
-  if (temp_buff) {
-    return temp_buff;
-  }
-  else {
-    return NULL;
+    if (temp_buff) {
+      return temp_buff;
+    }
+    else {
+      return NULL;
+    }
   }
 }
 
 void GHOST_SystemCocoa::putClipboard(GHOST_TInt8 *buffer, bool selection) const
 {
-  NSString *textToCopy;
-
   if (selection)
     return;  // for copying the selection, used on X11
 
-  NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+  @autoreleasepool {
 
-  NSPasteboard *pasteBoard = [NSPasteboard generalPasteboard];
-
-  if (pasteBoard == nil) {
-    [pool drain];
-    return;
+    NSPasteboard *pasteBoard = NSPasteboard.generalPasteboard;
+    [pasteBoard declareTypes:@[ NSStringPboardType ] owner:nil];
+    NSString *textToCopy = [NSString stringWithCString:buffer encoding:NSUTF8StringEncoding];
+    [pasteBoard setString:textToCopy forType:NSStringPboardType];
   }
-
-  NSArray *supportedTypes = [NSArray arrayWithObject:NSStringPboardType];
-
-  [pasteBoard declareTypes:supportedTypes owner:nil];
-
-  textToCopy = [NSString stringWithCString:buffer encoding:NSUTF8StringEncoding];
-
-  [pasteBoard setString:textToCopy forType:NSStringPboardType];
-
-  [pool drain];
 }

intern/guardedalloc/CMakeLists.txt

@@ -77,6 +77,7 @@ if(WITH_GTESTS)
   set(TEST_SRC
     tests/guardedalloc_alignment_test.cc
     tests/guardedalloc_overflow_test.cc
+    tests/guardedalloc_test_base.h
   )
   set(TEST_INC
     ../../source/blender/blenlib

intern/libmv/.clang-format

@@ -1,2 +1,34 @@
-DisableFormat: true
-SortIncludes: false
+BasedOnStyle: Google
+
+ColumnLimit: 80
+
+Standard: Cpp11
+
+# Indent nested preprocessor.
+# #ifdef Foo
+# #  include <nested>
+# #endif
+IndentPPDirectives: AfterHash
+
+# For the cases when namespace is closing with a wrong comment
+FixNamespaceComments: true
+
+AllowShortFunctionsOnASingleLine: InlineOnly
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: true
+
+# No bin packing, every argument is on its own line.
+BinPackArguments: false
+BinPackParameters: false
+
+# Ensure pointer alignment.
+# ObjectType* object;
+PointerAlignment: Left
+DerivePointerAlignment: false
+
+AlignEscapedNewlines: Right
+
+IncludeBlocks: Preserve
+SortIncludes: true

intern/libmv/intern/autotrack.cc

@@ -22,15 +22,15 @@
 #include "intern/utildefines.h"
 #include "libmv/autotrack/autotrack.h"
 
+using libmv::TrackRegionOptions;
+using libmv::TrackRegionResult;
 using mv::AutoTrack;
 using mv::FrameAccessor;
 using mv::Marker;
-using libmv::TrackRegionOptions;
-using libmv::TrackRegionResult;
 
-libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor *frame_accessor) {
-  return (libmv_AutoTrack*) LIBMV_OBJECT_NEW(AutoTrack,
-                                             (FrameAccessor*) frame_accessor);
+libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor* frame_accessor) {
+  return (libmv_AutoTrack*)LIBMV_OBJECT_NEW(AutoTrack,
+                                            (FrameAccessor*)frame_accessor);
 }
 
 void libmv_autoTrackDestroy(libmv_AutoTrack* libmv_autotrack) {
@@ -39,7 +39,7 @@ void libmv_autoTrackDestroy(libmv_AutoTrack* libmv_autotrack) {
 
 void libmv_autoTrackSetOptions(libmv_AutoTrack* libmv_autotrack,
                                const libmv_AutoTrackOptions* options) {
-  AutoTrack *autotrack = ((AutoTrack*) libmv_autotrack);
+  AutoTrack* autotrack = ((AutoTrack*)libmv_autotrack);
   libmv_configureTrackRegionOptions(options->track_region,
                                     &autotrack->options.track_region);
 
@@ -51,18 +51,15 @@ void libmv_autoTrackSetOptions(libmv_AutoTrack* libmv_autotrack,
 
 int libmv_autoTrackMarker(libmv_AutoTrack* libmv_autotrack,
                           const libmv_TrackRegionOptions* libmv_options,
-                          libmv_Marker *libmv_tracked_marker,
+                          libmv_Marker* libmv_tracked_marker,
                           libmv_TrackRegionResult* libmv_result) {
-
   Marker tracked_marker;
   TrackRegionOptions options;
   TrackRegionResult result;
   libmv_apiMarkerToMarker(*libmv_tracked_marker, &tracked_marker);
-  libmv_configureTrackRegionOptions(*libmv_options,
-                                    &options);
-  bool ok = (((AutoTrack*) libmv_autotrack)->TrackMarker(&tracked_marker,
-                                                         &result,
-                                                         &options));
+  libmv_configureTrackRegionOptions(*libmv_options, &options);
+  bool ok = (((AutoTrack*)libmv_autotrack)
+                 ->TrackMarker(&tracked_marker, &result, &options));
   libmv_markerToApiMarker(tracked_marker, libmv_tracked_marker);
   libmv_regionTrackergetResult(result, libmv_result);
   return ok && result.is_usable();
@@ -72,7 +69,7 @@ void libmv_autoTrackAddMarker(libmv_AutoTrack* libmv_autotrack,
                               const libmv_Marker* libmv_marker) {
   Marker marker;
   libmv_apiMarkerToMarker(*libmv_marker, &marker);
-  ((AutoTrack*) libmv_autotrack)->AddMarker(marker);
+  ((AutoTrack*)libmv_autotrack)->AddMarker(marker);
 }
 
 void libmv_autoTrackSetMarkers(libmv_AutoTrack* libmv_autotrack,
@@ -87,19 +84,17 @@ void libmv_autoTrackSetMarkers(libmv_AutoTrack* libmv_autotrack,
   for (size_t i = 0; i < num_markers; ++i) {
     libmv_apiMarkerToMarker(libmv_marker[i], &markers[i]);
   }
-  ((AutoTrack*) libmv_autotrack)->SetMarkers(&markers);
+  ((AutoTrack*)libmv_autotrack)->SetMarkers(&markers);
 }
 
 int libmv_autoTrackGetMarker(libmv_AutoTrack* libmv_autotrack,
                              int clip,
                              int frame,
                              int track,
-                             libmv_Marker *libmv_marker) {
+                             libmv_Marker* libmv_marker) {
   Marker marker;
-  int ok = ((AutoTrack*) libmv_autotrack)->GetMarker(clip,
-                                                     frame,
-                                                     track,
-                                                     &marker);
+  int ok =
+      ((AutoTrack*)libmv_autotrack)->GetMarker(clip, frame, track, &marker);
   if (ok) {
     libmv_markerToApiMarker(marker, libmv_marker);
   }

intern/libmv/intern/autotrack.h

@@ -21,9 +21,9 @@
 #define LIBMV_C_API_AUTOTRACK_H_
 
 #include "intern/frame_accessor.h"
-#include "intern/tracksN.h"
-#include "intern/track_region.h"
 #include "intern/region.h"
+#include "intern/track_region.h"
+#include "intern/tracksN.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -36,7 +36,7 @@ typedef struct libmv_AutoTrackOptions {
   libmv_Region search_region;
 } libmv_AutoTrackOptions;
 
-libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor *frame_accessor);
+libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor* frame_accessor);
 
 void libmv_autoTrackDestroy(libmv_AutoTrack* libmv_autotrack);
 
@@ -45,7 +45,7 @@ void libmv_autoTrackSetOptions(libmv_AutoTrack* libmv_autotrack,
 
 int libmv_autoTrackMarker(libmv_AutoTrack* libmv_autotrack,
                           const libmv_TrackRegionOptions* libmv_options,
-                          libmv_Marker *libmv_tracker_marker,
+                          libmv_Marker* libmv_tracker_marker,
                           libmv_TrackRegionResult* libmv_result);
 
 void libmv_autoTrackAddMarker(libmv_AutoTrack* libmv_autotrack,
@@ -59,7 +59,7 @@ int libmv_autoTrackGetMarker(libmv_AutoTrack* libmv_autotrack,
                              int clip,
                              int frame,
                              int track,
-                             libmv_Marker *libmv_marker);
+                             libmv_Marker* libmv_marker);
 
 #ifdef __cplusplus
 }

intern/libmv/intern/camera_intrinsics.cc

@@ -21,62 +21,56 @@
 #include "intern/utildefines.h"
 #include "libmv/simple_pipeline/camera_intrinsics.h"
 
+using libmv::BrownCameraIntrinsics;
 using libmv::CameraIntrinsics;
 using libmv::DivisionCameraIntrinsics;
-using libmv::PolynomialCameraIntrinsics;
 using libmv::NukeCameraIntrinsics;
-using libmv::BrownCameraIntrinsics;
+using libmv::PolynomialCameraIntrinsics;
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsNew(
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsNew(
     const libmv_CameraIntrinsicsOptions* libmv_camera_intrinsics_options) {
-  CameraIntrinsics *camera_intrinsics =
-    libmv_cameraIntrinsicsCreateFromOptions(libmv_camera_intrinsics_options);
-  return (libmv_CameraIntrinsics *) camera_intrinsics;
+  CameraIntrinsics* camera_intrinsics =
+      libmv_cameraIntrinsicsCreateFromOptions(libmv_camera_intrinsics_options);
+  return (libmv_CameraIntrinsics*)camera_intrinsics;
 }
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsCopy(
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsCopy(
     const libmv_CameraIntrinsics* libmv_intrinsics) {
-  const CameraIntrinsics *orig_intrinsics =
-    (const CameraIntrinsics *) libmv_intrinsics;
+  const CameraIntrinsics* orig_intrinsics =
+      (const CameraIntrinsics*)libmv_intrinsics;
 
-  CameraIntrinsics *new_intrinsics = NULL;
+  CameraIntrinsics* new_intrinsics = NULL;
   switch (orig_intrinsics->GetDistortionModelType()) {
-    case libmv::DISTORTION_MODEL_POLYNOMIAL:
-      {
-        const PolynomialCameraIntrinsics *polynomial_intrinsics =
+    case libmv::DISTORTION_MODEL_POLYNOMIAL: {
+      const PolynomialCameraIntrinsics* polynomial_intrinsics =
           static_cast<const PolynomialCameraIntrinsics*>(orig_intrinsics);
-        new_intrinsics = LIBMV_OBJECT_NEW(PolynomialCameraIntrinsics,
-                                          *polynomial_intrinsics);
-        break;
-      }
-    case libmv::DISTORTION_MODEL_DIVISION:
-      {
-        const DivisionCameraIntrinsics *division_intrinsics =
+      new_intrinsics =
+          LIBMV_OBJECT_NEW(PolynomialCameraIntrinsics, *polynomial_intrinsics);
+      break;
+    }
+    case libmv::DISTORTION_MODEL_DIVISION: {
+      const DivisionCameraIntrinsics* division_intrinsics =
           static_cast<const DivisionCameraIntrinsics*>(orig_intrinsics);
-        new_intrinsics = LIBMV_OBJECT_NEW(DivisionCameraIntrinsics,
-                                          *division_intrinsics);
-        break;
-      }
-    case libmv::DISTORTION_MODEL_NUKE:
-      {
-        const NukeCameraIntrinsics *nuke_intrinsics =
+      new_intrinsics =
+          LIBMV_OBJECT_NEW(DivisionCameraIntrinsics, *division_intrinsics);
+      break;
+    }
+    case libmv::DISTORTION_MODEL_NUKE: {
+      const NukeCameraIntrinsics* nuke_intrinsics =
           static_cast<const NukeCameraIntrinsics*>(orig_intrinsics);
-        new_intrinsics = LIBMV_OBJECT_NEW(NukeCameraIntrinsics,
-                                          *nuke_intrinsics);
-        break;
-      }
-    case libmv::DISTORTION_MODEL_BROWN:
-      {
-        const BrownCameraIntrinsics *brown_intrinsics =
+      new_intrinsics = LIBMV_OBJECT_NEW(NukeCameraIntrinsics, *nuke_intrinsics);
+      break;
+    }
+    case libmv::DISTORTION_MODEL_BROWN: {
+      const BrownCameraIntrinsics* brown_intrinsics =
           static_cast<const BrownCameraIntrinsics*>(orig_intrinsics);
-        new_intrinsics = LIBMV_OBJECT_NEW(BrownCameraIntrinsics,
-                                          *brown_intrinsics);
-        break;
-      }
-    default:
-      assert(!"Unknown distortion model");
+      new_intrinsics =
+          LIBMV_OBJECT_NEW(BrownCameraIntrinsics, *brown_intrinsics);
+      break;
+    }
+    default: assert(!"Unknown distortion model");
   }
-  return (libmv_CameraIntrinsics *) new_intrinsics;
+  return (libmv_CameraIntrinsics*)new_intrinsics;
 }
 
 void libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics* libmv_intrinsics) {
@@ -86,7 +80,7 @@ void libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics* libmv_intrinsics) {
 void libmv_cameraIntrinsicsUpdate(
     const libmv_CameraIntrinsicsOptions* libmv_camera_intrinsics_options,
     libmv_CameraIntrinsics* libmv_intrinsics) {
-  CameraIntrinsics *camera_intrinsics = (CameraIntrinsics *) libmv_intrinsics;
+  CameraIntrinsics* camera_intrinsics = (CameraIntrinsics*)libmv_intrinsics;
 
   double focal_length = libmv_camera_intrinsics_options->focal_length;
   double principal_x = libmv_camera_intrinsics_options->principal_point_x;
@@ -115,191 +109,173 @@ void libmv_cameraIntrinsicsUpdate(
   }
 
   switch (libmv_camera_intrinsics_options->distortion_model) {
-    case LIBMV_DISTORTION_MODEL_POLYNOMIAL:
-      {
-        assert(camera_intrinsics->GetDistortionModelType() ==
-               libmv::DISTORTION_MODEL_POLYNOMIAL);
+    case LIBMV_DISTORTION_MODEL_POLYNOMIAL: {
+      assert(camera_intrinsics->GetDistortionModelType() ==
+             libmv::DISTORTION_MODEL_POLYNOMIAL);
 
-        PolynomialCameraIntrinsics *polynomial_intrinsics =
-          (PolynomialCameraIntrinsics *) camera_intrinsics;
+      PolynomialCameraIntrinsics* polynomial_intrinsics =
+          (PolynomialCameraIntrinsics*)camera_intrinsics;
 
-        double k1 = libmv_camera_intrinsics_options->polynomial_k1;
-        double k2 = libmv_camera_intrinsics_options->polynomial_k2;
-        double k3 = libmv_camera_intrinsics_options->polynomial_k3;
+      double k1 = libmv_camera_intrinsics_options->polynomial_k1;
+      double k2 = libmv_camera_intrinsics_options->polynomial_k2;
+      double k3 = libmv_camera_intrinsics_options->polynomial_k3;
 
-        if (polynomial_intrinsics->k1() != k1 ||
-            polynomial_intrinsics->k2() != k2 ||
-            polynomial_intrinsics->k3() != k3) {
-          polynomial_intrinsics->SetRadialDistortion(k1, k2, k3);
-        }
-        break;
+      if (polynomial_intrinsics->k1() != k1 ||
+          polynomial_intrinsics->k2() != k2 ||
+          polynomial_intrinsics->k3() != k3) {
+        polynomial_intrinsics->SetRadialDistortion(k1, k2, k3);
+      }
+      break;
+    }
+
+    case LIBMV_DISTORTION_MODEL_DIVISION: {
+      assert(camera_intrinsics->GetDistortionModelType() ==
+             libmv::DISTORTION_MODEL_DIVISION);
+
+      DivisionCameraIntrinsics* division_intrinsics =
+          (DivisionCameraIntrinsics*)camera_intrinsics;
+
+      double k1 = libmv_camera_intrinsics_options->division_k1;
+      double k2 = libmv_camera_intrinsics_options->division_k2;
+
+      if (division_intrinsics->k1() != k1 || division_intrinsics->k2() != k2) {
+        division_intrinsics->SetDistortion(k1, k2);
       }
 
-    case LIBMV_DISTORTION_MODEL_DIVISION:
-      {
-        assert(camera_intrinsics->GetDistortionModelType() ==
-               libmv::DISTORTION_MODEL_DIVISION);
+      break;
+    }
 
-        DivisionCameraIntrinsics *division_intrinsics =
-          (DivisionCameraIntrinsics *) camera_intrinsics;
+    case LIBMV_DISTORTION_MODEL_NUKE: {
+      assert(camera_intrinsics->GetDistortionModelType() ==
+             libmv::DISTORTION_MODEL_NUKE);
 
-        double k1 = libmv_camera_intrinsics_options->division_k1;
-        double k2 = libmv_camera_intrinsics_options->division_k2;
+      NukeCameraIntrinsics* nuke_intrinsics =
+          (NukeCameraIntrinsics*)camera_intrinsics;
 
-        if (division_intrinsics->k1() != k1 ||
-            division_intrinsics->k2() != k2) {
-          division_intrinsics->SetDistortion(k1, k2);
-        }
+      double k1 = libmv_camera_intrinsics_options->nuke_k1;
+      double k2 = libmv_camera_intrinsics_options->nuke_k2;
 
-        break;
+      if (nuke_intrinsics->k1() != k1 || nuke_intrinsics->k2() != k2) {
+        nuke_intrinsics->SetDistortion(k1, k2);
       }
 
-    case LIBMV_DISTORTION_MODEL_NUKE:
-      {
-        assert(camera_intrinsics->GetDistortionModelType() ==
-               libmv::DISTORTION_MODEL_NUKE);
+      break;
+    }
 
-        NukeCameraIntrinsics *nuke_intrinsics =
-          (NukeCameraIntrinsics *) camera_intrinsics;
+    case LIBMV_DISTORTION_MODEL_BROWN: {
+      assert(camera_intrinsics->GetDistortionModelType() ==
+             libmv::DISTORTION_MODEL_BROWN);
 
-        double k1 = libmv_camera_intrinsics_options->nuke_k1;
-        double k2 = libmv_camera_intrinsics_options->nuke_k2;
+      BrownCameraIntrinsics* brown_intrinsics =
+          (BrownCameraIntrinsics*)camera_intrinsics;
 
-        if (nuke_intrinsics->k1() != k1 ||
-            nuke_intrinsics->k2() != k2) {
-          nuke_intrinsics->SetDistortion(k1, k2);
-        }
+      double k1 = libmv_camera_intrinsics_options->brown_k1;
+      double k2 = libmv_camera_intrinsics_options->brown_k2;
+      double k3 = libmv_camera_intrinsics_options->brown_k3;
+      double k4 = libmv_camera_intrinsics_options->brown_k4;
 
-        break;
+      if (brown_intrinsics->k1() != k1 || brown_intrinsics->k2() != k2 ||
+          brown_intrinsics->k3() != k3 || brown_intrinsics->k4() != k4) {
+        brown_intrinsics->SetRadialDistortion(k1, k2, k3, k4);
       }
 
-    case LIBMV_DISTORTION_MODEL_BROWN:
-      {
-        assert(camera_intrinsics->GetDistortionModelType() ==
-               libmv::DISTORTION_MODEL_BROWN);
+      double p1 = libmv_camera_intrinsics_options->brown_p1;
+      double p2 = libmv_camera_intrinsics_options->brown_p2;
 
-        BrownCameraIntrinsics *brown_intrinsics =
-          (BrownCameraIntrinsics *) camera_intrinsics;
-
-        double k1 = libmv_camera_intrinsics_options->brown_k1;
-        double k2 = libmv_camera_intrinsics_options->brown_k2;
-        double k3 = libmv_camera_intrinsics_options->brown_k3;
-        double k4 = libmv_camera_intrinsics_options->brown_k4;
-
-        if (brown_intrinsics->k1() != k1 ||
-            brown_intrinsics->k2() != k2 ||
-            brown_intrinsics->k3() != k3 ||
-            brown_intrinsics->k4() != k4) {
-          brown_intrinsics->SetRadialDistortion(k1, k2, k3, k4);
-        }
-
-        double p1 = libmv_camera_intrinsics_options->brown_p1;
-        double p2 = libmv_camera_intrinsics_options->brown_p2;
-
-        if (brown_intrinsics->p1() != p1 || brown_intrinsics->p2() != p2) {
-          brown_intrinsics->SetTangentialDistortion(p1, p2);
-        }
-        break;
+      if (brown_intrinsics->p1() != p1 || brown_intrinsics->p2() != p2) {
+        brown_intrinsics->SetTangentialDistortion(p1, p2);
       }
+      break;
+    }
 
-    default:
-      assert(!"Unknown distortion model");
+    default: assert(!"Unknown distortion model");
   }
 }
 
 void libmv_cameraIntrinsicsSetThreads(libmv_CameraIntrinsics* libmv_intrinsics,
                                       int threads) {
-  CameraIntrinsics *camera_intrinsics = (CameraIntrinsics *) libmv_intrinsics;
+  CameraIntrinsics* camera_intrinsics = (CameraIntrinsics*)libmv_intrinsics;
   camera_intrinsics->SetThreads(threads);
 }
 
 void libmv_cameraIntrinsicsExtractOptions(
     const libmv_CameraIntrinsics* libmv_intrinsics,
     libmv_CameraIntrinsicsOptions* camera_intrinsics_options) {
-  const CameraIntrinsics *camera_intrinsics =
-    (const CameraIntrinsics *) libmv_intrinsics;
+  const CameraIntrinsics* camera_intrinsics =
+      (const CameraIntrinsics*)libmv_intrinsics;
 
   // Fill in options which are common for all distortion models.
   camera_intrinsics_options->focal_length = camera_intrinsics->focal_length();
   camera_intrinsics_options->principal_point_x =
-    camera_intrinsics->principal_point_x();
+      camera_intrinsics->principal_point_x();
   camera_intrinsics_options->principal_point_y =
-    camera_intrinsics->principal_point_y();
+      camera_intrinsics->principal_point_y();
 
   camera_intrinsics_options->image_width = camera_intrinsics->image_width();
   camera_intrinsics_options->image_height = camera_intrinsics->image_height();
 
   switch (camera_intrinsics->GetDistortionModelType()) {
-    case libmv::DISTORTION_MODEL_POLYNOMIAL:
-      {
-        const PolynomialCameraIntrinsics *polynomial_intrinsics =
-          static_cast<const PolynomialCameraIntrinsics *>(camera_intrinsics);
-        camera_intrinsics_options->distortion_model =
+    case libmv::DISTORTION_MODEL_POLYNOMIAL: {
+      const PolynomialCameraIntrinsics* polynomial_intrinsics =
+          static_cast<const PolynomialCameraIntrinsics*>(camera_intrinsics);
+      camera_intrinsics_options->distortion_model =
           LIBMV_DISTORTION_MODEL_POLYNOMIAL;
-        camera_intrinsics_options->polynomial_k1 = polynomial_intrinsics->k1();
-        camera_intrinsics_options->polynomial_k2 = polynomial_intrinsics->k2();
-        camera_intrinsics_options->polynomial_k3 = polynomial_intrinsics->k3();
-        camera_intrinsics_options->polynomial_p1 = polynomial_intrinsics->p1();
-        camera_intrinsics_options->polynomial_p2 = polynomial_intrinsics->p2();
-        break;
-      }
+      camera_intrinsics_options->polynomial_k1 = polynomial_intrinsics->k1();
+      camera_intrinsics_options->polynomial_k2 = polynomial_intrinsics->k2();
+      camera_intrinsics_options->polynomial_k3 = polynomial_intrinsics->k3();
+      camera_intrinsics_options->polynomial_p1 = polynomial_intrinsics->p1();
+      camera_intrinsics_options->polynomial_p2 = polynomial_intrinsics->p2();
+      break;
+    }
 
-    case libmv::DISTORTION_MODEL_DIVISION:
-      {
-        const DivisionCameraIntrinsics *division_intrinsics =
-          static_cast<const DivisionCameraIntrinsics *>(camera_intrinsics);
-        camera_intrinsics_options->distortion_model =
+    case libmv::DISTORTION_MODEL_DIVISION: {
+      const DivisionCameraIntrinsics* division_intrinsics =
+          static_cast<const DivisionCameraIntrinsics*>(camera_intrinsics);
+      camera_intrinsics_options->distortion_model =
           LIBMV_DISTORTION_MODEL_DIVISION;
-        camera_intrinsics_options->division_k1 = division_intrinsics->k1();
-        camera_intrinsics_options->division_k2 = division_intrinsics->k2();
-        break;
-      }
+      camera_intrinsics_options->division_k1 = division_intrinsics->k1();
+      camera_intrinsics_options->division_k2 = division_intrinsics->k2();
+      break;
+    }
 
-    case libmv::DISTORTION_MODEL_NUKE:
-      {
-        const NukeCameraIntrinsics *nuke_intrinsics =
-          static_cast<const NukeCameraIntrinsics *>(camera_intrinsics);
-        camera_intrinsics_options->distortion_model =
-          LIBMV_DISTORTION_MODEL_NUKE;
-        camera_intrinsics_options->nuke_k1 = nuke_intrinsics->k1();
-        camera_intrinsics_options->nuke_k2 = nuke_intrinsics->k2();
-        break;
-      }
+    case libmv::DISTORTION_MODEL_NUKE: {
+      const NukeCameraIntrinsics* nuke_intrinsics =
+          static_cast<const NukeCameraIntrinsics*>(camera_intrinsics);
+      camera_intrinsics_options->distortion_model = LIBMV_DISTORTION_MODEL_NUKE;
+      camera_intrinsics_options->nuke_k1 = nuke_intrinsics->k1();
+      camera_intrinsics_options->nuke_k2 = nuke_intrinsics->k2();
+      break;
+    }
 
-    case libmv::DISTORTION_MODEL_BROWN:
-      {
-        const BrownCameraIntrinsics *brown_intrinsics =
-          static_cast<const BrownCameraIntrinsics *>(camera_intrinsics);
-        camera_intrinsics_options->distortion_model =
+    case libmv::DISTORTION_MODEL_BROWN: {
+      const BrownCameraIntrinsics* brown_intrinsics =
+          static_cast<const BrownCameraIntrinsics*>(camera_intrinsics);
+      camera_intrinsics_options->distortion_model =
           LIBMV_DISTORTION_MODEL_BROWN;
-        camera_intrinsics_options->brown_k1 = brown_intrinsics->k1();
-        camera_intrinsics_options->brown_k2 = brown_intrinsics->k2();
-        camera_intrinsics_options->brown_k3 = brown_intrinsics->k3();
-        camera_intrinsics_options->brown_k4 = brown_intrinsics->k4();
-        camera_intrinsics_options->brown_p1 = brown_intrinsics->p1();
-        camera_intrinsics_options->brown_p2 = brown_intrinsics->p2();
-        break;
-      }
+      camera_intrinsics_options->brown_k1 = brown_intrinsics->k1();
+      camera_intrinsics_options->brown_k2 = brown_intrinsics->k2();
+      camera_intrinsics_options->brown_k3 = brown_intrinsics->k3();
+      camera_intrinsics_options->brown_k4 = brown_intrinsics->k4();
+      camera_intrinsics_options->brown_p1 = brown_intrinsics->p1();
+      camera_intrinsics_options->brown_p2 = brown_intrinsics->p2();
+      break;
+    }
 
-    default:
-      assert(!"Unknown distortion model");
+    default: assert(!"Unknown distortion model");
   }
 }
 
 void libmv_cameraIntrinsicsUndistortByte(
     const libmv_CameraIntrinsics* libmv_intrinsics,
-    const unsigned char *source_image,
+    const unsigned char* source_image,
     int width,
     int height,
     float overscan,
     int channels,
     unsigned char* destination_image) {
-  CameraIntrinsics *camera_intrinsics = (CameraIntrinsics *) libmv_intrinsics;
-  camera_intrinsics->UndistortBuffer(source_image,
-                                     width, height,
-                                     overscan,
-                                     channels,
-                                     destination_image);
+  CameraIntrinsics* camera_intrinsics = (CameraIntrinsics*)libmv_intrinsics;
+  camera_intrinsics->UndistortBuffer(
+      source_image, width, height, overscan, channels, destination_image);
 }
 
 void libmv_cameraIntrinsicsUndistortFloat(
@@ -310,28 +286,22 @@ void libmv_cameraIntrinsicsUndistortFloat(
     float overscan,
     int channels,
     float* destination_image) {
-  CameraIntrinsics *intrinsics = (CameraIntrinsics *) libmv_intrinsics;
-  intrinsics->UndistortBuffer(source_image,
-                              width, height,
-                              overscan,
-                              channels,
-                              destination_image);
+  CameraIntrinsics* intrinsics = (CameraIntrinsics*)libmv_intrinsics;
+  intrinsics->UndistortBuffer(
+      source_image, width, height, overscan, channels, destination_image);
 }
 
 void libmv_cameraIntrinsicsDistortByte(
     const struct libmv_CameraIntrinsics* libmv_intrinsics,
-    const unsigned char *source_image,
+    const unsigned char* source_image,
     int width,
     int height,
     float overscan,
     int channels,
-    unsigned char *destination_image) {
-  CameraIntrinsics *intrinsics = (CameraIntrinsics *) libmv_intrinsics;
-  intrinsics->DistortBuffer(source_image,
-                            width, height,
-                            overscan,
-                            channels,
-                            destination_image);
+    unsigned char* destination_image) {
+  CameraIntrinsics* intrinsics = (CameraIntrinsics*)libmv_intrinsics;
+  intrinsics->DistortBuffer(
+      source_image, width, height, overscan, channels, destination_image);
 }
 
 void libmv_cameraIntrinsicsDistortFloat(
@@ -342,12 +312,9 @@ void libmv_cameraIntrinsicsDistortFloat(
     float overscan,
     int channels,
     float* destination_image) {
-  CameraIntrinsics *intrinsics = (CameraIntrinsics *) libmv_intrinsics;
-  intrinsics->DistortBuffer(source_image,
-                            width, height,
-                            overscan,
-                            channels,
-                            destination_image);
+  CameraIntrinsics* intrinsics = (CameraIntrinsics*)libmv_intrinsics;
+  intrinsics->DistortBuffer(
+      source_image, width, height, overscan, channels, destination_image);
 }
 
 void libmv_cameraIntrinsicsApply(
@@ -356,7 +323,7 @@ void libmv_cameraIntrinsicsApply(
     double y,
     double* x1,
     double* y1) {
-  CameraIntrinsics *intrinsics = (CameraIntrinsics *) libmv_intrinsics;
+  CameraIntrinsics* intrinsics = (CameraIntrinsics*)libmv_intrinsics;
   intrinsics->ApplyIntrinsics(x, y, x1, y1);
 }
 
@@ -366,7 +333,7 @@ void libmv_cameraIntrinsicsInvert(
     double y,
     double* x1,
     double* y1) {
-  CameraIntrinsics *intrinsics = (CameraIntrinsics *) libmv_intrinsics;
+  CameraIntrinsics* intrinsics = (CameraIntrinsics*)libmv_intrinsics;
   intrinsics->InvertIntrinsics(x, y, x1, y1);
 }
 
@@ -381,69 +348,63 @@ static void libmv_cameraIntrinsicsFillFromOptions(
       camera_intrinsics_options->principal_point_y);
 
   camera_intrinsics->SetImageSize(camera_intrinsics_options->image_width,
-      camera_intrinsics_options->image_height);
+                                  camera_intrinsics_options->image_height);
 
   switch (camera_intrinsics_options->distortion_model) {
-    case LIBMV_DISTORTION_MODEL_POLYNOMIAL:
-      {
-        PolynomialCameraIntrinsics *polynomial_intrinsics =
+    case LIBMV_DISTORTION_MODEL_POLYNOMIAL: {
+      PolynomialCameraIntrinsics* polynomial_intrinsics =
           static_cast<PolynomialCameraIntrinsics*>(camera_intrinsics);
 
-        polynomial_intrinsics->SetRadialDistortion(
-            camera_intrinsics_options->polynomial_k1,
-            camera_intrinsics_options->polynomial_k2,
-            camera_intrinsics_options->polynomial_k3);
+      polynomial_intrinsics->SetRadialDistortion(
+          camera_intrinsics_options->polynomial_k1,
+          camera_intrinsics_options->polynomial_k2,
+          camera_intrinsics_options->polynomial_k3);
 
-        break;
-      }
+      break;
+    }
 
-    case LIBMV_DISTORTION_MODEL_DIVISION:
-      {
-        DivisionCameraIntrinsics *division_intrinsics =
+    case LIBMV_DISTORTION_MODEL_DIVISION: {
+      DivisionCameraIntrinsics* division_intrinsics =
           static_cast<DivisionCameraIntrinsics*>(camera_intrinsics);
 
-        division_intrinsics->SetDistortion(
-            camera_intrinsics_options->division_k1,
-            camera_intrinsics_options->division_k2);
-        break;
-      }
+      division_intrinsics->SetDistortion(
+          camera_intrinsics_options->division_k1,
+          camera_intrinsics_options->division_k2);
+      break;
+    }
 
-    case LIBMV_DISTORTION_MODEL_NUKE:
-      {
-        NukeCameraIntrinsics *nuke_intrinsics =
+    case LIBMV_DISTORTION_MODEL_NUKE: {
+      NukeCameraIntrinsics* nuke_intrinsics =
           static_cast<NukeCameraIntrinsics*>(camera_intrinsics);
 
-        nuke_intrinsics->SetDistortion(
-            camera_intrinsics_options->nuke_k1,
-            camera_intrinsics_options->nuke_k2);
-        break;
-      }
+      nuke_intrinsics->SetDistortion(camera_intrinsics_options->nuke_k1,
+                                     camera_intrinsics_options->nuke_k2);
+      break;
+    }
 
-    case LIBMV_DISTORTION_MODEL_BROWN:
-      {
-        BrownCameraIntrinsics *brown_intrinsics =
+    case LIBMV_DISTORTION_MODEL_BROWN: {
+      BrownCameraIntrinsics* brown_intrinsics =
           static_cast<BrownCameraIntrinsics*>(camera_intrinsics);
 
-        brown_intrinsics->SetRadialDistortion(
-            camera_intrinsics_options->brown_k1,
-            camera_intrinsics_options->brown_k2,
-            camera_intrinsics_options->brown_k3,
-            camera_intrinsics_options->brown_k4);
-        brown_intrinsics->SetTangentialDistortion(
+      brown_intrinsics->SetRadialDistortion(
+          camera_intrinsics_options->brown_k1,
+          camera_intrinsics_options->brown_k2,
+          camera_intrinsics_options->brown_k3,
+          camera_intrinsics_options->brown_k4);
+      brown_intrinsics->SetTangentialDistortion(
           camera_intrinsics_options->brown_p1,
           camera_intrinsics_options->brown_p2);
 
-        break;
-      }
+      break;
+    }
 
-    default:
-      assert(!"Unknown distortion model");
+    default: assert(!"Unknown distortion model");
   }
 }
 
 CameraIntrinsics* libmv_cameraIntrinsicsCreateFromOptions(
     const libmv_CameraIntrinsicsOptions* camera_intrinsics_options) {
-  CameraIntrinsics *camera_intrinsics = NULL;
+  CameraIntrinsics* camera_intrinsics = NULL;
   switch (camera_intrinsics_options->distortion_model) {
     case LIBMV_DISTORTION_MODEL_POLYNOMIAL:
       camera_intrinsics = LIBMV_OBJECT_NEW(PolynomialCameraIntrinsics);
@@ -457,8 +418,7 @@ CameraIntrinsics* libmv_cameraIntrinsicsCreateFromOptions(
     case LIBMV_DISTORTION_MODEL_BROWN:
       camera_intrinsics = LIBMV_OBJECT_NEW(BrownCameraIntrinsics);
       break;
-    default:
-      assert(!"Unknown distortion model");
+    default: assert(!"Unknown distortion model");
   }
   libmv_cameraIntrinsicsFillFromOptions(camera_intrinsics_options,
                                         camera_intrinsics);

intern/libmv/intern/camera_intrinsics.h

@@ -56,10 +56,10 @@ typedef struct libmv_CameraIntrinsicsOptions {
   double brown_p1, brown_p2;
 } libmv_CameraIntrinsicsOptions;
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsNew(
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsNew(
     const libmv_CameraIntrinsicsOptions* libmv_camera_intrinsics_options);
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsCopy(
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsCopy(
     const libmv_CameraIntrinsics* libmv_intrinsics);
 
 void libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics* libmv_intrinsics);
@@ -76,7 +76,7 @@ void libmv_cameraIntrinsicsExtractOptions(
 
 void libmv_cameraIntrinsicsUndistortByte(
     const libmv_CameraIntrinsics* libmv_intrinsics,
-    const unsigned char *source_image,
+    const unsigned char* source_image,
     int width,
     int height,
     float overscan,
@@ -94,12 +94,12 @@ void libmv_cameraIntrinsicsUndistortFloat(
 
 void libmv_cameraIntrinsicsDistortByte(
     const struct libmv_CameraIntrinsics* libmv_intrinsics,
-    const unsigned char *source_image,
+    const unsigned char* source_image,
     int width,
     int height,
     float overscan,
     int channels,
-    unsigned char *destination_image);
+    unsigned char* destination_image);
 
 void libmv_cameraIntrinsicsDistortFloat(
     const libmv_CameraIntrinsics* libmv_intrinsics,
@@ -131,7 +131,7 @@ void libmv_cameraIntrinsicsInvert(
 #ifdef __cplusplus
 
 namespace libmv {
-  class CameraIntrinsics;
+class CameraIntrinsics;
 }
 
 libmv::CameraIntrinsics* libmv_cameraIntrinsicsCreateFromOptions(

intern/libmv/intern/detector.cc

@@ -34,7 +34,7 @@ struct libmv_Features {
 
 namespace {
 
-libmv_Features *libmv_featuresFromVector(
+libmv_Features* libmv_featuresFromVector(
     const libmv::vector<Feature>& features) {
   libmv_Features* libmv_features = LIBMV_STRUCT_NEW(libmv_Features, 1);
   int count = features.size();
@@ -50,12 +50,12 @@ libmv_Features *libmv_featuresFromVector(
   return libmv_features;
 }
 
-void libmv_convertDetectorOptions(libmv_DetectOptions *options,
-                                  DetectOptions *detector_options) {
+void libmv_convertDetectorOptions(libmv_DetectOptions* options,
+                                  DetectOptions* detector_options) {
   switch (options->detector) {
-#define LIBMV_CONVERT(the_detector) \
-  case LIBMV_DETECTOR_ ## the_detector:                 \
-    detector_options->type = DetectOptions::the_detector; \
+#define LIBMV_CONVERT(the_detector)                                            \
+  case LIBMV_DETECTOR_##the_detector:                                          \
+    detector_options->type = DetectOptions::the_detector;                      \
     break;
     LIBMV_CONVERT(FAST)
     LIBMV_CONVERT(MORAVEC)
@@ -72,7 +72,7 @@ void libmv_convertDetectorOptions(libmv_DetectOptions *options,
 
 }  // namespace
 
-libmv_Features *libmv_detectFeaturesByte(const unsigned char* image_buffer,
+libmv_Features* libmv_detectFeaturesByte(const unsigned char* image_buffer,
                                          int width,
                                          int height,
                                          int channels,
@@ -133,7 +133,7 @@ void libmv_getFeature(const libmv_Features* libmv_features,
                       double* y,
                       double* score,
                       double* size) {
-  Feature &feature = libmv_features->features[number];
+  Feature& feature = libmv_features->features[number];
   *x = feature.x;
   *y = feature.y;
   *score = feature.score;

intern/libmv/intern/detector.h

@@ -38,7 +38,7 @@ typedef struct libmv_DetectOptions {
   int min_distance;
   int fast_min_trackness;
   int moravec_max_count;
-  unsigned char *moravec_pattern;
+  unsigned char* moravec_pattern;
   double harris_threshold;
 } libmv_DetectOptions;
 

intern/libmv/intern/frame_accessor.cc

@@ -36,20 +36,18 @@ struct LibmvFrameAccessor : public FrameAccessor {
                      libmv_ReleaseImageCallback release_image_callback,
                      libmv_GetMaskForTrackCallback get_mask_for_track_callback,
                      libmv_ReleaseMaskCallback release_mask_callback)
-    : user_data_(user_data),
-      get_image_callback_(get_image_callback),
-      release_image_callback_(release_image_callback),
-      get_mask_for_track_callback_(get_mask_for_track_callback),
-      release_mask_callback_(release_mask_callback) { }
+      : user_data_(user_data),
+        get_image_callback_(get_image_callback),
+        release_image_callback_(release_image_callback),
+        get_mask_for_track_callback_(get_mask_for_track_callback),
+        release_mask_callback_(release_mask_callback) {}
 
-  virtual ~LibmvFrameAccessor() {
-  }
+  virtual ~LibmvFrameAccessor() {}
 
   libmv_InputMode get_libmv_input_mode(InputMode input_mode) {
     switch (input_mode) {
-#define CHECK_INPUT_MODE(mode) \
-      case mode: \
-        return LIBMV_IMAGE_MODE_ ## mode;
+#define CHECK_INPUT_MODE(mode)                                                 \
+  case mode: return LIBMV_IMAGE_MODE_##mode;
       CHECK_INPUT_MODE(MONO)
       CHECK_INPUT_MODE(RGBA)
 #undef CHECK_INPUT_MODE
@@ -59,8 +57,7 @@ struct LibmvFrameAccessor : public FrameAccessor {
     return LIBMV_IMAGE_MODE_MONO;
   }
 
-  void get_libmv_region(const Region& region,
-                        libmv_Region* libmv_region) {
+  void get_libmv_region(const Region& region, libmv_Region* libmv_region) {
     libmv_region->min[0] = region.min(0);
     libmv_region->min[1] = region.min(1);
     libmv_region->max[0] = region.max(0);
@@ -74,7 +71,7 @@ struct LibmvFrameAccessor : public FrameAccessor {
                const Region* region,
                const Transform* transform,
                FloatImage* destination) {
-    float *float_buffer;
+    float* float_buffer;
     int width, height, channels;
     libmv_Region libmv_region;
     if (region) {
@@ -86,46 +83,41 @@ struct LibmvFrameAccessor : public FrameAccessor {
                                         get_libmv_input_mode(input_mode),
                                         downscale,
                                         region != NULL ? &libmv_region : NULL,
-                                        (libmv_FrameTransform*) transform,
+                                        (libmv_FrameTransform*)transform,
                                         &float_buffer,
                                         &width,
                                         &height,
                                         &channels);
 
     // TODO(sergey): Dumb code for until we can set data directly.
-    FloatImage temp_image(float_buffer,
-                          height,
-                          width,
-                          channels);
+    FloatImage temp_image(float_buffer, height, width, channels);
     destination->CopyFrom(temp_image);
 
     return cache_key;
   }
 
-  void ReleaseImage(Key cache_key) {
-    release_image_callback_(cache_key);
-  }
+  void ReleaseImage(Key cache_key) { release_image_callback_(cache_key); }
 
   Key GetMaskForTrack(int clip,
                       int frame,
                       int track,
                       const Region* region,
                       FloatImage* destination) {
-    float *float_buffer;
+    float* float_buffer;
     int width, height;
     libmv_Region libmv_region;
     if (region) {
       get_libmv_region(*region, &libmv_region);
     }
-    Key cache_key = get_mask_for_track_callback_(
-        user_data_,
-        clip,
-        frame,
-        track,
-        region != NULL ? &libmv_region : NULL,
-        &float_buffer,
-        &width,
-        &height);
+    Key cache_key =
+        get_mask_for_track_callback_(user_data_,
+                                     clip,
+                                     frame,
+                                     track,
+                                     region != NULL ? &libmv_region : NULL,
+                                     &float_buffer,
+                                     &width,
+                                     &height);
 
     if (cache_key == NULL) {
       // No mask for the given track.
@@ -133,30 +125,21 @@ struct LibmvFrameAccessor : public FrameAccessor {
     }
 
     // TODO(sergey): Dumb code for until we can set data directly.
-    FloatImage temp_image(float_buffer,
-                          height,
-                          width,
-                          1);
+    FloatImage temp_image(float_buffer, height, width, 1);
     destination->CopyFrom(temp_image);
 
     return cache_key;
   }
 
-  void ReleaseMask(Key key) {
-    release_mask_callback_(key);
-  }
+  void ReleaseMask(Key key) { release_mask_callback_(key); }
 
-  bool GetClipDimensions(int /*clip*/, int * /*width*/, int * /*height*/) {
+  bool GetClipDimensions(int /*clip*/, int* /*width*/, int* /*height*/) {
     return false;
   }
 
-  int NumClips() {
-    return 1;
-  }
+  int NumClips() { return 1; }
 
-  int NumFrames(int /*clip*/) {
-    return 0;
-  }
+  int NumFrames(int /*clip*/) { return 0; }
 
   libmv_FrameAccessorUserData* user_data_;
   libmv_GetImageCallback get_image_callback_;
@@ -173,35 +156,35 @@ libmv_FrameAccessor* libmv_FrameAccessorNew(
     libmv_ReleaseImageCallback release_image_callback,
     libmv_GetMaskForTrackCallback get_mask_for_track_callback,
     libmv_ReleaseMaskCallback release_mask_callback) {
-  return (libmv_FrameAccessor*) LIBMV_OBJECT_NEW(LibmvFrameAccessor,
-                                                 user_data,
-                                                 get_image_callback,
-                                                 release_image_callback,
-                                                 get_mask_for_track_callback,
-                                                 release_mask_callback);
+  return (libmv_FrameAccessor*)LIBMV_OBJECT_NEW(LibmvFrameAccessor,
+                                                user_data,
+                                                get_image_callback,
+                                                release_image_callback,
+                                                get_mask_for_track_callback,
+                                                release_mask_callback);
 }
 
 void libmv_FrameAccessorDestroy(libmv_FrameAccessor* frame_accessor) {
   LIBMV_OBJECT_DELETE(frame_accessor, LibmvFrameAccessor);
 }
 
-int64_t libmv_frameAccessorgetTransformKey(const libmv_FrameTransform *transform) {
-  return ((FrameAccessor::Transform*) transform)->key();
+int64_t libmv_frameAccessorgetTransformKey(
+    const libmv_FrameTransform* transform) {
+  return ((FrameAccessor::Transform*)transform)->key();
 }
 
-void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform *transform,
-                                        const libmv_FloatImage *input_image,
-                                        libmv_FloatImage *output_image) {
+void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform* transform,
+                                        const libmv_FloatImage* input_image,
+                                        libmv_FloatImage* output_image) {
   const FloatImage input(input_image->buffer,
                          input_image->height,
                          input_image->width,
                          input_image->channels);
 
   FloatImage output;
-  ((FrameAccessor::Transform*) transform)->run(input,
-                                               &output);
+  ((FrameAccessor::Transform*)transform)->run(input, &output);
 
-  int num_pixels = output.Width() *output.Height() * output.Depth();
+  int num_pixels = output.Width() * output.Height() * output.Depth();
   output_image->buffer = new float[num_pixels];
   memcpy(output_image->buffer, output.Data(), num_pixels * sizeof(float));
   output_image->width = output.Width();

intern/libmv/intern/frame_accessor.h

@@ -32,14 +32,14 @@ extern "C" {
 typedef struct libmv_FrameAccessor libmv_FrameAccessor;
 typedef struct libmv_FrameTransform libmv_FrameTransform;
 typedef struct libmv_FrameAccessorUserData libmv_FrameAccessorUserData;
-typedef void *libmv_CacheKey;
+typedef void* libmv_CacheKey;
 
 typedef enum {
   LIBMV_IMAGE_MODE_MONO,
   LIBMV_IMAGE_MODE_RGBA,
 } libmv_InputMode;
 
-typedef libmv_CacheKey (*libmv_GetImageCallback) (
+typedef libmv_CacheKey (*libmv_GetImageCallback)(
     libmv_FrameAccessorUserData* user_data,
     int clip,
     int frame,
@@ -52,9 +52,9 @@ typedef libmv_CacheKey (*libmv_GetImageCallback) (
     int* height,
     int* channels);
 
-typedef void (*libmv_ReleaseImageCallback) (libmv_CacheKey cache_key);
+typedef void (*libmv_ReleaseImageCallback)(libmv_CacheKey cache_key);
 
-typedef libmv_CacheKey (*libmv_GetMaskForTrackCallback) (
+typedef libmv_CacheKey (*libmv_GetMaskForTrackCallback)(
     libmv_FrameAccessorUserData* user_data,
     int clip,
     int frame,
@@ -63,7 +63,7 @@ typedef libmv_CacheKey (*libmv_GetMaskForTrackCallback) (
     float** destination,
     int* width,
     int* height);
-typedef void (*libmv_ReleaseMaskCallback) (libmv_CacheKey cache_key);
+typedef void (*libmv_ReleaseMaskCallback)(libmv_CacheKey cache_key);
 
 libmv_FrameAccessor* libmv_FrameAccessorNew(
     libmv_FrameAccessorUserData* user_data,
@@ -73,11 +73,12 @@ libmv_FrameAccessor* libmv_FrameAccessorNew(
     libmv_ReleaseMaskCallback release_mask_callback);
 void libmv_FrameAccessorDestroy(libmv_FrameAccessor* frame_accessor);
 
-int64_t libmv_frameAccessorgetTransformKey(const libmv_FrameTransform *transform);
+int64_t libmv_frameAccessorgetTransformKey(
+    const libmv_FrameTransform* transform);
 
-void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform *transform,
-                                        const libmv_FloatImage *input_image,
-                                        libmv_FloatImage *output_image);
+void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform* transform,
+                                        const libmv_FloatImage* input_image,
+                                        libmv_FloatImage* output_image);
 #ifdef __cplusplus
 }
 #endif

intern/libmv/intern/homography.cc

@@ -41,10 +41,8 @@ void libmv_homography2DFromCorrespondencesEuc(/* const */ double (*x1)[2],
   LG << "x2: " << x2_mat;
 
   libmv::EstimateHomographyOptions options;
-  libmv::EstimateHomography2DFromCorrespondences(x1_mat,
-                                                 x2_mat,
-                                                 options,
-                                                 &H_mat);
+  libmv::EstimateHomography2DFromCorrespondences(
+      x1_mat, x2_mat, options, &H_mat);
 
   LG << "H: " << H_mat;
 

intern/libmv/intern/image.cc

@@ -21,14 +21,14 @@
 #include "intern/utildefines.h"
 #include "libmv/tracking/track_region.h"
 
-#include <cassert>
 #include <png.h>
+#include <cassert>
 
 using libmv::FloatImage;
 using libmv::SamplePlanarPatch;
 
-void libmv_floatImageDestroy(libmv_FloatImage *image) {
-  delete [] image->buffer;
+void libmv_floatImageDestroy(libmv_FloatImage* image) {
+  delete[] image->buffer;
 }
 
 /* Image <-> buffers conversion */
@@ -63,8 +63,7 @@ void libmv_floatBufferToFloatImage(const float* buffer,
   }
 }
 
-void libmv_floatImageToFloatBuffer(const FloatImage &image,
-                                   float* buffer) {
+void libmv_floatImageToFloatBuffer(const FloatImage& image, float* buffer) {
   for (int y = 0, a = 0; y < image.Height(); y++) {
     for (int x = 0; x < image.Width(); x++) {
       for (int k = 0; k < image.Depth(); k++) {
@@ -74,9 +73,9 @@ void libmv_floatImageToFloatBuffer(const FloatImage &image,
   }
 }
 
-void libmv_floatImageToByteBuffer(const libmv::FloatImage &image,
+void libmv_floatImageToByteBuffer(const libmv::FloatImage& image,
                                   unsigned char* buffer) {
-  for (int y = 0, a= 0; y < image.Height(); y++) {
+  for (int y = 0, a = 0; y < image.Height(); y++) {
     for (int x = 0; x < image.Width(); x++) {
       for (int k = 0; k < image.Depth(); k++) {
         buffer[a++] = image(y, x, k) * 255.0f;
@@ -93,7 +92,7 @@ static bool savePNGImage(png_bytep* row_pointers,
                          const char* file_name) {
   png_infop info_ptr;
   png_structp png_ptr;
-  FILE *fp = fopen(file_name, "wb");
+  FILE* fp = fopen(file_name, "wb");
 
   if (fp == NULL) {
     return false;
@@ -153,7 +152,7 @@ bool libmv_saveImage(const FloatImage& image,
                      int x0,
                      int y0) {
   int x, y;
-  png_bytep *row_pointers;
+  png_bytep* row_pointers;
 
   assert(image.Depth() == 1);
 
@@ -180,9 +179,8 @@ bool libmv_saveImage(const FloatImage& image,
 
   static int image_counter = 0;
   char file_name[128];
-  snprintf(file_name, sizeof(file_name),
-           "%s_%02d.png",
-           prefix, ++image_counter);
+  snprintf(
+      file_name, sizeof(file_name), "%s_%02d.png", prefix, ++image_counter);
   bool result = savePNGImage(row_pointers,
                              image.Width(),
                              image.Height(),
@@ -191,9 +189,9 @@ bool libmv_saveImage(const FloatImage& image,
                              file_name);
 
   for (y = 0; y < image.Height(); y++) {
-    delete [] row_pointers[y];
+    delete[] row_pointers[y];
   }
-  delete [] row_pointers;
+  delete[] row_pointers;
 
   return result;
 }
@@ -211,7 +209,7 @@ void libmv_samplePlanarPatchFloat(const float* image,
                                   double* warped_position_x,
                                   double* warped_position_y) {
   FloatImage libmv_image, libmv_patch, libmv_mask;
-  FloatImage *libmv_mask_for_sample = NULL;
+  FloatImage* libmv_mask_for_sample = NULL;
 
   libmv_floatBufferToFloatImage(image, width, height, channels, &libmv_image);
 
@@ -221,8 +219,10 @@ void libmv_samplePlanarPatchFloat(const float* image,
   }
 
   SamplePlanarPatch(libmv_image,
-                    xs, ys,
-                    num_samples_x, num_samples_y,
+                    xs,
+                    ys,
+                    num_samples_x,
+                    num_samples_y,
                     libmv_mask_for_sample,
                     &libmv_patch,
                     warped_position_x,
@@ -232,19 +232,19 @@ void libmv_samplePlanarPatchFloat(const float* image,
 }
 
 void libmv_samplePlanarPatchByte(const unsigned char* image,
-                                  int width,
-                                  int height,
-                                  int channels,
-                                  const double* xs,
-                                  const double* ys,
-                                  int num_samples_x,
-                                  int num_samples_y,
-                                  const float* mask,
-                                  unsigned char* patch,
-                                  double* warped_position_x,
-                                  double* warped_position_y) {
+                                 int width,
+                                 int height,
+                                 int channels,
+                                 const double* xs,
+                                 const double* ys,
+                                 int num_samples_x,
+                                 int num_samples_y,
+                                 const float* mask,
+                                 unsigned char* patch,
+                                 double* warped_position_x,
+                                 double* warped_position_y) {
   libmv::FloatImage libmv_image, libmv_patch, libmv_mask;
-  libmv::FloatImage *libmv_mask_for_sample = NULL;
+  libmv::FloatImage* libmv_mask_for_sample = NULL;
 
   libmv_byteBufferToFloatImage(image, width, height, channels, &libmv_image);
 
@@ -254,8 +254,10 @@ void libmv_samplePlanarPatchByte(const unsigned char* image,
   }
 
   libmv::SamplePlanarPatch(libmv_image,
-                           xs, ys,
-                           num_samples_x, num_samples_y,
+                           xs,
+                           ys,
+                           num_samples_x,
+                           num_samples_y,
                            libmv_mask_for_sample,
                            &libmv_patch,
                            warped_position_x,

intern/libmv/intern/image.h

@@ -35,7 +35,7 @@ void libmv_floatBufferToFloatImage(const float* buffer,
                                    libmv::FloatImage* image);
 
 void libmv_floatImageToFloatBuffer(const libmv::FloatImage& image,
-                                   float *buffer);
+                                   float* buffer);
 
 void libmv_floatImageToByteBuffer(const libmv::FloatImage& image,
                                   unsigned char* buffer);
@@ -51,13 +51,13 @@ extern "C" {
 #endif
 
 typedef struct libmv_FloatImage {
-  float *buffer;
+  float* buffer;
   int width;
   int height;
   int channels;
 } libmv_FloatImage;
 
-void libmv_floatImageDestroy(libmv_FloatImage *image);
+void libmv_floatImageDestroy(libmv_FloatImage* image);
 
 void libmv_samplePlanarPatchFloat(const float* image,
                                   int width,
@@ -72,18 +72,18 @@ void libmv_samplePlanarPatchFloat(const float* image,
                                   double* warped_position_x,
                                   double* warped_position_y);
 
- void libmv_samplePlanarPatchByte(const unsigned char* image,
-                                  int width,
-                                  int height,
-                                  int channels,
-                                  const double* xs,
-                                  const double* ys,
-                                  int num_samples_x,
-                                  int num_samples_y,
-                                  const float* mask,
-                                  unsigned char* patch,
-                                  double* warped_position_x,
-                                  double* warped_position_y);
+void libmv_samplePlanarPatchByte(const unsigned char* image,
+                                 int width,
+                                 int height,
+                                 int channels,
+                                 const double* xs,
+                                 const double* ys,
+                                 int num_samples_x,
+                                 int num_samples_y,
+                                 const float* mask,
+                                 unsigned char* patch,
+                                 double* warped_position_x,
+                                 double* warped_position_y);
 
 #ifdef __cplusplus
 }

intern/libmv/intern/reconstruction.cc

@@ -24,8 +24,8 @@
 
 #include "libmv/logging/logging.h"
 #include "libmv/simple_pipeline/bundle.h"
-#include "libmv/simple_pipeline/keyframe_selection.h"
 #include "libmv/simple_pipeline/initialize_reconstruction.h"
+#include "libmv/simple_pipeline/keyframe_selection.h"
 #include "libmv/simple_pipeline/modal_solver.h"
 #include "libmv/simple_pipeline/pipeline.h"
 #include "libmv/simple_pipeline/reconstruction_scale.h"
@@ -39,19 +39,19 @@ using libmv::EuclideanScaleToUnity;
 using libmv::Marker;
 using libmv::ProgressUpdateCallback;
 
-using libmv::PolynomialCameraIntrinsics;
-using libmv::Tracks;
 using libmv::EuclideanBundle;
 using libmv::EuclideanCompleteReconstruction;
 using libmv::EuclideanReconstructTwoFrames;
 using libmv::EuclideanReprojectionError;
+using libmv::PolynomialCameraIntrinsics;
+using libmv::Tracks;
 
 struct libmv_Reconstruction {
   EuclideanReconstruction reconstruction;
 
   /* Used for per-track average error calculation after reconstruction */
   Tracks tracks;
-  CameraIntrinsics *intrinsics;
+  CameraIntrinsics* intrinsics;
 
   double error;
   bool is_valid;
@@ -63,7 +63,7 @@ class ReconstructUpdateCallback : public ProgressUpdateCallback {
  public:
   ReconstructUpdateCallback(
       reconstruct_progress_update_cb progress_update_callback,
-      void *callback_customdata) {
+      void* callback_customdata) {
     progress_update_callback_ = progress_update_callback;
     callback_customdata_ = callback_customdata;
   }
@@ -73,13 +73,14 @@ class ReconstructUpdateCallback : public ProgressUpdateCallback {
       progress_update_callback_(callback_customdata_, progress, message);
     }
   }
+
  protected:
   reconstruct_progress_update_cb progress_update_callback_;
   void* callback_customdata_;
 };
 
 void libmv_solveRefineIntrinsics(
-    const Tracks &tracks,
+    const Tracks& tracks,
     const int refine_intrinsics,
     const int bundle_constraints,
     reconstruct_progress_update_cb progress_update_callback,
@@ -96,11 +97,11 @@ void libmv_solveRefineIntrinsics(
     bundle_intrinsics |= libmv::BUNDLE_PRINCIPAL_POINT;
   }
 
-#define SET_DISTORTION_FLAG_CHECKED(type, coefficient) \
-  do { \
-    if (refine_intrinsics & LIBMV_REFINE_ ##  type ##_DISTORTION_ ## coefficient) { \
-      bundle_intrinsics |= libmv::BUNDLE_ ## type ## _ ## coefficient; \
-    } \
+#define SET_DISTORTION_FLAG_CHECKED(type, coefficient)                         \
+  do {                                                                         \
+    if (refine_intrinsics & LIBMV_REFINE_##type##_DISTORTION_##coefficient) {  \
+      bundle_intrinsics |= libmv::BUNDLE_##type##_##coefficient;               \
+    }                                                                          \
   } while (0)
 
   SET_DISTORTION_FLAG_CHECKED(RADIAL, K1);
@@ -123,20 +124,19 @@ void libmv_solveRefineIntrinsics(
 }
 
 void finishReconstruction(
-    const Tracks &tracks,
-    const CameraIntrinsics &camera_intrinsics,
-    libmv_Reconstruction *libmv_reconstruction,
+    const Tracks& tracks,
+    const CameraIntrinsics& camera_intrinsics,
+    libmv_Reconstruction* libmv_reconstruction,
     reconstruct_progress_update_cb progress_update_callback,
-    void *callback_customdata) {
-  EuclideanReconstruction &reconstruction =
-    libmv_reconstruction->reconstruction;
+    void* callback_customdata) {
+  EuclideanReconstruction& reconstruction =
+      libmv_reconstruction->reconstruction;
 
   /* Reprojection error calculation. */
   progress_update_callback(callback_customdata, 1.0, "Finishing solution");
   libmv_reconstruction->tracks = tracks;
-  libmv_reconstruction->error = EuclideanReprojectionError(tracks,
-                                                           reconstruction,
-                                                           camera_intrinsics);
+  libmv_reconstruction->error =
+      EuclideanReprojectionError(tracks, reconstruction, camera_intrinsics);
 }
 
 bool selectTwoKeyframesBasedOnGRICAndVariance(
@@ -148,9 +148,8 @@ bool selectTwoKeyframesBasedOnGRICAndVariance(
   libmv::vector<int> keyframes;
 
   /* Get list of all keyframe candidates first. */
-  SelectKeyframesBasedOnGRICAndVariance(normalized_tracks,
-                                        camera_intrinsics,
-                                        keyframes);
+  SelectKeyframesBasedOnGRICAndVariance(
+      normalized_tracks, camera_intrinsics, keyframes);
 
   if (keyframes.size() < 2) {
     LG << "Not enough keyframes detected by GRIC";
@@ -175,24 +174,20 @@ bool selectTwoKeyframesBasedOnGRICAndVariance(
     EuclideanReconstruction reconstruction;
     int current_keyframe = keyframes[i];
     libmv::vector<Marker> keyframe_markers =
-      normalized_tracks.MarkersForTracksInBothImages(previous_keyframe,
-                                                     current_keyframe);
+        normalized_tracks.MarkersForTracksInBothImages(previous_keyframe,
+                                                       current_keyframe);
 
     Tracks keyframe_tracks(keyframe_markers);
 
     /* get a solution from two keyframes only */
     EuclideanReconstructTwoFrames(keyframe_markers, &reconstruction);
     EuclideanBundle(keyframe_tracks, &reconstruction);
-    EuclideanCompleteReconstruction(keyframe_tracks,
-                                    &reconstruction,
-                                    NULL);
+    EuclideanCompleteReconstruction(keyframe_tracks, &reconstruction, NULL);
 
-    double current_error = EuclideanReprojectionError(tracks,
-                                                      reconstruction,
-                                                      camera_intrinsics);
+    double current_error =
+        EuclideanReprojectionError(tracks, reconstruction, camera_intrinsics);
 
-    LG << "Error between " << previous_keyframe
-       << " and " << current_keyframe
+    LG << "Error between " << previous_keyframe << " and " << current_keyframe
        << ": " << current_error;
 
     if (current_error < best_error) {
@@ -214,53 +209,49 @@ Marker libmv_projectMarker(const EuclideanPoint& point,
   projected /= projected(2);
 
   libmv::Marker reprojected_marker;
-  intrinsics.ApplyIntrinsics(projected(0), projected(1),
-                             &reprojected_marker.x,
-                             &reprojected_marker.y);
+  intrinsics.ApplyIntrinsics(
+      projected(0), projected(1), &reprojected_marker.x, &reprojected_marker.y);
 
   reprojected_marker.image = camera.image;
   reprojected_marker.track = point.track;
   return reprojected_marker;
 }
 
-void libmv_getNormalizedTracks(const Tracks &tracks,
-                               const CameraIntrinsics &camera_intrinsics,
-                               Tracks *normalized_tracks) {
+void libmv_getNormalizedTracks(const Tracks& tracks,
+                               const CameraIntrinsics& camera_intrinsics,
+                               Tracks* normalized_tracks) {
   libmv::vector<Marker> markers = tracks.AllMarkers();
   for (int i = 0; i < markers.size(); ++i) {
-    Marker &marker = markers[i];
-    camera_intrinsics.InvertIntrinsics(marker.x, marker.y,
-                                       &marker.x, &marker.y);
-    normalized_tracks->Insert(marker.image,
-                              marker.track,
-                              marker.x, marker.y,
-                              marker.weight);
+    Marker& marker = markers[i];
+    camera_intrinsics.InvertIntrinsics(
+        marker.x, marker.y, &marker.x, &marker.y);
+    normalized_tracks->Insert(
+        marker.image, marker.track, marker.x, marker.y, marker.weight);
   }
 }
 
 }  // namespace
 
-libmv_Reconstruction *libmv_solveReconstruction(
+libmv_Reconstruction* libmv_solveReconstruction(
     const libmv_Tracks* libmv_tracks,
     const libmv_CameraIntrinsicsOptions* libmv_camera_intrinsics_options,
     libmv_ReconstructionOptions* libmv_reconstruction_options,
     reconstruct_progress_update_cb progress_update_callback,
     void* callback_customdata) {
-  libmv_Reconstruction *libmv_reconstruction =
-    LIBMV_OBJECT_NEW(libmv_Reconstruction);
+  libmv_Reconstruction* libmv_reconstruction =
+      LIBMV_OBJECT_NEW(libmv_Reconstruction);
 
-  Tracks &tracks = *((Tracks *) libmv_tracks);
-  EuclideanReconstruction &reconstruction =
-    libmv_reconstruction->reconstruction;
+  Tracks& tracks = *((Tracks*)libmv_tracks);
+  EuclideanReconstruction& reconstruction =
+      libmv_reconstruction->reconstruction;
 
   ReconstructUpdateCallback update_callback =
-    ReconstructUpdateCallback(progress_update_callback,
-                              callback_customdata);
+      ReconstructUpdateCallback(progress_update_callback, callback_customdata);
 
   /* Retrieve reconstruction options from C-API to libmv API. */
-  CameraIntrinsics *camera_intrinsics;
+  CameraIntrinsics* camera_intrinsics;
   camera_intrinsics = libmv_reconstruction->intrinsics =
-    libmv_cameraIntrinsicsCreateFromOptions(libmv_camera_intrinsics_options);
+      libmv_cameraIntrinsicsCreateFromOptions(libmv_camera_intrinsics_options);
 
   /* Invert the camera intrinsics/ */
   Tracks normalized_tracks;
@@ -276,10 +267,10 @@ libmv_Reconstruction *libmv_solveReconstruction(
     update_callback.invoke(0, "Selecting keyframes");
 
     if (selectTwoKeyframesBasedOnGRICAndVariance(tracks,
-                                             normalized_tracks,
-                                             *camera_intrinsics,
-                                             keyframe1,
-                                             keyframe2)) {
+                                                 normalized_tracks,
+                                                 *camera_intrinsics,
+                                                 keyframe1,
+                                                 keyframe2)) {
       /* so keyframes in the interface would be updated */
       libmv_reconstruction_options->keyframe1 = keyframe1;
       libmv_reconstruction_options->keyframe2 = keyframe2;
@@ -290,7 +281,7 @@ libmv_Reconstruction *libmv_solveReconstruction(
   LG << "frames to init from: " << keyframe1 << " " << keyframe2;
 
   libmv::vector<Marker> keyframe_markers =
-    normalized_tracks.MarkersForTracksInBothImages(keyframe1, keyframe2);
+      normalized_tracks.MarkersForTracksInBothImages(keyframe1, keyframe2);
 
   LG << "number of markers for init: " << keyframe_markers.size();
 
@@ -309,14 +300,12 @@ libmv_Reconstruction *libmv_solveReconstruction(
   }
 
   EuclideanBundle(normalized_tracks, &reconstruction);
-  EuclideanCompleteReconstruction(normalized_tracks,
-                                  &reconstruction,
-                                  &update_callback);
+  EuclideanCompleteReconstruction(
+      normalized_tracks, &reconstruction, &update_callback);
 
   /* Refinement. */
   if (libmv_reconstruction_options->refine_intrinsics) {
-    libmv_solveRefineIntrinsics(
-                                tracks,
+    libmv_solveRefineIntrinsics(tracks,
                                 libmv_reconstruction_options->refine_intrinsics,
                                 libmv::BUNDLE_NO_CONSTRAINTS,
                                 progress_update_callback,
@@ -336,31 +325,29 @@ libmv_Reconstruction *libmv_solveReconstruction(
                        callback_customdata);
 
   libmv_reconstruction->is_valid = true;
-  return (libmv_Reconstruction *) libmv_reconstruction;
+  return (libmv_Reconstruction*)libmv_reconstruction;
 }
 
-libmv_Reconstruction *libmv_solveModal(
-    const libmv_Tracks *libmv_tracks,
-    const libmv_CameraIntrinsicsOptions *libmv_camera_intrinsics_options,
-    const libmv_ReconstructionOptions *libmv_reconstruction_options,
+libmv_Reconstruction* libmv_solveModal(
+    const libmv_Tracks* libmv_tracks,
+    const libmv_CameraIntrinsicsOptions* libmv_camera_intrinsics_options,
+    const libmv_ReconstructionOptions* libmv_reconstruction_options,
     reconstruct_progress_update_cb progress_update_callback,
-    void *callback_customdata) {
-  libmv_Reconstruction *libmv_reconstruction =
-    LIBMV_OBJECT_NEW(libmv_Reconstruction);
+    void* callback_customdata) {
+  libmv_Reconstruction* libmv_reconstruction =
+      LIBMV_OBJECT_NEW(libmv_Reconstruction);
 
-  Tracks &tracks = *((Tracks *) libmv_tracks);
-  EuclideanReconstruction &reconstruction =
-    libmv_reconstruction->reconstruction;
+  Tracks& tracks = *((Tracks*)libmv_tracks);
+  EuclideanReconstruction& reconstruction =
+      libmv_reconstruction->reconstruction;
 
   ReconstructUpdateCallback update_callback =
-    ReconstructUpdateCallback(progress_update_callback,
-                              callback_customdata);
+      ReconstructUpdateCallback(progress_update_callback, callback_customdata);
 
   /* Retrieve reconstruction options from C-API to libmv API. */
-  CameraIntrinsics *camera_intrinsics;
+  CameraIntrinsics* camera_intrinsics;
   camera_intrinsics = libmv_reconstruction->intrinsics =
-    libmv_cameraIntrinsicsCreateFromOptions(
-                                            libmv_camera_intrinsics_options);
+      libmv_cameraIntrinsicsCreateFromOptions(libmv_camera_intrinsics_options);
 
   /* Invert the camera intrinsics. */
   Tracks normalized_tracks;
@@ -378,11 +365,11 @@ libmv_Reconstruction *libmv_solveModal(
 
   /* Refinement. */
   if (libmv_reconstruction_options->refine_intrinsics) {
-    libmv_solveRefineIntrinsics(
-                                tracks,
+    libmv_solveRefineIntrinsics(tracks,
                                 libmv_reconstruction_options->refine_intrinsics,
                                 libmv::BUNDLE_NO_TRANSLATION,
-                                progress_update_callback, callback_customdata,
+                                progress_update_callback,
+                                callback_customdata,
                                 &reconstruction,
                                 camera_intrinsics);
   }
@@ -395,26 +382,25 @@ libmv_Reconstruction *libmv_solveModal(
                        callback_customdata);
 
   libmv_reconstruction->is_valid = true;
-  return (libmv_Reconstruction *) libmv_reconstruction;
+  return (libmv_Reconstruction*)libmv_reconstruction;
 }
 
-int libmv_reconstructionIsValid(libmv_Reconstruction *libmv_reconstruction) {
+int libmv_reconstructionIsValid(libmv_Reconstruction* libmv_reconstruction) {
   return libmv_reconstruction->is_valid;
 }
 
-void libmv_reconstructionDestroy(libmv_Reconstruction *libmv_reconstruction) {
+void libmv_reconstructionDestroy(libmv_Reconstruction* libmv_reconstruction) {
   LIBMV_OBJECT_DELETE(libmv_reconstruction->intrinsics, CameraIntrinsics);
   LIBMV_OBJECT_DELETE(libmv_reconstruction, libmv_Reconstruction);
 }
 
 int libmv_reprojectionPointForTrack(
-    const libmv_Reconstruction *libmv_reconstruction,
+    const libmv_Reconstruction* libmv_reconstruction,
     int track,
     double pos[3]) {
-  const EuclideanReconstruction *reconstruction =
-    &libmv_reconstruction->reconstruction;
-  const EuclideanPoint *point =
-    reconstruction->PointForTrack(track);
+  const EuclideanReconstruction* reconstruction =
+      &libmv_reconstruction->reconstruction;
+  const EuclideanPoint* point = reconstruction->PointForTrack(track);
   if (point) {
     pos[0] = point->X[0];
     pos[1] = point->X[2];
@@ -425,23 +411,22 @@ int libmv_reprojectionPointForTrack(
 }
 
 double libmv_reprojectionErrorForTrack(
-    const libmv_Reconstruction *libmv_reconstruction,
-    int track) {
-  const EuclideanReconstruction *reconstruction =
-    &libmv_reconstruction->reconstruction;
-  const CameraIntrinsics *intrinsics = libmv_reconstruction->intrinsics;
+    const libmv_Reconstruction* libmv_reconstruction, int track) {
+  const EuclideanReconstruction* reconstruction =
+      &libmv_reconstruction->reconstruction;
+  const CameraIntrinsics* intrinsics = libmv_reconstruction->intrinsics;
   libmv::vector<Marker> markers =
-    libmv_reconstruction->tracks.MarkersForTrack(track);
+      libmv_reconstruction->tracks.MarkersForTrack(track);
 
   int num_reprojected = 0;
   double total_error = 0.0;
 
   for (int i = 0; i < markers.size(); ++i) {
     double weight = markers[i].weight;
-    const EuclideanCamera *camera =
-      reconstruction->CameraForImage(markers[i].image);
-    const EuclideanPoint *point =
-      reconstruction->PointForTrack(markers[i].track);
+    const EuclideanCamera* camera =
+        reconstruction->CameraForImage(markers[i].image);
+    const EuclideanPoint* point =
+        reconstruction->PointForTrack(markers[i].track);
 
     if (!camera || !point || weight == 0.0) {
       continue;
@@ -450,7 +435,7 @@ double libmv_reprojectionErrorForTrack(
     num_reprojected++;
 
     Marker reprojected_marker =
-      libmv_projectMarker(*point, *camera, *intrinsics);
+        libmv_projectMarker(*point, *camera, *intrinsics);
     double ex = (reprojected_marker.x - markers[i].x) * weight;
     double ey = (reprojected_marker.y - markers[i].y) * weight;
 
@@ -461,14 +446,13 @@ double libmv_reprojectionErrorForTrack(
 }
 
 double libmv_reprojectionErrorForImage(
-    const libmv_Reconstruction *libmv_reconstruction,
-    int image) {
-  const EuclideanReconstruction *reconstruction =
-    &libmv_reconstruction->reconstruction;
-  const CameraIntrinsics *intrinsics = libmv_reconstruction->intrinsics;
+    const libmv_Reconstruction* libmv_reconstruction, int image) {
+  const EuclideanReconstruction* reconstruction =
+      &libmv_reconstruction->reconstruction;
+  const CameraIntrinsics* intrinsics = libmv_reconstruction->intrinsics;
   libmv::vector<Marker> markers =
-    libmv_reconstruction->tracks.MarkersInImage(image);
-  const EuclideanCamera *camera = reconstruction->CameraForImage(image);
+      libmv_reconstruction->tracks.MarkersInImage(image);
+  const EuclideanCamera* camera = reconstruction->CameraForImage(image);
   int num_reprojected = 0;
   double total_error = 0.0;
 
@@ -477,8 +461,8 @@ double libmv_reprojectionErrorForImage(
   }
 
   for (int i = 0; i < markers.size(); ++i) {
-    const EuclideanPoint *point =
-      reconstruction->PointForTrack(markers[i].track);
+    const EuclideanPoint* point =
+        reconstruction->PointForTrack(markers[i].track);
 
     if (!point) {
       continue;
@@ -487,7 +471,7 @@ double libmv_reprojectionErrorForImage(
     num_reprojected++;
 
     Marker reprojected_marker =
-      libmv_projectMarker(*point, *camera, *intrinsics);
+        libmv_projectMarker(*point, *camera, *intrinsics);
     double ex = (reprojected_marker.x - markers[i].x) * markers[i].weight;
     double ey = (reprojected_marker.y - markers[i].y) * markers[i].weight;
 
@@ -498,13 +482,12 @@ double libmv_reprojectionErrorForImage(
 }
 
 int libmv_reprojectionCameraForImage(
-    const libmv_Reconstruction *libmv_reconstruction,
+    const libmv_Reconstruction* libmv_reconstruction,
     int image,
     double mat[4][4]) {
-  const EuclideanReconstruction *reconstruction =
-    &libmv_reconstruction->reconstruction;
-  const EuclideanCamera *camera =
-    reconstruction->CameraForImage(image);
+  const EuclideanReconstruction* reconstruction =
+      &libmv_reconstruction->reconstruction;
+  const EuclideanCamera* camera = reconstruction->CameraForImage(image);
 
   if (camera) {
     for (int j = 0; j < 3; ++j) {
@@ -541,11 +524,11 @@ int libmv_reprojectionCameraForImage(
 }
 
 double libmv_reprojectionError(
-    const libmv_Reconstruction *libmv_reconstruction) {
+    const libmv_Reconstruction* libmv_reconstruction) {
   return libmv_reconstruction->error;
 }
 
-libmv_CameraIntrinsics *libmv_reconstructionExtractIntrinsics(
-    libmv_Reconstruction *libmv_reconstruction) {
-  return (libmv_CameraIntrinsics *) libmv_reconstruction->intrinsics;
+libmv_CameraIntrinsics* libmv_reconstructionExtractIntrinsics(
+    libmv_Reconstruction* libmv_reconstruction) {
+  return (libmv_CameraIntrinsics*)libmv_reconstruction->intrinsics;
 }

intern/libmv/intern/reconstruction.h

@@ -31,17 +31,16 @@ struct libmv_CameraIntrinsicsOptions;
 typedef struct libmv_Reconstruction libmv_Reconstruction;
 
 enum {
-  LIBMV_REFINE_FOCAL_LENGTH             = (1 << 0),
-  LIBMV_REFINE_PRINCIPAL_POINT          = (1 << 1),
+  LIBMV_REFINE_FOCAL_LENGTH = (1 << 0),
+  LIBMV_REFINE_PRINCIPAL_POINT = (1 << 1),
 
-  LIBMV_REFINE_RADIAL_DISTORTION_K1     = (1 << 2),
-  LIBMV_REFINE_RADIAL_DISTORTION_K2     = (1 << 3),
-  LIBMV_REFINE_RADIAL_DISTORTION_K3     = (1 << 4),
-  LIBMV_REFINE_RADIAL_DISTORTION_K4     = (1 << 5),
-  LIBMV_REFINE_RADIAL_DISTORTION        = (LIBMV_REFINE_RADIAL_DISTORTION_K1 |
-                                           LIBMV_REFINE_RADIAL_DISTORTION_K2 |
-                                           LIBMV_REFINE_RADIAL_DISTORTION_K3 |
-                                           LIBMV_REFINE_RADIAL_DISTORTION_K4),
+  LIBMV_REFINE_RADIAL_DISTORTION_K1 = (1 << 2),
+  LIBMV_REFINE_RADIAL_DISTORTION_K2 = (1 << 3),
+  LIBMV_REFINE_RADIAL_DISTORTION_K3 = (1 << 4),
+  LIBMV_REFINE_RADIAL_DISTORTION_K4 = (1 << 5),
+  LIBMV_REFINE_RADIAL_DISTORTION =
+      (LIBMV_REFINE_RADIAL_DISTORTION_K1 | LIBMV_REFINE_RADIAL_DISTORTION_K2 |
+       LIBMV_REFINE_RADIAL_DISTORTION_K3 | LIBMV_REFINE_RADIAL_DISTORTION_K4),
 
   LIBMV_REFINE_TANGENTIAL_DISTORTION_P1 = (1 << 6),
   LIBMV_REFINE_TANGENTIAL_DISTORTION_P2 = (1 << 7),
@@ -55,9 +54,9 @@ typedef struct libmv_ReconstructionOptions {
   int refine_intrinsics;
 } libmv_ReconstructionOptions;
 
-typedef void (*reconstruct_progress_update_cb) (void* customdata,
-                                                double progress,
-                                                const char* message);
+typedef void (*reconstruct_progress_update_cb)(void* customdata,
+                                               double progress,
+                                               const char* message);
 
 libmv_Reconstruction* libmv_solveReconstruction(
     const struct libmv_Tracks* libmv_tracks,
@@ -73,35 +72,32 @@ libmv_Reconstruction* libmv_solveModal(
     reconstruct_progress_update_cb progress_update_callback,
     void* callback_customdata);
 
-int libmv_reconstructionIsValid(libmv_Reconstruction *libmv_reconstruction);
+int libmv_reconstructionIsValid(libmv_Reconstruction* libmv_reconstruction);
 
 void libmv_reconstructionDestroy(libmv_Reconstruction* libmv_reconstruction);
 
 int libmv_reprojectionPointForTrack(
-    const libmv_Reconstruction* libmv_reconstruction,
-    int track,
-    double pos[3]);
+    const libmv_Reconstruction* libmv_reconstruction, int track, double pos[3]);
 
 double libmv_reprojectionErrorForTrack(
-    const libmv_Reconstruction* libmv_reconstruction,
-    int track);
+    const libmv_Reconstruction* libmv_reconstruction, int track);
 
 double libmv_reprojectionErrorForImage(
-    const libmv_Reconstruction* libmv_reconstruction,
-    int image);
+    const libmv_Reconstruction* libmv_reconstruction, int image);
 
 int libmv_reprojectionCameraForImage(
     const libmv_Reconstruction* libmv_reconstruction,
     int image,
     double mat[4][4]);
 
-double libmv_reprojectionError(const libmv_Reconstruction* libmv_reconstruction);
+double libmv_reprojectionError(
+    const libmv_Reconstruction* libmv_reconstruction);
 
 struct libmv_CameraIntrinsics* libmv_reconstructionExtractIntrinsics(
-    libmv_Reconstruction *libmv_Reconstruction);
+    libmv_Reconstruction* libmv_Reconstruction);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif   // LIBMV_C_API_RECONSTRUCTION_H_
+#endif  // LIBMV_C_API_RECONSTRUCTION_H_

intern/libmv/intern/stub.cc

@@ -24,7 +24,7 @@
 
 /* ************ Logging ************ */
 
-void libmv_initLogging(const char * /*argv0*/) {
+void libmv_initLogging(const char* /*argv0*/) {
 }
 
 void libmv_startDebugLogging(void) {
@@ -36,18 +36,18 @@ void libmv_setLoggingVerbosity(int /*verbosity*/) {
 /* ************ Planar tracker ************ */
 
 /* TrackRegion (new planar tracker) */
-int libmv_trackRegion(const libmv_TrackRegionOptions * /*options*/,
-                      const float * /*image1*/,
+int libmv_trackRegion(const libmv_TrackRegionOptions* /*options*/,
+                      const float* /*image1*/,
                       int /*image1_width*/,
                       int /*image1_height*/,
-                      const float * /*image2*/,
+                      const float* /*image2*/,
                       int /*image2_width*/,
                       int /*image2_height*/,
-                      const double *x1,
-                      const double *y1,
-                      libmv_TrackRegionResult *result,
-                      double *x2,
-                      double *y2) {
+                      const double* x1,
+                      const double* y1,
+                      libmv_TrackRegionResult* result,
+                      double* x2,
+                      double* y2) {
   /* Convert to doubles for the libmv api. The four corners and the center. */
   for (int i = 0; i < 5; ++i) {
     x2[i] = x1[i];
@@ -61,46 +61,46 @@ int libmv_trackRegion(const libmv_TrackRegionOptions * /*options*/,
   return false;
 }
 
-void libmv_samplePlanarPatchFloat(const float * /*image*/,
+void libmv_samplePlanarPatchFloat(const float* /*image*/,
                                   int /*width*/,
                                   int /*height*/,
                                   int /*channels*/,
-                                  const double * /*xs*/,
-                                  const double * /*ys*/,
+                                  const double* /*xs*/,
+                                  const double* /*ys*/,
                                   int /*num_samples_x*/,
                                   int /*num_samples_y*/,
-                                  const float * /*mask*/,
-                                  float * /*patch*/,
-                                  double * /*warped_position_x*/,
-                                  double * /*warped_position_y*/) {
+                                  const float* /*mask*/,
+                                  float* /*patch*/,
+                                  double* /*warped_position_x*/,
+                                  double* /*warped_position_y*/) {
   /* TODO(sergey): implement */
 }
 
-void libmv_samplePlanarPatchByte(const unsigned char * /*image*/,
+void libmv_samplePlanarPatchByte(const unsigned char* /*image*/,
                                  int /*width*/,
                                  int /*height*/,
                                  int /*channels*/,
-                                 const double * /*xs*/,
-                                 const double * /*ys*/,
-                                 int /*num_samples_x*/, int /*num_samples_y*/,
-                                 const float * /*mask*/,
-                                 unsigned char * /*patch*/,
-                                 double * /*warped_position_x*/,
-                                 double * /*warped_position_y*/) {
+                                 const double* /*xs*/,
+                                 const double* /*ys*/,
+                                 int /*num_samples_x*/,
+                                 int /*num_samples_y*/,
+                                 const float* /*mask*/,
+                                 unsigned char* /*patch*/,
+                                 double* /*warped_position_x*/,
+                                 double* /*warped_position_y*/) {
   /* TODO(sergey): implement */
 }
 
-void libmv_floatImageDestroy(libmv_FloatImage* /*image*/)
-{
+void libmv_floatImageDestroy(libmv_FloatImage* /*image*/) {
 }
 
 /* ************ Tracks ************ */
 
-libmv_Tracks *libmv_tracksNew(void) {
+libmv_Tracks* libmv_tracksNew(void) {
   return NULL;
 }
 
-void libmv_tracksInsert(libmv_Tracks * /*libmv_tracks*/,
+void libmv_tracksInsert(libmv_Tracks* /*libmv_tracks*/,
                         int /*image*/,
                         int /*track*/,
                         double /*x*/,
@@ -108,152 +108,152 @@ void libmv_tracksInsert(libmv_Tracks * /*libmv_tracks*/,
                         double /*weight*/) {
 }
 
-void libmv_tracksDestroy(libmv_Tracks * /*libmv_tracks*/) {
+void libmv_tracksDestroy(libmv_Tracks* /*libmv_tracks*/) {
 }
 
 /* ************ Reconstruction solver ************ */
 
-libmv_Reconstruction *libmv_solveReconstruction(
-    const libmv_Tracks * /*libmv_tracks*/,
-    const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
-    libmv_ReconstructionOptions * /*libmv_reconstruction_options*/,
+libmv_Reconstruction* libmv_solveReconstruction(
+    const libmv_Tracks* /*libmv_tracks*/,
+    const libmv_CameraIntrinsicsOptions* /*libmv_camera_intrinsics_options*/,
+    libmv_ReconstructionOptions* /*libmv_reconstruction_options*/,
     reconstruct_progress_update_cb /*progress_update_callback*/,
-    void * /*callback_customdata*/) {
+    void* /*callback_customdata*/) {
   return NULL;
 }
 
-libmv_Reconstruction *libmv_solveModal(
-    const libmv_Tracks * /*libmv_tracks*/,
-    const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
-    const libmv_ReconstructionOptions * /*libmv_reconstruction_options*/,
+libmv_Reconstruction* libmv_solveModal(
+    const libmv_Tracks* /*libmv_tracks*/,
+    const libmv_CameraIntrinsicsOptions* /*libmv_camera_intrinsics_options*/,
+    const libmv_ReconstructionOptions* /*libmv_reconstruction_options*/,
     reconstruct_progress_update_cb /*progress_update_callback*/,
-    void * /*callback_customdata*/) {
+    void* /*callback_customdata*/) {
   return NULL;
 }
 
-int libmv_reconstructionIsValid(libmv_Reconstruction * /*libmv_reconstruction*/) {
+int libmv_reconstructionIsValid(
+    libmv_Reconstruction* /*libmv_reconstruction*/) {
   return 0;
 }
 
 int libmv_reprojectionPointForTrack(
-    const libmv_Reconstruction * /*libmv_reconstruction*/,
+    const libmv_Reconstruction* /*libmv_reconstruction*/,
     int /*track*/,
     double /*pos*/[3]) {
   return 0;
 }
 
 double libmv_reprojectionErrorForTrack(
-    const libmv_Reconstruction * /*libmv_reconstruction*/,
-    int /*track*/) {
+    const libmv_Reconstruction* /*libmv_reconstruction*/, int /*track*/) {
   return 0.0;
 }
 
 double libmv_reprojectionErrorForImage(
-    const libmv_Reconstruction * /*libmv_reconstruction*/,
-    int /*image*/) {
+    const libmv_Reconstruction* /*libmv_reconstruction*/, int /*image*/) {
   return 0.0;
 }
 
 int libmv_reprojectionCameraForImage(
-    const libmv_Reconstruction * /*libmv_reconstruction*/,
+    const libmv_Reconstruction* /*libmv_reconstruction*/,
     int /*image*/,
     double /*mat*/[4][4]) {
   return 0;
 }
 
 double libmv_reprojectionError(
-    const libmv_Reconstruction * /*libmv_reconstruction*/) {
+    const libmv_Reconstruction* /*libmv_reconstruction*/) {
   return 0.0;
 }
 
 void libmv_reconstructionDestroy(
-    struct libmv_Reconstruction * /*libmv_reconstruction*/) {
+    struct libmv_Reconstruction* /*libmv_reconstruction*/) {
 }
 
 /* ************ Feature detector ************ */
 
-libmv_Features *libmv_detectFeaturesByte(const unsigned char * /*image_buffer*/,
+libmv_Features* libmv_detectFeaturesByte(const unsigned char* /*image_buffer*/,
                                          int /*width*/,
                                          int /*height*/,
                                          int /*channels*/,
-                                         libmv_DetectOptions * /*options*/) {
+                                         libmv_DetectOptions* /*options*/) {
   return NULL;
 }
 
-struct libmv_Features *libmv_detectFeaturesFloat(
-    const float * /*image_buffer*/,
+struct libmv_Features* libmv_detectFeaturesFloat(
+    const float* /*image_buffer*/,
     int /*width*/,
     int /*height*/,
     int /*channels*/,
-    libmv_DetectOptions * /*options*/) {
+    libmv_DetectOptions* /*options*/) {
   return NULL;
 }
 
-int libmv_countFeatures(const libmv_Features * /*libmv_features*/) {
+int libmv_countFeatures(const libmv_Features* /*libmv_features*/) {
   return 0;
 }
 
-void libmv_getFeature(const libmv_Features * /*libmv_features*/,
+void libmv_getFeature(const libmv_Features* /*libmv_features*/,
                       int /*number*/,
-                      double *x,
-                      double *y,
-                      double *score,
-                      double *size) {
+                      double* x,
+                      double* y,
+                      double* score,
+                      double* size) {
   *x = 0.0;
   *y = 0.0;
   *score = 0.0;
   *size = 0.0;
 }
 
-void libmv_featuresDestroy(struct libmv_Features * /*libmv_features*/) {
+void libmv_featuresDestroy(struct libmv_Features* /*libmv_features*/) {
 }
 
 /* ************ Camera intrinsics ************ */
 
-libmv_CameraIntrinsics *libmv_reconstructionExtractIntrinsics(
-    libmv_Reconstruction * /*libmv_reconstruction*/) {
+libmv_CameraIntrinsics* libmv_reconstructionExtractIntrinsics(
+    libmv_Reconstruction* /*libmv_reconstruction*/) {
   return NULL;
 }
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsNew(
-    const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/) {
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsNew(
+    const libmv_CameraIntrinsicsOptions* /*libmv_camera_intrinsics_options*/) {
   return NULL;
 }
 
-libmv_CameraIntrinsics *libmv_cameraIntrinsicsCopy(
-    const libmv_CameraIntrinsics * /*libmvIntrinsics*/) {
+libmv_CameraIntrinsics* libmv_cameraIntrinsicsCopy(
+    const libmv_CameraIntrinsics* /*libmvIntrinsics*/) {
   return NULL;
 }
 
 void libmv_cameraIntrinsicsDestroy(
-    libmv_CameraIntrinsics * /*libmvIntrinsics*/) {
+    libmv_CameraIntrinsics* /*libmvIntrinsics*/) {
 }
 
 void libmv_cameraIntrinsicsUpdate(
-    const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
-    libmv_CameraIntrinsics * /*libmv_intrinsics*/) {
+    const libmv_CameraIntrinsicsOptions* /*libmv_camera_intrinsics_options*/,
+    libmv_CameraIntrinsics* /*libmv_intrinsics*/) {
 }
 
 void libmv_cameraIntrinsicsSetThreads(
-    libmv_CameraIntrinsics * /*libmv_intrinsics*/,
-    int /*threads*/) {
+    libmv_CameraIntrinsics* /*libmv_intrinsics*/, int /*threads*/) {
 }
 
 void libmv_cameraIntrinsicsExtractOptions(
-    const libmv_CameraIntrinsics * /*libmv_intrinsics*/,
-    libmv_CameraIntrinsicsOptions *camera_intrinsics_options) {
+    const libmv_CameraIntrinsics* /*libmv_intrinsics*/,
+    libmv_CameraIntrinsicsOptions* camera_intrinsics_options) {
   memset(camera_intrinsics_options, 0, sizeof(libmv_CameraIntrinsicsOptions));
   camera_intrinsics_options->focal_length = 1.0;
 }
 
 void libmv_cameraIntrinsicsUndistortByte(
-    const libmv_CameraIntrinsics * /*libmv_intrinsics*/,
-    const unsigned char *source_image,
-    int width, int height,
+    const libmv_CameraIntrinsics* /*libmv_intrinsics*/,
+    const unsigned char* source_image,
+    int width,
+    int height,
     float /*overscan*/,
     int channels,
-    unsigned char *destination_image) {
-  memcpy(destination_image, source_image,
+    unsigned char* destination_image) {
+  memcpy(destination_image,
+         source_image,
          channels * width * height * sizeof(unsigned char));
 }
 
@@ -265,19 +265,21 @@ void libmv_cameraIntrinsicsUndistortFloat(
     float /*overscan*/,
     int channels,
     float* destination_image) {
-  memcpy(destination_image, source_image,
+  memcpy(destination_image,
+         source_image,
          channels * width * height * sizeof(float));
 }
 
 void libmv_cameraIntrinsicsDistortByte(
     const struct libmv_CameraIntrinsics* /*libmv_intrinsics*/,
-    const unsigned char *source_image,
+    const unsigned char* source_image,
     int width,
     int height,
     float /*overscan*/,
     int channels,
-    unsigned char *destination_image) {
-  memcpy(destination_image, source_image,
+    unsigned char* destination_image) {
+  memcpy(destination_image,
+         source_image,
          channels * width * height * sizeof(unsigned char));
 }
 
@@ -289,7 +291,8 @@ void libmv_cameraIntrinsicsDistortFloat(
     float /*overscan*/,
     int channels,
     float* destination_image) {
-  memcpy(destination_image, source_image,
+  memcpy(destination_image,
+         source_image,
          channels * width * height * sizeof(float));
 }
 
@@ -315,8 +318,8 @@ void libmv_cameraIntrinsicsInvert(
   *y1 = 0.0;
 }
 
-void libmv_homography2DFromCorrespondencesEuc(/* const */ double (* /*x1*/)[2],
-                                              /* const */ double (* /*x2*/)[2],
+void libmv_homography2DFromCorrespondencesEuc(/* const */ double (*/*x1*/)[2],
+                                              /* const */ double (*/*x2*/)[2],
                                               int /*num_points*/,
                                               double H[3][3]) {
   memset(H, 0, sizeof(double[3][3]));
@@ -327,45 +330,38 @@ void libmv_homography2DFromCorrespondencesEuc(/* const */ double (* /*x1*/)[2],
 
 /* ************ autotrack ************ */
 
-libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor* /*frame_accessor*/)
-{
+libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor* /*frame_accessor*/) {
   return NULL;
 }
 
-void libmv_autoTrackDestroy(libmv_AutoTrack* /*libmv_autotrack*/)
-{
+void libmv_autoTrackDestroy(libmv_AutoTrack* /*libmv_autotrack*/) {
 }
 
 void libmv_autoTrackSetOptions(libmv_AutoTrack* /*libmv_autotrack*/,
-                               const libmv_AutoTrackOptions* /*options*/)
-{
+                               const libmv_AutoTrackOptions* /*options*/) {
 }
 
 int libmv_autoTrackMarker(libmv_AutoTrack* /*libmv_autotrack*/,
                           const libmv_TrackRegionOptions* /*libmv_options*/,
-                          libmv_Marker * /*libmv_tracker_marker*/,
-                          libmv_TrackRegionResult* /*libmv_result*/)
-{
+                          libmv_Marker* /*libmv_tracker_marker*/,
+                          libmv_TrackRegionResult* /*libmv_result*/) {
   return 0;
 }
 
 void libmv_autoTrackAddMarker(libmv_AutoTrack* /*libmv_autotrack*/,
-                              const libmv_Marker* /*libmv_marker*/)
-{
+                              const libmv_Marker* /*libmv_marker*/) {
 }
 
 void libmv_autoTrackSetMarkers(libmv_AutoTrack* /*libmv_autotrack*/,
                                const libmv_Marker* /*libmv_marker-*/,
-                               size_t /*num_markers*/)
-{
+                               size_t /*num_markers*/) {
 }
 
 int libmv_autoTrackGetMarker(libmv_AutoTrack* /*libmv_autotrack*/,
                              int /*clip*/,
                              int /*frame*/,
                              int /*track*/,
-                             libmv_Marker* /*libmv_marker*/)
-{
+                             libmv_Marker* /*libmv_marker*/) {
   return 0;
 }
 
@@ -376,24 +372,20 @@ libmv_FrameAccessor* libmv_FrameAccessorNew(
     libmv_GetImageCallback /*get_image_callback*/,
     libmv_ReleaseImageCallback /*release_image_callback*/,
     libmv_GetMaskForTrackCallback /*get_mask_for_track_callback*/,
-    libmv_ReleaseMaskCallback /*release_mask_callback*/)
-{
+    libmv_ReleaseMaskCallback /*release_mask_callback*/) {
   return NULL;
 }
 
-void libmv_FrameAccessorDestroy(libmv_FrameAccessor* /*frame_accessor*/)
-{
+void libmv_FrameAccessorDestroy(libmv_FrameAccessor* /*frame_accessor*/) {
 }
 
 int64_t libmv_frameAccessorgetTransformKey(
-    const libmv_FrameTransform * /*transform*/)
-{
+    const libmv_FrameTransform* /*transform*/) {
   return 0;
 }
 
-void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform* /*transform*/,
-                                        const libmv_FloatImage* /*input_image*/,
-                                        libmv_FloatImage* /*output_image*/)
-{
+void libmv_frameAccessorgetTransformRun(
+    const libmv_FrameTransform* /*transform*/,
+    const libmv_FloatImage* /*input_image*/,
+    libmv_FloatImage* /*output_image*/) {
 }
-

intern/libmv/intern/track_region.cc

@@ -21,6 +21,7 @@
 #include "intern/image.h"
 #include "intern/utildefines.h"
 #include "libmv/image/image.h"
+#include "libmv/logging/logging.h"
 #include "libmv/tracking/track_region.h"
 
 /* define this to generate PNG images with content of search areas
@@ -32,27 +33,53 @@
 #undef DUMP_ALWAYS
 
 using libmv::FloatImage;
+using libmv::TrackRegion;
 using libmv::TrackRegionOptions;
 using libmv::TrackRegionResult;
-using libmv::TrackRegion;
 
-void libmv_configureTrackRegionOptions(
-    const libmv_TrackRegionOptions& options,
-    TrackRegionOptions* track_region_options) {
-  switch (options.motion_model) {
-#define LIBMV_CONVERT(the_model) \
-  case TrackRegionOptions::the_model: \
-    track_region_options->mode = TrackRegionOptions::the_model; \
-    break;
+namespace {
+
+TrackRegionOptions::Direction convertDirection(
+    libmv_TrackRegionDirection direction) {
+  switch (direction) {
+    case LIBMV_TRACK_REGION_FORWARD: return TrackRegionOptions::FORWARD;
+    case LIBMV_TRACK_REGION_BACKWARD: return TrackRegionOptions::BACKWARD;
+  }
+
+  LOG(FATAL) << "Unhandled tracking direction " << direction
+             << ", should never happen.";
+
+  return TrackRegionOptions::FORWARD;
+}
+
+TrackRegionOptions::Mode convertMotionModelToMode(int motion_model) {
+  switch (motion_model) {
+#define LIBMV_CONVERT(the_model)                                               \
+  case TrackRegionOptions::the_model: return TrackRegionOptions::the_model;
+
     LIBMV_CONVERT(TRANSLATION)
     LIBMV_CONVERT(TRANSLATION_ROTATION)
     LIBMV_CONVERT(TRANSLATION_SCALE)
     LIBMV_CONVERT(TRANSLATION_ROTATION_SCALE)
     LIBMV_CONVERT(AFFINE)
     LIBMV_CONVERT(HOMOGRAPHY)
+
 #undef LIBMV_CONVERT
   }
 
+  LOG(FATAL) << "Unhandled motion model " << motion_model
+             << ", should never happen.";
+
+  return TrackRegionOptions::TRANSLATION;
+}
+
+}  // namespace
+
+void libmv_configureTrackRegionOptions(
+    const libmv_TrackRegionOptions& options,
+    TrackRegionOptions* track_region_options) {
+  track_region_options->direction = convertDirection(options.direction);
+  track_region_options->mode = convertMotionModelToMode(options.motion_model);
   track_region_options->minimum_correlation = options.minimum_correlation;
   track_region_options->max_iterations = options.num_iterations;
   track_region_options->sigma = options.sigma;
@@ -66,7 +93,8 @@ void libmv_configureTrackRegionOptions(
    * so disabling for now for until proper prediction model is landed.
    *
    * The thing is, currently blender sends input coordinates as the guess to
-   * region tracker and in case of fast motion such an early out ruins the track.
+   * region tracker and in case of fast motion such an early out ruins the
+   * track.
    */
   track_region_options->attempt_refine_before_brute = false;
   track_region_options->use_normalized_intensities = options.use_normalization;
@@ -74,7 +102,7 @@ void libmv_configureTrackRegionOptions(
 
 void libmv_regionTrackergetResult(const TrackRegionResult& track_region_result,
                                   libmv_TrackRegionResult* result) {
-  result->termination = (int) track_region_result.termination;
+  result->termination = (int)track_region_result.termination;
   result->termination_reason = "";
   result->correlation = track_region_result.correlation;
 }
@@ -108,33 +136,27 @@ int libmv_trackRegion(const libmv_TrackRegionOptions* options,
 
   libmv_configureTrackRegionOptions(*options, &track_region_options);
   if (options->image1_mask) {
-    libmv_floatBufferToFloatImage(options->image1_mask,
-                                  image1_width,
-                                  image1_height,
-                                  1,
-                                  &image1_mask);
+    libmv_floatBufferToFloatImage(
+        options->image1_mask, image1_width, image1_height, 1, &image1_mask);
 
     track_region_options.image1_mask = &image1_mask;
   }
 
   // Convert from raw float buffers to libmv's FloatImage.
   FloatImage old_patch, new_patch;
-  libmv_floatBufferToFloatImage(image1,
-                                image1_width,
-                                image1_height,
-                                1,
-                                &old_patch);
-  libmv_floatBufferToFloatImage(image2,
-                                image2_width,
-                                image2_height,
-                                1,
-                                &new_patch);
+  libmv_floatBufferToFloatImage(
+      image1, image1_width, image1_height, 1, &old_patch);
+  libmv_floatBufferToFloatImage(
+      image2, image2_width, image2_height, 1, &new_patch);
 
   TrackRegionResult track_region_result;
-  TrackRegion(old_patch, new_patch,
-              xx1, yy1,
+  TrackRegion(old_patch,
+              new_patch,
+              xx1,
+              yy1,
               track_region_options,
-              xx2, yy2,
+              xx2,
+              yy2,
               &track_region_result);
 
   // Convert to floats for the blender api.

intern/libmv/intern/track_region.h

@@ -24,14 +24,20 @@
 extern "C" {
 #endif
 
+typedef enum libmv_TrackRegionDirection {
+  LIBMV_TRACK_REGION_FORWARD,
+  LIBMV_TRACK_REGION_BACKWARD,
+} libmv_TrackRegionDirection;
+
 typedef struct libmv_TrackRegionOptions {
+  libmv_TrackRegionDirection direction;
   int motion_model;
   int num_iterations;
   int use_brute;
   int use_normalization;
   double minimum_correlation;
   double sigma;
-  float *image1_mask;
+  float* image1_mask;
 } libmv_TrackRegionOptions;
 
 typedef struct libmv_TrackRegionResult {
@@ -42,9 +48,9 @@ typedef struct libmv_TrackRegionResult {
 
 #ifdef __cplusplus
 namespace libmv {
-  struct TrackRegionOptions;
-  struct TrackRegionResult;
-}
+struct TrackRegionOptions;
+struct TrackRegionResult;
+}  // namespace libmv
 void libmv_configureTrackRegionOptions(
     const libmv_TrackRegionOptions& options,
     libmv::TrackRegionOptions* track_region_options);

intern/libmv/intern/tracks.cc

@@ -28,18 +28,18 @@ using libmv::Tracks;
 libmv_Tracks* libmv_tracksNew(void) {
   Tracks* tracks = LIBMV_OBJECT_NEW(Tracks);
 
-  return (libmv_Tracks*) tracks;
+  return (libmv_Tracks*)tracks;
 }
 
 void libmv_tracksDestroy(libmv_Tracks* libmv_tracks) {
   LIBMV_OBJECT_DELETE(libmv_tracks, Tracks);
 }
 
-void libmv_tracksInsert(libmv_Tracks *libmv_tracks,
+void libmv_tracksInsert(libmv_Tracks* libmv_tracks,
                         int image,
                         int track,
                         double x,
                         double y,
                         double weight) {
-  ((Tracks *) libmv_tracks)->Insert(image, track, x, y, weight);
+  ((Tracks*)libmv_tracks)->Insert(image, track, x, y, weight);
 }

intern/libmv/intern/tracksN.cc

@@ -25,8 +25,7 @@
 using mv::Marker;
 using mv::Tracks;
 
-void libmv_apiMarkerToMarker(const libmv_Marker& libmv_marker,
-                             Marker *marker) {
+void libmv_apiMarkerToMarker(const libmv_Marker& libmv_marker, Marker* marker) {
   marker->clip = libmv_marker.clip;
   marker->frame = libmv_marker.frame;
   marker->track = libmv_marker.track;
@@ -41,17 +40,16 @@ void libmv_apiMarkerToMarker(const libmv_Marker& libmv_marker,
   marker->search_region.max(0) = libmv_marker.search_region_max[0];
   marker->search_region.max(1) = libmv_marker.search_region_max[1];
   marker->weight = libmv_marker.weight;
-  marker->source = (Marker::Source) libmv_marker.source;
-  marker->status = (Marker::Status) libmv_marker.status;
+  marker->source = (Marker::Source)libmv_marker.source;
+  marker->status = (Marker::Status)libmv_marker.status;
   marker->reference_clip = libmv_marker.reference_clip;
   marker->reference_frame = libmv_marker.reference_frame;
-  marker->model_type = (Marker::ModelType) libmv_marker.model_type;
+  marker->model_type = (Marker::ModelType)libmv_marker.model_type;
   marker->model_id = libmv_marker.model_id;
   marker->disabled_channels = libmv_marker.disabled_channels;
 }
 
-void libmv_markerToApiMarker(const Marker& marker,
-                             libmv_Marker *libmv_marker) {
+void libmv_markerToApiMarker(const Marker& marker, libmv_Marker* libmv_marker) {
   libmv_marker->clip = marker.clip;
   libmv_marker->frame = marker.frame;
   libmv_marker->track = marker.track;
@@ -66,11 +64,11 @@ void libmv_markerToApiMarker(const Marker& marker,
   libmv_marker->search_region_max[0] = marker.search_region.max(0);
   libmv_marker->search_region_max[1] = marker.search_region.max(1);
   libmv_marker->weight = marker.weight;
-  libmv_marker->source = (libmv_MarkerSource) marker.source;
-  libmv_marker->status = (libmv_MarkerStatus) marker.status;
+  libmv_marker->source = (libmv_MarkerSource)marker.source;
+  libmv_marker->status = (libmv_MarkerStatus)marker.status;
   libmv_marker->reference_clip = marker.reference_clip;
   libmv_marker->reference_frame = marker.reference_frame;
-  libmv_marker->model_type = (libmv_MarkerModelType) marker.model_type;
+  libmv_marker->model_type = (libmv_MarkerModelType)marker.model_type;
   libmv_marker->model_id = marker.model_id;
   libmv_marker->disabled_channels = marker.disabled_channels;
 }
@@ -78,7 +76,7 @@ void libmv_markerToApiMarker(const Marker& marker,
 libmv_TracksN* libmv_tracksNewN(void) {
   Tracks* tracks = LIBMV_OBJECT_NEW(Tracks);
 
-  return (libmv_TracksN*) tracks;
+  return (libmv_TracksN*)tracks;
 }
 
 void libmv_tracksDestroyN(libmv_TracksN* libmv_tracks) {
@@ -89,7 +87,7 @@ void libmv_tracksAddMarkerN(libmv_TracksN* libmv_tracks,
                             const libmv_Marker* libmv_marker) {
   Marker marker;
   libmv_apiMarkerToMarker(*libmv_marker, &marker);
-  ((Tracks*) libmv_tracks)->AddMarker(marker);
+  ((Tracks*)libmv_tracks)->AddMarker(marker);
 }
 
 void libmv_tracksGetMarkerN(libmv_TracksN* libmv_tracks,
@@ -98,7 +96,7 @@ void libmv_tracksGetMarkerN(libmv_TracksN* libmv_tracks,
                             int track,
                             libmv_Marker* libmv_marker) {
   Marker marker;
-  ((Tracks*) libmv_tracks)->GetMarker(clip, frame, track, &marker);
+  ((Tracks*)libmv_tracks)->GetMarker(clip, frame, track, &marker);
   libmv_markerToApiMarker(marker, libmv_marker);
 }
 
@@ -106,26 +104,25 @@ void libmv_tracksRemoveMarkerN(libmv_TracksN* libmv_tracks,
                                int clip,
                                int frame,
                                int track) {
-  ((Tracks *) libmv_tracks)->RemoveMarker(clip, frame, track);
+  ((Tracks*)libmv_tracks)->RemoveMarker(clip, frame, track);
 }
 
-void libmv_tracksRemoveMarkersForTrack(libmv_TracksN* libmv_tracks,
-                                       int track) {
-  ((Tracks *) libmv_tracks)->RemoveMarkersForTrack(track);
+void libmv_tracksRemoveMarkersForTrack(libmv_TracksN* libmv_tracks, int track) {
+  ((Tracks*)libmv_tracks)->RemoveMarkersForTrack(track);
 }
 
 int libmv_tracksMaxClipN(libmv_TracksN* libmv_tracks) {
-  return ((Tracks*) libmv_tracks)->MaxClip();
+  return ((Tracks*)libmv_tracks)->MaxClip();
 }
 
 int libmv_tracksMaxFrameN(libmv_TracksN* libmv_tracks, int clip) {
-  return ((Tracks*) libmv_tracks)->MaxFrame(clip);
+  return ((Tracks*)libmv_tracks)->MaxFrame(clip);
 }
 
 int libmv_tracksMaxTrackN(libmv_TracksN* libmv_tracks) {
-  return ((Tracks*) libmv_tracks)->MaxTrack();
+  return ((Tracks*)libmv_tracks)->MaxTrack();
 }
 
 int libmv_tracksNumMarkersN(libmv_TracksN* libmv_tracks) {
-  return ((Tracks*) libmv_tracks)->NumMarkers();
+  return ((Tracks*)libmv_tracks)->NumMarkers();
 }

intern/libmv/intern/tracksN.h

@@ -79,20 +79,19 @@ typedef struct libmv_Marker {
 
 #ifdef __cplusplus
 namespace mv {
-  struct Marker;
+struct Marker;
 }
 void libmv_apiMarkerToMarker(const libmv_Marker& libmv_marker,
-                             mv::Marker *marker);
+                             mv::Marker* marker);
 
 void libmv_markerToApiMarker(const mv::Marker& marker,
-                             libmv_Marker *libmv_marker);
+                             libmv_Marker* libmv_marker);
 #endif
 
 libmv_TracksN* libmv_tracksNewN(void);
 
 void libmv_tracksDestroyN(libmv_TracksN* libmv_tracks);
 
-
 void libmv_tracksAddMarkerN(libmv_TracksN* libmv_tracks,
                             const libmv_Marker* libmv_marker);
 
@@ -107,8 +106,7 @@ void libmv_tracksRemoveMarkerN(libmv_TracksN* libmv_tracks,
                                int frame,
                                int track);
 
-void libmv_tracksRemoveMarkersForTrack(libmv_TracksN* libmv_tracks,
-                                       int track);
+void libmv_tracksRemoveMarkersForTrack(libmv_TracksN* libmv_tracks, int track);
 
 int libmv_tracksMaxClipN(libmv_TracksN* libmv_tracks);
 int libmv_tracksMaxFrameN(libmv_TracksN* libmv_tracks, int clip);

intern/libmv/intern/utildefines.h

@@ -30,27 +30,33 @@
 #  define LIBMV_OBJECT_NEW OBJECT_GUARDED_NEW
 #  define LIBMV_OBJECT_DELETE OBJECT_GUARDED_DELETE
 #  define LIBMV_OBJECT_DELETE OBJECT_GUARDED_DELETE
-#  define LIBMV_STRUCT_NEW(type, count) \
-  (type*)MEM_mallocN(sizeof(type) * count, __func__)
+#  define LIBMV_STRUCT_NEW(type, count)                                        \
+    (type*)MEM_mallocN(sizeof(type) * count, __func__)
 #  define LIBMV_STRUCT_DELETE(what) MEM_freeN(what)
 #else
 // Need this to keep libmv-capi potentially standalone.
 #  if defined __GNUC__ || defined __sun
-#    define LIBMV_OBJECT_NEW(type, args ...) \
-  new(malloc(sizeof(type))) type(args)
+#    define LIBMV_OBJECT_NEW(type, args...)                                    \
+      new (malloc(sizeof(type))) type(args)
 #  else
-#    define LIBMV_OBJECT_NEW(type, ...) \
-  new(malloc(sizeof(type))) type(__VA_ARGS__)
-#endif
-#  define LIBMV_OBJECT_DELETE(what, type) \
-  { \
-    if (what) { \
-      ((type*)(what))->~type(); \
-      free(what); \
-    } \
-  } (void)0
+#    define LIBMV_OBJECT_NEW(type, ...)                                        \
+      new (malloc(sizeof(type))) type(__VA_ARGS__)
+#  endif
+#  define LIBMV_OBJECT_DELETE(what, type)                                      \
+    {                                                                          \
+      if (what) {                                                              \
+        ((type*)(what))->~type();                                              \
+        free(what);                                                            \
+      }                                                                        \
+    }                                                                          \
+    (void)0
 #  define LIBMV_STRUCT_NEW(type, count) (type*)malloc(sizeof(type) * count)
-#  define LIBMV_STRUCT_DELETE(what) { if (what) free(what); } (void)0
+#  define LIBMV_STRUCT_DELETE(what)                                            \
+    {                                                                          \
+      if (what)                                                                \
+        free(what);                                                            \
+    }                                                                          \
+    (void)0
 #endif
 
 #endif  // LIBMV_C_API_UTILDEFINES_H_

intern/libmv/libmv/autotrack/autotrack.cc

@@ -21,9 +21,9 @@
 // Author: mierle@gmail.com (Keir Mierle)
 
 #include "libmv/autotrack/autotrack.h"
-#include "libmv/autotrack/quad.h"
 #include "libmv/autotrack/frame_accessor.h"
 #include "libmv/autotrack/predict_tracks.h"
+#include "libmv/autotrack/quad.h"
 #include "libmv/base/scoped_ptr.h"
 #include "libmv/logging/logging.h"
 #include "libmv/numeric/numeric.h"
@@ -35,34 +35,30 @@ namespace {
 class DisableChannelsTransform : public FrameAccessor::Transform {
  public:
   DisableChannelsTransform(int disabled_channels)
-      : disabled_channels_(disabled_channels) {  }
+      : disabled_channels_(disabled_channels) {}
 
-  int64_t key() const {
-    return disabled_channels_;
-  }
+  int64_t key() const { return disabled_channels_; }
 
   void run(const FloatImage& input, FloatImage* output) const {
-    bool disable_red   = (disabled_channels_ & Marker::CHANNEL_R) != 0,
+    bool disable_red = (disabled_channels_ & Marker::CHANNEL_R) != 0,
          disable_green = (disabled_channels_ & Marker::CHANNEL_G) != 0,
-         disable_blue  = (disabled_channels_ & Marker::CHANNEL_B) != 0;
+         disable_blue = (disabled_channels_ & Marker::CHANNEL_B) != 0;
 
-    LG << "Disabling channels: "
-       << (disable_red   ? "R " : "")
-       << (disable_green ? "G " : "")
-       << (disable_blue  ? "B" : "");
+    LG << "Disabling channels: " << (disable_red ? "R " : "")
+       << (disable_green ? "G " : "") << (disable_blue ? "B" : "");
 
     // It's important to rescale the resultappropriately so that e.g. if only
     // blue is selected, it's not zeroed out.
-    float scale = (disable_red   ? 0.0f : 0.2126f) +
+    float scale = (disable_red ? 0.0f : 0.2126f) +
                   (disable_green ? 0.0f : 0.7152f) +
-                  (disable_blue  ? 0.0f : 0.0722f);
+                  (disable_blue ? 0.0f : 0.0722f);
 
     output->Resize(input.Height(), input.Width(), 1);
     for (int y = 0; y < input.Height(); y++) {
       for (int x = 0; x < input.Width(); x++) {
-        float r = disable_red   ? 0.0f : input(y, x, 0);
+        float r = disable_red ? 0.0f : input(y, x, 0);
         float g = disable_green ? 0.0f : input(y, x, 1);
-        float b = disable_blue  ? 0.0f : input(y, x, 2);
+        float b = disable_blue ? 0.0f : input(y, x, 2);
         (*output)(y, x, 0) = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
       }
     }
@@ -73,7 +69,7 @@ class DisableChannelsTransform : public FrameAccessor::Transform {
   int disabled_channels_;
 };
 
-template<typename QuadT, typename ArrayT>
+template <typename QuadT, typename ArrayT>
 void QuadToArrays(const QuadT& quad, ArrayT* x, ArrayT* y) {
   for (int i = 0; i < 4; ++i) {
     x[i] = quad.coordinates(i, 0);
@@ -115,11 +111,20 @@ FrameAccessor::Key GetMaskForMarker(const Marker& marker,
                                     FrameAccessor* frame_accessor,
                                     FloatImage* mask) {
   Region region = marker.search_region.Rounded();
-  return frame_accessor->GetMaskForTrack(marker.clip,
-                                         marker.frame,
-                                         marker.track,
-                                         &region,
-                                         mask);
+  return frame_accessor->GetMaskForTrack(
+      marker.clip, marker.frame, marker.track, &region, mask);
+}
+
+PredictDirection getPredictDirection(const TrackRegionOptions* track_options) {
+  switch (track_options->direction) {
+    case TrackRegionOptions::FORWARD: return PredictDirection::FORWARD;
+    case TrackRegionOptions::BACKWARD: return PredictDirection::BACKWARD;
+  }
+
+  LOG(FATAL) << "Unhandled tracking direction " << track_options->direction
+             << ", should never happen.";
+
+  return PredictDirection::AUTO;
 }
 
 }  // namespace
@@ -128,8 +133,9 @@ bool AutoTrack::TrackMarker(Marker* tracked_marker,
                             TrackRegionResult* result,
                             const TrackRegionOptions* track_options) {
   // Try to predict the location of the second marker.
+  const PredictDirection predict_direction = getPredictDirection(track_options);
   bool predicted_position = false;
-  if (PredictMarkerPosition(tracks_, tracked_marker)) {
+  if (PredictMarkerPosition(tracks_, predict_direction, tracked_marker)) {
     LG << "Successfully predicted!";
     predicted_position = true;
   } else {
@@ -152,23 +158,20 @@ bool AutoTrack::TrackMarker(Marker* tracked_marker,
   // TODO(keir): Technically this could take a smaller slice from the source
   // image instead of taking one the size of the search window.
   FloatImage reference_image;
-  FrameAccessor::Key reference_key = GetImageForMarker(reference_marker,
-                                                       frame_accessor_,
-                                                       &reference_image);
+  FrameAccessor::Key reference_key =
+      GetImageForMarker(reference_marker, frame_accessor_, &reference_image);
   if (!reference_key) {
     LG << "Couldn't get frame for reference marker: " << reference_marker;
     return false;
   }
 
   FloatImage reference_mask;
-  FrameAccessor::Key reference_mask_key = GetMaskForMarker(reference_marker,
-                                                           frame_accessor_,
-                                                           &reference_mask);
+  FrameAccessor::Key reference_mask_key =
+      GetMaskForMarker(reference_marker, frame_accessor_, &reference_mask);
 
   FloatImage tracked_image;
-  FrameAccessor::Key tracked_key = GetImageForMarker(*tracked_marker,
-                                                     frame_accessor_,
-                                                     &tracked_image);
+  FrameAccessor::Key tracked_key =
+      GetImageForMarker(*tracked_marker, frame_accessor_, &tracked_image);
   if (!tracked_key) {
     frame_accessor_->ReleaseImage(reference_key);
     LG << "Couldn't get frame for tracked marker: " << tracked_marker;
@@ -191,9 +194,11 @@ bool AutoTrack::TrackMarker(Marker* tracked_marker,
   local_track_region_options.attempt_refine_before_brute = predicted_position;
   TrackRegion(reference_image,
               tracked_image,
-              x1, y1,
+              x1,
+              y1,
               local_track_region_options,
-              x2, y2,
+              x2,
+              y2,
               result);
 
   // Copy results over the tracked marker.
@@ -208,7 +213,7 @@ bool AutoTrack::TrackMarker(Marker* tracked_marker,
   tracked_marker->search_region.Offset(delta);
   tracked_marker->source = Marker::TRACKED;
   tracked_marker->status = Marker::UNKNOWN;
-  tracked_marker->reference_clip  = reference_marker.clip;
+  tracked_marker->reference_clip = reference_marker.clip;
   tracked_marker->reference_frame = reference_marker.frame;
 
   // Release the images and masks from the accessor cache.
@@ -230,7 +235,9 @@ void AutoTrack::SetMarkers(vector<Marker>* markers) {
   tracks_.SetMarkers(markers);
 }
 
-bool AutoTrack::GetMarker(int clip, int frame, int track,
+bool AutoTrack::GetMarker(int clip,
+                          int frame,
+                          int track,
                           Marker* markers) const {
   return tracks_.GetMarker(clip, frame, track, markers);
 }
@@ -242,7 +249,8 @@ void AutoTrack::DetectAndTrack(const DetectAndTrackOptions& options) {
     vector<Marker> previous_frame_markers;
     // Q: How to decide track #s when detecting?
     // Q: How to match markers from previous frame? set of prev frame tracks?
-    // Q: How to decide what markers should get tracked and which ones should not?
+    // Q: How to decide what markers should get tracked and which ones should
+    // not?
     for (int frame = 0; frame < num_frames; ++frame) {
       if (Cancelled()) {
         LG << "Got cancel message while detecting and tracking...";
@@ -271,8 +279,7 @@ void AutoTrack::DetectAndTrack(const DetectAndTrackOptions& options) {
       for (int i = 0; i < this_frame_markers.size(); ++i) {
         tracks_in_this_frame.push_back(this_frame_markers[i].track);
       }
-      std::sort(tracks_in_this_frame.begin(),
-                tracks_in_this_frame.end());
+      std::sort(tracks_in_this_frame.begin(), tracks_in_this_frame.end());
 
       // Find tracks in the previous frame that are not in this one.
       vector<Marker*> previous_frame_markers_to_track;

intern/libmv/libmv/autotrack/autotrack.h

@@ -23,8 +23,8 @@
 #ifndef LIBMV_AUTOTRACK_AUTOTRACK_H_
 #define LIBMV_AUTOTRACK_AUTOTRACK_H_
 
-#include "libmv/autotrack/tracks.h"
 #include "libmv/autotrack/region.h"
+#include "libmv/autotrack/tracks.h"
 #include "libmv/tracking/track_region.h"
 
 namespace libmv {
@@ -74,15 +74,14 @@ class AutoTrack {
     Region search_region;
   };
 
-  AutoTrack(FrameAccessor* frame_accessor)
-    : frame_accessor_(frame_accessor) {}
+  AutoTrack(FrameAccessor* frame_accessor) : frame_accessor_(frame_accessor) {}
 
   // Marker manipulation.
   // Clip manipulation.
 
   // Set the number of clips. These clips will get accessed from the frame
   // accessor, matches between frames found, and a reconstruction created.
-  //void SetNumFrames(int clip, int num_frames);
+  // void SetNumFrames(int clip, int num_frames);
 
   // Tracking & Matching
 
@@ -90,7 +89,7 @@ class AutoTrack {
   // Caller maintains ownership of *result and *tracked_marker.
   bool TrackMarker(Marker* tracked_marker,
                    TrackRegionResult* result,
-                   const TrackRegionOptions* track_options=NULL);
+                   const TrackRegionOptions* track_options = NULL);
 
   // Wrapper around Tracks API; however these may add additional processing.
   void AddMarker(const Marker& tracked_marker);
@@ -99,36 +98,36 @@ class AutoTrack {
 
   // TODO(keir): Implement frame matching! This could be very cool for loop
   // closing and connecting across clips.
-  //void MatchFrames(int clip1, int frame1, int clip2, int frame2) {}
+  // void MatchFrames(int clip1, int frame1, int clip2, int frame2) {}
 
   // Wrapper around the Reconstruction API.
   // Returns the new ID.
   int AddCameraIntrinsics(CameraIntrinsics* intrinsics) {
-    (void) intrinsics;
+    (void)intrinsics;
     return 0;
   }  // XXX
   int SetClipIntrinsics(int clip, int intrinsics) {
-    (void) clip;
-    (void) intrinsics;
+    (void)clip;
+    (void)intrinsics;
     return 0;
-  }        // XXX
+  }  // XXX
 
   enum Motion {
     GENERAL_CAMERA_MOTION,
     TRIPOD_CAMERA_MOTION,
   };
   int SetClipMotion(int clip, Motion motion) {
-    (void) clip;
-    (void) motion;
+    (void)clip;
+    (void)motion;
     return 0;
-  } // XXX
+  }  // XXX
 
   // Decide what to refine for the given intrinsics. bundle_options is from
   // bundle.h (e.g. BUNDLE_FOCAL_LENGTH | BUNDLE_RADIAL_K1).
   void SetIntrinsicsRefine(int intrinsics, int bundle_options) {
-    (void) intrinsics;
-    (void) bundle_options;
-  } // XXX
+    (void)intrinsics;
+    (void)bundle_options;
+  }  // XXX
 
   // Keyframe read/write.
   struct ClipFrame {
@@ -150,20 +149,19 @@ class AutoTrack {
   };
   void DetectAndTrack(const DetectAndTrackOptions& options);
 
-  struct DetectFeaturesInFrameOptions {
-  };
-  void DetectFeaturesInFrame(int clip, int frame,
-                             const DetectFeaturesInFrameOptions* options=NULL) {
-    (void) clip;
-    (void) frame;
-    (void) options;
-  } // XXX
+  struct DetectFeaturesInFrameOptions {};
+  void DetectFeaturesInFrame(
+      int clip, int frame, const DetectFeaturesInFrameOptions* options = NULL) {
+    (void)clip;
+    (void)frame;
+    (void)options;
+  }  // XXX
 
   // Does not take ownership of the given listener, but keeps a reference to it.
-  void AddListener(OperationListener* listener) {(void) listener;}  // XXX
+  void AddListener(OperationListener* listener) { (void)listener; }  // XXX
 
   // Create the initial reconstruction,
-  //void FindInitialReconstruction();
+  // void FindInitialReconstruction();
 
   // State machine
   //
@@ -202,17 +200,17 @@ class AutoTrack {
   bool Cancelled() { return false; }
 
   Tracks tracks_;  // May be normalized camera coordinates or raw pixels.
-  //Reconstruction reconstruction_;
+  // Reconstruction reconstruction_;
 
   // TODO(keir): Add the motion models here.
-  //vector<MotionModel> motion_models_;
+  // vector<MotionModel> motion_models_;
 
   // TODO(keir): Should num_clips and num_frames get moved to FrameAccessor?
   // TODO(keir): What about masking for clips and frames to prevent various
   // things like reconstruction or tracking from happening on certain frames?
   FrameAccessor* frame_accessor_;
-  //int num_clips_;
-  //vector<int> num_frames_;  // Indexed by clip.
+  // int num_clips_;
+  // vector<int> num_frames_;  // Indexed by clip.
 
   // The intrinsics for each clip, assuming each clip has fixed intrinsics.
   // TODO(keir): Decide what the semantics should be for varying focal length.

intern/libmv/libmv/autotrack/frame_accessor.h

@@ -41,7 +41,7 @@ using libmv::FloatImage;
 // implementations to cache filtered image pieces).
 struct FrameAccessor {
   struct Transform {
-    virtual ~Transform() {  }
+    virtual ~Transform() {}
     // The key should depend on the transform arguments. Must be non-zero.
     virtual int64_t key() const = 0;
 
@@ -50,10 +50,7 @@ struct FrameAccessor {
     virtual void run(const FloatImage& input, FloatImage* output) const = 0;
   };
 
-  enum InputMode {
-    MONO,
-    RGBA
-  };
+  enum InputMode { MONO, RGBA };
 
   typedef void* Key;
 
@@ -100,6 +97,6 @@ struct FrameAccessor {
   virtual int NumFrames(int clip) = 0;
 };
 
-}  // namespace libmv
+}  // namespace mv
 
 #endif  // LIBMV_AUTOTRACK_FRAME_ACCESSOR_H_

intern/libmv/libmv/autotrack/marker.h

@@ -57,23 +57,19 @@ struct Marker {
   float weight;
 
   enum Source {
-    MANUAL,      // The user placed this marker manually.
-    DETECTED,    // A keypoint detector found this point.
-    TRACKED,     // The tracking algorithm placed this marker.
-    MATCHED,     // A matching algorithm (e.g. SIFT or SURF or ORB) found this.
-    PREDICTED,   // A motion model predicted this marker. This is needed for
-                 // handling occlusions in some cases where an imaginary marker
-                 // is placed to keep camera motion smooth.
+    MANUAL,     // The user placed this marker manually.
+    DETECTED,   // A keypoint detector found this point.
+    TRACKED,    // The tracking algorithm placed this marker.
+    MATCHED,    // A matching algorithm (e.g. SIFT or SURF or ORB) found this.
+    PREDICTED,  // A motion model predicted this marker. This is needed for
+                // handling occlusions in some cases where an imaginary marker
+                // is placed to keep camera motion smooth.
   };
   Source source;
 
   // Markers may be inliers or outliers if the tracking fails; this allows
   // visualizing the markers in the image.
-  enum Status {
-    UNKNOWN,
-    INLIER,
-    OUTLIER
-  };
+  enum Status { UNKNOWN, INLIER, OUTLIER };
   Status status;
 
   // When doing correlation tracking, where to search in the current frame for
@@ -90,12 +86,7 @@ struct Marker {
   // another primitive (a rectangular prisim). This captures the information
   // needed to say that for example a collection of markers belongs to model #2
   // (and model #2 is a plane).
-  enum ModelType {
-    POINT,
-    PLANE,
-    LINE,
-    CUBE
-  };
+  enum ModelType { POINT, PLANE, LINE, CUBE };
   ModelType model_type;
 
   // The model ID this track (e.g. the second model, which is a plane).
@@ -114,7 +105,7 @@ struct Marker {
   int disabled_channels;
 
   // Offset everything (center, patch, search) by the given delta.
-  template<typename T>
+  template <typename T>
   void Offset(const T& offset) {
     center += offset.template cast<float>();
     patch.coordinates.rowwise() += offset.template cast<int>();
@@ -122,19 +113,15 @@ struct Marker {
   }
 
   // Shift the center to the given new position (and patch, search).
-  template<typename T>
+  template <typename T>
   void SetPosition(const T& new_center) {
     Offset(new_center - center);
   }
 };
 
 inline std::ostream& operator<<(std::ostream& out, const Marker& marker) {
-  out << "{"
-      << marker.clip << ", "
-      << marker.frame << ", "
-      << marker.track << ", ("
-      << marker.center.x() << ", "
-      << marker.center.y() << ")"
+  out << "{" << marker.clip << ", " << marker.frame << ", " << marker.track
+      << ", (" << marker.center.x() << ", " << marker.center.y() << ")"
       << "}";
   return out;
 }

intern/libmv/libmv/autotrack/model.h

@@ -23,18 +23,13 @@
 #ifndef LIBMV_AUTOTRACK_MODEL_H_
 #define LIBMV_AUTOTRACK_MODEL_H_
 
-#include "libmv/numeric/numeric.h"
 #include "libmv/autotrack/quad.h"
+#include "libmv/numeric/numeric.h"
 
 namespace mv {
 
 struct Model {
-  enum ModelType {
-    POINT,
-    PLANE,
-    LINE,
-    CUBE
-  };
+  enum ModelType { POINT, PLANE, LINE, CUBE };
 
   // ???
 };

intern/libmv/libmv/autotrack/predict_tracks.cc

@@ -20,8 +20,8 @@
 //
 // Author: mierle@gmail.com (Keir Mierle)
 
-#include "libmv/autotrack/marker.h"
 #include "libmv/autotrack/predict_tracks.h"
+#include "libmv/autotrack/marker.h"
 #include "libmv/autotrack/tracks.h"
 #include "libmv/base/vector.h"
 #include "libmv/logging/logging.h"
@@ -31,8 +31,8 @@ namespace mv {
 
 namespace {
 
-using libmv::vector;
 using libmv::Vec2;
+using libmv::vector;
 
 // Implied time delta between steps. Set empirically by tweaking and seeing
 // what numbers did best at prediction.
@@ -57,6 +57,8 @@ const double dt = 3.8;
 
 // For a typical system having constant velocity. This gives smooth-appearing
 // predictions, but they are not always as accurate.
+//
+// clang-format off
 const double velocity_state_transition_data[] = {
   1, dt,       0,  0,  0,        0,
   0,  1,       0,  0,  0,        0,
@@ -65,10 +67,13 @@ const double velocity_state_transition_data[] = {
   0,  0,       0,  0,  1,        0,
   0,  0,       0,  0,  0,        1
 };
+// clang-format on
 
 #if 0
 // This 3rd-order system also models acceleration. This makes for "jerky"
 // predictions, but that tend to be more accurate.
+//
+// clang-format off
 const double acceleration_state_transition_data[] = {
   1, dt, dt*dt/2,  0,  0,        0,
   0,  1,      dt,  0,  0,        0,
@@ -77,9 +82,12 @@ const double acceleration_state_transition_data[] = {
   0,  0,       0,  0,  1,       dt,
   0,  0,       0,  0,  0,        1
 };
+// clang-format on
 
 // This system (attempts) to add an angular velocity component. However, it's
 // total junk.
+//
+// clang-format off
 const double angular_state_transition_data[] = {
   1, dt,     -dt,  0,  0,        0,   // Position x
   0,  1,       0,  0,  0,        0,   // Velocity x
@@ -88,17 +96,22 @@ const double angular_state_transition_data[] = {
   0,  0,       0,  0,  1,        0,   // Velocity y
   0,  0,       0,  0,  0,        1    // Ignored
 };
+// clang-format on
 #endif
 
 const double* state_transition_data = velocity_state_transition_data;
 
 // Observation matrix.
+// clang-format off
 const double observation_data[] = {
   1., 0., 0., 0., 0., 0.,
   0., 0., 0., 1., 0., 0.
 };
+// clang-format on
 
 // Process covariance.
+//
+// clang-format off
 const double process_covariance_data[] = {
  35,  0,  0,  0,  0,  0,
   0,  5,  0,  0,  0,  0,
@@ -107,14 +120,19 @@ const double process_covariance_data[] = {
   0,  0,  0,  0,  5,  0,
   0,  0,  0,  0,  0,  5
 };
+// clang-format on
 
 // Process covariance.
 const double measurement_covariance_data[] = {
-  0.01,  0.00,
-  0.00,  0.01,
+    0.01,
+    0.00,
+    0.00,
+    0.01,
 };
 
 // Initial covariance.
+//
+// clang-format off
 const double initial_covariance_data[] = {
  10,  0,  0,  0,  0,  0,
   0,  1,  0,  0,  0,  0,
@@ -123,6 +141,7 @@ const double initial_covariance_data[] = {
   0,  0,  0,  0,  1,  0,
   0,  0,  0,  0,  0,  1
 };
+// clang-format on
 
 typedef mv::KalmanFilter<double, 6, 2> TrackerKalman;
 
@@ -138,7 +157,7 @@ bool OrderByFrameLessThan(const Marker* a, const Marker* b) {
     }
     return a->clip < b->clip;
   }
-  return a->frame < b-> frame;
+  return a->frame < b->frame;
 }
 
 // Predicted must be after the previous markers (in the frame numbering sense).
@@ -146,9 +165,9 @@ void RunPrediction(const vector<Marker*> previous_markers,
                    Marker* predicted_marker) {
   TrackerKalman::State state;
   state.mean << previous_markers[0]->center.x(), 0, 0,
-                previous_markers[0]->center.y(), 0, 0;
-  state.covariance = Eigen::Matrix<double, 6, 6, Eigen::RowMajor>(
-      initial_covariance_data);
+      previous_markers[0]->center.y(), 0, 0;
+  state.covariance =
+      Eigen::Matrix<double, 6, 6, Eigen::RowMajor>(initial_covariance_data);
 
   int current_frame = previous_markers[0]->frame;
   int target_frame = predicted_marker->frame;
@@ -159,19 +178,18 @@ void RunPrediction(const vector<Marker*> previous_markers,
   for (int i = 1; i < previous_markers.size(); ++i) {
     // Step forward predicting the state until it is on the current marker.
     int predictions = 0;
-    for (;
-         current_frame != previous_markers[i]->frame;
+    for (; current_frame != previous_markers[i]->frame;
          current_frame += frame_delta) {
       filter.Step(&state);
       predictions++;
-      LG << "Predicted point (frame " << current_frame << "): "
-         << state.mean(0) << ", " << state.mean(3);
+      LG << "Predicted point (frame " << current_frame << "): " << state.mean(0)
+         << ", " << state.mean(3);
     }
     // Log the error -- not actually used, but interesting.
     Vec2 error = previous_markers[i]->center.cast<double>() -
                  Vec2(state.mean(0), state.mean(3));
-    LG << "Prediction error for " << predictions << " steps: ("
-       << error.x() << ", " << error.y() << "); norm: " << error.norm();
+    LG << "Prediction error for " << predictions << " steps: (" << error.x()
+       << ", " << error.y() << "); norm: " << error.norm();
     // Now that the state is predicted in the current frame, update the state
     // based on the measurement from the current frame.
     filter.Update(previous_markers[i]->center.cast<double>(),
@@ -184,8 +202,8 @@ void RunPrediction(const vector<Marker*> previous_markers,
   // predict until the target frame.
   for (; current_frame != target_frame; current_frame += frame_delta) {
     filter.Step(&state);
-    LG << "Final predicted point (frame " << current_frame << "): "
-       << state.mean(0) << ", " << state.mean(3);
+    LG << "Final predicted point (frame " << current_frame
+       << "): " << state.mean(0) << ", " << state.mean(3);
   }
 
   // The x and y positions are at 0 and 3; ignore acceleration and velocity.
@@ -207,7 +225,9 @@ void RunPrediction(const vector<Marker*> previous_markers,
 
 }  // namespace
 
-bool PredictMarkerPosition(const Tracks& tracks, Marker* marker) {
+bool PredictMarkerPosition(const Tracks& tracks,
+                           const PredictDirection direction,
+                           Marker* marker) {
   // Get all markers for this clip and track.
   vector<Marker> markers;
   tracks.GetMarkersForTrackInClip(marker->clip, marker->track, &markers);
@@ -253,13 +273,13 @@ bool PredictMarkerPosition(const Tracks& tracks, Marker* marker) {
   } else if (insert_at != -1) {
     // Found existing marker; scan before and after it.
     forward_scan_begin = insert_at + 1;
-    forward_scan_end = markers.size() - 1;;
+    forward_scan_end = markers.size() - 1;
     backward_scan_begin = insert_at - 1;
     backward_scan_end = 0;
   } else {
     // Didn't find existing marker but found an insertion point.
     forward_scan_begin = insert_before;
-    forward_scan_end = markers.size() - 1;;
+    forward_scan_end = markers.size() - 1;
     backward_scan_begin = insert_before - 1;
     backward_scan_end = 0;
   }
@@ -272,9 +292,17 @@ bool PredictMarkerPosition(const Tracks& tracks, Marker* marker) {
   }
 
   bool predict_forward = false;
-  if (backward_scan_end <= backward_scan_begin) {
-    // TODO(keir): Add smarter handling and detecting of consecutive frames!
-    predict_forward = true;
+  switch (direction) {
+    case PredictDirection::AUTO:
+      if (backward_scan_end <= backward_scan_begin) {
+        // TODO(keir): Add smarter handling and detecting of consecutive frames!
+        predict_forward = true;
+      }
+      break;
+
+    case PredictDirection::FORWARD: predict_forward = true; break;
+
+    case PredictDirection::BACKWARD: predict_forward = false; break;
   }
 
   const int max_frames_to_predict_from = 20;
@@ -301,9 +329,8 @@ bool PredictMarkerPosition(const Tracks& tracks, Marker* marker) {
       return false;
     }
     LG << "Predicting backward";
-    int predict_begin =
-        std::min(forward_scan_begin + max_frames_to_predict_from,
-                 forward_scan_end);
+    int predict_begin = std::min(
+        forward_scan_begin + max_frames_to_predict_from, forward_scan_end);
     int predict_end = forward_scan_begin;
     vector<Marker*> previous_markers;
     for (int i = predict_begin; i >= predict_end; --i) {
@@ -312,7 +339,6 @@ bool PredictMarkerPosition(const Tracks& tracks, Marker* marker) {
     RunPrediction(previous_markers, marker);
     return false;
   }
-
 }
 
 }  // namespace mv

intern/libmv/libmv/autotrack/predict_tracks.h

@@ -28,9 +28,27 @@ namespace mv {
 class Tracks;
 struct Marker;
 
+enum class PredictDirection {
+  // Detect direction in which to predict marker position based on an existing
+  // Tracks context. Prediction will happen in the preferred direction of a
+  // missing information.
+  // If markers exists to the both sides of the given one the prediction
+  // direction is preferred to be forward.
+  AUTO,
+
+  // Predict position of the marker from the past to the future (used for
+  // forward tracking).
+  FORWARD,
+
+  // Predict position from the future to the past (used for backward tracking).
+  BACKWARD,
+};
+
 // Predict the position of the given marker, and update it accordingly. The
 // existing position will be overwritten.
-bool PredictMarkerPosition(const Tracks& tracks, Marker* marker);
+bool PredictMarkerPosition(const Tracks& tracks,
+                           const PredictDirection direction,
+                           Marker* marker);
 
 }  // namespace mv
 

intern/libmv/libmv/autotrack/predict_tracks_test.cc

@@ -35,17 +35,15 @@ static void AddMarker(int frame, float x, float y, Tracks* tracks) {
   marker.frame = frame;
   marker.center.x() = x;
   marker.center.y() = y;
-  marker.patch.coordinates << x - 1, y - 1,
-                              x + 1, y - 1,
-                              x + 1, y + 1,
-                              x - 1, y + 1;
+  marker.patch.coordinates << x - 1, y - 1, x + 1, y - 1, x + 1, y + 1, x - 1,
+      y + 1;
   tracks->AddMarker(marker);
 }
 
 TEST(PredictMarkerPosition, EasyLinearMotion) {
   Tracks tracks;
-  AddMarker(0, 1.0,  0.0, &tracks);
-  AddMarker(1, 2.0,  5.0, &tracks);
+  AddMarker(0, 1.0, 0.0, &tracks);
+  AddMarker(1, 2.0, 5.0, &tracks);
   AddMarker(2, 3.0, 10.0, &tracks);
   AddMarker(3, 4.0, 15.0, &tracks);
   AddMarker(4, 5.0, 20.0, &tracks);
@@ -58,7 +56,7 @@ TEST(PredictMarkerPosition, EasyLinearMotion) {
   predicted.track = 0;
   predicted.frame = 8;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
   EXPECT_LT(error, 0.1);
@@ -66,10 +64,8 @@ TEST(PredictMarkerPosition, EasyLinearMotion) {
   // Check the patch coordinates as well.
   double x = 9, y = 40.0;
   Quad2Df expected_patch;
-  expected_patch.coordinates << x - 1, y - 1,
-                                x + 1, y - 1,
-                                x + 1, y + 1,
-                                x - 1, y + 1;
+  expected_patch.coordinates << x - 1, y - 1, x + 1, y - 1, x + 1, y + 1, x - 1,
+      y + 1;
 
   error = (expected_patch.coordinates - predicted.patch.coordinates).norm();
   LG << "Patch error: " << error;
@@ -78,8 +74,8 @@ TEST(PredictMarkerPosition, EasyLinearMotion) {
 
 TEST(PredictMarkerPosition, EasyBackwardLinearMotion) {
   Tracks tracks;
-  AddMarker(8, 1.0,  0.0, &tracks);
-  AddMarker(7, 2.0,  5.0, &tracks);
+  AddMarker(8, 1.0, 0.0, &tracks);
+  AddMarker(7, 2.0, 5.0, &tracks);
   AddMarker(6, 3.0, 10.0, &tracks);
   AddMarker(5, 4.0, 15.0, &tracks);
   AddMarker(4, 5.0, 20.0, &tracks);
@@ -92,7 +88,7 @@ TEST(PredictMarkerPosition, EasyBackwardLinearMotion) {
   predicted.track = 0;
   predicted.frame = 0;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   LG << predicted;
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
@@ -101,10 +97,8 @@ TEST(PredictMarkerPosition, EasyBackwardLinearMotion) {
   // Check the patch coordinates as well.
   double x = 9.0, y = 40.0;
   Quad2Df expected_patch;
-  expected_patch.coordinates << x - 1, y - 1,
-                                x + 1, y - 1,
-                                x + 1, y + 1,
-                                x - 1, y + 1;
+  expected_patch.coordinates << x - 1, y - 1, x + 1, y - 1, x + 1, y + 1, x - 1,
+      y + 1;
 
   error = (expected_patch.coordinates - predicted.patch.coordinates).norm();
   LG << "Patch error: " << error;
@@ -113,8 +107,8 @@ TEST(PredictMarkerPosition, EasyBackwardLinearMotion) {
 
 TEST(PredictMarkerPosition, TwoFrameGap) {
   Tracks tracks;
-  AddMarker(0, 1.0,  0.0, &tracks);
-  AddMarker(1, 2.0,  5.0, &tracks);
+  AddMarker(0, 1.0, 0.0, &tracks);
+  AddMarker(1, 2.0, 5.0, &tracks);
   AddMarker(2, 3.0, 10.0, &tracks);
   AddMarker(3, 4.0, 15.0, &tracks);
   AddMarker(4, 5.0, 20.0, &tracks);
@@ -127,7 +121,7 @@ TEST(PredictMarkerPosition, TwoFrameGap) {
   predicted.track = 0;
   predicted.frame = 8;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
   EXPECT_LT(error, 0.1);
@@ -135,8 +129,8 @@ TEST(PredictMarkerPosition, TwoFrameGap) {
 
 TEST(PredictMarkerPosition, FourFrameGap) {
   Tracks tracks;
-  AddMarker(0, 1.0,  0.0, &tracks);
-  AddMarker(1, 2.0,  5.0, &tracks);
+  AddMarker(0, 1.0, 0.0, &tracks);
+  AddMarker(1, 2.0, 5.0, &tracks);
   AddMarker(2, 3.0, 10.0, &tracks);
   AddMarker(3, 4.0, 15.0, &tracks);
   // Missing frames 4, 5, 6, 7.
@@ -146,7 +140,7 @@ TEST(PredictMarkerPosition, FourFrameGap) {
   predicted.track = 0;
   predicted.frame = 8;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
   EXPECT_LT(error, 2.0);  // Generous error due to larger prediction window.
@@ -154,13 +148,13 @@ TEST(PredictMarkerPosition, FourFrameGap) {
 
 TEST(PredictMarkerPosition, MultipleGaps) {
   Tracks tracks;
-  AddMarker(0, 1.0,  0.0, &tracks);
-  AddMarker(1, 2.0,  5.0, &tracks);
+  AddMarker(0, 1.0, 0.0, &tracks);
+  AddMarker(1, 2.0, 5.0, &tracks);
   AddMarker(2, 3.0, 10.0, &tracks);
   // AddMarker(3, 4.0, 15.0, &tracks);   // Note the 3-frame gap.
   // AddMarker(4, 5.0, 20.0, &tracks);
   // AddMarker(5, 6.0, 25.0, &tracks);
-  AddMarker(6, 7.0, 30.0, &tracks);      // Intermediate measurement.
+  AddMarker(6, 7.0, 30.0, &tracks);  // Intermediate measurement.
   // AddMarker(7, 8.0, 35.0, &tracks);
 
   Marker predicted;
@@ -168,7 +162,7 @@ TEST(PredictMarkerPosition, MultipleGaps) {
   predicted.track = 0;
   predicted.frame = 8;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
   EXPECT_LT(error, 1.0);  // Generous error due to larger prediction window.
@@ -178,21 +172,21 @@ TEST(PredictMarkerPosition, MarkersInRandomOrder) {
   Tracks tracks;
 
   // This is the same as the easy, except that the tracks are randomly ordered.
-  AddMarker(0, 1.0,  0.0, &tracks);
+  AddMarker(0, 1.0, 0.0, &tracks);
   AddMarker(2, 3.0, 10.0, &tracks);
   AddMarker(7, 8.0, 35.0, &tracks);
   AddMarker(5, 6.0, 25.0, &tracks);
   AddMarker(4, 5.0, 20.0, &tracks);
   AddMarker(3, 4.0, 15.0, &tracks);
   AddMarker(6, 7.0, 30.0, &tracks);
-  AddMarker(1, 2.0,  5.0, &tracks);
+  AddMarker(1, 2.0, 5.0, &tracks);
 
   Marker predicted;
   predicted.clip = 0;
   predicted.track = 0;
   predicted.frame = 8;
 
-  PredictMarkerPosition(tracks, &predicted);
+  PredictMarkerPosition(tracks, PredictDirection::AUTO, &predicted);
   double error = (libmv::Vec2f(9.0, 40.0) - predicted.center).norm();
   LG << "Got error: " << error;
   EXPECT_LT(error, 0.1);

intern/libmv/libmv/autotrack/quad.h

@@ -27,7 +27,7 @@
 
 namespace mv {
 
-template<typename T, int D>
+template <typename T, int D>
 struct Quad {
   // A quad is 4 points; generally in 2D or 3D.
   //
@@ -35,7 +35,7 @@ struct Quad {
   //    |\.
   //    | \.
   //    |  z (z goes into screen)
-  //    |   
+  //    |
   //    |     r0----->r1
   //    |      ^       |
   //    |      |   .   |
@@ -44,7 +44,7 @@ struct Quad {
   //    |              \.
   //    |               \.
   //    v                normal goes away (right handed).
-  //    y   
+  //    y
   //
   // Each row is one of the corners coordinates; either (x, y) or (x, y, z).
   Eigen::Matrix<T, 4, D> coordinates;

intern/libmv/libmv/autotrack/reconstruction.h

@@ -57,17 +57,17 @@ class Reconstruction {
  public:
   // All methods copy their input reference or take ownership of the pointer.
   void AddCameraPose(const CameraPose& pose);
-  int  AddCameraIntrinsics(CameraIntrinsics* intrinsics);
-  int  AddPoint(const Point& point);
-  int  AddModel(Model* model);
+  int AddCameraIntrinsics(CameraIntrinsics* intrinsics);
+  int AddPoint(const Point& point);
+  int AddModel(Model* model);
 
   // Returns the corresponding pose or point or NULL if missing.
-        CameraPose* CameraPoseForFrame(int clip, int frame);
+  CameraPose* CameraPoseForFrame(int clip, int frame);
   const CameraPose* CameraPoseForFrame(int clip, int frame) const;
-        Point* PointForTrack(int track);
+  Point* PointForTrack(int track);
   const Point* PointForTrack(int track) const;
 
-  const vector<vector<CameraPose> >& camera_poses() const {
+  const vector<vector<CameraPose>>& camera_poses() const {
     return camera_poses_;
   }
 

intern/libmv/libmv/autotrack/region.h

@@ -46,7 +46,7 @@ struct Region {
   Vec2f min;
   Vec2f max;
 
-  template<typename T>
+  template <typename T>
   void Offset(const T& offset) {
     min += offset.template cast<float>();
     max += offset.template cast<float>();

intern/libmv/libmv/autotrack/tracks.cc

@@ -23,8 +23,8 @@
 #include "libmv/autotrack/tracks.h"
 
 #include <algorithm>
-#include <vector>
 #include <iterator>
+#include <vector>
 
 #include "libmv/numeric/numeric.h"
 
@@ -34,12 +34,12 @@ Tracks::Tracks(const Tracks& other) {
   markers_ = other.markers_;
 }
 
-Tracks::Tracks(const vector<Marker>& markers) : markers_(markers) {}
+Tracks::Tracks(const vector<Marker>& markers) : markers_(markers) {
+}
 
 bool Tracks::GetMarker(int clip, int frame, int track, Marker* marker) const {
   for (int i = 0; i < markers_.size(); ++i) {
-    if (markers_[i].clip  == clip &&
-        markers_[i].frame == frame &&
+    if (markers_[i].clip == clip && markers_[i].frame == frame &&
         markers_[i].track == track) {
       *marker = markers_[i];
       return true;
@@ -60,8 +60,7 @@ void Tracks::GetMarkersForTrackInClip(int clip,
                                       int track,
                                       vector<Marker>* markers) const {
   for (int i = 0; i < markers_.size(); ++i) {
-    if (clip  == markers_[i].clip &&
-        track == markers_[i].track) {
+    if (clip == markers_[i].clip && track == markers_[i].track) {
       markers->push_back(markers_[i]);
     }
   }
@@ -71,15 +70,16 @@ void Tracks::GetMarkersInFrame(int clip,
                                int frame,
                                vector<Marker>* markers) const {
   for (int i = 0; i < markers_.size(); ++i) {
-    if (markers_[i].clip  == clip &&
-        markers_[i].frame == frame) {
+    if (markers_[i].clip == clip && markers_[i].frame == frame) {
       markers->push_back(markers_[i]);
     }
   }
 }
 
-void Tracks::GetMarkersForTracksInBothImages(int clip1, int frame1,
-                                             int clip2, int frame2,
+void Tracks::GetMarkersForTracksInBothImages(int clip1,
+                                             int frame1,
+                                             int clip2,
+                                             int frame2,
                                              vector<Marker>* markers) const {
   std::vector<int> image1_tracks;
   std::vector<int> image2_tracks;
@@ -99,20 +99,19 @@ void Tracks::GetMarkersForTracksInBothImages(int clip1, int frame1,
   std::sort(image1_tracks.begin(), image1_tracks.end());
   std::sort(image2_tracks.begin(), image2_tracks.end());
   std::vector<int> intersection;
-  std::set_intersection(image1_tracks.begin(), image1_tracks.end(),
-                        image2_tracks.begin(), image2_tracks.end(),
+  std::set_intersection(image1_tracks.begin(),
+                        image1_tracks.end(),
+                        image2_tracks.begin(),
+                        image2_tracks.end(),
                         std::back_inserter(intersection));
 
   // Scan through and get the relevant tracks from the two images.
   for (int i = 0; i < markers_.size(); ++i) {
     // Save markers that are in either frame and are in our candidate set.
-    if (((markers_[i].clip  == clip1 &&
-          markers_[i].frame == frame1) ||
-         (markers_[i].clip  == clip2 &&
-          markers_[i].frame == frame2)) &&
-         std::binary_search(intersection.begin(),
-                            intersection.end(),
-                            markers_[i].track)) {
+    if (((markers_[i].clip == clip1 && markers_[i].frame == frame1) ||
+         (markers_[i].clip == clip2 && markers_[i].frame == frame2)) &&
+        std::binary_search(
+            intersection.begin(), intersection.end(), markers_[i].track)) {
       markers->push_back(markers_[i]);
     }
   }
@@ -122,8 +121,7 @@ void Tracks::AddMarker(const Marker& marker) {
   // TODO(keir): This is quadratic for repeated insertions. Fix this by adding
   // a smarter data structure like a set<>.
   for (int i = 0; i < markers_.size(); ++i) {
-    if (markers_[i].clip  == marker.clip &&
-        markers_[i].frame == marker.frame &&
+    if (markers_[i].clip == marker.clip && markers_[i].frame == marker.frame &&
         markers_[i].track == marker.track) {
       markers_[i] = marker;
       return;
@@ -139,8 +137,7 @@ void Tracks::SetMarkers(vector<Marker>* markers) {
 bool Tracks::RemoveMarker(int clip, int frame, int track) {
   int size = markers_.size();
   for (int i = 0; i < markers_.size(); ++i) {
-    if (markers_[i].clip  == clip &&
-        markers_[i].frame == frame &&
+    if (markers_[i].clip == clip && markers_[i].frame == frame &&
         markers_[i].track == track) {
       markers_[i] = markers_[size - 1];
       markers_.resize(size - 1);

intern/libmv/libmv/autotrack/tracks.h

@@ -23,8 +23,8 @@
 #ifndef LIBMV_AUTOTRACK_TRACKS_H_
 #define LIBMV_AUTOTRACK_TRACKS_H_
 
-#include "libmv/base/vector.h"
 #include "libmv/autotrack/marker.h"
+#include "libmv/base/vector.h"
 
 namespace mv {
 
@@ -33,8 +33,8 @@ using libmv::vector;
 // The Tracks container stores correspondences between frames.
 class Tracks {
  public:
-  Tracks() { }
-  Tracks(const Tracks &other);
+  Tracks() {}
+  Tracks(const Tracks& other);
 
   // Create a tracks object with markers already initialized. Copies markers.
   explicit Tracks(const vector<Marker>& markers);
@@ -51,8 +51,10 @@ class Tracks {
   //
   // This is not the same as the union of the markers in frame1 and
   // frame2; each marker is for a track that appears in both images.
-  void GetMarkersForTracksInBothImages(int clip1, int frame1,
-                                       int clip2, int frame2,
+  void GetMarkersForTracksInBothImages(int clip1,
+                                       int frame1,
+                                       int clip2,
+                                       int frame2,
                                        vector<Marker>* markers) const;
 
   void AddMarker(const Marker& marker);

intern/libmv/libmv/autotrack/tracks_test.cc

@@ -22,8 +22,8 @@
 
 #include "libmv/autotrack/tracks.h"
 
-#include "testing/testing.h"
 #include "libmv/logging/logging.h"
+#include "testing/testing.h"
 
 namespace mv {
 

intern/libmv/libmv/base/aligned_malloc.cc

@@ -41,11 +41,11 @@
 
 namespace libmv {
 
-void *aligned_malloc(int size, int alignment) {
+void* aligned_malloc(int size, int alignment) {
 #ifdef _WIN32
   return _aligned_malloc(size, alignment);
 #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__APPLE__)
-  void *result;
+  void* result;
 
   if (posix_memalign(&result, alignment, size)) {
     // non-zero means allocation error
@@ -58,7 +58,7 @@ void *aligned_malloc(int size, int alignment) {
 #endif
 }
 
-void aligned_free(void *ptr) {
+void aligned_free(void* ptr) {
 #ifdef _WIN32
   _aligned_free(ptr);
 #else

intern/libmv/libmv/base/aligned_malloc.h

@@ -24,10 +24,10 @@
 namespace libmv {
 
 // Allocate block of size bytes at least aligned to a given value.
-void *aligned_malloc(int size, int alignment);
+void* aligned_malloc(int size, int alignment);
 
 // Free memory allocated by aligned_malloc.
-void aligned_free(void *ptr);
+void aligned_free(void* ptr);
 
 }  // namespace libmv
 

intern/libmv/libmv/base/id_generator.h

@@ -28,6 +28,7 @@ class IdGenerator {
  public:
   IdGenerator() : next_(0) {}
   ID Generate() { return next_++; }
+
  private:
   ID next_;
 };

intern/libmv/libmv/base/map.h

@@ -26,8 +26,8 @@
 
 namespace libmv {
 
-using std::map;
 using std::make_pair;
+using std::map;
 
 }  // namespace libmv
 

intern/libmv/libmv/base/scoped_ptr.h

@@ -30,44 +30,44 @@ namespace libmv {
  * A handle for a heap-allocated resource that should be freed when it goes out
  * of scope. This looks similar to the one found in TR1.
  */
-template<typename T>
+template <typename T>
 class scoped_ptr {
  public:
-  scoped_ptr(T *resource) : resource_(resource) {}
+  scoped_ptr(T* resource) : resource_(resource) {}
   ~scoped_ptr() { reset(0); }
 
-  T *get()             const { return resource_;  }
-  T *operator->()      const { return resource_;  }
-  T &operator*()       const { return *resource_; }
+  T* get() const { return resource_; }
+  T* operator->() const { return resource_; }
+  T& operator*() const { return *resource_; }
 
-  void reset(T *new_resource) {
+  void reset(T* new_resource) {
     if (sizeof(T)) {
       delete resource_;
     }
     resource_ = new_resource;
   }
 
-  T *release() {
-    T *released_resource = resource_;
+  T* release() {
+    T* released_resource = resource_;
     resource_ = 0;
     return released_resource;
   }
 
  private:
   // No copying allowed.
-  T *resource_;
+  T* resource_;
 };
 
 // Same as scoped_ptr but caller must allocate the data
 // with new[] and the destructor will free the memory
 // using delete[].
-template<typename T>
+template <typename T>
 class scoped_array {
  public:
-  scoped_array(T *array) : array_(array) {}
+  scoped_array(T* array) : array_(array) {}
   ~scoped_array() { reset(NULL); }
 
-  T *get() const { return array_;  }
+  T* get() const { return array_; }
 
   T& operator[](std::ptrdiff_t i) const {
     assert(i >= 0);
@@ -75,25 +75,27 @@ class scoped_array {
     return array_[i];
   }
 
-  void reset(T *new_array) {
+  void reset(T* new_array) {
     if (sizeof(T)) {
       delete array_;
     }
     array_ = new_array;
   }
 
-  T *release() {
-    T *released_array = array_;
+  T* release() {
+    T* released_array = array_;
     array_ = NULL;
     return released_array;
   }
 
  private:
-  T *array_;
+  T* array_;
 
   // Forbid comparison of different scoped_array types.
-  template <typename T2> bool operator==(scoped_array<T2> const& p2) const;
-  template <typename T2> bool operator!=(scoped_array<T2> const& p2) const;
+  template <typename T2>
+  bool operator==(scoped_array<T2> const& p2) const;
+  template <typename T2>
+  bool operator!=(scoped_array<T2> const& p2) const;
 
   // Disallow evil constructors
   scoped_array(const scoped_array&);

intern/libmv/libmv/base/scoped_ptr_test.cc

@@ -25,9 +25,9 @@ namespace libmv {
 namespace {
 
 struct FreeMe {
-  FreeMe(int *freed) : freed(freed) {}
+  FreeMe(int* freed) : freed(freed) {}
   ~FreeMe() { (*freed)++; }
-  int *freed;
+  int* freed;
 };
 
 TEST(ScopedPtr, NullDoesNothing) {
@@ -61,8 +61,8 @@ TEST(ScopedPtr, Reset) {
 
 TEST(ScopedPtr, ReleaseAndGet) {
   int frees = 0;
-  FreeMe *allocated = new FreeMe(&frees);
-  FreeMe *released = NULL;
+  FreeMe* allocated = new FreeMe(&frees);
+  FreeMe* released = NULL;
   {
     scoped_ptr<FreeMe> scoped(allocated);
     EXPECT_EQ(0, frees);

intern/libmv/libmv/base/vector_test.cc

@@ -19,9 +19,9 @@
 // IN THE SOFTWARE.
 
 #include "libmv/base/vector.h"
+#include <algorithm>
 #include "libmv/numeric/numeric.h"
 #include "testing/testing.h"
-#include <algorithm>
 
 namespace {
 using namespace libmv;
@@ -62,7 +62,7 @@ int foo_destruct_calls = 0;
 struct Foo {
  public:
   Foo() : value(5) { foo_construct_calls++; }
-  ~Foo()           { foo_destruct_calls++;  }
+  ~Foo() { foo_destruct_calls++; }
   int value;
 };
 
@@ -150,7 +150,7 @@ TEST_F(VectorTest, CopyConstructor) {
   a.push_back(3);
 
   vector<int> b(a);
-  EXPECT_EQ(a.size(),     b.size());
+  EXPECT_EQ(a.size(), b.size());
   for (int i = 0; i < a.size(); ++i) {
     EXPECT_EQ(a[i], b[i]);
   }
@@ -164,7 +164,7 @@ TEST_F(VectorTest, OperatorEquals) {
 
   b = a;
 
-  EXPECT_EQ(a.size(),     b.size());
+  EXPECT_EQ(a.size(), b.size());
   for (int i = 0; i < a.size(); ++i) {
     EXPECT_EQ(a[i], b[i]);
   }

intern/libmv/libmv/base/vector_utils.h

@@ -18,14 +18,13 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 
-
 #ifndef LIBMV_BASE_VECTOR_UTILS_H_
 #define LIBMV_BASE_VECTOR_UTILS_H_
 
 /// Delete the contents of a container.
 template <class Array>
-void DeleteElements(Array *array)  {
-  for (int i = 0; i < array->size(); ++i)  {
+void DeleteElements(Array* array) {
+  for (int i = 0; i < array->size(); ++i) {
     delete (*array)[i];
   }
   array->clear();

intern/libmv/libmv/image/array_nd.cc

@@ -18,18 +18,17 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 // IN THE SOFTWARE.
 
-#include "libmv/image/image.h"
-#include <iostream>
 #include <cmath>
+#include <iostream>
+#include "libmv/image/image.h"
 
 namespace libmv {
 
-void FloatArrayToScaledByteArray(const Array3Df &float_array,
-                                 Array3Du *byte_array,
-                                 bool automatic_range_detection
-                                ) {
+void FloatArrayToScaledByteArray(const Array3Df& float_array,
+                                 Array3Du* byte_array,
+                                 bool automatic_range_detection) {
   byte_array->ResizeLike(float_array);
-  float minval =  HUGE_VAL;
+  float minval = HUGE_VAL;
   float maxval = -HUGE_VAL;
   if (automatic_range_detection) {
     for (int i = 0; i < float_array.Height(); ++i) {
@@ -54,8 +53,8 @@ void FloatArrayToScaledByteArray(const Array3Df &float_array,
   }
 }
 
-void ByteArrayToScaledFloatArray(const Array3Du &byte_array,
-                                 Array3Df *float_array) {
+void ByteArrayToScaledFloatArray(const Array3Du& byte_array,
+                                 Array3Df* float_array) {
   float_array->ResizeLike(byte_array);
   for (int i = 0; i < byte_array.Height(); ++i) {
     for (int j = 0; j < byte_array.Width(); ++j) {
@@ -66,10 +65,10 @@ void ByteArrayToScaledFloatArray(const Array3Du &byte_array,
   }
 }
 
-void SplitChannels(const Array3Df &input,
-                          Array3Df *channel0,
-                          Array3Df *channel1,
-                          Array3Df *channel2) {
+void SplitChannels(const Array3Df& input,
+                   Array3Df* channel0,
+                   Array3Df* channel1,
+                   Array3Df* channel2) {
   assert(input.Depth() >= 3);
   channel0->Resize(input.Height(), input.Width());
   channel1->Resize(input.Height(), input.Width());
@@ -83,7 +82,7 @@ void SplitChannels(const Array3Df &input,
   }
 }
 
-void PrintArray(const Array3Df &array) {
+void PrintArray(const Array3Df& array) {
   using namespace std;
 
   printf("[\n");

intern/libmv/libmv/image/array_nd.h

@@ -44,13 +44,13 @@ class ArrayND : public BaseArray {
   ArrayND() : data_(NULL), own_data_(true) { Resize(Index(0)); }
 
   /// Create an array with the specified shape.
-  ArrayND(const Index &shape) : data_(NULL), own_data_(true) { Resize(shape); }
+  ArrayND(const Index& shape) : data_(NULL), own_data_(true) { Resize(shape); }
 
   /// Create an array with the specified shape.
-  ArrayND(int *shape) : data_(NULL), own_data_(true) { Resize(shape); }
+  ArrayND(int* shape) : data_(NULL), own_data_(true) { Resize(shape); }
 
   /// Copy constructor.
-  ArrayND(const ArrayND<T, N> &b) : data_(NULL), own_data_(true) {
+  ArrayND(const ArrayND<T, N>& b) : data_(NULL), own_data_(true) {
     ResizeLike(b);
     std::memcpy(Data(), b.Data(), sizeof(T) * Size());
   }
@@ -58,7 +58,7 @@ class ArrayND : public BaseArray {
   ArrayND(int s0) : data_(NULL), own_data_(true) { Resize(s0); }
   ArrayND(int s0, int s1) : data_(NULL), own_data_(true) { Resize(s0, s1); }
   ArrayND(int s0, int s1, int s2) : data_(NULL), own_data_(true) {
-     Resize(s0, s1, s2);
+    Resize(s0, s1, s2);
   }
 
   ArrayND(T* data, int s0, int s1, int s2)
@@ -69,28 +69,24 @@ class ArrayND : public BaseArray {
   /// Destructor deletes pixel data.
   ~ArrayND() {
     if (own_data_) {
-      delete [] data_;
+      delete[] data_;
     }
   }
 
   /// Assignation copies pixel data.
-  ArrayND &operator=(const ArrayND<T, N> &b) {
+  ArrayND& operator=(const ArrayND<T, N>& b) {
     assert(this != &b);
     ResizeLike(b);
     std::memcpy(Data(), b.Data(), sizeof(T) * Size());
     return *this;
   }
 
-  const Index &Shapes() const {
-    return shape_;
-  }
+  const Index& Shapes() const { return shape_; }
 
-  const Index &Strides() const {
-    return strides_;
-  }
+  const Index& Strides() const { return strides_; }
 
   /// Create an array of shape s.
-  void Resize(const Index &new_shape) {
+  void Resize(const Index& new_shape) {
     if (data_ != NULL && shape_ == new_shape) {
       // Don't bother realloacting if the shapes match.
       return;
@@ -101,7 +97,7 @@ class ArrayND : public BaseArray {
       strides_(i - 1) = strides_(i) * shape_(i);
     }
     if (own_data_) {
-      delete [] data_;
+      delete[] data_;
       data_ = NULL;
       if (Size() > 0) {
         data_ = new T[Size()];
@@ -109,15 +105,13 @@ class ArrayND : public BaseArray {
     }
   }
 
-  template<typename D>
-  void ResizeLike(const ArrayND<D, N> &other) {
+  template <typename D>
+  void ResizeLike(const ArrayND<D, N>& other) {
     Resize(other.Shape());
   }
 
   /// Resizes the array to shape s.  All data is lost.
-  void Resize(const int *new_shape_array) {
-    Resize(Index(new_shape_array));
-  }
+  void Resize(const int* new_shape_array) { Resize(Index(new_shape_array)); }
 
   /// Resize a 1D array to length s0.
   void Resize(int s0) {
@@ -136,9 +130,7 @@ class ArrayND : public BaseArray {
   }
 
   // Match Eigen2's API.
-  void resize(int rows, int cols) {
-    Resize(rows, cols);
-  }
+  void resize(int rows, int cols) { Resize(rows, cols); }
 
   /// Resize a 3D array to shape (s0,s1,s2).
   void Resize(int s0, int s1, int s2) {
@@ -147,11 +139,11 @@ class ArrayND : public BaseArray {
     Resize(shape);
   }
 
-  template<typename D>
-  void CopyFrom(const ArrayND<D, N> &other) {
+  template <typename D>
+  void CopyFrom(const ArrayND<D, N>& other) {
     ResizeLike(other);
-    T *data = Data();
-    const D *other_data = other.Data();
+    T* data = Data();
+    const D* other_data = other.Data();
     for (int i = 0; i < Size(); ++i) {
       data[i] = T(other_data[i]);
     }
@@ -171,19 +163,13 @@ class ArrayND : public BaseArray {
   }
 
   /// Return a tuple containing the length of each axis.
-  const Index &Shape() const {
-    return shape_;
-  }
+  const Index& Shape() const { return shape_; }
 
   /// Return the length of an axis.
-  int Shape(int axis) const {
-    return shape_(axis);
-  }
+  int Shape(int axis) const { return shape_(axis); }
 
   /// Return the distance between neighboring elements along axis.
-  int Stride(int axis) const {
-    return strides_(axis);
-  }
+  int Stride(int axis) const { return strides_(axis); }
 
   /// Return the number of elements of the array.
   int Size() const {
@@ -194,18 +180,16 @@ class ArrayND : public BaseArray {
   }
 
   /// Return the total amount of memory used by the array.
-  int MemorySizeInBytes() const {
-    return sizeof(*this) + Size() * sizeof(T);
-  }
+  int MemorySizeInBytes() const { return sizeof(*this) + Size() * sizeof(T); }
 
   /// Pointer to the first element of the array.
-  T *Data() { return data_; }
+  T* Data() { return data_; }
 
   /// Constant pointer to the first element of the array.
-  const T *Data() const { return data_; }
+  const T* Data() const { return data_; }
 
   /// Distance between the first element and the element at position index.
-  int Offset(const Index &index) const {
+  int Offset(const Index& index) const {
     int offset = 0;
     for (int i = 0; i < N; ++i)
       offset += index(i) * Stride(i);
@@ -231,25 +215,23 @@ class ArrayND : public BaseArray {
   }
 
   /// Return a reference to the element at position index.
-  T &operator()(const Index &index) {
+  T& operator()(const Index& index) {
     // TODO(pau) Boundary checking in debug mode.
-    return *( Data() + Offset(index) );
+    return *(Data() + Offset(index));
   }
 
   /// 1D specialization.
-  T &operator()(int i0) {
-    return *( Data() + Offset(i0) );
-  }
+  T& operator()(int i0) { return *(Data() + Offset(i0)); }
 
   /// 2D specialization.
-  T &operator()(int i0, int i1) {
+  T& operator()(int i0, int i1) {
     assert(0 <= i0 && i0 < Shape(0));
     assert(0 <= i1 && i1 < Shape(1));
     return *(Data() + Offset(i0, i1));
   }
 
   /// 3D specialization.
-  T &operator()(int i0, int i1, int i2) {
+  T& operator()(int i0, int i1, int i2) {
     assert(0 <= i0 && i0 < Shape(0));
     assert(0 <= i1 && i1 < Shape(1));
     assert(0 <= i2 && i2 < Shape(2));
@@ -257,29 +239,27 @@ class ArrayND : public BaseArray {
   }
 
   /// Return a constant reference to the element at position index.
-  const T &operator()(const Index &index) const {
+  const T& operator()(const Index& index) const {
     return *(Data() + Offset(index));
   }
 
   /// 1D specialization.
-  const T &operator()(int i0) const {
-    return *(Data() + Offset(i0));
-  }
+  const T& operator()(int i0) const { return *(Data() + Offset(i0)); }
 
   /// 2D specialization.
-  const T &operator()(int i0, int i1) const {
+  const T& operator()(int i0, int i1) const {
     assert(0 <= i0 && i0 < Shape(0));
     assert(0 <= i1 && i1 < Shape(1));
     return *(Data() + Offset(i0, i1));
   }
 
   /// 3D specialization.
-  const T &operator()(int i0, int i1, int i2) const {
+  const T& operator()(int i0, int i1, int i2) const {
     return *(Data() + Offset(i0, i1, i2));
   }
 
   /// True if index is inside array.
-  bool Contains(const Index &index) const {
+  bool Contains(const Index& index) const {
     for (int i = 0; i < N; ++i)
       if (index(i) < 0 || index(i) >= Shape(i))
         return false;
@@ -287,26 +267,24 @@ class ArrayND : public BaseArray {
   }
 
   /// 1D specialization.
-  bool Contains(int i0) const {
-    return 0 <= i0 && i0 < Shape(0);
-  }
+  bool Contains(int i0) const { return 0 <= i0 && i0 < Shape(0); }
 
   /// 2D specialization.
   bool Contains(int i0, int i1) const {
-    return 0 <= i0 && i0 < Shape(0)
-        && 0 <= i1 && i1 < Shape(1);
+    return 0 <= i0 && i0 < Shape(0) && 0 <= i1 && i1 < Shape(1);
   }
 
   /// 3D specialization.
   bool Contains(int i0, int i1, int i2) const {
-    return 0 <= i0 && i0 < Shape(0)
-        && 0 <= i1 && i1 < Shape(1)
-        && 0 <= i2 && i2 < Shape(2);
+    return 0 <= i0 && i0 < Shape(0) && 0 <= i1 && i1 < Shape(1) && 0 <= i2 &&
+           i2 < Shape(2);
   }
 
-  bool operator==(const ArrayND<T, N> &other) const {
-    if (shape_ != other.shape_) return false;
-    if (strides_ != other.strides_) return false;
+  bool operator==(const ArrayND<T, N>& other) const {
+    if (shape_ != other.shape_)
+      return false;
+    if (strides_ != other.strides_)
+      return false;
     for (int i = 0; i < Size(); ++i) {
       if (this->Data()[i] != other.Data()[i])
         return false;
@@ -314,11 +292,11 @@ class ArrayND : public BaseArray {
     return true;
   }
 
-  bool operator!=(const ArrayND<T, N> &other) const {
+  bool operator!=(const ArrayND<T, N>& other) const {
     return !(*this == other);
   }
 
-  ArrayND<T, N> operator*(const ArrayND<T, N> &other) const {
+  ArrayND<T, N> operator*(const ArrayND<T, N>& other) const {
     assert(Shape() = other.Shape());
     ArrayND<T, N> res;
     res.ResizeLike(*this);
@@ -336,7 +314,7 @@ class ArrayND : public BaseArray {
   Index strides_;
 
   /// Pointer to the first element of the array.
-  T *data_;
+  T* data_;
 
   /// Flag if this Array either own or reference the data
   bool own_data_;
@@ -346,30 +324,20 @@ class ArrayND : public BaseArray {
 template <typename T>
 class Array3D : public ArrayND<T, 3> {
   typedef ArrayND<T, 3> Base;
+
  public:
-  Array3D()
-      : Base() {
-  }
-  Array3D(int height, int width, int depth = 1)
-      : Base(height, width, depth) {
-  }
+  Array3D() : Base() {}
+  Array3D(int height, int width, int depth = 1) : Base(height, width, depth) {}
   Array3D(T* data, int height, int width, int depth = 1)
-      : Base(data, height, width, depth) {
-  }
+      : Base(data, height, width, depth) {}
 
   void Resize(int height, int width, int depth = 1) {
     Base::Resize(height, width, depth);
   }
 
-  int Height() const {
-    return Base::Shape(0);
-  }
-  int Width() const {
-    return Base::Shape(1);
-  }
-  int Depth() const {
-    return Base::Shape(2);
-  }
+  int Height() const { return Base::Shape(0); }
+  int Width() const { return Base::Shape(1); }
+  int Depth() const { return Base::Shape(2); }
 
   // Match Eigen2's API so that Array3D's and Mat*'s can work together via
   // template magic.
@@ -377,15 +345,15 @@ class Array3D : public ArrayND<T, 3> {
   int cols() const { return Width(); }
   int depth() const { return Depth(); }
 
-  int Get_Step() const { return Width()*Depth(); }
+  int Get_Step() const { return Width() * Depth(); }
 
   /// Enable accessing with 2 indices for grayscale images.
-  T &operator()(int i0, int i1, int i2 = 0) {
+  T& operator()(int i0, int i1, int i2 = 0) {
     assert(0 <= i0 && i0 < Height());
     assert(0 <= i1 && i1 < Width());
     return Base::operator()(i0, i1, i2);
   }
-  const T &operator()(int i0, int i1, int i2 = 0) const {
+  const T& operator()(int i0, int i1, int i2 = 0) const {
     assert(0 <= i0 && i0 < Height());
     assert(0 <= i1 && i1 < Width());
     return Base::operator()(i0, i1, i2);
@@ -398,31 +366,29 @@ typedef Array3D<int> Array3Di;
 typedef Array3D<float> Array3Df;
 typedef Array3D<short> Array3Ds;
 
-void SplitChannels(const Array3Df &input,
-                   Array3Df *channel0,
-                   Array3Df *channel1,
-                   Array3Df *channel2);
+void SplitChannels(const Array3Df& input,
+                   Array3Df* channel0,
+                   Array3Df* channel1,
+                   Array3Df* channel2);
 
-void PrintArray(const Array3Df &array);
+void PrintArray(const Array3Df& array);
 
 /** Convert a float array into a byte array by scaling values by 255* (max-min).
- *  where max and min are automatically detected 
+ *  where max and min are automatically detected
  *  (if automatic_range_detection = true)
  * \note and TODO this automatic detection only works when the image contains
  *  at least one pixel of both bounds.
  **/
-void FloatArrayToScaledByteArray(const Array3Df &float_array,
-                                 Array3Du *byte_array,
+void FloatArrayToScaledByteArray(const Array3Df& float_array,
+                                 Array3Du* byte_array,
                                  bool automatic_range_detection = false);
 
 //! Convert a byte array into a float array by dividing values by 255.
-void ByteArrayToScaledFloatArray(const Array3Du &byte_array,
-                                 Array3Df *float_array);
+void ByteArrayToScaledFloatArray(const Array3Du& byte_array,
+                                 Array3Df* float_array);
 
 template <typename AArrayType, typename BArrayType, typename CArrayType>
-void MultiplyElements(const AArrayType &a,
-           const BArrayType &b,
-           CArrayType *c) {
+void MultiplyElements(const AArrayType& a, const BArrayType& b, CArrayType* c) {
   // This function does an element-wise multiply between
   // the two Arrays A and B, and stores the result in C.
   // A and B must have the same dimensions.
@@ -435,7 +401,7 @@ void MultiplyElements(const AArrayType &a,
 
   // The index starts at the maximum value for each dimension
   const typename CArrayType::Index& cShape = c->Shape();
-  for ( int i = 0; i < CArrayType::Index::SIZE; ++i )
+  for (int i = 0; i < CArrayType::Index::SIZE; ++i)
     index(i) = cShape(i) - 1;
 
   // After each multiplication, the highest-dimensional index is reduced.
@@ -443,12 +409,12 @@ void MultiplyElements(const AArrayType &a,
   // and decrements the index of the next lower dimension.
   // This ripple-action continues until the entire new array has been
   // calculated, indicated by dimension zero having a negative index.
-  while ( index(0) >= 0 ) {
+  while (index(0) >= 0) {
     (*c)(index) = a(index) * b(index);
 
     int dimension = CArrayType::Index::SIZE - 1;
     index(dimension) = index(dimension) - 1;
-    while ( dimension > 0 && index(dimension) < 0 ) {
+    while (dimension > 0 && index(dimension) < 0) {
       index(dimension) = cShape(dimension) - 1;
       index(dimension - 1) = index(dimension - 1) - 1;
       --dimension;
@@ -457,9 +423,9 @@ void MultiplyElements(const AArrayType &a,
 }
 
 template <typename TA, typename TB, typename TC>
-void MultiplyElements(const ArrayND<TA, 3> &a,
-                      const ArrayND<TB, 3> &b,
-                      ArrayND<TC, 3> *c) {
+void MultiplyElements(const ArrayND<TA, 3>& a,
+                      const ArrayND<TB, 3>& b,
+                      ArrayND<TC, 3>* c) {
   // Specialization for N==3
   c->ResizeLike(a);
   assert(a.Shape(0) == b.Shape(0));
@@ -475,9 +441,9 @@ void MultiplyElements(const ArrayND<TA, 3> &a,
 }
 
 template <typename TA, typename TB, typename TC>
-void MultiplyElements(const Array3D<TA> &a,
-                      const Array3D<TB> &b,
-                      Array3D<TC> *c) {
+void MultiplyElements(const Array3D<TA>& a,
+                      const Array3D<TB>& b,
+                      Array3D<TC>* c) {
   // Specialization for N==3
   c->ResizeLike(a);
   assert(a.Shape(0) == b.Shape(0));

intern/libmv/libmv/image/array_nd_test.cc

@@ -21,9 +21,9 @@
 #include "libmv/image/array_nd.h"
 #include "testing/testing.h"
 
-using libmv::ArrayND;
 using libmv::Array3D;
 using libmv::Array3Df;
+using libmv::ArrayND;
 
 namespace {
 
@@ -100,7 +100,7 @@ TEST(ArrayND, Size) {
   int l[] = {0, 1, 2};
   ArrayND<int, 3>::Index last(l);
 
-  EXPECT_EQ(a.Size(), a.Offset(last)+1);
+  EXPECT_EQ(a.Size(), a.Offset(last) + 1);
   EXPECT_TRUE(a.Contains(last));
   EXPECT_FALSE(a.Contains(shape));
 }
@@ -120,8 +120,8 @@ TEST(ArrayND, Parenthesis) {
   int s[] = {3, 3};
   ArrayND<int, 2> a(s);
 
-  *(a.Data()+0) = 0;
-  *(a.Data()+5) = 5;
+  *(a.Data() + 0) = 0;
+  *(a.Data() + 5) = 5;
 
   int i1[] = {0, 0};
   EXPECT_EQ(0, a(Index(i1)));
@@ -210,7 +210,7 @@ TEST(ArrayND, MultiplyElements) {
   b(1, 1, 0) = 3;
   ArrayND<int, 3> c;
   MultiplyElements(a, b, &c);
-  EXPECT_FLOAT_EQ(6,  c(0, 0, 0));
+  EXPECT_FLOAT_EQ(6, c(0, 0, 0));
   EXPECT_FLOAT_EQ(10, c(0, 1, 0));
   EXPECT_FLOAT_EQ(12, c(1, 0, 0));
   EXPECT_FLOAT_EQ(12, c(1, 1, 0));

intern/libmv/libmv/image/convolve.cc

@@ -29,7 +29,7 @@ namespace libmv {
 // Compute a Gaussian kernel and derivative, such that you can take the
 // derivative of an image by convolving with the kernel horizontally then the
 // derivative vertically to get (eg) the y derivative.
-void ComputeGaussianKernel(double sigma, Vec *kernel, Vec *derivative) {
+void ComputeGaussianKernel(double sigma, Vec* kernel, Vec* derivative) {
   assert(sigma >= 0.0);
 
   // 0.004 implies a 3 pixel kernel with 1 pixel sigma.
@@ -37,7 +37,7 @@ void ComputeGaussianKernel(double sigma, Vec *kernel, Vec *derivative) {
 
   // Calculate the kernel size based on sigma such that it is odd.
   float precisehalfwidth = GaussianInversePositive(truncation_factor, sigma);
-  int width = lround(2*precisehalfwidth);
+  int width = lround(2 * precisehalfwidth);
   if (width % 2 == 0) {
     width++;
   }
@@ -47,7 +47,7 @@ void ComputeGaussianKernel(double sigma, Vec *kernel, Vec *derivative) {
   kernel->setZero();
   derivative->setZero();
   int halfwidth = width / 2;
-  for (int i = -halfwidth; i <= halfwidth; ++i)  {
+  for (int i = -halfwidth; i <= halfwidth; ++i) {
     (*kernel)(i + halfwidth) = Gaussian(i, sigma);
     (*derivative)(i + halfwidth) = GaussianDerivative(i, sigma);
   }
@@ -57,16 +57,21 @@ void ComputeGaussianKernel(double sigma, Vec *kernel, Vec *derivative) {
   // Normalize the derivative differently. See
   // www.cs.duke.edu/courses/spring03/cps296.1/handouts/Image%20Processing.pdf
   double factor = 0.;
-  for (int i = -halfwidth; i <= halfwidth; ++i)  {
-    factor -= i*(*derivative)(i+halfwidth);
+  for (int i = -halfwidth; i <= halfwidth; ++i) {
+    factor -= i * (*derivative)(i + halfwidth);
   }
   *derivative /= factor;
 }
 
 template <int size, bool vertical>
-void FastConvolve(const Vec &kernel, int width, int height,
-                  const float* src, int src_stride, int src_line_stride,
-                  float* dst, int dst_stride) {
+void FastConvolve(const Vec& kernel,
+                  int width,
+                  int height,
+                  const float* src,
+                  int src_stride,
+                  int src_line_stride,
+                  float* dst,
+                  int dst_stride) {
   double coefficients[2 * size + 1];
   for (int k = 0; k < 2 * size + 1; ++k) {
     coefficients[k] = kernel(2 * size - k);
@@ -93,14 +98,14 @@ void FastConvolve(const Vec &kernel, int width, int height,
   }
 }
 
-template<bool vertical>
-void Convolve(const Array3Df &in,
-              const Vec &kernel,
-              Array3Df *out_pointer,
+template <bool vertical>
+void Convolve(const Array3Df& in,
+              const Vec& kernel,
+              Array3Df* out_pointer,
               int plane) {
   int width = in.Width();
   int height = in.Height();
-  Array3Df &out = *out_pointer;
+  Array3Df& out = *out_pointer;
   if (plane == -1) {
     out.ResizeLike(in);
     plane = 0;
@@ -119,61 +124,62 @@ void Convolve(const Array3Df &in,
   // fast path.
   int half_width = kernel.size() / 2;
   switch (half_width) {
-#define static_convolution(size) case size: \
-  FastConvolve<size, vertical>(kernel, width, height, src, src_stride, \
-                               src_line_stride, dst, dst_stride); break;
-    static_convolution(1)
-    static_convolution(2)
-    static_convolution(3)
-    static_convolution(4)
-    static_convolution(5)
-    static_convolution(6)
-    static_convolution(7)
+#define static_convolution(size)                                               \
+  case size:                                                                   \
+    FastConvolve<size, vertical>(kernel,                                       \
+                                 width,                                        \
+                                 height,                                       \
+                                 src,                                          \
+                                 src_stride,                                   \
+                                 src_line_stride,                              \
+                                 dst,                                          \
+                                 dst_stride);                                  \
+    break;
+    static_convolution(1) static_convolution(2) static_convolution(3)
+        static_convolution(4) static_convolution(5) static_convolution(6)
+            static_convolution(7)
 #undef static_convolution
-    default:
-      int dynamic_size = kernel.size() / 2;
-      for (int y = 0; y < height; ++y) {
-        for (int x = 0; x < width; ++x) {
-          double sum = 0;
-          // Slow path: this loop cannot be unrolled.
-          for (int k = -dynamic_size; k <= dynamic_size; ++k) {
-            if (vertical) {
-              if (y + k >= 0 && y + k < height) {
-                sum += src[k * src_line_stride] *
-                    kernel(2 * dynamic_size - (k + dynamic_size));
-              }
-            } else {
-              if (x + k >= 0 && x + k < width) {
-                sum += src[k * src_stride] *
-                    kernel(2 * dynamic_size - (k + dynamic_size));
-              }
+                default : int dynamic_size = kernel.size() / 2;
+    for (int y = 0; y < height; ++y) {
+      for (int x = 0; x < width; ++x) {
+        double sum = 0;
+        // Slow path: this loop cannot be unrolled.
+        for (int k = -dynamic_size; k <= dynamic_size; ++k) {
+          if (vertical) {
+            if (y + k >= 0 && y + k < height) {
+              sum += src[k * src_line_stride] *
+                     kernel(2 * dynamic_size - (k + dynamic_size));
+            }
+          } else {
+            if (x + k >= 0 && x + k < width) {
+              sum += src[k * src_stride] *
+                     kernel(2 * dynamic_size - (k + dynamic_size));
             }
           }
-          dst[0] = static_cast<float>(sum);
-          src += src_stride;
-          dst += dst_stride;
         }
+        dst[0] = static_cast<float>(sum);
+        src += src_stride;
+        dst += dst_stride;
       }
+    }
   }
 }
 
-void ConvolveHorizontal(const Array3Df &in,
-                        const Vec &kernel,
-                        Array3Df *out_pointer,
+void ConvolveHorizontal(const Array3Df& in,
+                        const Vec& kernel,
+                        Array3Df* out_pointer,
                         int plane) {
   Convolve<false>(in, kernel, out_pointer, plane);
 }
 
-void ConvolveVertical(const Array3Df &in,
-                      const Vec &kernel,
-                      Array3Df *out_pointer,
+void ConvolveVertical(const Array3Df& in,
+                      const Vec& kernel,
+                      Array3Df* out_pointer,
                       int plane) {
   Convolve<true>(in, kernel, out_pointer, plane);
 }
 
-void ConvolveGaussian(const Array3Df &in,
-                      double sigma,
-                      Array3Df *out_pointer) {
+void ConvolveGaussian(const Array3Df& in, double sigma, Array3Df* out_pointer) {
   Vec kernel, derivative;
   ComputeGaussianKernel(sigma, &kernel, &derivative);
 
@@ -182,10 +188,10 @@ void ConvolveGaussian(const Array3Df &in,
   ConvolveHorizontal(tmp, kernel, out_pointer);
 }
 
-void ImageDerivatives(const Array3Df &in,
+void ImageDerivatives(const Array3Df& in,
                       double sigma,
-                      Array3Df *gradient_x,
-                      Array3Df *gradient_y) {
+                      Array3Df* gradient_x,
+                      Array3Df* gradient_y) {
   Vec kernel, derivative;
   ComputeGaussianKernel(sigma, &kernel, &derivative);
   Array3Df tmp;
@@ -199,11 +205,11 @@ void ImageDerivatives(const Array3Df &in,
   ConvolveVertical(tmp, derivative, gradient_y);
 }
 
-void BlurredImageAndDerivatives(const Array3Df &in,
+void BlurredImageAndDerivatives(const Array3Df& in,
                                 double sigma,
-                                Array3Df *blurred_image,
-                                Array3Df *gradient_x,
-                                Array3Df *gradient_y) {
+                                Array3Df* blurred_image,
+                                Array3Df* gradient_x,
+                                Array3Df* gradient_y) {
   Vec kernel, derivative;
   ComputeGaussianKernel(sigma, &kernel, &derivative);
   Array3Df tmp;
@@ -224,9 +230,9 @@ void BlurredImageAndDerivatives(const Array3Df &in,
 // image, and store the results in three channels. Since the blurred value and
 // gradients are closer in memory, this leads to better performance if all
 // three values are needed at the same time.
-void BlurredImageAndDerivativesChannels(const Array3Df &in,
+void BlurredImageAndDerivativesChannels(const Array3Df& in,
                                         double sigma,
-                                        Array3Df *blurred_and_gradxy) {
+                                        Array3Df* blurred_and_gradxy) {
   assert(in.Depth() == 1);
 
   Vec kernel, derivative;
@@ -246,10 +252,10 @@ void BlurredImageAndDerivativesChannels(const Array3Df &in,
   ConvolveVertical(tmp, derivative, blurred_and_gradxy, 2);
 }
 
-void BoxFilterHorizontal(const Array3Df &in,
+void BoxFilterHorizontal(const Array3Df& in,
                          int window_size,
-                         Array3Df *out_pointer) {
-  Array3Df &out = *out_pointer;
+                         Array3Df* out_pointer) {
+  Array3Df& out = *out_pointer;
   out.ResizeLike(in);
   int half_width = (window_size - 1) / 2;
 
@@ -266,7 +272,7 @@ void BoxFilterHorizontal(const Array3Df &in,
         out(i, j, k) = sum;
       }
       // Fill interior.
-      for (int j = half_width + 1; j < in.Width()-half_width; ++j) {
+      for (int j = half_width + 1; j < in.Width() - half_width; ++j) {
         sum -= in(i, j - half_width - 1, k);
         sum += in(i, j + half_width, k);
         out(i, j, k) = sum;
@@ -280,10 +286,10 @@ void BoxFilterHorizontal(const Array3Df &in,
   }
 }
 
-void BoxFilterVertical(const Array3Df &in,
+void BoxFilterVertical(const Array3Df& in,
                        int window_size,
-                       Array3Df *out_pointer) {
-  Array3Df &out = *out_pointer;
+                       Array3Df* out_pointer) {
+  Array3Df& out = *out_pointer;
   out.ResizeLike(in);
   int half_width = (window_size - 1) / 2;
 
@@ -300,7 +306,7 @@ void BoxFilterVertical(const Array3Df &in,
         out(i, j, k) = sum;
       }
       // Fill interior.
-      for (int i = half_width + 1; i < in.Height()-half_width; ++i) {
+      for (int i = half_width + 1; i < in.Height() - half_width; ++i) {
         sum -= in(i - half_width - 1, j, k);
         sum += in(i + half_width, j, k);
         out(i, j, k) = sum;
@@ -314,9 +320,7 @@ void BoxFilterVertical(const Array3Df &in,
   }
 }
 
-void BoxFilter(const Array3Df &in,
-               int box_width,
-               Array3Df *out) {
+void BoxFilter(const Array3Df& in, int box_width, Array3Df* out) {
   Array3Df tmp;
   BoxFilterHorizontal(in, box_width, &tmp);
   BoxFilterVertical(tmp, box_width, out);
@@ -327,17 +331,17 @@ void LaplaceFilter(unsigned char* src,
                    int width,
                    int height,
                    int strength) {
-  for (int y = 1; y < height-1; y++)
-    for (int x = 1; x < width-1; x++) {
-      const unsigned char* s = &src[y*width+x];
-      int l = 128 +
-          s[-width-1] + s[-width] + s[-width+1] +
-          s[1]        - 8*s[0]    + s[1]        +
-          s[ width-1] + s[ width] + s[ width+1];
-      int d = ((256-strength)*s[0] + strength*l) / 256;
-      if (d < 0) d=0;
-      if (d > 255) d=255;
-      dst[y*width+x] = d;
+  for (int y = 1; y < height - 1; y++)
+    for (int x = 1; x < width - 1; x++) {
+      const unsigned char* s = &src[y * width + x];
+      int l = 128 + s[-width - 1] + s[-width] + s[-width + 1] + s[1] -
+              8 * s[0] + s[1] + s[width - 1] + s[width] + s[width + 1];
+      int d = ((256 - strength) * s[0] + strength * l) / 256;
+      if (d < 0)
+        d = 0;
+      if (d > 255)
+        d = 255;
+      dst[y * width + x] = d;
     }
 }
 

intern/libmv/libmv/image/convolve.h

@@ -30,70 +30,71 @@ namespace libmv {
 
 // Zero mean Gaussian.
 inline double Gaussian(double x, double sigma) {
-  return 1/sqrt(2*M_PI*sigma*sigma) * exp(-(x*x/2/sigma/sigma));
+  return 1 / sqrt(2 * M_PI * sigma * sigma) * exp(-(x * x / 2 / sigma / sigma));
 }
 // 2D gaussian (zero mean)
 // (9) in http://mathworld.wolfram.com/GaussianFunction.html
 inline double Gaussian2D(double x, double y, double sigma) {
-  return 1.0/(2.0*M_PI*sigma*sigma) * exp( -(x*x+y*y)/(2.0*sigma*sigma));
+  return 1.0 / (2.0 * M_PI * sigma * sigma) *
+         exp(-(x * x + y * y) / (2.0 * sigma * sigma));
 }
 inline double GaussianDerivative(double x, double sigma) {
   return -x / sigma / sigma * Gaussian(x, sigma);
 }
 // Solve the inverse of the Gaussian for positive x.
 inline double GaussianInversePositive(double y, double sigma) {
-  return sqrt(-2 * sigma * sigma * log(y * sigma * sqrt(2*M_PI)));
+  return sqrt(-2 * sigma * sigma * log(y * sigma * sqrt(2 * M_PI)));
 }
 
-void ComputeGaussianKernel(double sigma, Vec *kernel, Vec *derivative);
-void ConvolveHorizontal(const FloatImage &in,
-                        const Vec &kernel,
-                        FloatImage *out_pointer,
+void ComputeGaussianKernel(double sigma, Vec* kernel, Vec* derivative);
+void ConvolveHorizontal(const FloatImage& in,
+                        const Vec& kernel,
+                        FloatImage* out_pointer,
                         int plane = -1);
-void ConvolveVertical(const FloatImage &in,
-                      const Vec &kernel,
-                      FloatImage *out_pointer,
+void ConvolveVertical(const FloatImage& in,
+                      const Vec& kernel,
+                      FloatImage* out_pointer,
                       int plane = -1);
-void ConvolveGaussian(const FloatImage &in,
+void ConvolveGaussian(const FloatImage& in,
                       double sigma,
-                      FloatImage *out_pointer);
+                      FloatImage* out_pointer);
 
-void ImageDerivatives(const FloatImage &in,
+void ImageDerivatives(const FloatImage& in,
                       double sigma,
-                      FloatImage *gradient_x,
-                      FloatImage *gradient_y);
+                      FloatImage* gradient_x,
+                      FloatImage* gradient_y);
 
-void BlurredImageAndDerivatives(const FloatImage &in,
+void BlurredImageAndDerivatives(const FloatImage& in,
                                 double sigma,
-                                FloatImage *blurred_image,
-                                FloatImage *gradient_x,
-                                FloatImage *gradient_y);
+                                FloatImage* blurred_image,
+                                FloatImage* gradient_x,
+                                FloatImage* gradient_y);
 
 // Blur and take the gradients of an image, storing the results inside the
 // three channels of blurred_and_gradxy.
-void BlurredImageAndDerivativesChannels(const FloatImage &in,
+void BlurredImageAndDerivativesChannels(const FloatImage& in,
                                         double sigma,
-                                        FloatImage *blurred_and_gradxy);
+                                        FloatImage* blurred_and_gradxy);
 
-void BoxFilterHorizontal(const FloatImage &in,
+void BoxFilterHorizontal(const FloatImage& in,
                          int window_size,
-                         FloatImage *out_pointer);
+                         FloatImage* out_pointer);
 
-void BoxFilterVertical(const FloatImage &in,
+void BoxFilterVertical(const FloatImage& in,
                        int window_size,
-                       FloatImage *out_pointer);
+                       FloatImage* out_pointer);
 
-void BoxFilter(const FloatImage &in,
-               int box_width,
-               FloatImage *out);
+void BoxFilter(const FloatImage& in, int box_width, FloatImage* out);
 
 /*!
     Convolve \a src into \a dst with the discrete laplacian operator.
 
     \a src and \a dst should be \a width x \a height images.
-    \a strength is an interpolation coefficient (0-256) between original image and the laplacian.
+    \a strength is an interpolation coefficient (0-256) between original image
+   and the laplacian.
 
-    \note Make sure the search region is filtered with the same strength as the pattern.
+    \note Make sure the search region is filtered with the same strength as the
+   pattern.
 */
 void LaplaceFilter(unsigned char* src,
                    unsigned char* dst,
@@ -104,4 +105,3 @@ void LaplaceFilter(unsigned char* src,
 }  // namespace libmv
 
 #endif  // LIBMV_IMAGE_CONVOLVE_H_
-

intern/libmv/libmv/image/convolve_test.cc

@@ -85,26 +85,26 @@ TEST(Convolve, BlurredImageAndDerivativesChannelsHorizontalSlope) {
   FloatImage image(10, 10), blurred_and_derivatives;
   for (int j = 0; j < 10; ++j) {
     for (int i = 0; i < 10; ++i) {
-      image(j, i) = 2*i;
+      image(j, i) = 2 * i;
     }
   }
   BlurredImageAndDerivativesChannels(image, 0.9, &blurred_and_derivatives);
   EXPECT_NEAR(blurred_and_derivatives(5, 5, 0), 10.0, 1e-7);
-  EXPECT_NEAR(blurred_and_derivatives(5, 5, 1),  2.0, 1e-7);
-  EXPECT_NEAR(blurred_and_derivatives(5, 5, 2),  0.0, 1e-7);
+  EXPECT_NEAR(blurred_and_derivatives(5, 5, 1), 2.0, 1e-7);
+  EXPECT_NEAR(blurred_and_derivatives(5, 5, 2), 0.0, 1e-7);
 }
 
 TEST(Convolve, BlurredImageAndDerivativesChannelsVerticalSlope) {
   FloatImage image(10, 10), blurred_and_derivatives;
   for (int j = 0; j < 10; ++j) {
     for (int i = 0; i < 10; ++i) {
-      image(j, i) = 2*j;
+      image(j, i) = 2 * j;
     }
   }
   BlurredImageAndDerivativesChannels(image, 0.9, &blurred_and_derivatives);
   EXPECT_NEAR(blurred_and_derivatives(5, 5, 0), 10.0, 1e-7);
-  EXPECT_NEAR(blurred_and_derivatives(5, 5, 1),  0.0, 1e-7);
-  EXPECT_NEAR(blurred_and_derivatives(5, 5, 2),  2.0, 1e-7);
+  EXPECT_NEAR(blurred_and_derivatives(5, 5, 1), 0.0, 1e-7);
+  EXPECT_NEAR(blurred_and_derivatives(5, 5, 2), 2.0, 1e-7);
 }
 
 }  // namespace

intern/libmv/libmv/image/correlation.h

@@ -21,14 +21,14 @@
 #ifndef LIBMV_IMAGE_CORRELATION_H
 #define LIBMV_IMAGE_CORRELATION_H
 
-#include "libmv/logging/logging.h"
 #include "libmv/image/image.h"
+#include "libmv/logging/logging.h"
 
 namespace libmv {
 
 inline double PearsonProductMomentCorrelation(
-        const FloatImage &image_and_gradient1_sampled,
-        const FloatImage &image_and_gradient2_sampled) {
+    const FloatImage& image_and_gradient1_sampled,
+    const FloatImage& image_and_gradient2_sampled) {
   assert(image_and_gradient1_sampled.Width() ==
          image_and_gradient2_sampled.Width());
   assert(image_and_gradient1_sampled.Height() ==
@@ -63,9 +63,8 @@ inline double PearsonProductMomentCorrelation(
   double covariance_xy = sXY - sX * sY;
 
   double correlation = covariance_xy / sqrt(var_x * var_y);
-  LG << "Covariance xy: " << covariance_xy
-     << ", var 1: " << var_x << ", var 2: " << var_y
-     << ", correlation: " << correlation;
+  LG << "Covariance xy: " << covariance_xy << ", var 1: " << var_x
+     << ", var 2: " << var_y << ", correlation: " << correlation;
   return correlation;
 }
 

intern/libmv/libmv/image/image.h

@@ -39,14 +39,11 @@ typedef Array3Ds ShortImage;
 // is the best solution after all.
 class Image {
  public:
-
   // Create an image from an array. The image takes ownership of the array.
-  Image(Array3Du *array) : array_type_(BYTE), array_(array) {}
-  Image(Array3Df *array) : array_type_(FLOAT), array_(array) {}
+  Image(Array3Du* array) : array_type_(BYTE), array_(array) {}
+  Image(Array3Df* array) : array_type_(FLOAT), array_(array) {}
 
-  Image(const Image &img): array_type_(NONE), array_(NULL) {
-    *this = img;
-  }
+  Image(const Image& img) : array_type_(NONE), array_(NULL) { *this = img; }
 
   // Underlying data type.
   enum DataType {
@@ -62,20 +59,18 @@ class Image {
     int size;
     switch (array_type_) {
       case BYTE:
-        size = reinterpret_cast<Array3Du *>(array_)->MemorySizeInBytes();
-      break;
+        size = reinterpret_cast<Array3Du*>(array_)->MemorySizeInBytes();
+        break;
       case FLOAT:
-        size = reinterpret_cast<Array3Df *>(array_)->MemorySizeInBytes();
-      break;
+        size = reinterpret_cast<Array3Df*>(array_)->MemorySizeInBytes();
+        break;
       case INT:
-        size = reinterpret_cast<Array3Di *>(array_)->MemorySizeInBytes();
-      break;
+        size = reinterpret_cast<Array3Di*>(array_)->MemorySizeInBytes();
+        break;
       case SHORT:
-        size = reinterpret_cast<Array3Ds *>(array_)->MemorySizeInBytes();
-      break;
-    default :
-      size = 0;
-      assert(0);
+        size = reinterpret_cast<Array3Ds*>(array_)->MemorySizeInBytes();
+        break;
+      default: size = 0; assert(0);
     }
     size += sizeof(*this);
     return size;
@@ -83,71 +78,57 @@ class Image {
 
   ~Image() {
     switch (array_type_) {
-        case BYTE:
-          delete reinterpret_cast<Array3Du *>(array_);
-
-        break;
-        case FLOAT:
-          delete reinterpret_cast<Array3Df *>(array_);
-
-        break;
-        case INT:
-          delete reinterpret_cast<Array3Di *>(array_);
-
-        break;
-        case SHORT:
-          delete reinterpret_cast<Array3Ds *>(array_);
-
-        break;
-        default:
-          assert(0);
-      }
+      case BYTE: delete reinterpret_cast<Array3Du*>(array_); break;
+      case FLOAT: delete reinterpret_cast<Array3Df*>(array_); break;
+      case INT: delete reinterpret_cast<Array3Di*>(array_); break;
+      case SHORT: delete reinterpret_cast<Array3Ds*>(array_); break;
+      default: assert(0);
+    }
   }
 
-  Image& operator= (const Image& f)  {
+  Image& operator=(const Image& f) {
     if (this != &f) {
       array_type_ = f.array_type_;
       switch (array_type_) {
         case BYTE:
-          delete reinterpret_cast<Array3Du *>(array_);
-          array_ = new Array3Du(*(Array3Du *)f.array_);
-        break;
+          delete reinterpret_cast<Array3Du*>(array_);
+          array_ = new Array3Du(*(Array3Du*)f.array_);
+          break;
         case FLOAT:
-          delete reinterpret_cast<Array3Df *>(array_);
-          array_ = new Array3Df(*(Array3Df *)f.array_);
-        break;
+          delete reinterpret_cast<Array3Df*>(array_);
+          array_ = new Array3Df(*(Array3Df*)f.array_);
+          break;
         case INT:
-          delete reinterpret_cast<Array3Di *>(array_);
-          array_ = new Array3Di(*(Array3Di *)f.array_);
-        break;
+          delete reinterpret_cast<Array3Di*>(array_);
+          array_ = new Array3Di(*(Array3Di*)f.array_);
+          break;
         case SHORT:
-          delete reinterpret_cast<Array3Ds *>(array_);
-          array_ = new Array3Ds(*(Array3Ds *)f.array_);
-        break;
-        default:
-          assert(0);
+          delete reinterpret_cast<Array3Ds*>(array_);
+          array_ = new Array3Ds(*(Array3Ds*)f.array_);
+          break;
+        default: assert(0);
       }
     }
     return *this;
   }
 
-  Array3Du *AsArray3Du() const {
+  Array3Du* AsArray3Du() const {
     if (array_type_ == BYTE) {
-      return reinterpret_cast<Array3Du *>(array_);
+      return reinterpret_cast<Array3Du*>(array_);
     }
     return NULL;
   }
 
-  Array3Df *AsArray3Df() const {
+  Array3Df* AsArray3Df() const {
     if (array_type_ == FLOAT) {
-      return reinterpret_cast<Array3Df *>(array_);
+      return reinterpret_cast<Array3Df*>(array_);
     }
     return NULL;
   }
 
  private:
   DataType array_type_;
-  BaseArray *array_;
+  BaseArray* array_;
 };
 
 }  // namespace libmv

intern/libmv/libmv/image/image_converter.h

@@ -28,7 +28,7 @@ namespace libmv {
 // The factor comes from http://www.easyrgb.com/
 // RGB to XYZ : Y is the luminance channel
 // var_R * 0.2126 + var_G * 0.7152 + var_B * 0.0722
-template<typename T>
+template <typename T>
 inline T RGB2GRAY(const T r, const T g, const T b) {
   return static_cast<T>(r * 0.2126 + g * 0.7152 + b * 0.0722);
 }
@@ -42,8 +42,8 @@ inline unsigned char RGB2GRAY<unsigned char>(const unsigned char r,
   return (unsigned char)(r * 0.2126 + g * 0.7152 + b * 0.0722 +0.5);
 }*/
 
-template<class ImageIn, class ImageOut>
-void Rgb2Gray(const ImageIn &imaIn, ImageOut *imaOut) {
+template <class ImageIn, class ImageOut>
+void Rgb2Gray(const ImageIn& imaIn, ImageOut* imaOut) {
   // It is all fine to cnvert RGBA image here as well,
   // all the additional channels will be nicely ignored.
   assert(imaIn.Depth() >= 3);
@@ -52,21 +52,22 @@ void Rgb2Gray(const ImageIn &imaIn, ImageOut *imaOut) {
   // Convert each RGB pixel into Gray value (luminance)
 
   for (int j = 0; j < imaIn.Height(); ++j) {
-    for (int i = 0; i < imaIn.Width(); ++i)  {
-      (*imaOut)(j, i) = RGB2GRAY(imaIn(j, i, 0) , imaIn(j, i, 1), imaIn(j, i, 2));
+    for (int i = 0; i < imaIn.Width(); ++i) {
+      (*imaOut)(j, i) =
+          RGB2GRAY(imaIn(j, i, 0), imaIn(j, i, 1), imaIn(j, i, 2));
     }
   }
 }
 
 // Convert given float image to an unsigned char array of pixels.
-template<class Image>
-unsigned char *FloatImageToUCharArray(const Image &image) {
-  unsigned char *buffer =
+template <class Image>
+unsigned char* FloatImageToUCharArray(const Image& image) {
+  unsigned char* buffer =
       new unsigned char[image.Width() * image.Height() * image.Depth()];
 
   for (int y = 0; y < image.Height(); y++) {
-    for (int x = 0; x < image.Width(); x++)  {
-      for (int d = 0; d < image.Depth(); d++)  {
+    for (int x = 0; x < image.Width(); x++) {
+      for (int d = 0; d < image.Depth(); d++) {
         int index = (y * image.Width() + x) * image.Depth() + d;
         buffer[index] = 255.0 * image(y, x, d);
       }

intern/libmv/libmv/image/image_drawing.h

@@ -34,9 +34,9 @@ namespace libmv {
 /// Put the pixel in the image to the given color only if the point (xc,yc)
 /// is inside the image.
 template <class Image, class Color>
-inline void safePutPixel(int yc, int xc, const Color & col, Image *pim) {
+inline void safePutPixel(int yc, int xc, const Color& col, Image* pim) {
   if (!pim)
-     return;
+    return;
   if (pim->Contains(yc, xc)) {
     (*pim)(yc, xc) = col;
   }
@@ -45,9 +45,9 @@ inline void safePutPixel(int yc, int xc, const Color & col, Image *pim) {
 /// is inside the image. This function support multi-channel color
 /// \note The color pointer col must have size as the image depth
 template <class Image, class Color>
-inline void safePutPixel(int yc, int xc, const Color *col, Image *pim) {
+inline void safePutPixel(int yc, int xc, const Color* col, Image* pim) {
   if (!pim)
-     return;
+    return;
   if (pim->Contains(yc, xc)) {
     for (int i = 0; i < pim->Depth(); ++i)
       (*pim)(yc, xc, i) = *(col + i);
@@ -59,19 +59,23 @@ inline void safePutPixel(int yc, int xc, const Color *col, Image *pim) {
 // Add the rotation of the ellipse.
 // As the algo. use symmetry we must use 4 rotations.
 template <class Image, class Color>
-void DrawEllipse(int xc, int yc, int radiusA, int radiusB,
-                 const Color &col, Image *pim, double angle = 0.0) {
+void DrawEllipse(int xc,
+                 int yc,
+                 int radiusA,
+                 int radiusB,
+                 const Color& col,
+                 Image* pim,
+                 double angle = 0.0) {
   int a = radiusA;
   int b = radiusB;
 
   // Counter Clockwise rotation matrix.
-  double matXY[4] = { cos(angle), sin(angle),
-                     -sin(angle), cos(angle)};
+  double matXY[4] = {cos(angle), sin(angle), -sin(angle), cos(angle)};
   int x, y;
   double d1, d2;
   x = 0;
   y = b;
-  d1 = b*b - a*a*b + a*a/4;
+  d1 = b * b - a * a * b + a * a / 4;
 
   float rotX = (matXY[0] * x + matXY[1] * y);
   float rotY = (matXY[2] * x + matXY[3] * y);
@@ -86,12 +90,12 @@ void DrawEllipse(int xc, int yc, int radiusA, int radiusB,
   rotY = (-matXY[2] * x + matXY[3] * y);
   safePutPixel(yc + rotY, xc + rotX, col, pim);
 
-  while (a*a*(y-.5) > b*b*(x+1)) {
+  while (a * a * (y - .5) > b * b * (x + 1)) {
     if (d1 < 0) {
-      d1 += b*b*(2*x+3);
+      d1 += b * b * (2 * x + 3);
       ++x;
     } else {
-      d1 += b*b*(2*x+3) + a*a*(-2*y+2);
+      d1 += b * b * (2 * x + 3) + a * a * (-2 * y + 2);
       ++x;
       --y;
     }
@@ -108,14 +112,14 @@ void DrawEllipse(int xc, int yc, int radiusA, int radiusB,
     rotY = (-matXY[2] * x + matXY[3] * y);
     safePutPixel(yc + rotY, xc + rotX, col, pim);
   }
-  d2 = b*b*(x+.5)*(x+.5) + a*a*(y-1)*(y-1) - a*a*b*b;
+  d2 = b * b * (x + .5) * (x + .5) + a * a * (y - 1) * (y - 1) - a * a * b * b;
   while (y > 0) {
     if (d2 < 0) {
-      d2 += b*b*(2*x+2) + a*a*(-2*y+3);
+      d2 += b * b * (2 * x + 2) + a * a * (-2 * y + 3);
       --y;
       ++x;
     } else {
-      d2 += a*a*(-2*y+3);
+      d2 += a * a * (-2 * y + 3);
       --y;
     }
     rotX = (matXY[0] * x + matXY[1] * y);
@@ -137,23 +141,23 @@ void DrawEllipse(int xc, int yc, int radiusA, int radiusB,
 // So it's better the use the Andres method.
 // http://fr.wikipedia.org/wiki/Algorithme_de_tracé_de_cercle_d'Andres.
 template <class Image, class Color>
-void DrawCircle(int x, int y, int radius, const Color &col, Image *pim) {
-  Image &im = *pim;
-  if (  im.Contains(y + radius, x + radius)
-     || im.Contains(y + radius, x - radius)
-     || im.Contains(y - radius, x + radius)
-     || im.Contains(y - radius, x - radius)) {
+void DrawCircle(int x, int y, int radius, const Color& col, Image* pim) {
+  Image& im = *pim;
+  if (im.Contains(y + radius, x + radius) ||
+      im.Contains(y + radius, x - radius) ||
+      im.Contains(y - radius, x + radius) ||
+      im.Contains(y - radius, x - radius)) {
     int x1 = 0;
     int y1 = radius;
     int d = radius - 1;
     while (y1 >= x1) {
       // Draw the point for each octant.
-      safePutPixel( y1 + y,  x1 + x, col, pim);
-      safePutPixel( x1 + y,  y1 + x, col, pim);
-      safePutPixel( y1 + y, -x1 + x, col, pim);
-      safePutPixel( x1 + y, -y1 + x, col, pim);
-      safePutPixel(-y1 + y,  x1 + x, col, pim);
-      safePutPixel(-x1 + y,  y1 + x, col, pim);
+      safePutPixel(y1 + y, x1 + x, col, pim);
+      safePutPixel(x1 + y, y1 + x, col, pim);
+      safePutPixel(y1 + y, -x1 + x, col, pim);
+      safePutPixel(x1 + y, -y1 + x, col, pim);
+      safePutPixel(-y1 + y, x1 + x, col, pim);
+      safePutPixel(-x1 + y, y1 + x, col, pim);
       safePutPixel(-y1 + y, -x1 + x, col, pim);
       safePutPixel(-x1 + y, -y1 + x, col, pim);
       if (d >= 2 * x1) {
@@ -163,7 +167,7 @@ void DrawCircle(int x, int y, int radius, const Color &col, Image *pim) {
         if (d <= 2 * (radius - y1)) {
           d = d + 2 * y1 - 1;
           y1 -= 1;
-        } else  {
+        } else {
           d = d + 2 * (y1 - x1 - 1);
           y1 -= 1;
           x1 += 1;
@@ -175,8 +179,8 @@ void DrawCircle(int x, int y, int radius, const Color &col, Image *pim) {
 
 // Bresenham algorithm
 template <class Image, class Color>
-void DrawLine(int xa, int ya, int xb, int yb, const Color &col, Image *pim) {
-  Image &im = *pim;
+void DrawLine(int xa, int ya, int xb, int yb, const Color& col, Image* pim) {
+  Image& im = *pim;
 
   // If one point is outside the image
   // Replace the outside point by the intersection of the line and
@@ -185,35 +189,37 @@ void DrawLine(int xa, int ya, int xb, int yb, const Color &col, Image *pim) {
     int width = pim->Width();
     int height = pim->Height();
     const bool xdir = xa < xb, ydir = ya < yb;
-    float nx0 = xa, nx1 = xb, ny0 = ya, ny1 = yb,
-        &xleft = xdir?nx0:nx1,  &yleft = xdir?ny0:ny1,
-        &xright = xdir?nx1:nx0, &yright = xdir?ny1:ny0,
-        &xup = ydir?nx0:nx1,    &yup = ydir?ny0:ny1,
-        &xdown = ydir?nx1:nx0,  &ydown = ydir?ny1:ny0;
+    float nx0 = xa, nx1 = xb, ny0 = ya, ny1 = yb, &xleft = xdir ? nx0 : nx1,
+          &yleft = xdir ? ny0 : ny1, &xright = xdir ? nx1 : nx0,
+          &yright = xdir ? ny1 : ny0, &xup = ydir ? nx0 : nx1,
+          &yup = ydir ? ny0 : ny1, &xdown = ydir ? nx1 : nx0,
+          &ydown = ydir ? ny1 : ny0;
 
-    if (xright < 0 || xleft >= width) return;
+    if (xright < 0 || xleft >= width)
+      return;
     if (xleft < 0) {
-      yleft -= xleft*(yright - yleft)/(xright - xleft);
-      xleft  = 0;
+      yleft -= xleft * (yright - yleft) / (xright - xleft);
+      xleft = 0;
     }
     if (xright >= width) {
-      yright -= (xright - width)*(yright - yleft)/(xright - xleft);
-      xright  = width - 1;
+      yright -= (xright - width) * (yright - yleft) / (xright - xleft);
+      xright = width - 1;
     }
-    if (ydown < 0 || yup >= height) return;
+    if (ydown < 0 || yup >= height)
+      return;
     if (yup < 0) {
-      xup -= yup*(xdown - xup)/(ydown - yup);
-      yup  =  0;
+      xup -= yup * (xdown - xup) / (ydown - yup);
+      yup = 0;
     }
     if (ydown >= height) {
-      xdown -= (ydown - height)*(xdown - xup)/(ydown - yup);
-      ydown  =  height - 1;
+      xdown -= (ydown - height) * (xdown - xup) / (ydown - yup);
+      ydown = height - 1;
     }
 
-    xa = (int) xleft;
-    xb = (int) xright;
-    ya = (int) yleft;
-    yb = (int) yright;
+    xa = (int)xleft;
+    xb = (int)xright;
+    ya = (int)yleft;
+    yb = (int)yright;
   }
 
   int xbas, xhaut, ybas, yhaut;
@@ -241,7 +247,7 @@ void DrawLine(int xa, int ya, int xb, int yb, const Color &col, Image *pim) {
   }
   if (dy > 0) {  // Positive slope will increment X.
     incrmY = 1;
-  } else {       // Negative slope.
+  } else {  // Negative slope.
     incrmY = -1;
   }
   if (dx >= dy) {
@@ -255,9 +261,9 @@ void DrawLine(int xa, int ya, int xb, int yb, const Color &col, Image *pim) {
       x += incrmX;
       if (dp <= 0) {  // Go in direction of the South Pixel.
         dp += S;
-      } else {        // Go to the North.
+      } else {  // Go to the North.
         dp += N;
-        y+=incrmY;
+        y += incrmY;
       }
     }
   } else {
@@ -271,7 +277,7 @@ void DrawLine(int xa, int ya, int xb, int yb, const Color &col, Image *pim) {
       y += incrmY;
       if (dp <= 0) {  // Go in direction of the South Pixel.
         dp += S;
-      } else {        // Go to the North.
+      } else {  // Go to the North.
         dp += N;
         x += incrmX;
       }

intern/libmv/libmv/image/image_test.cc

@@ -23,20 +23,20 @@
 #include "libmv/image/image.h"
 #include "testing/testing.h"
 
-using libmv::Image;
 using libmv::Array3Df;
+using libmv::Image;
 
 namespace {
 
 TEST(Image, SimpleImageAccessors) {
-  Array3Df *array = new Array3Df(2, 3);
+  Array3Df* array = new Array3Df(2, 3);
   Image image(array);
   EXPECT_EQ(array, image.AsArray3Df());
   EXPECT_TRUE(NULL == image.AsArray3Du());
 }
 
 TEST(Image, MemorySizeInBytes) {
-  Array3Df *array = new Array3Df(2, 3);
+  Array3Df* array = new Array3Df(2, 3);
   Image image(array);
   int size = sizeof(image) + array->MemorySizeInBytes();
   EXPECT_EQ(size, image.MemorySizeInBytes());

intern/libmv/libmv/image/sample.h

@@ -26,17 +26,14 @@
 namespace libmv {
 
 /// Nearest neighbor interpolation.
-template<typename T>
-inline T SampleNearest(const Array3D<T> &image,
-                       float y, float x, int v = 0) {
+template <typename T>
+inline T SampleNearest(const Array3D<T>& image, float y, float x, int v = 0) {
   const int i = int(round(y));
   const int j = int(round(x));
   return image(i, j, v);
 }
 
-inline void LinearInitAxis(float x, int size,
-                           int *x1, int *x2,
-                           float *dx) {
+inline void LinearInitAxis(float x, int size, int* x1, int* x2, float* dx) {
   const int ix = static_cast<int>(x);
   if (ix < 0) {
     *x1 = 0;
@@ -54,32 +51,32 @@ inline void LinearInitAxis(float x, int size,
 }
 
 /// Linear interpolation.
-template<typename T>
-inline T SampleLinear(const Array3D<T> &image, float y, float x, int v = 0) {
+template <typename T>
+inline T SampleLinear(const Array3D<T>& image, float y, float x, int v = 0) {
   int x1, y1, x2, y2;
   float dx, dy;
 
   LinearInitAxis(y, image.Height(), &y1, &y2, &dy);
-  LinearInitAxis(x, image.Width(),  &x1, &x2, &dx);
+  LinearInitAxis(x, image.Width(), &x1, &x2, &dx);
 
   const T im11 = image(y1, x1, v);
   const T im12 = image(y1, x2, v);
   const T im21 = image(y2, x1, v);
   const T im22 = image(y2, x2, v);
 
-  return T(     dy  * (dx * im11 + (1.0 - dx) * im12) +
+  return T(dy * (dx * im11 + (1.0 - dx) * im12) +
            (1 - dy) * (dx * im21 + (1.0 - dx) * im22));
 }
 
 /// Linear interpolation, of all channels. The sample is assumed to have the
 /// same size as the number of channels in image.
-template<typename T>
-inline void SampleLinear(const Array3D<T> &image, float y, float x, T *sample) {
+template <typename T>
+inline void SampleLinear(const Array3D<T>& image, float y, float x, T* sample) {
   int x1, y1, x2, y2;
   float dx, dy;
 
   LinearInitAxis(y, image.Height(), &y1, &y2, &dy);
-  LinearInitAxis(x, image.Width(),  &x1, &x2, &dx);
+  LinearInitAxis(x, image.Width(), &x1, &x2, &dx);
 
   for (int i = 0; i < image.Depth(); ++i) {
     const T im11 = image(y1, x1, i);
@@ -87,7 +84,7 @@ inline void SampleLinear(const Array3D<T> &image, float y, float x, T *sample) {
     const T im21 = image(y2, x1, i);
     const T im22 = image(y2, x2, i);
 
-    sample[i] = T(     dy  * (dx * im11 + (1.0 - dx) * im12) +
+    sample[i] = T(dy * (dx * im11 + (1.0 - dx) * im12) +
                   (1 - dy) * (dx * im21 + (1.0 - dx) * im22));
   }
 }
@@ -95,7 +92,7 @@ inline void SampleLinear(const Array3D<T> &image, float y, float x, T *sample) {
 // Downsample all channels by 2. If the image has odd width or height, the last
 // row or column is ignored.
 // FIXME(MatthiasF): this implementation shouldn't be in an interface file
-inline void DownsampleChannelsBy2(const Array3Df &in, Array3Df *out) {
+inline void DownsampleChannelsBy2(const Array3Df& in, Array3Df* out) {
   int height = in.Height() / 2;
   int width = in.Width() / 2;
   int depth = in.Depth();
@@ -106,10 +103,12 @@ inline void DownsampleChannelsBy2(const Array3Df &in, Array3Df *out) {
   for (int r = 0; r < height; ++r) {
     for (int c = 0; c < width; ++c) {
       for (int k = 0; k < depth; ++k) {
+        // clang-format off
         (*out)(r, c, k) = (in(2 * r,     2 * c,     k) +
                            in(2 * r + 1, 2 * c,     k) +
                            in(2 * r,     2 * c + 1, k) +
                            in(2 * r + 1, 2 * c + 1, k)) / 4.0f;
+        // clang-format on
       }
     }
   }
@@ -117,11 +116,12 @@ inline void DownsampleChannelsBy2(const Array3Df &in, Array3Df *out) {
 
 // Sample a region centered at x,y in image with size extending by half_width
 // from x,y. Channels specifies the number of channels to sample from.
-inline void SamplePattern(const FloatImage &image,
-                   double x, double y,
-                   int half_width,
-                   int channels,
-                   FloatImage *sampled) {
+inline void SamplePattern(const FloatImage& image,
+                          double x,
+                          double y,
+                          int half_width,
+                          int channels,
+                          FloatImage* sampled) {
   sampled->Resize(2 * half_width + 1, 2 * half_width + 1, channels);
   for (int r = -half_width; r <= half_width; ++r) {
     for (int c = -half_width; c <= half_width; ++c) {

intern/libmv/libmv/image/sample_test.cc

@@ -32,9 +32,9 @@ TEST(Image, Nearest) {
   image(1, 0) = 2;
   image(1, 1) = 3;
   EXPECT_EQ(0, SampleNearest(image, -0.4f, -0.4f));
-  EXPECT_EQ(0, SampleNearest(image,  0.4f,  0.4f));
-  EXPECT_EQ(3, SampleNearest(image,  0.6f,  0.6f));
-  EXPECT_EQ(3, SampleNearest(image,  1.4f,  1.4f));
+  EXPECT_EQ(0, SampleNearest(image, 0.4f, 0.4f));
+  EXPECT_EQ(3, SampleNearest(image, 0.6f, 0.6f));
+  EXPECT_EQ(3, SampleNearest(image, 1.4f, 1.4f));
 }
 
 TEST(Image, Linear) {
@@ -57,7 +57,7 @@ TEST(Image, DownsampleBy2) {
   ASSERT_EQ(1, resampled_image.Height());
   ASSERT_EQ(1, resampled_image.Width());
   ASSERT_EQ(1, resampled_image.Depth());
-  EXPECT_FLOAT_EQ(6./4., resampled_image(0, 0));
+  EXPECT_FLOAT_EQ(6. / 4., resampled_image(0, 0));
 }
 
 TEST(Image, DownsampleBy2MultiChannel) {
@@ -82,8 +82,8 @@ TEST(Image, DownsampleBy2MultiChannel) {
   ASSERT_EQ(1, resampled_image.Height());
   ASSERT_EQ(1, resampled_image.Width());
   ASSERT_EQ(3, resampled_image.Depth());
-  EXPECT_FLOAT_EQ((0+1+2+3)/4.,    resampled_image(0, 0, 0));
-  EXPECT_FLOAT_EQ((5+6+7+8)/4.,    resampled_image(0, 0, 1));
-  EXPECT_FLOAT_EQ((9+10+11+12)/4., resampled_image(0, 0, 2));
+  EXPECT_FLOAT_EQ((0 + 1 + 2 + 3) / 4., resampled_image(0, 0, 0));
+  EXPECT_FLOAT_EQ((5 + 6 + 7 + 8) / 4., resampled_image(0, 0, 1));
+  EXPECT_FLOAT_EQ((9 + 10 + 11 + 12) / 4., resampled_image(0, 0, 2));
 }
 }  // namespace

intern/libmv/libmv/image/tuple.h

@@ -34,10 +34,14 @@ class Tuple {
   Tuple(T initial_value) { Reset(initial_value); }
 
   template <typename D>
-  Tuple(D *values) { Reset(values); }
+  Tuple(D* values) {
+    Reset(values);
+  }
 
   template <typename D>
-  Tuple(const Tuple<D, N> &b) { Reset(b); }
+  Tuple(const Tuple<D, N>& b) {
+    Reset(b);
+  }
 
   template <typename D>
   Tuple& operator=(const Tuple<D, N>& b) {
@@ -46,30 +50,32 @@ class Tuple {
   }
 
   template <typename D>
-  void Reset(const Tuple<D, N>& b) { Reset(b.Data()); }
+  void Reset(const Tuple<D, N>& b) {
+    Reset(b.Data());
+  }
 
   template <typename D>
-  void Reset(D *values) {
-    for (int i = 0;i < N; i++) {
+  void Reset(D* values) {
+    for (int i = 0; i < N; i++) {
       data_[i] = T(values[i]);
     }
   }
 
   // Set all tuple values to the same thing.
   void Reset(T value) {
-    for (int i = 0;i < N; i++) {
+    for (int i = 0; i < N; i++) {
       data_[i] = value;
     }
   }
 
   // Pointer to the first element.
-  T *Data() { return &data_[0]; }
-  const T *Data() const { return &data_[0]; }
+  T* Data() { return &data_[0]; }
+  const T* Data() const { return &data_[0]; }
 
-  T &operator()(int i) { return data_[i]; }
-  const T &operator()(int i) const { return data_[i]; }
+  T& operator()(int i) { return data_[i]; }
+  const T& operator()(int i) const { return data_[i]; }
 
-  bool operator==(const Tuple<T, N> &other) const {
+  bool operator==(const Tuple<T, N>& other) const {
     for (int i = 0; i < N; ++i) {
       if ((*this)(i) != other(i)) {
         return false;
@@ -77,9 +83,7 @@ class Tuple {
     }
     return true;
   }
-  bool operator!=(const Tuple<T, N> &other) const {
-    return !(*this == other);
-  }
+  bool operator!=(const Tuple<T, N>& other) const { return !(*this == other); }
 
  private:
   T data_[N];