How to convert a hex color string to RGBColor?

Question

For example: "#FF8000".

How could I convert it to RGBColor or Hue?

Answer 1

Using IntegerDigits to convert directly to base 256:

hexToRGB = RGBColor @@ (IntegerDigits[
  ToExpression@StringReplace[#, "#" -> "16^^"], 256, 3]/255.) &

hexToRGB["#FF8000"]
(*   RGBColor[1., 0.501961, 0.]  *)

Edit

Shorter version, since somebody mentioned golfing...

hexToRGB = RGBColor @@ (IntegerDigits[# ~StringDrop~ 1 ~FromDigits~ 16, 256, 3]/255.) &

Answer 2

I hate regular expressions... :)

hexColorToRGB[s_] := RGBColor[FromDigits[#, 16]/255 & /@ Flatten[
  StringCases[ToLowerCase@s,
   {RegularExpression[
    "#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})" ] 
      -> {"$1", "$2", "$3"},
        RegularExpression["#([0-9a-f])([0-9a-f])([0-9a-f])"] 
          -> {"$1$1", "$2$2", "$3$3"}}
 ]]]

ColorSetter /@ 
 hexColorToRGB /@ 
    {"#000", "#FF0000", "#0F0", "#0000FF", "#FF0", 
     "#00FFFF", "#F0F", "#C0C0C0", "#FFF"}

Answer 3

Borrowing from amr's answer here

ToExpression["16^^" <> #] & /@ 
   Partition[Characters@StringTrim[#, "#"], 2] & /@ {"FFFFFF", 
  "#FFFFFF", "000000", "#FF5500", "#005500"}

=>{{255, 255, 255}, {255, 255, 255}, {0, 0, 0}, {255, 85, 0}, {0, 85, 0}}

Answer 4

Here is another option:

hexToRGB =
  RGBColor[ FromDigits[#, 16]/255 & /@ StringTake[#, {{2, 3}, {4, 5}, {6, 7}}] ] &;

hexToRGB@"#FF8c00" // ColorSetter

And another:

hexToRGB =
  RGBColor[ FromDigits[#, 16]/255 & /@ StringCases[#, Except["#"] ~~ _] ] &;

---

#RGB form

Responding to cormullion's comment:

hexToRGB[color_String | {colors__String}] :=
  RGBColor[FromDigits[#, 16]/255 & /@ #] & @@@
    StringCases[{color, colors},
      {"#" ~~ r_ ~~ g_ ~~ b_ ~~ EndOfString :> {r ~~ r, g ~~ g, b ~~ b},
       "#" ~~ r : (_ ~~ _) ~~ g : (_ ~~ _) ~~ b : (_ ~~ _) :> {r, g, b}}]

ColorSetter /@ hexToRGB @ 
  {"#000", "#FF0000", "#0F0", "#0000FF", "#FF0", "#00FFFF", "#F0F", "#C0C0C0", "#FFF"}

Operating on the entire list of color strings should be faster than one at a time.

Answer 5

Just to add nothing to the previous answers

toRGB[str_String]:=ToExpression["16^^" <> #] & /@ 
  str~StringDrop~1~StringCases~Repeated[_, {2}] /. 
 List -> RGBColor

Answer 6

You guys are to fast for me ;)

My solution which is similar to's @cormullion:

hexToRGB[hex_String] :=Module[{RGB},
    RGB = StringCases[hex, 
       RegularExpression["^#(\\w{2})(\\w{2})(\\w{2})"] -> {"$1", "$2", 
        "$3"}] // Flatten;
    RGBColor[FromDigits[#, 16]/100 - 1 & /@ RGB]
]

Graphics[{hexToRGB["#A4A4A4"], Disk[]}]

P.S.: Things are not always just #000000 and #FFFFFF. It's mostly a varying of shades of #A4A4A4 :)

EDIT

PieChart of the sector angles proportional to {R, G, B}

hexToPiechart =PieChart3D @@ {ToExpression@#/255. & /@ (StringCases[#, 
    RegularExpression["^#(\\w{2})(\\w{2})(\\w{2})"] -> {"16^^$1", 
          "16^^$2", "16^^$3"}])} &;


hexToPiechart["#A4A4A4"]

Answer 7

 ColorData["WebSafe", "Panel"] (*click to get RGBColor *)

Answer 8

Also

rgb[x_] := RGBColor[FromDigits[#, 2] / 255 & /@ 
            Partition[IntegerDigits[FromDigits[StringDrop[x, 1], 16], 2, 24], 8]]

rgb@"#FF5500"

RGBColor[{255, 85, 0}]

Edit

Golfing a one liner :)

rgb[x_] := RGBColor[FromDigits[#, 16]/255 & /@ StringJoin /@ Partition[Rest@Characters@x, 2]]

Answer 9

Function that converts string to a list of 3 numbers: for R, G and B component:

toRGBSequence[i_] := 
  Composition[FromDigits[#, 16] &, StringJoin] /@ 
   Partition[Characters[StringDrop[i, 1]], 2] /. List -> Sequence;

• First, dropping the # sign.
• Converting to a list, using the Characters function.
• Partitioning in groups of 2.
• Composition of function to first join the two letters and than convert it to a base-10 format.
• Map over a list.
• Converting everything to Sequence to use with RGBColor function.

Usage:

RGBColor[toRGBSequence["#FF5500"]]

PS: This may, or may not be the most accurate and fast solution.