mirror/vcpkg
1
0
Fork 0
mirror of https://github.com/microsoft/vcpkg.git synced 2024-12-27 16:37:55 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity
f24bd414ce
vcpkg/ports/theia/fix-oiio.patch
Arkady Shapkin 5715b6023b [theia] Fix build (#3141)
2018-04-02 19:32:08 -07:00

392 lines
17 KiB
Diff
Raw Blame History

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);
Reference in New Issue View Git Blame Copy Permalink