esercizi in python Archivi

26 Febbraio 2021 Nessun commento

[python] Semplice esercizio per riconoscere immagini di frutti con TensorFlow (machine learning)

Vogliamo realizzare un semplice programma in Python che sia in grado di riconoscere, utilizzando TensorFlow e machine learning, delle immagini di frutti.

Questo esercizio riprende i medesimi concetti già visti in: [python] Semplice esercizio su TensorFlow e il riconoscimento delle immagini nel gioco del Tris (Machine Learning)

Dato il seguente set di immagini (qui unite in una singola), vogliamo addestrare il programma a riuscire a riconoscere correttamente i frutti rappresentati:

Per farlo addestreremo il programma con altre immagini di training, suddivise rispettivamente in mele (che forse assomigliano più a dei pomodori), pere e banane:

Il risultato che vogliamo ottenere analizzando la prima immagine sarà qualcosa del genere (abbiamo tagliato l’immagine in tutte le sottoparti):

I tre numeri rappresentano la percentuale di probabilità per cui l’immagine sia, rispettivamente, una mela, una pera o una banana. Questo significa che la prima immagine è al 100% di probabilità una pera, mentre la seconda una banana ecc.

Il progetto si sviluppa in Python 3.7. Prima di procedere assicuriamoci di aver installato tutte le librerie necessarie, in particolare:

pip install Pillow
pip install numpy
pip install tensorflow
pip install matplotlib

pip install Pillow

pip install numpy

pip install tensorflow

pip install matplotlib

A questo punto prepariamo le immagini per il training ed il test. Attraverso le immagini di training alleneremo il nostro algoritmo, mentre useremo quelle per il test per verificare l’efficacia. Sottolineo ancora una volta come questo sia un esempio semplificato al massimo, utilizzando immagini semplici per non dover produrre una grande mole di dati sia per il training che per il test.

Per preparare le immagini dobbiamo tagliare i quattro file precedentemente preparati. A tale scopo creiamo una classe per elaborare le immagini nel modo seguente (nei commenti c’è la descrizione delle singole operazioni):

class ElaboraImmagini:

    # acquisiamo i dati per le immagini, con i seguenti argomenti
    # orig: lista che contiene il percorso alle immagini originali da tagliare
    # dest: cartella di destinazione nella quale salvare le immagini
    # n: numero di immagini in colonna
    # w: larghezza delle singole immagini
    def __init__(s, orig = [], dest = None, n = 4, w = 100):

        # prendiamo il percorso originale della cartella nella quale ci troviamo
        # ovvero dove si trova lo script di Python
        s.__orig_dir = os.path.dirname(os.path.realpath(__file__))
        # impostiamo la variabile privata con la lista delle immagini da elaborare
        s.__orig = orig
        # creiamo la cartella di destinazione
        s.__dest = s.__orig_dir + "\\" + dest

        # se la cartella non esiste...
        if not os.path.exists(s.__dest):
            # ... allora la creiamo
            os.makedirs(s.__dest)

        # salviamo n e w in variabili private
        s.__n = n
        s.__w = w

        # chiamiamo l'elaborazione delle immagini
        s.elabora()

    # creiamo il metodo per elaborare le immagini
    def elabora(s):

        # per ogni file nella lista di origine
        for f in s.__orig:
            # creiamo il nome del file con il percorso assoluto
            nome_file = s.__orig_dir + "\\" + f
            # per ogni riga...
            for i in range(s.__n):
                # ... e per ogni colonna
                for j in range(s.__n):
                    # ritagliamo le immagini con l'apposito metodo
                    # al metodo verranno passate le coordinate come 4-tupla
                    # calcolata da righe e colonne, oltre al nome del file da creare
                    # il nome lo creiamo come: nome del file senza estensione + conteggio
                    # quindi se stiamo tagliando banane.png avremo banane_x.png
                    # in questo modo potremo riconoscere le immagini dai nomi dei file
                    s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \
                                nome_file , \
                                os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

    # ritaglia con i seguenti argomenti:
    # coor: posizione left, top, right, bottom, come se fossero x e y insomma
    # nome_file: nome del file corrente
    # nome_dest: nome del file da creare
    def ritaglia(s, coor, nome_file, nome_dest):
        # apriamo il file
        img = Image.open(nome_file)
        # ritagliamolo
        cropped = img.crop(coor)
        # creiamo la posizione di salvataggio
        file_salvato = s.__dest + "\\" + nome_dest
        # salviamo
        cropped.save(file_salvato)

class ElaboraImmagini:

# acquisiamo i dati per le immagini, con i seguenti argomenti

# orig: lista che contiene il percorso alle immagini originali da tagliare

# dest: cartella di destinazione nella quale salvare le immagini

# n: numero di immagini in colonna

# w: larghezza delle singole immagini

def __init__(s, orig = [], dest = None, n = 4, w = 100):

# prendiamo il percorso originale della cartella nella quale ci troviamo

# ovvero dove si trova lo script di Python

s.__orig_dir = os.path.dirname(os.path.realpath(__file__))

# impostiamo la variabile privata con la lista delle immagini da elaborare

s.__orig = orig

# creiamo la cartella di destinazione

s.__dest = s.__orig_dir + "\\" + dest

# se la cartella non esiste...

if not os.path.exists(s.__dest):

# ... allora la creiamo

os.makedirs(s.__dest)

# salviamo n e w in variabili private

s.__n = n

s.__w = w

# chiamiamo l'elaborazione delle immagini

s.elabora()

# creiamo il metodo per elaborare le immagini

def elabora(s):

# per ogni file nella lista di origine

for f in s.__orig:

# creiamo il nome del file con il percorso assoluto

nome_file = s.__orig_dir + "\\" + f

# per ogni riga...

for i in range(s.__n):

# ... e per ogni colonna

for j in range(s.__n):

# ritagliamo le immagini con l'apposito metodo

# al metodo verranno passate le coordinate come 4-tupla

# calcolata da righe e colonne, oltre al nome del file da creare

# il nome lo creiamo come: nome del file senza estensione + conteggio

# quindi se stiamo tagliando banane.png avremo banane_x.png

# in questo modo potremo riconoscere le immagini dai nomi dei file

s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \

nome_file , \

os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

# ritaglia con i seguenti argomenti:

# coor: posizione left, top, right, bottom, come se fossero x e y insomma

# nome_file: nome del file corrente

# nome_dest: nome del file da creare

def ritaglia(s, coor, nome_file, nome_dest):

# apriamo il file

img = Image.open(nome_file)

# ritagliamolo

cropped = img.crop(coor)

# creiamo la posizione di salvataggio

file_salvato = s.__dest + "\\" + nome_dest

# salviamo

cropped.save(file_salvato)

Per elaborare i due gruppi di immagini ci sarà sufficiente chiamare:

ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")
ElaboraImmagini(["frutta.png"],"TEST")

1 2	ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING") ElaboraImmagini(["frutta.png"],"TEST")

A questo punto creiamo una classe per elaborare questa base dati, nel modo seguente:

class CreaDBImmagini:

    # creiamo delle "costanti" giusto per codificare il tipo di output
    # che vogliamo ottenere passando il tipo al costruttore
    TEST = 0
    TRAINING = 1

    # qui codifichiamo la frutta
    MELE = 0
    PERE = 1
    BANANE = 2

    # passiamo al costruttore due argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)
    def __init__(s, path, tipo = 0):
        s.__path = path
        # lista che conterrà le immagini in byte
        s.__immagini = []
        # lista contenente le descrizioni
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo la cartella con le immagini
    def elabora(s):
        # per ciascuna immagine nella cartella
        for f in os.listdir(s.__path):
            # creiamo il percorso del file
            percorso_file = s.__path + "\\" + f
            # se il file esiste (per come è costruito il metodo non c'è
            # motivo per cui il file non debba esistere, in realtà
            # verifichiamo che eventualmente non sia una cartella)
            if os.path.isfile(percorso_file):
                # leggiamo l'immagine usando la libreria Pillow
                img = Image.open(percorso_file)
                # trasformiamo i byte dell'immagine in un array di NumPy
                aimg = np.asarray(img)
                # aggiungiamo tale array alla lista delle immagini
                s.__immagini.append(aimg)

                # se elaboriamo le immagini per il training...
                if s.__tipo == s.TRAINING:
                    # preniamo il tipo del frutto dal nome
                    # ricordiamoci che i nomi sono del tipo mela_1.png
                    # quindi spezziamo il nome su _ e prendiamo la prima
                    # parte
                    frutto = f.split("_")[0]
                    # codifichiamo il nome con il numero
                    if frutto == "mele": desc = s.MELE
                    if frutto == "pere": desc = s.PERE
                    if frutto == "banane": desc = s.BANANE
                    # aggiungiamo tale numero alla lista delle descrizioni
                    s.__descrizioni.append(desc)

                # in caso di test ci accontentiamo dei meri nomi dei file
                if s.__tipo == s.TEST:
                    s.__descrizioni.append(f)

    # metodo per restituire la lista di immagini e descrizioni
    # codificate come array di NumPy
    def get(s):
        return (np.array(s.__immagini), np.array(s.__descrizioni))

class CreaDBImmagini:

# creiamo delle "costanti" giusto per codificare il tipo di output

# che vogliamo ottenere passando il tipo al costruttore

TEST = 0

TRAINING = 1

# qui codifichiamo la frutta

MELE = 0

PERE = 1

BANANE = 2

# passiamo al costruttore due argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)

def __init__(s, path, tipo = 0):

s.__path = path

# lista che conterrà le immagini in byte

s.__immagini = []

# lista contenente le descrizioni

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo la cartella con le immagini

def elabora(s):

# per ciascuna immagine nella cartella

for f in os.listdir(s.__path):

# creiamo il percorso del file

percorso_file = s.__path + "\\" + f

# se il file esiste (per come è costruito il metodo non c'è

# motivo per cui il file non debba esistere, in realtà

# verifichiamo che eventualmente non sia una cartella)

if os.path.isfile(percorso_file):

# leggiamo l'immagine usando la libreria Pillow

img = Image.open(percorso_file)

# trasformiamo i byte dell'immagine in un array di NumPy

aimg = np.asarray(img)

# aggiungiamo tale array alla lista delle immagini

s.__immagini.append(aimg)

# se elaboriamo le immagini per il training...

if s.__tipo == s.TRAINING:

# preniamo il tipo del frutto dal nome

# ricordiamoci che i nomi sono del tipo mela_1.png

# quindi spezziamo il nome su _ e prendiamo la prima

# parte

frutto = f.split("_")[0]

# codifichiamo il nome con il numero

if frutto == "mele": desc = s.MELE

if frutto == "pere": desc = s.PERE

if frutto == "banane": desc = s.BANANE

# aggiungiamo tale numero alla lista delle descrizioni

s.__descrizioni.append(desc)

# in caso di test ci accontentiamo dei meri nomi dei file

if s.__tipo == s.TEST:

s.__descrizioni.append(f)

# metodo per restituire la lista di immagini e descrizioni

# codificate come array di NumPy

def get(s):

return (np.array(s.__immagini), np.array(s.__descrizioni))

Fatto tutto questo possiamo anzitutto costruire il nostro modello, che andremo a salvare, nella stessa cartella dell’eseguibile come modello_frutta.

Per creare il modello anzitutto preleviamo le immagini con:

train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

1	train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

Costruiamo poi il nostro modello:

modello = keras.Sequential([
            keras.layers.Flatten(input_shape=(100,100,3)),
            keras.layers.Dense(128, activation="relu"),
            keras.layers.Dense(3, activation="softmax")
        ])

modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100,100,3)),

keras.layers.Dense(128, activation="relu"),

keras.layers.Dense(3, activation="softmax")

])

I tre layer servono rispettivamente per:

keras.layers.Flatten(input_shape=(100,100,3)) ci permette di ridurre ad una dimensione la matrice tridimensionale delle immagini (100 righe x 100 colonne x 3 byte di colore) contenente 30.000 byte. Per farlo dobbiamo ricordarci lo shape dei dati passati in input, che provengono da una lista, contenente a sua volte una lista tridimensionale.
keras.layers.Dense(128, activation="relu") applica l’algoritmo relu ai dati ottenuti dal primo layer, su 128 nodi (il numero è arbitrario, scelto per via principalmente sperimentale)
keras.layers.Dense(3, activation="softmax") applichiamo l’algoritmo softmax per ridurre tutte le informazioni a 3 nodi, rappresentati i 3 dati di output che vogliamo ottenere.

Aggiungo una nota per comprendere meglio il passaggio dei layer intermedi. Il primo layer è necessario per ridurre i dati in input ad una forma univoca, mentre l’ultimo layer serve a portare in output i dati che passiamo come “descrizione”, ovvero output conosciuto, durante il training. I layer intermedi invece possono essere molteplici, e servono per manipolare i diversi aspetti dell’informazione, tentando di ridurla ad una schematizzazione ricorrente. Per capire meglio questo processo immaginiamo di voler interpretare un’immagine (non succede la medesima cosa, ma l’esempio descrive bene il concetto generale).

Se avessimo un immagine come questa di seguito, avremmo a che fare con un’enorme quantità di dettagli diversi da analizzare. Essendo l’immagine grande 1200 x 761 pixel, potremmo dire di aver bisogno di 1200×761 = 913.200 nodi per interpretare ogni informazione singolarmente, quindi potremmo decidere di utilizzare un layer con 913.200 nodi (o neuroni). Questo vorrebbe dire che diamo importanza ad OGNI singolo nodo e quindi ad OGNI singolo dettaglio dell’informazione. Laddove volessimo confrontare immagini diverse sarebbe molto complesso cercare di trovare un’affinità tra i singoli nodi e quindi un percorso che riconduca al medesimo output desiderato.

Albania Sud | Vagabondo

Dello stesso posto potremmo avere ad esempio la seguente immagine:

Turismo dentale Albania | EliteDental

Le due immagini risulterebbero, per il computer, prese tali e quali, fondamentalmente diverse. Adesso proviamo a ridurre il dettaglio dei pixel, nel modo seguente:

Adesso possiamo identificare, nelle immagini divese, zone analoghe associabili per forma e colore tra di loro (nonostante le differenze ancora esistenti). In questo caso abbiamo ridotto le immagini in quadrati da 36×36 pixel ciascuno, quindi in totale abbiamo ridotto il tutto a circa 700 nodi. Ovviamente si è ridotta la complessità e di conseguenza il livello di dettaglio. Potremo apprezzare meno dettagli, ma confrontare meglio i macro-elementi presenti in entrambe le immagini.

Detto tutto questo compiliamo il nostro modello:

modello.compile(optimizer="adam",
            loss="sparse_categorical_crossentropy",
            metrics=["accuracy"])

modello.compile(optimizer="adam",

loss="sparse_categorical_crossentropy",

metrics=["accuracy"])

E infine compiliamolo e salviamolo:

modello.fit(train_img, train_desc, epochs=20)
modello.save("modello_frutta")

1 2	modello.fit(train_img, train_desc, epochs=20) modello.save("modello_frutta")

Per usare il modello salvato lo possiamo caricare usando:

modello = keras.models.load_model("modello_frutta")

1	modello = keras.models.load_model("modello_frutta")

A questo punto carichiamo le immagini di TEST e mettiamo a prova il nostro modello:

test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

1	test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

Adesso facciamo prevedere al modello i risultati:

previsione = modello.predict(test_img)

1	previsione = modello.predict(test_img)

Infine stampiamoli a video per ottenere il risultato iniziale:

for i, img in enumerate(test_img):
    previsione = modello.predict(np.array([img]))
    print(previsione, test_desc[i])

for i, img in enumerate(test_img):

previsione = modello.predict(np.array([img]))

print(previsione, test_desc[i])

Riporto anche tutto il codice insieme:

from __future__ import absolute_import, division, print_function, unicode_literals
 
from PIL import Image
import numpy as np
import os
 
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt


class ElaboraImmagini:

    # acquisiamo i dati per le immagini, con i seguenti argomenti
    # orig: lista che contiene il percorso alle immagini originali da tagliare
    # dest: cartella di destinazione nella quale salvare le immagini
    # n: numero di immagini in colonna
    # w: larghezza delle singole immagini
    def __init__(s, orig = [], dest = None, n = 4, w = 100):

        # prendiamo il percorso originale della cartella nella quale ci troviamo
        # ovvero dove si trova lo script di Python
        s.__orig_dir = os.path.dirname(os.path.realpath(__file__))
        # impostiamo la variabile privata con la lista delle immagini da elaborare
        s.__orig = orig
        # creiamo la cartella di destinazione
        s.__dest = s.__orig_dir + "\\" + dest

        # se la cartella non esiste...
        if not os.path.exists(s.__dest):
            # ... allora la creiamo
            os.makedirs(s.__dest)

        # salviamo n e w in variabili private
        s.__n = n
        s.__w = w

        # chiamiamo l'elaborazione delle immagini
        s.elabora()

    # creiamo il metodo per elaborare le immagini
    def elabora(s):

        # per ogni file nella lista di origine
        for f in s.__orig:
            # creiamo il nome del file con il percorso assoluto
            nome_file = s.__orig_dir + "\\" + f
            # per ogni riga...
            for i in range(s.__n):
                # ... e per ogni colonna
                for j in range(s.__n):
                    # ritagliamo le immagini con l'apposito metodo
                    # al metodo verranno passate le coordinate come 4-tupla
                    # calcolata da righe e colonne, oltre al nome del file da creare
                    # il nome lo creiamo come: nome del file senza estensione + conteggio
                    # quindi se stiamo tagliando banane.png avremo banane_x.png
                    # in questo modo potremo riconoscere le immagini dai nomi dei file
                    s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \
                                nome_file , \
                                os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

    # ritaglia con i seguenti argomenti:
    # coor: posizione left, top, right, bottom, come se fossero x e y insomma
    # nome_file: nome del file corrente
    # nome_dest: nome del file da creare
    def ritaglia(s, coor, nome_file, nome_dest):
        # apriamo il file
        img = Image.open(nome_file)
        # ritagliamolo
        cropped = img.crop(coor)
        # creiamo la posizione di salvataggio
        file_salvato = s.__dest + "\\" + nome_dest
        # salviamo
        cropped.save(file_salvato)



ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")
ElaboraImmagini(["frutta.png"],"TEST")

class CreaDBImmagini:

    # creiamo delle "costanti" giusto per codificare il tipo di output
    # che vogliamo ottenere passando il tipo al costruttore
    TEST = 0
    TRAINING = 1

    # qui codifichiamo la frutta
    MELE = 0
    PERE = 1
    BANANE = 2

    # passiamo al costruttore due argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)
    def __init__(s, path, tipo = 0):
        s.__path = path
        # lista che conterrà le immagini in byte
        s.__immagini = []
        # lista contenente le descrizioni
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo la cartella con le immagini
    def elabora(s):
        # per ciascuna immagine nella cartella
        for f in os.listdir(s.__path):
            # creiamo il percorso del file
            percorso_file = s.__path + "\\" + f
            # se il file esiste (per come è costruito il metodo non c'è
            # motivo per cui il file non debba esistere, in realtà
            # verifichiamo che eventualmente non sia una cartella)
            if os.path.isfile(percorso_file):
                # leggiamo l'immagine usando la libreria Pillow
                img = Image.open(percorso_file)
                # trasformiamo i byte dell'immagine in un array di NumPy
                aimg = np.asarray(img)
                # aggiungiamo tale array alla lista delle immagini
                s.__immagini.append(aimg)

                # se elaboriamo le immagini per il training...
                if s.__tipo == s.TRAINING:
                    # preniamo il tipo del frutto dal nome
                    # ricordiamoci che i nomi sono del tipo mela_1.png
                    # quindi spezziamo il nome su _ e prendiamo la prima
                    # parte
                    frutto = f.split("_")[0]
                    # codifichiamo il nome con il numero
                    if frutto == "mele": desc = s.MELE
                    if frutto == "pere": desc = s.PERE
                    if frutto == "banane": desc = s.BANANE
                    # aggiungiamo tale numero alla lista delle descrizioni
                    s.__descrizioni.append(desc)

                # in caso di test ci accontentiamo dei meri nomi dei file
                if s.__tipo == s.TEST:
                    s.__descrizioni.append(f)

    # metodo per restituire la lista di immagini e descrizioni
    # codificate come array di NumPy
    def get(s):
        return (np.array(s.__immagini), np.array(s.__descrizioni))

# qui alleno il modello (ora disattivato con False)
if True:
    train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

    modello = keras.Sequential([
            keras.layers.Flatten(input_shape=(100,100,3)),
            keras.layers.Dense(128, activation="relu"),
            keras.layers.Dense(3, activation="softmax")
        ])

    modello.compile(optimizer="adam",
            loss="sparse_categorical_crossentropy",
            metrics=["accuracy"])

    modello.fit(train_img, train_desc, epochs=20)

    modello.save("modello_frutta")

# qui uso il modello
if True:
    modello = keras.models.load_model("modello_frutta")

    test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

    print("elenco di previsioni grezzo")
    previsione = modello.predict(test_img)

    print("elenco previsioni gestito")
    for i, img in enumerate(test_img):
        previsione = modello.predict(np.array([img]))
        print(previsione, test_desc[i])

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

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

class ElaboraImmagini:

# acquisiamo i dati per le immagini, con i seguenti argomenti

# orig: lista che contiene il percorso alle immagini originali da tagliare

# dest: cartella di destinazione nella quale salvare le immagini

# n: numero di immagini in colonna

# w: larghezza delle singole immagini

def __init__(s, orig = [], dest = None, n = 4, w = 100):

# prendiamo il percorso originale della cartella nella quale ci troviamo

# ovvero dove si trova lo script di Python

s.__orig_dir = os.path.dirname(os.path.realpath(__file__))

# impostiamo la variabile privata con la lista delle immagini da elaborare

s.__orig = orig

# creiamo la cartella di destinazione

s.__dest = s.__orig_dir + "\\" + dest

# se la cartella non esiste...

if not os.path.exists(s.__dest):

# ... allora la creiamo

os.makedirs(s.__dest)

# salviamo n e w in variabili private

s.__n = n

s.__w = w

# chiamiamo l'elaborazione delle immagini

s.elabora()

# creiamo il metodo per elaborare le immagini

def elabora(s):

# per ogni file nella lista di origine

for f in s.__orig:

# creiamo il nome del file con il percorso assoluto

nome_file = s.__orig_dir + "\\" + f

# per ogni riga...

for i in range(s.__n):

# ... e per ogni colonna

for j in range(s.__n):

# ritagliamo le immagini con l'apposito metodo

# al metodo verranno passate le coordinate come 4-tupla

# calcolata da righe e colonne, oltre al nome del file da creare

# il nome lo creiamo come: nome del file senza estensione + conteggio

# quindi se stiamo tagliando banane.png avremo banane_x.png

# in questo modo potremo riconoscere le immagini dai nomi dei file

s.ritaglia( (j*s.__w,i*s.__w,(j+1)*s.__w,(i+1)*s.__w) , \

nome_file , \

os.path.basename(nome_file)[:-4] + "_" + str( i * s.__n + j) + ".png")

# ritaglia con i seguenti argomenti:

# coor: posizione left, top, right, bottom, come se fossero x e y insomma

# nome_file: nome del file corrente

# nome_dest: nome del file da creare

def ritaglia(s, coor, nome_file, nome_dest):

# apriamo il file

img = Image.open(nome_file)

# ritagliamolo

cropped = img.crop(coor)

# creiamo la posizione di salvataggio

file_salvato = s.__dest + "\\" + nome_dest

# salviamo

cropped.save(file_salvato)

ElaboraImmagini(["mele.png","pere.png","banane.png"],"TRAINING")

ElaboraImmagini(["frutta.png"],"TEST")

class CreaDBImmagini:

# creiamo delle "costanti" giusto per codificare il tipo di output

# che vogliamo ottenere passando il tipo al costruttore

TEST = 0

TRAINING = 1

# qui codifichiamo la frutta

MELE = 0

PERE = 1

BANANE = 2

# passiamo al costruttore due argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di elaborazione che vogliamo fare (TEST o TRAINING)

def __init__(s, path, tipo = 0):

s.__path = path

# lista che conterrà le immagini in byte

s.__immagini = []

# lista contenente le descrizioni

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo la cartella con le immagini

def elabora(s):

# per ciascuna immagine nella cartella

for f in os.listdir(s.__path):

# creiamo il percorso del file

percorso_file = s.__path + "\\" + f

# se il file esiste (per come è costruito il metodo non c'è

# motivo per cui il file non debba esistere, in realtà

# verifichiamo che eventualmente non sia una cartella)

if os.path.isfile(percorso_file):

# leggiamo l'immagine usando la libreria Pillow

img = Image.open(percorso_file)

# trasformiamo i byte dell'immagine in un array di NumPy

aimg = np.asarray(img)

# aggiungiamo tale array alla lista delle immagini

s.__immagini.append(aimg)

# se elaboriamo le immagini per il training...

if s.__tipo == s.TRAINING:

# preniamo il tipo del frutto dal nome

# ricordiamoci che i nomi sono del tipo mela_1.png

# quindi spezziamo il nome su _ e prendiamo la prima

# parte

frutto = f.split("_")[0]

# codifichiamo il nome con il numero

if frutto == "mele": desc = s.MELE

if frutto == "pere": desc = s.PERE

if frutto == "banane": desc = s.BANANE

# aggiungiamo tale numero alla lista delle descrizioni

s.__descrizioni.append(desc)

# in caso di test ci accontentiamo dei meri nomi dei file

if s.__tipo == s.TEST:

s.__descrizioni.append(f)

# metodo per restituire la lista di immagini e descrizioni

# codificate come array di NumPy

def get(s):

return (np.array(s.__immagini), np.array(s.__descrizioni))

# qui alleno il modello (ora disattivato con False)

if True:

train_img, train_desc = CreaDBImmagini("TRAINING",CreaDBImmagini.TRAINING).get()

modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100,100,3)),

keras.layers.Dense(128, activation="relu"),

keras.layers.Dense(3, activation="softmax")

])

modello.compile(optimizer="adam",

loss="sparse_categorical_crossentropy",

metrics=["accuracy"])

modello.fit(train_img, train_desc, epochs=20)

modello.save("modello_frutta")

# qui uso il modello

if True:

modello = keras.models.load_model("modello_frutta")

test_img, test_desc = CreaDBImmagini("TEST",CreaDBImmagini.TEST).get()

print("elenco di previsioni grezzo")

previsione = modello.predict(test_img)

print("elenco previsioni gestito")

for i, img in enumerate(test_img):

previsione = modello.predict(np.array([img]))

print(previsione, test_desc[i])

Qui il progetto con le immagini scaricabile in formato zip.

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

1 Agosto 2019 1 commento

[python] Esercizio su wxPython e PyOpenGL per disegnare un poligono dato il numero di lati

Quello che voglio realizzare oggi è un semplice programma in Python 2.7, con interfaccia grafica e che permetta di disegnare un poligono regolare dato il numero di lati. In questo esercizio vedremo quindi due cose:

L’utilizzo di wxPython per creare un rudimentale programma con interfaccia grafica
L’utilizzo di PyOpenGL per disegnare dentro ad un canvas una figura geometrica

Il programma che andremo a creare avrà alla fine questo aspetto, con uno spazio per inserire il numero di lati ed un canvas su cui disegnare:

Anzitutto assicuriamoci di disporre di entrambe le librerie, per farlo installiamole con pip eseguendo i seguenti due comandi da terminale:

pip install wxPython
pip install PyOpenGL

1 2	pip install wxPython pip install PyOpenGL

Una volta installate le librerie possiamo cominciare a creare il nostro programma.

Per prima cosa creiamo una classe per la nostra applicazione, utilizzando wx.Frame e avviando la finestra principale. Il codice di cui avremo bisogno sarà il seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        s.Show(True)


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

s.Show(True)

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

In questo modo creiamo una finestra di dimensione 800 x 600 px con titolo Disegnatore. La nostra applicazione è un’estensione di wx.Frame, laddove un Frame è una finestra le cui dimensioni e posizione possono essere modificate dall’utente (insomma la classica finestra in Windows). Inoltre essa può contenere una barra del titolo, dei menu, dello stato e degli strumenti.

Con wx.App avviamo invece l’applicazione vera e propria, questa classe ci serve per lanciare il contenitore principale dell’applicazione e passiamo come argomento False (che sarebbe così anche di predefinito) per non reindirizzare lo sys.stdout e lo sys.stderr. Per maggiori informazioni rimando alla guida ufficiale su App.

A questo punto voglio aggiungere la casella di testo e il pulsante per impostare il numero di lati. Per farlo dobbiamo usare un wx.Panel, che sostanzialmente è il contenitore degli elementi di controllo e si trova tipicamente dentro un Frame. Per maggiori informazioni leggere qui su Panel.

Modifico quindi il codice nella maniera seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ molto importante che il Panel venga istanziato prima del metodo aggPulsanti che poi aggiunge elementi al Panel. Arrivati a questo punto lanciamo il nostro programma e verifichiamo che abbia il seguente aspetto.

A questo punto è l’ora di aggiungere anche il Canvas che ci permetterà di mostrare grafica in OpenGL. Per farlo includiamo anzitutto le librerie necessarie:

from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

Modifichiamo poi il codice nel modo seguente:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ importante stabilire le dimensioni del canvas in due variabili s.width e s.height per delle correzioni che apporteremo successivamente, per ora prendiamola per buona così.

A questo punto inizializziamo il canvas aggiungendo le seguenti istruzioni:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Faccio notare che il metodo glClearColor(1, 1, 1, 1) imposta il colore dello sfondo su bianco, mentre il metodo glClearColor(0, 0, 0, 1) lo imposta su nero. I primi tre parametri sono i valori di RGB da 0 a 1.

Siamo arrivati a buon punto e siamo praticamente pronti a disegnare il nostro poligono. Il nostro riferimento è uno spazio cartesiano con gli assi che attraversano a metà il canvas e il punto (0, 0) al centro del canvas stesso. Un poligono regolare ha tanti vertici quanti i lati e ogni vertice poggia su una circonferenza di raggio r.

Questo significa che un angolo α che passa da un vertice all’altro è dato dalla seguente equazione:

$\alpha = 2 * \pi / n$

Dove n è il numero di lati (o vertici) del poligono. Traduciamo questa formula in Python nel modo seguente:

angolo_lato = 2.0*math.pi/s.n

1	angolo_lato = 2.0*math.pi/s.n

Avremo bisogno della libreria math che importiamo con:

import math

1	import math

L’angolo di partenza è arbitrario, però per far sì che il lato superiore del poligono sia parallelo all’asse delle ascisse voglio prendere come angolo di partenza:

$\beta = \pi / 2 - \pi / n$

Quindi la nostra formula sarà:

angolo_partenza = math.pi/2.0 - math.pi/s.n

1	angolo_partenza = math.pi/2.0 - math.pi/s.n

Attenzione ad inserire i numeri con almeno una cifra decimale, anche se zero, per assicurarci che Python esegua tutti i calcoli con valori decimali e non tronchi ad interi.

Infine vogliamo definire un raggio fisso per i nostri poligoni, per farlo userò come riferimento l’apotema a (anche se sarebbe sufficienti lato e raggio) nel modo seguente:

$apotema = 0.5$

$lato = apotema * ( 2.0 * \tan( \pi / n ) )$

$raggio = \sqrt{ (lato/2)^2+apotema^2 }$

Il primo vertice avrà quindi coordinate:

$( raggio * \cos( \beta ) , raggio * \sin( \beta ) )$

Il secondo vertice sarà:

$( raggio * \cos( \beta + \alpha ) , raggio * \sin( \beta + \alpha ) )$

Il terzo vertice sarà:

$( raggio * \cos( \beta + 2 * \alpha ) , raggio * \sin( \beta + 2 * \alpha ) )$

E così via.

Traduciamo il tutto nel seguente metodo:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Spostiamoci sul metodo onDraw e modifichiamolo nel modo seguente:

    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

Nel costruttore __init__ della classe aggiungiamo una variabile s.n per il numero di lati, subito dopo le dimensioni del canvas, nel modo seguente:

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        #numero di lati
        s.n = 5

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

#numero di lati

s.n = 5

Se abbiamo fatto tutto correttamente dovremmo vedere qualcosa come questo:

Notiamo subito che il pentagono è deformato ed inoltre manca la possibilità di definire una dimensione a piacere.

Anzitutto occupiamoci della deformazione, essa dipende dal fatto che il canvas ha una dimensione fissa di 1 x 1, che poi viene ripartita in parti decimali. Quindi tale dimensione si adatta poi alle proporzioni del canvas. Per ottenere un pentagono regolare anzitutto dobbiamo introdurre un fattore correttivo, che nel nostro caso sarà dato da:

s.ratio = 1.0 * s.height / s.width

1	s.ratio = 1.0 * s.height / s.width

Aggiungiamo la variabile subito dopo larghezza e altezza impostate in __init__.

Modifichiamo il metodo per disegnare il poligono nel modo seguente:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Adesso il poligono risulta regolare:

Infine attribuiamo un valore personalizzato al numero di lati s.n del poligono. Aggiungiamo i seguenti due metodi alla nostra classe:

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

E dove abbiamo istanziato s.pulsante aggiungiamo:

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

1	s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

In questo modo colleghiamo il metodo s.btn_calcola all’evento wx.EVT_BUTTON che corrisponde alla pressione del pulsante. Con il metodo verificaIntero controlliamo se il valore passato dall’utente sia intero. Se non è intero mostriamo, grazie a wx.MessageBox, un messaggio a video con notifica di errore.

Se abbiamo fatto tutto correttamente otterremo il seguente codice finale:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *
import math

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        s.ratio = 1.0 * s.height / s.width
        #numero di lati
        s.n = 5

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))
        s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

import math

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

s.ratio = 1.0 * s.height / s.width

#numero di lati

s.n = 5

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Se lo eseguiamo abbiamo il nostro programma che ci permetterà di disegnare qualunque poligono regolare:

Vedi articolo

13 Luglio 2019 Nessun commento

[python] Esercizio su funzioni ricorsive e calcolo tratte dei treni

Facciamo un piccolo programma in Python che ci permetta di gestire le distanze da percorrere tra due stazioni, di partenza ed arrivo.

Abbiamo le seguenti tratte:

Stazione A	Stazione B	Distanza
Firenze	Bologna	100km
Firenze	Roma	250km
Roma	Napoli	200km
Bologna	Milano	220km
Bologna	Venezia	150km

Ogni tratta è percorribile sia in andata che in ritorno. Quello che vogliamo è che il programma ci permetta di inserire due città e calcolare la distanza minima da percorrere e le stazioni da attraversare.

Anzitutto vediamo come sono disposti i nodi dell’intero percorso:

Notiamo che in questa configurazione elementare solo Bologna ha 3 rami, mentre tutte le altre città hanno solo 2 rami ciascuna.

Potremmo affrontare l’esercizio lavorando sui nodi oppure sulle tratte. In questa soluzione lavorerò sulle tratte.

Cominciamo quindi creando anzitutto una classe che ci permetta di descrivere ogni tratta come abbiamo visto nel mandato dell’esercizio.

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

In questo modo dichiariamo 3 variabili private per registrare le due città della tratta e la rispettiva distanza.

Adesso registriamo tutte le tratte in una lista, nel modo seguente:

tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

Ora cominciamo a pensare all’algoritmo che potrebbe permetterci di calcolare il percorso.

Immaginiamo anzitutto la soluzione più semplice, dove io penso di andare da Firenze a Napoli. Su questa tratta non ci sono diramazione e sostanzialmente il percorso che dovrà venire fuori sarà Firenze – Roma – Napoli.

Fase 1:

Faccio un ciclo su ogni elemento della lista tratte[] e cerco anzitutto dove è presente la città di partenza. Siccome la città può essere sia in A che in B, per ogni oggetto Tratta dovrò implementare un metodo all’interno dell’oggetto stesso che mi permetta di valutare se la città sia presente in modo comodo. Implementiamo quindi la classe nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

Il metodo presente(citta) mi permette di valutare se la città sia presente nella tratta.

Fase 2:

Se trovo la città di partenza su una tratta allora controllo se l’altra città della tratta sia quella di arrivo. Allo stesso tempo registro la città di partenza all’interno di una lista percorso[] in modo da metterla come partenza del percorso complessivo.

Quindi se l’altra città è quella di arrivo posso chiudere il percorso, altrimenti passo il controllo sull’altra città.

def calcolatore(da,a,percorso=[]):
    # aggiungo la partenza al percorso
    percorso.append(da)
    # comincio a controllare tutte le tratte
    for t in tratte:
        # se la città di partenza è sulla tratta allora analizzo la tratta
        if t.presente(da):
            # se l'altra città è presente allora la aggiungo al percorso
            if t.presente(a):
                percorso.append(a)
            # altrimenti controllo la partenza e l'arrivo sull'altra città
            else:
                calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

Quando mi trovo nella riga 10 capisco anche che ho trovato la fine del percorso, quindi posso salvare l’intero percorso da qualche parte. Siccome potrei avere molteplici percorsi possibili decido di salvare il percorso in una lista globale chiamata percorsi = []

Modifichiamo quindi il codice nel modo seguente:

def calcolatore(da,a,percorso=[]):
    # aggiungo la partenza al percorso
    percorso.append(da)
    # comincio a controllare tutte le tratte
    for t in tratte:
        # se la città di partenza è sulla tratta allora analizzo la tratta
        if t.presente(da):
            # se l'altra città è presente allora la aggiungo al percorso
            if t.presente(a):
                percorso.append(a)
                percorsi.append(percorso)
            # altrimenti controllo la partenza e l'arrivo sull'altra città
            else:
                calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

Adesso analizziamo due aspetti dell’ultima istruzione, quella dove richiamo la funzione.

calcolatore(t.altra(da),a,[]+percorso)

1	calcolatore(t.altra(da),a,[]+percorso)

Anzitutto voglio tirare fuori dalla tratta l’altra città, rispetto alla città di partenza. Per farlo implemento la classe principale nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

In questo modo quando mi trovo per esempio sulla tratta Firenze – Roma posso passare all’oggetto tratta Firenze, che conosco essendo il punto di partenza e chiedergli di darmi l’altra città della tratta, in questo caso Roma.

Il secondo aspetto che voglio evidenziare è che passo la lista percorso[] alla funzione medesima in partenza dall’altra città, per farlo utilizzo l’istruzione []+percorso, in caso contrario percorso passerebbe per riferimento e qualora fosse passato su più rami verrebbe elaborato contemporaneamente da più rami. Io invece voglio che resti un oggetto singolo e lineare per ogni percorso.

Arrivati a questo punto del codice la situazione è la seguente:

Prendo in input partenza DA = Firenze e A = Napoli
Aggiungo DA (Firenze) al percorso[]
Passo a setaccio la lista delle tratte[]
In posizione 0 trovo la tratta Firenze – Bologna a cui DA appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Bologna e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Bologna) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 0 sulla tratta Firenze – Bologna
LOOP INFINITO!

Fase 3:

Devo evitare il loop infinito in cui il percorso possa tornare indietro. Per farlo modifico la mia funzione aggiungendo il seguente controllo all’inizio:

def calcolatore(da,a,percorso=[]):
    # interrompo la funzione qualora la destinazione sia già nel percorso
    if da not in percorso:
        # aggiungo la partenza al percorso
        percorso.append(da)
        # comincio a controllare tutte le tratte
        for t in tratte:
            # se la città di partenza è sulla tratta allora analizzo la tratta
            if t.presente(da):
                # se l'altra città è presente allora la aggiungo al percorso
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                # altrimenti controllo la partenza e l'arrivo sull'altra città
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

# interrompo la funzione qualora la destinazione sia già nel percorso

if da not in percorso:

# aggiungo la partenza al percorso

percorso.append(da)

# comincio a controllare tutte le tratte

for t in tratte:

# se la città di partenza è sulla tratta allora analizzo la tratta

if t.presente(da):

# se l'altra città è presente allora la aggiungo al percorso

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

# altrimenti controllo la partenza e l'arrivo sull'altra città

else:

calcolatore(t.altra(da),a,[]+percorso)

In questo modo controllo che il punto di partenza DA non sia già presente nel percorso[].

Adesso ricomincio a controllare il mio algoritmo da capo:

Prendo in input partenza DA = Firenze e A = Napoli
Aggiungo DA (Firenze) al percorso[]
Passo a setaccio la lista delle tratte[]
In posizione 0 trovo la tratta Firenze – Bologna a cui DA appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Bologna e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Bologna) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 0 sulla tratta Firenze – Bologna
L’altra città (Firenze) è uguale ad A? No, quindi ripasso l’altra città come nuovo DA alla funzione medesima
La funzione si interrompe, perché DA (Firenze) è già presente in percorso[]
Torno al punto 9
In posizione 3 trovo Bologna – Milano dentro tratte[] dove appartiene il mio DA
Questo pezzo di codice adesso si ripete uguale a quello tra 10 e 12 fino a chiudersi su Milano e Venezia che terminano il percorso
Trono al punto 3
In posizione 1 trovo la tratta Firenze – Roma a cui DA (Firenze) appartiene
Controllo se A (Napoli) appartiene alla tratta
Dal momento che non appartiene, prendo l’altra città della tratta, ovvero Roma e la passo come nuovo DA alla funzione medesima
La funzione ricomincia e aggiungendo DA (Roma) al percorso[]
Scorro la lista delle tratte[] in cerca di DA (Bologna)
Trovo che DA nella posizione 1 sulla tratta Firenze – Roma
L’altra città (Firenze) è uguale ad A? No, quindi ripasso l’altra città come nuovo DA alla funzione medesima
La funzione si interrompe, perché DA (Firenze) è già presente in percorso[]
Torno al punto 20
Trovo che DA nella posizione 2 sulla tratta Roma – Napoli
Controllo se A (Napoli) appartiene alla tratta
Napoli appartiene alla tratta nel pezzo di codice if t.presente(a)
A questo punto aggiungo A (Napoli) alla fine di percorso[]
Aggiungo il percorso[] ai percorsi[] con l’istruzione percorsi.append(percorso)

Fase 4:

Apporto ancora un paio di correzioni tecniche alla mia funzione per evitare inutili duplicati.

def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

A questo punto posso scrivere la parte principale del mio programma con:

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

Per stampare il percorso faccio una join su ogni percorso che trovo dentro a percorsi[]

Fase 5:

Aggiungo soltanto un metodo per calcolare le distanze. Potrei farlo anche in modi più ottimizzato, ma per le finalità di questo esercizio ci accontentiamo di percorrere tutte le stazioni, esclusa l’ultima, e di calcolare la distanza tra la stazione corrente e la successiva sommandole tutte insieme.

A tale proposito aggiunto un metodo che mi permetta di valutare se 2 città appartengono entrambe alla tratta ed un getter per la distanza.

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

La funzione quindi sarà:

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

Fatto tutto questo posso completare il mio programma nella sua versione finale nel modo seguente:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]


tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))

def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)
        print "Distanza: %.2fkm" % distanziatore(p)

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

print "Distanza: %.2fkm" % distanziatore(p)

Se volessimo complicare un po’ lo schema potremmo aggiungere altre tratte:

tratte.append(Tratta("Milano","Venezia",260))
tratte.append(Tratta("Milano","Torino",140))
tratte.append(Tratta("Bologna","Torino",340))
tratte.append(Tratta("Firenze","Livorno",90))
tratte.append(Tratta("Firenze","Pisa",90))
tratte.append(Tratta("Livorno","Pisa",30))
tratte.append(Tratta("Grosseto","Pisa",160))
tratte.append(Tratta("Roma","Grosseto",190))

tratte.append(Tratta("Milano","Venezia",260))

tratte.append(Tratta("Milano","Torino",140))

tratte.append(Tratta("Bologna","Torino",340))

tratte.append(Tratta("Firenze","Livorno",90))

tratte.append(Tratta("Firenze","Pisa",90))

tratte.append(Tratta("Livorno","Pisa",30))

tratte.append(Tratta("Grosseto","Pisa",160))

tratte.append(Tratta("Roma","Grosseto",190))

Ed ottenere una versione finale del programma in questo modo:

class Tratta():

    def __init__(s,citta1,citta2,distanza):
        s.__citta_a = citta1
        s.__citta_b = citta2
        s.__distanza = distanza

    def presente(s,citta):
        return citta in [s.__citta_a,s.__citta_b]

    def altra(s,citta):
        if s.__citta_a == citta: return s.__citta_b
        return s.__citta_a

    def getDistanza(s):
        return s.__distanza

    def questa(s,citta1,citta2):
        return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]


tratte = []
tratte.append(Tratta("Firenze","Bologna",100))
tratte.append(Tratta("Firenze","Roma",250))
tratte.append(Tratta("Roma","Napoli",200))
tratte.append(Tratta("Bologna","Milano",220))
tratte.append(Tratta("Bologna","Venezia",150))
tratte.append(Tratta("Milano","Venezia",260))
tratte.append(Tratta("Milano","Torino",140))
tratte.append(Tratta("Bologna","Torino",340))
tratte.append(Tratta("Firenze","Livorno",90))
tratte.append(Tratta("Firenze","Pisa",90))
tratte.append(Tratta("Livorno","Pisa",30))
tratte.append(Tratta("Grosseto","Pisa",160))
tratte.append(Tratta("Roma","Grosseto",190))


def calcolatore(da,a,percorso=[]):
    if a in percorso:
        if percorso not in percorsi: percorsi.append(percorso)
        return
    if da not in percorso:
        percorso.append(da)
        for t in tratte:
            if t.presente(da):
                if t.presente(a):
                    percorso.append(a)
                    percorsi.append(percorso)
                else:
                    calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):
    distanza = 0
    for i in range(len(percorsi)-1):
        for t in tratte:
            if t.questa(percorsi[i],percorsi[i+1]):
                distanza += t.getDistanza()
    return distanza

while True:

    percorsi = []

    print "-- calcola percorso --"
    print "DA: ",
    da = input()
    print "A: ",
    a = input()
    calcolatore(da,a,[])
    for i, p in enumerate(percorsi):
        print "-- soluzione %s--" % (i+1)
        print "Percorso: " + " - ".join(p)
        print "Distanza: %.2fkm" % distanziatore(p)

class Tratta():

def __init__(s,citta1,citta2,distanza):

s.__citta_a = citta1

s.__citta_b = citta2

s.__distanza = distanza

def presente(s,citta):

return citta in [s.__citta_a,s.__citta_b]

def altra(s,citta):

if s.__citta_a == citta: return s.__citta_b

return s.__citta_a

def getDistanza(s):

return s.__distanza

def questa(s,citta1,citta2):

return citta1 in [s.__citta_a,s.__citta_b] and citta2 in [s.__citta_a,s.__citta_b]

tratte = []

tratte.append(Tratta("Firenze","Bologna",100))

tratte.append(Tratta("Firenze","Roma",250))

tratte.append(Tratta("Roma","Napoli",200))

tratte.append(Tratta("Bologna","Milano",220))

tratte.append(Tratta("Bologna","Venezia",150))

tratte.append(Tratta("Milano","Venezia",260))

tratte.append(Tratta("Milano","Torino",140))

tratte.append(Tratta("Bologna","Torino",340))

tratte.append(Tratta("Firenze","Livorno",90))

tratte.append(Tratta("Firenze","Pisa",90))

tratte.append(Tratta("Livorno","Pisa",30))

tratte.append(Tratta("Grosseto","Pisa",160))

tratte.append(Tratta("Roma","Grosseto",190))

def calcolatore(da,a,percorso=[]):

if a in percorso:

if percorso not in percorsi: percorsi.append(percorso)

return

if da not in percorso:

percorso.append(da)

for t in tratte:

if t.presente(da):

if t.presente(a):

percorso.append(a)

percorsi.append(percorso)

else:

calcolatore(t.altra(da),a,[]+percorso)

def distanziatore(percorsi):

distanza = 0

for i in range(len(percorsi)-1):

for t in tratte:

if t.questa(percorsi[i],percorsi[i+1]):

distanza += t.getDistanza()

return distanza

while True:

percorsi = []

print "-- calcola percorso --"

print "DA: ",

da = input()

print "A: ",

a = input()

calcolatore(da,a,[])

for i, p in enumerate(percorsi):

print "-- soluzione %s--" % (i+1)

print "Percorso: " + " - ".join(p)

print "Distanza: %.2fkm" % distanziatore(p)

Il nostro nuovo programma genererà un output come questo:

Vedi articolo