AliceVision
Photogrammetric Computer Vision Framework
ImageInfo.hpp
1 // This file is part of the AliceVision project.
2 // Copyright (c) 2023 AliceVision contributors.
3 // This Source Code Form is subject to the terms of the Mozilla Public License,
4 // v. 2.0. If a copy of the MPL was not distributed with this file,
5 // You can obtain one at https://mozilla.org/MPL/2.0/.
6 
7 #pragma once
8 
9 #include <aliceVision/types.hpp>
10 
11 #include <aliceVision/image/dcp.hpp>
12 #include <aliceVision/lensCorrectionProfile/lcp.hpp>
13 #include <aliceVision/sfmData/ExposureSetting.hpp>
14 #include <aliceVision/sfmData/exif.hpp>
15 #include <aliceVision/sensorDB/Datasheet.hpp>
16 #include <aliceVision/camera/IntrinsicInitMode.hpp>
17 
18 #include <regex>
19 
20 namespace aliceVision {
21 namespace sfmData {
22 
23 class ImageInfo
24 {
25  public:
33  ImageInfo(const std::string& imagePath = "",
34  std::size_t width = 0,
35  std::size_t height = 0,
36  const std::map<std::string, std::string>& metadata = std::map<std::string, std::string>())
37  : _imagePath(imagePath),
38  _width(width),
39  _height(height),
40  _metadata(metadata)
41  {}
42 
43  ImageInfo * clone()
44  {
45  return new ImageInfo(*this);
46  }
47 
48  bool operator==(const ImageInfo& other) const
49  {
50  // image paths can be different
51  return _width == other._width && _height == other._height;
52  }
53 
54  inline bool operator!=(const ImageInfo& other) const { return !(*this == other); }
55 
60  const std::string& getImagePath() const { return _imagePath; }
61 
66  std::size_t getWidth() const { return _width; }
67 
72  std::size_t getHeight() const { return _height; }
73 
78  std::pair<std::size_t, std::size_t> getImgSize() const { return {_width, _height}; }
79 
85  ExposureSetting getCameraExposureSetting() const { return ExposureSetting(getMetadataShutter(), getMetadataFNumber(), getMetadataISO()); }
86 
92  double getEv() const;
93 
97  std::map<std::string, std::string>::const_iterator findMetadataIterator(const std::string& name) const;
98 
104  bool hasMetadata(const std::vector<std::string>& names) const;
105 
111  bool hasGpsMetadata() const;
112 
119  bool hasDigitMetadata(const std::vector<std::string>& names, bool isPositive = true) const;
120 
126  const std::string& getMetadata(const std::vector<std::string>& names) const;
127 
133  double readRealNumber(const std::string& str) const;
134 
140  double getDoubleMetadata(const std::vector<std::string>& names) const;
141 
148  bool getDoubleMetadata(const std::vector<std::string>& names, double& val) const;
149 
155  int getIntMetadata(const std::vector<std::string>& names) const;
156 
161  const std::string& getMetadataMake() const { return getMetadata({"Make", "cameraMake", "camera make"}); }
162 
167  const std::string& getMetadataModel() const
168  {
169  return getMetadata({"Model", "cameraModel", "cameraModelName", "CameraModel", "camera model", "camera_model", "camera model name"});
170  }
171 
176  const std::string& getMetadataBodySerialNumber() const
177  {
178  return getMetadata({"Exif:BodySerialNumber", "cameraSerialNumber", "SerialNumber", "Serial Number"});
179  }
180 
185  const std::string& getMetadataLensModel() const { return getMetadata({"Exif:LensModel", "lensModel", "lens model"}); }
186 
191  int getMetadataLensID() const { return getIntMetadata({"Exif:LensID", "lensID", "lensType"}); }
192 
197  const std::string& getMetadataLensSerialNumber() const
198  {
199  return getMetadata({"Exif:LensSerialNumber", "lensSerialNumber", "lens serial number", "lens_serial_number"});
200  }
201 
206  double getMetadataFocalLength() const;
207 
212  double getMetadataShutter() const { return getDoubleMetadata({"ExposureTime", "Shutter Speed Value"}); }
213 
218  double getMetadataFNumber() const
219  {
220  if (hasDigitMetadata({"FNumber"}))
221  {
222  return getDoubleMetadata({"FNumber"});
223  }
224  if (hasDigitMetadata({"ApertureValue", "Aperture Value"}))
225  {
226  const double aperture = getDoubleMetadata({"ApertureValue", "Aperture Value"});
227  // fnumber = 2^(aperture/2)
228  return std::pow(2.0, aperture / 2.0);
229  }
230  return -1;
231  }
232 
237  double getMetadataISO() const
238  {
239  return getDoubleMetadata({"Exif:PhotographicSensitivity", "PhotographicSensitivity", "Photographic Sensitivity", "ISO"});
240  }
241 
246  EEXIFOrientation getMetadataOrientation() const
247  {
248  const int orientation = getIntMetadata({"Exif:Orientation", "Orientation"});
249  if (orientation < 0)
250  return EEXIFOrientation::UNKNOWN;
251  return static_cast<EEXIFOrientation>(orientation);
252  }
253 
258  Vec3 getGpsPositionFromMetadata() const;
259 
266  void getGpsPositionWGS84FromMetadata(double& lat, double& lon, double& alt) const;
267 
272  Vec3 getGpsPositionWGS84FromMetadata() const;
273 
274  const std::string& getColorProfileFileName() const { return getMetadata({"AliceVision:DCP:colorProfileFileName"}); }
275 
276  const std::string& getRawColorInterpretation() const { return getMetadata({"AliceVision:rawColorInterpretation"}); }
277 
278  const std::vector<int> getCameraMultiplicators() const
279  {
280  const std::string cam_mul = getMetadata({"raw:cam_mul"});
281  std::vector<int> v_mult;
282 
283  size_t last = 0;
284  size_t next = 0;
285  while ((next = cam_mul.find(" ", last)) != std::string::npos)
286  {
287  v_mult.push_back(std::stoi(cam_mul.substr(last, next - last)));
288  last = next + 1;
289  }
290  v_mult.push_back(std::stoi(cam_mul.substr(last)));
291 
292  return v_mult;
293  }
294 
295  const bool getVignettingParams(std::vector<float>& v_vignParam) const
296  {
297  v_vignParam.clear();
298  bool valid = true;
299  double value;
300 
301  valid = valid && getDoubleMetadata({"AliceVision:VignParamFocX"}, value);
302  v_vignParam.push_back(static_cast<float>(value));
303  valid = valid && getDoubleMetadata({"AliceVision:VignParamFocY"}, value);
304  v_vignParam.push_back(static_cast<float>(value));
305  valid = valid && getDoubleMetadata({"AliceVision:VignParamCenterX"}, value);
306  v_vignParam.push_back(static_cast<float>(value));
307  valid = valid && getDoubleMetadata({"AliceVision:VignParamCenterY"}, value);
308  v_vignParam.push_back(static_cast<float>(value));
309  valid = valid && getDoubleMetadata({"AliceVision:VignParam1"}, value);
310  v_vignParam.push_back(static_cast<float>(value));
311  valid = valid && getDoubleMetadata({"AliceVision:VignParam2"}, value);
312  v_vignParam.push_back(static_cast<float>(value));
313  valid = valid && getDoubleMetadata({"AliceVision:VignParam3"}, value);
314  v_vignParam.push_back(static_cast<float>(value));
315  return valid;
316  }
317 
318  const bool getChromaticAberrationParams(std::vector<float>& v_caGParam, std::vector<float>& v_caBGParam, std::vector<float>& v_caRGParam) const
319  {
320  v_caGParam.clear();
321  v_caBGParam.clear();
322  v_caRGParam.clear();
323  bool valid = true;
324  double value;
325 
326  valid = valid && getDoubleMetadata({"AliceVision:CAGreenFocX"}, value);
327  v_caGParam.push_back(static_cast<float>(value));
328  valid = valid && getDoubleMetadata({"AliceVision:CAGreenFocY"}, value);
329  v_caGParam.push_back(static_cast<float>(value));
330  valid = valid && getDoubleMetadata({"AliceVision:CAGreenCenterX"}, value);
331  v_caGParam.push_back(static_cast<float>(value));
332  valid = valid && getDoubleMetadata({"AliceVision:CAGreenCenterY"}, value);
333  v_caGParam.push_back(static_cast<float>(value));
334  valid = valid && getDoubleMetadata({"AliceVision:CAGreenParam1"}, value);
335  v_caGParam.push_back(static_cast<float>(value));
336  valid = valid && getDoubleMetadata({"AliceVision:CAGreenParam2"}, value);
337  v_caGParam.push_back(static_cast<float>(value));
338  valid = valid && getDoubleMetadata({"AliceVision:CAGreenParam3"}, value);
339  v_caGParam.push_back(static_cast<float>(value));
340  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenFocX"}, value);
341  v_caBGParam.push_back(static_cast<float>(value));
342  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenFocY"}, value);
343  v_caBGParam.push_back(static_cast<float>(value));
344  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenCenterX"}, value);
345  v_caBGParam.push_back(static_cast<float>(value));
346  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenCenterY"}, value);
347  v_caBGParam.push_back(static_cast<float>(value));
348  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenParam1"}, value);
349  v_caBGParam.push_back(static_cast<float>(value));
350  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenParam2"}, value);
351  v_caBGParam.push_back(static_cast<float>(value));
352  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenParam3"}, value);
353  v_caBGParam.push_back(static_cast<float>(value));
354  valid = valid && getDoubleMetadata({"AliceVision:CABlueGreenScaleFactor"}, value);
355  v_caBGParam.push_back(static_cast<float>(value));
356  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenFocX"}, value);
357  v_caRGParam.push_back(static_cast<float>(value));
358  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenFocY"}, value);
359  v_caRGParam.push_back(static_cast<float>(value));
360  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenCenterX"}, value);
361  v_caRGParam.push_back(static_cast<float>(value));
362  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenCenterY"}, value);
363  v_caRGParam.push_back(static_cast<float>(value));
364  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenParam1"}, value);
365  v_caRGParam.push_back(static_cast<float>(value));
366  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenParam2"}, value);
367  v_caRGParam.push_back(static_cast<float>(value));
368  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenParam3"}, value);
369  v_caRGParam.push_back(static_cast<float>(value));
370  valid = valid && getDoubleMetadata({"AliceVision:CARedGreenScaleFactor"}, value);
371  v_caRGParam.push_back(static_cast<float>(value));
372 
373  return valid;
374  }
375 
376  const bool hasMetadataDateTimeOriginal() const
377  {
378  return hasMetadata({"Exif:DateTimeOriginal", "DateTimeOriginal", "DateTime", "Date Time", "Create Date", "ctime"});
379  }
380 
381  const std::string& getMetadataDateTimeOriginal() const
382  {
383  return getMetadata({"Exif:DateTimeOriginal", "DateTimeOriginal", "DateTime", "Date Time", "Create Date", "ctime"});
384  }
385 
386  int64_t getMetadataDateTimestamp() const
387  {
388  std::smatch sm;
389  std::string dtstring = getMetadataDateTimeOriginal();
390  std::regex regex("([\\d]+):([\\d]+):([\\d]+) ([\\d]+):([\\d]+):([\\d]+)");
391 
392  if (!std::regex_match(dtstring, sm, regex))
393  {
394  return -1;
395  }
396 
397  int64_t year = std::stoi(sm[1]);
398  int64_t month = std::stoi(sm[2]);
399  int64_t day = std::stoi(sm[3]);
400  int64_t hour = std::stoi(sm[4]);
401  int64_t minutes = std::stoi(sm[5]);
402  int64_t seconds = std::stoi(sm[6]);
403  int64_t timecode = ((((((((year * 12) + month) * 31) + day) * 24) + hour) * 60 + minutes) * 60) + seconds;
404 
405  return timecode;
406  }
407 
408  double getSensorWidth() const { return getDoubleMetadata({"AliceVision:SensorWidth"}); }
409 
410  double getSensorHeight() const { return getDoubleMetadata({"AliceVision:SensorHeight"}); }
411 
416  const std::map<std::string, std::string>& getMetadata() const { return _metadata; }
417 
422  void setImagePath(const std::string& imagePath) { _imagePath = imagePath; }
423 
428  void setWidth(std::size_t width) { _width = width; }
429 
434  void setHeight(std::size_t height) { _height = height; }
435 
440  void setMetadata(const std::map<std::string, std::string>& metadata) { _metadata = metadata; }
441 
447  void addMetadata(const std::string& key, const std::string& value) { _metadata[key] = value; }
448 
453  void addDCPMetadata(image::DCPProfile& dcpProf)
454  {
455  addMetadata("AliceVision:DCP:colorProfileFileName", dcpProf.info.filename);
456 
457  addMetadata("AliceVision:DCP:Temp1", std::to_string(dcpProf.info.temperature_1));
458  addMetadata("AliceVision:DCP:Temp2", std::to_string(dcpProf.info.temperature_2));
459 
460  const int colorMatrixNumber =
461  (dcpProf.info.has_color_matrix_1 && dcpProf.info.has_color_matrix_2) ? 2 : (dcpProf.info.has_color_matrix_1 ? 1 : 0);
462  addMetadata("AliceVision:DCP:ColorMatrixNumber", std::to_string(colorMatrixNumber));
463 
464  const int forwardMatrixNumber =
465  (dcpProf.info.has_forward_matrix_1 && dcpProf.info.has_forward_matrix_2) ? 2 : (dcpProf.info.has_forward_matrix_1 ? 1 : 0);
466  addMetadata("AliceVision:DCP:ForwardMatrixNumber", std::to_string(forwardMatrixNumber));
467 
468  const int calibMatrixNumber =
469  (dcpProf.info.has_camera_calibration_1 && dcpProf.info.has_camera_calibration_2) ? 2 : (dcpProf.info.has_camera_calibration_1 ? 1 : 0);
470  addMetadata("AliceVision:DCP:CameraCalibrationMatrixNumber", std::to_string(calibMatrixNumber));
471 
472  std::vector<std::string> v_strColorMatrix;
473  dcpProf.getMatricesAsStrings("color", v_strColorMatrix);
474  for (int k = 0; k < v_strColorMatrix.size(); k++)
475  {
476  addMetadata("AliceVision:DCP:ColorMat" + std::to_string(k + 1), v_strColorMatrix[k]);
477  }
478 
479  std::vector<std::string> v_strForwardMatrix;
480  dcpProf.getMatricesAsStrings("forward", v_strForwardMatrix);
481  for (int k = 0; k < v_strForwardMatrix.size(); k++)
482  {
483  addMetadata("AliceVision:DCP:ForwardMat" + std::to_string(k + 1), v_strForwardMatrix[k]);
484  }
485 
486  std::vector<std::string> v_strCalibMatrix;
487  dcpProf.getMatricesAsStrings("calib", v_strCalibMatrix);
488  for (int k = 0; k < v_strCalibMatrix.size(); k++)
489  {
490  addMetadata("AliceVision:DCP:CameraCalibrationMat" + std::to_string(k + 1), v_strCalibMatrix[k]);
491  }
492  }
493 
498  void addVignettingMetadata(LensParam& lensParam)
499  {
500  addMetadata("AliceVision:VignParamFocX", std::to_string(lensParam.vignParams.FocalLengthX));
501  addMetadata("AliceVision:VignParamFocY", std::to_string(lensParam.vignParams.FocalLengthY));
502  addMetadata("AliceVision:VignParamCenterX", std::to_string(lensParam.vignParams.ImageXCenter));
503  addMetadata("AliceVision:VignParamCenterY", std::to_string(lensParam.vignParams.ImageYCenter));
504  addMetadata("AliceVision:VignParam1", std::to_string(lensParam.vignParams.VignetteModelParam1));
505  addMetadata("AliceVision:VignParam2", std::to_string(lensParam.vignParams.VignetteModelParam2));
506  addMetadata("AliceVision:VignParam3", std::to_string(lensParam.vignParams.VignetteModelParam3));
507  }
508 
513  void addChromaticMetadata(LensParam& lensParam)
514  {
515  addMetadata("AliceVision:CAGreenFocX", std::to_string(lensParam.ChromaticGreenParams.FocalLengthX));
516  addMetadata("AliceVision:CAGreenFocY", std::to_string(lensParam.ChromaticGreenParams.FocalLengthY));
517  addMetadata("AliceVision:CAGreenCenterX", std::to_string(lensParam.ChromaticGreenParams.ImageXCenter));
518  addMetadata("AliceVision:CAGreenCenterY", std::to_string(lensParam.ChromaticGreenParams.ImageYCenter));
519  addMetadata("AliceVision:CAGreenParam1", std::to_string(lensParam.ChromaticGreenParams.RadialDistortParam1));
520  addMetadata("AliceVision:CAGreenParam2", std::to_string(lensParam.ChromaticGreenParams.RadialDistortParam2));
521  addMetadata("AliceVision:CAGreenParam3", std::to_string(lensParam.ChromaticGreenParams.RadialDistortParam3));
522  addMetadata("AliceVision:CABlueGreenFocX", std::to_string(lensParam.ChromaticBlueGreenParams.FocalLengthX));
523  addMetadata("AliceVision:CABlueGreenFocY", std::to_string(lensParam.ChromaticBlueGreenParams.FocalLengthY));
524  addMetadata("AliceVision:CABlueGreenCenterX", std::to_string(lensParam.ChromaticBlueGreenParams.ImageXCenter));
525  addMetadata("AliceVision:CABlueGreenCenterY", std::to_string(lensParam.ChromaticBlueGreenParams.ImageYCenter));
526  addMetadata("AliceVision:CABlueGreenParam1", std::to_string(lensParam.ChromaticBlueGreenParams.RadialDistortParam1));
527  addMetadata("AliceVision:CABlueGreenParam2", std::to_string(lensParam.ChromaticBlueGreenParams.RadialDistortParam2));
528  addMetadata("AliceVision:CABlueGreenParam3", std::to_string(lensParam.ChromaticBlueGreenParams.RadialDistortParam3));
529  addMetadata("AliceVision:CABlueGreenScaleFactor", std::to_string(lensParam.ChromaticBlueGreenParams.ScaleFactor));
530  addMetadata("AliceVision:CARedGreenFocX", std::to_string(lensParam.ChromaticRedGreenParams.FocalLengthX));
531  addMetadata("AliceVision:CARedGreenFocY", std::to_string(lensParam.ChromaticRedGreenParams.FocalLengthY));
532  addMetadata("AliceVision:CARedGreenCenterX", std::to_string(lensParam.ChromaticRedGreenParams.ImageXCenter));
533  addMetadata("AliceVision:CARedGreenCenterY", std::to_string(lensParam.ChromaticRedGreenParams.ImageYCenter));
534  addMetadata("AliceVision:CARedGreenParam1", std::to_string(lensParam.ChromaticRedGreenParams.RadialDistortParam1));
535  addMetadata("AliceVision:CARedGreenParam2", std::to_string(lensParam.ChromaticRedGreenParams.RadialDistortParam2));
536  addMetadata("AliceVision:CARedGreenParam3", std::to_string(lensParam.ChromaticRedGreenParams.RadialDistortParam3));
537  addMetadata("AliceVision:CARedGreenScaleFactor", std::to_string(lensParam.ChromaticRedGreenParams.ScaleFactor));
538  }
539 
550  int getSensorSize(const std::vector<sensorDB::Datasheet>& sensorDatabase,
551  double& sensorWidth,
552  double& sensorHeight,
553  double& focalLengthmm,
554  camera::EInitMode& intrinsicInitMode,
555  bool verbose = false);
556 
557  private:
559  std::string _imagePath;
561  std::size_t _width;
563  std::size_t _height;
565  std::map<std::string, std::string> _metadata;
566 };
567 
568 } // namespace sfmData
569 } // namespace aliceVision
LensParam
LensParam contains parameters of distortion, vignetting and chromatic aberration models for a set of ...
Definition: lcp.hpp:198
aliceVision::sfmData::ImageInfo::getMetadataLensID
int getMetadataLensID() const
Get the corresponding "LensID" metadata value.
Definition: ImageInfo.hpp:191
LensParam::ChromaticBlueGreenParams
RectilinearModel ChromaticBlueGreenParams
Chromatic Blue/Green model parameters.
Definition: lcp.hpp:261
aliceVision::sfmData::ImageInfo::getMetadataFocalLength
double getMetadataFocalLength() const
Get the corresponding "FocalLength" metadata value.
Definition: ImageInfo.cpp:399
aliceVision::sfmData::ImageInfo::addMetadata
void addMetadata(const std::string &key, const std::string &value)
Add view metadata.
Definition: ImageInfo.hpp:447
aliceVision::sfmData::ImageInfo::getSensorSize
int getSensorSize(const std::vector< sensorDB::Datasheet > &sensorDatabase, double &sensorWidth, double &sensorHeight, double &focalLengthmm, camera::EInitMode &intrinsicInitMode, bool verbose=false)
Get sensor size by combining info in metadata and in sensor database.
Definition: ImageInfo.cpp:185
aliceVision::sfmData::ImageInfo::getImagePath
const std::string & getImagePath() const
Get view image path.
Definition: ImageInfo.hpp:60
LensParam::ChromaticRedGreenParams
RectilinearModel ChromaticRedGreenParams
Chromatic Red/Green model parameters.
Definition: lcp.hpp:257
aliceVision::sfmData::ImageInfo::setWidth
void setWidth(std::size_t width)
Set the given view image width.
Definition: ImageInfo.hpp:428
aliceVision::sfmData::ImageInfo::getIntMetadata
int getIntMetadata(const std::vector< std::string > &names) const
Get the metadata value as an integer.
Definition: ImageInfo.cpp:132
aliceVision::sfmData::ImageInfo::getMetadataFNumber
double getMetadataFNumber() const
Get the corresponding "FNumber" (relative aperture) metadata value.
Definition: ImageInfo.hpp:218
LensParam::ChromaticGreenParams
RectilinearModel ChromaticGreenParams
Chromatic Green model parameters.
Definition: lcp.hpp:253
aliceVision::sfmData::ImageInfo::addVignettingMetadata
void addVignettingMetadata(LensParam &lensParam)
Add vignetting model parameters in metadata.
Definition: ImageInfo.hpp:498
aliceVision::sfmData::ImageInfo::getImgSize
std::pair< std::size_t, std::size_t > getImgSize() const
Get view image size.
Definition: ImageInfo.hpp:78
aliceVision
Definition: checkerDetector.cpp:32
aliceVision::image::DCPProfile::getMatricesAsStrings
void getMatricesAsStrings(const std::string &type, std::vector< std::string > &v_strMat) const
getMatricesAsStrings gets some matrices contained in the profile in a string format (one string per m...
Definition: dcp.cpp:2223
aliceVision::sfmData::ImageInfo::hasDigitMetadata
bool hasDigitMetadata(const std::vector< std::string > &names, bool isPositive=true) const
Return true if the given metadata name exists and is a digit.
Definition: ImageInfo.cpp:49
aliceVision::sfmData::ImageInfo::findMetadataIterator
std::map< std::string, std::string >::const_iterator findMetadataIterator(const std::string &name) const
Get an iterator on the map of metadata from a given name.
Definition: ImageInfo.cpp:19
aliceVision::sfmData::ImageInfo::hasMetadata
bool hasMetadata(const std::vector< std::string > &names) const
Return true if the given metadata name exists.
Definition: ImageInfo.cpp:44
aliceVision::sfmData::ImageInfo::getMetadataModel
const std::string & getMetadataModel() const
Get the corresponding "Model" metadata value.
Definition: ImageInfo.hpp:167
aliceVision::sfmData::ImageInfo::getCameraExposureSetting
ExposureSetting getCameraExposureSetting() const
Get the Camera Exposure Setting value. For the same scene, this value is linearly proportional to the...
Definition: ImageInfo.hpp:85
aliceVision::sfmData::ImageInfo::getMetadataMake
const std::string & getMetadataMake() const
Get the corresponding "Make" metadata value.
Definition: ImageInfo.hpp:161
aliceVision::sfmData::ImageInfo::addChromaticMetadata
void addChromaticMetadata(LensParam &lensParam)
Add chromatic model parameters in metadata.
Definition: ImageInfo.hpp:513
aliceVision::sfmData::ImageInfo::getEv
double getEv() const
Get the Exposure Value. EV is a number that represents a combination of a camera's shutter speed and ...
Definition: ImageInfo.cpp:17
aliceVision::sfmData::ImageInfo::getMetadataOrientation
EEXIFOrientation getMetadataOrientation() const
Get the corresponding "Orientation" metadata value.
Definition: ImageInfo.hpp:246
aliceVision::sfmData::ImageInfo::setMetadata
void setMetadata(const std::map< std::string, std::string > &metadata)
Set view metadata.
Definition: ImageInfo.hpp:440
aliceVision::sfmData::ImageInfo::getDoubleMetadata
double getDoubleMetadata(const std::vector< std::string > &names) const
Get the metadata value as a double.
Definition: ImageInfo.cpp:115
aliceVision::sfmData::ImageInfo::getMetadataShutter
double getMetadataShutter() const
Get the corresponding "ExposureTime" (shutter) metadata value.
Definition: ImageInfo.hpp:212
aliceVision::sfmData::ImageInfo::addDCPMetadata
void addDCPMetadata(image::DCPProfile &dcpProf)
Add DCP info in metadata.
Definition: ImageInfo.hpp:453
aliceVision::sfmData::ImageInfo::ImageInfo
ImageInfo(const std::string &imagePath="", std::size_t width=0, std::size_t height=0, const std::map< std::string, std::string > &metadata=std::map< std::string, std::string >())
Image Constructor.
Definition: ImageInfo.hpp:33
aliceVision::sfmData::ImageInfo::getMetadata
const std::map< std::string, std::string > & getMetadata() const
Get the view metadata structure.
Definition: ImageInfo.hpp:416
aliceVision::sfmData::ImageInfo::getWidth
std::size_t getWidth() const
Get view image width.
Definition: ImageInfo.hpp:66
aliceVision::sfmData::ImageInfo::hasGpsMetadata
bool hasGpsMetadata() const
Return true if the metadata for longitude and latitude exist. It checks that all the tags from GPSExi...
Definition: ImageInfo.cpp:147
LensParam::vignParams
VignetteModel vignParams
Vignetting model parameters.
Definition: lcp.hpp:275
aliceVision::sfmData::ImageInfo::setImagePath
void setImagePath(const std::string &imagePath)
Set the given view image path.
Definition: ImageInfo.hpp:422
aliceVision::image::DCPProfile
DCPProfile contains a Dng Color Profile as specified by Adobe DNG specification can be found here: ht...
Definition: dcp.hpp:121
aliceVision::sfmData::ImageInfo::readRealNumber
double readRealNumber(const std::string &str) const
Read a floating point value from a string. It support an integer, a floating point value or a fractio...
Definition: ImageInfo.cpp:89
aliceVision::sfmData::ImageInfo::getMetadataISO
double getMetadataISO() const
Get the corresponding "PhotographicSensitivity" (ISO) metadata value.
Definition: ImageInfo.hpp:237
aliceVision::sfmData::ExposureSetting
Definition: ExposureSetting.hpp:15
aliceVision::sfmData::ImageInfo::getMetadataLensSerialNumber
const std::string & getMetadataLensSerialNumber() const
Get the corresponding "LensSerialNumber" metadata value.
Definition: ImageInfo.hpp:197
aliceVision::sfmData::ImageInfo::setHeight
void setHeight(std::size_t height)
Set the given view image height.
Definition: ImageInfo.hpp:434
aliceVision::sfmData::ImageInfo::getHeight
std::size_t getHeight() const
Get view image height.
Definition: ImageInfo.hpp:72
aliceVision::sfmData::ImageInfo::getMetadataLensModel
const std::string & getMetadataLensModel() const
Get the corresponding "LensModel" metadata value.
Definition: ImageInfo.hpp:185
aliceVision::sfmData::ImageInfo::getGpsPositionWGS84FromMetadata
Vec3 getGpsPositionWGS84FromMetadata() const
Get the gps position in the WGS84 reference system as a vector.
Definition: ImageInfo.cpp:175
aliceVision::sfmData::ImageInfo::getMetadataBodySerialNumber
const std::string & getMetadataBodySerialNumber() const
Get the corresponding "BodySerialNumber" metadata value.
Definition: ImageInfo.hpp:176
aliceVision::sfmData::ImageInfo::getGpsPositionFromMetadata
Vec3 getGpsPositionFromMetadata() const
Get the gps position in the absolute cartesian reference system.
Definition: ImageInfo.cpp:153
aliceVision::sfmData::ImageInfo
Definition: ImageInfo.hpp:23
Generated on Fri May 29 2026 13:07:14 for AliceVision by   doxygen 1.8.17