diff --git a/general_concepts/colors/bit_depth.rst b/general_concepts/colors/bit_depth.rst index 51b70f0ee..63174d8f5 100644 --- a/general_concepts/colors/bit_depth.rst +++ b/general_concepts/colors/bit_depth.rst @@ -1,68 +1,68 @@ .. meta:: :description: Bit depth in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: Color, Color Bit Depth, Bit Depth, Deep Color, Indexed Color, Real Color, Floating Point Color, Color Channels .. _bit_depth: ========= 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 color. To illustrate this, I'll briefly talk about something that is not even available in Krita: Indexed Color --------------- In older programs, the computer would have per image, a palette that contains a number for each color. The palette size is defined in bits, because the computer can only store data in bit-sizes. .. figure:: /images/color_category/Kiki_lowbit.png :figwidth: 453 :align: center 1bit Only two colors 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. 8bit 256 colors in total. 8bit images are commonly used in games to save on memory for textures and sprites. However, this is not available in Krita. Krita instead works with channels, and counts how many colors per channel you need (described in terms of ''bits per channel''). This is called 'real color'. Real Color ---------- .. figure:: /images/color_category/Rgbcolorcube_3.png :figwidth: 800 :align: center 1, 2, and 3bit per channel don't actually exist in any graphics application out there, however, by imagining them, we can imagine how each bit affects the precision: Usually, each bit subdivides each section in the color cube meaning precision becomes a power of 2 bigger than the previous cube. 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. + 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. +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". This color depth type doesn't have negative values possible, so it is 16bit precision, meaning that you have 65536 values per channel. 16bit float Similar to 16bit, but with more range and less precision. Where 16bit only allows coordinates like [1, 4, 3], 16bit float has coordinates like [0.15, 0.70, 0.3759], with [1.0,1.0,1.0] representing white. Because of the differences between floating point and integer type variables, and because Scene-referred imaging allows for negative values, you have about 10-11bits of precision per channel in 16 bit floating point compared to 16 bit in 16 bit int (this is 2048 values per channel in the 0-1 range). Required for HDR/Scene referred images, and often known as 'half floating point'. 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. Because of the nature of floating point type variables, 32bit float is roughly equal to 23-24 bits of precision per channel (16777216 values per channel in the 0-1 range), but with a much wider range (it can go far above 1), necessary for HDR/Scene-referred values. It is also known as 'single floating point'. This is important if you have a working color space that is larger than your device space: At the least, if you do not want color 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. diff --git a/general_concepts/colors/color_managed_workflow.rst b/general_concepts/colors/color_managed_workflow.rst index 1156837ae..810f1c547 100644 --- a/general_concepts/colors/color_managed_workflow.rst +++ b/general_concepts/colors/color_managed_workflow.rst @@ -1,378 +1,378 @@ .. meta:: :description: How a color managed workflow works. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier - AnetK - Tokiedian :license: GNU free documentation license 1.3 or later. .. index:: Color, Color Management, ICC Profiles, OCIO .. _color_managed_workflow: ====================== Color Managed Workflow ====================== You may have heard 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 professionally, and hopefully this page will explain why. 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 color space with the sRGB profile. This means you can choose for *sRGB built-in* or *sRGB-elle-v2-srgbtrc.icc*. With the new color space browser this profile is marked with *(default)* when using 8bit. 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, to get new and interesting results from filters, blending modes, or just the color smudge brush. What is the problem? -------------------- To explain the point of color management, you'd first need to learn which problem color management tries to solve. Let us imagine a kinder garden: The class of 28 children is subdivided in groups of 7. Each group has its 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. .. figure:: /images/color_category/Krita_2_9_colormanagement_group1.png :figwidth: 500 :align: center 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. .. figure:: /images/color_category/Krita_2_9_colormanagement_group2.png :figwidth: 500 :align: center Group 2 had magenta red, citron yellow and cerulean blue. Magenta is a type of red that is closer to pink, opposed to vermillion, which is closer to orange. However, their green looks nice because cerulean is a much lighter blue. .. figure:: /images/color_category/Krita_2_9_colormanagement_group3.png :figwidth: 500 :align: center Group 3 had vermillion red, citron yellow, emerald green and cerulean blue. They didn't mix their green, and thus ended up with a purer color. .. figure:: /images/color_category/Krita_2_9_colormanagement_group4.png :figwidth: 500 :align: center Finally, group 4 has vermillion red, citron yellow and cerulean blue. Their colors probably look like what you imagined. Now, these are kindergarteners, 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 disastrous! For this purpose, we invented color management. What is color management? ------------------------- Color management is, dryly put, a set of systems that tries to have the same color translate properly between color devices. It usually works by attempting to covert a color to the reference color space XYZ. XYZ is a coordinate system that has a spot for all colors that the average 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 color management. On the one hand, we have **lcms2**, which deal with ICC profiles, and on the other, we have **OCIO**, which deal with LUT color management. To give a crude estimate, ICC profiles deal with keeping colors consistent over many interpretations of devices (screens, printers) by using a reference space, and OCIO deals with manipulating the interpretation of said colors. Within both we can identify the following color spaces: Device spaces 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 gray it produces. Using these and several other measurements it creates an ICC profile unique to your screen. You set these in Krita's color management tab. By default we assume sRGB for screens, but it's very likely that your screen isn't exactly fitting sRGB, especially if you have a high quality screen, where it may be a bigger space instead. Device spaces are also why you should first consult with your printer what profile they expect. Many printing houses have their own device profiles for their printers, or may prefer doing color conversion themselves. You can read more about colorimeter usage :ref:`here `. Working spaces These are delivered alongside Krita for ICC, and downloadable from the OCIO website for OCIO. Working spaces are particularly nice to do color calculations in, which programs like Krita do often. It's therefore recommended to have a working space profile for your image. Aesthetic or Look spaces These are special spaces that have been deformed to give a certain look to an image. Krita doesn't deliver Look profiles for ICC, nor does it yet support Look spaces for OCIO. Color managed workflow ---------------------- Knowing this about these spaces of course doesn't give you an idea of how to use them, but it does make it easier to explain how to use them. So let us look at a typical color management workflow: .. figure:: /images/color_category/Krita-colormanaged-workflow_text.svg :figwidth: 800 :align: center A typical example of a color managed workflow. We have input from scanners and cameras, which we convert to a working space that can be used between different editing software, and is converted to an output space for viewing on screen or printing. In a traditional color managed workflow, we usually think in terms of real world colors being converted to computer colors and the other way around. So, for example photos from a camera or scanned in images. If you have a device space of such a device, we first assign said device space to the image, and then convert it to a working space. -We then do all our editing in the working space, and use the working space to communicate between editing programs. In Krita's case, due to it having two color management systems, we use ICC profiles between programs like GIMP 2.9+, Inkscape, digiKam and Scribus, and OCIO configuration between Blender and Natron. +We then do all our editing in the working space, and use the working space to communicate between editing programs. In Krita's case, due to it having two color management systems, we use ICC profiles between programs like Gimp 2.9+, Inkscape, digiKam and Scribus, and OCIO configuration between Blender and Natron. You also store your working files in the working space, just like how you have the layers unmerged in the working file, or have it at a very high resolution. Sometimes, we apply aesthetic or 'look' spaces to an image as part of the editing process. This is rather advanced, and probably not something to worry about in Krita's case. Then, when we're done editing, we try to convert to an output space, which is another device space. This can be CMYK for printers or a special screen RGB profile. When you are dealing with professional printing houses, it is best to ask them about this step. They have a lot of experience with doing the best conversion, and may prefer to do the conversion from your working space to the device space of their printers. Another form of output is the way your screen displays the color. Unlike regular output, this one is done all the time during editing: After all, you need to be able to see what you are doing, but your screen is still a device with a device space, so it does distort how the image looks. In this manner, you can see your screen as a set of binoculars you have to look through to see your image at all. Therefore, without a profiled monitor, you actually don't know what the actual colors you are working with are like, because the computer doesn't know the relevant properties of your screen. So if you profiled your monitor, give Krita the profile in the settings, and select the sRGB space to draw in, you are for the first time seeing the actual colors of the sRGB space. So what does this mean? ----------------------- .. figure:: /images/color_category/Krita-colormanaged-workflow_krita_text.svg :figwidth: 300 :align: right When we paint from scratch, we can see our screen profile as the input space, because we use it to determine what colors to pick. This somewhat simplifies the workflow, but makes the screen profile and viewing conditions more important. Now, photographers and people who do a tricky discipline of VFX called 'color grading' will go completely mad over trying to get the colors they put in to come out 100% correctly, and will even count in factors like the time of day and the color they painted their walls. For example, if the wall behind your computer is pure red, your eyes will adjust to be less sensitive to red, which means that the colors they pick in the program could come out redder. We call these the *viewing conditions*. Thankfully, artists have to worry a slight bit less about this. As illustrations are fully handmade, we are able to identify the important bits and make appropriate contrasts between colors. This means that even if our images turn out to be slightly redder than intended, it is less likely the whole image is ruined. If we look back at the kindergarten example above, we still understand what the image was supposed to look like, despite there being different colors on each image. Furthermore, because the colors in illustrations are deliberately picked, we can correct them more easily on a later date. Yet, at the same time, it is of course a big drag to do this, and we might have had much more flexibility had we taken viewing conditions under consideration. That said, for artists it is also very useful to understand the working spaces. Different working spaces give different results with filters and mixing, and only some working spaces can be used for advanced technology like HDR. Similarly, Krita, as a program intended to make images from scratch, doesn't really worry about assigning workspaces after having made the image. But because you are using the screen as a binocular to look at your image, and to pick colors, you can see your screen's device space as an input space to the image. Hence why profiling your monitor and giving the profile to Krita in the settings can help with preparing your work for print and future ventures in the long run. Overall, it is kinda useful to keep things like viewing conditions in the back of your mind. Many professional artists use a mid-gray color as their default canvas background because they find they create much more dynamic images due to having improved their viewing conditions. It is also why a lot of graphics programs, including Krita, come with a dark theme nowadays. (Though, of course this might also be because dark themes can be considered cool, who knows.) .. _icc_profiles: ICC profiles ------------ -An ICC profile is a set of coordinates describing the extremities of the device space within XYZ, and it is the color management data you use to communicate your working space to printers and applications that are designed for the print industry, such as GIMP, Scribus, Photoshop, Illustrator, Inkscape, Digikam, RawTheraphee, etc. You have two types of ICC profiles: +An ICC profile is a set of coordinates describing the extremities of the device space within XYZ, and it is the color management data you use to communicate your working space to printers and applications that are designed for the print industry, such as Gimp, Scribus, Photoshop, Illustrator, Inkscape, digiKam, RawTheraphee, etc. You have two types of ICC profiles: -Matrix Shaper profiles. +Matrix Shaper profiles These are delivered alongside Krita. Matrix shaper profiles are made by setting parameters and interpolating between these to get the exact size of the color space. Due to this, Krita's color space browser can give you a lot of information on these profiles. Such profiles are also preferable as working space. .. figure:: /images/color_category/Kiki_matrix_profile.png :figwidth: 500 :align: center Matrix shaper profiles have a few parameters that describe the color space which are then interpolated between, this requires a lot of maths. cLUT profiles These are fairly rare, and primarily used to describe printer profiles, such as CMYK. cLUT, or Color Look-up Table profiles store far more data than Matrix shaper profiles, so they can hold data of little particularities caused by, for example, unexpected results from mixing pigments. This is a far more organic approach to describing a color space, hence why a lot of programs that don't care for color management much don't support these. .. figure:: /images/color_category/Kiki_cLUTprofiles.png :figwidth: 500 :align: center cLUT profiles work by holding tables of each color in a color space and their respective coordinates in a reference space. For CMYK this is typically L\*A\*B\* and for the rest XYZ. These tables are tricky to make, which means these profiles are a lot rarer. 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. Perceptual 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 color reproduction. Use this if you want to see all colors in an image, or want to express all possible contrasts. Doesn't work with Matrix Shaper profiles, defaults to relative colorimetric. -Absolute Colorimetric. +Absolute Colorimetric The opposite to Perceptual, Absolute colorimetric will attempt to retain all the correct colors at whatever cost, which may result in awful looking colors. Recommended only for reproduction work. Doesn't work with Matrix Shaper profiles in Krita due to ICC v4 workflow standards. Relative Colorimetric An in between solution between perceptual and absolute, relative will try to fit whatever colors it can match between color spaces. It does this by aligning the white and black points. It cuts off the rest to their respective borders. This is what all matrix shaper profiles default to during conversion, because the ICC v4 workflow specifies to only use Relative Colorimetric for matrix shaper profiles. Saturation Does anything to retain colorfulness, even hue will be sacrificed. Used in infographics. Doesn't work with Matrix Shaper profiles, defaults to relative colorimetric. *ICC profile version* is the last thing to keep in mind when dealing with ICC profiles. Krita delivers both Version 2 and Version 4 profiles, with the later giving better results in doing color maths, but the former being more widely supported (as seen below in 'Interaction with other applications'). This is also why Krita defaults to V2, and we recommend using V2 when you aren't certain if the other programs you are using support V4. LUT docker and HDR imaging -------------------------- .. figure:: /images/dockers/LUT_Management_Docker.png :figwidth: 300 :align: center The :ref:`lut_docker` is the second important bit of color management in Krita that is shared between Krita and programs like Blender, Natron and Nuke, and only uses Look Up Tables that are configured via a config file. You can set the workingspace of the image under input color space, and the display to sRGB or your own LUT if you have added it to the configuration. View in this case is for proofing transforms to a certain display device. Component, exposure, gamma, whitepoint and blackpoint are knobs which allows you to modify the display filter. .. figure:: /images/color_category/Krita_HDR_1.svg :figwidth: 800 :align: center As explained before, we can see our monitor as a telescope or binocular into the world of our picture. Which means it distorts our view of the image a little. But we can modify this binocular, or display filter to see our image in a different way. For example, to allow us to see the white in an image that are whiter than the white of our screen. To explain what that means, we need to think about what white is. For example, white, on our monitor is full red, full green and full blue. But it's certainly different from white on our paper, or the color 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 blacker than the black-point. The LUT docker allows us to control this display-filter and modify the distortion. This is useful when we start modifying images that are made with scene referred values, such as HDR photos, or images coming out of a render engine. .. figure:: /images/color_category/Krita_HDR2.svg :figwidth: 800 :align: center So, for example, we can choose to scale whiter-than-screen-white to our screen-white so we can see the contrasts there. 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 your screen can't show the difference), graphics programs can certainly use it. 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 available 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. LUT docker manipulations are per view, so you can create a new view and set it to luminosity. This way you can see the image in both color as well as grayscale and keep a good eye on your values. Another example is to carefully watch the gradients in a certain section. Like ICC, the LUT Docker allows you to create a profile of sorts for your device. In this case it's the 'lut', which stands for 'Look Up Table', and which can be added to OCIO by modifying the configuration file. When OCIO is turned on, the configuration in :menuselection:`Settings --> Configure Krita --> Color Management` is turned off, unless you are using the :guilabel:`Internal` color engine. In summary ---------- Krita has two modes of color management: * ICC works in terms of spaces relative to the CIEXYZ space, and requires an ICC profile. -* OCIO works in terms of interpretation, and makes use of luts. +* OCIO works in terms of interpretation, and makes use of LUTs. * both can be made with a colorimeter. * If you want to have a properly color managed workflow, you have one made customary for the input device (your screen) and the output devices (your printer, or target screen). For web the output is always sRGB. * Set up your screen profiles under :menuselection:`Settings --> Configure Krita --> Color management`. * Do NOT use screen profiles or other device profiles to draw in. Use a working space profile such as any of the elle profiles for this, as the color maths will be much more predictable and pleasant. Krita will convert between your screen and working space on the fly, allowing you to pick the correct colors. This turns your screen into binoculars to view the image. * Use the appropriate color management for the appropriate workflow. If you are working with Blender, you will be better off using OCIO, than ICC. If you are working with Scribus or Photoshop, use ICC. Krita does a lot of color maths, often concerning the blending of colors. This color maths works best in linear color space, and linear color space requires a bit depth of at the least 16bit to work correctly. The disadvantage is that linear space can be confusing to work in. -If you like painting, have a decent amount of RAM, and are looking to start your baby-steps in taking advantage of Krita's color management, try upgrading from having all your images in sRGB built-in to sRGB-v2-elle-g10.icc or rec2020-v2-elle-g10.icc at 16bit float. This'll give you better color blending while opening up the possibility for you to start working in hdr! +If you like painting, have a decent amount of RAM, and are looking to start your baby-steps in taking advantage of Krita's color management, try upgrading from having all your images in sRGB built-in to sRGB-v2-elle-g10.icc or rec2020-v2-elle-g10.icc at 16bit float. This'll give you better color blending while opening up the possibility for you to start working in HDR! .. note:: Some graphics cards, such as those of the NVidia-brand actually have the best performance under 16bit float, because NVidia cards convert to floating point internally. When it does not need to do that, it speeds up! .. note:: 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. Exporting --------- When you have finished your image and are ready to export it, you can modify the color space to optimize 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 smaller. * Krita doesn't have built-in dithering currently, which means that 16 to 18bit conversions can come out a bit banded. But you can simulate it by adding a fill layer with a pattern, set this fill layer to overlay, and to 5% opacity. Then flatten the whole image and convert it to 8bit. The pattern will function as dithering giving a smoother look to gradients. * If it's a gray-scale image, convert it to gray-scale. * 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 monitor (if they have one). That way, the image will look almost exactly the same on your screen and on other profiled monitors. .. note:: - In some versions of Firefox, the colors actually look strange: This is a bug in Firefox, which is because its `color management system is incomplete `_, save your png, jpg or tiff without an embedded profile to work around this. + In some versions of Firefox, the colors actually look strange: This is a bug in Firefox, which is because its `color management system is incomplete `_, save your PNG, JPG or TIFF without an embedded profile to work around this. If you are preparing for print: -* You hopefully made the picture in a working space profile instead of the actual custom profile of your screen, if not, convert it to something like adobe rgb, sRGB or rec2020. +* You hopefully made the picture in a working space profile instead of the actual custom profile of your screen, if not, convert it to something like Adobe RGB, sRGB or rec2020. * Check with the printer what kind of image they expect. Maybe they expect sRGB color space, or perhaps they have their own profile. Interaction with other applications ----------------------------------- Blender ~~~~~~~ -If you wish to use krita's OCIO functionality, and in particular in combination with Blender's color management, you can try to have it use Blender's OCIO config. +If you wish to use Krita's OCIO functionality, and in particular in combination with Blender's color management, you can try to have it use Blender's OCIO config. Blender's OCIO config is under ``/version number/datafiles/colormanagement``. -Set the LUT docker to use the OCIO engine, and select the config from the above path. This will give you blender's input and screen spaces, but not the looks, as those aren't supported in Krita yet. +Set the LUT docker to use the OCIO engine, and select the config from the above path. This will give you Blender's input and screen spaces, but not the looks, as those aren't supported in Krita yet. Windows Photo Viewer ~~~~~~~~~~~~~~~~~~~~ You might encounter some issues when using different applications together. One important thing to note is that the standard Windows Photo Viewer application does not handle modern ICC profiles. Krita uses version 4 profiles; Photo Viewer can only handle version 2 profiles. If you export to JPEG with an embedded profile, Photo Viewer will display your image much too dark. Example workflows ----------------- Here are some example workflows to get a feeling of how your color management workflow may look like. As mentioned before, input for your screen is set via :menuselection:`Settings --> Configure Krita --> Color management`, or via the LUT docker's 'screen space'. Working space is set via new file per document, or in the LUT docker via 'input space'. Webcomic ~~~~~~~~ .. image:: /images/color_category/Krita-colormanaged-workflow_webcomic.svg :width: 800 :align: center Input Your screen profile. (You pick colors via your screen) Workingspace sRGB (the default screen profile) or any larger profile if you can spare the bit depth and like working in them. Output sRGB, ICC version 2, sRGB TRC for the internet, and a specialized CMYK profile from the printing house for the printed images. -Use the sRGB-elle-V2-srgbtrc.icc for going between Inkscape, Photoshop, Painttool Sai, Illustrator, GIMP, Manga Studio, Paintstorm Studio, MyPaint, Artrage, Scribus, etc. and Krita. +Use the sRGB-elle-V2-srgbtrc.icc for going between Inkscape, Photoshop, Painttool Sai, Illustrator, Gimp, Manga Studio, Paintstorm Studio, MyPaint, Artrage, Scribus, etc. and Krita. -If you are using a larger space via ICC, you will only be able to interchange it between Krita, Photoshop, Illustrator, GIMP 2.9, Manga Studio and Scribus. All others assume sRGB for your space, no matter what, because they don't have color management. +If you are using a larger space via ICC, you will only be able to interchange it between Krita, Photoshop, Illustrator, Gimp 2.9, Manga Studio and Scribus. All others assume sRGB for your space, no matter what, because they don't have color management. If you are going between Krita and Blender, Nuke or Natron, use OCIO and set the input space to 'sRGB', but make sure to select the sRGB profile for ICC when creating a new file. -For the final for the web, convert the image to sRGB 8bit, srgbtrc, do not embed the ICC profile. Then, if using png, put it through something like pngcrush or other png optimizers. sRGB in this case is chosen because you can assume the vast majority of your audience hasn't profiled their screen, nor do they have screens that are advanced enough for the wide gamut stuff. So hence why we convert to the screen default for the internet, sRGB. +For the final for the web, convert the image to sRGB 8bit, 'srgbtrc', do not embed the ICC profile. Then, if using PNG, put it through something like 'pngcrush' or other PNG optimizers. sRGB in this case is chosen because you can assume the vast majority of your audience hasn't profiled their screen, nor do they have screens that are advanced enough for the wide gamut stuff. So hence why we convert to the screen default for the internet, sRGB. Print ~~~~~ .. image:: /images/color_category/Krita-colormanaged-workflow_print.svg :width: 800 :align: center Input Your screen profile. (You pick colors via your screen) Workingspace sRGB or rec2020 if you can afford the bit-depth being 16bit. Output Specialized CMYK profile from the printing house for the printed images. The CMYK profiles are different per printer, and even per paper or ink-type so don't be presumptuous and ask ahead for them, instead of doing something like trying to paint in any random CMYK profile. As mentioned in the viewing conditions section, you want to keep your options open. You can set the advanced color selector to transform to a given profile via :menuselection:`Settings --> Configure Krita --> Color Selector Settings`. There, tick :guilabel:`Color Selector Uses Different Color Space than Image` and select the CMYK profile you are aiming for. This will limit your colors a little bit, but keep all the nice filter and blending options from RGB. Games ~~~~~ .. image:: /images/color_category/Krita-colormanaged-workflow_games.svg :width: 800 :align: center Input Your screen profile. (You pick colors via your screen) Workingspace sRGB or grayscale linear for roughness and specular maps. Output This one is tricky, but in the end it'll be sRGB for the regular player. -So this one is tricky. You can use OCIO and ICC between programs, but recommended is to have your images to the engine in sRGB or grayscale. Many physically based renderers these days allow you to set whether an image should be read as a linear or srgbtrc image, and this is even vital to have the images being considered properly in the physically based calculations of the game renderer. +So this one is tricky. You can use OCIO and ICC between programs, but recommended is to have your images to the engine in sRGB or grayscale. Many physically based renderers these days allow you to set whether an image should be read as a linear or 'srgbtrc' image, and this is even vital to have the images being considered properly in the physically based calculations of the game renderer. While game engines need to have optimized content, and it's recommended to stay within 8bit, future screens may have higher bit depths, and when renderers will start supporting those, it may be beneficial to develop a workflow where the working-space files are rather unnecessarily big and you run some scripts to optimize them for your current render needs, making updating the game in the future for fancier screens less of a drag. Normal maps and heightmaps are officially supposed to be defined with a 'non-color data' working space, but you'll find that most engines will not care much for this. Instead, tell the game engine not to do any conversion on the file when importing. Specular, glossiness, metalness and roughness maps are all based on linear calculations, and when you find that certain material has a metalness of 0.3, this is 30% gray in a linear space. Therefore, make sure to tell the game engine renderer that this is a linear space image (or at the very least, should NOT be converted). .. seealso:: - * `Visualizing the XYZ color space `_ - * `Basics of gamma correction `_ - * `Panda3d example of how an image that has gamma encoded without the 3d renderer being notified of it having gamma-encoding can result in too dark images `_ - * `2d examples of the effect of gamma-encoding on color maths `_ - * `Basic overview of color management from argylcms manual `_ + * `Visualizing the XYZ color space `_. + * `Basics of gamma correction `_. + * `Panda3D example of how an image that has gamma encoded without the 3D renderer being notified of it having gamma-encoding can result in too dark images `_. + * `2D examples of the effect of gamma-encoding on color maths `_. + * `Basic overview of color management from ArgyllCMS manual `_. diff --git a/general_concepts/colors/color_mixing.rst b/general_concepts/colors/color_mixing.rst index ece9c7109..f73ad62fb 100644 --- a/general_concepts/colors/color_mixing.rst +++ b/general_concepts/colors/color_mixing.rst @@ -1,151 +1,151 @@ .. meta:: :description: Color Mixing in a digital media. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier - Emmet O'Neil :license: GNU free documentation license 1.3 or later. .. index:: Color, Color Mixing, Glossing, Scumbling, Hatching, Dithering, Halftone, Smudge .. _color_mixing: .. _mixing_colors: ============= Mixing Colors ============= Much like physical media, there are many ways to mix colors together in Krita. Traditional painters and illustrators often use techniques like **glazing**, **scumbling**, and **hatching** to mix colors directly on their canvas, on top of mixing colors together on a **palette** or even within the hairs of their **brush**. With a little bit of practice and know-how, and thanks to the variety of powerful tools in Krita, we can mimic all of these mixing techniques in digital painting. In both traditional and digital painting, mixing techniques can be divided into *two major categories*: let's call them **"on-canvas"** and **"off-canvas"**. On-Canvas Mixing ---------------- On-canvas mixing techniques are ones where multiple colors are combined directly on the canvas as the artist paints. This takes a few forms, including **layering semi-transparent color** on top of another color, using **texture** to change how a color is perceived, or even in the interaction between two areas of wet paint in traditional media. Bottom line: on-canvas mixing happens right on the canvas and is a great tool for artistic exploration and "happy accidents". Glazing ~~~~~~~ .. image:: /images/color_category/Color_gloss.gif :align: center In traditional painting, **glazing** is overlaying many different semi-transparent layers to create on-canvas color mixtures. Likewise, in digital painting we can also use glazing to mix colors directly on our canvas. This is one of the most fundamental and commonly used mixing techniques in digital painting. We first lay down a semi-transparent layer on top of another color that we intend to mix with. Then, we pick the **resultant color** with :kbd:`Ctrl` + |mouseleft| (this can be configured in the canvas input settings), and paint with that. Depending on our brush's **opacity setting**, each time we glaze one color over another we will get a color that is somewhere between those two colors, often leading to a nice mixture. We can mix even more easily with glazing when we set our brush's **flow** to a lower setting. Subtly different than opacity, :ref:`flow ` is transparency per dab instead of stroke, and so it gives us softer strokes without giving up control. Furthermore, we can combine glazing with various **blending modes** to achieve different, interesting effects. For example, glazing with the **multiply** blending mode to create nice shadows: .. image:: /images/color_category/Color_gloss_example_1.png :align: center Staring with line art and base colors. .. image:: /images/color_category/Color_gloss_example_2.png :align: center Using a semi-transparent brush that's set to multiply, we can add colored layers to suggest shadows and mid-tones. The multiply blending mode will darken and interact with each base color differently. .. image:: /images/color_category/Color_gloss_example_3.png :align: center Then, using a brush with low flow (~0.30), we can pick the resulting colors and lay down more layers. Not only does this help you define the different planes and forms that are so crucial for creating a sense of depth and three-dimensionality, it also gives quite a nice, painterly effect! .. image:: /images/color_category/Color_gloss_example_4.png :align: center Continue with a lower opacity and flow to create even smoother gradients. Make your **edges** as sharp or smooth as your subject matter and art style demands! Smudging ~~~~~~~~ .. image:: /images/color_category/Color_mix.gif :align: center -**Smudge mixing** is done with the :ref:`color_smudge_brush_engine`, a special brush engine that allows you to mix your current brush color with the color(s) under the brush. It's a very powerful type of brush that gives a lovely painterly effect. *Performance wise, it's a bit more demanding and slower than the regular pixel brush.* +**Smudge mixing** is done with the :ref:`color_smudge_brush_engine`, a special brush engine that allows you to mix your current brush color with the color(s) under the brush. It's a very powerful type of brush that gives a lovely painterly effect. *Performance wise, it's a bit more demanding and slower than the regular pixel brush*. If you *remove all paint from a smudge brush*, you get a simple-yet-powerful smudge effect: .. image:: /images/color_category/Color_smudge.gif :align: center Different smudge brushes have different effects, so be sure to try them all out! Scumbling ~~~~~~~~~ **Scumbling** is similar to glazing, except instead of having a semi-opaque layer, we use layers of **textured** or **patterned** paint. .. image:: /images/color_category/Color_scumble2.gif :align: center Like most painting programs, Krita allows you to pick a :ref:`option_brush_tip`, which can be used to create a textured effect like that of scumbling. .. image:: /images/color_category/Color_scumble.gif :align: center Krita's brush engines also allow you to use :ref:`option_texture`. This allows you to create interesting and stylized screentone-like effects. With glazing can get you pretty far when it comes to *defining planes and forms*, scumbling is the best method to *create texture and to break up big pasty flats* in your painting. Off-Canvas Mixing ----------------- **Off-canvas** mixing has basically always been a core tool for artists everywhere; when we think of the stereotypical artist we might imagine someone with a few **brushes** in one hand and a wooden **palette** in the other. Whether it's oils, watercolor, or other traditional media, for the artist to have absolute control over their colors it's crucial to have some kind of palette, plate, jar, or other **off-canvas area** to mix colors together. While it's easy to overlook this in digital painting (where selecting fresh new colors without mixing at all is both easy and free), Krita has a few very useful and unique features for off-canvas mixing. Color Picker Blending ~~~~~~~~~~~~~~~~~~~~~ .. versionadded:: 4.1 Krita, like almost every art and graphics program, has a :ref:`color_picker_tool` which allows you to very quickly sample a color from any pixel on your canvas. While this tool may seem relatively simple and humble, it is also one of the most important and commonly used tools in the digital artist's toolbox - perhaps only second to the brush! In fact, the color picker tool is at the very heart of mixing colors, and is often used in combination with on-canvas techniques like glazing and scumbling to produce smooth blends of color. And still, there is more to this little tool than meets the eye! Not only can you configure Krita's color picker to sample from the average color of a **radius** of pixels, Krita's Color Picker also has a unique **blending** feature: a powerful and intuitive tool for off-canvas color mixing! .. image:: /images/color_category/Krita_cpb_mixing.gif :align: center The Color Picker Blending feature changes the way that picking colors has traditionally worked for decades; instead of completely replacing your current brush color with the newly sampled color, *blending allows you to quickly "soak up" some portion of the sampled color*, which is then mixed with your current brush color. You can use Color Picker Blending much like a physical paint brush in traditional media. If you were to dip your paint brush into a pool of *blue* paint, and then immediately dip again into a pool of *red* paint and paint a stroke across your canvas, the stoke wouldn't be pure red - it would be some combination of blue and red which would mix to create an intermediate purple color. Which shade of purple would depend on the ratio of paints that mix together within the hairs of your brush, and this is essentially what the Color Picker's "blend" option controls: what percentage of sampled color is mixed together with your current brush color! Not only does Krita's Color Picker Blending feel even more like mixing paints, it is also completely off-canvas and independent of opacity, flow, shape, and other brush settings. Furthermore, unlike most on-canvas mixing techniques, Color Picker Blending works regardless of the location of colors on your canvas - enabling you to mix with colors at any position, on any layer, or even in different documents! Quickly mix lighting colors with local colors, mix the ambient sky color into shadows, create atmospheric depth, mix from a preselected palette of colors in another layer/document, etc. To use Color Picker Blending, simply set the "blend" option in the **Tool Options Docker** while the Color Picker Tool is active; setting blend to 100% will cause your Color Picker to work in the traditional way (completely replacing your brush color with the picked color), setting to around 50% will give you a half-way mix between colors, and setting to a lower value will create more subtle shifts in colors each click. Of course, blending affects both your dedicated Color Picker Tool as well as the :kbd:`Ctrl +` |mouseleft| shortcut. .. note:: Clicking and dragging the Color Picker around the canvas currently causes it to sample many times as it switches pixels. You can use this trait to quickly soak up more color by "dipping" your color picker into color and swirling it around. This can be pretty satisfying! However, this also means that some care must be taken to prevent from accidentally picking up more color than you want. It's pretty easy to click a single pixel only one time using a **mouse**, but when painting with a **drawing tablet and pen** it can sometimes be desirable to use a slightly lower blend setting! The Digital Colors Mixer ~~~~~~~~~~~~~~~~~~~~~~~~ Somewhat hidden away in the **Dockers** menu (:menuselection:`Settings --> Dockers --> Digital Colors Mixer`), this can be a useful tool for off-canvas mixing. The Digital Colors Mixer looks a little bit like an audio mixing board that you'd see in a recording studio, but instead of mixing music it mixes colors! It contains 6 independent **color mixers** that mix your current brush color with any color of your choosing. .. image:: /images/color_category/Digi_colormixer.png :align: center By clicking the **color buttons** below each mixer you can choose a palette of colors to mix with. Above each mixer is a **color patch** that will produce a color that mixes some amount of your current brush color with the palette color. Colors towards the top of the mixer will deliver subtle changes to your current color, while colors towards the bottom will be much closer to the palette color of that channel. Other Tips ---------- Outside of making it easier to create smooth gradients, mixing has another benefit: It allows you to create a cohesive piece. Limiting the number of colors we use and then mixing tends to give a more cohesive palette, as we're not trying to do too much at once. This cohesive palette in turn means it will become easier to create a certain mood in an image. Sometimes, mixing in a little bit of accent color can also create unexpected results which in turn can be a little discovery for the audience to delight over as they discover the world of your image. What we can learn from this, is that the next time we select, say, gray, instead of reaching for a random or generic gray from the Advanced Color Selector, consider using one of Krita's many wonderful mixing tools to create an interesting and fitting gray from hues that are roughly complementary (opposite each other on the hue wheel). While on-canvas and off-canvas techniques are fundamentally different categories of mixing colors, they are not mutually exclusive. All of the mixing methods in this article have pros and cons; different tools can be useful for different situations, and combining various techniques can be extremely powerful and fun! Finally, mixing colors will often go far better in a :ref:`higher bit-depth like 16bit `, though it'll make the image take up much more working **memory** (RAM). Furthermore, using a :ref:`linear color space ` can often give far better mixtures than a **gamma-corrected** one, though doing sketches and line art is easier to do in a gamma-corrected space. diff --git a/general_concepts/colors/color_models.rst b/general_concepts/colors/color_models.rst index dda0c048f..25dee234a 100644 --- a/general_concepts/colors/color_models.rst +++ b/general_concepts/colors/color_models.rst @@ -1,196 +1,196 @@ .. meta:: :description: Color Models in Krita .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: Color, Color Models .. _color_models: ============ Color Models ============ Krita has many different color spaces and models. Following here is a brief explanation of each, and their use-cases. .. _model_rgb: RGB --- Red, Green, Blue. These are the most efficient primaries for light-based color mixing, like computer screens. Adding Red, Green and Blue light together results in White, and is thus named the additive color wheel. RGB is used for two purposes: Images that are meant for viewing on a screen: * So that could be images for the web, buttons, avatars, or just portfolio images. * Or for Video games, both sprites and textures are best in RGB there. * Or for 3d rendering, visual effects and cg animation. And for the working space. A working space is an RGB gamut that is really large and predictable, meaning it's good for image manipulation. You use this next to a profiled monitor. This way you can have precise colors while also being able to view them correctly on multiple screens. Blending modes in RGB ~~~~~~~~~~~~~~~~~~~~~ +-------+-----------------+-----------------+-----------------+--------------------+--------------------+ | | Color 1 | Color 2 | Normal | Multiply | Screen | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+------+------+------+------+ | | R | G | B | R | G | B | R | G | B | R | G | B | R | G | B | +=======+=====+=====+=====+=====+=====+=====+=====+=====+=====+======+======+======+======+======+======+ | R & G | 1.0 | 0.0 | 0.0 | 0.0 | 1.0 | 0.0 | 0.5 | 0.5 | 0.0 | 0.0 | 0.0 | 0.0 | 1.0 | 1.0 | 0.0 | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+------+------+------+------+ | Gray | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.5 | 0.25 | 0.25 | 0.25 | 0.75 | 0.75 | 0.75 | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+------+------+------+------+ RGB models: HSV, HSL, HSI and HSY ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ These are not included as their own color spaces in Krita. However, they do show up in the blending modes and color selectors, so a brief overview: --Images of relationship rgb-hsv etc. Hue The tint of a color, or, whether it's red, yellow, green, etc. Krita's Hue is measured in 360 degrees, with 0 being red, 120 being green and 240 being blue. Saturation How vibrant a color is. Saturation is slightly different between HSV and the others. In HSV it's a measurement of the difference between two base colors being used and three base colors being used. In the others it's a measurement of how close a color is to gray, and sometimes this value is called **Chroma**. Saturation ranges from 0 (gray) to 100 (pure color). Value Sometimes known as Brightness. Measurement of how much the pixel needs to light up. Also measured from 0 to 100. Lightness Where a color aligns between white and black. This value is non-linear, and puts all the most saturated possible colors at 50. Ranges from 0 to 100. Intensity Similar to lightness, except it acknowledges that yellow (1,1,0) is lighter than blue (0,0,1). Ranges from 0 to 100. Luma (Y') Similar to lightness and Intensity, except it weights the red, green and blue components based real-life measurements of how much light a color reflects to determine its lightness. Ranges from 0 to 100. Luma is well known for being used in film-color spaces. .. _model_gray: Grayscale --------- This color space only registers gray values. This is useful, because by only registering gray values, it only needs one channel of information, which in turn means the image becomes much lighter in memory consumption! This is useful for textures, but also anything else that needs to stay grayscale, like Black and White comics. +------+---------+---------+--------+----------+--------+ | | Color 1 | Color 2 | Normal | Multiply | Screen | +------+---------+---------+--------+----------+--------+ | | G | G | G | G | G | +======+=========+=========+========+==========+========+ | Gray | 0.5 | 0.5 | 0.5 | 0.25 | 0.75 | +------+---------+---------+--------+----------+--------+ .. _model_cmyk: CMYK ---- Cyan, Magenta, Yellow, Key This is the color space of printers. Unlike computers, printers have these four colors, and adding them all adds up to black instead of white. This is thus also called a 'subtractive' color space. +-------+-----------------------+-----------------------+-----------------------+--------------------------+--------------------------+ | | Color 1 | Color 2 | Normal | Multiply | Screen | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+-----+------+------+------+-----+------+ | | C | M | Y | K | C | M | Y | K | C | M | Y | K | C | M | Y | K | C | M | Y | K | +=======+=====+=====+=====+=====+=====+=====+=====+=====+=====+=====+=====+=====+======+======+=====+======+======+======+=====+======+ | R & G | 0.0 | 1.0 | 1.0 | 0.0 | 1.0 | 0.0 | 1.0 | 0.0 | 0.5 | 0.5 | 1.0 | 0.0 | 0.25 | 0.25 | 1.0 | 0.0 | 0.75 | 0.75 | 1.0 | 0.0 | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+-----+------+------+------+-----+------+ | Gray | 0.0 | 0.0 | 0.0 | 0.5 | 0.0 | 0.0 | 0.0 | 0.5 | 0.0 | 0.0 | 0.0 | 0.5 | 0.0 | 0.0 | 0.0 | 0.25 | 0.0 | 0.0 | 0.0 | 0.75 | +-------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+------+------+-----+------+------+------+-----+------+ There's also a difference between 'colored gray' and 'neutral gray' depending on the profile. +--------------+---------------------------+-----------------------+---------------------------+ | | 25% | 50% | 75% | +--------------+------+------+------+------+-----+-----+-----+-----+------+------+------+------+ | | C | M | Y | K | C | M | Y | K | C | M | Y | K | +==============+======+======+======+======+=====+=====+=====+=====+======+======+======+======+ | Colored Gray | 0.25 | 0.25 | 0.25 | 0.25 | 0.5 | 0.5 | 0.5 | 0.5 | 0.75 | 0.75 | 0.75 | 0.75 | +--------------+------+------+------+------+-----+-----+-----+-----+------+------+------+------+ | Neutral Gray | 0.0 | 0.0 | 0.0 | 0.25 | 0.0 | 0.0 | 0.0 | 0.5 | 0.0 | 0.0 | 0.0 | 0.75 | +--------------+------+------+------+------+-----+-----+-----+-----+------+------+------+------+ .. figure:: /images/color_category/Cmyk_black_differences.png :figwidth: 500 :align: center In Krita, there's also the fact that the default color is a perfect black in RGB, which then gets converted to our default CMYK in a funny manner, giving a yellow look to the strokes. Again, another good reason to work in RGB and let the conversion be done by the printing house. While CMYK has a smaller 'gamut' than RGB, however, it's still recommended to use an RGB working space profile to do your editing in. Afterwards, you can convert it to your printer's CMYK profile using either perceptual or relative colorimetric intent. Or you can just give the workspace rgb image to your printer and let them handle the work. .. _model_ycrcb: YCrCb ----- Luminosity, Red-chroma, Blue-chroma -YCrCb stands for +YCrCb stands for: Y'/Y Luma/Luminosity, thus, the amount of light a color reflects. Cr Red Chroma. This value measures how red a color is versus how green it is. Cb Blue Chroma. This value measures how blue a color is versus how yellow it is. This color space is often used in photography and in (correct) implementations of JPEG. As a human you're much more sensitive to the lightness of colors, and thus JPEG tries to compress the Cr and Cb channels, and leave the Y channel in full quality. .. warning:: Krita doesn't bundle a ICC profile for YCrCb on the basis of there being no open source ICC profiles for this color space. It's unusable without one, and also probably very untested. .. _model_xyz: XYZ ~~~ Back in 1931, the CIE (Institute of Color and Light), was studying human color perception. In doing so, they made the first color spaces, with XYZ being the one best at approximating human vision. It's almost impossible to really explain what XYZ is. Y - is equal to green. + Is equal to green. Z - akin to blue. + Akin to blue. X - is supposed to be red. + Is supposed to be red. XYZ is used as a baseline reference for all other profiles and models. All color conversions are done in XYZ, and all profiles coordinates match XYZ. .. _model_lab: L\*a\*b\* ~~~~~~~~~ Stands for: L\* Lightness, similar to luminosity in this case. a\* a\* in this case is the measurement of how magenta a color is versus how green it is. b\* b\* in this case is a measurement of how yellow a color is versus how blue a color is. L\*a\*b\* is supposed to be a more comprehensible variety of XYZ and the most 'complete' of all color spaces. It's often used as an in between color space in conversion, but even more as the correct color space to do color-balancing in. It's far easier to adjust the contrast and color tone in L*a*b*. L\*a\*b\* is technically the same as Photoshop's LAB. Photoshop specifically uses CIELAB d50. Filters and blending modes -------------------------- Maybe you have noticed that blending modes in LAB don't work like they do in RGB or CMYK. This is because the blending modes work by doing a bit of maths on the color coordinates, and because color coordinates are different per color space, the blending modes look different. diff --git a/general_concepts/colors/linear_and_gamma.rst b/general_concepts/colors/linear_and_gamma.rst index c0254e33a..777fedc1d 100644 --- a/general_concepts/colors/linear_and_gamma.rst +++ b/general_concepts/colors/linear_and_gamma.rst @@ -1,122 +1,122 @@ .. meta:: :description: The effect of gamma and linear. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier - MicahB :license: GNU free documentation license 1.3 or later. .. index:: Gamma, Linear Color Space, Linear, Tone Response curve, EOTF, Transfer Curve .. _gamma_and_linear: .. _linear_and_gamma: ================ Gamma and Linear ================ Now, the situation we talk about when talking theory 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 distinguish between darker grays than we do between lighter grays. 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-encoding', because it is applying a gamma function to the TRC or transfer function of an image. The TRC in this case being the Tone Response Curve or Tone Reproduction Curve or Transfer function (because color management specialists hate themselves), which tells your computer or printer how much color corresponds to a certain value. .. figure:: /images/color_category/Pepper_tonecurves.png :align: center :figwidth: 800 - One of the most common issues people have with Krita's color management is the assigning of the right colorspace to the encoded TRC. Above, the center Pepper is the right one, where the encoded and assigned TRC are the same. To the left we have a Pepper encoded in sRGB, but assigned a linear profile, and to the right we have a Pepper encoded with a linear TRC and assigned an sRGB TRC. Image from `Pepper & Carrot `_ + One of the most common issues people have with Krita's color management is the assigning of the right colorspace to the encoded TRC. Above, the center Pepper is the right one, where the encoded and assigned TRC are the same. To the left we have a Pepper encoded in sRGB, but assigned a linear profile, and to the right we have a Pepper encoded with a linear TRC and assigned an sRGB TRC. Image from `Pepper & Carrot `_. The following table shows how there's a lot of space being used by lighter values in a linear space compared to the default sRGB TRC of our modern computers and other TRCs available in our delivered profiles: .. image:: /images/color_category/trc_gray_gradients.svg :align: center If you look at linear of rec 709 TRCs, you can see there's quite a jump between the darker shades and the lighter shades, while if we look at the Lab L* TRC or the sRGB TRC, which seem more evenly spaced. This is due to our eyes' sensitivity to darker values. This also means that if you do not have enough bit depth, an image in a linear space will look as if it has ugly banding. Hence why, when we make images for viewing on a screen, we always use something like the LAB L\*, sRGB or Gamma 2.2 TRCs to encode the image with. However, this modification to give more space to darker values does lead to wonky color maths when mixing the colors. We can see this with the following experiment: .. figure:: /images/color_category/Krita_2_9_colormanagement_blending_1.png :figwidth: 500 :align: center **Left:** Colored circles blurred in a regular sRGB space. **Right:** Colored circles blurred in a linear space. Colored circles, 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 color smudge brush: .. figure:: /images/color_category/Krita_2_9_colormanagement_blending_2.png :figwidth: 500 :align: center That's right, the 'muddying' of colors as is a common complaint by digital painters everywhere, is in fact, a gamma-corrected colorspace mucking up your colors. If you had been working in LAB to avoid this, be sure to try out a linear rgb color space. What is happening under the hood -------------------------------- Imagine we want to mix red and green. First, we would need the color coordinates of red and green inside our color space's color model. So, that'd be... ===== === ===== ==== Color Red Green Blue ===== === ===== ==== Red 1.0 0.0 0.0 Green 0.0 1.0 0.0 ===== === ===== ==== We then average these coordinates over three mixes: +-------+-----+------+------+------+-------+ | | Red | Mix1 | Mix2 | Mix3 | Green | +=======+=====+======+======+======+=======+ | Red | 1.0 | 0.75 | 0.5 | 0.25 | 0.0 | +-------+-----+------+------+------+-------+ | Green | 0.0 | 0.25 | 0.5 | 0.75 | 1.0 | +-------+-----+------+------+------+-------+ | Blue | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | +-------+-----+------+------+------+-------+ But to figure out how these colors look on screen, we first put the individual values through the TRC of the color-space we're working with: .. image:: /images/color_category/Basicreading3trcsv2.svg :width: 800 :align: center Then we fill in the values into the correct spot. Compare these to the values of the mixture table above! .. image:: /images/color_category/red_green_mixes_trc.svg :align: center And this is why color mixtures are lighter and softer in linear space. Linear space is more physically correct, but sRGB is more efficient in terms of space, so hence why many images have an sRGB TRC encoded into them. -In case this still doesn't make sense: *sRGB gives largely* **darker** *values than linear space for the same coordinates.* +In case this still doesn't make sense: *sRGB gives largely* **darker** *values than linear space for the same coordinates*. So different TRCs give different mixes between colors, in the following example, every set of gradients is in order a mix using linear TRC, a mix using sRGB TRC and a mix using LAB L* TRC. .. image:: /images/color_category/3trcsresult.png :width: 800 :align: center 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 'g10', such as *sRGB-elle-v2-g10.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. If you use the color space browser, you can tell the TRC from the 'estimated gamma'(if it's 1.0, it's linear), or from the TRC widget in Krita 3.0, which looks exactly like the curve graphs above. 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 its own. The downside of linear space is of course that white seems very overpowered when mixing with black, because in a linear space, light grays get more room. In the end, while linear space is physically correct, and a boon to work in when you are dealing with physically correct renderers for videogames and raytracing, Krita is a tool and no-one will hunt you down for preferring the dark mixing of the sRGB TRC. diff --git a/general_concepts/colors/profiling_and_callibration.rst b/general_concepts/colors/profiling_and_callibration.rst index c78925fcc..0165a7425 100644 --- a/general_concepts/colors/profiling_and_callibration.rst +++ b/general_concepts/colors/profiling_and_callibration.rst @@ -1,91 +1,91 @@ .. meta:: :description: Color Models in Krita .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier - RNicole - Timothée Giet - Troy Sobotka :license: GNU free documentation license 1.3 or later. .. index:: Color, Profiling, Calibration .. _profiling_and_calibration: ========================== Profiling and Calibration ========================== So to make it simple, a color profile is just a file defining a set of colors inside a pure XYZ color cube. This "color set" can be used to define different things: * the colors inside an image * the colors a device can output Choosing the right workspace profile to use depends on how much colors you need and on the bit depth you plan to use. Imagine a line with the whole color spectrum from pure black (0,0,0) to pure blue (0,0,1) in a pure XYZ color cube. If you divide it choosing steps at a regular interval, you get what is called a linear profile, with a gamma=1 curve represented as a straight line from 0 to 1. With 8bit/channel bit depth, we have only 256 values to store this whole line. If we use a linear profile as described above to define those color values, we will miss some important visible color change steps and have a big number of values looking the same (leading to posterization effect). This is why was created the sRGB profile to fit more different colors in this limited amount of values, in a perceptually regular grading, by applying a custom gamma curve (see picture here: http://en.wikipedia.org/wiki/SRGB) to emulate the standard response curve of old CRT screens. So sRGB profile is optimized to fit all colors that most common screen can reproduce in those 256 values per R/G/B channels. Some other profiles like Adobe RGB are optimized to fit more printable colors in this limited range, primarily extending cyan-green hues. Working with such profile can be useful to improve print results, but is dangerous if not used with a properly profiled and/or calibrated good display. Most common CMYK workspace profile can usually fit all their colors within 8bit/channel depth, but they are all so different and specific that it's usually better to work with a regular RGB workspace first and then convert the output to the appropriate CMYK profile. Starting with 16bit/channel, we already have 65536 values instead of 256, so we can use workspace profiles with higher gamut range like Wide-gamut RGB or Pro-photo RGB, or even unlimited gamut like scRGB. But sRGB being a generic profile (even more as it comes from old CRT specifications...), there are big chances that your monitor have actually a different color response curve, and so color profile. So when you are using sRGB workspace and have a proper screen profile loaded (see next point), Krita knows that the colors the file contains are within the sRGB color space, and converts those sRGB values to corresponding color values from your monitor profile to display the canvas. Note that when you export your file and view it in another software, this software has to do two things: * read the embed profile to know the "good" color values from the file (which most software do nowadays; when they don't they usually default to sRGB, so in the case described here we're safe ) * and then convert it to the profile associated to the monitor (which very few software actually does, and just output to sRGB.. so this can explain some viewing differences most of the time). Krita uses profiles extensively, and comes bundled with many. The most important one is the one of your own screen. It doesn't come bundled, and you have to make it with a color profiling device. In case you don't have access to such a device, you can't make use of Krita's color management as intended. However, Krita does allow the luxury of picking any of the other bundled profiles as working spaces. Profiling devices ----------------- Profiling devices, called Colorimeters, are tiny little cameras of a kind that you connect to your computer via an usb, and then you run a profiling software (often delivered alongside of the device). .. note:: - If you don't have software packaged with your colorimeter, or are unhappy with the results, we recommend `Argyllcms `_ + If you don't have software packaged with your colorimeter, or are unhappy with the results, we recommend `ArgyllCMS `_. The little camera then measures what the brightest red, green, blue, white and black are like on your screen using a predefined white as base. It also measures how gray the color gray is. It then puts all this information into an ICC profile, which can be used by the computer to correct your colors. It's recommended not to change the "calibration" (contrast, brightness, you know the menu) of your screen after profiling. Doing so makes the profile useless, as the qualities of the screen change significantly while calibrating. To make your screen display more accurate colors, you can do one or two things: profile your screen or calibrate and profile it. Just profiling your screen means measuring the colors of your monitor with its native settings and put those values in a color profile, which can be used by color-managed application to adapt source colors to the screen for optimal result. Calibrating and profiling means the same except that first you try to calibrate the screen colors to match a certain standard setting like sRGB or other more specific profiles. Calibrating is done first with hardware controls (lightness, contrast, gamma curves), and then with software that creates a vcgt (video card gamma table) to load in the GPU. So when or why should you do just one or both? Profiling only: -with a good monitor - you can get most of the sRGB colors and lot of extra colors not inside sRGB. So this can be good to have more visible colors. -with a bad monitor - you will get just a subset of actual sRGB, and miss lot of details, or even have hue shifts. Trying to calibrate it before profiling can help to get closer to full-sRGB colors. +With a good monitor + You can get most of the sRGB colors and lot of extra colors not inside sRGB. So this can be good to have more visible colors. +With a bad monitor + You will get just a subset of actual sRGB, and miss lot of details, or even have hue shifts. Trying to calibrate it before profiling can help to get closer to full-sRGB colors. Calibration+profiling: -bad monitors - as explained just before. -multi-monitor setup - when using several monitors, and specially in mirror mode where both monitor have the same content, you can't have this content color-managed for both screen profiles. In such case, calibrating both screens to match sRGB profile (or another standard for high-end monitors if they both support it) can be a good solution. -soft-proofing - when you need to match an exact rendering context for soft-proofing, calibrating can help getting closer to the expected result. Though switching through several monitor calibration and profiles should be done extremely carefully. +Bad monitors + As explained just before. +Multi-monitor setup + When using several monitors, and specially in mirror mode where both monitor have the same content, you can't have this content color-managed for both screen profiles. In such case, calibrating both screens to match sRGB profile (or another standard for high-end monitors if they both support it) can be a good solution. +Soft-proofing + When you need to match an exact rendering context for soft-proofing, calibrating can help getting closer to the expected result. Though switching through several monitor calibration and profiles should be done extremely carefully. diff --git a/general_concepts/file_formats.rst b/general_concepts/file_formats.rst index 3fd48810a..c202c62c4 100644 --- a/general_concepts/file_formats.rst +++ b/general_concepts/file_formats.rst @@ -1,58 +1,58 @@ .. meta:: :description: The file formats category. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. _general_concept_file_formats: ============ File Formats ============ This category is for graphics file-formats. While most file-formats can be looked up on wikipedia, this doesn't always explain what the format can be used for and what its strengths and weaknesses are. In this category we try to describe these in a manner that can be read by beginners. Generally, there are the following features that people pay attention to in regards to file formats: Compression ----------- Compression is how the file-format tries to describe the image with as little data as possible, so that the resulting file is as small as it can get without losing quality. What we generally see is that formats that are small on disk either lose image quality, or require the computer to spend a lot of time thinking about how the image should look. -Vector file-formats like ``svg`` are a typical example of the latter. They are really small because the technology used to create them is based on mathematics, so it only stores maths-variables and can achieve very high quality. The downside is that the computer needs to spend a lot of time thinking about how it should look, and sometimes different programs have different ways of interpreting the values. Furthermore, vector file-formats imply vector graphics, which is a very different way of working than Krita is specialized in. +Vector file-formats like ``SVG`` are a typical example of the latter. They are really small because the technology used to create them is based on mathematics, so it only stores maths-variables and can achieve very high quality. The downside is that the computer needs to spend a lot of time thinking about how it should look, and sometimes different programs have different ways of interpreting the values. Furthermore, vector file-formats imply vector graphics, which is a very different way of working than Krita is specialized in. -:ref:`Lossy file formats `, like ``jpg`` or ``webp`` are an example of small on disk, but lowering the quality, and are best used for very particular types of images. Lossy thus means that the file format plays fast and loose with describing your image to reduce filesize. +:ref:`Lossy file formats `, like ``JPG`` or ``WebP`` are an example of small on disk, but lowering the quality, and are best used for very particular types of images. Lossy thus means that the file format plays fast and loose with describing your image to reduce filesize. -:ref:`Non-lossy or lossless formats `, like ``png``, ``gif`` or ``bmp`` are in contrast, much heavier on disk, but much more likely to retain quality. +:ref:`Non-lossy or lossless formats `, like ``PNG``, ``GIF`` or ``BMP`` are in contrast, much heavier on disk, but much more likely to retain quality. -Then, there's proper working file formats like Krita's ``.kra``, Gimp's ``xcf``, Photoshop's ``psd``, but also interchange formats like ora and exr. These are the heaviest on the hard-drive and often require special programs to open them up, but on the other hand these are meant to keep your working environment intact, and keep all the layers and guides in them. +Then, there's proper working file formats like Krita's ``KRA``, Gimp's ``XCF``, Photoshop's ``PSD``, but also interchange formats like ``ORA`` and ``EXR``. These are the heaviest on the hard-drive and often require special programs to open them up, but on the other hand these are meant to keep your working environment intact, and keep all the layers and guides in them. Metadata -------- Metadata is the ability of a file format to contain information outside of the actual image contents. This can be human readable data, like the date of creation, the name of the author, a description of the image, but also computer readable data, like an icc-profile which tells the computer about the qualities of how the colors inside the file should be read. Openness -------- This is a bit of an odd quality, but it's about how easy it to open or recover the file, and how widely it's supported. Most internal file formats, like PSD are completely closed, and it's really difficult for human outsiders to recover the data inside without opening Photoshop. Other examples are camera raw files which have different properties per camera manufacturer. SVG, as a vector file format, is on the other end of the spectrum, and can be opened with any text-editor and edited. -Most formats are in-between, and thus there's also a matter of how widely supported the format is. jpg and png cannot be read or edited by human eyes, but the vast majority of programs can open them, meaning the owner has easy access to them. +Most formats are in-between, and thus there's also a matter of how widely supported the format is. JPG and PNG cannot be read or edited by human eyes, but the vast majority of programs can open them, meaning the owner has easy access to them. .. toctree:: :maxdepth: 1 :caption: Contents: :glob: file_formats/* diff --git a/general_concepts/file_formats/file_bmp.rst b/general_concepts/file_formats/file_bmp.rst index 384f7a58d..4b42d1d07 100644 --- a/general_concepts/file_formats/file_bmp.rst +++ b/general_concepts/file_formats/file_bmp.rst @@ -1,19 +1,19 @@ .. meta:: :description: The Bitmap file format. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.bmp, BMP, Bitmap Fileformat .. _file_bmp: ====== \*.bmp ====== -.bmp, or Bitmap, is the simplest raster file format out there, and, being patent-free, most programs can open and save bitmap files. +``.bmp``, or Bitmap, is the simplest raster file format out there, and, being patent-free, most programs can open and save bitmap files. However, most programs don't compress bitmap files, leading to BMP having a reputation for being very heavy. If you need a lossless file format, we actually recommend :ref:`file_png`. diff --git a/general_concepts/file_formats/file_csv.rst b/general_concepts/file_formats/file_csv.rst index 5507a5f4f..e305df674 100644 --- a/general_concepts/file_formats/file_csv.rst +++ b/general_concepts/file_formats/file_csv.rst @@ -1,44 +1,44 @@ .. meta:: :description: The CSV file format as exported by Krita. .. metadata-placeholder :authors: - Lazlo Fazekas :license: GNU free documentation license 1.3 or later. .. index:: *.csv, CSV, Comma Separated Values .. _file_csv: ====== \*.csv ====== -.csv is the abbreviation for Comma Separated Values. It is an open, plain text spreadsheet format. Since the .csv format is a plain text itself, it is possible to use a spreadsheet program or even a text editor to edit the .csv file. +``.csv`` is the abbreviation for Comma Separated Values. It is an open, plain text spreadsheet format. Since the CSV format is a plain text itself, it is possible to use a spreadsheet program or even a text editor to edit the ``*.csv`` file. -Krita supports the .csv version used by TVPaint, to transfer layered animation between these two softwares and probably with others, like Blender. This is not an image sequence format, so use the document loading and saving functions in Krita instead of the :guilabel:`Import animation frames` and :guilabel:`Render Animation` menu items. +Krita supports the CSV version used by TVPaint, to transfer layered animation between these two softwares and probably with others, like Blender. This is not an image sequence format, so use the document loading and saving functions in Krita instead of the :guilabel:`Import animation frames` and :guilabel:`Render Animation` menu items. -The format consists of a text file with .csv extension, together with a folder under the same name and a .frames extension. The .csv file and the folder must be on the same path location. The text file contains the parameters for the scene, like the field resolution and frame rate, and also contains the exposure sheet for the layers. The folder contains :ref:`file_png` picture files. Unlike image sequences, a key frame instance is only a single file and the exposure sheet links it to one or more frames on the timeline. +The format consists of a text file with ``.csv`` extension, together with a folder under the same name and a ``.frames`` extension. The CSV file and the folder must be on the same path location. The text file contains the parameters for the scene, like the field resolution and frame rate, and also contains the exposure sheet for the layers. The folder contains :ref:`file_png` picture files. Unlike image sequences, a key frame instance is only a single file and the exposure sheet links it to one or more frames on the timeline. .. figure:: /images/Csv_spreadsheet.png :align: center - A .csv file as a spreadsheet in :program:`LibreOffice Calc` + A ``.csv`` file as a spreadsheet in :program:`LibreOffice Calc`. Krita can both export and import this format. It is recommended to use 8bit sRGB color space because that's the only color space for :program:`TVPaint`. Layer groups and layer masks are also not supported. TVPaint can only export this format by itself. In :program:`TVPaint 11`, use the :guilabel:`Export to...` option of the :guilabel:`File` menu, and on the upcoming :guilabel:`Export footage` window, use the :guilabel:`Clip: Layers structure` tab. .. figure:: /images/Csv_tvp_csvexport.png :align: center - Exporting into .csv in TVPaint + Exporting into ``.csv`` in TVPaint. To import this format back into TVPaint there is a George language script extension. See the "Packs, Plugins, Third party" section on the TVPaint community forum for more details and also if you need support for other softwares. Moho/Anime Studio and Blender also have plugins to import this format. .. seealso:: - - `.csv import script for TVPaint `_ - - `.csv import script for Moho/Anime Studio `_ - - `.csv import script for Blender `_ + - `CSV import script for TVPaint `_. + - `CSV import script for Moho/Anime Studio `_. + - `CSV import script for Blender `_. diff --git a/general_concepts/file_formats/file_exr.rst b/general_concepts/file_formats/file_exr.rst index f95289d0f..2ea308b7b 100644 --- a/general_concepts/file_formats/file_exr.rst +++ b/general_concepts/file_formats/file_exr.rst @@ -1,22 +1,22 @@ .. meta:: :description: The EXR file format as exported by Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: EXR, HDR Fileformat, OpenEXR, *.exr .. _file_exr: ====== \*.exr ====== -.exr is the prime file format for saving and loading :ref:`floating point bit depths `, and due to the library made to load and save these images being fully open source, the main interchange format as well. +``.exr`` is the prime file format for saving and loading :ref:`floating point bit depths `, and due to the library made to load and save these images being fully open source, the main interchange format as well. -Floating point bit-depths are used by the computer graphics industry to record scene referred values, which can be made via a camera or a computer renderer. Scene referred values means that the file can have values whiter than white, which in turn means that such a file can record lighting conditions, such as sunsets very accurately. These exr files can then be used inside a renderer to create realistic lighting. +Floating point bit-depths are used by the computer graphics industry to record scene referred values, which can be made via a camera or a computer renderer. Scene referred values means that the file can have values whiter than white, which in turn means that such a file can record lighting conditions, such as sunsets very accurately. These EXR files can then be used inside a renderer to create realistic lighting. -Krita can load and save exr for the purpose of paint-over (yes, Krita can paint with scene referred values) and interchange with applications like Blender, Mari, Nuke and Natron. +Krita can load and save EXR for the purpose of paint-over (yes, Krita can paint with scene referred values) and interchange with applications like Blender, Mari, Nuke and Natron. diff --git a/general_concepts/file_formats/file_gbr.rst b/general_concepts/file_formats/file_gbr.rst index 554aa9215..4d0755c61 100644 --- a/general_concepts/file_formats/file_gbr.rst +++ b/general_concepts/file_formats/file_gbr.rst @@ -1,28 +1,28 @@ .. meta:: :description: The Gimp Brush file format as used in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: Gimp Brush, GBR, *.gbr .. _file_gbr: ====== \*.gbr ====== The GIMP brush format. Krita can open, save and use these files as :ref:`predefined brushes `. -There's three things that you can decide upon when exporting a \*.gbr: +There's three things that you can decide upon when exporting a ``*.gbr``: Name This name is different from the file name, and will be shown inside Krita as the name of the brush. Spacing This sets the default spacing. Use color as mask - This'll turn the darkest values of the image as the ones that paint, and the whitest as transparent. Untick this if you are using colored images for the brush + This'll turn the darkest values of the image as the ones that paint, and the whitest as transparent. Untick this if you are using colored images for the brush. -.gbr brushes are otherwise unremarkable, and limited to 8bit color precision. +GBR brushes are otherwise unremarkable, and limited to 8bit color precision. diff --git a/general_concepts/file_formats/file_gif.rst b/general_concepts/file_formats/file_gif.rst index 017bfd11d..737005f0f 100644 --- a/general_concepts/file_formats/file_gif.rst +++ b/general_concepts/file_formats/file_gif.rst @@ -1,19 +1,19 @@ .. meta:: :description: - The Gif file format in Krita. + The GIF file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: GIF, *.gif .. _file_gif: ====== \*.gif ====== -.gif is a file format mostly known for the fact that it can save animations. It's a fairly old format, and it does its compression by :ref:`indexing ` the colors to a maximum of 256 colors per frame. Because we can technically design an image for 256 colors and are always able save over an edited gif without any kind of extra degradation, this is a :ref:`lossless ` compression technique. +``.gif`` is a file format mostly known for the fact that it can save animations. It's a fairly old format, and it does its compression by :ref:`indexing ` the colors to a maximum of 256 colors per frame. Because we can technically design an image for 256 colors and are always able save over an edited GIF without any kind of extra degradation, this is a :ref:`lossless ` compression technique. This means that it can handle most grayscale images just fine and without losing any visible quality. But for color images that don't animate it might be better to use :ref:`file_jpg` or :ref:`file_png`. diff --git a/general_concepts/file_formats/file_gih.rst b/general_concepts/file_formats/file_gih.rst index ffccd4030..b6a80e213 100644 --- a/general_concepts/file_formats/file_gih.rst +++ b/general_concepts/file_formats/file_gih.rst @@ -1,45 +1,45 @@ .. meta:: :description: The Gimp Image Hose file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: Image Hose, Gimp Image Hose, GIH, *.gih .. _file_gih: ====== \*.gih ====== The GIMP image hose format. Krita can open and save these, as well as import via the :ref:`predefined brush tab `. Image Hose means that this file format allows you to store multiple images and then set some options to make it specify how to output the multiple images. .. figure:: /images/brushes/Gih-examples.png :figwidth: 640px :align: center From top to bottom: Incremental, Pressure and Random Gimp image hose format options: Constant This'll use the first image, no matter what. Incremental This'll paint the image layers in sequence. This is good for images that can be strung together to create a pattern. Pressure This'll paint the images depending on pressure. This is good for brushes imitating the hairs of a natural brush. Random This'll draw the images randomly. This is good for image-collections used in speedpainting as well as images that generate texture. Or perhaps more graphical symbols. Angle This'll use the dragging angle to determine with image to draw. -When exporting a krita file as a .gih, you will also get the option to set the default spacing, the option to set the name (very important for looking it up in the UI) and the ability to choose whether or not to generate the mask from the colors. +When exporting a Krita file as a ``.gih``, you will also get the option to set the default spacing, the option to set the name (very important for looking it up in the UI) and the ability to choose whether or not to generate the mask from the colors. Use Color as Mask This'll turn the darkest values of the image as the ones that paint, and the whitest as transparent. Untick this if you are using colored images for the brush. We have a :ref:`Krita Brush tip page ` on how to create your own gih brush. diff --git a/general_concepts/file_formats/file_jpeg.rst b/general_concepts/file_formats/file_jpeg.rst index 8253f278c..e6226ec28 100644 --- a/general_concepts/file_formats/file_jpeg.rst +++ b/general_concepts/file_formats/file_jpeg.rst @@ -1,26 +1,26 @@ .. meta:: :description: The JPEG file format as exported by Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: jpeg, jpg, *.jpg .. _file_jpg: .. _file_jpeg: ====== \*.jpg ====== -.jpg, .jpeg or .jpeg2000 are a family of file-formats designed to encode photographs. +``.jpg``, ``.jpeg`` or ``.jpeg2000`` are a family of file-formats designed to encode photographs. -Photographs have the problem that they have a lot of little gradients, which means that you cannot index the file like you can with :ref:`file_gif` and expect the result to look good. What jpeg instead does is that it converts the file to a perceptual color space (:ref:`YCrCb `), and then compresses the channels that encode the colors, while keeping the channel that holds information about the relative lightness uncompressed. This works really well because human eye-sight is not as sensitive to colorfulness as it is to relative lightness. Jpeg also uses other :ref:`lossy ` compression techniques, like using cosine waves to describe image contrasts. +Photographs have the problem that they have a lot of little gradients, which means that you cannot index the file like you can with :ref:`file_gif` and expect the result to look good. What JPEG instead does is that it converts the file to a perceptual color space (:ref:`YCrCb `), and then compresses the channels that encode the colors, while keeping the channel that holds information about the relative lightness uncompressed. This works really well because human eye-sight is not as sensitive to colorfulness as it is to relative lightness. JPEG also uses other :ref:`lossy ` compression techniques, like using cosine waves to describe image contrasts. -However, it does mean that jpeg should be used in certain cases. For images with a lot of gradients, like full scale paintings, jpeg performs better than :ref:`file_png` and :ref:`file_gif`. +However, it does mean that JPEG should be used in certain cases. For images with a lot of gradients, like full scale paintings, JPEG performs better than :ref:`file_png` and :ref:`file_gif`. -But for images with a lot of sharp contrasts, like text and comic book styles, png is a much better choice despite a larger file size. For grayscale images, png and gif will definitely be more efficient. +But for images with a lot of sharp contrasts, like text and comic book styles, PNG is a much better choice despite a larger file size. For grayscale images, :ref:`file_png` and :ref:`file_gif` will definitely be more efficient. -Because jpeg uses lossy compression, it is not advised to save over the same jpeg multiple times. The lossy compression will cause the file to reduce in quality each time you save it. This is a fundamental problem with lossy compression methods. Instead use a lossless file format, or a working file format while you are working on the image. +Because JPEG uses lossy compression, it is not advised to save over the same JPEG multiple times. The lossy compression will cause the file to reduce in quality each time you save it. This is a fundamental problem with lossy compression methods. Instead use a lossless file format, or a working file format while you are working on the image. diff --git a/general_concepts/file_formats/file_kpl.rst b/general_concepts/file_formats/file_kpl.rst index b3e8b5d25..0ca2e16cc 100644 --- a/general_concepts/file_formats/file_kpl.rst +++ b/general_concepts/file_formats/file_kpl.rst @@ -1,19 +1,19 @@ .. meta:: :description: The Krita Palette file format. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.kpl, KPL, Krita Palette .. _file_kpl: ====== \*.kpl ====== Since 4.0, Krita has a new palette file-format that can handle colors that are wide gamut, RGB, CMYK, XYZ, GRAY, or LAB, and can be of any of the available bitdepths, as well as groups. These are Krita Palettes, or ``*.kpl``. -``*.kpl`` files are zip files, with two XMLs and ICC profiles inside. The colorset XML contains the swatches as ColorSetEntry and Groups as Group. The profiles.XML contains a list of profiles, and the ICC profiles themselves are embedded to ensure compatibility over different computers. +``*.kpl`` files are ZIP files, with two XMLs and ICC profiles inside. The colorset XML contains the swatches as ColorSetEntry and Groups as Group. The profiles.XML contains a list of profiles, and the ICC profiles themselves are embedded to ensure compatibility over different computers. diff --git a/general_concepts/file_formats/file_kra.rst b/general_concepts/file_formats/file_kra.rst index 337c9911d..869591890 100644 --- a/general_concepts/file_formats/file_kra.rst +++ b/general_concepts/file_formats/file_kra.rst @@ -1,19 +1,19 @@ .. meta:: :description: The Krita Raster Archive file format. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.kra, KRA, Krita Archive .. _file_kra: ====== \*.kra ====== -.kra is Krita's internal file-format, which means that it is the file format that saves all of the features Krita can handle. It's construction is vaguely based on the open document standard, which means that you can rename your .kra file to a .zip file and open it up to look at the insides. +``.kra`` is Krita's internal file-format, which means that it is the file format that saves all of the features Krita can handle. It's construction is vaguely based on the open document standard, which means that you can rename your ``.kra`` file to a ``.zip`` file and open it up to look at the insides. It is a format that you can expect to get very heavy, and isn't meant for sharing on the internet. diff --git a/general_concepts/file_formats/file_ora.rst b/general_concepts/file_formats/file_ora.rst index a600052ca..9e9de660d 100644 --- a/general_concepts/file_formats/file_ora.rst +++ b/general_concepts/file_formats/file_ora.rst @@ -1,23 +1,23 @@ .. meta:: :description: The Open Raster Archive file format as exported by Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.ora, ORA, Open Raster Archive .. _file_ora: ====== \*.ora ====== -.ora, or the Open Raster format, is an interchange format. It was designed to replace :ref:`file_psd` as an interchange format, as the latter isn't meant for that. Like :ref:`file_kra` it is loosely based on the Open Document structure, thus a zip file with a bunch of xmls and pngs, but where Krita's internal file format can sometimes have fully binary chunks, .ora saves its layers as :ref:`file_png` making it fully open and easy to support. +``.ora``, or the Open Raster format, is an interchange format. It was designed to replace :ref:`file_psd` as an interchange format, as the latter isn't meant for that. Like :ref:`file_kra` it is loosely based on the Open Document structure, thus a ZIP file with a bunch of XMLs and PNGs, but where Krita's internal file format can sometimes have fully binary chunks, ``.ora`` saves its layers as :ref:`file_png` making it fully open and easy to support. As an interchange format, it can be expected to be heavy and isn't meant for uploading to the internet. .. seealso:: `Open Raster Specification `_ diff --git a/general_concepts/file_formats/file_pbgpm.rst b/general_concepts/file_formats/file_pbgpm.rst index 06c6ea909..bff5be551 100644 --- a/general_concepts/file_formats/file_pbgpm.rst +++ b/general_concepts/file_formats/file_pbgpm.rst @@ -1,27 +1,27 @@ .. meta:: :description: - The pbm, pgm and ppm file formats as exported by Krita. + The PBM, PGM and PPM file formats as exported by Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.pbm, *.pgm, *.ppm, PBM, PGM, PPM .. _file_pbm: .. _file_pgm: .. _file_ppm: -====================== -\*.pbm, \*.pgm, \*.ppm -====================== -.pbm, .pgm, .ppm are a series of file-formats with a similar logic to them. They are designed to save images in a way that the result can be read as an ascii file, from back when email clients couldn't read images reliably. +========================= +\*.pbm, \*.pgm and \*.ppm +========================= +``.pbm``, ``.pgm`` and ``.ppm`` are a series of file-formats with a similar logic to them. They are designed to save images in a way that the result can be read as an ASCII file, from back when email clients couldn't read images reliably. They are very old file formats, and not used outside of very specialized usecases, such as embedding images inside code. .pbm - one-bit and can only show strict black and white. + One-bit and can only show strict black and white. .pgm - can show 255 values of gray (8bit). + Can show 255 values of gray (8bit). .ppm - can show 8bit rgb values. + Can show 8bit rgb values. diff --git a/general_concepts/file_formats/file_pdf.rst b/general_concepts/file_formats/file_pdf.rst index fb4a3c363..7628cf468 100644 --- a/general_concepts/file_formats/file_pdf.rst +++ b/general_concepts/file_formats/file_pdf.rst @@ -1,21 +1,21 @@ .. meta:: :description: The PDF file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.pdf, PDF .. _file_pdf: ====== \*.pdf ====== -.pdf is a format intended for making sure a document looks the same on all computers. It became popular because it allows the creator to make sure that the document looks the same and cannot be changed by viewers. These days it is an open standard and there is quite a variety of programs that can read and save pdfs. +``.pdf`` is a format intended for making sure a document looks the same on all computers. It became popular because it allows the creator to make sure that the document looks the same and cannot be changed by viewers. These days it is an open standard and there is quite a variety of programs that can read and save PDFs. -Krita can open pdfs with multiple layers. There is currently no PDF export, nor is that planned. If you want to create a PDF with images from Krita, use `Scribus `_. +Krita can open PDFs with multiple layers. There is currently no PDF export, nor is that planned. If you want to create a PDF with images from Krita, use `Scribus `_. -While pdfs can be viewed via most browsers, they can also become very heavy and are thus not recommended outside of official documents. Printhouses will often accept pdf. +While PDFs can be viewed via most browsers, they can also become very heavy and are thus not recommended outside of official documents. Printhouses will often accept PDF. diff --git a/general_concepts/file_formats/file_png.rst b/general_concepts/file_formats/file_png.rst index 6598965c6..1441757fe 100644 --- a/general_concepts/file_formats/file_png.rst +++ b/general_concepts/file_formats/file_png.rst @@ -1,26 +1,26 @@ .. meta:: :description: The Portable Network Graphics file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier - Boudewijn Rempt :license: GNU free documentation license 1.3 or later. .. index:: *.png, png, portable network graphics .. _file_png: ====== \*.png ====== -.png, or Portable Network Graphics, is a modern alternative to :ref:`file_gif` and with that and :ref:`file_jpg` it makes up the three main formats that are widely supported on the internet. +``.png``, or Portable Network Graphics, is a modern alternative to :ref:`file_gif` and with that and :ref:`file_jpg` it makes up the three main formats that are widely supported on the internet. -png is a :ref:`lossless ` file format, which means that it is able to maintain all the colors of your image perfectly. It does so at the cost of the file size being big, and therefore it is recommended to try :ref:`file_jpg` for images with a lot of gradients and different colors. Grayscale images will do better in png as well as images with a lot of text and sharp contrasts, like comics. +PNG is a :ref:`lossless ` file format, which means that it is able to maintain all the colors of your image perfectly. It does so at the cost of the file size being big, and therefore it is recommended to try :ref:`file_jpg` for images with a lot of gradients and different colors. Grayscale images will do better in PNG as well as images with a lot of text and sharp contrasts, like comics. -Like :ref:`file_gif`, png can support indexed color. Unlike :ref:`file_gif`, png doesn't support animation. There have been two attempts at giving animation support to png, apng and mng, the former is unofficial and the latter too complicated, so neither have really taken off yet. +Like :ref:`file_gif`, PNG can support indexed color. Unlike :ref:`file_gif`, PNG doesn't support animation. There have been two attempts at giving animation support to PNG, APNG and MNG, the former is unofficial and the latter too complicated, so neither have really taken off yet. .. versionadded:: 4.2 - Since 4.2 we support saving HDR to PNG as according to the `W3C PQ HDR PNG standard `_. To save as such files, toggle :guilabel:`Save as HDR image (Rec. 2020 PQ)`, which will convert your image to the Rec 2020 PQ color space and then save it as a special HDR png. + Since 4.2 we support saving HDR to PNG as according to the `W3C PQ HDR PNG standard `_. To save as such files, toggle :guilabel:`Save as HDR image (Rec. 2020 PQ)`, which will convert your image to the Rec 2020 PQ color space and then save it as a special HDR PNG. diff --git a/general_concepts/file_formats/file_psd.rst b/general_concepts/file_formats/file_psd.rst index 2dff505bf..a8c79cdc0 100644 --- a/general_concepts/file_formats/file_psd.rst +++ b/general_concepts/file_formats/file_psd.rst @@ -1,27 +1,27 @@ .. meta:: :description: The Photoshop file format as exported by Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.psd, PSD, Photoshop Document .. _file_psd: ====== \*.psd ====== -.psd is Photoshop's internal file format. For some reason, people like to use it as an interchange format, even though it is not designed for this. +``.psd`` is Photoshop's internal file format. For some reason, people like to use it as an interchange format, even though it is not designed for this. -.psd, unlike actual interchange formats like :ref:`file_pdf`, :ref:`file_tif`, :ref:`file_exr`, :ref:`file_ora` and :ref:`file_svg` doesn't have an official spec online. Which means that it needs to be reverse engineered. Furthermore, as an internal file format, it doesn't have much of a philosophy to its structure, as it's only purpose is to save what photoshop is busy with, or rather, what all the past versions of photoshop have been busy with. This means that the inside of a psd looks somewhat like photoshop's virtual brains, and psd is in general a very disliked file-format. +``.psd``, unlike actual interchange formats like :ref:`file_pdf`, :ref:`file_tif`, :ref:`file_exr`, :ref:`file_ora` and :ref:`file_svg` doesn't have an official spec online. Which means that it needs to be reverse engineered. Furthermore, as an internal file format, it doesn't have much of a philosophy to its structure, as it's only purpose is to save what Photoshop is busy with, or rather, what all the past versions of Photoshop have been busy with. This means that the inside of a PSD looks somewhat like Photoshop's virtual brains, and PSD is in general a very disliked file-format. -Due to .psd being used as an interchange format, this leads to confusion amongst people using these programs, as to why not all programs support opening these. Sometimes, you might even see users saying that a certain program is terrible because it doesn't support opening psds properly. But as psd is an internal file-format without online specs, it is impossible to have any program outside it support it 100%. +Due to ``.psd`` being used as an interchange format, this leads to confusion amongst people using these programs, as to why not all programs support opening these. Sometimes, you might even see users saying that a certain program is terrible because it doesn't support opening PSDs properly. But as PSD is an internal file-format without online specs, it is impossible to have any program outside it support it 100%. -Krita supports loading and saving raster layers, blending modes, layerstyles, layer groups, and transparency masks from psd. It will likely never support vector and text layers, as these are just too difficult to program properly. +Krita supports loading and saving raster layers, blending modes, layerstyles, layer groups, and transparency masks from PSD. It will likely never support vector and text layers, as these are just too difficult to program properly. -We recommend using any other file format instead of psd if possible, with a strong preference towards :ref:`file_ora` or :ref:`file_tif`. +We recommend using any other file format instead of PSD if possible, with a strong preference towards :ref:`file_ora` or :ref:`file_tif`. -As a working file format, psds can be expected to become very heavy and most websites won't accept them. +As a working file format, PSDs can be expected to become very heavy and most websites won't accept them. diff --git a/general_concepts/file_formats/file_svg.rst b/general_concepts/file_formats/file_svg.rst index 63c376d73..07cc7dc2f 100644 --- a/general_concepts/file_formats/file_svg.rst +++ b/general_concepts/file_formats/file_svg.rst @@ -1,25 +1,25 @@ .. meta:: :description: The Scalable Vector Graphics file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: SVG, *.svg, Scalable Vector Graphics Format .. _file_svg: ====== \*.svg ====== -.svg, or Scalable Vector Graphics, is the most modern vector graphics interchange file format out there. +``.svg``, or Scalable Vector Graphics, is the most modern vector graphics interchange file format out there. -Being vector graphics, svg is very light weight. This is because it usually only stores coordinates and parameters for the maths involved with vector graphics. +Being vector graphics, SVG is very light weight. This is because it usually only stores coordinates and parameters for the maths involved with vector graphics. -It is maintained by the w3c svg working group, who also maintain other open standards that make up our modern internet. +It is maintained by the W3C SVG working group, who also maintain other open standards that make up our modern internet. -While you can open up svg files with any text-editor to edit them, it is best to use a vector program like Inkscape. Krita 2.9 to 3.3 supports importing svg via the add shape docker. Since Krita 4.0, SVGs can be properly imported, and you can export singlevector layers via :menuselection:`Layer --> Import/Export --> Save Vector Layer as SVG...`. For 4.0, Krita will also use SVG to save vector data into its :ref:`internal format `. +While you can open up SVG files with any text-editor to edit them, it is best to use a vector program like Inkscape. Krita 2.9 to 3.3 supports importing SVG via the add shape docker. Since Krita 4.0, SVGs can be properly imported, and you can export singlevector layers via :menuselection:`Layer --> Import/Export --> Save Vector Layer as SVG...`. For 4.0, Krita will also use SVG to save vector data into its :ref:`internal format `. -svg is designed for the internet, though sadly, because vector graphics are considered a bit obscure compared to raster graphics, not a lot of websites accept them yet. Hosting them on your own webhost works just fine though. +SVG is designed for the internet, though sadly, because vector graphics are considered a bit obscure compared to raster graphics, not a lot of websites accept them yet. Hosting them on your own webhost works just fine though. diff --git a/general_concepts/file_formats/file_tif.rst b/general_concepts/file_formats/file_tif.rst index 6a1b88366..2ce3c744a 100644 --- a/general_concepts/file_formats/file_tif.rst +++ b/general_concepts/file_formats/file_tif.rst @@ -1,22 +1,22 @@ .. meta:: :description: The Tagged Image file format in Krita. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: *.tif, *.tiff, TIF, TIFF, Tagged Image File Format .. _file_tif: .. _file_tiff: ======= \*.tiff ======= -.tiff, or Tagged Image File Format, is a raster interchange format that was originally designed to be a common format generated by scanners and used by printers. +``.tiff``, or Tagged Image File Format, is a raster interchange format that was originally designed to be a common format generated by scanners and used by printers. -It can support multiple color spaces, and even layers. However, the latter is a bit odd, as the official specs, owned by Adobe, have a different way of saving layers to tiff than Photoshop, also owned by Adobe. +It can support multiple color spaces, and even layers. However, the latter is a bit odd, as the official specs, owned by Adobe, have a different way of saving layers to TIFF than Photoshop, also owned by Adobe. -As an interchange format, .tiff is not meant for sharing on the internet, and you will not find many websites that do accept it. However, printhouses know the file format, and will likely accept it. +As an interchange format, ``.tiff`` is not meant for sharing on the internet, and you will not find many websites that do accept it. However, printhouses know the file format, and will likely accept it. diff --git a/general_concepts/file_formats/lossy_lossless.rst b/general_concepts/file_formats/lossy_lossless.rst index 2fb6b0e89..58543ad94 100644 --- a/general_concepts/file_formats/lossy_lossless.rst +++ b/general_concepts/file_formats/lossy_lossless.rst @@ -1,38 +1,38 @@ .. meta:: :description: The difference between lossy and lossless compression. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. index:: lossy, lossless, compression .. _lossy_compression: .. _lossless_compression: ==================================== Lossy and Lossless Image Compression ==================================== When we compress a file, we do this because we want to temporarily make it smaller (like for sending over email), or we want to permanently make it smaller (like for showing images on the internet). *Lossless* compression techniques are for when we want to *temporarily* reduce information. As the name implies, they compress without losing information. In text, the use of abbreviations is a good example of a lossless compression technique. Everyone knows 'etc.' expands to 'etcetera', meaning that you can half the 8 character long 'etcetera' to the four character long 'etc.'. Within image formats, examples of such compression is by for example 'indexed' color, where we make a list of available colors in an image, and then assign a single number to them. Then, when describing the pixels, we only write down said number, so that we don't need to write the color definition over and over. *Lossy* compression techniques are for when we want to *permanently* reduce the file size of an image. This is necessary for final products where having a small filesize is preferable such as a website. That the image will not be edited anymore after this allows for the use of the context of a pixel to be taken into account when compressing, meaning that we can rely on psychological and statistical tricks. One of the primary things JPEG for example does is chroma sub-sampling, that is, to split up the image into a grayscale and two color versions (one containing all red-green contrast and the other containing all blue-yellow contrast), and then it makes the latter two versions smaller. This works because humans are much more sensitive to differences in lightness than we are to differences in hue and saturation. Another thing it does is to use cosine waves to describe contrasts in an image. What this means is that JPEG and other lossy formats using this are *very good at describing gradients, but not very good at describing sharp contrasts*. Conversely, lossless image compression techniques are *really good at describing images with few colors thus sharp contrasts, but are not good to compress images with a lot of gradients*. -Another big difference between lossy and lossless images is that lossy file formats will degrade if you re-encode them, that is, if you load a jpeg into Krita edit a little, resave, edit a little, resave, each subsequent save will lose some data. This is a fundamental part of lossy image compression, and the primary reason we use working files. +Another big difference between lossy and lossless images is that lossy file formats will degrade if you re-encode them, that is, if you load a JPEG into Krita edit a little, resave, edit a little, resave, each subsequent save will lose some data. This is a fundamental part of lossy image compression, and the primary reason we use working files. .. seealso:: If you're interested in different compression techniques, `Wikipedia's page(s) on image compression `_ are very good, if not a little technical. diff --git a/general_concepts/projection.rst b/general_concepts/projection.rst index ab0af29ba..96693937e 100644 --- a/general_concepts/projection.rst +++ b/general_concepts/projection.rst @@ -1,31 +1,31 @@ .. meta:: :description lang=en: The Perspective Projection Category. .. metadata-placeholder :authors: - Wolthera van Hövell tot Westerflier :license: GNU free documentation license 1.3 or later. .. _cat_projection: .. _general_concept_projection: ###################### Perspective Projection ###################### The Perspective Projection tutorial is one of the Kickstarter 2015 tutorial rewards. It's about something that humanity has known scientifically for a very long time, and decent formal training will teach you about this. But I think there are very very few tutorials about it in regard to how to achieve it in digital painting programs, let alone open source. -The tutorial is a bit image heavy, and technical, but I hope the skill it teaches will be really useful to anyone trying to get a grasp on a complicated pose. Enjoy, and don't forget to thank `Raghukamath `_ for choosing this topic! +The tutorial is a bit image heavy, and technical, but I hope the skill it teaches will be really useful to anyone trying to get a grasp on a complicated pose. Enjoy, and don't forget to thank `Raghukamath `_ for choosing this topic! .. figure:: /images/category_projection/projection-cube_09.svg :align: center .. toctree:: :maxdepth: 1 :caption: Parts: projection/orthographic_oblique projection/axonometric projection/perspective projection/practical