utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CORE_UTILS_HPP_
#define IV_SRC_CORE_UTILS_HPP_
 
#include "core/defines.hpp"
 
#include <cmath>
#include <fmt/format.h>
#include <iostream>
#include <optional>
 
namespace iv
{
 
namespace color::utils
{
 
template<typename T>
iv::types::color compactRgb(T r, T g, T b, T a)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if constexpr (std::is_floating_point_v<T>)
    {
        if (r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1 || a < 0 || a > 1)
        {
            throw std::invalid_argument("Color components must be in the range [0, 1]");
        }
 
        return static_cast<iv::types::color>((static_cast<uint8_t>(a * 255) << 24) |
                                             (static_cast<uint8_t>(r * 255) << 16) |
                                             (static_cast<uint8_t>(g * 255) << 8) | static_cast<uint8_t>(b * 255));
    }
    else
    {
        if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255)
        {
            throw std::invalid_argument("Color components must be in the range [0, 255]");
        }
 
        return static_cast<iv::types::color>((a << 24) | (r << 16) | (g << 8) | b);
    }
}
 
template<typename T>
iv::types::color compactRgb(T r, T g, T b)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if constexpr (std::is_floating_point_v<T>)
    {
        return compactRgb<double>(r, g, b, 1.f);
    }
    else
    {
        return compactRgb<uint8_t>(r, g, b, 255);
    }
}
 
std::string colorToHex(iv::types::color value, bool hasAlpha = true);
 
std::optional<iv::types::color> hexToColor(std::string_view hex);
 
template<typename T>
void hexToBgr(iv::types::color hexValue, T *b_out, T *g_out, T *r_out, std::optional<T> alpha_out = std::nullopt)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if (b_out == nullptr || g_out == nullptr || r_out == nullptr)
    {
        throw std::invalid_argument("Null pointer provided for color component output.");
    }
 
    if constexpr (std::is_floating_point_v<T>)
    {
        if (alpha_out.has_value())
        {
            *alpha_out = (hexValue >> 24);// Extract alpha component
        }
 
        *b_out = ((hexValue >> 16) & 0xFF) / 255.0;// Extract blue component
        *g_out = ((hexValue >> 8) & 0xFF) / 255.0; // Extract green component
        *r_out = (hexValue & 0xFF) / 255.0;        // Extract red component
    }
    else
    {
        if (alpha_out.has_value())
        {
            *alpha_out = (hexValue >> 24) & 0xFF;// Extract alpha component
        }
 
        *b_out = (hexValue >> 16) & 0xFF;// Extract blue component
        *g_out = (hexValue >> 8) & 0xFF; // Extract green component
        *r_out = hexValue & 0xFF;        // Extract red component
    }
}
 
template<typename T>
void hexToRgb(iv::types::color hexValue, T *r_out, T *g_out, T *b_out,
              std::optional<std::reference_wrapper<T>> alpha_out = std::nullopt)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if (r_out == nullptr || g_out == nullptr || b_out == nullptr)
    {
        throw std::invalid_argument("Null pointer provided for color component output.");
    }
 
    if constexpr (std::is_floating_point_v<T>)
    {
        if (alpha_out.has_value())
        {
            alpha_out->get() =
                    static_cast<T>((hexValue >> 24) & 0xFF) / static_cast<T>(255.0);// Extract alpha component
        }
 
        *r_out = static_cast<T>(((hexValue >> 16) & 0xFF)) / static_cast<T>(255.0);// Extract red component
        *g_out = static_cast<T>(((hexValue >> 8) & 0xFF)) / static_cast<T>(255.0); // Extract green component
        *b_out = static_cast<T>((hexValue & 0xFF)) / static_cast<T>(255.0);        // Extract blue component
    }
    else
    {
        if (alpha_out.has_value())
        {
            alpha_out->get() = static_cast<unsigned char>((hexValue >> 24) & 0xFF);// Extract alpha component
        }
 
        *r_out = (hexValue >> 16) & 0xFF;// Extract red component
        *g_out = (hexValue >> 8) & 0xFF; // Extract green component
        *b_out = hexValue & 0xFF;        // Extract blue component
    }
}
 
template<typename T>
void rgbToHex(T r, T g, T b, T alpha, iv::types::color *hexValue_out)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if (hexValue_out == nullptr)
    {
        throw std::invalid_argument("Null pointer provided for color component output.");
    }
 
    if constexpr (std::is_floating_point_v<T>)
    {
        *hexValue_out = static_cast<iv::types::color>((static_cast<uint8_t>(alpha * static_cast<T>(255.0)) << 24) |
                                                      (static_cast<uint8_t>(r * static_cast<T>(255.0)) << 16) |
                                                      (static_cast<uint8_t>(g * static_cast<T>(255.0)) << 8) |
                                                      static_cast<uint8_t>(b * static_cast<T>(255.0)));
    }
    else
    {
        *hexValue_out = static_cast<iv::types::color>((alpha << 24) | (r << 16) | (g << 8) | b);
    }
}
 
double getAlpha(iv::types::color hexValue);
 
iv::types::color removeAlpha(iv::types::color hexValue);
 
template<typename T>
iv::types::color addAlpha(iv::types::color hexValue, T alpha)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    if constexpr (std::is_floating_point_v<T>)
    {
        return (hexValue & 0x00FFFFFF) | (static_cast<uint32_t>(alpha * 255) << 24);
    }
    else
    {
        return (hexValue & 0x00FFFFFF) | (static_cast<uint32_t>(alpha) << 24);
    }
}
 
template<typename T>
iv::types::color changeAlpha(iv::types::color hexValue, T alpha)
    requires((std::is_floating_point_v<T> && std::numeric_limits<T>::is_iec559 &&
              (std::numeric_limits<T>::radix == 2)) ||
             (std::is_unsigned_v<T> && sizeof(T) == 1))
{
    iv::types::color nonAlphaColor = removeAlpha(hexValue);
    return addAlpha(nonAlphaColor, alpha);
}
 
//TODO: Revisar el uso de estas funciones
 
iv::types::color colorBorder(iv::types::color colorState);
 
uint32_t darkenColorRgb(uint32_t rgb, double factorDarken);
 
iv::types::color darkenColorArgb(iv::types::color argb, double factorDarken);
 
iv::types::color illuminateColorRgb(iv::types::color rgb, double factorIlluminate);
 
bool isDarkColorRgb(uint32_t rgb);
 
bool isIlluminateColorRgb(uint32_t rgb);
 
void getRgb2Char(iv::types::color color, unsigned char *r, unsigned char *g, unsigned char *b);
 
}// namespace color::utils
 
namespace math::utils
{
 
template<typename T1, typename T2, typename T3 = double>
bool isEqual(T1 d1, T2 d2, T3 tolerance = iv::constants::maths::Precision)
    requires std::is_arithmetic_v<T1> && std::is_arithmetic_v<T2> && std::is_arithmetic_v<T3>
{
    return (std::fabs(static_cast<double>(d1) - static_cast<double>(d2)) < static_cast<double>(tolerance));
}
 
template<typename T>
T roundToDecimals(T value, uint8_t decimals)
    requires std::is_floating_point_v<T>
{
    if (decimals == 0)
    {
        return std::round(value);
    }
 
    const T factor = std::pow(10.0, decimals);
    return std::round(value * factor) / factor;
}
 
}// namespace math::utils
 
namespace time::utils
{
 
#define TIME_IT(expr)                                                                                                  \
    do                                                                                                                 \
    {                                                                                                                  \
        auto inicio = std::chrono::high_resolution_clock::now();                                                       \
        expr;                                                                                                          \
        auto fin = std::chrono::high_resolution_clock::now();                                                          \
        std::chrono::duration<double, std::milli> duracion = fin - inicio;                                             \
        std::cout << "[" #expr "] Tiempo de ejecución: " << duracion.count() << " ms" << std::endl;                    \
    } while (0)
 
inline iv::types::timestamp safeAbsoluteDiff(const iv::types::timestamp a, const iv::types::timestamp b)
{
    if (a > b)
    {
        return a - b;
    }
    return b - a;
}
 
std::string formatCalendarTimeFromMilliseconds(iv::types::milliseconds timeInMilliseconds);
 
std::string formatTimeUnitsFromMilliseconds(iv::types::milliseconds timeInMilliseconds, bool isShortForm = false);
 
}// namespace time::utils
 
namespace utils
{
 
uint8_t maxBitsLength(iv::eDataType dataType);
 
}// namespace utils
 
}// namespace iv
 
#endif//IV_SRC_CORE_UTILS_HPP_