| |
| #include "dynamic_depth/camera.h" |
| |
| #include "android-base/logging.h" |
| #include "dynamic_depth/const.h" |
| |
| using ::dynamic_depth::xmpmeta::xml::Deserializer; |
| using ::dynamic_depth::xmpmeta::xml::Serializer; |
| |
| 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 |