CoordinateConversion.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "Types.h"
#include <algorithm>
#include <cmath>
#include <iomanip>
 
namespace morton_index {
template <typename MortonT> bool morton_contains(const MortonT lower, const MortonT upper, const MortonT value) {
  return lower <= value && value <= upper;
}
 
template <size_t ND, typename IntT, typename MortonT> MortonT calculateDefaultBound(IntT intBound) {
  IntArray<ND, IntT> minCoord;
  minCoord.fill(intBound);
  return Interleaver<ND, IntT, MortonT>::interleave(minCoord);
}
 
template <int ND>
size_t CalculateRequiredCoordinateIntegerWidth(const MDSpaceBounds<ND> &bounds, const MDSpaceSteps<ND> &steps) {
  size_t maxBits(0);
  for (size_t i = 0; i < ND; ++i) {
    /* Calculate the required integer width to accurately represent coordinates
     * on axis i. */
    size_t bits = std::ceil(std::log2((bounds(i, 1) - bounds(i, 0)) / steps(i)));
 
    /* Record highest bit width requirement */
    maxBits = std::max(maxBits, bits);
  }
  return maxBits;
}
 
template <int ND> void ExpandBounds(MDSpaceBounds<ND> &bounds) {
  for (size_t i = 0; i < ND; ++i) {
    bounds(i, 0) = std::nexttoward(bounds(i, 0), std::numeric_limits<float>::lowest());
    bounds(i, 1) = std::nexttoward(bounds(i, 1), std::numeric_limits<float>::max());
  }
}
 
template <int ND> bool CheckCoordinatesInMDSpace(const MDSpaceBounds<ND> &bounds, const MDCoordinate<ND> &coord) {
  for (size_t i = 0; i < coord.rows(); i++) {
    const float coordValue = coord(i, 0);
    const Eigen::Matrix<float, 1, 2> coordBounds = bounds.row(i);
 
    if (coordValue < coordBounds[0] || coordValue > coordBounds[1]) {
      return false;
    }
  }
 
  return true;
}
 
template <int ND, typename IntT>
Eigen::Array<IntT, ND, 1> ConvertCoordinatesToIntegerRange(const MDSpaceBounds<ND> &bounds, const float *crd) {
  MDCoordinate<ND> coord(crd);
  const MDCoordinate<ND> range = bounds.col(1) - bounds.col(0);
  const MDCoordinate<ND> coordFactorOfRange = (coord - bounds.col(0)) / range;
  const MDCoordinate<ND> n = coordFactorOfRange * std::numeric_limits<IntT>::max();
  Eigen::Array<IntT, ND, 1> res = n.template cast<IntT>();
  for (unsigned i = 0; i < ND; ++i)
    if (coord[i] == bounds(i, 1))
      res[i] = std::numeric_limits<IntT>::max();
    else if (coord[i] == bounds(i, 0))
      res[i] = 0;
  return res;
}
 
template <int ND, typename IntT>
MDCoordinate<ND> ConvertCoordinatesFromIntegerRange(const MDSpaceBounds<ND> &bounds,
                                                    const Eigen::Array<IntT, ND, 1> &intCoord) {
  const auto range = bounds.col(1) - bounds.col(0);
  const auto coordFactorOfRange = intCoord.template cast<float>() / (float)std::numeric_limits<IntT>::max();
  return bounds.col(0) + (coordFactorOfRange * range);
}
 
template <typename IntT> IntT ConvertCoordinateToIntegerRange(float value, float lower, float upper) {
  const float coordFactorOfRange = (value - lower) / (upper - lower);
  const float intValue = coordFactorOfRange * std::numeric_limits<IntT>::max();
  return (IntT)intValue;
}
 
template <typename IntT> float ConvertCoordinateFromIntegerRange(IntT value, float lower, float upper) {
  const float coordFactorOfRange = (float)value / (float)std::numeric_limits<IntT>::max();
  return lower + (coordFactorOfRange * (upper - lower));
}
 
template <size_t nd, typename IntT, typename MortonT>
MDCoordinate<nd> indexToCoordinates(const MortonT &idx, const MDSpaceBounds<nd> &space) {
  return morton_index::ConvertCoordinatesFromIntegerRange<nd, IntT>(space,
                                                                    Interleaver<nd, IntT, MortonT>::deinterleave(idx));
}
 
template <size_t nd, typename IntT, typename MortonT, typename coord_t = float>
MortonT coordinatesToIndex(coord_t *coord, const MDSpaceBounds<nd> &space) {
  return Interleaver<nd, IntT, MortonT>::interleave(
      morton_index::ConvertCoordinatesToIntegerRange<nd, IntT>(space, coord));
}
 
} // namespace morton_index