From BlenderWiki

Jump to: navigation, search
Blender3D FreeTip.gif
IMPORTANT! Do not update this page!
We have moved the Blender User Manual to a new location. Please do not update this page, as it will be locked soon.

Comme le laisse entendre le titre, ces nœuds convertissent les couleurs et autres propriétés de diverses données (par ex. des images), de diverses manières. Ils séparent ou re-combinent également les différentes composantes (couleurs) d'une image, vous permettant de travailler sur chaque canal indépendamment. Différents types de canaux couleurs sont supportés, incluant les espaces de couleur informatiques standards (RGB et HSV), et les espace de couleur vidéo (YUV et YCbCr), utilisés par les nouveaux formats HD.

Nœud "ColorRamp"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsColorRamp

Nœud ColorRamp.

Le nœud ColorRamp est utilisé pour "mapper" (~= convertir) des valeurs vers des couleurs, par l'intermédiaire d'un gradient. Il fonctionne exactement comme une colorband (bande couleur) pour les textures et les matériaux, utilisant la valeur Facteur comme index, pointeur sur une couleur de la colorband affichée, et produisant en sortie une couleur et une valeur alpha.

Par défaut, la bande couleur du nœud est une transition entre deux couleurs aux extrémités opposées. Un noir total à gauche (c'est la couleur visible dans le contrôle échantillon, avec un Alpha de 1.0), et un blanc pur à droite. Pour sélectionner une couleur, cliquez LMB Template-LMB.png sur la fine barre verticale lui correspondant dans la bande couleur (la barre sélectionnée devient plus épaisse). L'image d'exemple montre la couleur noire sélectionnée. Les réglages de la couleur courante sont affichés au-dessus de la bande couleur: (de gauche à droite) le contrôle échantillon pour la couleur, la valeur Alpha, et le type d'interpolation entre couleurs.

Pour modifier la couleur sélectionnée dans la colorband, cliquez LMB Template-LMB.png dans le contrôle échantillon, et utilisez le sélecteur de couleur qui apparaît pour en choisir une nouvelle. Tapez Entrer pour valider.

Pour ajouter une couleur dans la colorband, cliquez CtrlLMB Template-LMB.png dans la bande. Choisissez votre couleur en cliquant dans le contrôle échantillon, et entrez une valeur Alpha dans le bouton numérique. Notez que vous pouvez utiliser des textures comme masques (ou pour simuler la vieille fonction "Emit") en connectant la sortie Alpha à l'entrée Facteur d'un nœud RGB mixer.

Pour supprimer une couleur de la bande, sélectionnez-la et cliquez sur le bouton Delete.

Quand vous utilisez plusieurs couleurs, vous pouvez contrôler le type de transition (d'interpolation) entre elles, avec les boutons: Ease, Cardinal, Linear, ou Spline.

Enfin, le bouton numérique Alpha vous permet de définir la transparence de chaque couleur présente dans le bande couleur.

Utiliser un nœud "ColorRamp" pour créer un masque Alpha

Un usage puissant mais souvent méconnu du nœud ColorRamp est de créer un masque Alpha, ou un masque superposé à une autre image, et, comme tout bon masque, qui laisse visible une partie du fond. Le système d'exemple ci-dessous montre comment utiliser le nœud ColorRamp pour faire cela:

Utiliser le nœud ColorRamp pour créer un masque Alpha.

Dans le système ci-dessus, une image de tourbillon Noir & Blanc, à qui il manque un canal Alpha, est placée en entrée Factor d'un nœud ColorRamp (en fait, pour rester "techniquement correct", nous aurions dû convertir d'abord l'image en valeurs Noir & Blanc avec un nœud RGB to BW, mais bon, cela marche très bien car nous utilisons une image BW en entrée!).

Nous avons réglé le nœud ColorRamp en transparence totale à la limite gauche du "spectre", et en couleur rouge opaque à la limite droite. Comme le montre le nœud Viewer, le nœud ColorRamp produit un masque, totalement transparent là où l'image d'entrée est totalement noire. Le noir vaut zéro, donc ColorRamp utilise la "couleur" à la limite gauche du spectre, que nous avons choisie transparente. L'image produite par ColorRamp est totalement rouge et opaque là où l'image d'entrée est totalement blanche (1.0).

Nous contrôlons que l'image de sortie est bien transparente en la superposant à une image de citrouille. Pour le plaisir, nous rendons l'image produite par cet AlphaOver partiellement transparente (0.66), nous pourrons ainsi, plus tard, superposer cette image à un fond blanc clignotant, pour simuler une scène effrayante avec des éclairs de lumière.

Utiliser un nœud "ColorRamp" pour coloriser une Image

La vraie puissance du nœud ColorRamp réside dans la possibilité d'ajouter autant de couleurs que souhaité dans le "spectre" de couleur. L'exemple de système de compositing ci-dessous transforme une triste image Noir & Blanc en un flamboyant tourbillon!

Manual-Compositing-ColorRamp Colorize.png

Dans cet exemple, nous avons "mappé" les nuances de gris de l'image d'entrée vers trois couleurs, bleu, jaune et rouge, toutes totalement opaques (Alpha de 1.0). Là où l'image est noire, ColorRamp produit du bleu (la couleur actuellement sélectionnée). Là où elle est en nuances de gris, ColorRamp choisit la couleur correspondante dans son "spectre" (bleutée, jaune, puis vers le rouge). Là où l'image est totalement blanche, ColorRamp choisit le rouge.

Nœud "RGB to BW"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsRGB to BW

Nœud RGB to BW.

Ce nœud convertit une image couleur en une image N&B (ou plus précisément, en nuances de gris).

Nœud "Set Alpha"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsSet Alpha

Nœud Set Alpha.

Ce nœud ajoute un canal alpha à une image. Certains formats d'image, comme le JPEG, ne supportent pas de canal alpha. Pour superposer une image JPEG à un fond, vous devez lui ajouter un canal alpha par l'intermédiaire de ce nœud.

La prise d'entrée Image est optionnelle. Si une image n'est pas fournie en entrée, la couleur unie visible dans le contrôle échantillon sera utilisée. Pour en changer, cliquez LMB Template-LMB.png dessus et utilisez le sélecteur de couleur, ou entrez directement la valeur de la couleur souhaitée.

La quantité d'Alpha (1.0 donne une image totalement opaque, 0.0, totalement transparente) peut être réglée pour toute l'image avec le bouton numérique. Alternativement, vous pouvez contrôler ce facteur en fournissant une valeur à sa prise d'entrée.

Utiliser le nœud "SetAlpha" pour faire un fondu au noir

Pour faire passer les spectateurs d'une scène (ou d'un plan) à un(e) autre, une technique classique est le "fondu au noir". Comme son nom l'indique, l'image se fond dans un écran noir. Vous pouvez aussi faire un "fondu au blanc", ou n'importe quelle autre couleur à votre goût, mais le noir est une bonne couleur neutre, reposante pour les yeux et qui "réinitialise" l'esprit du spectateur. Le système de nœud ci-dessous montre comment réaliser cela avec le nœud Set Alpha.

Fondu au noir.

Dans cet exemple, le canal alpha de l'image de la spirale est ignoré. Un nœud Time fournit une valeur de 0.0 à 1.0, sur 60 images (soit deux secondes en NTSC) en entrée Alpha du nœud Set Alpha. Notez que la courbe temporelle a une forme exponentielle, de manière que le noir apparaisse en douceur, puis accélère sa "prise de pouvoir". Le nœud Set Alpha n'a pas besoin d'une image en entrée; un noir uni est utilisé à la place. Le nœud Set Alpha utilise l'entrée Alpha et la couleur unie pour créer une image noire dont l'alpha va de 0.0 à 1.0 (c-à-d de totalement transparente à complètement opaque) sur 60 images. Pensez à l'alpha comme la vivacité, la netteté avec laquelle vous voyez un pixel donné. Nos deux images (celle de départ et celle générée par Set Alpha sont alors combinées par notre indispensable nœud AlphaOver (avec un Facteur à 1.0) pour produire le fondu au noir: le nœud Set Alpha va, en fonction de l'image courante, produire une image noire unie plus ou moins transparente. Lancez l'animation, et vous obtenez une séquence de deux secondes (à 30 fps) de fondu au noir.

Pas de données scène utilisées
Ce système de nœud n'utilise pas d'entrée RenderLayer. Pour produire cette vidéo de deux secondes, aucune donnée issue d'une scène Blender n'a été utilisée. C'est un exemple de l'utilisation des puissantes capacités de Blender en compositing seul, sans recours à ses capacités en modelage et animation. (Un nœud RenderLayer aurait bien sûr pu être substitué au nœud Image, sans influence sur l'effet produit par ce système de nœud.)


Utiliser le nœud "SetAlpha" pour introduire en fondu un titre

Pour introduire votre animation, vous voudrez afficher son titre sur un arrière plan. Vous pouvez le faire apparaître "en volant", ou en fondu. Pour l'introduire en fondu, utilisez le nœud SetAlpha avec un nœud Time comme montré ci-dessous:

Utiliser Set Alpha pour introduire un titre en fondu.

Ici, une courbe Time fournit une valeur en entrée Alpha du nœud Set Alpha. Le RenderLayer actif lui fournit le titre en entrée Image. De nouveau, le nœud AlphaOver combine (en utilisant les valeurs alpha) la spirale de fond et l'image avec canal alpha du titre pour produire l'image finale. Notez le bouton ConvertPre-Multiply désactivé: cela produit une image finale où le titre laisse transparaître l'image de fond, même là où elle est transparente, vous permettant de superposer des images les unes au-dessus des autres.

Utiliser le nœud "SetAlpha" pour coloriser une image N&B

Utiliser SetAlpha pour coloriser une image.

Dans cet exemple, notez comme la couleur bleue de l'entrée Image du nœud Set Alpha teinte la spirale. Vous pouvez utiliser le contrôle échantillon de cette entrée, avec le système de nœud ci-dessus, pour ajouter une couleur homogène à une image N&B.

Utilisez la valeur de l'entrée Alpha du nœud SetAlpha pour contrôler l'intensité de la colorisation. Reliez l'image N&B et la sortie de SetAplha aux prises d'entrée d'un nœud AlphaOver, pour coloriser n'importe quelle image N&B. Notez le bouton ConvertPre-Multiply activé, ce qui indique au nœud AlphaOver de ne pas multiplier les valeurs alpha des deux images entre elles.

Nœud "ID Mask"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsID Mask

Nœud ID Mask.

Ce nœud utilise la passe indice d'objet (Object Index pass, voyez le nœud Render Layers) pour produire un masque alpha anti-aliasé pour l'indice d'objet sélectionné. Le masque est opaque là où l'objet se trouve, et transparent ailleurs. Si l'objet est partiellement transparent, le masque alpha reflète cette transparence. Cette fonction de postprocessing adoucit/efface les "escaliers" par interpolation.

Indice d'Objet
Les indices d'objet ne sont fournis que par un nœud Render Layers, ou enregistrés dans une image OpenEXR multi-couches.


Régler un Indice d'Objet.

Vous pouvez spécifier, pour n'importe quel objet de votre scène, un indice d'objet (comme ci-dessus, partie droite de l'image, l'objet sélectionné a un indice de 2). Lors du rendu, si la passe Object Index est activée, l'indice de notre objet sera de 2, et régler un nœud ID Mask sur 2 montrera où il se trouve dans l'image.

Ce nœud est trèèèèès pratique pour – entre autre – enlever les artefacts produits par le nœud Defocus, ou le système de nœud DoF, là où des objets proches de la caméra sont "sur" des objets éloignés.

Exemples

Exemple.

Dans cet exemple, le cube rouge de gauche a pour indice d'objet (PassIndex) 1, et le cube de droite, 2. Là où les deux cubes s'intersectent, il y aura un effet d'escalier, une pixelisation, notable, car ils se rencontrent avec un angle important et sont de couleurs différentes. En utilisant le masque de l'objet 1, qui est adouci (anti-aliasé) aux bords, relié (avec l'image de départ) à un nœud Mix réglé sur Multiply pour multiplier les bords adoucis avec l'image de base, on obtient une image débarrassée de ces artefacts désagréables. Ainsi adouci(e)s, les Rolling Stones n'amassent pas mousse (comprend qui peut!).

Notez que le masque retourne du blanc là où l'objet est "vraiment" visible par la caméra (il n'y a rien entre elle et lui), et du noir pour les parties de l'objet cachées par d'autres objets, que ceux-ci soient (partiellement) transparents ou non. Cela signifie que même si vous pouvez voir sur le rendu ces parties "cachées" par d'autres objets transparents, le masque les rendra noires (et pas, par ex., en nuances de gris…).

Nœud "Math"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsMath

Nœud Math.

Ce nœud effectue l'opération mathématiques sélectionnée sur une image ou un tampon. Toutes les fonctions mathématiques courantes sont supportées. Si une seule image est placée en entrée, la fonction sera appliquée à tous les pixels de celle-ci en prenant la constante définie dans l'autre entrée comme deuxième paramètre. Choisissez une fonction en cliquant sur la liste déroulante (fonction Addition sélectionnée par défaut).

Les fonctions trigonométriques (Sine – sinus, Cosine – cosinus, et Tangent – tangente) n'utilisent qu'une entrée (prise supérieure), et la considèrent comme étant en radians (c-à-d qu'elles ont une période de  – ~=6.28 – elles retrouvent les mêmes valeurs pour 0.0, , , etc.)

Blender 2.44+

Bug connu: La prise d'en haut doit recevoir une image si celle du bas est laissée en valeur constante.

Exemples

Z-Masque manuel
Exemple

Cet exemple a une scène en entrée via le nœud Render Layers supérieur, constituée d'un cube à peu près à 10 BU (Unités Blender) de la caméra. Le nœud Render Layers du bas fournit une scène ("FlyCam") avec un plan couvrant la moitié gauche de la vue, à 7 BU de la caméra. Tous les deux passent par leur nœuds Map Value respectifs pour diviser leur canal Z (profondeur) par 20 (c-à-d le multiplier par 0.05!), et le limiter à l'intervalle (Min, Max) de (0.0, 1.0).

Pour la fonction Minimum, le nœud sélectionne ces Z-valeurs les plus proches de la caméra: il choisit donc les "pixels" du plans pour la moitié gauche, et la partie droite du cube. L'arrière plan ayant une Z-valeur infinie, elle est ramenée à 1.0 (blanc pur).

Dans l'exemple Maximum, les Z-valeurs maximum sont sélectionnées: à gauche, le cube et son arrière-plan, à droite, l'arrière-plan du plan (à l'infini, ramené à 1.0, donc plus éloigné que le cube!).

Utiliser la fonction "Sine" pour pulser
Manual-Compositing-Node-Math Sine.jpg

Cet exemple a un nœud Time produisant une progression linéaire de 0.0 à 1.0 sur 101 images. Le curseur (ligne verticale verte) indique que l'image 25 est activée, donnant une valeur de 0.25. Cette valeur est multipliée par , et donne 1.0 une fois passée par la fonction Sine; nous savons tous que sin(2π/4) = sin(π/2) = +1.0.

Puisque la fonction Sine peut produire des valeurs entre -1.0 et +1.0, Le nœud Map Value les "mappe" entre 0.0 et 1.0, en ajoutant 1 (de 0.0 à 2.0), puis les multipliant par 0.5 (division par deux). Le nœud ColorRamp par défaut convertit alors ces valeurs en nuances de gris. Ainsi, le gris moyen correspond à la sortie 0.0 de la fonction sinus, le noir à -1.0, et le blanc à 1.0. Comme vous pouvez le constater, sin(π/2) = 1.0! Comme d'avoir votre propre calculette visuelle à couleurs! Animer ce système permet d'obtenir une séquence cyclique de transitions douces entre nuances de gris.

Utilisez cette fonction pour, par exemple, faire varier le canal Alpha d'une image et produire un effet de fondu "oscillant"; modifier un canal Z pour déplacer une scène dans/hors du plan focal; modifier un canal couleur pour la faire "pulser"…

Éclairer/Redistribuer un canal
Manual-Compositing-Node-Math Multiply.jpg

Cet exemple a un nœud MathMultiply augmentant la luminance (canal Y) de l'image pour la rendre plus lumineuse. Notez que vous devriez utiliser un nœud Map Value avec Min et Max activés pour limiter les valeurs de sortie à l'intervalle valide. Avec cette approche vous pourriez utiliser une fonction logarithmique pour faire une image HDR (haute dynamique). Pour cet exemple particulier, il serait probablement plus simple d'utiliser un nœud Bright/Contrast pour un simple contrôle sur la luminosité.

Quantizer/Restreindre le nombre de couleurs

Dans cet exemple, nous voulons restreindre la sortie des couleurs à 256 valeurs possibles seulement. Les utilisations de cet "effet" incluent par exemple une prévisualisation de ce que donnera notre image sur un écran 8-bits de téléphone portable. Pour réaliser cela, il nous faut restreindre les valeurs R, G et B de tout pixel à certaines valeurs, de telle façon qu'une fois combinées, elles ne puissent produire plus de 256 couleurs. Le nombre de couleurs possibles est le produit du nombre de valeurs possibles de chaque canal: Q = R × G × B.

Puisque qu'il y a trois canaux et 256 couleurs, nous avons une certaine flexibilité sur la quantization de chaque canal, puisque nombreuses sont les combinaisons de R×G×B qui donnent 256. Par exemple, si {R,G,B} = {4,4,16}, alors 4 × 4 × 16 = 256. De même, {6,6,7} donnerait 252 couleurs possibles. La différence d'aspect entre {4,4,16} et {6,6,7} est que la première distribution aura moins de nuances de rouge et de vert, mais beaucoup de nuances de bleu. La seconde distribution est bien plus équilibrée. Pour obtenir une meilleure qualité d'image avec peu de couleurs, donnez plus de valeurs possibles aux couleurs prédominantes de l'image.

Théorie
Deux approches pour quantizer vers 6 valeurs.

Pour accomplir cette quantization d'une image vers 256 couleurs, utilisons la distribution {6,6,7}. Pour séparer un intervalle continu de valeurs entre 0.0 et 1.0 (l'ensemble des valeurs Rouge, par ex.) en six valeurs, nous devons construire un algorithme, une fonction, qui prend n'importe quelle valeur en entrée, mais ne produit qu'une des six valeurs possibles en sortie, comme le montre l'image ci-contre. Nous voulons inclure 0.0 comme noir total, plus cinq autre valeurs réparties uniformément. L'approche montrée nous donne {0.0, 0.2, 0.4, 0.6, 0.8, 1.0}. 1.0/5 = 0.2, ce qui nous donne l'écartement entre les différentes valeurs quantifiées.

Donc, pour obtenir des nuances bien réparties, nous voulons que les valeurs inférieures ou égales à 0.16 produisent la valeur 0.0; que les valeurs entre 0.16 et 0.33 produisent la valeur 0.2; que les valeurs entre 0.33 et 0.5 produisent la valeur 0.4; et ainsi de suite, jusqu'aux valeurs entre 0.83 et 1.0 qui doivent produire la valeur 1.0.

Fonction f(x)
Une fonction algébrique est constituée d'opérations mathématiques "de base" (addition, soustraction, multiplication, sinus, cosinus, etc.) qui opèrent sur une valeur d'entrée pour produire la valeur de sortie voulue.


Tableau montrant le fonctionnement d'une fonction de quantization.


La théorie derrière cette fonction est la "troncation mise à l'échelle" ("scaled truncation"). Supposons que nous voulions une fonction mathématique qui, pour un valeur dans l'intervalle (0.0, 1.0), comme 0.552, produit la valeur la plus proche de l'ensemble {0.0, 0.2, 0.4, 0.6, 0.8, 1.0}. Nous pouvons donc imaginer qu'il nous faut "étendre" nos valeurs sur un intervalle (0.0, 6.0) pour que nous puissions nous "débarrasser" des virgules et obtenir des entiers. Donc, avec six valeurs, comment faire cela? Il nous suffit de multiplier les valeurs d'entrée par 6, ce qui nous donne bien des valeurs comprises entre 0.0 et 6.0. Nous souhaitons une répartition correcte, et puisque nous utilisons la fonction d'arrondi (round, voyez le tableau ci-contre), nous voulons que toute valeur "autour" d'un nombre entier donne ce nombre entier. Donc, nous décalons de -0.5 toutes les valeurs; puis la fonction d'arrondi ramène ces valeurs à des nombres entiers de l'ensemble {0, 1, 2, 3, 4, 5}: nous obtenons bien six valeurs. Il ne nous reste plus qu'à les diviser par 5 pour revenir à un intervalle (0.0, 1.0), qui peut être ensuite recombiné avec les autres canaux de couleur. Vous obtenez donc la fonction:

f(x,n) = round(xn - ½) / (n-1)

n est le nombre de valeurs de sortie possibles, et x est la couleur du pixel d'entrée, et f(x,n) est la valeur de sortie. Il n'y a qu'un petit problème: la valeur d'entrée 1.0 donne en sortie 1.2, ce qui est une valeur invalide. Cela car la fonction Round() applique la convention, qui veut que 5.5 est arrondi à 6. Donc, en soustrayant 0.501 (au lieu de 0.500), nous compensons cela: 6.0 - 0.501 = 5.499, arrondi à 5. À l'autre bout du spectre, le noir pur, 0.0 - 0.501 = -0.501, mais comme Round() ne retourne que des valeurs positives, il l'arrondit quand même à 0.

Parfois, utiliser un tableau (ou même une feuille de calcul dans un tableur!) peut vous aider à comprendre comment organiser et connecter les nœuds entre eux pour obtenir le résultat voulu. Pas à pas, à travers les différentes étapes de la fonction, avec par exemple n=6 et x=0.70: localisez la ligne du tableau ayant en entrée la valeur 8-bits 179 (valeur Réelle de 0.7). Multiplié par 6, donne 4.2. Moins 0.5, donne 3.7, arrondi à 4. 4 divisé par 5 (n-1) donne 0.6. Donc, f(0.7, 6) = 0.8, soit 153 en 8-bits. Vous pouvez constater que cette même valeur 8-bits est produite pour un intervalle de valeurs d'entrée. Yeah! Geek Rule! Voilà comment "programmer" Blender pour faire du "compositing algébrique". Pensez à remercier votre prof si vous avez compris!

Réalité
Manual-Compositing-Node-Math Quantize-Red.jpg

Pour implémenter cette fonction dans Blender, considérez le système de nœuds ci-dessus. D'abord, passez l'image au nœud Separate RGB. Pour le canal Rouge, nous relions quatre nœuds Math pour réaliser la fonction définie précédemment: un qui multiplie par n (6), un qui décale les valeurs de -0.5 (soustraction), un qui effectue l'arrondi, et le dernier qui divise par n-1 (5). Donc, les transformations font passer l'ensemble des valeurs de {0.01.0} à {0.06.0}, puis {-0.55.5}, l'arrondi aux entiers les plus proches restreint alors les valeurs à {0, 1, 2, 3, 4, 5} (car cette fonction effectue un arrondi à l'inférieur – NdT: troncature???), et pour finir, la division par 5 qui nous donne des valeurs dans l'ensemble {0.0, 0.2, 0.4, 0.6, 0.8, 1.0}.

Le résultat est donc que la sortie est limitée à quelques valeurs discrètes, séparées grâce à la fonction d'arrondi du troisième nœud Math. Vous n'avez plus qu'à copier ces quatre nœuds pour les canaux Vert et Bleu, pour obtenir le système de nœuds ci-dessus. Pour obtenir la répartition 6:6:7, nous réglons les trois nœuds multiplicateurs à {6, 6, 7}, et les nœuds diviseurs à {5, 5, 6}.

Si vous faites de tout ça un groupe de nœuds, vous pourrez aisément le réutiliser dans d'autres projets. Pensez alors à utiliser des nœuds d'entrée Value pour donner les différentes valeurs constantes des nœuds Math, cela vous évitera d'avoir à le faire à la main et diminuera les risques d'erreur.

Résumé

Normalement, un rendu est effectué avec une profondeur de couleurs sur 24 ou 32 bits, et chaque pixel peut être d'une couleur parmi des millions de possibilités. Le système de nœuds donné en exemple ci-dessus prend chacun des trois canaux rouge, vert, bleu, et les normalise vers quelques valeurs seulement. Quand ces trois canaux sont recombinés, chaque couleur ne peut plus être que l'une des 252 possibilités.

Bien que notre exemple utilise les nœuds Separate/Combine RGB pour séparer les couleurs, d'autre paires Separate/Combine sont également utilisables. Si vous utilisez des valeurs YUV, rappelez-vous que les composantes U et V de cet espace de couleur sont comprises dans l'intervalle (-0.5, 0.5), vous devrez donc (par exemple) leur rajouter 0.5 pour obtenir des valeurs entre 0.0 et 1.0, effectuer la quantization, puis leur soustraire de nouveau 0.5 pour les ramener dans leur intervalle standard.

Les formats d'image Jpeg et PNG continueront à enregistrer vos images quantizées dans leur profondeur de couleur normale (par exemple, 24 bits pour du Jpeg), mais la taille du fichier produit sera très réduite, car cette réduction du nombre de couleurs réduit très fortement le nombre d'informations à stocker.

Vous n'êtes pas obligé de réduire la profondeur de couleur de manière égale pour chaque canal. Par exemple, si le bleu est la couleur dominante de votre image, pour en préserver la qualité, vous pourriez réduire le rouge à deux valeurs, le vert à quatre, et laisser au bleu 256/(2*4) = 32 valeurs. Si vous utilisez le système HSV, vous pourriez réduire saturation et valeur à deux valeurs (0.0 et 1.0 – multiplication par 2 et division par… 1!), et laisser à la teinte les 64 valeurs des 6 bits restants.

Vous pouvez bien sûr également utiliser ce système de nœuds pour quantizer d'autres canaux: Alpha, Vector (vitesse), z-valeurs, et ainsi de suite (attention: les valeurs de ces deux derniers "canaux" ne sont pas limitées par un intervalle, elles peuvent être (très) supérieures à 1.0 ou (très) inférieures à 0.0!).

Nœuds "Separate/Combine"

Tous ces nœuds font essentiellement la même chose: ils séparent une image en (ou recombine une image à partir de) ses canaux de couleurs composantes. Chaque type supporte le canal Alpha (transparence). Il existe plusieurs moyens de représenter la couleur d'une image, appelés "espaces de couleur". Blender supporte plusieurs espaces de couleur:

  • RGB (ou RVB en français): Les trois composantes (Red pour Rouge, Green pour Vert, et Blue pour Bleu) de la synthèse lumineuse additive, surtout utilisé en informatique (format de transfert de l'image vers la plupart des moniteurs informatiques).
  • HSV (ou TSV en français): Trois valeurs, souvent considérées comme plus intuitives que le RGB (quasiment réservé à l'informatique):
    • Hue (ou Teinte): la teinte de la couleur (en quelque sorte, sélectionne une "couleur" de l'arc-en-ciel);
    • Saturation: la quantité de teinte dans la couleur (du désaturé – niveaux de gris – au saturé – couleurs les plus vives);
    • Value (ou Valeur): la luminosité de la couleur (de "l'absence" de lumière – noir – à la pleine lumière – couleur "totale", ou blanc si Saturation à 0.0).
  • YUV: Espace de couleur utilisé par certains standards vidéo (comme la TV analogique PAL – européenne). Y représente la luminance (quantité de lumière), et U et V sont deux coordonnées "abstraites" représentant la chrominance (~= couleur).
  • YCbCr: Espace de couleur voisin du précédent, utilisé par la TV numérique, et la vidéo HD en général (HDTV, HDMI [la nouvelle Péritel], …). Comme avec YUV, Y représente la luminance, et Cr et Cb représentent la chrominance rouge et la chrominance bleue (la chrominance verte se calcule à partir des trois autres canaux).

Voyez Wikipedia pour plus de détails sur les espaces de couleur.

Nœuds "Separate/Combine RGBA"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsSeparate RGBA

Nœud Separate RGBA.

Ce nœud sépare une image en ses canaux rouge (Red), vert (Green), bleu (Blue) et Alpha. Il y a une prise pour chaque canal, à droite.

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsCombine RGBA

Nœud Combine RGBA.

Ce nœud combine en une seule image couleur quatre images d'entrée monochromes, considérées comme les quatre canaux RGBA. Il vous permet de "reconstruire" une image après avoir travaillé sur ses composantes RGBA individuellement.

Exemples
Manual-Compositing-Covert-CombineRGBA.png

Dans ce premier exemple, nous prenons le canal Alpha et le floutons, puis le recombinons avec les canaux couleur. Dans une scène, les bords des objets seront ainsi adoucis, un peu comme avec l'anti-aliasing. Utiliser ce système lorsque vous ajoutez des éléments CG à une vidéo, pour enlever les bords durs. En animant cet effet sur une plus grande échelle, l'objet semblera en train d'essayer de se synchroniser (se "phaser"?) dans notre espace temporel (effet sci-fi!).

Manual-Compositing-Covert-CombineRGBA2.png

Dans ce sympathique petit système, nous passons le canal rouge en vert et le canal vert à la fois en rouge et en bleu (en enlevant donc complètement le canal bleu). Très mignon. Très marrant.

Nœuds "Separate/Combine HSVA"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsSeparate HSVA

Nœud Separate HSVA.

Ce nœud sépare une image en ses canaux teinte (Hue), saturation (Saturation), valeur (Value) et Alpha. Il y a une prise pour chaque canal, à droite.

Utilisez et manipulez les canaux séparés dans plusieurs buts: pour réaliser un réglage des couleurs, ou du compositing… Par exemple, vous pourriez amplifier le canal Value (en utilisant le nœud MathMultiply pour rendre toutes les couleurs plus claires. Vous pourriez rendre une image plus relaxante en diminuant (via un nœud MathDivide ou Map Value) le canal Saturation. Vous pourriez isoler un intervalle spécifique de couleurs (en limitant le canal Hue avec le nœud ColorRamp), et modifier celles-ci (avec un nœud MixAdd/Substract).

Nœuds "Separate/Combine YUVA"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsSeparate YUVA

Nœud Separate YUVA.

Ce nœud convertit une image RGBA dans l'espace de couleur YUVA, puis sépare les canaux qui sont alors disponibles sur leurs propres prises de sortie pour être manipulés indépendamment. Notez que les valeurs U et V sont réparties sur l'intervalle -0.5 à +0.5.

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsCombine YUVA

Nœud Combine YUVA.

Combine les canaux en une unique image. Si vous ne reliez pas une ou plusieurs prises d'entrée, la valeur spécifiée dans le bouton numérique sera prise pour toute l'image.

Nœuds "Separate/Combine YCbCrA"

Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsSeparate YCbCrA

Nœud Separate YCbCrA.

Ce nœud convertit une image RGBA dans l'espace de couleur YCbCrA, puis sépare les canaux qui sont alors disponibles sur leurs propres prises de sortie pour être manipulés indépendamment:

  • Y: Luminance, 0.0=noir, 1.0=blanc;
  • Cb: Chrominance Bleu;
  • Cr: Chrominance Rouge.
Note:
Si vous faites passer ces canaux dans un ColorRamp pour ajuster leurs valeurs, utilisez l'interpolation de couleur Cardinale pour une représentation précise. Une interpolation Ease (quadratique) sur le canal luminance (Y) donne un effet de haut contraste.


Panneau: Node EditorNode Composition

Menu: ⇧ ShiftAConvertorsCombine YCbCrA

Nœud Combine YCbCrA.

Bon, je pense que vous commencez à saisir le principe, et j'ai bien essayé de trouver une autre manière originale d'écrire la même chose, mais rien à faire. Donc, vous devrez comprendre ce nœud tout seul (dur!).