1 files changed, 282 insertions, 0 deletions
diff --git a/internal/dynamic_depth/camera.cc b/internal/dynamic_depth/camera.cc
new file mode 100644
index 0000000..db068e3
--- /dev/null
+++ b/internal/dynamic_depth/camera.cc
@@ -0,0 +1,282 @@
+
+#include "dynamic_depth/camera.h"
+
+#include "android-base/logging.h"
+#include "dynamic_depth/const.h"
+
+using photos_editing_formats::xml::Deserializer;
+using photos_editing_formats::xml::Serializer;
+
+namespace photos_editing_formats {
+namespace dynamic_depth {
+namespace {
+
+const char kNamespaceHref[] = "http://ns.google.com/photos/dd/1.0/camera/";
+
+constexpr const char* kTrait = "Trait";
+constexpr const char* kTraitPhysical = "Physical";
+constexpr const char* kTraitPhysicalLower = "physical";
+constexpr const char* kTraitLogical = "Logical";
+constexpr const char* kTraitLogicalLower = "logical";
+
+constexpr const char* kImageJpegMime = "image/jpeg";
+
+string TraitToString(CameraTrait trait) {
+  switch (trait) {
+    case PHYSICAL:
+      return kTraitPhysical;
+    case LOGICAL:
+      return kTraitLogical;
+    case NONE:  // Fallthrough.
+    default:
+      return "";
+  }
+}
+
+CameraTrait StringToTrait(const string& trait_name) {
+  string trait_lower = trait_name;
+  std::transform(trait_lower.begin(), trait_lower.end(), trait_lower.begin(),
+                 ::tolower);
+  if (kTraitPhysicalLower == trait_lower) {
+    return CameraTrait::PHYSICAL;
+  }
+
+  if (kTraitLogicalLower == trait_lower) {
+    return CameraTrait::LOGICAL;
+  }
+
+  return CameraTrait::NONE;
+}
+
+std::unique_ptr<Camera> ParseFields(const Deserializer& deserializer) {
+  string trait_str;
+  deserializer.ParseString(DynamicDepthConst::Camera(), kTrait, &trait_str);
+  CameraTrait trait = StringToTrait(trait_str);
+
+  std::unique_ptr<Image> image = Image::FromDeserializer(deserializer);
+  if (image == nullptr) {
+    LOG(ERROR) << "An image must be present in a Camera, but none was found";
+    return nullptr;
+  }
+
+  std::unique_ptr<LightEstimate> light_estimate =
+      LightEstimate::FromDeserializer(deserializer);
+
+  std::unique_ptr<Pose> pose =
+      Pose::FromDeserializer(deserializer, DynamicDepthConst::Camera());
+
+  std::unique_ptr<DepthMap> depth_map =
+      DepthMap::FromDeserializer(deserializer);
+
+  std::unique_ptr<ImagingModel> imaging_model =
+      ImagingModel::FromDeserializer(deserializer);
+
+  std::unique_ptr<PointCloud> point_cloud =
+      PointCloud::FromDeserializer(deserializer);
+
+  std::unique_ptr<VendorInfo> vendor_info =
+      VendorInfo::FromDeserializer(deserializer, DynamicDepthConst::Camera());
+
+  std::unique_ptr<AppInfo> app_info =
+      AppInfo::FromDeserializer(deserializer, DynamicDepthConst::Camera());
+
+  std::unique_ptr<CameraParams> params(new CameraParams(std::move(image)));
+  params->depth_map = std::move(depth_map);
+  params->light_estimate = std::move(light_estimate);
+  params->pose = std::move(pose);
+  params->imaging_model = std::move(imaging_model);
+  params->point_cloud = std::move(point_cloud);
+  params->vendor_info = std::move(vendor_info);
+  params->app_info = std::move(app_info);
+  params->trait = trait;
+  return Camera::FromData(std::move(params));
+}
+
+}  // namespace
+
+// Private constructor.
+Camera::Camera(std::unique_ptr<CameraParams> params) {
+  params_ = std::move(params);
+}
+
+// Public methods.
+void Camera::GetNamespaces(
+    std::unordered_map<string, string>* ns_name_href_map) {
+  if (ns_name_href_map == nullptr) {
+    LOG(ERROR) << "Namespace list is null";
+    return;
+  }
+  ns_name_href_map->emplace(DynamicDepthConst::Camera(), kNamespaceHref);
+  if (params_->image) {
+    params_->image->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->light_estimate) {
+    params_->light_estimate->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->pose) {
+    params_->pose->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->depth_map) {
+    params_->depth_map->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->imaging_model) {
+    params_->imaging_model->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->point_cloud) {
+    params_->point_cloud->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->vendor_info) {
+    params_->vendor_info->GetNamespaces(ns_name_href_map);
+  }
+  if (params_->app_info) {
+    params_->app_info->GetNamespaces(ns_name_href_map);
+  }
+}
+
+std::unique_ptr<Camera> Camera::FromDataForCamera0(
+    std::unique_ptr<CameraParams> params,
+    std::vector<std::unique_ptr<Item>>* items) {
+  if (params->image == nullptr) {
+    params->image = Image::FromDataForPrimaryImage(kImageJpegMime, items);
+  }
+  return std::unique_ptr<Camera>(new Camera(std::move(params)));  // NOLINT
+}
+
+std::unique_ptr<Camera> Camera::FromData(std::unique_ptr<CameraParams> params) {
+  if (params->image == nullptr) {
+    LOG(ERROR) << "Camera must have an image eleemnt";
+    return nullptr;
+  }
+
+  return std::unique_ptr<Camera>(new Camera(std::move(params)));  // NOLINT
+}
+
+std::unique_ptr<Camera> Camera::FromDeserializer(
+    const Deserializer& parent_deserializer) {
+  std::unique_ptr<Deserializer> deserializer =
+      parent_deserializer.CreateDeserializer(
+          DynamicDepthConst::Namespace(DynamicDepthConst::Camera()),
+          DynamicDepthConst::Camera());
+  if (deserializer == nullptr) {
+    return nullptr;
+  }
+
+  return ParseFields(*deserializer);
+}
+
+const Image* Camera::GetImage() const { return params_->image.get(); }
+
+const LightEstimate* Camera::GetLightEstimate() const {
+  return params_->light_estimate.get();
+}
+
+const Pose* Camera::GetPose() const { return params_->pose.get(); }
+
+const DepthMap* Camera::GetDepthMap() const { return params_->depth_map.get(); }
+
+const ImagingModel* Camera::GetImagingModel() const {
+  return params_->imaging_model.get();
+}
+
+const PointCloud* Camera::GetPointCloud() const {
+  return params_->point_cloud.get();
+}
+
+const VendorInfo* Camera::GetVendorInfo() const {
+  return params_->vendor_info.get();
+}
+
+const AppInfo* Camera::GetAppInfo() const { return params_->app_info.get(); }
+
+CameraTrait Camera::GetTrait() const { return params_->trait; }
+
+bool Camera::Serialize(Serializer* serializer) const {
+  if (serializer == nullptr) {
+    LOG(ERROR) << "Serializer is null";
+    return false;
+  }
+
+  if (params_->trait != CameraTrait::NONE) {
+    string trait_name = TraitToString(params_->trait);
+    serializer->WriteProperty(DynamicDepthConst::Camera(), kTrait, trait_name);
+  }
+
+  // Error checking has already been done at instantiation time.
+  if (params_->image != nullptr) {
+    std::unique_ptr<Serializer> image_serializer = serializer->CreateSerializer(
+        DynamicDepthConst::Namespace(DynamicDepthConst::Image()),
+        DynamicDepthConst::Image());
+    if (!params_->image->Serialize(image_serializer.get())) {
+      LOG(WARNING) << "Could not serialize Image";
+    }
+  }
+
+  if (params_->depth_map != nullptr) {
+    std::unique_ptr<Serializer> depth_map_serializer =
+        serializer->CreateSerializer(DynamicDepthConst::Camera(),
+                                     DynamicDepthConst::DepthMap());
+    if (!params_->depth_map->Serialize(depth_map_serializer.get())) {
+      LOG(WARNING) << "Could not serializer Depth Map";
+    }
+  }
+
+  if (params_->light_estimate != nullptr) {
+    std::unique_ptr<Serializer> light_estimate_serializer =
+        serializer->CreateSerializer(
+            DynamicDepthConst::Namespace(DynamicDepthConst::LightEstimate()),
+            DynamicDepthConst::LightEstimate());
+    if (!params_->light_estimate->Serialize(light_estimate_serializer.get())) {
+      LOG(WARNING) << "Could not serialize LightEstimate";
+    }
+  }
+
+  if (params_->pose != nullptr) {
+    std::unique_ptr<Serializer> pose_serializer = serializer->CreateSerializer(
+        DynamicDepthConst::Camera(), DynamicDepthConst::Pose());
+    if (!params_->pose->Serialize(pose_serializer.get())) {
+      LOG(WARNING) << "Could not serialize Pose";
+    }
+  }
+
+  if (params_->imaging_model != nullptr) {
+    std::unique_ptr<Serializer> imaging_model_serializer =
+        serializer->CreateSerializer(
+            DynamicDepthConst::Namespace(DynamicDepthConst::ImagingModel()),
+            DynamicDepthConst::ImagingModel());
+    if (!params_->imaging_model->Serialize(imaging_model_serializer.get())) {
+      LOG(WARNING) << "Could not serialize ImagingModel";
+    }
+  }
+
+  if (params_->point_cloud != nullptr) {
+    std::unique_ptr<Serializer> point_cloud_serializer =
+        serializer->CreateSerializer(DynamicDepthConst::Camera(),
+                                     DynamicDepthConst::PointCloud());
+    if (!params_->point_cloud->Serialize(point_cloud_serializer.get())) {
+      LOG(WARNING) << "Could not serialize PointCloud";
+    }
+  }
+
+  if (params_->vendor_info != nullptr) {
+    std::unique_ptr<Serializer> vendor_info_serializer =
+        serializer->CreateSerializer(DynamicDepthConst::Camera(),
+                                     DynamicDepthConst::VendorInfo());
+    if (!params_->vendor_info->Serialize(vendor_info_serializer.get())) {
+      LOG(WARNING) << "Could not serialize VendorInfo";
+    }
+  }
+
+  if (params_->app_info != nullptr) {
+    std::unique_ptr<Serializer> app_info_serializer =
+        serializer->CreateSerializer(DynamicDepthConst::Camera(),
+                                     DynamicDepthConst::AppInfo());
+    if (!params_->app_info->Serialize(app_info_serializer.get())) {
+      LOG(WARNING) << "Could not serialize AppInfo";
+    }
+  }
+
+  return true;
+}
+
+}  // namespace dynamic_depth
+}  // namespace photos_editing_formats