pygame Archivi - Petar Karan

23 Aprile 2021 Nessun commento

[python] Semplice simulazione dell’espansione di un contagio tipo COVID19 con PyGame e OpenGL

Ripropongo un esercizio in Python simile a quello svolto in JavaScript in Simulazione sull’espansione del contagio da Coronavirus (COVID-19)

Questa volta utilizzeremo PyGame e OpenGL per costruire la simulazione, similmente a quanto fatto nel precedente articolo. Il programma è stato svolto in Python 3.9.

import pygame as pg
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

import math
from copy import copy
import random

import matplotlib.pyplot as plt

dati = [
    {"infetto":False,"velocita":10,"numero":200},
    {"infetto":False,"velocita":0,"numero":10},
    {"infetto":True,"velocita":10,"numero":1}
    ]

class Simulazione:

    def __init__(s, w = 1200, h = 800, dati = []):

        s.posizioni = []

        s.ratio = w / h
        s.w = w
        s.h = h

        pg.init()
        schermo = (w,h)
        pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

        # in movimento
        for d in dati:
            for i in range(d["numero"]):
                x = random.randint(-w/2+10,w/2-10)
                y = random.randint(-h/2+10,h/2-10)
                a = 2*math.pi*random.random()
                s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

        infezioni = []

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    quit()
        
            glClearColor(1.0, 1.0, 1.0, 1.0)
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

            tot_infetti = 0

            for p in s.posizioni:
                p.muovi()
                s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)
                if p.infetto and not p.guarito: tot_infetti += 1

            infezioni.append(tot_infetti)

            s.controllaUrti()

            pg.display.flip()
            pg.time.wait(10)

            if tot_infetti == 0:
                pg.quit()
                break

        plt.plot(range(len(infezioni)),infezioni)
        plt.title("curva contagi")
        plt.xlabel("periodo")
        plt.ylabel("contagi")
        plt.show()
        

    def controllaUrti(s):
        for p in s.posizioni:
            if copy(p) in s.posizioni:
                pass

    def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):
        raggio = 2 * raggio / s.w
        x = 2 * x / s.w
        y = 2 * y / s.h
        r,g,b = colore
        glColor3f(r,g,b)
        glBegin(GL_POLYGON)
        for v in range(lati):
            angolo = float(v) * 2.0 * math.pi / lati
            glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)
        glEnd()

class Punto:

    def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):
        s.x = x
        s.y = y
        s.v = v
        s.alfa = alfa
        s.id = id(s)
        s.colore = colore
        s.raggio = raggio
        s.urtato = False
        s.guarito = False
        s.infetto = infetto
        s.durata_infezione = 120 # cicli

    def __eq__(s,o):
        if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:
            salfa = s.alfa
            oalfa = o.alfa
            if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):
                s.infetto = o.infetto = True
            if not s.urtato: s.urto(oalfa)
            if not o.urtato: o.urto(salfa)
            return True
        else:
            return False

    def muovi(s):

        s.urtato = False

        if s.infetto: s.durata_infezione -= 1
        if s.durata_infezione < 0:
            s.guarito = True
            s.colore=(0.0, 1.0, 0.0)
        if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)
        
        dx = s.v * math.cos(s.alfa)
        dy = s.v * math.sin(s.alfa)

        if s.x+dx >= 600 or s.x+dx <= -600:
            s.alfa = math.pi-s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        if s.y+dy >= 400 or s.y+dy <= -400:
            s.alfa = -s.alfa
            dx = s.v * math.cos(s.alfa)
            dy = s.v * math.sin(s.alfa)

        s.x += dx
        s.y += dy

        if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:
            s.v = -s.v

    def urto(s,theta):
        s.alfa = s.alfa+theta
        s.urtato = True


Simulazione(dati=dati)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

import pygame as pg

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

from copy import copy

import random

import matplotlib.pyplot as plt

dati = [

{"infetto":False,"velocita":10,"numero":200},

{"infetto":False,"velocita":0,"numero":10},

{"infetto":True,"velocita":10,"numero":1}

]

class Simulazione:

def __init__(s, w = 1200, h = 800, dati = []):

s.posizioni = []

s.ratio = w / h

s.w = w

s.h = h

pg.init()

schermo = (w,h)

pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

# in movimento

for d in dati:

for i in range(d["numero"]):

x = random.randint(-w/2+10,w/2-10)

y = random.randint(-h/2+10,h/2-10)

a = 2*math.pi*random.random()

s.posizioni.append(Punto(x,y,d["velocita"],a,infetto=d["infetto"]))

infezioni = []

while True:

for event in pg.event.get():

if event.type == pg.QUIT:

pg.quit()

quit()

glClearColor(1.0, 1.0, 1.0, 1.0)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

tot_infetti = 0

for p in s.posizioni:

p.muovi()

s.disegnaPunto(p.x,p.y,raggio=p.raggio,colore=p.colore)

if p.infetto and not p.guarito: tot_infetti += 1

infezioni.append(tot_infetti)

s.controllaUrti()

pg.display.flip()

pg.time.wait(10)

if tot_infetti == 0:

pg.quit()

break

plt.plot(range(len(infezioni)),infezioni)

plt.title("curva contagi")

plt.xlabel("periodo")

plt.ylabel("contagi")

plt.show()

def controllaUrti(s):

for p in s.posizioni:

if copy(p) in s.posizioni:

pass

def disegnaPunto(s,x,y,lati=10,raggio=20,colore=(0.0, 0.0, 1.0)):

raggio = 2 * raggio / s.w

x = 2 * x / s.w

y = 2 * y / s.h

r,g,b = colore

glColor3f(r,g,b)

glBegin(GL_POLYGON)

for v in range(lati):

angolo = float(v) * 2.0 * math.pi / lati

glVertex2f(math.cos(angolo)*raggio + x,math.sin(angolo)*raggio*s.ratio + y)

glEnd()

class Punto:

def __init__(s,x,y,v=3,alfa=0,colore=(0.0, 0.0, 1.0),raggio=5,infetto=False):

s.x = x

s.y = y

s.v = v

s.alfa = alfa

s.id = id(s)

s.colore = colore

s.raggio = raggio

s.urtato = False

s.guarito = False

s.infetto = infetto

s.durata_infezione = 120 # cicli

def __eq__(s,o):

if math.sqrt((s.x - o.x)**2+(s.y - o.y)**2) < s.raggio * 2 and s.id != o.id:

salfa = s.alfa

oalfa = o.alfa

if (s.infetto and not s.guarito) or (o.infetto and not o.guarito):

s.infetto = o.infetto = True

if not s.urtato: s.urto(oalfa)

if not o.urtato: o.urto(salfa)

return True

else:

return False

def muovi(s):

s.urtato = False

if s.infetto: s.durata_infezione -= 1

if s.durata_infezione < 0:

s.guarito = True

s.colore=(0.0, 1.0, 0.0)

if s.infetto and not s.guarito: s.colore=(1.0, 0.0, 0.0)

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.x+dx >= 600 or s.x+dx <= -600:

s.alfa = math.pi-s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

if s.y+dy >= 400 or s.y+dy <= -400:

s.alfa = -s.alfa

dx = s.v * math.cos(s.alfa)

dy = s.v * math.sin(s.alfa)

s.x += dx

s.y += dy

if s.x >= 600 or s.x <= -600 or s.y >= 400 or s.y <= -400:

s.v = -s.v

def urto(s,theta):

s.alfa = s.alfa+theta

s.urtato = True

Simulazione(dati=dati)

Il risultato produrrà qualcosa di simile a questo:

Vedi articolo

26 Dicembre 2019 Nessun commento

[python] Disegnare un fiocco di neve con OpenGL, Python e pygame

Visto che siamo in tema natalizio vediamo come disegnare un fiocco di neve con Python, OpenGL e pygame.

Questo esercizio riprende in parte quanto già visto per disegnare un poligono sempre con Python e OpenGL.

Anzitutto assicuriamoci di avere installate le librerie PyOpenGL e pygame, qualora non le avessimo sarà sufficiente installarle mediante pip con i seguenti due comandi:

pip install PyOpenGL
pip install pygame

1 2	pip install PyOpenGL pip install pygame

Fatto questo possiamo cominciare a predisporre il nostro programma.

Anzitutto voglio fare un breve approfondimento su alcune funzioni che andremo ad utilizzare.

Cominciamo da gluPerspective. Questa funzione accetta 4 argomenti:

fovy: sostanzialmente l’angolo di visione in gradi, come illustrato nell’immagine di seguito
aspect ratio: il rapporto tra altezza e larghezza, sostanzialmente ci andiamo ad inserire il rapporto tra le dimensioni del nostro schermo (poi ne discutiamo meglio)
zNear: il piano più vicino dopo il quale comincia la visione
zFar: il piano più lontano al quale termina la visione

Risultato immagini per gluPerspective" — Immagine presa da GLUT and OpenGL by Robby T. Tan

Ricordiamoci che andremo a disegnare un oggetto in 3D, che dovrà essere posizionato all’interno del tronco di piramide definito dai due piani e dall’angolo di apertura. Se l’oggetto dovesse uscire da questo spazio semplicemente non risulterebbe visibile sullo schermo (o risulterebbe parzialmente tagliato). Da questo si capisce come l’angolo di apertura determinerà la prospettiva e lo spazio di interazione dell’oggetto. La situazione sostanzialmente è la seguente:

Per maggiori approfondimenti consiglio anche una lettura veloce a Perspective distortion (photography)

Dal momento che andrò a posizionare i nostri oggetti a partire da (0,0,0) voglio anche spostare il punto di visione (viewpoint) indietro, in modo da farceli entrare, altrimenti non sarebbero visibili. Per farlo utilizzo la funzione glTranslatef che prendere come argomenti i valori x, y e z sui quali effettuare la traslazione.

Infine voglio disegnare delle linee usando i rispettivi vertici. Per farlo dovrò aggiungere coppie di vertici alla “matrice del mondo” con il metodo glVertex3fv. Nel caso specifico posso disegnare una linea orizzontale che vada da (0,0,0) a (1,0,0) scrivendo le seguenti quattro righe di codice:

glBegin(GL_LINES)
glVertex3fv((0.0,0.0,0.0))
glVertex3fv((1.0,0.0,0.0))
glEnd()

glBegin(GL_LINES)

glVertex3fv((0.0,0.0,0.0))

glVertex3fv((1.0,0.0,0.0))

glEnd()

Se volessi disegnare un quadrato dovrei disegnare tutte le linee a coppie di vertici, nel modo seguente:

glBegin(GL_LINES)
glVertex3fv((0.0,0.0,0.0))
glVertex3fv((1.0,0.0,0.0))
        
glVertex3fv((1.0,0.0,0.0))
glVertex3fv((1.0,1.0,0.0))
        
glVertex3fv((1.0,1.0,0.0))
glVertex3fv((0.0,1.0,0.0))
        
glVertex3fv((0.0,1.0,0.0))
glVertex3fv((0.0,0.0,0.0))
        
glEnd()

glBegin(GL_LINES)

glVertex3fv((0.0,0.0,0.0))

glVertex3fv((1.0,0.0,0.0))

glVertex3fv((1.0,1.0,0.0))

glVertex3fv((0.0,1.0,0.0))

glVertex3fv((0.0,0.0,0.0))

glEnd()

Sostanzialmente quello che facciamo in questo caso potrebbe essere riassunto col seguente schema:

Disegniamo le varie linee del quadrato seguendo le direzioni delle frecce rosse.

Adesso se volessimo limitarci a disegnare un quadrato e farlo ruotare davanti alla telecamera potremmo scrivere il seguente programma:

import pygame as pg
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

import math

class FioccoDiNeve():

    def __init__(s):

        pg.init()
        schermo = (800,600)
        pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

        gluPerspective(30, (schermo[0]/schermo[1]), 0.1, 50)
        glTranslatef(0.0, 0.0, -5)

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    quit()

            glRotatef(1, 1, 1, 1)
            glClearColor(0, 0, 0.1, 1)
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

            s.quadrato()
            
            pg.display.flip()
            pg.time.wait(10)

    def quadrato(s):
        glBegin(GL_LINES)
        glVertex3fv((0.0,0.0,0.0))
        glVertex3fv((1.0,0.0,0.0))
        
        glVertex3fv((1.0,0.0,0.0))
        glVertex3fv((1.0,1.0,0.0))
        
        glVertex3fv((1.0,1.0,0.0))
        glVertex3fv((0.0,1.0,0.0))
        
        glVertex3fv((0.0,1.0,0.0))
        glVertex3fv((0.0,0.0,0.0))
        
        glEnd()


if __name__ == "__main__":
    
    FioccoDiNeve()

import pygame as pg

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

class FioccoDiNeve():

def __init__(s):

pg.init()

schermo = (800,600)

pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

gluPerspective(30, (schermo[0]/schermo[1]), 0.1, 50)

glTranslatef(0.0, 0.0, -5)

while True:

for event in pg.event.get():

if event.type == pg.QUIT:

pg.quit()

quit()

glRotatef(1, 1, 1, 1)

glClearColor(0, 0, 0.1, 1)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

s.quadrato()

pg.display.flip()

pg.time.wait(10)

def quadrato(s):

glBegin(GL_LINES)

glVertex3fv((0.0,0.0,0.0))

glVertex3fv((1.0,0.0,0.0))

glVertex3fv((1.0,1.0,0.0))

glVertex3fv((0.0,1.0,0.0))

glVertex3fv((0.0,0.0,0.0))

glEnd()

if __name__ == "__main__":

FioccoDiNeve()

Grazie a glClearColor(0, 0, 0.1, 1) coloriamo lo sfondo di un blu scuro. Eseguendo il programma vedremo qualcosa di simile:

Il quadrato sarà in movimento ovviamente, grazie alla funzione glRotatef che ruota la matrice del mondo.

Arrivati a questo punto ci manca solo di disegnare il fiocco di neve, ovvero preparare le coppie di vertici di tutte le linee del fiocco di neve stesso.

Per farlo voglio seguire il seguente schema:

Partiamo dal basso e disegniamo un ramo di lunghezza L. Prendiamo come riferimento un angolo α di 45° (ovvero π/4). Alla fine del ramo teniamo conto dell’angolo di arrivo e disegniamo altri due rami, ciascuno spostato di 45°. Procediamo in avanti ripetendo questo schema per n iterazioni.

Creiamo quindi due classi, una per il Fiocco e una per ciascun Ramo, nel modo seguente (nei commenti in Python ulteriori dettagli):

class Fiocco():

    # elenco di tutti i vertici, ovvero delle coppie di vertici
    __vertici = []
    # numero massimo di iterazioni
    __max = 4

    def __init__(s,iterazioni):

        # assegniamo il numero massimo di iterazioni
        s.__max = iterazioni
        
        # nodo iniziale
        inizio = Ramo(0.0,0.0,0.0,0.0,0)

        # aggiungiamo i due rami iniziali in alto
        s.aggRamo(0.0,1.0,inizio,0)

        # aggiungiamo i due rami iniziali in basso
        s.aggRamo(-math.pi,1.0,inizio,0)

    def aggRamo(s,alfa,l,genitore,iterazione):

        # generiamo il ramo di sinistra
        sx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa-math.pi/4.0,l/2.0)
        # prendiamo il vertice iniziale
        s.__vertici.append(sx.geti())
        # prendiamo il vertice finale
        s.__vertici.append(sx.getf())

        # generiamo il ramo di destra
        dx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa+math.pi/4.0,l/2.0)
        # prendiamo ancora una volta i vertici iniziali e finali
        s.__vertici.append(dx.geti())
        s.__vertici.append(dx.getf())

        # se l'iterazione corrente e' minore della massima consentita proseguiamo
        if iterazione < s.__max:
            # disegniamo a sinistra
            s.aggRamo(sx.getalfa(),l/2.0,sx,iterazione+1)
            # disegniamo a destra
            s.aggRamo(dx.getalfa(),l/2.0,dx,iterazione+1)

    # tiriamo fuori tutti i vertici
    def getVertici(s):
        return s.__vertici
        

class Ramo():

    # coordinate del vertice iniziale del ramo
    __xi = 0.0
    __yi = 0.0
    __zi = 0.0

    # coordinate del vertice finale del ramo
    __xf = 0.0
    __yf = 0.0
    __zf = 0.0

    # lunghezza del ramo
    __l = 1.0
    # angolo del ramo
    __alfa = 0.0

    #creiamo il ramo
    def __init__(s,x,y,z,alfa,l):
        s.__xi = x
        s.__yi = y
        s.__zi = z
        s.__l = l
        s.__alfa = alfa
        s.__calcola()

    # calcoliamo i valori finali del vertice
    def __calcola(s):
        
        s.__xf = math.cos(s.__alfa) * s.__l + s.__xi
        s.__yf = math.sin(s.__alfa) * s.__l + s.__yi

    # otteniamo la x del vertice finale
    def getxf(s):
        return s.__xf

    # otteniamo la y del vertice finale
    def getyf(s):
        return s.__yf

    # otteniamo l'angolo alfa
    def getalfa(s):
        return s.__alfa

    # otteniamo le coordinate del vertice iniziale
    def geti(s):
        return [s.__xi,s.__yi,s.__zi]

    # otteniamo le coordinate del vertice finale
    def getf(s):
        return [s.__xf,s.__yf,s.__zf]

class Fiocco():

# elenco di tutti i vertici, ovvero delle coppie di vertici

__vertici = []

# numero massimo di iterazioni

__max = 4

def __init__(s,iterazioni):

# assegniamo il numero massimo di iterazioni

s.__max = iterazioni

# nodo iniziale

inizio = Ramo(0.0,0.0,0.0,0.0,0)

# aggiungiamo i due rami iniziali in alto

s.aggRamo(0.0,1.0,inizio,0)

# aggiungiamo i due rami iniziali in basso

s.aggRamo(-math.pi,1.0,inizio,0)

def aggRamo(s,alfa,l,genitore,iterazione):

# generiamo il ramo di sinistra

sx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa-math.pi/4.0,l/2.0)

# prendiamo il vertice iniziale

s.__vertici.append(sx.geti())

# prendiamo il vertice finale

s.__vertici.append(sx.getf())

# generiamo il ramo di destra

dx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa+math.pi/4.0,l/2.0)

# prendiamo ancora una volta i vertici iniziali e finali

s.__vertici.append(dx.geti())

s.__vertici.append(dx.getf())

# se l'iterazione corrente e' minore della massima consentita proseguiamo

if iterazione < s.__max:

# disegniamo a sinistra

s.aggRamo(sx.getalfa(),l/2.0,sx,iterazione+1)

# disegniamo a destra

s.aggRamo(dx.getalfa(),l/2.0,dx,iterazione+1)

# tiriamo fuori tutti i vertici

def getVertici(s):

return s.__vertici

class Ramo():

# coordinate del vertice iniziale del ramo

__xi = 0.0

__yi = 0.0

__zi = 0.0

# coordinate del vertice finale del ramo

__xf = 0.0

__yf = 0.0

__zf = 0.0

# lunghezza del ramo

__l = 1.0

# angolo del ramo

__alfa = 0.0

#creiamo il ramo

def __init__(s,x,y,z,alfa,l):

s.__xi = x

s.__yi = y

s.__zi = z

s.__l = l

s.__alfa = alfa

s.__calcola()

# calcoliamo i valori finali del vertice

def __calcola(s):

s.__xf = math.cos(s.__alfa) * s.__l + s.__xi

s.__yf = math.sin(s.__alfa) * s.__l + s.__yi

# otteniamo la x del vertice finale

def getxf(s):

return s.__xf

# otteniamo la y del vertice finale

def getyf(s):

return s.__yf

# otteniamo l'angolo alfa

def getalfa(s):

return s.__alfa

# otteniamo le coordinate del vertice iniziale

def geti(s):

return [s.__xi,s.__yi,s.__zi]

# otteniamo le coordinate del vertice finale

def getf(s):

return [s.__xf,s.__yf,s.__zf]

Fatto tutte questo reintegriamo il tutto nella nostra classe iniziale FioccoDiNeve.

import pygame as pg
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

import math

class FioccoDiNeve():

    __vertici = []

    def __init__(s):

        s.creaFiocco()

        pg.init()
        schermo = (800,600)
        pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

        gluPerspective(30, (schermo[0]/schermo[1]), 0.1, 50)
        glTranslatef(0.0, 0.0, -5)

        while True:
            for event in pg.event.get():
                if event.type == pg.QUIT:
                    pg.quit()
                    quit()

            glRotatef(1, 1, 1, 1)
            glClearColor(0, 0, 0.1, 1)
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

            s.fiocco()
            
            pg.display.flip()
            pg.time.wait(10)

    def creaFiocco(s):
        fiocco = Fiocco(6)
        s.__vertici = fiocco.getVertici()

    def fiocco(s):
        glBegin(GL_LINES)

        for v in s.__vertici:
            glVertex3fv((v[0],v[1],v[2]))
        
        glEnd()

class Fiocco():

    # elenco di tutti i vertici, ovvero delle coppie di vertici
    __vertici = []
    # numero massimo di iterazioni
    __max = 4

    def __init__(s,iterazioni):

        # assegniamo il numero massimo di iterazioni
        s.__max = iterazioni
        
        # nodo iniziale
        inizio = Ramo(0.0,0.0,0.0,0.0,0)

        # aggiungiamo i due rami iniziali in alto
        s.aggRamo(0.0,1.0,inizio,0)

        # aggiungiamo i due rami iniziali in basso
        s.aggRamo(-math.pi,1.0,inizio,0)

    def aggRamo(s,alfa,l,genitore,iterazione):

        # generiamo il ramo di sinistra
        sx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa-math.pi/4.0,l/2.0)
        # prendiamo il vertice iniziale
        s.__vertici.append(sx.geti())
        # prendiamo il vertice finale
        s.__vertici.append(sx.getf())

        # generiamo il ramo di destra
        dx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa+math.pi/4.0,l/2.0)
        # prendiamo ancora una volta i vertici iniziali e finali
        s.__vertici.append(dx.geti())
        s.__vertici.append(dx.getf())

        # se l'iterazione corrente e' minore della massima consentita proseguiamo
        if iterazione < s.__max:
            # disegniamo a sinistra
            s.aggRamo(sx.getalfa(),l/2.0,sx,iterazione+1)
            # disegniamo a destra
            s.aggRamo(dx.getalfa(),l/2.0,dx,iterazione+1)

    # tiriamo fuori tutti i vertici
    def getVertici(s):
        return s.__vertici
        

class Ramo():

    # coordinate del vertice iniziale del ramo
    __xi = 0.0
    __yi = 0.0
    __zi = 0.0

    # coordinate del vertice finale del ramo
    __xf = 0.0
    __yf = 0.0
    __zf = 0.0

    # lunghezza del ramo
    __l = 1.0
    # angolo del ramo
    __alfa = 0.0

    #creiamo il ramo
    def __init__(s,x,y,z,alfa,l):
        s.__xi = x
        s.__yi = y
        s.__zi = z
        s.__l = l
        s.__alfa = alfa
        s.__calcola()

    # calcoliamo i valori finali del vertice
    def __calcola(s):
        
        s.__xf = math.cos(s.__alfa) * s.__l + s.__xi
        s.__yf = math.sin(s.__alfa) * s.__l + s.__yi

    # otteniamo la x del vertice finale
    def getxf(s):
        return s.__xf

    # otteniamo la y del vertice finale
    def getyf(s):
        return s.__yf

    # otteniamo l'angolo alfa
    def getalfa(s):
        return s.__alfa

    # otteniamo le coordinate del vertice iniziale
    def geti(s):
        return [s.__xi,s.__yi,s.__zi]

    # otteniamo le coordinate del vertice finale
    def getf(s):
        return [s.__xf,s.__yf,s.__zf]


if __name__ == "__main__":
    
    FioccoDiNeve()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

import pygame as pg

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

class FioccoDiNeve():

__vertici = []

def __init__(s):

s.creaFiocco()

pg.init()

schermo = (800,600)

pg.display.set_mode(schermo, DOUBLEBUF|OPENGL)

gluPerspective(30, (schermo[0]/schermo[1]), 0.1, 50)

glTranslatef(0.0, 0.0, -5)

while True:

for event in pg.event.get():

if event.type == pg.QUIT:

pg.quit()

quit()

glRotatef(1, 1, 1, 1)

glClearColor(0, 0, 0.1, 1)

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)

s.fiocco()

pg.display.flip()

pg.time.wait(10)

def creaFiocco(s):

fiocco = Fiocco(6)

s.__vertici = fiocco.getVertici()

def fiocco(s):

glBegin(GL_LINES)

for v in s.__vertici:

glVertex3fv((v[0],v[1],v[2]))

glEnd()

class Fiocco():

# elenco di tutti i vertici, ovvero delle coppie di vertici

__vertici = []

# numero massimo di iterazioni

__max = 4

def __init__(s,iterazioni):

# assegniamo il numero massimo di iterazioni

s.__max = iterazioni

# nodo iniziale

inizio = Ramo(0.0,0.0,0.0,0.0,0)

# aggiungiamo i due rami iniziali in alto

s.aggRamo(0.0,1.0,inizio,0)

# aggiungiamo i due rami iniziali in basso

s.aggRamo(-math.pi,1.0,inizio,0)

def aggRamo(s,alfa,l,genitore,iterazione):

# generiamo il ramo di sinistra

sx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa-math.pi/4.0,l/2.0)

# prendiamo il vertice iniziale

s.__vertici.append(sx.geti())

# prendiamo il vertice finale

s.__vertici.append(sx.getf())

# generiamo il ramo di destra

dx = Ramo(genitore.getxf(),genitore.getyf(),0.0,alfa+math.pi/4.0,l/2.0)

# prendiamo ancora una volta i vertici iniziali e finali

s.__vertici.append(dx.geti())

s.__vertici.append(dx.getf())

# se l'iterazione corrente e' minore della massima consentita proseguiamo

if iterazione < s.__max:

# disegniamo a sinistra

s.aggRamo(sx.getalfa(),l/2.0,sx,iterazione+1)

# disegniamo a destra

s.aggRamo(dx.getalfa(),l/2.0,dx,iterazione+1)

# tiriamo fuori tutti i vertici

def getVertici(s):

return s.__vertici

class Ramo():

# coordinate del vertice iniziale del ramo

__xi = 0.0

__yi = 0.0

__zi = 0.0

# coordinate del vertice finale del ramo

__xf = 0.0

__yf = 0.0

__zf = 0.0

# lunghezza del ramo

__l = 1.0

# angolo del ramo

__alfa = 0.0

#creiamo il ramo

def __init__(s,x,y,z,alfa,l):

s.__xi = x

s.__yi = y

s.__zi = z

s.__l = l

s.__alfa = alfa

s.__calcola()

# calcoliamo i valori finali del vertice

def __calcola(s):

s.__xf = math.cos(s.__alfa) * s.__l + s.__xi

s.__yf = math.sin(s.__alfa) * s.__l + s.__yi

# otteniamo la x del vertice finale

def getxf(s):

return s.__xf

# otteniamo la y del vertice finale

def getyf(s):

return s.__yf

# otteniamo l'angolo alfa

def getalfa(s):

return s.__alfa

# otteniamo le coordinate del vertice iniziale

def geti(s):

return [s.__xi,s.__yi,s.__zi]

# otteniamo le coordinate del vertice finale

def getf(s):

return [s.__xf,s.__yf,s.__zf]

if __name__ == "__main__":

FioccoDiNeve()

Se abbiamo fatto tutto correttamente otterremo il nostro fiocco di neve frattale ruotante in questo modo:

Vedi articolo