diff --git a/src/theia/image/image.cc b/src/theia/image/image.cc
index df6aba4..5e2b8dc 100644
--- a/src/theia/image/image.cc
+++ b/src/theia/image/image.cc
@@ -60,18 +60,18 @@ FloatImage::FloatImage(const FloatImage& image_to_copy) {
 }
 
 FloatImage::FloatImage(const int width, const int height, const int channels) {
-  OpenImageIO::ImageSpec image_spec(width, height, channels,
-                                    OpenImageIO::TypeDesc::FLOAT);
+  OIIO_NAMESPACE::ImageSpec image_spec(width, height, channels,
+                                    OIIO_NAMESPACE::TypeDesc::FLOAT);
   image_.reset(image_spec);
 }
 
 FloatImage::FloatImage(const int width, const int height, const int channels,
                        float* buffer)
-    : image_(OpenImageIO::ImageSpec(width, height, channels,
-                                    OpenImageIO::TypeDesc::FLOAT),
+    : image_(OIIO_NAMESPACE::ImageSpec(width, height, channels,
+                                    OIIO_NAMESPACE::TypeDesc::FLOAT),
              reinterpret_cast<void*>(buffer)) {}
 
-FloatImage::FloatImage(const OpenImageIO::ImageBuf& image) {
+FloatImage::FloatImage(const OIIO_NAMESPACE::ImageBuf& image) {
   image_.copy(image);
 }
 
@@ -80,11 +80,11 @@ FloatImage& FloatImage::operator=(const FloatImage& image2) {
   return *this;
 }
 
-OpenImageIO::ImageBuf& FloatImage::GetOpenImageIOImageBuf() {
+OIIO_NAMESPACE::ImageBuf& FloatImage::GetOpenImageIOImageBuf() {
   return image_;
 }
 
-const OpenImageIO::ImageBuf& FloatImage::GetOpenImageIOImageBuf() const {
+const OIIO_NAMESPACE::ImageBuf& FloatImage::GetOpenImageIOImageBuf() const {
   return image_;
 }
 
@@ -110,7 +110,7 @@ void FloatImage::SetXY(const int x,
   DCHECK_LT(c, Channels());
 
   // Set the ROI to be the precise pixel location in the correct channel.
-  OpenImageIO::ImageBuf::Iterator<float> it(image_, x, y, 0);
+  OIIO_NAMESPACE::ImageBuf::Iterator<float> it(image_, x, y, 0);
   it[c] = value;
 }
 
@@ -195,9 +195,9 @@ void FloatImage::ConvertToGrayscaleImage() {
   // Compute luminance via a weighted sum of R,G,B (assuming Rec709 primaries
   // and a linear scale)
   const float luma_weights[3] = {.2126, .7152, .0722};
-  OpenImageIO::ImageBuf source = image_;
+  OIIO_NAMESPACE::ImageBuf source = image_;
   image_.clear();
-  OpenImageIO::ImageBufAlgo::channel_sum(image_, source, luma_weights);
+  OIIO_NAMESPACE::ImageBufAlgo::channel_sum(image_, source, luma_weights);
 }
 
 void FloatImage::ConvertToRGBImage() {
@@ -207,13 +207,13 @@ void FloatImage::ConvertToRGBImage() {
   }
 
   // Copy the single grayscale channel into r, g, and b.
-  const OpenImageIO::ImageBuf source(image_);
-  OpenImageIO::ImageSpec image_spec(Width(), Height(), 3,
-                                    OpenImageIO::TypeDesc::FLOAT);
+  const OIIO_NAMESPACE::ImageBuf source(image_);
+  OIIO_NAMESPACE::ImageSpec image_spec(Width(), Height(), 3,
+                                    OIIO_NAMESPACE::TypeDesc::FLOAT);
   image_.reset(image_spec);
-  OpenImageIO::ImageBufAlgo::paste(image_, 0, 0, 0, 0, source);
-  OpenImageIO::ImageBufAlgo::paste(image_, 0, 0, 0, 1, source);
-  OpenImageIO::ImageBufAlgo::paste(image_, 0, 0, 0, 2, source);
+  OIIO_NAMESPACE::ImageBufAlgo::paste(image_, 0, 0, 0, 0, source);
+  OIIO_NAMESPACE::ImageBufAlgo::paste(image_, 0, 0, 0, 1, source);
+  OIIO_NAMESPACE::ImageBufAlgo::paste(image_, 0, 0, 0, 2, source);
 }
 
 FloatImage FloatImage::AsGrayscaleImage() const {
@@ -238,12 +238,12 @@ FloatImage FloatImage::AsRGBImage() const {
 }
 
 void FloatImage::ScalePixels(float scale) {
-  OpenImageIO::ImageBufAlgo::mul(image_, image_, scale);
+  OIIO_NAMESPACE::ImageBufAlgo::mul(image_, image_, scale);
 }
 
 void FloatImage::Read(const std::string& filename) {
   image_.reset(filename);
-  image_.read(0, 0, true, OpenImageIO::TypeDesc::FLOAT);
+  image_.read(0, 0, true, OIIO_NAMESPACE::TypeDesc::FLOAT);
 }
 
 void FloatImage::Write(const std::string& filename) const {
@@ -259,19 +259,19 @@ const float* FloatImage::Data() const {
 
 FloatImage FloatImage::ComputeGradientX() const {
   float sobel_filter_x[9] = {-.125, 0, .125, -.25, 0, .25, -.125, 0, .125};
-  OpenImageIO::ImageSpec spec(3, 3, 1, OpenImageIO::TypeDesc::FLOAT);
-  OpenImageIO::ImageBuf kernel_x(spec, sobel_filter_x);
-  OpenImageIO::ImageBuf gradient_x;
-  OpenImageIO::ImageBufAlgo::convolve(gradient_x, image_, kernel_x, false);
+  OIIO_NAMESPACE::ImageSpec spec(3, 3, 1, OIIO_NAMESPACE::TypeDesc::FLOAT);
+  OIIO_NAMESPACE::ImageBuf kernel_x(spec, sobel_filter_x);
+  OIIO_NAMESPACE::ImageBuf gradient_x;
+  OIIO_NAMESPACE::ImageBufAlgo::convolve(gradient_x, image_, kernel_x, false);
   return FloatImage(gradient_x);
 }
 
 FloatImage FloatImage::ComputeGradientY() const {
   float sobel_filter_y[9] = {-.125, -.25, -.125, 0, 0, 0, .125, .25, .125};
-  OpenImageIO::ImageSpec spec(3, 3, 1, OpenImageIO::TypeDesc::FLOAT);
-  OpenImageIO::ImageBuf kernel_y(spec, sobel_filter_y);
-  OpenImageIO::ImageBuf gradient_y;
-  OpenImageIO::ImageBufAlgo::convolve(gradient_y, image_, kernel_y, false);
+  OIIO_NAMESPACE::ImageSpec spec(3, 3, 1, OIIO_NAMESPACE::TypeDesc::FLOAT);
+  OIIO_NAMESPACE::ImageBuf kernel_y(spec, sobel_filter_y);
+  OIIO_NAMESPACE::ImageBuf gradient_y;
+  OIIO_NAMESPACE::ImageBufAlgo::convolve(gradient_y, image_, kernel_y, false);
   return FloatImage(gradient_y);
 }
 
@@ -280,28 +280,28 @@ FloatImage FloatImage::ComputeGradient() const {
   float sobel_filter_x[9] = {-.125, 0, .125, -.25, 0, .25, -.125, 0, .125};
   float sobel_filter_y[9] = {-.125, -.25, -.125, 0, 0, 0, .125, .25, .125};
 
-  OpenImageIO::ImageSpec spec(3, 3, 1, OpenImageIO::TypeDesc::FLOAT);
-  OpenImageIO::ImageBuf kernel_x(spec, sobel_filter_x);
-  OpenImageIO::ImageBuf kernel_y(spec, sobel_filter_y);
+  OIIO_NAMESPACE::ImageSpec spec(3, 3, 1, OIIO_NAMESPACE::TypeDesc::FLOAT);
+  OIIO_NAMESPACE::ImageBuf kernel_x(spec, sobel_filter_x);
+  OIIO_NAMESPACE::ImageBuf kernel_y(spec, sobel_filter_y);
 
-  OpenImageIO::ImageBuf gradient, gradient_x, gradient_y;
-  OpenImageIO::ImageBufAlgo::convolve(gradient_x, image_, kernel_x, false);
-  OpenImageIO::ImageBufAlgo::abs(gradient_x, gradient_x);
-  OpenImageIO::ImageBufAlgo::convolve(gradient_y, image_, kernel_y, false);
-  OpenImageIO::ImageBufAlgo::abs(gradient_y, gradient_y);
-  OpenImageIO::ImageBufAlgo::add(gradient, gradient_x, gradient_y);
+  OIIO_NAMESPACE::ImageBuf gradient, gradient_x, gradient_y;
+  OIIO_NAMESPACE::ImageBufAlgo::convolve(gradient_x, image_, kernel_x, false);
+  OIIO_NAMESPACE::ImageBufAlgo::abs(gradient_x, gradient_x);
+  OIIO_NAMESPACE::ImageBufAlgo::convolve(gradient_y, image_, kernel_y, false);
+  OIIO_NAMESPACE::ImageBufAlgo::abs(gradient_y, gradient_y);
+  OIIO_NAMESPACE::ImageBufAlgo::add(gradient, gradient_x, gradient_y);
 
   return FloatImage(gradient);
 }
 
 void FloatImage::ApproximateGaussianBlur(const double sigma) {
-  OpenImageIO::ImageBuf kernel;
-  OpenImageIO::ImageBufAlgo::make_kernel(kernel, "gaussian", 5.0f, 5.0f);
-  OpenImageIO::ImageBufAlgo::convolve(image_, image_, kernel);
+  OIIO_NAMESPACE::ImageBuf kernel;
+  OIIO_NAMESPACE::ImageBufAlgo::make_kernel(kernel, "gaussian", 5.0f, 5.0f);
+  OIIO_NAMESPACE::ImageBufAlgo::convolve(image_, image_, kernel);
 }
 
 void FloatImage::MedianFilter(const int patch_width) {
-  CHECK(OpenImageIO::ImageBufAlgo::median_filter(image_, image_, patch_width));
+  CHECK(OIIO_NAMESPACE::ImageBufAlgo::median_filter(image_, image_, patch_width));
 }
 
 void FloatImage::Integrate(FloatImage* integral) const {
@@ -327,14 +327,14 @@ void FloatImage::Resize(int new_width, int new_height) {
   // If the image has not been initialized then initialize it with the image
   // spec. Otherwise resize the image and interpolate pixels accordingly.
   if (!image_.initialized()) {
-    OpenImageIO::ImageSpec image_spec(new_width, new_height, Channels(),
-                                      OpenImageIO::TypeDesc::FLOAT);
+    OIIO_NAMESPACE::ImageSpec image_spec(new_width, new_height, Channels(),
+                                      OIIO_NAMESPACE::TypeDesc::FLOAT);
     image_.reset(image_spec);
   } else {
-    OpenImageIO::ROI roi(0, new_width, 0, new_height, 0, 1, 0, Channels());
-    OpenImageIO::ImageBuf dst;
-    CHECK(OpenImageIO::ImageBufAlgo::resize(dst, image_, nullptr, roi))
-      << OpenImageIO::geterror();
+    OIIO_NAMESPACE::ROI roi(0, new_width, 0, new_height, 0, 1, 0, Channels());
+    OIIO_NAMESPACE::ImageBuf dst;
+    CHECK(OIIO_NAMESPACE::ImageBufAlgo::resize(dst, image_, nullptr, roi))
+      << OIIO_NAMESPACE::geterror();
     image_.copy(dst);
   }
 }
diff --git a/src/theia/image/image.h b/src/theia/image/image.h
index e4f22cc..29122d2 100644
--- a/src/theia/image/image.h
+++ b/src/theia/image/image.h
@@ -64,7 +64,7 @@ class FloatImage {
 
   // Copy function. This is a deep copy of the image.
   FloatImage(const FloatImage& image_to_copy);
-  explicit FloatImage(const OpenImageIO::ImageBuf& image);
+  explicit FloatImage(const OIIO_NAMESPACE::ImageBuf& image);
   FloatImage& operator=(const FloatImage& image2);
   ~FloatImage() {}
 
@@ -74,8 +74,8 @@ class FloatImage {
   // wrapper for all algorithms. Getting a reference to the ImageBuf provides
   // efficient access to the image data so that the image processing algorithms
   // or other manipulations may be executed on the pixels.
-  OpenImageIO::ImageBuf& GetOpenImageIOImageBuf();
-  const OpenImageIO::ImageBuf& GetOpenImageIOImageBuf() const;
+  OIIO_NAMESPACE::ImageBuf& GetOpenImageIOImageBuf();
+  const OIIO_NAMESPACE::ImageBuf& GetOpenImageIOImageBuf() const;
 
   // Image information
   int Rows() const;
@@ -171,7 +171,7 @@ class FloatImage {
   void Resize(double scale);
 
  protected:
-  OpenImageIO::ImageBuf image_;
+  OIIO_NAMESPACE::ImageBuf image_;
 };
 }  // namespace theia
 
diff --git a/src/theia/image/image_test.cc b/src/theia/image/image_test.cc
index 894dc30..340488d 100644
--- a/src/theia/image/image_test.cc
+++ b/src/theia/image/image_test.cc
@@ -53,11 +53,11 @@ RandomNumberGenerator rng(51);
 std::string img_filename = THEIA_DATA_DIR + std::string("/") + FLAGS_test_img;
 
 #define ASSERT_IMG_EQ(oiio_img, theia_img, rows, cols)      \
-  oiio_img.read(0, 0, true, OpenImageIO::TypeDesc::FLOAT);  \
+  oiio_img.read(0, 0, true, OIIO_NAMESPACE::TypeDesc::FLOAT);  \
   ASSERT_EQ(oiio_img.oriented_width(), theia_img.Cols());   \
   ASSERT_EQ(oiio_img.oriented_height(), theia_img.Rows());  \
   ASSERT_EQ(oiio_img.nchannels(), theia_img.Channels());    \
-  OpenImageIO::ImageBuf::ConstIterator<float> it(oiio_img); \
+  OIIO_NAMESPACE::ImageBuf::ConstIterator<float> it(oiio_img); \
   for (; !it.done(); ++it) {                                \
     for (int c = 0; c < oiio_img.nchannels(); c++) {        \
       ASSERT_EQ(it[c], theia_img.GetXY(it.x(), it.y(), c)); \
@@ -89,7 +89,7 @@ float Interpolate(const FloatImage& image,
 
 // Test that inputting the old fashioned way is the same as through our class.
 TEST(Image, RGBInput) {
-  OpenImageIO::ImageBuf oiio_img(img_filename.c_str());
+  OIIO_NAMESPACE::ImageBuf oiio_img(img_filename.c_str());
   oiio_img.read();
   FloatImage theia_img(img_filename);
 
@@ -102,7 +102,7 @@ TEST(Image, RGBInput) {
 
 // Test that width and height methods work.
 TEST(Image, RGBColsRows) {
-  OpenImageIO::ImageBuf oiio_img(img_filename.c_str());
+  OIIO_NAMESPACE::ImageBuf oiio_img(img_filename.c_str());
   FloatImage theia_img(img_filename);
 
   int true_height = oiio_img.oriented_height();
@@ -114,10 +114,10 @@ TEST(Image, RGBColsRows) {
 
 // Test that inputting the old fashioned way is the same as through our class.
 TEST(Image, ConvertToGrayscaleImage) {
-  OpenImageIO::ImageBuf oiio_img(img_filename.c_str());
-  OpenImageIO::ImageBuf gray_img;
+  OIIO_NAMESPACE::ImageBuf oiio_img(img_filename.c_str());
+  OIIO_NAMESPACE::ImageBuf gray_img;
   const float luma_weights[3] = {.2126, .7152, .0722};
-  OpenImageIO::ImageBufAlgo::channel_sum(gray_img, oiio_img, luma_weights);
+  OIIO_NAMESPACE::ImageBufAlgo::channel_sum(gray_img, oiio_img, luma_weights);
 
   FloatImage theia_img(img_filename);
   theia_img.ConvertToGrayscaleImage();
@@ -131,10 +131,10 @@ TEST(Image, ConvertToGrayscaleImage) {
 }
 
 TEST(Image, ConvertToRGBImage) {
-  OpenImageIO::ImageBuf oiio_img(img_filename.c_str());
-  OpenImageIO::ImageBuf gray_img;
+  OIIO_NAMESPACE::ImageBuf oiio_img(img_filename.c_str());
+  OIIO_NAMESPACE::ImageBuf gray_img;
   const float luma_weights[3] = {.2126, .7152, .0722};
-  OpenImageIO::ImageBufAlgo::channel_sum(gray_img, oiio_img, luma_weights);
+  OIIO_NAMESPACE::ImageBufAlgo::channel_sum(gray_img, oiio_img, luma_weights);
 
   // This should result in an image with the grayscale image copied in each
   // channel.
@@ -148,7 +148,7 @@ TEST(Image, ConvertToRGBImage) {
 
   // Check that all channels have equal value and that the value is equal to the
   // grayscale image.
-  for (OpenImageIO::ImageBuf::ConstIterator<float> it(gray_img);
+  for (OIIO_NAMESPACE::ImageBuf::ConstIterator<float> it(gray_img);
        !it.done();
        ++it) {
     ASSERT_EQ(it[0], rgb_img.GetXY(it.x(), it.y(), 0));
diff --git a/src/theia/sfm/exif_reader.cc b/src/theia/sfm/exif_reader.cc
index 48c049a..fea884d 100644
--- a/src/theia/sfm/exif_reader.cc
+++ b/src/theia/sfm/exif_reader.cc
@@ -127,8 +127,8 @@ bool ExifReader::ExtractEXIFMetadata(
     CameraIntrinsicsPrior* camera_intrinsics_prior) const {
   CHECK_NOTNULL(camera_intrinsics_prior);
 
-  OpenImageIO::ImageBuf image(image_file);
-  OpenImageIO::ImageSpec image_spec = image.spec();
+  OIIO_NAMESPACE::ImageBuf image(image_file);
+  OIIO_NAMESPACE::ImageSpec image_spec = image.spec();
 
   // Set the image dimensions.
   camera_intrinsics_prior->image_width = image_spec.width;
@@ -154,7 +154,7 @@ bool ExifReader::ExtractEXIFMetadata(
   camera_intrinsics_prior->focal_length.is_set = true;
 
   // Set GPS latitude.
-  const OpenImageIO::ImageIOParameter* latitude =
+  const OIIO_NAMESPACE::ImageIOParameter* latitude =
       image_spec.find_attribute("GPS:Latitude");
   if (latitude != nullptr) {
     camera_intrinsics_prior->latitude.is_set = true;
@@ -173,7 +173,7 @@ bool ExifReader::ExtractEXIFMetadata(
   }
 
   // Set GPS longitude.
-  const OpenImageIO::ImageIOParameter* longitude =
+  const OIIO_NAMESPACE::ImageIOParameter* longitude =
       image_spec.find_attribute("GPS:Longitude");
   if (longitude != nullptr) {
     camera_intrinsics_prior->longitude.is_set = true;
@@ -193,7 +193,7 @@ bool ExifReader::ExtractEXIFMetadata(
 
 
   // Set GSP altitude.
-  const OpenImageIO::ImageIOParameter* altitude =
+  const OIIO_NAMESPACE::ImageIOParameter* altitude =
       image_spec.find_attribute("GPS:Altitude");
   if (altitude != nullptr) {
     camera_intrinsics_prior->altitude.is_set = true;
@@ -205,7 +205,7 @@ bool ExifReader::ExtractEXIFMetadata(
 }
 
 bool ExifReader::SetFocalLengthFromExif(
-    const OpenImageIO::ImageSpec& image_spec,
+    const OIIO_NAMESPACE::ImageSpec& image_spec,
     CameraIntrinsicsPrior* camera_intrinsics_prior) const {
   static const float kMinFocalLength = 1e-2;
 
@@ -268,7 +268,7 @@ bool ExifReader::SetFocalLengthFromExif(
 }
 
 bool ExifReader::SetFocalLengthFromSensorDatabase(
-    const OpenImageIO::ImageSpec& image_spec,
+    const OIIO_NAMESPACE::ImageSpec& image_spec,
     CameraIntrinsicsPrior* camera_intrinsics_prior) const {
   const int max_image_dimension = std::max(image_spec.width, image_spec.height);
   const float exif_focal_length =
diff --git a/src/theia/sfm/exif_reader.h b/src/theia/sfm/exif_reader.h
index 3049cf4..d9d3108 100644
--- a/src/theia/sfm/exif_reader.h
+++ b/src/theia/sfm/exif_reader.h
@@ -74,13 +74,13 @@ class ExifReader {
   // Sets the focal length from the focal plane resolution. Returns true if a
   // valid focal length is found and false otherwise.
   bool SetFocalLengthFromExif(
-      const OpenImageIO::ImageSpec& image_spec,
+      const OIIO_NAMESPACE::ImageSpec& image_spec,
       CameraIntrinsicsPrior* camera_intrinsics_prior) const;
 
   // Sets the focal length from a look up in the sensor width database. Returns
   // true if a valid focal length is found and false otherwise.
   bool SetFocalLengthFromSensorDatabase(
-      const OpenImageIO::ImageSpec& image_spec,
+      const OIIO_NAMESPACE::ImageSpec& image_spec,
       CameraIntrinsicsPrior* camera_intrinsics_prior) const;
 
   std::unordered_map<std::string, double> sensor_width_database_;
diff --git a/src/theia/sfm/undistort_image.cc b/src/theia/sfm/undistort_image.cc
index 95a061d..ae0690e 100644
--- a/src/theia/sfm/undistort_image.cc
+++ b/src/theia/sfm/undistort_image.cc
@@ -160,9 +160,9 @@ void RemoveImageLensDistortion(const Camera& distorted_camera,
   // For each pixel in the undistorted image, find the coordinate in the
   // distorted image and set the pixel color accordingly.
   const int num_channels = distorted_image.Channels();
-  OpenImageIO::ImageBuf& undistorted_img =
+  OIIO_NAMESPACE::ImageBuf& undistorted_img =
       undistorted_image->GetOpenImageIOImageBuf();
-  OpenImageIO::ImageBuf::Iterator<float> undistorted_it(undistorted_img);
+  OIIO_NAMESPACE::ImageBuf::Iterator<float> undistorted_it(undistorted_img);
   for (; !undistorted_it.done(); ++undistorted_it) {
     Eigen::Vector2d image_point(undistorted_it.x() + 0.5,
                                 undistorted_it.y() + 0.5);
