RColor.hxx

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT7_RColor
#define ROOT7_RColor

#include <ROOT/RAttrBase.hxx>

#include <array>


namespace ROOT {
namespace Experimental {

// TODO: see also imagemagick's C++ interface for RColor operations!
// https://www.imagemagick.org/api/magick++-classes.php

/** \class RColor
\ingroup GpadROOT7
\brief The color class
\author Axel Naumann <axel@cern.ch>
\author Sergey Linev <S.Linev@gsi.de>
\date 2017-09-26
\warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback is welcome!
*/

class RColor : public RAttrBase {

   R__ATTR_CLASS(RColor, "color_", AddString("rgb", "").AddString("a", "").AddString("name", "").AddBool("auto", false));

   using RGB_t = std::array<int, 3>;

private:

   static std::string toHex(int v);

   /** Set RGB values as floats, each from 0..1. Real color values will be stored in hex format */
   RColor &SetRGBFloat(float r, float g, float b)
   {
      return SetRGB(int(r*255),int(g*255),int(b*255));
   }

   bool GetRGBFloat(float &r, float &g, float &b) const;

   int GetColorComponent(int indx) const;

public:

   /** Construct color with provided r,g,b values */
   RColor(int r, int g, int b) : RColor() { SetRGB(r, g, b); }

   /** Construct color with provided r,g,b and alpha values */
   RColor(int r, int g, int b, float alpha) : RColor()
   {
      SetRGB(r, g, b);
      SetAlpha(alpha);
   }

   /** Construct color with provided RGB_t value */
   RColor(const RGB_t &rgb) : RColor() { SetRGB(rgb); }

   /** Set r/g/b/ components of color as hex code, default for the color */
   RColor &SetRGB(const RGB_t &rgb) { return SetRGB(rgb[0], rgb[1], rgb[2]); }

   /** Set r/g/b/ components of color as hex code, default for the color */
   RColor &SetRGB(int r, int g, int b) { return SetHex(toHex(r) + toHex(g) + toHex(b)); }

   /** Set color as hex string like 00FF00 */
   RColor &SetHex(const std::string &_hex)
   {
      SetValue("rgb", _hex);
      return *this;
   }

   /** Return color as hex string like 00FF00 */
   std::string GetHex() const { return GetValue<std::string>("rgb"); }

   bool GetRGB(int &r, int &g, int &b) const;

   /** Returns red color component 0..255 */
   int GetRed() const { return GetColorComponent(0); }

   /** Returns green color component 0..255 */
   int GetGreen() const { return GetColorComponent(1); }

   /** Returns blue color component 0..255 */
   int GetBlue() const { return GetColorComponent(2); }

   /** Clear RGB color value (if any) */
   void ClearRGB()
   {
      ClearValue("rgb");
   }

   /** Set color as plain SVG name like "white" or "lightblue". Clears RGB component before */
   RColor &SetName(const std::string &_name)
   {
      ClearRGB();
      SetValue("name", _name);
      return *this;
   }

   /** Returns color as plain SVG name like "white" or "lightblue" */
   std::string GetName() const { return GetValue<std::string>("name"); }

   /** Clear color plain SVG name (if any) */
   void ClearName() { ClearValue("name"); }

   /** Returns color alpha (opacity) as float from 0. to 1. */
   float GetAlpha() const
   {
      auto hex = GetAlphaHex();
      if (hex.empty())
         return 1.;
      return std::strtol(hex.c_str(), nullptr, 16) / 255.;
   }

   /** Returns color alpha (opacity) as hex string like FF. Default is empty */
   std::string GetAlphaHex() const { return GetValue<std::string>("a"); }

   /** Returns true if color alpha (opacity) was specified */
   bool HasAlpha() const { return HasValue("a"); }

   /** Set color alpha (opacity) value - from 0 to 1 */
   RColor &SetAlpha(float _alpha) { return SetAlphaHex(toHex((int)(_alpha * 255))); }

   /** Set color alpha (opacity) value as hex string */
   RColor &SetAlphaHex(const std::string &_alfa)
   {
      SetValue("a", _alfa);
      return *this;
   }

   /** Clear alpha value of the color */
   void ClearAlpha() { ClearValue("a"); }

   /** Returns true if color should get auto value when primitive drawing is performed */
   bool IsAuto() const { return GetValue<bool>("auto"); }

   /** Set automatic mode for RColor, will be assigned before primitive painted on the canvas */
   RColor &SetAuto(bool on = true)
   {
      SetValue("auto", on);
      return *this;
   }

   /** Clear auto flag of the RColor */
   void ClearAuto() { ClearValue("auto"); }

   /** Return the Hue, Light, Saturation (HLS) definition of this RColor */
   bool GetHLS(float &hue, float &light, float &satur) const;

   /** Set the Red Green and Blue (RGB) values from the Hue, Light, Saturation (HLS). */
   RColor &SetHLS(float hue, float light, float satur);

   /** Returns color value as it will be used in SVG drawing
    * It either include hex format #66FF66 or just plain SVG name */
   std::string AsSVG() const
   {
      auto hex = GetHex();
      if (!hex.empty())
         return std::string("#") + hex + GetAlphaHex();


      // check that alpha is not specified
      return GetName();
   }

   void Clear()
   {
      ClearRGB();
      ClearName();
      ClearAlpha();
      ClearAuto();
   }

   static constexpr RGB_t kRed{{255, 0, 0}};
   static constexpr RGB_t kGreen{{0, 255, 0}};
   static constexpr RGB_t kBlue{{0, 0, 255}};
   static constexpr RGB_t kWhite{{255, 255, 255}};
   static constexpr RGB_t kBlack{{0, 0, 0}};
   static constexpr double kTransparent{0.};
   static constexpr double kOpaque{1.};

   friend bool operator==(const RColor &lhs, const RColor &rhs)
   {
      // auto flag is not taken into account when comparing colors
      return (lhs.GetHex() == rhs.GetHex()) && (lhs.GetName() == rhs.GetName()) &&
             (lhs.GetAlphaHex() == rhs.GetAlphaHex()); //  && (lhs.IsAuto() == rhs.IsAuto());
   }
};

} // namespace Experimental
} // namespace ROOT

#endif