color_difference.h

Go to the documentation of this file.

 
#pragma once
 
#include <qualpal/matrix.h>
#include <qualpal/metrics.h>
#include <qualpal/threads.h>
#include <vector>
 
#ifdef _OPENMP
#include <omp.h>
#endif
 
namespace qualpal {
namespace detail {
 
inline std::size_t
estimateMatrixMemory(std::size_t n)
{
  return n * n * sizeof(double);
}
 
inline bool
checkMatrixSize(std::size_t n, double max_gb = 1.0)
{
  double estimated_gb = estimateMatrixMemory(n) / (1024.0 * 1024.0 * 1024.0);
  return estimated_gb <= max_gb;
}
} // namespace detail
 
template<typename ColorType, typename Metric = metrics::DIN99d>
Matrix<double>
colorDifferenceMatrix(const std::vector<ColorType>& colors,
                      const Metric& metric = Metric{},
                      const double max_memory = 1)
{
  using namespace detail;
 
  const std::size_t n_colors = colors.size();
 
  if (n_colors < 1) {
    throw std::invalid_argument("At least one color is required to compute "
                                "a color difference matrix.");
  }
 
  if (!checkMatrixSize(n_colors, max_memory)) {
    throw std::runtime_error(
      "Color difference matrix would require " +
      std::to_string(estimateMatrixMemory(n_colors) /
                     (1024.0 * 1024.0 * 1024.0)) +
      " GB, which exceeds the limit of " + std::to_string(max_memory) +
      " GB. Reduce the number of colors or increase the memory limit.");
  }
 
  Matrix<double> result(n_colors, n_colors);
 
#ifdef _OPENMP
#pragma omp parallel for num_threads(Threads::get())
#endif
  for (int i = 0; i < static_cast<int>(n_colors); ++i) {
    result(i, i) = 0.0;
#ifdef _OPENMP
#pragma omp simd
#endif
    for (std::size_t j = static_cast<std::size_t>(i) + 1; j < n_colors; ++j) {
      double d = metric(colors[i], colors[j]);
      result(i, j) = d;
      result(j, i) = d;
    }
  }
  return result;
}
 
Matrix<double>
colorDifferenceMatrix(const std::vector<colors::XYZ>& colors,
                      const metrics::MetricType& metric_type,
                      const double max_memory = 1,
                      const std::array<double, 3>& white_point = { 0.95047,
                                                                   1,
                                                                   1.08883 });
 
} // namespace qualpal