# Color scheme used by Colorize?

The Colorize function is often used to display the results produced by MorphologicalComponents:

i = ImageTake[
ExampleData[{"TestImage", "Mandrill"}], {1, -1, 10}, {1, -1, 10}];
b = Binarize[i, .5];
mc = MorphologicalComponents[b];
Colorize[mc]


The colors represent the integer index values of each foreground component, so the magenta area is 2, the black background is 0, 42 is browney-orange, 19 is violet, and - well, my question is, what is this color scheme?

I'm working on images like the following, to try to understand morphological images, but a legend-type approach might be better:

Show[
ArrayPlot[mc,
Epilog -> {
MapIndexed[{Text[Style[#1, 10, Gray],
Reverse[#2 - {.5, .5}]]} &,
Reverse[mc],
Colorize[mc]
]


# Update

Thanks to stefan's amazing detective work, I've got a way to list the colors, although this isn't available until you run Colorize once or set up the colors another way first:

colorizeColors[n_] :=
Part[RGBColor[N@#1/256, N@#2/256, N@#3/256] & @@
ImageColorOperationsDumphashcolor[#1] & /@ Range[1, 100], n]
Graphics[Table[{colorizeColors[x], Rectangle[{x, 0}, {x + 1, 1}],
White, Text[x, {x + 0.5, -.5}]}, {x, 1, 30}], Background -> Black,
ImageSize -> 800]


• Whohoo!! That looks just amazing!! Wow. Nice job @cormullion :) – Stefan Jun 26 '13 at 6:49
• @stefan it's all your fault :) – cormullion Jun 26 '13 at 6:50
• I found out how to initialize the internal data structures as well...see my update :) That's what I call a good start of a day. – Stefan Jun 26 '13 at 6:51
• @stefan yes you've lifted up a rock and looked at the strange things crawling around underneath! :) – cormullion Jun 26 '13 at 6:55
• @Pickett well, yes, but where's the fun :) – cormullion Jun 26 '13 at 7:04

How does Colorize work

Colorize does use DarkRainbow as a default color scheme.

What Colorize does first is setting up a hashtable with RGB values from DarkRainbow through DataPacletsColorDataDump

The next operation is setting up a list of indices from the original image, iterating through the internal hash-table to fill a list of color triplets and call an internal mapping function, to join it all together.

1) create the indices table

indices = Cases[Tally[Flatten[mc]][[All, 1]], _?Positive]


2) allocate a color list

colors = ConstantArray[0, {Max[0, indices], 3}]


3) fill the colors list with the hashcolor values

((colors[[#]] = Quiet[ImageColorOperationsDumphashcolor[#1]]) &) /@ indices;


4) join it all together to create an image

Image[ImageColorOperationsDumpmapFunc2D1[mc, colors, indices],
Byte, ColorSpace -> "RGB"]


There is one problem with this approach. I didn't find out, how the internal hash-table is generated with the values from DarkRainbow. What that means is, that if my approach should succeed, there must've been an execution of Colorize before.

Agreed, that setting up the internal hash-table is a critical step in the coloring process of Colorize, it does by all means solve your legend problem.

Update: Setting up the internal hash-table

I wrote before that I couldn't find out how the internal hash-table was generated. Well, now I know how:

Caution! This makes heavy use of undocumented functionality and may be deprecated.

The internal data-structures are set up from the first time any function is called with Colorize and/or HighlighImage functionality.

What they do is, they call but do not evaluate them. This seems to be enough in order to initialize the internal data structures, they just construct the object.

SystemDumpAutoLoad[Hold[Colorize],
Hold[Colorize, HighlightImage,
ImageColorOperationsDumpcolorspaceToColor,
ImageColorOperationsDumpcolorToColorspace],
"ImageProcessingColorOpsColorize"
]


So if you evaluate this code block everything else I described works just perfectly.

Update 2: Cleaner Initialisation

Although the above code block works I didn't like it. There must be another way to initialise the internal data-structures for Colorize. Something that does not rely on undocumented functionality which may change in future versions.

It seems to me that a load of Mathematica implementation is loaded from a dump file, the first time it gets used.

Let's check that for Colorize:

ClearAttributes[Colorize, ReadProtected]
Information[Colorize]


This sequence yields the same code that I listed above. Obviously this is the initialisation sequence specific for Colorize (and HighlighImage).

In C++/Java there is something called a Constructor. So my question was is there a way to avoid the above ugly code block and simply initialize the Colorize functionality prior any usage, meaning calling a Constructor.

Actually it is. Evaluate!

What this means is. You can completely replace the above SystemDump sequence with a simple call to Evaluate in order to initialise the internal data-structures:

Evaluate[Colorize]; (*construct the object and initialise internal data-structures*)


Done. As long as WRI continues with their load on demand paradigm this will hold true. Btw. this works on version 8 as well.

• More complicated than I thought! Thanks, will experiment... (+1) – cormullion Jun 25 '13 at 14:12
• Cheers :) I tried to find out the hash-table generation as well, but then my notebook crashed several times. I'm working here from linux. Maybe someone else on another platform, with more ram, has more luck. – Stefan Jun 25 '13 at 14:19
• The Evaluate is not needed, just Colorize; will trigger the autoload. – Simon Woods Jun 27 '13 at 12:28
• @SimonWoods yes indeed, but does it also held the attributes held unevaluated. i wasn't sure about that. that's why i encapsulated it inside an Evaluate – Stefan Jun 27 '13 at 12:31
• Actually ImageColorOperationsDumphashcolor has nothing to do with the "DarkRainbow" color scheme: it's implementation is based on Hash as can be seen from its definition: Compile[{{i, _Integer}}, 30 + IntegerDigits[Hash[i], 200, 3]]` (checked with Mathematica 8.0.4). – Alexey Popkov Jun 13 '17 at 8:48