feat(color): add Rgb(uint32_t hex) constructor and float, decimal, and hex format specifiers (#298)

Author: finger563

components/color/example/main/color_example.cpp

@@ -31,6 +31,30 @@ extern "C" void app_main(void) {
     fmt::print(espp::color_code(grey_hsv.rgb()), "Grey HSV: {} --> RGB {}\n", grey_hsv,
                grey_hsv.rgb());
 
+    // test RGB from hex integer construction
+    fmt::print("RGB from hex:\n");
+    fmt::print("--------------\n");
+    uint32_t red_hex_int = 0xFF0000;
+    espp::Rgb red_hex(red_hex_int);
+    fmt::print(espp::color_code(red_hex), "Red from hex:   {0:d} == {0:x} ? {1}\n", red_hex,
+               red_hex.hex() == red_hex_int);
+    uint32_t green_hex_int = 0x00FF00;
+    espp::Rgb green_hex(green_hex_int);
+    fmt::print(espp::color_code(green_hex), "Green from hex: {0:d} == {0:x} ? {1}\n", green_hex,
+               green_hex.hex() == green_hex_int);
+    uint32_t blue_hex_int = 0x0000FF;
+    espp::Rgb blue_hex(blue_hex_int);
+    fmt::print(espp::color_code(blue_hex), "Blue from hex:  {0:d} == {0:x} ? {1}\n", blue_hex,
+               blue_hex.hex() == blue_hex_int);
+    uint32_t white_hex_int = 0xFFFFFF;
+    espp::Rgb white_hex(white_hex_int);
+    fmt::print(espp::color_code(white_hex), "White from hex: {0:d} == {0:x} ? {1}\n", white_hex,
+               white_hex.hex() == white_hex_int);
+    uint32_t grey_hex_int = 0x808080;
+    espp::Rgb grey_hex(grey_hex_int);
+    fmt::print(espp::color_code(grey_hex), "Grey from hex:  {0:d} == {0:x} ? {1}\n", grey_hex,
+               grey_hex.hex() == grey_hex_int);
+
     espp::Rgb white(1., 1., 1.);
     espp::Rgb black(0., 0., 0.);
     espp::Rgb red(1., 0., 0.);

components/color/include/color.hpp

@@ -51,6 +51,13 @@ class Rgb {
    */
   explicit Rgb(const Hsv &hsv);
 
+  /**
+   * @brief Construct an Rgb object from the provided hex value.
+   * @param hex Hex value to convert to RGB. The hex value should be in the
+   *        format 0xRRGGBB.
+   */
+  explicit Rgb(const uint32_t &hex);
+
   /**
    * @brief Assign the values of the provided Rgb object to this Rgb object.
    * @param other The Rgb object to copy.
@@ -82,6 +89,12 @@ class Rgb {
    * @return An HSV object containing the HSV representation.
    */
   Hsv hsv() const;
+
+  /**
+   * @brief Get the hex representation of this RGB color.
+   * @return The hex representation of this RGB color.
+   */
+  uint32_t hex() const;
 };
 
 /**
@@ -163,12 +176,35 @@ class Hsv {
 // for allowing easy serialization/printing of the
 // Rgb
 template <> struct fmt::formatter<espp::Rgb> {
-  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) const {
-    return ctx.begin();
+  // Presentation format: 'f' - floating [0,1] (default), 'd' - integer [0,255], 'x' - hex integer.
+  char presentation = 'f';
+
+  template <typename ParseContext> constexpr auto parse(ParseContext &ctx) {
+    // Parse the presentation format and store it in the formatter:
+    auto it = ctx.begin(), end = ctx.end();
+    if (it != end && (*it == 'f' || *it == 'd' || *it == 'x'))
+      presentation = *it++;
+
+    // TODO: Check if reached the end of the range:
+    // if (it != end && *it != '}') throw format_error("invalid format");
+
+    // Return an iterator past the end of the parsed range:
+    return it;
   }
 
   template <typename FormatContext> auto format(espp::Rgb const &rgb, FormatContext &ctx) const {
-    return fmt::format_to(ctx.out(), "({}, {}, {})", rgb.r, rgb.g, rgb.b);
+    switch (presentation) {
+    case 'f':
+      return fmt::format_to(ctx.out(), "({}, {}, {})", rgb.r, rgb.g, rgb.b);
+    case 'd':
+      return fmt::format_to(ctx.out(), "({}, {}, {})", static_cast<int>(rgb.r * 255),
+                            static_cast<int>(rgb.g * 255), static_cast<int>(rgb.b * 255));
+    case 'x':
+      return fmt::format_to(ctx.out(), "{:#08X}", rgb.hex());
+    default:
+      // shouldn't get here!
+      return fmt::format_to(ctx.out(), "({}, {}, {})", rgb.r, rgb.g, rgb.b);
+    }
   }
 };
 

components/color/src/color.cpp

@@ -24,6 +24,12 @@ Rgb::Rgb(const Rgb &rgb)
 Rgb::Rgb(const Hsv &hsv)
     : Rgb(hsv.rgb()) {}
 
+Rgb::Rgb(const uint32_t &hex) {
+  r = ((hex >> 16) & 0xFF) / 255.0f;
+  g = ((hex >> 8) & 0xFF) / 255.0f;
+  b = (hex & 0xFF) / 255.0f;
+}
+
 Rgb &Rgb::operator=(const Hsv &hsv) {
   *this = hsv.rgb();
   return *this;
@@ -83,6 +89,14 @@ Hsv Rgb::hsv() const {
   return HSV;
 }
 
+uint32_t Rgb::hex() const {
+  uint32_t hex = 0;
+  hex |= static_cast<uint32_t>(r * 255) << 16;
+  hex |= static_cast<uint32_t>(g * 255) << 8;
+  hex |= static_cast<uint32_t>(b * 255);
+  return hex;
+}
+
 Hsv::Hsv(const float &_h, const float &_s, const float &_v)
     : h(_h)
     , s(_s)