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 
TraitToString(CameraTrait trait)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 
StringToTrait(const string & trait_name)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 
ParseFields(const Deserializer & deserializer)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.
Camera(std::unique_ptr<CameraParams> params)97 Camera::Camera(std::unique_ptr<CameraParams> params) {
98   params_ = std::move(params);
99 }
100 
101 // Public methods.
GetNamespaces(std::unordered_map<string,string> * ns_name_href_map)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 
FromDataForCamera0(std::unique_ptr<CameraParams> params,std::vector<std::unique_ptr<Item>> * items)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 
FromData(std::unique_ptr<CameraParams> params)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 
FromDeserializer(const Deserializer & parent_deserializer)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 
GetImage() const166 const Image* Camera::GetImage() const { return params_->image.get(); }
167 
GetLightEstimate() const168 const LightEstimate* Camera::GetLightEstimate() const {
169   return params_->light_estimate.get();
170 }
171 
GetPose() const172 const Pose* Camera::GetPose() const { return params_->pose.get(); }
173 
GetDepthMap() const174 const DepthMap* Camera::GetDepthMap() const { return params_->depth_map.get(); }
175 
GetImagingModel() const176 const ImagingModel* Camera::GetImagingModel() const {
177   return params_->imaging_model.get();
178 }
179 
GetPointCloud() const180 const PointCloud* Camera::GetPointCloud() const {
181   return params_->point_cloud.get();
182 }
183 
GetVendorInfo() const184 const VendorInfo* Camera::GetVendorInfo() const {
185   return params_->vendor_info.get();
186 }
187 
GetAppInfo() const188 const AppInfo* Camera::GetAppInfo() const { return params_->app_info.get(); }
189 
GetTrait() const190 CameraTrait Camera::GetTrait() const { return params_->trait; }
191 
Serialize(Serializer * serializer) const192 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