Dessiner "Dessiner une fougère par programme" en Python

J'ai profité de la série "Dessin de fougère par programmation" et l'ai également écrite en Python.

• Dessinez la fougère avec le programme-Procédez à feu vif
• Dessiner "Dessiner une fougère par programme" avec Dart --Qiita
• Dessiner "Dessiner une fougère par programme" avec Go --Qiita
• Clojure - Dessin de fougères par programmation - Qiita

Résultat de sortie

Code source

Version d'appel récursif

• Une version d'appel récursive similaire à l'original.
• Je l'ai bien écrit en utilisant lambda dans la définition de la fonction.
• Nécessite la bibliothèque d'images PIL (Python Imaging Library) ou Pillow.

import random

N = 20
xm = 0
ym = 0.5
h = 0.6

width = 500
height = 500

W1x = lambda x, y: 0.836 * x + 0.044 * y
W1y = lambda x, y: -0.044 * x + 0.836 * y + 0.169
W2x = lambda x, y: -0.141 * x + 0.302 * y
W2y = lambda x, y: 0.302 * x + 0.141 * y + 0.127
W3x = lambda x, y: 0.141 * x - 0.302 * y
W3y = lambda x, y: 0.302 * x + 0.141 * y + 0.169
W4x = lambda x, y: 0
W4y = lambda x, y: 0.175337 * y

def f(im, k, x, y):
    if 0 < k:
        f(im, k - 1, W1x(x, y), W1y(x, y))
        if random.random() < 0.3:
            f(im, k - 1, W2x(x, y), W2y(x, y))
        if random.random() < 0.3:
            f(im, k - 1, W3x(x, y), W3y(x, y))
        if random.random() < 0.3:
            f(im, k - 1, W4x(x, y), W4y(x, y))
    else:
        s = 490
        im.putpixel((int(x * s + width * 0.5), int(height - y * s)), (0, 128, 0))

if __name__ == '__main__':
    from PIL import Image
    im = Image.new("RGB", (width, height), (255, 255, 255))
    f(im, N, 0, 0)
    im.show()

C'est un peu peu attrayant car la fonction f () transmet les arguments liés à l'image et la logique de dessin doit être écrite à l'intérieur de la fonction, alors j'ai essayé d'utiliser un peu plus Pythonic.

Appel récursif + version générateur

• Le générateur est utilisé pour renvoyer le résultat de l'appel récursif avec yield.
• La logique de dessin a pu sortir de la fonction f ().

import random

N = 20
xm = 0
ym = 0.5
h = 0.6

width = 500
height = 500

W1x = lambda x, y: 0.836 * x + 0.044 * y
W1y = lambda x, y: -0.044 * x + 0.836 * y + 0.169
W2x = lambda x, y: -0.141 * x + 0.302 * y
W2y = lambda x, y: 0.302 * x + 0.141 * y + 0.127
W3x = lambda x, y: 0.141 * x - 0.302 * y
W3y = lambda x, y: 0.302 * x + 0.141 * y + 0.169
W4x = lambda x, y: 0
W4y = lambda x, y: 0.175337 * y

def f(k, x, y):
    if 0 < k:
        for p in f(k - 1, W1x(x, y), W1y(x, y)):
            yield p
        if random.random() < 0.3:
            for p in f(k - 1, W2x(x, y), W2y(x, y)):
                yield p
        if random.random() < 0.3:
            for p in f(k - 1, W3x(x, y), W3y(x, y)):
                yield p
        if random.random() < 0.3:
            for p in f(k - 1, W4x(x, y), W4y(x, y)):
                yield p
    else:
        s = 490
        yield x * s + width * 0.5, height - y * s

if __name__ == '__main__':
    from PIL import Image
    im = Image.new("RGB", (width, height), (255, 255, 255))
    for p in f(N, 0, 0):
        im.putpixel((int(p[0]), int(p[1])), (0, 128, 0))
    im.show()

Résumé

• Technique de combinaison appel récursif + générateur
• Logique de dessin séparée et logique de calcul des coordonnées
• J'aime le générateur qui peut être écrit légèrement avec yield.