modif maths tp3 et ajout tp4

Maths/tp/Bezier/tp3/tp3_exo2.py

@@ -128,18 +128,19 @@ def traceLettre(char, offset=[0,0], trace_controle=False, **kwargs):
         strokes.append( [ [.78,.1], [-.25,-.3], [-.3,.7], [.8, .5] ] )  # deuxième trait du 'a'
 
     elif char=="m":
-        strokes.append( [ [1.1,0], [1.1,1.1], [0,1.1], [0,0] ] )
-        strokes.append( [ [1.1,0], [1.1,1.1], [2.1,1.1], [2.1,0] ] )
+        strokes.append( [ [0.5,0], [0.5,0.8], [0,0.8], [0,0] ] )
+        strokes.append( [ [0.5,0], [0.5,0.8], [1,0.8], [1,0] ] )
         # B = np.array([[4.3,1.4], [4.3,1.2]])    # Permet de faire un bout de sein si on inverse les appends de [A B C D] en [B A D C]
         # plt.plot(B[:,0], B[:,1], linestyle='--', color='black')
     
     elif char=="k":
-        strokes.append( [ [0,0], [0,1.1], [1.1,0], [0,0] ] )
-        strokes.append( [ [1.1,1.1], [1.1,0], [0,1.1], [1.1,1.1] ] )
+        strokes.append( [ [0.2,0], [0.2,1]] )
+        strokes.append( [ [0.2,0.3], [0.5,0]] )
+        strokes.append( [ [0.2, 0.3], [0.5,0.3], [0.5,0.7], [0.2,0.7]])
 
     elif char=="l":
-         strokes.append( [ [0,0], [0,1.1], [1.1,1.1], [0,0] ] )
-         strokes.append( [ [1.1,0], [1.1,1.1], [0,1.1], [1.1,0] ] )
+         strokes.append( [ [0.2,0.5], [0.3,0.5], [0.3,1], [0.2,1] ] )
+         strokes.append([ [0.2, 0], [0.2, 1] ])
 
     elif char==" ":
         pass                                                            # pour 'tracer' le caractère espace... on ne trace rien ! ^^
@@ -151,17 +152,17 @@ def traceLettre(char, offset=[0,0], trace_controle=False, **kwargs):
     for lst in strokes:
         print(lst)      # pour que vous compreniez ce que contient la variable lst (vous pouvez ensuite supprimer cette ligne)
         P = np.array(lst)
-        traceBezier(P)                # Tracer la courbe de Bézier définie par la liste de points lst
+        traceBezier(P + offset)                # Tracer la courbe de Bézier définie par la liste de points lst
 
 
 
 ### Code de test:
 plt.figure()
-traceLettre("m", trace_controle=True, color="blue", linewidth=3)
+traceLettre("a", trace_controle=True, color="blue", linewidth=3)
 # traceCarre(color="green")
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 
 print("-"*80)
@@ -176,27 +177,27 @@ Attention : chaque lettre doit "tenir" dans un carré unité (le "g" pouvant dé
 
 ### Teste le "g":
 plt.figure()
-traceLettre("g", trace_controle=True, color="blue", linewidth=3)
+traceLettre("m", trace_controle=True, color="blue", linewidth=3)
 traceCarre(color="green")
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 ### Teste le "t":
 plt.figure()
-traceLettre("t", trace_controle=True, color="blue", linewidth=3)
+traceLettre("k", trace_controle=True, color="blue", linewidth=3)
 traceCarre(color="green")
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 ### Teste le "c":
 plt.figure()
-traceLettre("c", trace_controle=True, color="blue", linewidth=3)
+traceLettre("l", trace_controle=True, color="blue", linewidth=3)
 traceCarre(color="green")
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 
 print("-"*80)
@@ -214,15 +215,15 @@ Vérification : une fois votre code écrit, le code ci-dessous représentera les
 plt.figure()
 traceLettre("a", offset = [0,0],  color="blue", linewidth=3)
 traceCarre(color="green", offset=[0,0] )
-traceLettre("c", offset = [2,0], color="blue", linewidth=3)
+traceLettre("m", offset = [2,0], color="blue", linewidth=3)
 traceCarre(color="green", offset=[2,0] )
-traceLettre("g", offset = [0,-2], color="blue", linewidth=3)
+traceLettre("l", offset = [0,-2], color="blue", linewidth=3)
 traceCarre(color="green", offset=[0,-2] )
-traceLettre("t", offset = [2,-2], color="blue", linewidth=3)
+traceLettre("k", offset = [2,-2], color="blue", linewidth=3)
 traceCarre(color="green", offset=[2,-2] )
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 
 print("-"*80)
@@ -235,11 +236,11 @@ Attention : chaque lettre doit toujours tenir dans un carré unité (en dépassa
 
 ### Vérification (par exemple, pour vérifier le code du "b" une fois qu'il est défini):
 plt.figure()
-traceLettre("b", trace_controle=True, color="blue", linewidth=3)
+traceLettre("a", trace_controle=True, color="blue", linewidth=3)
 traceCarre(color="green")
 plt.axis("equal")
 
-stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
+# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
 
 
 print("-"*80)
@@ -257,12 +258,15 @@ Consigne pour le OFFSET (décalage) : chaque caractère de la chaîne doit être
 # - trace_controle et kwargs : même signification que pour la fonction traceBezier
 
 def traceStr(chaine, trace_controle=False, **kwargs):
-    TODO()    
+    offset = [0,0]
+    for char in chaine:
+        traceLettre(char, trace_controle=trace_controle, offset=offset, **kwargs)
+        offset[0] += 1   
 
 
 ### Vérification:
 
-phrase = "gattaca taca tagata"                                   # version basique avec uniquement les lettre a,c,g,t
+phrase = "ammm aallkka ammllkklmm"                                   # version basique avec uniquement les lettre a,c,g,t
 # phrase = "portez ce vieux whisky au juge blond qui fume"       # pangramme (phrase avec les 26 lettres de l'alphabet)
 
 plt.figure()

Maths/tp/Bezier/tp4/tp4.py

@@ -0,0 +1,147 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import time
+# import shape
+
+# On active le "mode interactif" de pyplot. Ainsi, les plt.show() ne sont plus nécessaires.
+plt.ion()						
+
+# --------------------------------------------------------------------------------------
+# Fonction de "fin temporaire" pendant l'avancée du TP. Attend une frappe Entrée, puis quitte le script.
+
+def stop_ici():
+	plt.pause(0.1)	# nécessaire pour que matplotlib ait le temps d'afficher les figures
+	input()
+	exit()
+
+# Exercice 1
+
+# Question 1
+    #! F(A,B,C,t) = (1-t)**2*A + 2*t*(1 - t)*B + t**2*C
+
+def formuleBezier2(t,A,B,C):
+    return (1-t)**2*A + 2*t*(1 - t)*B + t**2*C
+
+A, B, C = np.array([0,1]),np.array([3,3]),np.array([5,0])
+allt = np.linspace(0,1,100)
+allFt = np.zeros((len(allt),2))
+for i in range(len(allt)):
+    allFt[i] = formuleBezier2(allt[i],A,B,C)
+plt.figure()
+plt.plot(allFt[:,0],allFt[:,1])
+
+# Exercice 2
+
+# Question 1
+    #! F(A,B,C,D,t) = (1-t)**3*A + 3*t*(1 - t)**2*B + 3*t**2*(1 - t)*C + t**3*D
+
+def formuleBezier3(t,A,B,C,D):
+    return (1-t)**3*A + 3*t*(1 - t)**2*B + 3*t**2*(1 - t)*C + t**3*D
+
+A, B, C, D = np.array([0,1]),np.array([3,3]),np.array([5,0]),np.array([7,1])
+allt = np.linspace(0,1,100)
+allFt = np.zeros((len(allt),2))
+for i in range(len(allt)):
+    allFt[i] = formuleBezier3(allt[i],A,B,C,D)
+plt.figure()
+plt.plot(allFt[:,0],allFt[:,1])
+
+# Exercice 3
+
+# Question 1
+def binom(N,k):
+    return np.math.factorial(N)/(np.math.factorial(k)*np.math.factorial(N-k))
+
+# Question 2
+
+def formuleBezierGenerale(t,P):
+    Ft = np.zeros(2)
+    for k in range(len(P)):
+        Ft += P[k]*np.math.factorial(len(P)-1)/(np.math.factorial(k)*np.math.factorial(len(P)-1-k))*t**k*(1-t)**(len(P)-1-k)
+    return Ft
+
+P = [np.array([0,1]),np.array([3,3]),np.array([5,0]),np.array([7,1])]
+allt = np.linspace(0,1,100)
+allFt = np.zeros((len(allt),2))
+for i in range(len(allt)):
+    allFt[i] = formuleBezierGenerale(allt[i],P)
+plt.figure()
+plt.plot(allFt[:,0],allFt[:,1])
+
+
+# Exercice 4
+
+A,B = np.array([0,1]),np.array([3,3])
+allt = np.linspace(0,1,100)
+
+
+#! /* version non vectorisée */
+#* allFt = np.zeros((len(allt),2))
+#* for i in range(len(allt)):
+    #* t = allt[i]
+    #* allFt[i] = (1-t)*A + t*B
+
+#! /* version vectorisée */
+#* allFt = (1-allt[:,None])*As[None,:] + allt[:,None]*B[None,:]
+
+
+# Question 1
+
+from time import time
+debut = time()
+allFt = np.zeros((len(allt),2))
+for i in range(len(allt)):
+    t = allt[i]
+    allFt[i] = (1-t)*A + t*B
+fin = time()
+duree = fin - debut
+print("Durée de la boucle for pour la non-vectorisé : ",duree)
+
+debut = time()
+allFt = (1-allt[:,None])*A[None,:] + allt[:,None]*B[None,:]
+fin = time()
+duree = fin - debut
+print("Durée de la boucle for pour la vectorisé : ",duree)
+
+# c'est environ 26 fois plus rapide
+
+# Question 2
+
+# Question a
+# shape = shape(allt)
+# shape2 = (len(allt[:None]),2)
+# shape3 = (len(B),2)
+# shape4 = (len(B[None,:]),2)
+# shape5 = (len(allt[:,None]*B[None,:]),2)
+
+# print(shape(allt))
+# print("shape2 = ",shape2)
+# print("shape3 = ",shape3)
+# print("shape4 = ",shape4)
+# print("shape5 = ",shape5)
+
+
+# Question b
+# allFt = (1-allt)*A + allt*B
+
+# Question 3
+# def formuleBezierVectorisee(allt, P):
+#     allFt = np.zeros((len(allt),2))
+#     for k in range(len(P)):
+#         allFt += P[k]*np.math.factorial(len(P)-1)/(np.math.factorial(k)*np.math.factorial(len(P)-1-k))*allt**k*(1-allt)**(len(P)-1-k)
+#     return allFt
+
+# P = [np.array([0,1]),np.array([3,3]),np.array([5,0]),np.array([7,1])]
+# allt = np.linspace(0,1,100)
+
+# debut = time()
+# allFt = formuleBezierVectorisee(allt,P)
+# fin = time()
+# duree = fin - debut
+# print("Durée de la formule vectorisée : ",duree)
+
+
+
+
+
+stop_ici() # pour arrêter le script ici