J'ai donc une mission où je dois reproduire l'image ci-dessous en utilisant la tortue. Je connais le concept de base du réglage du stylo sur une couleur, puis de la création d'une ligne, de la coordonnée 1 y vers le bas et de la répétition. Mais ce que j'ai besoin de savoir, c'est comment savoir de quelle couleur créer chaque ligne. J'ai entendu parler d'interpolation linéaire mais je n'ai aucune idée de ce que cela signifie.

affectation

0
KauDar123 23 sept. 2020 à 21:26

2 réponses

Meilleure réponse

Voici comment vous pouvez le faire avec toutes les couleurs de début et de fin, sans avoir à coder quoi que ce soit en dur. Notez que ceci est un exemple montrant les opérations effectuées sur chaque canal de couleur; ci-dessous, je vais vous montrer comment le faire de manière plus succincte.

# the starting color
initial_color = (0.60156, 0, 0.99218)  # (154, 0, 254)

# the final, target color
target_color = (0.86328, 0.47656, 0.31250)  # (221, 122, 80)

number_of_rows=10  # how many rows we're painting

# get the total difference between each color channel
red_difference=target_color[0]-initial_color[0]
green_difference=target_color[1]-initial_color[1]
blue_difference=target_color[2]-initial_color[2]

# divide the difference by the number of rows, so each color changes by this amount per row
red_delta = red_difference/number_of_rows
green_delta = green_difference/number_of_rows
blue_delta = blue_difference/number_of_rows

# display the color for each row
for i in range(0, number_of_rows):
    # apply the delta to the red, green and blue channels
    interpolated_color=(initial_color[0] + (red_delta * i), 
                        initial_color[1] + (green_delta * i),
                        initial_color[2] + (blue_delta * i))
    print(interpolated_color)

Production:

(0.60156, 0.0, 0.99218)
(0.627732, 0.047656, 0.9242119999999999)
(0.653904, 0.095312, 0.856244)
(0.680076, 0.14296799999999998, 0.788276)
(0.706248, 0.190624, 0.720308)
(0.7324200000000001, 0.23828, 0.6523399999999999)
(0.758592, 0.28593599999999997, 0.5843719999999999)
(0.784764, 0.333592, 0.516404)
(0.8109360000000001, 0.381248, 0.44843599999999995)
(0.8371080000000001, 0.42890399999999995, 0.3804679999999999)

Notez que cela s'arrête avant la couleur finale, vous pouvez soit utiliser la couleur cible pour votre dernière ligne, soit simplement augmenter la plage à number_of_rows + 1.

Voici le code ci-dessus mais très simplifié - il donne le même résultat:

# simpler version - we can skip the diffs and just get the deltas, and store all 3 colors in a list
deltas=[(target_color[i] - initial_color[i])/number_of_rows for i in range(3)]
for j in range(0, number_of_rows):
    interpolated_color=tuple([initial_color[i] + (deltas[i] * j) for i in range(3)])
    print(interpolated_color)
0
Random Davis 23 sept. 2020 à 19:19

Ok donc j'ai pu répondre à ma question. Ce que j'ai fait a été de prendre la différence entre le code RVB des 2 couleurs, puis de la diviser par la quantité que je voulais que le dégradé dure, puis de l'ajouter au RVB une ligne à la fois.

import turtle
jeff = turtle.Turtle()
jeff.speed('fastest')
def gradient():
 jeff.penup()
 jeff.goto(-450, 200)
 jeff.pendown()
 r = 154.0
 g = 0.0
 b = 254.0
 for i in range(125):
  jeff.pencolor(r, g, b)
  jeff.fd(900)
  jeff.penup()
  jeff.seth(270)
  jeff.fd(1)
  jeff.seth(180)
  jeff.pendown()
  r += 0.268
  g += 0.488
  b -= 0.696
  jeff.pencolor(r, g, b)
  jeff.fd(900)
  jeff.penup()
  jeff.seth(270)
  jeff.fd(1)
  jeff.seth(0)
  jeff.pendown()
  r += 0.268
  g += 0.488
  b -= 0.696
gradient():

C'est un peu rudimentaire, mais ça marche

0
KauDar123 23 sept. 2020 à 19:10