def losange_inf_gauche(point, col, longueur, centre, rayon):
"""
Réalise le dessin du losange inferieur gauche
"""
x, y = point
t.fillcolor(col[1])
t.begin_fill()
p = (longueur * cos(2 * pi / 3) + x, longueur * sin(2 * pi / 3) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
p = (longueur * cos(pi) + x, longueur * sin(pi) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
p = (longueur * cos(-2 * pi / 3) + x, longueur * sin(-2 * pi / 3) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
t.end_fill()
def losange_sup_droit(point, col, longueur, centre, rayon):
"""
Réalise le dessin du losange supérieur droit
"""
x, y = point
t.fillcolor(col[2])
t.begin_fill()
p = (longueur * cos(0) + x, longueur * sin(0) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
p = (longueur * cos(-pi / 3) + x, longueur * sin(-pi / 3) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
p = (longueur * cos(-2 * pi / 3) + x, longueur * sin(-2 * pi / 3) + y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
p = (x, y, 0)
p = (deformation(p, centre, rayon))
t.goto(p[0], p[1])
t.end_fill()
def losange_col_3(col, point, longueur, centre, rayon):
"""
Dessine le premier losange
"""
## définition des différents points de référence du losange
x, y, z = point
# definition du deuxieme sommet
x_bis = x - longueur * math.cos(math.pi / 3)
y_bis = y + longueur * math.sin(math.pi / 3)
point_2 = (x_bis, y_bis, z)
# definition du troisieme sommet
x_bis = x - longueur
y_bis = y
point_3 = (x_bis, y_bis, z)
# definition du quatrieme sommet
x_bis = x - longueur * math.cos(math.pi / 3)
y_bis = y - longueur * math.sin(math.pi / 3)
point_4 = (x_bis, y_bis, z)
# definition de la couleur a utiliser
turtle.color(col[2], col[2])
turtle.begin_fill()
# deformation de la position des points
point_2 = deformation.deformation(point_2, centre, rayon)
point_3 = deformation.deformation(point_3, centre, rayon)
point_4 = deformation.deformation(point_4, centre, rayon)
#dessin du losange
trace(point_2, point_3, point_4)
turtle.end_fill() # remplissage
return
def losange_sup_gauche(point, col, longueur, centre, rayon):
"""
Réalise le dessin du losange supérieur gauche
"""
t.penup()
x, y = point
p = (x, y, 0)
p = deformation(p, centre, rayon)
t.goto(p[0], p[1])
t.fillcolor(col[0])
t.begin_fill()
p = (longueur * cos(0) + x, longueur * sin(0) + y, 0)
p = deformation(p, centre, rayon)
t.goto(p[0], p[1])
p = (longueur * cos(pi / 3) + x, longueur * sin(pi / 3) + y, 0)
p = deformation(p, centre, rayon)
t.goto(p[0], p[1])
p = (longueur * cos(2 * pi / 3) + x, longueur * sin(2 * pi / 3) + y, 0)
p = deformation(p, centre, rayon)
t.goto(p[0], p[1])
p = (x, y, 0)
p = deformation(p, centre, rayon)
t.goto(p[0], p[1])
t.end_fill()
def hexagone(point, longueur, col, centre, rayon):
"""
fonction hexagone permettant à partir de 3 losanges d'afficher
un hexagone déformé peint de 3 couleurs centré en un point appelée "point" et
de longueur longueur, cela est fait grâce à la méthode goto de turtle et
à la fonction déformation qui renvoie un point déformé.
Calcul des coordonnées des sommets des losanges réalisés
grâce au théorème de Pythagore et l'aide du cosinus.
:param point:
:param longueur:
:param col:
:param centre:
:param rayon:
"""
point_x, point_y = point
point_z = 0
centre_hexagone = (deformation((point_x, point_y, point_z), centre,
rayon)[0:2])
sommet_a = (deformation((point_x + longueur, point_y, point_z), centre,
rayon)[0:2])
sommet_b = (deformation(
(point_x + (longueur / 2), point_y + cos(pi / 6) * longueur, point_z),
centre, rayon)[0:2])
sommet_c = (deformation(
(point_x - (longueur / 2), point_y + cos(pi / 6) * longueur, point_z),
centre, rayon)[0:2])
sommet_d = (deformation((point_x - longueur, point_y, 0), centre,
rayon)[0:2])
sommet_e = (deformation((point_x - (longueur / 2), point_y +
(-1 * cos(pi / 6) * longueur), point_z), centre,
rayon)[0:2])
sommet_f = (deformation((point_x + (longueur / 2), point_y +
(-1 * cos(pi / 6) * longueur), point_z), centre,
rayon)[0:2])
turtle.up(
) # ceci lève et permet à turtle de se déplacer sans tracer jusqu'au centre d'un hexagone
turtle.goto(centre_hexagone[0], centre_hexagone[1])
turtle.down() # rabaisse turtle pour tracer
sommets = [(sommet_a, sommet_b, sommet_c, centre_hexagone),
(sommet_e, sommet_f, sommet_a, centre_hexagone),
(sommet_c, sommet_d, sommet_e, centre_hexagone)]
losanges(sommets, col)
def deform_mesh(filename, model, cam, label_folder):
vertices, new_vertices, faces0, todo_vertices, inv_trasformation = get_mesh_to_deformation(
filename, model, cam, label_folder)
deformed = deformation(vertices, todo_vertices, new_vertices, faces0, 50)
t_vertices = np.array(deformed) - np.array(cam['trans']).reshape((1, 3))
rest_t_vertices = np.vstack((t_vertices.T, np.ones(
(1, t_vertices.shape[0]))))
v_t_w = (inv_trasformation[:, 0, :] * rest_t_vertices[0, :].reshape(
(1, -1)) + inv_trasformation[:, 1, :] * rest_t_vertices[1, :].reshape(
(1, -1)) +
inv_trasformation[:, 2, :] * rest_t_vertices[2, :].reshape(
(1, -1)) +
inv_trasformation[:, 3, :] * rest_t_vertices[3, :].reshape(
(1, -1))).T
v_t = v_t_w[:, :-1] / v_t_w[:, [3, 3, 3]]
return (v_t)
def hexagone(point, longueur, col, centre, rayon):
"""
Definition de la fonction hexagone qui produit trois hexagones
point :
sous forme d’un triple (tuple de trois composantes) donnant la valeur des trois coordonnées,
du point avant déformation où l’hexagone doit être peint
longueur:
la distance (avant déformation) entre le centre et n’importe quel coin de l’hexagone
col :
tuple contenant les trois couleurs (col1, col2, col3) qui vont être utilisées pour dessiner les hexagones
centre:
point sous forme de triple (c_x, c_y, c_z) qui donne le centre de la sphère de déformation
rayon:
le rayon de la sphère de déformation
"""
def losange_col_1(col, point, longueur, centre, rayon):
"""
Dessine le premier losange
"""
## définition des différents points de référence du losange
x, y, z = point
# definition du deuxieme sommet
x_bis = x - longueur*math.cos(math.pi/3)
y_bis = y - longueur*math.sin(math.pi/3)
point_2 = (x_bis,y_bis,z)
# definition du troisieme sommet
x_bis = x + longueur * math.cos(math.pi / 3)
y_bis = y - longueur * math.sin(math.pi / 3)
point_3 = (x_bis,y_bis,z)
# definition du quatrieme sommet
x_bis = x + longueur
y_bis = y
point_4 = (x_bis,y_bis,z)
# definition de la couleur a utiliser
turtle.color(col[0], col[0])
turtle.begin_fill()
# deformation de la position des points
point_2 = deformation.deformation(point_2, centre, rayon )
point_3 = deformation.deformation(point_3, centre, rayon)
point_4 = deformation.deformation(point_4, centre, rayon)
#dessin du losange
trace(point_2, point_3, point_4)
turtle.end_fill() # remplissage
return
def losange_col_2(col, point, longueur, centre, rayon):
"""
Dessine le deuxieme losange
"""
## définition des différents points de référence du losange
x, y, z = point
# definition du deuxieme sommet
x_bis = x + longueur
y_bis = y
point_2 = (x_bis, y_bis, z)
# definition du troisieme sommet
x_bis = x + longueur * math.cos(math.pi / 3)
y_bis = y + longueur * math.sin(math.pi / 3)
point_3 = (x_bis, y_bis, z)
# definition du quatrieme sommet
x_bis = x - longueur * math.cos(math.pi / 3)
y_bis = y + longueur * math.sin(math.pi / 3)
point_4 = (x_bis, y_bis, z)
# definition de la couleur a utiliser
turtle.color(col[1], col[1])
# deformation de la position des points
point_2 = deformation.deformation(point_2, centre, rayon)
point_3 = deformation.deformation(point_3, centre, rayon)
point_4 = deformation.deformation(point_4, centre, rayon)
#dessin du losange
trace(point_2, point_3, point_4)
return
def losange_col_3(col, point, longueur, centre, rayon):
"""
Dessine le premier losange
"""
## définition des différents points de référence du losange
x, y, z = point
# definition du deuxieme sommet
x_bis = x - longueur * math.cos(math.pi / 3)
y_bis = y + longueur * math.sin(math.pi / 3)
point_2 = (x_bis, y_bis, z)
# definition du troisieme sommet
x_bis = x - longueur
y_bis = y
point_3 = (x_bis, y_bis, z)
# definition du quatrieme sommet
x_bis = x - longueur * math.cos(math.pi / 3)
y_bis = y - longueur * math.sin(math.pi / 3)
point_4 = (x_bis, y_bis, z)
# definition de la couleur a utiliser
turtle.color(col[2], col[2])
turtle.begin_fill()
# deformation de la position des points
point_2 = deformation.deformation(point_2, centre, rayon)
point_3 = deformation.deformation(point_3, centre, rayon)
point_4 = deformation.deformation(point_4, centre, rayon)
#dessin du losange
trace(point_2, point_3, point_4)
turtle.end_fill() # remplissage
return
def trace(point_2, point_3, point_4):
"""
Dessin le losange
"""
turtle.begin_fill()
# dessin du losange
turtle.goto(point_2[0], point_2[1])
turtle.goto(point_3[0], point_3[1])
turtle.goto(point_4[0], point_4[1])
turtle.end_fill() # remplissage
point_mod = deformation.deformation(point, centre, rayon) #modification du point de reference
#positionne la tortue pour de dessin et fait le premier losange
turtle.up()
turtle.goto(point_mod[0], point_mod[1])
losange_col_1(col, point, longueur, centre, rayon) # dessin le premier losange
turtle.down()
#positionne la tortue pour de dessin et fait le deuxieme losange
turtle.up()
turtle.goto(point_mod[0], point_mod[1])
losange_col_2(col, point, longueur, centre, rayon) #dessin du deuxime losange
turtle.down()
#positionne la tortue pour de dessin et fait le troisieme losange
turtle.up()
turtle.goto(point_mod[0], point_mod[1])
losange_col_3(col, point, longueur, centre, rayon) #dessin du troisieme losange
turtle.down()
return
def hexagone(t, c, longueur, col1, col2, col3, deformation, centre, rayon):
"""
Fonction permettant de tracer 1 pavé hexagonal (à l'aide du module "turtle").
Entrées : paramètres saisis par l'utilisateur, transmis par la fonction "pavage".
Sorties : tracé d'1 pavé hexagonal (à l'écran, fenêtre "turtle").
Arguments :
t = tortue (remplace l'objet "Turtle" dans les fonctions liées au module "turtle") ;
c = liste contenant les coordonnées (x, y) du centre du pavé hexagonal (transmises par la fonction "pavage") ;
longueur = distance entre le centre "c" et n'importe quel coin de son périmètre extérieur ;
col1, col2, col3 = couleurs de remplissage ;
deformation = fonction appelée par "hexagone", ayant pour effet de déformer les pavés hexagonaux ;
centre = liste contenant les coordonnées (c_x, c_y, c_z) du centre de la sphère de déformation ;
rayon = rayon de la sphère de déformation.
"""
t.up()
# désactivation du "pinceau"
t.goto((deformation((c[0], c[1], 0), centre,
rayon)[0], deformation((c[0], c[1], 0), centre,
rayon)[1]))
# déplacement vers le centre "c" (déformé le cas échéant)
t.down()
# ré-activation du "pinceau"
palette_couleurs = [col1, col2, col3]
# création d'une liste où sont indexées pour référence les couleurs choisies par l'utilisateur (input)
los1pos1 = [(c[0] + longueur), c[1]]
los1pos2 = [(c[0] + (longueur * math.cos(math.pi / 3))),
(c[1] + (longueur * math.sin(math.pi / 3)))]
los1pos3 = [(c[0] - (longueur * math.cos(math.pi / 3))),
(c[1] + (longueur * math.sin(math.pi / 3)))]
# positions successives des points du losange 1 (hors retour à "c")
los2pos1 = [(c[0] - (longueur * math.cos(math.pi / 3))),
(c[1] + (longueur * math.sin(math.pi / 3)))]
los2pos2 = [(c[0] - longueur), c[1]]
los2pos3 = [(c[0] - (longueur * math.cos(math.pi / 3))),
(c[1] - (longueur * math.sin(math.pi / 3)))]
# positions successives des points du losange 2 (hors retour à "c")
los3pos1 = [(c[0] - (longueur * math.cos(math.pi / 3))),
(c[1] - (longueur * math.sin(math.pi / 3)))]
los3pos2 = [(c[0] + (longueur * math.cos(math.pi / 3))),
(c[1] - (longueur * math.sin(math.pi / 3)))]
los3pos3 = [(c[0] + longueur), c[1]]
# positions successives des points du losange 3 (hors retour à "c")
map_los1 = [los1pos1, los1pos2, los1pos3,
c] # carte du losange 1 (incluant le retour à "c")
map_los2 = [los2pos1, los2pos2, los2pos3,
c] # carte du losange 2 (incluant le retour à "c")
map_los3 = [los3pos1, los3pos2, los3pos3,
c] # carte du losange 3 (incluant le retour à "c")
map_glob = [map_los1, map_los2, map_los3
] # carte globale de l'hexagone, où chaque losange = une étape
# création d'une liste où sont indexées pour référence les positions des différents points à parcourir
for i in range(3): # pour chacun des 3 losanges composant 1 hexagone
map = map_glob[i] # choix de la carte du losange
t.color(palette_couleurs[i]) # choix de la couleur à appliquer
t.begin_fill() # début du remplissage
for i in range(4): # pour chacun des 4 segments composant 1 losange
p = map[
i] # identification du point suivant à atteindre, déplacement vers celui-ci (déformé le cas échéant)
t.goto((deformation((p[0], p[1], 0), centre, rayon)[0],
deformation((p[0], p[1], 0), centre, rayon)[1]))
t.end_fill() # fin du remplissage
def hexagone(point,longueur,col,centre,rayon):#Etape 1: definition de la fonction hexagone
"""
La fonction peint un hexagone déformé en traçant des lignes droites entre le centre
et les extrémités dont la position est calculée avec la fonction deformation
"""
turtle.hideturtle()
turtle.speed(50) #vitesse d'éxecution du dessin
turtle.up()
turtle.color('')
C_x =point[0] #coordonnée du centre de l'hexagone correspondant aux bord de la fenêtre
C_y = point[1]#(inf_gauche,sup_droite)
pc=(C_x,C_y,0)
pcprim=deformation(pc,centre,rayon)#deformation du centre par la fonctio deformation
turtle.goto(pcprim[0],pcprim[1])# deplacement de la tortue au point d'origine deformé
turtle.down()
"""
Dessin de la première face du pavé
"""
turtle.color(col[0])#couleur de la première face
turtle.begin_fill()#commencer le remplissage
X1=longueur*cos(0)+C_x
Y1=longueur*sin(0)+C_y
p=(X1,Y1,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X1=longueur*cos(pi/3)+C_x
Y1=longueur*sin(pi/3)+C_y
p=(X1,Y1,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X1=longueur*cos(2*pi/3)+C_x
Y1=longueur*sin(2*pi/3)+C_y
p=(X1,Y1,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
turtle.goto(pcprim[0],pcprim[1])
turtle.end_fill()
"""
Dessin de la deuxième face du pavé
"""
turtle.color(col[1])
turtle.begin_fill()
turtle.goto(pcprim[0],pcprim[1])
X2=longueur*cos(2*pi/3)+C_x
Y2=longueur*sin(2*pi/3)+C_y
p=(X2,Y2,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X2=-longueur+C_x
Y2=0.0+C_y
p=(X2,Y2,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X2=longueur*cos(4*pi/3)+C_x
Y2=longueur*sin(4*pi/3)+C_y
p=(X2,Y2,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
turtle.goto(pcprim[0],pcprim[1])
turtle.end_fill()
"""
Dessin de la troisième face du pavé
"""
turtle.color(col[2])
turtle.begin_fill()
turtle.goto(pcprim[0],pcprim[1])
X3=longueur*cos(4*pi/3)+C_x
Y3=longueur*sin(4*pi/3)+C_y
p=(X3,Y3,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X3=longueur*cos(5*pi/3)+C_x
Y3=longueur*sin(5*pi/3)+C_y
p=(X3,Y3,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
X3=longueur*cos(0)+C_x
Y3=longueur*sin(0)+C_y
p=(X3,Y3,0)
pprim=deformation(p,centre,rayon)
turtle.goto(pprim[0],pprim[1])
turtle.goto(pcprim[0],pcprim[1])
turtle.end_fill()
def hexagone (coordonnee,longueur,col,centre,rayon):
turtle.speed(0) # vitesse d'excution du dessin: vitesse lente
turtle.up()
x=coordonnee[0] #coordonnes d'origine du premier cube: cela correspond au coinf inferieur gauche et coin sup droite
y=coordonnee[1] # de la fenetre du dessin
turtle.goto(x,y) # deplacement de la tortue au point d'origine du dessin
turtle.down()
# dessin de la premiere face du cube
turtle.color(col[0]) # couleur de la face sup
turtle.begin_fill() # debuter le remplissage
x = x + longueur * (math.cos(0)) # abscisse avant deformation
y = y + longueur * (math.sin(0)) # ordonnée avant deformation
p = (x, y, 0)
pprim = deformation(p, centre, rayon) # coordonnées apres deformation
turtle.goto(pprim[0], pprim[1]) # la tortue va au point déformé
x = x + longueur * (math.cos(-1 * math.pi / 3))
y = y + longueur * (math.sin(-1 * math.pi / 3))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0], pprim[1])
x = x + longueur * (math.cos(-1 * math.pi))
y = y + longueur * (math.sin(-1 * math.pi))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0], pprim[1])
x = x + longueur * (math.cos(-120 * math.pi / 180))
y = y + longueur * (math.sin(120 * math.pi / 180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0], pprim[1])
turtle.end_fill()
# dessin de la deuxieme face du cube
turtle.color(col[1])
turtle.begin_fill()
x=x+longueur*(math.cos(-60*math.pi/180))
y=y+longueur*(math.sin(-60*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x=x+longueur*(math.cos(-120*math.pi/180))
y=y+longueur*(math.sin(-120*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x=x+longueur*(math.cos(-240*math.pi/180))
y=y+longueur*(math.sin(-240*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x = x + longueur * (math.cos(60 * math.pi / 180))
y = y + longueur * (math.sin(60 * math.pi / 180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0], pprim[1])
turtle.end_fill()
# dessin de la troisieme face du cube
turtle.color(col[2])
turtle.down()
turtle.begin_fill()
x=x+longueur*(math.cos(0*math.pi/180))
y=y+longueur*(math.sin(0*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x=x+longueur*(math.cos(-120*math.pi/180))
y=y+longueur*(math.sin(-120*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x=x+longueur*(math.cos(-180*math.pi/180))
y=y+longueur*(math.sin(-180*math.pi/180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0],pprim[1])
x = x + longueur * (math.cos(60 * math.pi / 180))
y = y + longueur * (math.sin(60 * math.pi / 180))
p = (x, y, 0)
pprim = deformation(p, centre, rayon)
turtle.goto(pprim[0], pprim[1])
turtle.end_fill()