internal/dynamic_depth/light_estimate.cc

#include "dynamic_depth/light_estimate.h"

#include "android-base/logging.h"
#include "dynamic_depth/const.h"
#include "xmpmeta/base64.h"

using ::dynamic_depth::xmpmeta::xml::Deserializer;
using ::dynamic_depth::xmpmeta::xml::Serializer;

namespace dynamic_depth {
namespace {
constexpr int kColorCorrectionSize = 3;

constexpr char kPixelIntensity[] = "PixelIntensity";
constexpr char kColorCorrectionR[] = "ColorCorrectionR";
constexpr char kColorCorrectionG[] = "ColorCorrectionG";
constexpr char kColorCorrectionB[] = "ColorCorrectionB";

constexpr char kNamespaceHref[] =
    "http://ns.google.com/photos/dd/1.0/lightestimate/";

}  // namespace

// Private constructor.
LightEstimate::LightEstimate() {}

// Public methods.
void LightEstimate::GetNamespaces(
    std::unordered_map<string, string>* ns_name_href_map) {
  if (ns_name_href_map == nullptr) {
    LOG(ERROR) << "Namespace list or own namespace is null";
    return;
  }
  ns_name_href_map->emplace(DynamicDepthConst::LightEstimate(), kNamespaceHref);
}

std::unique_ptr<LightEstimate> LightEstimate::FromData(float pixel_intensity) {
  return LightEstimate::FromData(pixel_intensity, {1.0f, 1.0f, 1.0f});
}

std::unique_ptr<LightEstimate> LightEstimate::FromData(
    float pixel_intensity, const std::vector<float>& color_correction) {
  // Priate constructor.
  std::unique_ptr<LightEstimate> light_estimate(
      std::unique_ptr<LightEstimate>(new LightEstimate()));  // NOLINT
  light_estimate->pixel_intensity_ = pixel_intensity;

  if (color_correction.size() >= kColorCorrectionSize) {
    std::copy(color_correction.begin(),
              color_correction.begin() + kColorCorrectionSize,
              light_estimate->color_correction_.begin());
  } else {
    LOG(WARNING) << "Color correction had fewer than three values, "
                 << "reverting to default of 1.0 for all RGB values";
  }

  return light_estimate;
}

float LightEstimate::GetPixelIntensity() const { return pixel_intensity_; }

const std::vector<float>& LightEstimate::GetColorCorrection() const {
  return color_correction_;
}

std::unique_ptr<LightEstimate> LightEstimate::FromDeserializer(
    const Deserializer& parent_deserializer) {
  std::unique_ptr<Deserializer> deserializer =
      parent_deserializer.CreateDeserializer(
          DynamicDepthConst::Namespace(DynamicDepthConst::LightEstimate()),
          DynamicDepthConst::LightEstimate());
  if (deserializer == nullptr) {
    return nullptr;
  }

  std::unique_ptr<LightEstimate> light_estimate(
      std::unique_ptr<LightEstimate>(new LightEstimate()));  // NOLINT
  if (!deserializer->ParseFloat(DynamicDepthConst::LightEstimate(),
                                kPixelIntensity,
                                &light_estimate->pixel_intensity_)) {
    return nullptr;
  }

  float color_correction_r;
  float color_correction_g;
  float color_correction_b;
  if (deserializer->ParseFloat(DynamicDepthConst::LightEstimate(),
                               kColorCorrectionR, &color_correction_r) &&
      deserializer->ParseFloat(DynamicDepthConst::LightEstimate(),
                               kColorCorrectionG, &color_correction_g) &&
      deserializer->ParseFloat(DynamicDepthConst::LightEstimate(),
                               kColorCorrectionB, &color_correction_b)) {
    light_estimate->color_correction_[0] = color_correction_r;
    light_estimate->color_correction_[1] = color_correction_g;
    light_estimate->color_correction_[2] = color_correction_b;
  }

  return light_estimate;
}

bool LightEstimate::Serialize(Serializer* serializer) const {
  if (serializer == nullptr) {
    LOG(ERROR) << "Serializer is null";
    return false;
  }

  if (!serializer->WriteProperty(DynamicDepthConst::LightEstimate(),
                                 kPixelIntensity,
                                 std::to_string(pixel_intensity_))) {
    return false;
  }

  CHECK(color_correction_.size() >= 3)
      << "Color correction not initialized to a size-3 vector";
  return serializer->WriteProperty(DynamicDepthConst::LightEstimate(),
                                   kColorCorrectionR,
                                   std::to_string(color_correction_[0])) &&
         serializer->WriteProperty(DynamicDepthConst::LightEstimate(),
                                   kColorCorrectionG,
                                   std::to_string(color_correction_[1])) &&
         serializer->WriteProperty(DynamicDepthConst::LightEstimate(),
                                   kColorCorrectionB,
                                   std::to_string(color_correction_[2]));
}

}  // namespace dynamic_depth