validation.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <cstdint>
#include <cstring>
#include <string_view>
 
#include "highmap/array.hpp"
#include "highmap/colormaps.hpp"
#include "highmap/logger.hpp"
#include "highmap/texture.hpp"
 
#include <source_location>
 
namespace hmap
{
 
[[nodiscard]] inline bool validate_shape(
    glm::ivec2                  shape,
    const std::source_location &loc = std::source_location::current())
{
  if (shape.x <= 0 || shape.y <= 0)
  {
    hmap::log::warn(loc,
                    "Invalid array shape ({}, {}): dimensions must be positive",
                    shape.x,
                    shape.y);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_non_empty(
    const Array                &array,
    const std::source_location &loc = std::source_location::current())
{
  if (array.shape.x <= 0 || array.shape.y <= 0 || array.vector.empty())
  {
    hmap::log::warn(
        loc,
        "Array is empty or uninitialized (shape: {}x{}, buffer size: {})",
        array.shape.x,
        array.shape.y,
        array.vector.size());
    return false;
  }
  if (array.vector.size() != static_cast<size_t>(array.shape.x * array.shape.y))
  {
    hmap::log::warn(
        loc,
        "Array buffer size ({}) does not match shape dimensions ({}x{} = {})",
        array.vector.size(),
        array.shape.x,
        array.shape.y,
        array.shape.x * array.shape.y);
    return false;
  }
  return true;
}
 
template <typename T>
  requires requires(const T &t) {
    { t.empty() } -> std::convertible_to<bool>;
  }
[[nodiscard]] inline bool validate_non_empty(
    const T                    &container,
    std::string_view            name = "Container",
    const std::source_location &loc = std::source_location::current())
{
  if (container.empty())
  {
    hmap::log::warn(loc, "{} is empty", name);
    return false;
  }
  return true;
}
 
template <typename T>
  requires requires(const T &t) {
    { t.size() } -> std::convertible_to<size_t>;
  }
[[nodiscard]] inline bool validate_min_size(
    const T                    &container,
    size_t                      min_size,
    std::string_view            name = "Container",
    const std::source_location &loc = std::source_location::current())
{
  if (container.size() < min_size)
  {
    hmap::log::warn(loc,
                    "{} has {} elements, but at least {} are required",
                    name,
                    container.size(),
                    min_size);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_same_shape(
    const Array                &a,
    const Array                &b,
    const std::source_location &loc = std::source_location::current())
{
  if (a.shape != b.shape || a.vector.size() != b.vector.size())
  {
    hmap::log::warn(
        loc,
        "Array shape mismatch: lhs is ({}, {}) [size: {}], rhs is ({}, {}) "
        "[size: {}]",
        a.shape.x,
        a.shape.y,
        a.vector.size(),
        b.shape.x,
        b.shape.y,
        b.vector.size());
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_same_shape(
    glm::ivec2                  shape,
    const Array                &b,
    const std::source_location &loc = std::source_location::current())
{
  if (shape != b.shape ||
      static_cast<size_t>(shape.x * shape.y) != b.vector.size())
  {
    hmap::log::warn(
        loc,
        "Array shape mismatch: expected shape ({}, {}), actual is ({}, {}) "
        "[size: {}]",
        shape.x,
        shape.y,
        b.shape.x,
        b.shape.y,
        b.vector.size());
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_non_empty(
    const Texture              &tex,
    int                         min_channels = 1,
    const std::source_location &loc = std::source_location::current())
{
  if (tex.shape.x <= 0 || tex.shape.y <= 0 || tex.channels.empty())
  {
    hmap::log::warn(
        loc,
        "Texture is empty or uninitialized (shape: {}x{}, channels: {})",
        tex.shape.x,
        tex.shape.y,
        tex.channels.size());
    return false;
  }
  if (static_cast<int>(tex.channels.size()) < min_channels)
  {
    hmap::log::warn(loc,
                    "Texture has {} channels, but at least {} are required",
                    tex.channels.size(),
                    min_channels);
    return false;
  }
  for (size_t k = 0; k < tex.channels.size(); ++k)
  {
    if (!validate_non_empty(tex.channels[k], loc)) return false;
    if (tex.channels[k].shape != tex.shape)
    {
      hmap::log::warn(loc,
                      "Texture channel {} shape mismatch: channel is ({}, {}), "
                      "texture is ({}, {})",
                      k,
                      tex.channels[k].shape.x,
                      tex.channels[k].shape.y,
                      tex.shape.x,
                      tex.shape.y);
      return false;
    }
  }
  return true;
}
 
[[nodiscard]] inline bool validate_channels(
    const Texture              &tex,
    int                         expected_channels,
    const std::source_location &loc = std::source_location::current())
{
  if (static_cast<int>(tex.channels.size()) != expected_channels)
  {
    hmap::log::warn(loc,
                    "Texture has {} channels, but exactly {} are required",
                    tex.channels.size(),
                    expected_channels);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_same_shape(
    const Texture              &a,
    const Texture              &b,
    const std::source_location &loc = std::source_location::current())
{
  if (a.shape != b.shape)
  {
    hmap::log::warn(loc,
                    "Texture shape mismatch: lhs is ({}, {}), rhs is ({}, {})",
                    a.shape.x,
                    a.shape.y,
                    b.shape.x,
                    b.shape.y);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_same_shape(
    const Texture              &tex,
    const Array                &arr,
    const std::source_location &loc = std::source_location::current())
{
  if (tex.shape != arr.shape)
  {
    hmap::log::warn(
        loc,
        "Texture/Array shape mismatch: texture is ({}, {}), array is ({}, {})",
        tex.shape.x,
        tex.shape.y,
        arr.shape.x,
        arr.shape.y);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_slice(
    const Array                &array,
    glm::ivec4                  idx,
    const std::source_location &loc = std::source_location::current())
{
  if (idx.x < 0 || idx.y > array.shape.x || idx.x >= idx.y || idx.z < 0 ||
      idx.w > array.shape.y || idx.z >= idx.w)
  {
    hmap::log::warn(loc,
                    "Invalid slice [{}, {}, {}, {}] for array shape ({}, {})",
                    idx.x,
                    idx.y,
                    idx.z,
                    idx.w,
                    array.shape.x,
                    array.shape.y);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_slice_for_array(
    const Array                &dest,
    glm::ivec4                  idx,
    const Array                &src,
    const std::source_location &loc = std::source_location::current())
{
  if (!validate_slice(dest, idx, loc)) return false;
 
  const int slice_w = idx.y - idx.x;
  const int slice_h = idx.w - idx.z;
  if (src.shape.x != slice_w || src.shape.y != slice_h)
  {
    hmap::log::warn(
        loc,
        "Slice dimensions ({}, {}) do not match source array shape ({}, {})",
        slice_w,
        slice_h,
        src.shape.x,
        src.shape.y);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_not_zero(
    float                       value,
    const std::source_location &loc = std::source_location::current())
{
  if (value == 0.f)
  {
    hmap::log::warn(loc, "Division by zero encountered");
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_parameter_range(
    glm::vec2                   range,
    float                       min_val,
    float                       max_val,
    std::string_view            param_name = "Range",
    const std::source_location &loc = std::source_location::current())
{
  if (range.x < min_val || range.y > max_val || range.x > range.y)
  {
    hmap::log::warn(loc,
                    "{} [{}, {}] is invalid: expected values within [{}, {}] "
                    "with low <= high",
                    param_name,
                    range.x,
                    range.y,
                    min_val,
                    max_val);
    return false;
  }
  return true;
}
 
[[nodiscard]] inline bool validate_finite(
    const Array                &array,
    const std::source_location &loc = std::source_location::current())
{
  if (!validate_non_empty(array, loc)) return false;
 
  for (size_t k = 0; k < array.vector.size(); ++k)
  {
    float    val = array.vector[k];
    uint32_t bits;
    std::memcpy(&bits, &val, sizeof(float));
    if ((bits & 0x7F800000u) == 0x7F800000u)
    {
      hmap::log::warn(loc,
                      "Non-finite value ({}) encountered at linear index {}",
                      val,
                      k);
      return false;
    }
  }
  return true;
}
 
[[nodiscard]] inline bool validate_cmap(
    int                         cmap,
    const std::source_location &loc = std::source_location::current())
{
  if (cmap < static_cast<int>(Cmap::BONE) ||
      cmap > static_cast<int>(Cmap::WHITE_UNIFORM))
  {
    hmap::log::warn(loc, "Invalid colormap ID ({})", cmap);
    return false;
  }
  return true;
}
 
} // namespace hmap