Calculer la valeur RGB pour une plage de valeurs pour créer de la chaleur de la carte

Je suis en train de créer une carte de chaleur avec python. Pour cela, je dois attribuer une valeur RVB de chaque valeur dans la plage de valeurs possibles. J'ai pensé à changer de couleur du bleu (valeur minimale) plus de vert à rouge (valeur maximale).

L'image d'exemple ci-dessous explique comment j'ai pensé à la composition des couleurs: Nous avons une gamme allant de 1 (un bleu pur) à 3 (rouge pur), 2 est entre ressemblait par vert.

J'ai lu sur l'interpolation linéaire et a écrit une fonction qui est (plus ou moins) traite le calcul pour une certaine valeur dans la plage comprise entre un minimum et un maximum et renvoie un RVB tuple. Il utilise if et elif conditions (qui ne me rend pas complètement heureux):

def convert_to_rgb(minimum, maximum, value):
    minimum, maximum = float(minimum), float(maximum)    
    halfmax = (minimum + maximum) / 2
    if minimum <= value <= halfmax:
        r = 0
        g = int( 255./(halfmax - minimum) * (value - minimum))
        b = int( 255. + -255./(halfmax - minimum)  * (value - minimum))
        return (r,g,b)    
    elif halfmax < value <= maximum:
        r = int( 255./(maximum - halfmax) * (value - halfmax))
        g = int( 255. + -255./(maximum - halfmax)  * (value - halfmax))
        b = 0
        return (r,g,b)

Cependant je me demande si on pourrait écrire une fonction pour chaque valeur de couleur sans à l'aide de if conditions. Quelqu'un a une idée? Merci beaucoup!

OriginalL'auteur aldorado | 2013-12-26

def rgb(minimum, maximum, value):
    minimum, maximum = float(minimum), float(maximum)
    ratio = 2 * (value-minimum) / (maximum - minimum)
    b = int(max(0, 255*(1 - ratio)))
    r = int(max(0, 255*(ratio - 1)))
    g = 255 - b - r
    return r, g, b

halfmax devrait être calculé comme (minimum - maximum) / 2 et value/halfmax devrait être (value - minimum)/halfmax, sinon il ne fonctionne correctement que lorsque minimum est 1 et maximum est 3. Voir: codereview.stackexchange.com/a/64720/7641
Merci pour la capture! Réponse de mise à jour.

OriginalL'auteur John1024

14

Voici une autre façon de faire que, bien que pas aussi absolument courte que possible, elle est beaucoup plus générale puisqu'elle n'a pas été codé en dur pour votre jeu de couleurs. Cela signifie qu'il peut également être utilisé pour interpoler linéairement une gamme de valeurs spécifiée sur une variable de la taille de la palette de couleurs arbitraires.

Aussi noter que les couleurs pourraient avoir été interpolé dans d'autres espaces de couleurs donne des résultats qui peuvent être plus agréable que dans d'autres. Ceci est illustré dans les différents résultats obtenus à partir des deux réponses que j'ai soumise à une question connexe intitulé Gamme pseudocolor.
```
import sys
EPSILON = sys.float_info.epsilon  # Smallest possible difference.
def convert_to_rgb(minval, maxval, val, colors):
# "colors" is a series of RGB colors delineating a series of
# adjacent linear color gradients between each pair.
# Determine where the given value falls proportionality within
# the range from minval->maxval and scale that fractional value
# by the total number in the "colors" pallette.
i_f = float(val-minval) / float(maxval-minval) * (len(colors)-1)
# Determine the lower index of the pair of color indices this
# value corresponds and its fractional distance between the lower
# and the upper colors.
i, f = int(i_f // 1), i_f % 1  # Split into whole & fractional parts.
# Does it fall exactly on one of the color points?
if f < EPSILON:
return colors[i]
else:  # Otherwise return a color within the range between them.
(r1, g1, b1), (r2, g2, b2) = colors[i], colors[i+1]
return int(r1 + f*(r2-r1)), int(g1 + f*(g2-g1)), int(b1 + f*(b2-b1))
if __name__ == '__main__':
minval, maxval = 1, 3
steps = 10
delta = float(maxval-minval) / steps
colors = [(0, 0, 255), (0, 255, 0), (255, 0, 0)]  # [BLUE, GREEN, RED]
print('  Val       R    B    G')
for i in range(steps+1):
val = minval + i*delta
r, g, b = convert_to_rgb(minval, maxval, val, colors)
print('{:.3f} -> ({:3d}, {:3d}, {:3d})'.format(val, r, g, b))
```
De sortie numérique:
```
  Val       R    G    B
1.000 -> (  0,   0, 255)
1.200 -> (  0,  50, 204)
1.400 -> (  0, 101, 153)
1.600 -> (  0, 153, 101)
1.800 -> (  0, 204,  50)
2.000 -> (  0, 255,   0)
2.200 -> ( 51, 203,   0)
2.400 -> (102, 152,   0)
2.600 -> (153, 101,   0)
2.800 -> (203,  51,   0)
3.000 -> (255,   0,   0)
```
Voici la sortie visualisé comme un dégradé horizontal:

J'ai utilisé ce code et il fonctionne merveilleusement, même avec de très différentes cartes de couleurs (rouge, orange, blanc). Cette solution peut être améliorée avec des commentaires dans votre code pour nous aider à comprendre la théorie et la pratique ici. Par exemple, quel est le point de trouver la différence entre le flotteur et l'int ci-dessus?
Une façon de voir c'est que colors spécifier une ligne à travers une 2D de l'espace couleur sur laquelle le linéaire d'entrée est mappé.
La soustraction est l'une des étapes impliquées dans le processus de séparation de l'entier et fractionnaire des parties de la virgule flottante résultat de la première interpolation linéaire (aka lerp) qui est en cours. La partie entière est i et la partie fractionnaire est f. Ces deux valeurs sont ensuite utilisées pour faire encore un autre lerp pour calculer la moyenne pondérée entre colors[i] et colors[i+1] dans la palette (à l'aide de f, qui se situent dans la gamme de 0 à 1.0). C'est une technique que j'ai imaginé il y a des années pour faire des dégradés lisses.
Une seule chose de mal avec ce point de vue de ce qui se passe est que la plupart des espaces de couleurs sont en 3D (par exemple, RVB, YIQ, et HLS), pas 2D.
Vrai. Une ligne de couleur 3D de l'espace.

OriginalL'auteur martineau
2

Vous pouvez souvent éliminer un if avec un index dans un tableau de deux valeurs. Python manque un opérateur conditionnel ternaire, mais cela fonctionne:
```
r = [red_curve_1, red_curve_2][value>=halfmax]
g = [green_curve_1, green_curve_2][value>=halfmax]
b = [blue_curve_1, blue_curve_2][value>=halfmax]
```
Remplacer le *_curve_1 et *_curve_2 expressions avec les constantes ou des pentes ou des courbes à gauche ou à droite du milieu, respectivement.

Je vais laisser ces substitutions pour vous, mais pour exemple:
- red_curve_1 et blue_curve_2 sont tout simplement 0
- green_curve_1 est 255*(value-minimum)/(halfmax-minimum)
- etc.
C'est juste ce que j'appellerais le "conditionnel de l'indexation". BTW, Python t ont un opérateur ternaire qu'il appelle une Expression Conditionnelle. Il permet à des déclarations comme r = red_curve_1 if value >= halfmax else red_curve_2 -- bien que, je suppose, à l'aide de la rendrait encore plus évident que l'approche n'était pas vraiment se débarrasser de la if conditions de l'OP cherche à éliminer.
Merci pour le rappel à propos de l'expression conditionnelle. Il les lit de moins obscurément que la condition d'indexation j'ai proposé. Mais comme vous le dites, OP veut apparemment à se débarrasser de if. (L'expression conditionnelle approche a aussi l'avantage de ne pas évaluer tout avant de retourner à sa suite.)

OriginalL'auteur Darren Stone
1

"Nous avons le sentiment que l'intensité de la lumière sur une échelle logarithmique
– une exponentielle de l'intensité de la bretelle sera vu comme un processus linéaire
rampe" https://courses.cs.washington.edu/courses/cse455/09wi/Lects/lect11.pdf

De la https://en.wikipedia.org/wiki/RGB_color_model: "une entrée de l'intensité de la valeur RVB (0.5, 0.5, 0.5) sorties seulement environ 22% de la pleine luminosité (1.0, 1.0, 1.0), au lieu de 50%"

Cela conduit à l'brunâtre bavure à 2.5 @martineau exemple, où il doit être le jaune et le cyan à 1,5 pour obtenir une bonne teinte de gradient.

Ainsi, la formule à utiliser pour obtenir le gradient n'est pas nécessairement ce que vous voulez. (désolé de ne pas répondre directement à votre question)

Mais il peut être pratique pour convertir VHS ou HLS de couleur modèle de l'espace, et l'utilisation H (teinte) et de l'utiliser comme entrée, et de convertir de retour RVB pour des fins d'affichage.
c'est à dire:
```
colorsys.hsv_to_rgb(value, 1, 1)
```
https://docs.python.org/2/library/colorsys.html

OriginalL'auteur Maarten Albers

Vous devez vous connecter pour publier un commentaire.