utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_MATH_UTILS_HPP_
#define IV_SRC_MATH_UTILS_HPP_
 
#include "core/utils.hpp"
#include "math/structs.hpp"
 
#include <cmath>
#include <vector>
 
namespace iv::math
{
 
namespace utils
{
 
bool isSameSign(double value1, double value2, double precision);
double valueInterpolation(double valueNormalized, double valueMin, double valueMax);
int64_t mmToDp(int64_t sizeMm);
iv::types::radian degreeToRadian(iv::types::degree degree);
iv::types::degree radianToDegree(iv::types::radian radian);
 
iv::math::geometry::Point2d pointOnCircle(iv::types::radius radius, iv::types::degree angle);
 
template<typename T1, typename T2 = double>
bool isZero(T1 value, T2 tolerance = iv::constants::maths::Precision)
    requires std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2>
{
    return iv::math::utils::isEqual(value, 0, tolerance);
}
 
template<typename T>
inline bool isInRange(T value, T min, T max)
    requires std::is_arithmetic_v<T>
{
    if (min > max)
    {
        throw std::invalid_argument("min must be less than or equal to max");
    }
 
    return min <= value and value <= max;
}
 
double stepsIncrement(iv::types::Range<double> range, uint64_t steps);
double roundToNearestStep(double value, double step, iv::types::Range<double> range);
 
}// namespace utils
 
namespace geometry::utils
{
 
inline iv::math::geometry::Point2d getCentroid(const std::vector<iv::math::geometry::Point2d> &points)
{
    if (points.empty())
    {
        return {0, 0};
    }
 
    iv::types::coord x = 0;
    iv::types::coord y = 0;
 
    for (const auto &point: points)
    {
        x += point.x;
        y += point.y;
    }
 
    x /= points.size();
    y /= points.size();
 
    return {x, y};
}
 
inline iv::types::height getHeight(const std::vector<iv::math::geometry::Point2d> &points)
{
    if (points.empty())
    {
        return 0;
    }
 
    iv::types::coord minY = points.front().y;
    iv::types::coord maxY = points.front().y;
 
    for (const auto &point: points)
    {
        minY = std::min(minY, point.y);
        maxY = std::max(maxY, point.y);
    }
 
    return maxY - minY;
}
 
inline iv::types::width getWidth(const std::vector<iv::math::geometry::Point2d> &points)
{
    if (points.empty())
    {
        return 0;
    }
 
    iv::types::coord minX = points.front().x;
    iv::types::coord maxX = points.front().x;
 
    for (const auto &point: points)
    {
        minX = std::min(minX, point.x);
        maxX = std::max(maxX, point.x);
    }
 
    return maxX - minX;
}
 
inline void alignSecondPoint(const iv::math::geometry::Point2d &firstPoint, iv::math::geometry::Point2d &secondPoint)
{
    iv::types::coord sizeX = std::abs(secondPoint.x - firstPoint.x);
    iv::types::coord sizeY = std::abs(secondPoint.y - firstPoint.y);
 
    if (sizeX > sizeY)
    {
        secondPoint.y = firstPoint.y;
    }
    else
    {
        secondPoint.x = firstPoint.x;
    }
}
 
inline void alignSecondPointWithDiagonal(const iv::math::geometry::Point2d &firstPoint,
                                         iv::math::geometry::Point2d &secondPoint)
{
    iv::types::coord dx = secondPoint.x - firstPoint.x;
    iv::types::coord dy = secondPoint.y - firstPoint.y;
 
    iv::types::coord absDx = std::abs(dx);
    iv::types::coord absDy = std::abs(dy);
 
    iv::types::coord distH = absDy;
    iv::types::coord distV = absDx;
    iv::types::coord distD = std::abs(absDx - absDy);
 
    if (distH <= distV && distH <= distD)
    {
        secondPoint.y = firstPoint.y;
    }
    else if (distV <= distD)
    {
        secondPoint.x = firstPoint.x;
    }
    else
    {
        if (absDx > absDy)
        {
            secondPoint.x = firstPoint.x + (dx > 0 ? absDy : -absDy);
            secondPoint.y = firstPoint.y + (dy > 0 ? absDy : -absDy);
        }
        else
        {
            secondPoint.x = firstPoint.x + (dx > 0 ? absDx : -absDx);
            secondPoint.y = firstPoint.y + (dy > 0 ? absDx : -absDx);
        }
    }
}
 
inline bool isSamePoint2D(const iv::math::geometry::Point2d &firstPoint, const iv::math::geometry::Point2d &secondPoint,
                          iv::types::coord precision)
{
    return iv::math::utils::isEqual(firstPoint.x, secondPoint.x, precision) &&
           iv::math::utils::isEqual(firstPoint.y, secondPoint.y, precision);
}
 
template<typename T>
    requires std::is_same_v<T, iv::math::geometry::Point2d> || std::is_same_v<T, iv::math::geometry::Point3d>
void close(std::vector<T> &v)
{
    if (v.empty() || v.front() == v.back())
    {
        return;
    }
 
    v.push_back(v.front());
}
 
template<typename T>
    requires std::is_same_v<T, iv::math::geometry::Point2d> || std::is_same_v<T, iv::math::geometry::Point3d>
bool isClosed(const std::vector<T> &v)
{
    if (v.empty())
    {
        return false;
    }
 
    return v.front() == v.back();
}
 
template<typename T>
    requires std::is_same_v<T, iv::math::geometry::Point2d>
double calculateArea(const std::vector<T> &v)
{
    double sum {0};
 
    for (uint64_t i = 0; i < v.size() - 1; i++)
    {
        T point1 = v[i];
        T point2 = v[i + 1];
 
        sum += (point2.x - point1.x) * (point2.y + point1.y);
    }
 
    return std::abs(sum / 2.);
}
 
template<typename T>
    requires std::is_same_v<T, iv::math::geometry::Point2d>
float *getArrayFloatC(std::vector<T> points)
{
    auto *array = static_cast<float *>(calloc(points.size() * 2, sizeof(float)));
 
    for (uint64_t itr = 0; itr < points.size(); itr++)
    {
        const uint64_t ind = itr * 2;
 
        array[ind] = static_cast<float>(points.at(itr).x);
        array[ind + 1] = static_cast<float>(points.at(itr).y);
    }
 
    return array;
}
 
template<typename T>
    requires std::is_same_v<T, iv::math::geometry::Point2d> || std::is_same_v<T, iv::math::geometry::Point3d>
float *getArray3dc(const std::vector<T> &v, const double z)
{
    float *array;
    if (not v.empty())
    {
        array = static_cast<float *>(calloc(3 * v.size(), sizeof(float)));
 
        for (uint64_t itr = 0; itr < v.size(); itr++)
        {
            const uint64_t ind = itr * 3;
 
            array[ind] = static_cast<float>(v.at(itr).x);
            array[ind + 1] = static_cast<float>(v.at(itr).y);
            array[ind + 2] = static_cast<float>(z);
        }
    }
    else
    {
        array = nullptr;
    }
 
    return array;
}
 
float *getArrayFloatC3d(std::vector<iv::math::geometry::Point3d> points);
 
//JSA he traido esto aquí porque trabaja con puntos 3d
//TODO: Eliminar esto lo antes posible
float *getArrayRgbac_old(const std::vector<iv::math::geometry::Point3d> &v, float alpha);
 
float *getArrayFloatCAppendingZ(const std::vector<iv::math::geometry::Point2d> &v, float z);
 
double module(Point2d begining, Point2d end);
 
}// namespace geometry::utils
 
}// namespace iv::math
 
#endif//IV_SRC_MATH_UTILS_HPP_