Initial commit

Author: MrMabulous

README.md

@@ -0,0 +1,5 @@
+# CubeMapToOctMap
+Fast tool to convert OpenExr Cube Maps to Octahedron Maps
+
+Build with Bazel:
+bazel build //src:cubemap_to_octmap

WORKSPACE

@@ -0,0 +1,26 @@
+workspace(name = "cubemap_to_octmap")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+  name = "gtest",
+  url = "https://github.com/google/googletest/archive/release-1.8.0.zip",
+  strip_prefix = "googletest-release-1.8.0",
+  sha256 = "f3ed3b58511efd272eb074a3a6d6fb79d7c2e6a0e374323d1e6bcbcc1ef141bf",
+  build_file = "@//third_party:gtest.BUILD",
+)
+
+http_archive(
+    name = "openexr",
+    build_file = "@//third_party:openexr.BUILD",
+    strip_prefix = "openexr-2.2.0",
+    urls = ["https://github.com/openexr/openexr/archive/v2.2.0.zip"],
+)
+
+http_archive(
+    name = "zlib",
+    build_file = "@//third_party:zlib.BUILD",
+    strip_prefix = "zlib-1.2.11",
+    sha256 = "f5cc4ab910db99b2bdbba39ebbdc225ffc2aa04b4057bc2817f1b94b6978cfc3",
+    urls = ["https://github.com/madler/zlib/archive/v1.2.11.zip"],
+)

src/BUILD

@@ -0,0 +1,36 @@
+# Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+
+config_setting(
+    name = "windows",
+    values = {
+        "crosstool_top": "//crosstools/windows",
+    },
+)
+
+cc_library(
+    name = "openexr_deps",
+    deps = [
+        "@openexr//:ilm_imf",
+        "@openexr//:imath",
+    ],
+)
+
+cc_binary(
+    name = "cubemap_to_octmap",
+    srcs = [
+        "main.cc",
+        "stringutils.cc"
+    ],
+    includes = [
+        "cubemaputil.h",
+        "octmaputil.h",
+        "stringutils.h",
+        "filter.h"
+    ],
+    copts = select({
+            ":windows": ["/std:c++17"],
+            "//conditions:default": ["-std:c++17"],
+    }),
+    deps = [":openexr_deps"],
+    visibility = ["//visibility:public"],
+)

src/cubemaputil.h

@@ -0,0 +1,144 @@
+/*
+ * Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+*/
+
+#ifndef CUBEMAP_UTIL_H
+#define CUBEMAP_UTIL_H
+
+#include <cmath>
+
+#include "IlmBase/Imath/ImathVec.h"
+
+// considers cubemaps to be in the following order:
+// [right][left][top][bottom][back][front]
+// This is how renderers like V-Ray or Keyshot output cubemaps.
+
+// for coordinates, a right handed coordinate syste is considered with:
+// Right:   +X
+// Top:     +Y
+// Forward: -Z
+
+// uv coordinates are considered to start in the bottom left corner.
+
+#define MIRROR_FACES 1
+// if this is defined, each face of the cubemap is teated as horizontally mirrored (except for top and bottom, which are vertically mirrored),
+// which again is how V-Ray and Keyshot output their cubemaps.
+
+Imath::V2f sampleCube(
+    const Imath::V3f& v,
+    int* faceIndex)
+{
+    Imath::V3f vAbs = Imath::V3f(std::abs(v.x), std::abs(v.y), std::abs(v.z));
+    float ma;
+    Imath::V2f uv;
+    if (vAbs.z >= vAbs.x && vAbs.z >= vAbs.y)
+    { // +Z -Z
+        *faceIndex = v.z < 0 ? 5 : 4;
+        ma = 0.5f / vAbs.z;
+        uv = Imath::V2f(v.z < 0 ? v.x : -v.x, v.y);
+#ifdef MIRROR_FACES
+        uv.x = -uv.x;
+#endif
+    }
+    else if (vAbs.y >= vAbs.x)
+    {
+        *faceIndex = v.y < 0 ? 3 : 2;
+        ma = 0.5f / vAbs.y;
+        uv = Imath::V2f(v.x, v.y < 0 ? -v.z : v.z);
+#ifdef MIRROR_FACES
+        uv.y = -uv.y;
+#endif
+    }
+    else
+    {
+        *faceIndex = v.x < 0 ? 1 : 0;
+        ma = 0.5f / vAbs.x;
+        uv = Imath::V2f(v.x < 0 ? -v.z : v.z, v.y);
+#ifdef MIRROR_FACES
+        uv.x = -uv.x;
+#endif
+    }
+    return (uv * ma) + Imath::V2f(0.5f,0.5f);
+}
+
+/** Assumes that v is a unit vector. The result is a cubemap vector on the [0, 1] square. */
+Imath::V2f cubeEncode(const Imath::V3f& v, int* face_out) {
+    Imath::V2f uv = sampleCube(v, face_out);
+    uv.x = std::clamp(uv.x, 0.0f, 1.0f);
+    uv.y = std::clamp(uv.y, 0.0f, 1.0f);
+    return uv;
+}
+
+/** Returns a unit vector. Argument o is an cubemap vector packed via cubeEncode,
+    on the [0, +1] square*/
+Imath::V3f cubeDecode(const Imath::V2f& o) {
+    float tmp;
+    float u = std::modf(o.x, &tmp);
+    if (u < 0)
+        u = 1.0f + u;
+    float v = std::modf(o.y, &tmp);
+    if (v < 0)
+        v = 1.0f + u;
+
+    Imath::V3f res;
+
+    v = v * 2.0f - 1.0f;
+    u *= 6.0f;
+    if (u < 1.0f) { // Right, +X
+        u = (u-0.5) * 2.0f;
+#ifdef MIRROR_FACES
+        u = -u;
+#endif
+       res.x = 1.0f;
+       res.y = v;
+       res.z = u;
+    }
+    else if (u < 2.0f) { // Left, -X
+        u = (u-1.5f) * 2.0f;
+#ifdef MIRROR_FACES
+        u = -u;
+#endif
+        res.x = -1.0f;
+        res.y = v;
+        res.z = -u;
+    }
+    else if (u < 3.0f) { // Top, +Y
+        u = (u-2.5f) * 2.0f;
+#ifdef MIRROR_FACES
+        v = -v;
+#endif
+        res.x = u;
+        res.y = 1.0f;
+        res.z = v;
+    }
+    else if (u < 4.0f) { // Bottom, -Y
+        u = (u-3.5f) * 2.0f;
+#ifdef MIRROR_FACES
+        v = -v;
+#endif
+        res.x = u;
+        res.y = -1.0f;
+        res.z = -v;
+    }
+    else if (u < 5.0f) { // Back, +Z
+        u = (u-4.5f) * 2.0f;
+#ifdef MIRROR_FACES
+        u = -u;
+#endif
+        res.x = -u;
+        res.y = v;
+        res.z = 1.0f;
+    }
+    else { // Front, -Z
+        u = (u-5.5f) * 2.0f;
+#ifdef MIRROR_FACES
+        u = -u;
+#endif
+        res.x = u;
+        res.y = v;
+        res.z = -1.0f;
+    }
+    return res.normalized();
+}
+
+#endif  // CUBEMAP_UTIL_H

src/filter.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+*/
+
+#ifndef IMAGE_FILTER_H
+#define IMAGE_FILTER_H
+
+#include "IlmBase/Imath/ImathVec.h"
+
+class Filter {
+ public:
+  // Evaluate the filter for the given position relative to it's center.
+  virtual float Eval(const Imath::V2f& position) const = 0;
+
+  // Return the radius of the filter. This is a bounding circle around the
+  // support of the filter.
+  virtual float GetRadius() const = 0;
+};
+
+class MitchellFilter : public Filter {
+ public:
+  // Constructs a Mitchell filter with the given parameters B and C.
+  // B = 0, C = 1 is the cubic B-spline.
+  // B = 0, is the family of cardinal splines.
+  // B = 0, C = 0.5 is the Catmull-Rom spline.
+  // The authors of the original paper suggest B + 2C = 1 as good parameters.
+  // In particular B = C = 1/3.
+  MitchellFilter(float b, float c) : b_(b), c_(c) {}
+
+  // Default constructor, B = C = 1/3.
+  MitchellFilter() : b_(1.0f / 3.0f), c_(1.0f / 3.0f) {}
+
+  float Eval(const Imath::V2f& position) const override {
+    const float d = position.length();
+    const float d2 = d * d;
+    const float d3 = d2 * d;
+    if (d < 1.0f) {
+      return ((12.0f - 9.0f * b_ - 6.0f * c_) * d3 +
+              (-18.0f + 12.0f * b_ + 6.0f * c_) * d2 +
+              (6.0f - 2.0f * b_)) /
+             6.0f;
+    } else if ((d >= 1.0f) && (d < 2.0f)) {
+      return ((-b_ - 6.0f * c_) * d3 +
+              (6.0f * b_ + 30.0f * c_) * d2 +
+              (-12.0f * b_ - 48.0f * c_) * d +
+              (8.0f * b_ + 24.0f * c_)) /
+             6.0f;
+    } else {
+      return 0.0f;
+    }
+  }
+
+  float GetRadius() const override { return 2.0f; }
+
+ private:
+  // The two constants B and C defining the filter's shape.
+  const float b_;
+  const float c_;
+};
+
+class GaussianFilter : public Filter {
+ public:
+  // Constructs a gaussian filter with the given standard deviation sigma and
+  // radius. The gaussian is truncated at distance radius and shifted such
+  // that f(radius) = 0. As a rule of thumb, radius = 3 * sigma is a reasonable
+  // choice for the cut-off.
+  GaussianFilter(float sigma, float radius)
+      : radius_(radius),
+        a_(1.0f / (std::sqrt(2 * M_PI) * sigma)),
+        b_(-1.0f / (2.0f * sigma * sigma)),
+        c_(-a_ * std::exp(radius * radius * b_)) {}
+
+  // Default constructor with radius = 2.0, sigma = 2.0/3
+  GaussianFilter() : GaussianFilter(2.0f/3, 2.0f) {}
+  
+
+  float Eval(const Imath::V2f& position) const override {
+    const float d2 = position.length2();;
+    if (d2 >= radius_ * radius_) {
+      return 0.0f;
+    }
+    return a_ * std::exp(d2 * b_) + c_;
+  }
+
+  float GetRadius() const override { return radius_; }
+
+ private:
+  const float radius_;
+  const float a_;
+  const float b_;
+  const float c_;
+};
+
+
+#endif  // IMAGE_FILTER_H

src/main.cc

@@ -0,0 +1,50 @@
+/*
+ * Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+*/
+
+#ifndef OCTMAP_UTIL_H
+#define OCTMAP_UTIL_H
+
+#include <cmath>
+
+#include "IlmBase/Imath/ImathVec.h"
+
+float signNotZero(float k) {
+    return (k >= 0.0f) ? 1.0f : -1.0f;
+}
+
+Imath::V2f signNotZero(const Imath::V2f& v) {
+    return Imath::V2f(signNotZero(v.x), signNotZero(v.y));
+}
+
+
+// X+ maps to result.x+
+// Y+ maps to result.y+
+// Z+ maps to the center
+// Z- maps to the corners
+
+/** Assumes that v is a unit vector. The result is an octahedral vector on the [-1, +1] square. */
+Imath::V2f octEncode(const Imath::V3f& v) {
+    float l1norm = std::abs(v.x) + abs(v.y) + abs(v.z);
+    float invL1norm = 1.0f / l1norm;
+    Imath::V2f result(v.x * invL1norm, v.y * invL1norm);
+    if (v.z < 0.0f) {
+        result = (Imath::V2f(1.0f,1.0f) - Imath::V2f(std::abs(result.y), std::abs(result.x))) *
+            signNotZero(Imath::V2f(result.x, result.y));
+    }
+    return result;
+}
+
+/** Returns a unit vector. Argument o is an octahedral vector packed via octEncode,
+    on the [-1, +1] square*/
+Imath::V3f octDecode(const Imath::V2f& o) {
+    Imath::V3f v(o.x, o.y, 1.0f - std::abs(o.x) - std::abs(o.y));
+    if (v.z < 0.0f) {
+        v.x = (1.0f - std::abs(o.y)) * signNotZero(o.x);
+        v.y = (1.0f - std::abs(o.x)) * signNotZero(o.y);
+    }
+    v.normalize();
+    return v;
+}
+
+#endif  // OCTMAP_UTIL_H

src/octmaputil.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+*/
+
+#include "stringutils.h"
+
+#include <algorithm>
+#include <cctype>
+
+// Removes leading and trailing whitespace from string.
+std::string trim(const std::string& s) {
+    std::string tmp = s.substr(0, s.find_last_not_of(" ") + 1);
+    tmp = tmp.substr(tmp.find_first_not_of(" "));
+    return tmp;
+}
+
+// Splits string at delimiter into array.
+std::vector<std::string> split(const std::string& str, const std::string& delimiter) {
+    std::string s = str;
+    size_t delimiterPos = s.find(delimiter);
+    if (delimiterPos == std::string::npos) {
+        s = trim(s);
+        return std::vector<std::string>(1, s);
+    }
+    std::string left = s.substr(0, delimiterPos);
+    left = trim(left);
+    std::string right = s.substr(delimiterPos + 1, std::string::npos);
+    right = trim(right);
+    std::vector<std::string> res(1, left);
+    std::vector<std::string> rightElements = split(right, delimiter);
+    res.insert(res.end(), rightElements.begin(), rightElements.end());
+    return res;
+}
+
+// Converts string to lower case.
+std::string toLower(const std::string& s) {
+    std::string lower = s;
+    std::transform(lower.begin(), lower.end(), lower.begin(),
+        [](unsigned char c) { return std::tolower(c); });
+    return lower;
+}

src/stringutils.cc

@@ -0,0 +1,20 @@
+/*
+ * Copyright(c) 2020 Matthias Bühlmann, Mabulous GmbH. http://www.mabulous.com
+*/
+
+#ifndef STRING_UTILS_H
+#define STRING_UTILS_H
+
+#include <string>
+#include <vector>
+
+// Removes leading and trailing whitespace from string.
+std::string trim(const std::string& s);
+
+// Splits string at delimiter into array.
+std::vector<std::string> split(const std::string& str, const std::string& delimiter);
+
+// Converts string to lower case.
+std::string toLower(const std::string& s);
+
+#endif  // STRING_UTILS_H

src/stringutils.h

@@ -0,0 +1,14 @@
+cc_library(
+    name = "main",
+    srcs = glob(
+        include = ["googletest/src/*.h",
+                   "googletest/include/gtest/internal/**/*.h",
+                   "googletest/src/*.cc"],
+        exclude = ["googletest/src/gtest-all.cc"]
+    ),
+    hdrs = glob(["googletest/include/gtest/*.h"]),
+    includes = ["googletest/",
+                "googletest/include"],
+    linkopts = ["-pthread"],
+    visibility = ["//visibility:public"],
+)

third_party/BUILD

@@ -0,0 +1,367 @@
+# Copyright 2017 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+#   Bazel build file for the ILM OpenEXR libraries.
+
+package(
+    default_visibility = ["//visibility:public"],
+    features = [
+        "-layering_check",
+        "-parse_headers",
+    ],
+)
+
+licenses(["notice"])  # BSD
+
+exports_files(["LICENSE"])
+
+config_setting(
+    name = "linux_x86_64",
+    values = {"cpu": "k8"},
+    visibility = ["//visibility:public"],
+)
+
+config_setting(
+    name = "windows_x86_64",
+    values = {"cpu": "x64_windows"},
+    visibility = ["//visibility:public"],
+)
+
+DEFINES = [
+    "DISABLE_GOOGLE_GLOBAL_USING_DECLARATIONS",
+] + select({
+    ":linux_x86_64": [
+        "OS_LINUX=OS_LINUX",
+        "ARCH_K8",
+    ],
+    ":windows_x86_64": [
+        "NOGDI",  # Don't pollute with GDI macros in windows.h.
+        "NOMINMAX",  # Don't define min/max macros in windows.h.
+        "OS_WINDOWS=OS_WINDOWS",
+        "PRAGMA_SUPPORTED",
+        "WIN32",
+        "WINVER=0x0600",
+        "_CRT_SECURE_NO_DEPRECATE",
+        "_WIN32",
+        "_WIN32_WINNT=0x0600",
+        "_WINDOWS",
+
+        # Defaults for other headers (along with OS_WINDOWS).
+        "COMPILER_MSVC",
+
+        # Use math constants (M_PI, etc.) from the math library
+        "_USE_MATH_DEFINES",
+
+        # Allows 'Foo&&' (e.g., move constructors).
+        "COMPILER_HAS_RVALUEREF",
+
+        # Doublespeak for "don't bloat namespace with incompatible winsock
+        # versions that I didn't include".
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms737629.aspx
+        "WIN32_LEAN_AND_MEAN=1",
+
+        "PLATFORM_WINDOWS",
+    ],
+})
+
+# Options for everything below
+all_options = [
+    "-D_THREAD_SAFE",
+] + select({
+    ":windows_x86_64": ["/EHsc"],
+    ":linux_x86_64": [
+        "-fexceptions",
+        "-fno-common",
+        "-Wno-unused-variable",
+        "-Wno-unused-result",
+        "-Wno-string-conversion",
+        "-Wno-switch",
+        "-Wno-tautological-compare",
+        "-Wno-deprecated-register",
+        # IlmImf/ImfHuf.cpp:111 wants to put a 21520 byte object on the stack.
+        "$(STACK_FRAME_UNLIMITED)",
+    ],
+})
+
+# Generates the config headers. Note we don't use the autoconf, but the
+# libraries still require a header.
+genrule(
+    name = "configure_ilmbase",
+    outs = ["IlmBase/config/IlmBaseConfig.h"],
+    cmd = "touch $@",
+)
+
+# Wraps the config header auto generation, then injects the desired defines and
+# include folder configuration.
+cc_library(
+    name = "ilmbase_config",
+    hdrs = [":configure_ilmbase"],
+    defines = DEFINES,
+    includes = ["IlmBase/config/"],
+)
+
+################################################################################
+# Build the half library and its support components
+# ILM's libhalf is considered the reference implementation.
+half_path = "IlmBase/Half/"
+
+cc_binary(
+    name = "toFloat",
+    srcs = [half_path + "toFloat.cpp"],
+    copts = all_options,
+    defines = DEFINES,
+)
+
+cc_binary(
+    name = "eLut",
+    srcs = [half_path + "eLut.cpp"],
+    copts = all_options,
+    defines = DEFINES,
+)
+
+genrule(
+    name = "toFloatAutoGen",
+    outs = [half_path + "toFloat.h"],
+    # Runs the tool from its built location, and captures to the single output
+    # of this rule.
+    cmd = "$(location :toFloat) > $@",
+    tools = [":toFloat"],
+)
+
+genrule(
+    name = "eLutAutoGen",
+    outs = [half_path + "eLut.h"],
+    # Runs the tool from its built location, and captures to the single output
+    # of this rule.
+    cmd = "$(location :eLut) > $@",
+    tools = [":eLut"],
+)
+
+cc_library(
+    name = "half",
+    srcs = glob([half_path + "half.cpp"]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [half_path],
+    textual_hdrs = glob([
+        half_path + "half.h",
+        half_path + "halfExport.h",
+        half_path + "halfFunction.h",
+        half_path + "halfLimits.h",
+    ]) + [
+        ":toFloatAutoGen",
+        ":eLutAutoGen",
+    ],
+    deps = [":ilmbase_config"],
+)
+
+################################################################################
+# Build the Iex library
+iex_path = "IlmBase/Iex/"
+
+cc_library(
+    name = "iex",
+    srcs = glob([iex_path + "*.cpp"]),
+    hdrs = glob([iex_path + "*.h"]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [iex_path],
+    deps = [":ilmbase_config"],
+)
+
+################################################################################
+# Build the IexMath library
+iex_math_path = "IlmBase/IexMath/"
+
+cc_library(
+    name = "iex_math",
+    srcs = glob([iex_math_path + "*.cpp"]),
+    hdrs = glob([iex_math_path + "*.h"]),
+    copts = all_options,
+    includes = [iex_math_path],
+    deps = [
+        ":half",
+        ":iex",
+    ],
+)
+
+################################################################################
+# Build the IlmThread library and its tests components
+ilm_thread_path = "IlmBase/IlmThread/"
+
+ilm_thread_win_srcs_pattern = ilm_thread_path + "*Win32.cpp"
+
+ilm_thread_win_hdrs_pattern = ilm_thread_path + "*Win32.h"
+
+cc_library(
+    name = "ilm_thread",
+    srcs = glob(
+        [ilm_thread_path + "*.cpp"],
+        exclude = [ilm_thread_win_srcs_pattern],
+    ) + select({
+        ":windows_x86_64": glob([ilm_thread_win_srcs_pattern]),
+        ":linux_x86_64": [],
+    }),
+    hdrs = glob(
+        [ilm_thread_path + "*.h"],
+        exclude = [ilm_thread_win_hdrs_pattern],
+    ) + select({
+        ":windows_x86_64": glob([ilm_thread_win_hdrs_pattern]),
+        ":linux_x86_64": [],
+    }),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [
+        ilm_thread_path,
+    ],
+    deps = [
+        ":iex",
+        ":ilmbase_config",
+    ],
+)
+
+################################################################################
+# Build the Imath library
+imath_path = "IlmBase/Imath/"
+
+cc_library(
+    name = "imath",
+    srcs = glob([imath_path + "*.cpp"]),
+    hdrs = glob([imath_path + "*.h"]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [
+        imath_path,
+    ],
+    deps = [
+        ":half",
+        ":iex",
+        ":iex_math",
+        ":ilmbase_config",
+    ],
+)
+
+################################################################################
+# Build the IlmImf library
+ilm_imf_path = "OpenEXR/IlmImf/"
+
+ilm_imf_util_path = "OpenEXR/IlmImfUtil/"
+
+# Generates the config headers. Note we don't use the autoconf, but the
+# libraries still require a header.
+genrule(
+    name = "configure_openexr",
+    outs = ["OpenEXR/config/OpenEXRConfig.h"],
+    cmd = "touch $@",
+)
+
+# Wraps the config auto generation with the include folder configuration.
+cc_library(
+    name = "openexr_config",
+    hdrs = [":configure_openexr"],
+    defines = DEFINES,
+    includes = ["OpenEXR/config/"],
+)
+
+cc_binary(
+    name = "dwaLookups",
+    srcs = [
+        ilm_imf_path + "dwaLookups.cpp",
+    ] +
+    # Note we include various headers via glob since we don't have cc_library
+    # targets for some of the sub-libraries of OpenEXR.
+    glob([
+        ilm_imf_util_path + "**/*.h",
+        ilm_imf_path + "*.h",
+    ]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [
+        imath_path,
+        iex_math_path,
+        ilm_imf_path,
+        ilm_imf_util_path,
+    ],
+    deps = [
+        ":half",
+        ":iex",
+        ":ilm_thread",
+        ":imath",
+        ":openexr_config",
+    ],
+)
+
+cc_binary(
+    name = "b44ExpLogTable",
+    srcs = [
+        ilm_imf_path + "b44ExpLogTable.cpp",
+    ] + glob(["**/*.h"]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [
+        half_path,
+        imath_path,
+        iex_math_path,
+        iex_path,
+        ilm_imf_path,
+        ilm_imf_util_path,
+        ilm_thread_path,
+    ],
+    deps = [
+        ":half",
+        ":iex",
+        ":ilm_thread",
+        ":openexr_config",
+    ],
+)
+
+genrule(
+    name = "dwaLookupsAutoGen",
+    outs = [ilm_imf_path + "dwaLookups.h"],
+    # Runs the tool from its built location, and captures to the single output
+    # of this rule.
+    cmd = "$(location :dwaLookups) > $@",
+    tools = [":dwaLookups"],
+)
+
+genrule(
+    name = "b44ExpLogTableAutoGen",
+    outs = [ilm_imf_path + "b44ExpLogTable.h"],
+    # Runs the tool from its built location, and captures to the single output
+    # of this rule.
+    cmd = "$(location :b44ExpLogTable) > $@",
+    tools = [":b44ExpLogTable"],
+)
+
+cc_library(
+    name = "ilm_imf",
+    srcs = glob([ilm_imf_path + "Imf*.cpp"]) + [
+        ":dwaLookupsAutoGen",
+        ":b44ExpLogTableAutoGen",
+    ],
+    hdrs = glob([ilm_imf_path + "Imf*.h"]),
+    copts = all_options,
+    defines = DEFINES,
+    includes = [ilm_imf_path],
+    deps = [
+        ":half",
+        ":iex",
+        ":iex_math",
+        ":ilm_thread",
+        ":imath",
+        ":openexr_config",
+        "@zlib//:zlib"
+    ],
+)

third_party/gtest.BUILD

@@ -0,0 +1,76 @@
+# Copyright 2017 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS-IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Description:
+#   Bazel build file for ZLib.
+
+package(
+    default_visibility = ["//visibility:public"],
+    features = [
+        "-layering_check",
+        "-parse_headers",
+    ],
+)
+
+genrule(
+    name = "copy_zconf",
+    srcs = ["zconf.h.in"],
+    outs = ["zconf.h"],
+    cmd_bat = "copy /b /Y $< $@",
+    cmd = "cp $< $@",
+    visibility = ["//visibility:private"],
+)
+
+cc_library(
+    name = "zconf",
+    hdrs = [":copy_zconf"],
+    visibility = ["//visibility:private"],
+)
+
+cc_library(
+    name = "zlib",
+    srcs = [
+        "adler32.c",
+        "compress.c",
+        "crc32.c",
+        "deflate.c",
+        "gzclose.c",
+        "gzlib.c",
+        "gzread.c",
+        "gzwrite.c",
+        "infback.c",
+        "inffast.c",
+        "inflate.c",
+        "inftrees.c",
+        "trees.c",
+        "uncompr.c",
+        "zutil.c",
+    ],
+    includes = ["zconf.h"],
+    hdrs = [
+        "crc32.h",
+        "deflate.h",
+        "gzguts.h",
+        "inffast.h",
+        "inffixed.h",
+        "inflate.h",
+        "inftrees.h",
+        "trees.h",
+        "zlib.h",
+        "zutil.h",
+        "zconf.h"
+    ],
+    deps = [":zconf"],
+    visibility = ["//visibility:public"],
+)