aabb.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <span>
#include <type_traits>
 
#include "clustering/always_assert.h"
#ifdef CLUSTERING_USE_AVX2
#include "clustering/math/detail/aabb_gap_avx2.h"
#endif
 
namespace clustering::math {

template <class T>
[[nodiscard]] inline T pointAabbGapSq(const T *point, std::span<const T> boxMin,
                                      std::span<const T> boxMax) noexcept {
  static_assert(std::is_same_v<T, float>,
                "pointAabbGapSq: T must be float; a double specialization is out of scope.");
  CLUSTERING_ALWAYS_ASSERT(boxMin.size() == boxMax.size());
  const std::size_t d = boxMin.size();
#ifdef CLUSTERING_USE_AVX2
  return detail::pointAabbGapSqAvx2F32(point, boxMin.data(), boxMax.data(), d);
#else
  T sum = T{0};
  for (std::size_t j = 0; j < d; ++j) {
    T gap = T{0};
    if (point[j] < boxMin[j]) {
      gap = boxMin[j] - point[j];
    } else if (point[j] > boxMax[j]) {
      gap = point[j] - boxMax[j];
    }
    sum += gap * gap;
  }
  return sum;
#endif
}

template <class T>
[[nodiscard]] inline T aabbAabbGapSq(std::span<const T> minA, std::span<const T> maxA,
                                     std::span<const T> minB, std::span<const T> maxB) noexcept {
  CLUSTERING_ALWAYS_ASSERT(minA.size() == maxA.size() && minB.size() == maxB.size() &&
                           minA.size() == minB.size());
  T sum = T{0};
  for (std::size_t j = 0; j < minA.size(); ++j) {
    T gap = T{0};
    if (minA[j] > maxB[j]) {
      gap = minA[j] - maxB[j];
    } else if (minB[j] > maxA[j]) {
      gap = minB[j] - maxA[j];
    }
    sum += gap * gap;
  }
  return sum;
}

template <class T>
[[nodiscard]] inline T pointAabbFarthestSq(const T *point, std::span<const T> boxMin,
                                           std::span<const T> boxMax) noexcept {
  CLUSTERING_ALWAYS_ASSERT(boxMin.size() == boxMax.size());
  T sum = T{0};
  for (std::size_t j = 0; j < boxMin.size(); ++j) {
    const T lo = point[j] - boxMin[j];
    const T hi = boxMax[j] - point[j];
    const T loMag = lo < T{0} ? -lo : lo;
    const T hiMag = hi < T{0} ? -hi : hi;
    const T farSide = loMag > hiMag ? loMag : hiMag;
    sum += farSide * farSide;
  }
  return sum;
}
 
} // namespace clustering::math