finally fixed the rgb to hsv conversion

added format option of hsv to the hsv class, so that no conversion has to be made, when you just need the value of it's members, but if you need it from an rgb color, you have to convert nevertheless

Author: Totto16

src/helper/color.cpp

@@ -7,17 +7,21 @@
 
 #include <fmt/format.h>
 
-
-#include <iostream>
-
 [[nodiscard]] Color HSVColor::to_rgb_color() const {
     return Color{ *this };
 }
 
 [[nodiscard]] std::string HSVColor::to_string() const {
-    return to_rgb_color().to_string(Color::SerializeMode::HSV);
+    return fmt::format("hsva({:.2f}, {:.5f}, {:.5f}, {:#2x})", h, s, v, a);
+}
+
+
+std::ostream& HSVColor::operator<<(std::ostream& os) const {
+    os << to_string();
+    return os;
 }
 
+
 helper::expected<Color, std::string> Color::from_string(const std::string& value) {
 
     const auto result = detail::get_color_from_string(value);
@@ -35,7 +39,8 @@ namespace {
         if (value < static_cast<T>(0.0)) {
             // see https://math.stackexchange.com/questions/2179579/how-can-i-find-a-mod-with-negative-number
             T result = value;
-            while (result < 0) {
+            //TODO: maybe this is possible faster?
+            while (result < static_cast<T>(0.0)) {
                 result += divisor;
             }
             return result;
@@ -47,34 +52,37 @@ namespace {
 // taken carefully from https://math.stackexchange.com/questions/556341/rgb-to-hsv-color-conversion-algorithm
 // and modified and sped up, by optimizing it manually
 [[nodiscard]] HSVColor Color::to_hsv_color() const {
-    constexpr auto max_d = static_cast<double>(0xFF);
-    const double r_d = static_cast<double>(r) / max_d;
-    const double g_d = static_cast<double>(g) / max_d;
-    const double b_d = static_cast<double>(b) / max_d;
+    using FloatType = double; //for more precision use "long double" here
+    constexpr auto max_d = static_cast<FloatType>(0xFF);
+    const auto r_d = static_cast<FloatType>(r) / max_d;
+    const auto g_d = static_cast<FloatType>(g) / max_d;
+    const auto b_d = static_cast<FloatType>(b) / max_d;
 
-    const double min = std::min({ r_d, g_d, b_d });
-    const double max = std::max({ r_d, g_d, b_d });
-    const double delta = max - min;
+    const auto min = std::min<FloatType>({ r_d, g_d, b_d });
+    const auto max = std::max<FloatType>({ r_d, g_d, b_d });
+    const auto delta = max - min;
 
-    double h_temp = 0.0;
+    FloatType h_temp = 0.0;
     if (min == max) {
         h_temp = 0.0;
-    } else if (r >= max) {        // > is bogus, just keeps compiler happy
-        h_temp = (g - b) / delta; // between yellow & magenta
-    } else if (g >= max) {
-        h_temp = 2.0 + ((b - r) / delta); // between cyan & yellow
+    } else if (r_d >= max) { // > is bogus, just keeps compiler happy
+        h_temp = fmod_always_positive<FloatType>(
+                (g_d - b_d) / delta, static_cast<FloatType>(6.0)
+        ); // between yellow & magenta
+    } else if (g_d >= max) {
+        h_temp = 2.0 + ((b_d - r_d) / delta); // between cyan & yellow
     } else {
-        h_temp = 4.0 + ((r - g) / delta); // between magenta & cyan
+        h_temp = 4.0 + ((r_d - g_d) / delta); // between magenta & cyan
     }
 
     // use custom fmod, that always result in a positive value
-    const double h = fmod_always_positive(h_temp, 6.0) * 60.0; //degrees
+    const FloatType h = h_temp * static_cast<FloatType>(60.0); //degrees
 
-    const double s = max == 0.0 ? 0.0 : delta / max;
+    const FloatType s = max == static_cast<FloatType>(0.0) ? static_cast<FloatType>(0.0) : delta / max;
 
     //v = max
 
-    return HSVColor{ h, s, max, a };
+    return HSVColor{ static_cast<double>(h), static_cast<double>(s), static_cast<double>(max), a };
 }
 
 //Note: this output formats are all deserializable by the from_string method!
@@ -89,7 +97,7 @@ namespace {
         }
         case SerializeMode::HSV: {
             const auto color = to_hsv_color();
-            return fmt::format("hsva({:.2f}, {:.5f}, {:.5f}, {:#2x})", color.h, color.s, color.v, color.a);
+            return color.to_string();
         }
         default:
             utils::unreachable();

src/helper/color.hpp

@@ -52,6 +52,8 @@ struct HSVColor {
     [[nodiscard]] Color to_rgb_color() const;
 
     [[nodiscard]] std::string to_string() const;
+
+    std::ostream& operator<<(std::ostream& os) const;
 };
 
 struct Color {