1 2 #include "dynamic_depth/camera.h" 3 4 #include "android-base/logging.h" 5 #include "dynamic_depth/const.h" 6 7 using ::dynamic_depth::xmpmeta::xml::Deserializer; 8 using ::dynamic_depth::xmpmeta::xml::Serializer; 9 10 namespace dynamic_depth { 11 namespace { 12 13 const char kNamespaceHref[] = "http://ns.google.com/photos/dd/1.0/camera/"; 14 15 constexpr const char* kTrait = "Trait"; 16 constexpr const char* kTraitPhysical = "Physical"; 17 constexpr const char* kTraitPhysicalLower = "physical"; 18 constexpr const char* kTraitLogical = "Logical"; 19 constexpr const char* kTraitLogicalLower = "logical"; 20 21 constexpr const char* kImageJpegMime = "image/jpeg"; 22 23 string TraitToString(CameraTrait trait) { 24 switch (trait) { 25 case PHYSICAL: 26 return kTraitPhysical; 27 case LOGICAL: 28 return kTraitLogical; 29 case NONE: // Fallthrough. 30 default: 31 return ""; 32 } 33 } 34 35 CameraTrait StringToTrait(const string& trait_name) { 36 string trait_lower = trait_name; 37 std::transform(trait_lower.begin(), trait_lower.end(), trait_lower.begin(), 38 ::tolower); 39 if (kTraitPhysicalLower == trait_lower) { 40 return CameraTrait::PHYSICAL; 41 } 42 43 if (kTraitLogicalLower == trait_lower) { 44 return CameraTrait::LOGICAL; 45 } 46 47 return CameraTrait::NONE; 48 } 49 50 std::unique_ptr<Camera> ParseFields(const Deserializer& deserializer) { 51 string trait_str; 52 deserializer.ParseString(DynamicDepthConst::Camera(), kTrait, &trait_str); 53 CameraTrait trait = StringToTrait(trait_str); 54 55 std::unique_ptr<Image> image = Image::FromDeserializer(deserializer); 56 if (image == nullptr) { 57 LOG(ERROR) << "An image must be present in a Camera, but none was found"; 58 return nullptr; 59 } 60 61 std::unique_ptr<LightEstimate> light_estimate = 62 LightEstimate::FromDeserializer(deserializer); 63 64 std::unique_ptr<Pose> pose = 65 Pose::FromDeserializer(deserializer, DynamicDepthConst::Camera()); 66 67 std::unique_ptr<DepthMap> depth_map = 68 DepthMap::FromDeserializer(deserializer); 69 70 std::unique_ptr<ImagingModel> imaging_model = 71 ImagingModel::FromDeserializer(deserializer); 72 73 std::unique_ptr<PointCloud> point_cloud = 74 PointCloud::FromDeserializer(deserializer); 75 76 std::unique_ptr<VendorInfo> vendor_info = 77 VendorInfo::FromDeserializer(deserializer, DynamicDepthConst::Camera()); 78 79 std::unique_ptr<AppInfo> app_info = 80 AppInfo::FromDeserializer(deserializer, DynamicDepthConst::Camera()); 81 82 std::unique_ptr<CameraParams> params(new CameraParams(std::move(image))); 83 params->depth_map = std::move(depth_map); 84 params->light_estimate = std::move(light_estimate); 85 params->pose = std::move(pose); 86 params->imaging_model = std::move(imaging_model); 87 params->point_cloud = std::move(point_cloud); 88 params->vendor_info = std::move(vendor_info); 89 params->app_info = std::move(app_info); 90 params->trait = trait; 91 return Camera::FromData(std::move(params)); 92 } 93 94 } // namespace 95 96 // Private constructor. 97 Camera::Camera(std::unique_ptr<CameraParams> params) { 98 params_ = std::move(params); 99 } 100 101 // Public methods. 102 void Camera::GetNamespaces( 103 std::unordered_map<string, string>* ns_name_href_map) { 104 if (ns_name_href_map == nullptr) { 105 LOG(ERROR) << "Namespace list is null"; 106 return; 107 } 108 ns_name_href_map->emplace(DynamicDepthConst::Camera(), kNamespaceHref); 109 if (params_->image) { 110 params_->image->GetNamespaces(ns_name_href_map); 111 } 112 if (params_->light_estimate) { 113 params_->light_estimate->GetNamespaces(ns_name_href_map); 114 } 115 if (params_->pose) { 116 params_->pose->GetNamespaces(ns_name_href_map); 117 } 118 if (params_->depth_map) { 119 params_->depth_map->GetNamespaces(ns_name_href_map); 120 } 121 if (params_->imaging_model) { 122 params_->imaging_model->GetNamespaces(ns_name_href_map); 123 } 124 if (params_->point_cloud) { 125 params_->point_cloud->GetNamespaces(ns_name_href_map); 126 } 127 if (params_->vendor_info) { 128 params_->vendor_info->GetNamespaces(ns_name_href_map); 129 } 130 if (params_->app_info) { 131 params_->app_info->GetNamespaces(ns_name_href_map); 132 } 133 } 134 135 std::unique_ptr<Camera> Camera::FromDataForCamera0( 136 std::unique_ptr<CameraParams> params, 137 std::vector<std::unique_ptr<Item>>* items) { 138 if (params->image == nullptr) { 139 params->image = Image::FromDataForPrimaryImage(kImageJpegMime, items); 140 } 141 return std::unique_ptr<Camera>(new Camera(std::move(params))); // NOLINT 142 } 143 144 std::unique_ptr<Camera> Camera::FromData(std::unique_ptr<CameraParams> params) { 145 if (params->image == nullptr) { 146 LOG(ERROR) << "Camera must have an image eleemnt"; 147 return nullptr; 148 } 149 150 return std::unique_ptr<Camera>(new Camera(std::move(params))); // NOLINT 151 } 152 153 std::unique_ptr<Camera> Camera::FromDeserializer( 154 const Deserializer& parent_deserializer) { 155 std::unique_ptr<Deserializer> deserializer = 156 parent_deserializer.CreateDeserializer( 157 DynamicDepthConst::Namespace(DynamicDepthConst::Camera()), 158 DynamicDepthConst::Camera()); 159 if (deserializer == nullptr) { 160 return nullptr; 161 } 162 163 return ParseFields(*deserializer); 164 } 165 166 const Image* Camera::GetImage() const { return params_->image.get(); } 167 168 const LightEstimate* Camera::GetLightEstimate() const { 169 return params_->light_estimate.get(); 170 } 171 172 const Pose* Camera::GetPose() const { return params_->pose.get(); } 173 174 const DepthMap* Camera::GetDepthMap() const { return params_->depth_map.get(); } 175 176 const ImagingModel* Camera::GetImagingModel() const { 177 return params_->imaging_model.get(); 178 } 179 180 const PointCloud* Camera::GetPointCloud() const { 181 return params_->point_cloud.get(); 182 } 183 184 const VendorInfo* Camera::GetVendorInfo() const { 185 return params_->vendor_info.get(); 186 } 187 188 const AppInfo* Camera::GetAppInfo() const { return params_->app_info.get(); } 189 190 CameraTrait Camera::GetTrait() const { return params_->trait; } 191 192 bool Camera::Serialize(Serializer* serializer) const { 193 if (serializer == nullptr) { 194 LOG(ERROR) << "Serializer is null"; 195 return false; 196 } 197 198 if (params_->trait != CameraTrait::NONE) { 199 string trait_name = TraitToString(params_->trait); 200 serializer->WriteProperty(DynamicDepthConst::Camera(), kTrait, trait_name); 201 } 202 203 // Error checking has already been done at instantiation time. 204 if (params_->image != nullptr) { 205 std::unique_ptr<Serializer> image_serializer = serializer->CreateSerializer( 206 DynamicDepthConst::Namespace(DynamicDepthConst::Image()), 207 DynamicDepthConst::Image()); 208 if (!params_->image->Serialize(image_serializer.get())) { 209 LOG(WARNING) << "Could not serialize Image"; 210 } 211 } 212 213 if (params_->depth_map != nullptr) { 214 std::unique_ptr<Serializer> depth_map_serializer = 215 serializer->CreateSerializer(DynamicDepthConst::Camera(), 216 DynamicDepthConst::DepthMap()); 217 if (!params_->depth_map->Serialize(depth_map_serializer.get())) { 218 LOG(WARNING) << "Could not serializer Depth Map"; 219 } 220 } 221 222 if (params_->light_estimate != nullptr) { 223 std::unique_ptr<Serializer> light_estimate_serializer = 224 serializer->CreateSerializer( 225 DynamicDepthConst::Namespace(DynamicDepthConst::LightEstimate()), 226 DynamicDepthConst::LightEstimate()); 227 if (!params_->light_estimate->Serialize(light_estimate_serializer.get())) { 228 LOG(WARNING) << "Could not serialize LightEstimate"; 229 } 230 } 231 232 if (params_->pose != nullptr) { 233 std::unique_ptr<Serializer> pose_serializer = serializer->CreateSerializer( 234 DynamicDepthConst::Camera(), DynamicDepthConst::Pose()); 235 if (!params_->pose->Serialize(pose_serializer.get())) { 236 LOG(WARNING) << "Could not serialize Pose"; 237 } 238 } 239 240 if (params_->imaging_model != nullptr) { 241 std::unique_ptr<Serializer> imaging_model_serializer = 242 serializer->CreateSerializer( 243 DynamicDepthConst::Namespace(DynamicDepthConst::ImagingModel()), 244 DynamicDepthConst::ImagingModel()); 245 if (!params_->imaging_model->Serialize(imaging_model_serializer.get())) { 246 LOG(WARNING) << "Could not serialize ImagingModel"; 247 } 248 } 249 250 if (params_->point_cloud != nullptr) { 251 std::unique_ptr<Serializer> point_cloud_serializer = 252 serializer->CreateSerializer(DynamicDepthConst::Camera(), 253 DynamicDepthConst::PointCloud()); 254 if (!params_->point_cloud->Serialize(point_cloud_serializer.get())) { 255 LOG(WARNING) << "Could not serialize PointCloud"; 256 } 257 } 258 259 if (params_->vendor_info != nullptr) { 260 std::unique_ptr<Serializer> vendor_info_serializer = 261 serializer->CreateSerializer(DynamicDepthConst::Camera(), 262 DynamicDepthConst::VendorInfo()); 263 if (!params_->vendor_info->Serialize(vendor_info_serializer.get())) { 264 LOG(WARNING) << "Could not serialize VendorInfo"; 265 } 266 } 267 268 if (params_->app_info != nullptr) { 269 std::unique_ptr<Serializer> app_info_serializer = 270 serializer->CreateSerializer(DynamicDepthConst::Camera(), 271 DynamicDepthConst::AppInfo()); 272 if (!params_->app_info->Serialize(app_info_serializer.get())) { 273 LOG(WARNING) << "Could not serialize AppInfo"; 274 } 275 } 276 277 return true; 278 } 279 280 } // namespace dynamic_depth 281
