Julekuler, stjernehimler og tilfeldighet

Hvilken av de to stjernehimlene over ser mest «naturlig» ut? Når vi lager kunst med programmering, blir tegningene våre fort veldig ryddige og perfekte. Dette kan føre til veldig vakre mønstere, men naturen er ikke helt perfekt, så det kan også se litt «kunstig» ut. Et triks for å få litt av naturens «ikke-perfekthet» inn in kodekunsten vår er å bruke tilfeldighet. Å legge på litt tilfeldighet er en teknikk som er hyppig brukt i bildekunst, spilldesign, animasjon og musikk

Bildekunst

Generativ kunst, variant 10print.

Prosedurale teksturer for dataspill

Illustrasjon av proseduralt genererte teksturer (illustrasjon av Drummyfish)

Proseduralt landskap

Proseduralt generert landskapsbilde (illustrasjon av Levyznin)

Musikk

Bilde av en modulær sythesizer. Slike kan ofte spille av lydsekvenser i en tilfeldig rekkefølge (Bilde av Muff på Flickr (CC-BY 2.0))

Tilfeldighet med Python

Under er et eksempel på broderi som vi skal lage i denne guiden.

Det første vi kan starte med er å se hvordan vi kan lage tilfeldige tall i Python. Nedenfor er en kodesnutt som printer ut et tilfeldig tall.

import random

tilfeldig_tall = random.randint(1, 6)
print(tilfeldig_tall)

6

Linje 1:

Importerer random-biblioteket som vi kan bruke for å trekke tilfeldige tall.

Linje 3:

Bruker random.randint-funksjonen til å trekke et tilfeldig tall fra og med 1 til og med 6 og lagrer dette tilfeldige tallet i tilfeldig_tall-variabelen.

Prøv selv:

• Kjør koden mange ganger. Får du forskjellig hver gang?

• Endre så det istedenfor gir et tall mellom 50 og 100

• Kjør koden mange ganger igjen, får du andre tall ut nå?

Dette kan vi bruke for å gjøre broderiene våre mer spennende. Her er kode for å generere en enkel stjerne

from turtlethread import Turtle

nål = Turtle()
with nål.running_stitch(25):
    for stråle in range(6):
        strålelengde = 100
        nål.forward(strålelengde)
        nål.backward(strålelengde)
        nål.right(60)

nål.visualise()

For å gjøre den mer naturlig og interessant kan vi legge på litt tilfeldighet på lengden til strålene:

import random
from turtlethread import Turtle

nål = Turtle()
with nål.running_stitch(25):
    for stråle in range(6):
        strålelengde = random.uniform(80, 120)
        nål.forward(strålelengde)
        nål.backward(strålelengde)
        nål.right(60)

nål.visualise()

Linje 7:

Trekker et tilfeldig tall mellom 80 og 120 og lagrer det i strålelengde variabelen.

Her ser vi at stjernen ser litt mer tilfeldig ut og dermed også litt mer naturlig.

Prøv selv:

• Endre så stråle-lengden er mellom 25 og 125 istedenfor 80 og 120. Hvordan endrer dette uttrykket til stjernen?

• Endre koden slik at antall stråler også er et tilfeldig tall. (HINT: Vinkelen mellom hver stråle må være 360 / antall_stråler)

Klikk her for å se programmet slik det skal være om du har gjort det rett:

import random
from turtlethread import Turtle

nål = Turtle()
with nål.running_stitch(25):
    antall_stråler = random.randint(3, 10)
    for stråle in range(antall_stråler):
        strålelengde = random.uniform(25, 125)
        nål.forward(strålelengde)
        nål.backward(strålelengde)
        nål.right(360 / antall_stråler)

nål.visualise()

Obs

Pass på at koden stemmer med løsningsforslaget over før du går videre.

Nå har vi tegnet en tilfeldig stjerne, men vi kan ta det hele ett steg lengre ved å tegne flere tilfeldige stjerner plassert tilfeldig over en stjernehimmel. Vi kan f.eks. bruke goto-kommandoen og la nåla gå til en tilfeldig plass på stoffet for hver stjerne. Koden nedenfor tegner en stjernehimmel med fire tilfeldige stjerner plassert tilfeldig ut over stjernehimmelen.

import random
from turtlethread import Turtle

nål = Turtle()
with nål.running_stitch(25):
    antall_stjerner = 4
    for stjerne in range(antall_stjerner):
        x = random.randint(-250, 250)
        y = random.randint(-250, 250)
        nål.goto(x, y)

        antall_stråler = random.randint(3, 10)
        for stråle in range(antall_stråler):
            strålelengde = random.randint(25, 100)
            nål.forward(strålelengde)
            nål.backward(strålelengde)
            nål.right(360 / antall_stråler)

nål.visualise()

Linje 6:

Definerer en antall_stjerner variabel som sier hvor mange stjerner vi ønsker å tegne

Linje 7:

Starter løkka vi bruker for å tegne flere stjerner

Linje 8-9:

Trekker tilfeldige koordinater mellom -250 og 250 for hver av stjernene våre

Linje 10:

Beveger nåla til den tilfeldige posisjonen hver av stjernene skal ha

Her har vi en fin, tilfeldig stjernehimmel! Men nå broderer vi også en linje mellom stjernene. Det kan gi en kul effekt som kanskje kan minne om stjernetegn, men hvis vi ikke ønsker å ha en slik linje kan vi bruke jump stitch til å la nåle hoppe uten å sy mellom hver stjerne.

import random
from turtlethread import Turtle

nål = Turtle()

antall_stjerner = 4
for stjerne in range(antall_stjerner):
    x = random.randint(-250, 250)
    y = random.randint(-250, 250)
    with nål.jump_stitch():
        nål.goto(x, y)

    with nål.running_stitch(25):
        antall_stråler = random.randint(3, 10)
        for stråle in range(antall_stråler):
            strålelengde = random.randint(25, 100)
            nål.forward(strålelengde)
            nål.backward(strålelengde)
            nål.right(360 / antall_stråler)

nål.visualise()

Linje 6-7:

Løkka som itererer over stjernene er flyttet ut av kodeblokka hvor nåla har sømmeinstrukser. Vi flytta løkka siden vi ønsker å bruke forskjellige sømmeinstrukser når vi tegner stjernene og når vi flytter nåla mellom stjernene.

Linje 10:

Gir nåla instruks om å flytte seg uten å sy sting. Dersom broderimaskina støtter det vil den klippe tråden om den allerede har sydd noen sting.

Linje 13:

Her er kodeblokka hvor vi tegner hver enkelt stjerne.

Prøv selv:

Endre koden slik at du tegner et tilfeldig antall stjerner på stjernehimmelen

Klikk her for å se programmet slik det skal være om du har gjort det rett:

import random
from turtlethread import Turtle

nål = Turtle()

antall_stjerner = random.randint(1, 10)
for stjerne in range(antall_stjerner):
    x = random.randint(-250, 250)
    y = random.randint(-250, 250)
    with nål.jump_stitch():
        nål.goto(x, y)

    with nål.running_stitch(25):
        antall_stråler = random.randint(3, 10)
        for stråle in range(antall_stråler):
            strålelengde = random.randint(25, 100)
            nål.forward(strålelengde)
            nål.backward(strålelengde)
            nål.right(360 / antall_stråler)

nål.visualise()

Obs

I dette eksempelet bruker vi randint-funksjonen i random-biblioteket, som trekker tall fra og med første argument, til og med andre argument. Hvis vi istedenfor hadde brukt randint-funksjonen i numpy.random eller pylab, så ville vi ikke kunne fått det andre argumentet. For eksempel vil random.randint(1, 6) gi oss et av tallene 1, 2, 3, 4, 5 eller 6, mens numpy.random.randint(1, 6) og pylab.randint(1, 6) vil bare gi oss et av tallene 1, 2, 3, 4 eller 5.

Prøv selv:

• Lag ditt eget broderimønster med tilfeldighet. Nedenfor er et galleri som du kan ta inspirasjon fra.

Eksempelbroderi med tilfeldighet

Eksempel 1

Kode

import random
from turtlethread import Turtle

nål = Turtle()

with nål.running_stitch(20):
    for side in range(20):
        sidelengde = random.randint(5 * side, 20*side)
        nål.forward(sidelengde)
        vinkel = random.randint(45, 90)
        nål.right(vinkel)

nål.visualise()

Eksempel 2

Kode

from turtlethread import Turtle
import random

nål = Turtle()

with nål.running_stitch(20):
    nål.circle(10)
    for sirkel in range(5):
        x = random.randint(-200, 200)
        y = random.randint(-200, 200)
        nål.goto(x, y)
        radius = random.randint(5, 40)
        nål.circle(radius)

nål.visualise()

Eksempel 3

Kode

import random
from turtlethread import Turtle

nål = Turtle()

with nål.running_stitch(30):
    # Tegn ett snøfnugg med seks sider
    for side in range(6):

        # Bestem hvor mange grener vi ønsker
        antall_grener = random.randint(2, 5)

        # Gi det speilsymmetri
        for retning in [1, -1]:

            nål.forward(30)

            # Legg til en liten gren i starten
            nål.right(120 * retning)
            nål.forward(30)
            nål.backward(30)
            nål.left(120 * retning)

            # Legg til et tilfeldig antall grener hvor hver gren har tilfeldig vinkel og lengde
            for gren in range(antall_grener):
                nål.forward(30)
                grenvinkel = random.randint(50, 70)
                grenlengde = random.randint(20, 30)

                nål.right(grenvinkel * retning)
                nål.forward(grenlengde)
                nål.backward(grenlengde)
                nål.left(grenvinkel * retning)

            nål.forward(30)
            nål.backward(60 + 30*antall_grener)

        nål.right(60)

nål.visualise()

Eksempel 4

Kode

import random
from turtlethread import Turtle

nål = Turtle()

with nål.running_stitch(30):

    # Tegn stjerna i toppen av juletreet
    nål.right(360 / 5*2)
    for p in range(5):
        nål.forward(30)
        nål.right(150)
        nål.forward(30)
        nål.left(150)
        nål.right(360/5)
    
    # Reset back to start
    nål.home()

    # Tegn treet med julekuler på
    retning = 1
    for gren_nummer in range(1, 10):
        retning *= -1  # Snu nåla hver runde
        y = 30 * gren_nummer
        x = 10 * gren_nummer
        
        # Legg på litt tilfeldighet mtp hvor grena ender
        jitter_x = random.randint(-x//3, x//3)
        jitter_y = random.randint(-10, 10)

        # Gå til der grena ender
        nål.goto(retning * x + jitter_x, y + jitter_y)

        # Tegn julekule
        radius = random.randint(10, 20)
        nål.circle(-radius)

nål.visualise()