Revision as of 21:53, 31 March 2015 by Wolthera (Talk | contribs) (moving around some headers.)

Jump to: navigation, search

You may have understood that Krita has something called color-management. Or maybe you just wondered what all these 'color model' and 'color profile' things you can find in the menus mean. Color management is pretty useful for people who work in digital imaging proffesionaly, and hopefully this page will explain why.

What is Color Management?

Basic info

If you've never worked with color management before, and have no clue what it is, then know that you've probably been working in the 8bit RGB colour space with the sRGB profile. This means you can choose for sRGB built-in or sRGB-elle-v2-srgbtrc.icc

We'll go into what these terms mean in the theory, but if you're here only for trying to figure out which is the default, you now know it. Maybe, after reading this, you may feel like changing the default.

What is the problem?

To explain the point of colour management, you'd first need to learn which problem colour management tries to solve.

Let us imagine a kinder garden:

The class of 28 children is subdivided in groups of 7. Each group has their own table.

The teacher gives them a painting assignment: They need to paint a red triangle, a blue square, a green circle and put a yellow border around the three. The kids are very experienced with painting already, so the teacher can confidently leave the smarter ones to their own devices, and spent more time on those who need help.

The following results come from painting:

Even though all groups had the same assignment, each group's result looks different.

Krita 2 9 colormanagement group1.png

Group 1 had vermillion red, citron yellow and ultramarine blue to their disposal. This means their triangle looks nice and red, but their circle's green is muddy. This is because ultramarine is too dark of a blue to create nice greens with.

Krita 2 9 colormanagement group2.png

Group 2 had magenta red, citron yellow and cerulean blue. Magenta is a type of red that is closer to pink, opossed to vermillion, which is closer to orange. However, their green looks nice because cerulean is a much lighter blue.

Krita 2.9 colormanagement group3.png

Group 3 had vermillion red, citron yellow, edmerald green and cerulean blue. They didn't mix their green, and thus ended up with a purer colour.

Krita 2.9 colormanagement group4.png

Finally, group 4 has Vermillion red, citron yellow and cerulean blue. Their colours probably look like what you imagined.

Now, these are kindergardeners, so this isn't the largest problem in the world. However, imagine that something like this happened at a printing company? Imagine four printers printing the same magazine with wildly different results? That would be disasterous!

For this purpose, we invented colour management.

What is colour management?

Colour management is a set of systems that tries to have the same colour translate properly between colour devices.

It usually works by attempting to covert a colour to the reference colour space XYZ. XYZ is a coordinate system that has a spot for all colours that the avarage human eye can see.

From XYZ it can then be translated back into another device space, such as RGB(for screens), or CMYK(for printers).

Krita has two systems dedicated to colour management. On one hand we have lcms2, which deal with Icc-profiles, and on the other we have OCIO, which deal with LUT colour management.

To give a crude estimate, ICC profiles deal with keeping colours consistent over many interpretations of devices(screens, printers) by using a reference space, and LUT deals with manipulating the interpretation of said colours.

Icc profiles

An Icc profile is a set of coordinates describing the extremities of the device space within XYZ. You have two types of icc profiles:

Device spaces
These are made with special profiling devices, and are unique per screen. You set these in Krita's colour management tab.
Working spaces
These are delivered alongside Krita. Working spaces are particularly nice to do colour calculations in, which programs like Krita do often. It's therefore recommended to have a working space profile for your image.

Device spaces are those describing your monitor, and have to be made using a little device that is called "colorimeter". This device, in combination with the right software, measures the strongest red, green and blue your screen can produce, as well as the white, black and grey it produces. Using these and several other measurements it creates an icc profile unique to your screen.

You can read more about colorimeter usage here.

The interesting thing about icc profiles is that your working space can be larger than your device space. This is generally not bad. However, when converting, you do end up with the question of how to translate the working space values.

This just squishes the values of the working space into the space it's converted to. It's a nice method to see all possible values in this, but not so good if you want accurate colour reproduction. Use this if you want to see all colours in an image, or want to express all possible contrasts.
Absolute Colorimetric.
The opposite to Perceptual, Absolute colorimetric will attempt to retain all the corect colours at whatever cost, which may result in awful looking colours. Recommended only for reproduction work.
Relative Colorimetric
A in between solution between perceptual and absolute, relative will try to fit whatever colours it can match between colour spaces. It cut's off the rest to their respective borders. This is a very powerful conversion intent, especially when you know the target device is colour managed.
Does anything to retain colourfulness, even hue will be sacrificed. Used in infographics.

LUT docker and hdr imaging

The LUT docker is the second important bit of colour management in krita, it helps you manage the editing and viewing of scene-reffered images such as HDR photos.

To explain what that means, we first need to look at what we consider white or black.

White, on our monitor is full red, full green and full blue. But it's certainly different from white on our paper, or the colour of milk, white from the sun, or even the white of our cell-phone displays.

Black similarly, is brighter on a LCD display than a LED one, and incomparable with the black of a carefully sealed room.

This means that there's potentially blacker blacks than screen black, and white whites than screen white. However, for simplicity's sake we still assign the black-point and the white-point to certain values. From there, we can determine whether a white is whiter than the white point, or a black black than the black-point. But, because we are assigning a number to the possible whites and black, and also the greys inbetween, we can use colour maths to show a different range of greys on the screen so we may examine the contrasts.

You do this with the LUT docker.

The point of this is that you can take advantage of more lightness detail in an image. While you can't see the difference between screen white and whiter-than-screen white(because you screen can't show the difference), graphics programs can use it certainly.

A common example is matching the lighting between a 3d model and a real world scene. Others are advanced photo retouching, with much more contrast information availeble to the user. In painting itself, this allows you to create an image where you can be flippant with the contrast, and allow yourself to go as bright as you'd like.

Like icc, the lutdocker allows you to create a profile of sorts for your device. In this case it's the 'lut', which stands for 'Look Up Table'. The look up table is a table of lightness measurements made with a colorimeter. It gives an indication of how bright your screen gets at a given value.

There's one last technicallity in regards to lightness:

Linear and Gamma corrected colours.

Now, the situation we talked about above is what we would call 'linear'. Each step of brightness is the same value. Our eyes do not perceive linearly. Rather, we find it more easy to distinquish between darker greys than we do between lighter greys. As humans are the ones using computers, we have made it so that computers will give more room to darker values in the coordinate system of the image. We call this 'gamma-correcting'.

Gamma correction, while it shows us pretty pictures, does have an important disadvantage to those painting: colour maths go wonky in gamma-corrected images.

We can see this with the following experiment:

Krita 2 9 colormanagement blending 1.png

Red circle and blue circle over grey, half blurred. In a gamma-corrected environment, this gives an odd black border. In a linear environment, this gives us a nice gradation.

This also counts for Krita's colour smudge brush:

That's right, the 'muddying' of colours as is a common complaint by digital painters everywhere, is in fact, a gamma-corrected colourspace mucking up your colours. If you had been working in LAB to avoid this, be sure to try out a linear rgb colour space.

That's right, the 'muddying' of colours as is a common complaint by digital painters everywhere, is in fact, a gamma-corrected colourspace mucking up your colours. If you had been working in LAB to avoid this, be sure to try out a linear rgb colour space.

So, you might be asking, how do I tick this option? Is it in the settings somewhere? The answer is that we have several icc profiles that can be used for this kind of work:

  • scRGB (linear)
  • All 'elle'-profiles ending in '1.0', such as sRGB-elle-v2-1.0.icc.

In fact, in all the 'elle'-profiles, the last number indicates the gamma. 1.0 is linear, higher is gamma-corrected and 'srgbtrc' is a special gamma correction for the original sRGB profile. Even if you do not paint much, but are for example making textures for a videogame or rendering, using a linear space is very beneficial and will speed up the renderer a little, for it won't have to convert images on it's own.

The downside of linear space is of course that white seems very overpowered when mixing with black, because in a linear space, light greys get more room.

Now that we've talked about icc, lut, working spaces and gamma-correction, there's one final thing we really need to cover:

Bit depth.

Bit depth basically refers to the amount of working memory per pixel you reserve for an image.

Like how having a A2 paper in real life can allow for much more detail in the end drawing, it does take up more of your desk than a simple A4 paper.

However, this does not just refer to the size of the image, but also how much precision you need per colour.

To illustrate this, I'll briefly talk about something that is not even available in Krita:

Indexed Colour.

Only two colours in total, usually black and white.
4bit(16 colors)
16 colors in total, these are famous as many early games were presented in this color palette.
256 colors in total. 8bit images are commonly used in games to save on memory for textures and sprites.

However, like I said, this is not available in Krita. Krita instead works with channels, and counts how many colours per channel you need. This is called 'real colour'.

Real Colour.

4bit per channel(not supported by Krita)
Also known as Hi-color, or 16bit color total. A bit of an old system, and not used outside of specific displays.
8bit per channel
Also known as "True Color", "Millions of colors" or "24bit/32bit". The standard for many screens, and the lowest bit-depth Krita can handle.
16bit per channel.
One step up from 8bit, 16bit per channel allows for colors that can't be displayed by the screen. However, due to this, you are more likely to have smoother gradients. Sometimes known as "Deep Color".
16bit float
Similar to 16bit, but with more precision. Where 16bit only allows coordinates like [1, 4, 3], 16bit float has coordinates like [0.15, 0.70, 0.3759] . Required for HDR images.
32bit float
similar to 16bit float but with even higher precision. The native color depth of OpenColor IO, and thus faster than 16bit float in HDR images, if not heavier.

This is important if you have a working colour space that is larger than your device space: At the least, if you do not want colour banding.

And while you can attempt to create all your images a 32bit float, this will quickly take up your ram. Therefore, it's important to consider which bit depth you will use for what kind of image.

In summary

Krita has two modes of colour management

  • Icc works in terms of hue and saturation, and requires an icc profile.
  • LUT works in terms of brightness, and makes use of luts.
  • both can be made with a colorimeter.

Krita does a lot of colour maths, often concerning the blending of colours. This colour maths works best in linear colour space, and linear colour space requires a bit depth of at the least 16bit to work correctly.

If you like painting, have a decent amount of ram, and are looking to start your baby-steps in taking advantage of Krita's colour management, try upgrading from having all your images in sRGB built-in to sRGB-v2-elle-1.0.icc at 16bit float. This'll give you better colour blending while opening up the possibility for you to start working in hdr!

Some graphics cards, such as those of the Nvidea brand actually have the best performance under 16bit float, because Nvidea cards convert to floating point internally. When it does not need to do that, it speeds up!

No amount of color management in the world can make the image on your screen and the image out of the printer have 100% the same color.


when you finished you image and are ready to export it, you can modify the color space to optimise it:

If you are preparing an image for the web:

  • If you use 16bit color depth or higher, convert the image to 8bit color depth. This will make the image much much more smaller.
  • If it's a grayscale image, convert it to grayscale.
  • If it's a color image, keep it in the working space profile: Many web browsers these days support color profiles embedded into images. Firefox, for example, will try to convert your image to fit the color profile of the other's monitor(if they have one), that way, the image will look near exactly the same on your screen and other profiled monitors.
In some versions of Firefox, the colours actually look strange: This is a bug in Firefox, which is resolved in the newest version.

If you are preparing for print:

  • You hopefully made the picture in a working space profile, if not convert it to something like adobe rgb.
  • Check with the printer what kind of image they expect. Maybe they expect RGB color space, or perhaps they have their own profile.

Content is available under Creative Commons License SA 4.0 unless otherwise noted.