Browse Source

Initial commit

master
Albakham 5 months ago
commit
fba01dbf09
Signed by: albakham <dev@geber.ga> GPG Key ID: 6CE390277A579221
100 changed files with 462173 additions and 0 deletions
  1. +1
    -0
      CM/.zshrc
  2. +14
    -0
      CM/euclide.py
  3. +9
    -0
      CM/tousdiff.py
  4. +38
    -0
      FUN/Turtle/amaze.py
  5. +48
    -0
      FUN/Turtle/carre_de_vasarely.py
  6. +31
    -0
      FUN/Turtle/colorful_spiral.py
  7. +37
    -0
      FUN/Turtle/colorful_triangle.py
  8. +3
    -0
      FUN/Turtle/etoile_n.py
  9. +36
    -0
      FUN/Turtle/figures_geometriques.py
  10. +24
    -0
      FUN/Turtle/ninja.py
  11. BIN
      FUN/Turtle/s.png
  12. +13
    -0
      FUN/Turtle/sierpinsky_cairo.py
  13. +29
    -0
      FUN/Turtle/sierpinsky_triangle.py
  14. +28
    -0
      FUN/Turtle/spirale.py
  15. +17
    -0
      FUN/Turtle/spirale_art.py
  16. +54
    -0
      FUN/Turtle/spiro_hurricane.py
  17. +43
    -0
      FUN/Turtle/spiro_sunflower.py
  18. +36
    -0
      FUN/Turtle/turtle_cube.py
  19. +55
    -0
      FUN/Turtle/yin_yang.py
  20. +36
    -0
      FUN/Vasarely/Corrections Projets/deformation.py
  21. +36
    -0
      FUN/Vasarely/Corrections Projets/module_deformation.py
  22. +25176
    -0
      FUN/Vasarely/Corrections Projets/pavage.eps
  23. +210
    -0
      FUN/Vasarely/Corrections Projets/projet1.py
  24. +131
    -0
      FUN/Vasarely/Corrections Projets/projet2.py
  25. +104
    -0
      FUN/Vasarely/Corrections Projets/projet3.py
  26. +3543
    -0
      FUN/Vasarely/Corrections Projets/projet_vasarely.eps
  27. +229
    -0
      FUN/Vasarely/FINI.py
  28. BIN
      FUN/Vasarely/VASA1.png
  29. BIN
      FUN/Vasarely/VASA2.png
  30. BIN
      FUN/Vasarely/VASA3.png
  31. BIN
      FUN/Vasarely/VASA4.png
  32. BIN
      FUN/Vasarely/VASA5.png
  33. BIN
      FUN/Vasarely/__pycache__/deformation.cpython-37.pyc
  34. +36
    -0
      FUN/Vasarely/deformation.py
  35. BIN
      FUN/Vasarely/enregistrement.mp4
  36. BIN
      FUN/Vasarely/fig-léger.gif
  37. BIN
      FUN/Vasarely/fig.gif
  38. +10260
    -0
      FUN/Vasarely/pavage.eps
  39. +41082
    -0
      FUN/Vasarely/pavage_degrade.eps
  40. +225
    -0
      FUN/Vasarely/projet_colore.py
  41. +228
    -0
      FUN/Vasarely/projet_finalisee.py
  42. +208
    -0
      FUN/Vasarely/projet_random.py
  43. +94806
    -0
      FUN/Vasarely/random-2.eps
  44. +94806
    -0
      FUN/Vasarely/random-3.eps
  45. +94806
    -0
      FUN/Vasarely/random-:).eps
  46. +94806
    -0
      FUN/Vasarely/random.eps
  47. +31
    -0
      FUN/est_premier.py
  48. +12
    -0
      FUN/hexagone.py
  49. +12
    -0
      FUN/jeu.py
  50. +3
    -0
      FUN/upylab_1_1.py
  51. +8
    -0
      FUN/upylab_2_1.py
  52. +7
    -0
      FUN/upylab_2_2.py
  53. +5
    -0
      FUN/upylab_2_3.py
  54. +7
    -0
      FUN/upylab_2_4.py
  55. +5
    -0
      FUN/upylab_2_6.py
  56. +13
    -0
      FUN/upylab_2_7.py
  57. +6
    -0
      FUN/upylab_2_8.py
  58. +13
    -0
      FUN/upylab_3_1.py
  59. +11
    -0
      FUN/upylab_3_10.py
  60. +6
    -0
      FUN/upylab_3_11.py
  61. +8
    -0
      FUN/upylab_3_12.py
  62. +16
    -0
      FUN/upylab_3_13.py
  63. +22
    -0
      FUN/upylab_3_14.py
  64. +31
    -0
      FUN/upylab_3_15.py
  65. +33
    -0
      FUN/upylab_3_16.py
  66. +9
    -0
      FUN/upylab_3_2.py
  67. +17
    -0
      FUN/upylab_3_3.py
  68. +8
    -0
      FUN/upylab_3_4.py
  69. +14
    -0
      FUN/upylab_3_5.py
  70. +28
    -0
      FUN/upylab_3_6.py
  71. +11
    -0
      FUN/upylab_3_7.py
  72. +31
    -0
      FUN/upylab_3_8.py
  73. +20
    -0
      FUN/upylab_3_9.py
  74. +12
    -0
      FUN/upylab_4_1.py
  75. +67
    -0
      FUN/upylab_4_10.py
  76. +17
    -0
      FUN/upylab_4_2.py
  77. +24
    -0
      FUN/upylab_4_3.py
  78. +19
    -0
      FUN/upylab_4_5.py
  79. +20
    -0
      FUN/upylab_4_6.py
  80. +40
    -0
      FUN/upylab_4_7.py
  81. +7
    -0
      FUN/upylab_4_8.py
  82. +16
    -0
      FUN/upylab_4_9.py
  83. +11
    -0
      FUN/upylab_5_1.py
  84. +26
    -0
      FUN/upylab_5_10.py
  85. +12
    -0
      FUN/upylab_5_11.py
  86. +19
    -0
      FUN/upylab_5_12.py
  87. +15
    -0
      FUN/upylab_5_13.py
  88. +14
    -0
      FUN/upylab_5_14.py
  89. +14
    -0
      FUN/upylab_5_15.py
  90. +28
    -0
      FUN/upylab_5_16.py
  91. +10
    -0
      FUN/upylab_5_17.py
  92. +9
    -0
      FUN/upylab_5_18.py
  93. +26
    -0
      FUN/upylab_5_2.py
  94. +27
    -0
      FUN/upylab_5_3.py
  95. +14
    -0
      FUN/upylab_5_4.py
  96. +20
    -0
      FUN/upylab_5_5.py
  97. +27
    -0
      FUN/upylab_5_6.py
  98. +15
    -0
      FUN/upylab_5_7.py
  99. +10
    -0
      FUN/upylab_5_8.py
  100. +23
    -0
      FUN/upylab_5_9.py

+ 1
- 0
CM/.zshrc View File

@@ -0,0 +1 @@
#!/usr/bin/env python

+ 14
- 0
CM/euclide.py View File

@@ -0,0 +1,14 @@
#!/usr/bin/env python

def pgcd(a,b):
r0 = b
r1 = a%b
if b > a : # on s'arrange pour que a soit toujours plus grand
temp = a
a = b
b = temp
while r1 != 0: # on répète l'opération jusqu'à ce que le reste soit nul
x = r1
r1 = r0%r1
r0 = x
return r0

+ 9
- 0
CM/tousdiff.py View File

@@ -0,0 +1,9 @@
#!/usr/bin/env python

def tousdiff(l):
res = True
for ind in range(len(l)):
for e in l[ind+1:]:
if l[ind] == e:
res = False
return res

+ 38
- 0
FUN/Turtle/amaze.py View File

@@ -0,0 +1,38 @@
#! /usr/bin/env python


from turtle import * # imports the module turtle,

speed(0) # vitesse rapide
pencolor('white') # écrire en blanc
bgcolor('black') # sur fond noir

x = 0 # on initialise x
up() # et on lève le stylo

rt(45)
fd(90)
rt(135)

down() # on pose le stylo
while x < 120: # tant que x est plus petit que 120,
# effectuer ceci:
fd(200)
rt(61)
fd(200)
rt(61)
fd(200)
rt(61)
fd(200)
rt(61)
fd(200)
rt(61)
fd(200)
rt(61)

rt(11.1111)
x += 1 # incrémenter x de 1

exitonclick() # suspendre turtle



+ 48
- 0
FUN/Turtle/carre_de_vasarely.py View File

@@ -0,0 +1,48 @@
#! /usr/bin/env python3

import turtle
from math import pi, sin, cos
import random
import time


def losange(x, y, abscisse_centre, ordonnee_centre, longueur_arete, color):
turtle.color(color)
turtle.begin_fill()
turtle.down()
alpha = 0
for c in range(4):
turtle.goto(abscisse_centre+(cos(alpha)*longueur_arete), ordonnee_centre+sin(alpha)*longueur_arete)
if alpha == 0:
alpha = x
elif alpha == x:
alpha = y
else:
alpha = 0
turtle.up()
turtle.end_fill()


def pave(abscisse_centre, ordonnee_centre, longueur_arete, color1, color2, color3):

"""Dessine avec turtle un pave hexagonal
en position ( abscisse_centre, ordonnee_centre)
paramètres :
- (abscisse_centre, ordonnee_centre) : point centre du pavé
- longueur_arete : longueur de chaque arête du pavé
- color1, color2, color3 : les couleurs des 3 hexagone"""

liste_couleurs = [color1, color2, color3]
for c in range(3):
color = liste_couleurs[c]
losange(4*pi/3, 2*pi/3, abscisse_centre, ordonnee_centre, longueur_arete, color)


turtle.hideturtle()
turtle.speed(5)
turtle.reset()
time.sleep(5)

while True:
pave(random.randint(-300, 300), random.randint(-300, 300), random.randint(10, 50), 'black', 'red', 'blue')
pave(random.randint(-300, 300), random.randint(-300, 300), random.randint(10, 50), 'white', 'grey', 'black')

+ 31
- 0
FUN/Turtle/colorful_spiral.py View File

@@ -0,0 +1,31 @@
#! /usr/bin/env python3

from turtle import *

from random import randint # on a besoin de random

speed(0)

bgcolor('black')

x = 1

while x < 400:

r = randint(0,255) # On génère des nombres aléatoires qui vont être,
g = randint(0,255) # attribués successivement à R, G, B
b = randint(0,255) # Changement à chaqye nouvelle boucle

colormode(255)

pencolor(r,g,b) # le stylo intègre les couleurs r, g, b pour
# prendre une nouvelle couleur

fd(1 + x)
rt(90.911)


x = x+1

exitonclick()


+ 37
- 0
FUN/Turtle/colorful_triangle.py View File

@@ -0,0 +1,37 @@
#! /usr/bin/env python

import turtle
turtle.setup(width=600, height=500)
turtle.reset()
turtle.hideturtle()
turtle.speed(0)

turtle.bgcolor('black')

c = 0
x = 0

colors = [
#reddish colors
(1.00, 0.00, 0.00),(1.00, 0.03, 0.00),(1.00, 0.05, 0.00),(1.00, 0.07, 0.00),(1.00, 0.10, 0.00),(1.00, 0.12, 0.00),(1.00, 0.15, 0.00),(1.00, 0.17, 0.00),(1.00, 0.20, 0.00),(1.00, 0.23, 0.00),(1.00, 0.25, 0.00),(1.00, 0.28, 0.00),(1.00, 0.30, 0.00),(1.00, 0.33, 0.00),(1.00, 0.35, 0.00),(1.00, 0.38, 0.00),(1.00, 0.40, 0.00),(1.00, 0.42, 0.00),(1.00, 0.45, 0.00),(1.00, 0.47, 0.00),
#orangey colors
(1.00, 0.50, 0.00),(1.00, 0.53, 0.00),(1.00, 0.55, 0.00),(1.00, 0.57, 0.00),(1.00, 0.60, 0.00),(1.00, 0.62, 0.00),(1.00, 0.65, 0.00),(1.00, 0.68, 0.00),(1.00, 0.70, 0.00),(1.00, 0.72, 0.00),(1.00, 0.75, 0.00),(1.00, 0.78, 0.00),(1.00, 0.80, 0.00),(1.00, 0.82, 0.00),(1.00, 0.85, 0.00),(1.00, 0.88, 0.00),(1.00, 0.90, 0.00),(1.00, 0.93, 0.00),(1.00, 0.95, 0.00),(1.00, 0.97, 0.00),
#yellowy colors
(1.00, 1.00, 0.00),(0.95, 1.00, 0.00),(0.90, 1.00, 0.00),(0.85, 1.00, 0.00),(0.80, 1.00, 0.00),(0.75, 1.00, 0.00),(0.70, 1.00, 0.00),(0.65, 1.00, 0.00),(0.60, 1.00, 0.00),(0.55, 1.00, 0.00),(0.50, 1.00, 0.00),(0.45, 1.00, 0.00),(0.40, 1.00, 0.00),(0.35, 1.00, 0.00),(0.30, 1.00, 0.00),(0.25, 1.00, 0.00),(0.20, 1.00, 0.00),(0.15, 1.00, 0.00),(0.10, 1.00, 0.00),(0.05, 1.00, 0.00),
#greenish colors
(0.00, 1.00, 0.00),(0.00, 0.95, 0.05),(0.00, 0.90, 0.10),(0.00, 0.85, 0.15),(0.00, 0.80, 0.20),(0.00, 0.75, 0.25),(0.00, 0.70, 0.30),(0.00, 0.65, 0.35),(0.00, 0.60, 0.40),(0.00, 0.55, 0.45),(0.00, 0.50, 0.50),(0.00, 0.45, 0.55),(0.00, 0.40, 0.60),(0.00, 0.35, 0.65),(0.00, 0.30, 0.70),(0.00, 0.25, 0.75),(0.00, 0.20, 0.80),(0.00, 0.15, 0.85),(0.00, 0.10, 0.90),(0.00, 0.05, 0.95),
#blueish colors
(0.00, 0.00, 1.00),(0.05, 0.00, 1.00),(0.10, 0.00, 1.00),(0.15, 0.00, 1.00),(0.20, 0.00, 1.00),(0.25, 0.00, 1.00),(0.30, 0.00, 1.00),(0.35, 0.00, 1.00),(0.40, 0.00, 1.00),(0.45, 0.00, 1.00),(0.50, 0.00, 1.00),(0.55, 0.00, 1.00),(0.60, 0.00, 1.00),(0.65, 0.00, 1.00),(0.70, 0.00, 1.00),(0.75, 0.00, 1.00),(0.80, 0.00, 1.00),(0.85, 0.00, 1.00),(0.90, 0.00, 1.00),(0.95, 0.00, 1.00)
]

while x < 1000:
idx = int(c)
color = colors[idx]
turtle.color(color)
turtle.forward(x)
turtle.right(98)
x = x + 1
c = c + 0.1

turtle.exitonclick()


+ 3
- 0
FUN/Turtle/etoile_n.py View File

@@ -0,0 +1,3 @@
#! /usr/bin/env python3



+ 36
- 0
FUN/Turtle/figures_geometriques.py View File

@@ -0,0 +1,36 @@
#! /usr/bin/env python3

"""auteur : Titouan Biteau
but du programme : dessine un polygone avec le module turtle
"""

from math import cos, sin, pi
import turtle
t = turtle.Turtle()


def polygone_turtle(n, x, y, rayon, couleur):
"""Dessine un polygone selon certains paramètres"""
t.goto(x+rayon, y)
t.color(couleur)
for i in range(1, n+1):
t.goto(x+rayon*cos(i*2*pi/n), y+rayon*sin(i*2*pi/n))


def etoile_turtle(n, x, y, rayon, couleur):
"""Dessine une étoile selon certains paramètres"""
t.goto(x+rayon, y)
t.color(couleur)
for i in range(1, n+1):
pass #TODO


n = int(input("Entrez un nombre de côtés : "))
print("Entrez les coordonnées x et y de la figure : ")
x = float(input("x : "))
y = float(input("y : "))
rayon = float(input("Entrez le rayon : "))
couleur = input("Entrez une couleur ou un code RGB : ")

polygone_turtle(n, x, y, rayon, couleur)
turtle.done()

+ 24
- 0
FUN/Turtle/ninja.py View File

@@ -0,0 +1,24 @@
#! /usr/bin/env python


import turtle

ninja = turtle.Turtle()

ninja.speed(10)

for i in range(180):
ninja.forward(100)
ninja.right(30)
ninja.forward(20)
ninja.left(60)
ninja.forward(50)
ninja.right(30)

ninja.penup()
ninja.setposition(0, 0)
ninja.pendown()

ninja.right(2)

turtle.done()

BIN
FUN/Turtle/s.png View File

Before After
Width: 97  |  Height: 84  |  Size: 2.2KB

+ 13
- 0
FUN/Turtle/sierpinsky_cairo.py View File

@@ -0,0 +1,13 @@
#! /usr/bin/env python3

from cairo import*
s=SVGSurface('_',97,84)
g=Context(s)
g.scale(97,84)
def f(w,x,y):
v=w/2
if w>.1:f(v,x,y);f(v,x+w/4,y-v);f(v,x+v,y)
else:g.move_to(x,y);g.line_to(x+v,y-w);g.line_to(x+w,y);g.fill()
f(1,0,1)
s.write_to_png('s.png')


+ 29
- 0
FUN/Turtle/sierpinsky_triangle.py View File

@@ -0,0 +1,29 @@
#! /usr/bin/env python

def sierpinski(a, n):
if n == 0:
t.begin_fill()
for i in range(3):
t.fd(a)
t.lt(120)
t.end_fill()
return
sierpinski(a / 2, n - 1)
t.pu()
t.fd(a / 2)
t.pd()
sierpinski(a / 2, n - 1)
t.pu()
t.lt(120)
t.fd(a / 2)
t.rt(120)
t.pd()
sierpinski(a / 2, n - 1)
#
# We should return home! This is important!
#
t.pu()
t.lt(60)
t.bk(a / 2)
t.rt(60)
t.pd()

+ 28
- 0
FUN/Turtle/spirale.py View File

@@ -0,0 +1,28 @@
#! /usr/bin/env python3

""" auteur: Titouan Biteau
date : 7 octobre 2019
but du programme : tracer une spirale\
selon certains paramètres donnés en entrée
"""

import turtle


def spirale(couleur, largeur):
""" Dessine avec turtle une spirale
paramètres :
- couleur : la couleur à utiliser
- largeur : la largeur du tracé"""
turtle.color(couleur)
turtle.width(largeur)
for i in range(100):
turtle.circle(i*(largeur/2), 90)


while True:
turtle.reset()
turtle.speed(0)
spirale('red', 10)



+ 17
- 0
FUN/Turtle/spirale_art.py View File

@@ -0,0 +1,17 @@
#! /usr/bin/env python3

import turtle

colors = ['red','yellow','green','purple','blue','orange']

t=turtle.Pen()
turtle.bgcolor('black')
t.speed(0)

for x in range(300):
t.pencolor(colors[x%6])
t.width(x/100+1)
t.forward(x)
t.left(59)

turtle.done()

+ 54
- 0
FUN/Turtle/spiro_hurricane.py View File

@@ -0,0 +1,54 @@
#! /usr/bin/env python3

from turtle import *
import time

speed(0)
colormode(255)
clrs = ["Darkred", "Firebrick", "Crimson", "IndianRed"]

cn=0

time.sleep(2)

for j in range(120):

c=40
f=70
h=3
pencolor(clrs[cn])

for i in range(14):


circle(c)
left(90)
penup()
forward(f)
right(90)
forward(h)
pendown()
c = c*0.8
f = f*0.8
h = h*1.2
circle(c)


penup()
goto(0,0)
forward(5)
right(3)
pendown()


if cn < 3:
cn = cn+1

else:
cn = 0




exitonclick()


+ 43
- 0
FUN/Turtle/spiro_sunflower.py View File

@@ -0,0 +1,43 @@
#! /usr/bin/env python3

from turtle import *

import time

speed(0)
colormode(255)
bgcolor("white")
clrs = ["saddlebrown", "saddlebrown", "gold", "gold", "darkorange", "forestgreen", "forestgreen"]


l = 280
a = 5
cn = 6


time.sleep(3)

for k in range(7):

pencolor(clrs[cn])

for j in range(72):

left(90)
forward(l)
circle(15)
right(180)
forward(l)
left(90)
forward(2)
right(a)

l = l/1.5

cn = cn-1




exitonclick()


+ 36
- 0
FUN/Turtle/turtle_cube.py View File

@@ -0,0 +1,36 @@
#!/usr/bin/env python3

"""
Tentative de dessin de cube successifs
avec le module turtle
"""

from turtle import *

# Une fonction carré décalé
def carre(avance):
forward(avance)
left(90)
forward(avance)
left(90)
forward(avance)
left(90)
forward(avance)
left(95)

# On défini nos variables
couleurs = ["blue","green","yellow","orange","red","purple"]
i=0

# On tooooouuuurne
speed('fast') # vite
left(90)
while i <=23 :
color(couleurs[i%6])

carre(200)
carre(200)
carre(200)

i+=1
done()

+ 55
- 0
FUN/Turtle/yin_yang.py View File

@@ -0,0 +1,55 @@
#! /usr/bin/env python3

""" auteur : Titouan Biteau
yin-yang dessiné avec turtle
"""

import turtle


def yin_yang(rayon=200, color1='pink', color2='white'):
""" dessine un logo yin-yang d'un certain rayon """

def yang(rayon, couleur1, couleur2):
""" dessin du yang à l'intérieur du yin """
turtle.speed(0)
turtle.left(90)
turtle.up()
turtle.forward(rayon*0.35)
turtle.right(90)
turtle.down()
turtle.color(couleur1, couleur2)
turtle.begin_fill()
turtle.circle(rayon*0.12)
turtle.end_fill()
turtle.left(90)
turtle.up()
turtle.backward(rayon*0.35)
turtle.down()
turtle.left(90)

def yin(rayon, couleur1, couleur2):
""" dessine la moitié d'un yin-yang le contour étant en noir"""
turtle.speed(0)
turtle.color("black", couleur1)
turtle.begin_fill()
turtle.circle(rayon/2., 180) # demi cercle de rayon / 2
turtle.circle(rayon, 180) # demi cercle de rayon
turtle.left(180)
turtle.circle(-rayon/2., 180) # demi cercle intérieur de rayon / 2
turtle.end_fill()
yang(rayon, couleur1, couleur2) # dessine le yang à l'intérieur du yin

# code de yin_yang
turtle.bgcolor("black")
turtle.reset()
turtle.width(2)
yin(rayon, color1, color2)
yin(rayon, color2, color1)
turtle.hideturtle()
turtle.done()
return


# code principal
yin_yang() # réalise le logo

+ 36
- 0
FUN/Vasarely/Corrections Projets/deformation.py View File

@@ -0,0 +1,36 @@
#!/usr/bin/env python3

from math import pi, sin, cos, sqrt, acos, asin, atan2

def deformation(p, centre, rayon):
""" Calcul des coordonnées d'un point suite à la déformation engendrée par la sphère émergeante
Entrées :
p : coordonnées (x, y, z) du point du dalage à tracer (z = 0) AVANT déformation
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
Sorties : coordonnées (xprim, yprim, zprim) du point du dallage à tracer APRÈS déformation
"""
x, y, z = p
xprim, yprim, zprim = x, y, z
xc, yc, zc = centre
if rayon**2 > zc**2:
zc = zc if zc <= 0 else -zc
r = sqrt(
(x - xc) ** 2 + (y - yc) ** 2) # distance horizontale depuis le point à dessiner jusqu'à l'axe de la sphère
rayon_emerge = sqrt(rayon ** 2 - zc ** 2) # rayon de la partie émergée de la sphère
rprim = rayon * sin(acos(-zc / rayon) * r / rayon_emerge)
if 0 < r <= rayon_emerge: # calcul de la déformation dans les autres cas
xprim = xc + (x - xc) * rprim / r # les nouvelles coordonnées sont proportionnelles aux anciennes
yprim = yc + (y - yc) * rprim / r
if r <= rayon_emerge:
beta = asin(rprim / rayon)
zprim = zc + rayon * cos(beta)
if centre[2] > 0:
zprim = -zprim
return (xprim, yprim, zprim)

if __name__ == "__main__": # code de test
for i in range(-150,150,50):
for j in range(-150,150,50):
print(deformation((i,j,0), (0,0,100), 100))
print()

+ 36
- 0
FUN/Vasarely/Corrections Projets/module_deformation.py View File

@@ -0,0 +1,36 @@
#!/usr/bin/env python3

from math import pi, sin, cos, sqrt, acos, asin, atan2

def deformation(p, centre, rayon):
""" Calcul des coordonnées d'un point suite à la déformation engendrée par la sphère émergeante
Entrées :
p : coordonnées (x, y, z) du point du dalage à tracer (z = 0) AVANT déformation
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
Sorties : coordonnées (xprim, yprim, zprim) du point du dallage à tracer APRÈS déformation
"""
x, y, z = p
xprim, yprim, zprim = x, y, z
xc, yc, zc = centre
if rayon**2 > zc**2:
zc = zc if zc <= 0 else -zc
r = sqrt(
(x - xc) ** 2 + (y - yc) ** 2) # distance horizontale depuis le point à dessiner jusqu'à l'axe de la sphère
rayon_emerge = sqrt(rayon ** 2 - zc ** 2) # rayon de la partie émergée de la sphère
rprim = rayon * sin(acos(-zc / rayon) * r / rayon_emerge)
if 0 < r <= rayon_emerge: # calcul de la déformation dans les autres cas
xprim = xc + (x - xc) * rprim / r # les nouvelles coordonnées sont proportionnelles aux anciennes
yprim = yc + (y - yc) * rprim / r
if r <= rayon_emerge:
beta = asin(rprim / rayon)
zprim = zc + rayon * cos(beta)
if centre[2] > 0:
zprim = -zprim
return (xprim, yprim, zprim)

if __name__ == "__main__": # code de test
for i in range(-150,150,50):
for j in range(-150,150,50):
print(deformation((i,j,0), (0,0,100), 100))
print()

+ 25176
- 0
FUN/Vasarely/Corrections Projets/pavage.eps
File diff suppressed because it is too large
View File


+ 210
- 0
FUN/Vasarely/Corrections Projets/projet1.py View File

@@ -0,0 +1,210 @@
"""
Projet Vasarely
Auteur : bapb
Date : 13/10/2019
Ce programme permet de réaliser une sorte de damier constitué d'hexagones. Celui-ci pourra si on le souhaite être déformé par une sphère dont on donnera
les paramètres. Les hexagones sont eux même formés de trois pavés dont on pourra paramétrer les couleurs.
La fonction demandera successivement tous les paramètres a l'utilisateur.

Entrées :
inf_gauche : définit le coin inférieur gauche de la figure
sup_droit : définit le coin supérieur droit
longueur : longueur entre le centre et n’importe quel coin des hexagones
col=(col1,col2,col3) : donne les trois couleurs des pavés formant les hexagones
centre=(c_x,c_y,c_z) : définit le centre de la sphère déformant le damier
rayon : définit le rayon de la sphère déformant le damier

Résultat :
Une fenêtre turtle s'ouvre et dessine sous vos yeux la figure demandée.
Le résultat est enregistré dans le répertoire de Pycharm sous le nom : projet_vasarely.eps


Le programme a besoin de 3 fonctions pour fonctionner :

deformation(p, centre, rayon) : fonction importée du module_deformation qui calcule des coordonnées d'un point suite à la
déformation engendrée par la sphère émergeante.

Deux autres fonctions internes sont présentes dans le programme :

hexagone(point, longueur, col, centre, rayon) qui dessine UN hexagone

pavage(inf_gauche,sup_droit, longueur, col, centre, rayon) qui dessine TOUS les hexagones en damier


"""



import turtle
from math import cos, sin, pi, sqrt
from module_deformation import deformation




"""
Fonction hexagone déssinant un hexagone comme association de 3 pavés. Celle ci comporte 5 paramètres, respectivement :
Entrées :
point : triple donnant la valeur des trois coordonnées du centre, avant déformation de l’hexagone
longueur : longueur 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 pavés formant l'hexagone
centre : triple de la forme (c_x, c_y, c_z) qui donne le centre de la sphère de déformation
rayon : rayon de la spère de déformation
Sortie : hexagone avec les paramètres désirés tracé dans une nouvelle fenêtre avec le module turtle
"""
def hexagone(point, longueur, col, centre, rayon):

#centre de l'hexagone auquel on applique la déformation
origine_hexagone=deformation(point,centre,rayon)

#Tortue devient lièvre !
turtle.speed(0)

#tracé du premier pavé dont les sommets correspondent aux angles 0,pi/3 et 2pi/3 sur le cercle circonscrit à l'hexagone' auxquels on applique la déformation
turtle.up()
turtle.goto((origine_hexagone[0], origine_hexagone[1]))
turtle.down()
turtle.color(col[0])
turtle.begin_fill()
for i in range(0,3):
sommet_hexagone = deformation((longueur * cos(i * pi / 3) + point[0], longueur * sin(i * pi / 3) + point[1], point[2]),
centre, rayon)
turtle.goto((sommet_hexagone[0],sommet_hexagone[1])) #seules les deux premières composantes des coordonnées des sommets déformés sont donnés à turtle.goto
turtle.goto((origine_hexagone[0],origine_hexagone[1]))
turtle.end_fill()

#tracé du second pavé dont les sommets correspondent aux angles 2pi/3,pi et 4pi/3 sur le cercle circonscrit à l'hexagone auxquels on applique la déformation
turtle.color(col[1])
turtle.begin_fill()
for i in range(2, 5):
sommet_hexagone = deformation(
(longueur * cos(i * pi / 3) + point[0], longueur * sin(i * pi / 3) + point[1], point[2]),
centre, rayon)
turtle.goto((sommet_hexagone[0], sommet_hexagone[1]))
turtle.goto((origine_hexagone[0], origine_hexagone[1]))
turtle.end_fill()

#tracé du troisième pavé dont les sommets correspondent aux angles 4pi/3,5pi/3 et 2pi sur le cercle circonscrit à l'hexagone auquels on applique la déformation
turtle.color(col[2])
turtle.begin_fill()
for i in range(4, 7):
sommet_hexagone = deformation(
(longueur * cos(i * pi / 3) + point[0], longueur * sin(i * pi / 3) + point[1], point[2]),
centre, rayon)
turtle.goto((sommet_hexagone[0], sommet_hexagone[1]))
turtle.goto((origine_hexagone[0], origine_hexagone[1]))
turtle.end_fill()
return()



"""
Fonction pavage
Cette fonction dessine le damier d'hexagones incluant la déformation visuelle : une sphère de centre et de rayon donnés qui ressort du plan
La fonction pavage trace les hexagones en les supperposant et forme ainsi des colonnes, celles ci forment deux groupes : celles dont l'ordonnée du centre de l'hexagone du bas est égal à inf_gauche
et celles dont l'ordonnée du centre de l'hexagone du bas est égal à inf_gauche+longueur+sqrt(longueur**2-(longueur**2)*(sin(pi/3)**2)), le décalage formant le damier.
Entrées :
inf_gauche : entier définissant le coin inférieur gauche de la fenetre turtle
sup_droit : entier définissant le coin supérieur droit de la fenetre turtle
longueur : longueur 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 pavés formant l'hexagone
centre : triple de la forme (c_x, c_y, c_z) qui donne le centre de la sphère de déformation
rayon : rayon de la spère de déformation
"""
def pavage(inf_gauche,sup_droit, longueur, col, centre, rayon):

#ouverture d'une fenêtre turtle dont le coin inférieur gauche est (inf_gauche, inf_gauche) et le coin supérieur droit est (sup_droit, sup_droit)
turtle.setworldcoordinates(inf_gauche, inf_gauche, sup_droit, sup_droit)

#Tracé du premier groupe de colonne : celles dont l'ordonnée du centre de l'hexagone du bas est égal à inf_gauche
#Coordonnées du centre du premier hexagone de la première colonne du damier
centre_hexagone=(inf_gauche,inf_gauche,0)

#Calcul du nombre d'hexagone à tracer dans le sens de la hauteur de l'écran
nombre_centre_vertical=int((sup_droit-inf_gauche)/(2*longueur*sin(pi/3)))+1

#Calcul du nombre d'hexagone à tracer dans le sens de la largeur l'écran
nombre_centre_horizontal=int((sup_droit-inf_gauche)/(longueur*3))+1

for i in range(0,nombre_centre_vertical):
for j in range(0,nombre_centre_horizontal):
hexagone((centre_hexagone[0]+j*3*longueur,centre_hexagone[1]+i*2*longueur*sin(pi/3),0),longueur,col,centre,rayon)

# Coordonnées du centre du premier hexagone de la seconde colonne du damier
centre_hexagone=(inf_gauche+longueur+sqrt(longueur**2-(longueur**2)*(sin(pi/3)**2)),inf_gauche+longueur*sin(pi/3),0)

# Calcul du nombre d'hexagone à tracer dans le sens de la hauteur de l'écran
nombre_centre_vertical=int((sup_droit-inf_gauche+longueur*sin(pi/3))/(2*longueur*sin(pi/3)))+1

# Calcul du nombre d'hexagone à tracer dans le sens de la largeur l'écran
nombre_centre_horizontal=int((sup_droit-inf_gauche+sqrt(2)*longueur)/(longueur*3))+1

for i in range(0,nombre_centre_vertical):
for j in range(0,nombre_centre_horizontal):
hexagone((centre_hexagone[0]+j*3*longueur,centre_hexagone[1]+i*2*longueur*sin(pi/3),0),longueur,col,centre,rayon)
return()


"""
Fonction principale du projet demandant successivement à l'utilisateur tous les paramètres nécéssaires au tracé de la figure sous turtle, à savoir :
Entrées :
inf_gauche : coin inférieur gauche de la fenetre turtle (entier)
sup_droit : coin supérieur droit (entier)
longeur : longueur entre le centre et n’importe quel coin de l’hexagone (entier positif)
col1 : couleur du pavé "nord-est" de l'hexagone (chaine de caractères)
col2 : couleur du pavé "ouest" de l'hexagone (chaine de caractères)
col3 : couleur du pavé "sud-est" de l'hexagone (chaine de caractères)
c_x : abscisse du centre de la sphère de déformation (entier)
c_y : ordonnée du centre de la sphère de déformation (entier)
c_z : hauteur du centre de la sphère de déformation (entier)
r : rayon de la sphère en déformation (entier)
Sortie : Une fenêtre turtle dessine la figure et un fichier projet_vasarely.eps est enregistré dans le répertoire courant de Pycharm


"""
def projet_vasarely():
print("Définissez d'abord le cadre inférieur gauche de votre figure (valeur entière) :")
inf_gauche=int(input())

print("Définissez ensuite le coin supérieur droit (valeur entière) :")
sup_droit=int(input())

print("La longueur d'un segment de pavé avant déformation est (valeur entière strictement positive) :")
longueur=int(input())
if longueur<=0:
print("Entrez plutôt une valeur strictement positive svp :")
longueur=int(input())

print("Entrez successivement les 3 couleurs de vos hexagones parmis par exemple : ")
print("yellow, gold, orange, red, maroon, violet, magenta, purple, navy, blue, skyblue, cyan, turquoise, lightgreen, green, darkgreen, chocolate, brown, black, gray, white")

col1=str(input())
col2=str(input())
col3=str(input())
col=(col1,col2,col3)

print("Entrez successivement les coordonnées cartésiennes du centre de la déformation (valeurs entières) :")
c_x=int(input())
c_y=int(input())
c_z=int(input())
centre=(c_x,c_y,c_z)

print("Entrez enfin le rayon de la sphère de déformation (valeur entière):")
r=int(input())


pavage(inf_gauche,sup_droit,longueur,col,centre,r)
turtle.getcanvas().postscript(file="projet_vasarely.eps")
turtle.done()

return()


"""
Exécution du programme
Exemple d'entrée :
((-300,300,20),('blue','black','red'),(-50,-50,-50),200)
"""
projet_vasarely()

+ 131
- 0
FUN/Vasarely/Corrections Projets/projet2.py View File

@@ -0,0 +1,131 @@
"""
Projet Vasarely (MOOC Python)
Auteur : nicolas
Date : 16/10/2019
Programme permettant de dessiner un pavage d'hexagone à la manière d'un tableau de Vasarely.
Entrée du programme : coordonnées du centre inférieur gauche (une seule valeur), coordonnées du centre supérieur droit
(une seule valeur), longueur du segment d'un losange avant déformation, couleur (tuple de 3 couleurs) du pavé, coordonnées
du centre de la sphère de déformation (tuple de 3 valeurs), rayon du centre de déformation
Sortie : pavage selon Vasarely

"""
#importation des modules nécessaires à l'éxécution du programme
import turtle
import math

#importation du fichier fourni pour la déformation
from deformation import deformation


def hexagone(point, longueur, col, centre, rayon):
""" Fonction qui dessine avec turtle un pave hexagonal
paramètres :
- point : tuple des 2 coordonnées du centre du pavé
- longueur : longueur de chaque segment du pavé
- col : tuple de 3 couleurs (1 couleur pour chaque pavé composant l'hexagone)"""

turtle.up() #on lève la tortue pour ne pas dessiner pendant son déplacement jusqu'au point central du pavé)

#calcul des coordonnées du centre de l'hexagone déformé
point_deforme=(deformation((point[0],point[1],0),centre,rayon)[0],deformation((point[0],point[1],0),centre,rayon)[1])

#déplacement de la tortue au centre de l'hexagon déformé, point de départ du tracé
turtle.goto(point_deforme[0], point_deforme[1])

#position des sommets du 1er pavé partir des cordonnées du centre (variable point)
losange1_sommet1 = [(point[0] + longueur), point[1]]
losange1_sommet2 = [(point[0] + (longueur * math.cos(math.pi / 3))), (point[1] + (longueur * math.sin(math.pi / 3)))]
losange1_sommet3 = [(point[0] - (longueur * math.cos(math.pi / 3))), (point[1] + (longueur * math.sin(math.pi / 3)))]

#position des sommets du 2ème losange à partir des cordonnées du centre (variable point)
losange2_sommet1 = [(point[0] - (longueur * math.cos(math.pi/3))), (point[1] + (longueur * math.sin(math.pi/3)))]
losange2_sommet2 = [(point[0] - longueur), point[1]]
losange2_sommet3 = [(point[0] - (longueur * math.cos(math.pi/3))), (point[1] - (longueur * math.sin(math.pi/3)))]

#position des sommets du 3ème losange à partir des cordonnées du centre (variable point)
losange3_sommet1 = [(point[0] - (longueur * math.cos(math.pi/3))), (point[1] - (longueur * math.sin(math.pi/3)))]
losange3_sommet2 = [(point[0] + (longueur * math.cos(math.pi/3))), (point[1] - (longueur * math.sin(math.pi/3)))]
losange3_sommet3 = [(point[0] + longueur), point[1]]

#coordonnées des points de chaque losange
losange1 = [losange1_sommet1, losange1_sommet2, losange1_sommet3, point]
losange2 = [losange2_sommet1, losange2_sommet2, losange2_sommet3, point]
losange3 = [losange3_sommet1, losange3_sommet2, losange3_sommet3, point]

#coordonnées de chaque losange qui constituent l'hexagone
losange_hexagone= [losange1, losange2, losange3]

for i in range (3) : # on boucle sur chacun des 3 pavés composant 1 hexagone
los = losange_hexagone[i] # losange à dessiner
turtle.color(col[i]) # choix de la couleur pour le remplissage
turtle.begin_fill() # on commence le remplissage avec la couleur col[i]
for i in range (4) : # on bouche sur chacun des 4 segments composant 1 losange
pt = los[i] #désignation du point suivant à atteindre

#déplacement du pointeur jusqu'aux coordonnées après déformation
turtle.goto((deformation((pt[0], pt[1], 0), centre, rayon)[0], deformation((pt[0], pt[1], 0), centre, rayon)[1]))
turtle.end_fill() # fin du remplissage



def pavage(inf_gauche, sup_droit, longueur, col, centre, rayon):
""" Fonction qui dessine avec turtle un pavage hexagonal à partir de la fonction hexagone
paramètres :
- bornes graphiques (inf_gauche et sup_droit) : tuple des 2 coordonnées du centre du pavé
- longueur : longueur de chaque segment du pavé
- col : tuple de 3 couleurs (1 couleur pour chaque pavé composant l'hexagone)
- centre : coordonnées (tuple de 3 valeurs) du centre de la sphère de déformation
- rayon : rayon de la sphère de déformation
"""
x_max = sup_droit[0] #coordonnée selon x du dernier pavé en haut à droite
y_max = sup_droit[1] #coordonnée selon y du dernier pavé en haut à droite (égal à x_max dans la consigne
#mais pourrait être différente
x_min = inf_gauche[0] #coordonnée selon x du premier pavé en bas à gauche
y_min = inf_gauche[1] #coordonnée selon y du premier pavé en bas à gauche (égal à x_min dans la consigne
#mais pourrait être différente
position=[x_min,y_min] #tuple des coordonnées minimales
num_ligne=0 #variable pour savoir sur quel type de ligne on trace les pavés : paire ou impair
while position[1]<=y_max: #on boucle tant qu'on n'atteint pas le haut de la fenêtre
while position[0]<=x_max: #on boucle tant qu'on n'atteint pas le bord droit de la fenêtre
hexagone((position[0], position[1]),longueur,col,centre,rayon) #on trace l'hexagone en partant du bas gauche
position[0]=position[0]+3*longueur #on décale de 3 longueurs l'hexagone suivant pour qu'ils se touchent
position[1] = position[1] + longueur * math.cos(30 * math.pi / 180) #décalage y du pavé de rang supérieur
num_ligne=num_ligne+1 #incrémentation du numéro de ligne
if num_ligne%2 == 0: #si la ligne est paire, on doit décaler le début du pavage
position[0] = x_min
else:
position[0]=x_min+1.5*longueur #si la ligne est impaire, on commence la pavage à x_min


"""Programme principal qui récupère les données saisies par l'utilisateur puis qui lance le pavage
"""

#demande à l'utilisateur des coordonnées des positions extrêmes du pavage
bord_gauche=int(input("coordonnée du bord inférieur gauche : "))
inf_gauche=(bord_gauche,bord_gauche)
bord_droit=int(input("coordonnée du bord supérieur droit : "))
sup_droit=(bord_droit,bord_droit)

#demande à l'utilisateur de la longueur des segments
longueur=int(input("longueur du segment du pavé : "))

#demande à l'utilisateur des couleurs de remplissage du pavage
col1=str(input("couleur du 1er pavé (en haut à droite) : "))
col2=str(input("couleur du 2ème pavé (en gauche) : "))
col3=str(input("couleur du 3ème pavé (en bas à droite) : "))
col=(col1,col2,col3) #création du tuple des 3 couleurs

#demande à l'utilisateur des coordonnées du centre de la sphère de formation
x_centre=int(input("coordonnées x du centre : "))
y_centre=int(input("coordonnées y du centre : "))
z_centre=int(input("coordonnées z du centre : "))
centre=(x_centre,y_centre,z_centre) #création du tuple des coordonnées du centre de la sphère de déformation

#demande à l'utilisateur du rayon de la sphère de déformation
rayon=int(input("rayon de la sphère de déformation : "))

#Let's go pour le pavage !
pavage(inf_gauche,sup_droit,longueur,col,centre,rayon) #fonction pour créer le pavage

turtle.getcanvas().postscript(file="pavage.eps")
turtle.done()

+ 104
- 0
FUN/Vasarely/Corrections Projets/projet3.py View File

@@ -0,0 +1,104 @@
import turtle
from math import pi, sin, cos, sqrt, acos, asin, atan2
from deformation import deformation
def hexagone(point, long, coul, centre, rayon, ang):
""" Trace un hexagone suite à la déformation engendrée par une sphère émergente
Entrées :
point : coordonnées (x, y, z) du point de départ de l'hexagone AVANT déformation
long : longueur AVANT déformation des côtés de l'hexagone
coul : couleur de coloriage de l'héxagone
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
ang : angle que fait l'hexagone par rapport à l'horizontale AVANT déformation
Sorties : aucune
"""
# Soulève et positionne le crayon au point de départ (APRES déformation)
turtle.up()
turtle.goto(deformation(point, centre, rayon)[0],deformation(point, centre, rayon)[1])
turtle.down()
turtle.color(coul)
turtle.begin_fill() # Marque le début de la zone à colorier
for i in range(3):
turtle.goto(deformation((point[0] + long * cos(ang + i * pi / 3),
point[1] + long * sin(ang + i * pi / 3),0),centre,rayon)[0],
deformation((point[0] + long * cos(ang + i * pi / 3),
point[1] + long * sin(ang + i * pi / 3), 0), centre, rayon)[1])
# Repositionne le crayon au point de départ (APRES déformation)
turtle.goto(deformation(point, centre, rayon)[0],deformation(point, centre, rayon)[1])
turtle.end_fill() # Colorier le losange
return None
def cube(point, long, col, centre, rayon):
""" Trace un cube tricolore déformé par une sphère émergeante
Entrées :
point : coordonnées (x, y, z) du point de départ de l'hexagone AVANT déformation
long : longueur AVANT déformation des côtés de l'hexagone
col : couleurs (col1, col2, col3) de coloriage des faces du cube
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
Sorties : aucune
"""
for i in range(3):
hexagone(point,long, col[i],centre, rayon, i* 2*pi/3)
turtle.up()
turtle.goto(point[0],point[1]) # Repositionne le crayon au point de départ
return None
def pavage(inf_gauche, sup_droit, long, col, centre, rayon):
""" Trace un dallage déformé par une sphère émergente
Entrées :
inf_gauche : valeurs des coordonnées (x, y) du coin inférieur gauche de la zone de traçage
sup_droit : valeurs des coordonnées (x, y) du coin supérieur droit de la zone de traçage
point : coordonnées (x, y, z) du point de départ de l'hexagone AVANT déformation
long : longueur AVANT déformation des côtés du dallage
col : couleurs (col1, col2, col3) de coloriage des faces du cube
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
Sorties : aucune
"""
i=0 #Initialisation du compteur de lignes
x, y = inf_gauche, inf_gauche
while y < sup_droit:
turtle.up()
x = inf_gauche
y = inf_gauche + 2 * i * sin(pi / 3) * long
turtle.goto(x, y)
j=0 #Initialisation du compteur de colonnes
while x < sup_droit:
cube((x,y,0), long, col, centre, rayon)
cube((x + long * (cos(0) + cos(pi / 3)), y + long * (sin(0) + sin(pi / 3)),0), long, col, centre, rayon)
x += 3 * long
j+=1 # Incrémentation du numéro de colonne
i+=1 # Incrémentation du numéro de ligne
return None
# Programme principal
print("Merci de saisir les paramètres du pavage :")
print(" - coordonnée (x1,x1) du bord inférieur gauche de la fenêtre de visualisation : ",end="")
p_inf_gauche=int(input())
print(" - coordonnée (x2,x2) du bord supérieur droit de la fenêtre de visualisation : ",end="")
p_sup_droit=int(input())
print(" - longueur d’un segment de pavé (avant déformation) : ",end="")
p_long=int(input())
print(" - 1ère couleur utilisée pour colorier les pavés : ",end="")
p_col1=str(input())
print(" - 2ème couleur utilisée pour colorier les pavés : ",end="")
p_col2=str(input())
print(" - 3ème couleur utilisée pour colorier les pavés : ",end="")
p_col3=str(input())
print(" - coordonnées du centre de la sphère déformante :")
p_c_x=int(input(" x : "))
p_c_y=int(input(" y : "))
p_c_z=int(input(" z : "))
print(" - rayon de la sphère déformante : ",end="")
p_rayon=int(input())
pavage(p_inf_gauche, p_sup_droit, p_long, (p_col1,p_col2,p_col3), (p_c_x,p_c_y,p_c_z), p_rayon)
# Exemple : pavage(-310, 310, 10, ("pale turquoise","steel blue","purple"), (50,50,0), 150)
turtle.hideturtle()
turtle.getcanvas().postscript(file="pavage.eps") #Enregistrement image du pavage
turtle.done()

+ 3543
- 0
FUN/Vasarely/Corrections Projets/projet_vasarely.eps
File diff suppressed because it is too large
View File


+ 229
- 0
FUN/Vasarely/FINI.py View File

@@ -0,0 +1,229 @@
#! /usr/bin/env python3
"""
auteur: Titouan Biteau
date: 24/10/2019
but du programme:
construire un pavage d'hexagone avec une déformation sphérique
"""

# ----------------------------------------------------
# 1) Importation des différents modules utilisés -----
# ----------------------------------------------------

import turtle
from math import pi, sin, cos
from deformation import deformation

# ----------------------------------------------------
# 2) Définition des fonctions ------------------------
# ----------------------------------------------------


def losange1(point, longueur, col, centre, rayon):
"""Construit le premier losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col) # on applique la couleur
turtle.begin_fill() # on commence le remplissage
IX, IY, IZ = x, y, z = point # on déballe les coordonnées

point = (IX+longueur, IY, 0) # on se déplace successivement aux coins
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(5*pi/3)*longueur, IY+sin(5*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(4*pi/3)*longueur, IY+sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill() # fin du remplissage


def losange2(point, longueur, col, centre, rayon):
"""Construit le second losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(5*pi/3)*longueur, IY + sin(2*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def losange3(point, longueur, col, centre, rayon):
"""Construit le 3ème losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + cos(4*pi/3)*longueur, IY + sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX - longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def hexagone(point, longueur, col, centre, rayon):
"""Construit un hexagone selon différents paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

couleur1, couleur2, couleur3 = col # on déballe le tuple des couleurs
turtle.up()
x, y, z = deformation(point, centre, rayon)
# on déballe les coordonnées du point
turtle.goto(x, y) # on se rend en ces coordonnées
turtle.down()

# on trace successivement les losanges composant l'hexagone
losange1(point, longueur, couleur1, centre, rayon)
losange2(point, longueur, couleur2, centre, rayon)
losange3(point, longueur, couleur3, centre, rayon)
turtle.up()


def pavage(inf_gauche, sup_droit, longueur, col, centre, rayon):
"""Construit le pavage complet selon différents paramètres:
Entrées:
inf_gauche: tuple des coordonnées du coin inférieur gauche du pavage
sup_gauche: tuple des coordonnées du coin supérieur droit du pavage
longueur: la longueur des côtés des hexagones, du centre aux coins
col: typle contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

x_inf, y_inf = inf_gauche
# on déballe le tuple du départ (coin inférieur gauche)
x_sup, y_sup = sup_droit
# on déballe le tuple de la fin (coin supérieur droit)
count = 1 # on initialise un compteur
i = longueur # i prend la valeur de la longueur des côtés

while count <= (y_sup-y_inf) // (longueur*sin(pi/3)):
# on répète l'opération jusqu'à atteindre le haut

nombre = (x_sup-x_inf) // (longueur*3)
# nombre d'hexagone pouvant être mis sur une ligne

for i in range(nombre + 1):
# on construit la première ligne composés de 'nombre+1' hexagones
hexagone(
(x_inf + i*longueur*3, y_inf + count*sin(pi/3)*longueur, 0),
longueur, col, centre, rayon)
i += i + longueur # on incrémente i de la longueur des côtés
count += 1 # le compteur prend +1

for i in range(nombre):
# on construit la 2ème ligne composés de 'nombre' hexagones
hexagone(
(x_inf + i*longueur*3 + longueur*(3/2),
y_inf + count*sin(pi/3)*longueur, 0),
# la ligne est décalée en x par rapport à la première
longueur,
col,
centre,
rayon)

count += 1 # le compteur prend encore +1


# ----------------------------------------------------
# 3) Corps principal ---------------------------------
# ----------------------------------------------------

inf_gauche = int(input("Coordonnée du coin inférieur gauche : "))

sup_droit = int(input("Coordonnée du coin supérieur droit : "))

longueur = int(input("Entrez la longueur des côtés : "))

col1 = input('Entrez la couleur du premier losange : ')
col2 = input('Entrez la couleur du deuxième losange : ')
col3 = input('Entrez la couleur du troisième losange : ')
col = (col1, col2, col3)

centre1 = int(input("Coordonnée 'x' de la déformation : "))
centre2 = int(input("Coordonnée 'y' de la déformation : "))
centre3 = int(input("Coordonnée 'z' de la déformation : "))
centre = (centre1, centre2, centre3)

r = int(input("Entrez le rayon de la déformation sphérique : "))

turtle.setup(width=sup_droit-inf_gauche+longueur,
height=sup_droit-inf_gauche+longueur)
# on gère correctement la taille du cadre
turtle.reset()
turtle.hideturtle() # on cache la tortue
turtle.speed(0) # on dessine rapidement
turtle.tracer(9, 0)

pavage( # enfin on appel la fonction pavage avec les paramètres adaptés:
(inf_gauche, inf_gauche), # coin bas à gauche
(sup_droit, sup_droit), # coin haut à droite
longueur, # largeur de côté de 10
col, # palette de couleurs
centre, # centre de la déformation
r # taille de la déformation
)

turtle.getcanvas().postscript(file="pavage.eps")
# on enregistre l'image dans un fichier
turtle.done()

BIN
FUN/Vasarely/VASA1.png View File

Before After
Width: 718  |  Height: 698  |  Size: 319KB

BIN
FUN/Vasarely/VASA2.png View File

Before After
Width: 716  |  Height: 695  |  Size: 518KB

BIN
FUN/Vasarely/VASA3.png View File

Before After
Width: 712  |  Height: 694  |  Size: 469KB

BIN
FUN/Vasarely/VASA4.png View File

Before After
Width: 719  |  Height: 696  |  Size: 41KB

BIN
FUN/Vasarely/VASA5.png View File

Before After
Width: 710  |  Height: 617  |  Size: 51KB

BIN
FUN/Vasarely/__pycache__/deformation.cpython-37.pyc View File


+ 36
- 0
FUN/Vasarely/deformation.py View File

@@ -0,0 +1,36 @@
#!/usr/bin/env python3

from math import pi, sin, cos, sqrt, acos, asin, atan2

def deformation(p, centre, rayon):
""" Calcul des coordonnées d'un point suite à la déformation engendrée par la sphère émergeante
Entrées :
p : coordonnées (x, y, z) du point du dalage à tracer (z = 0) AVANT déformation
centre : coordonnées (X0, Y0, Z0) du centre de la sphère
rayon : rayon de la sphère
Sorties : coordonnées (xprim, yprim, zprim) du point du dallage à tracer APRÈS déformation
"""
x, y, z = p
xprim, yprim, zprim = x, y, z
xc, yc, zc = centre
if rayon**2 > zc**2:
zc = zc if zc <= 0 else -zc
r = sqrt(
(x - xc) ** 2 + (y - yc) ** 2) # distance horizontale depuis le point à dessiner jusqu'à l'axe de la sphère
rayon_emerge = sqrt(rayon ** 2 - zc ** 2) # rayon de la partie émergée de la sphère
rprim = rayon * sin(acos(-zc / rayon) * r / rayon_emerge)
if 0 < r <= rayon_emerge: # calcul de la déformation dans les autres cas
xprim = xc + (x - xc) * rprim / r # les nouvelles coordonnées sont proportionnelles aux anciennes
yprim = yc + (y - yc) * rprim / r
if r <= rayon_emerge:
beta = asin(rprim / rayon)
zprim = zc + rayon * cos(beta)
if centre[2] > 0:
zprim = -zprim
return (xprim, yprim, zprim)

if __name__ == "__main__": # code de test
for i in range(-150,150,50):
for j in range(-150,150,50):
print(deformation((i,j,0), (0,0,100), 100))
print()

BIN
FUN/Vasarely/enregistrement.mp4 View File


BIN
FUN/Vasarely/fig-léger.gif View File

Before After
Width: 672  |  Height: 568  |  Size: 1010KB

BIN
FUN/Vasarely/fig.gif View File

Before After
Width: 672  |  Height: 568  |  Size: 1.7MB

+ 10260
- 0
FUN/Vasarely/pavage.eps
File diff suppressed because it is too large
View File


+ 41082
- 0
FUN/Vasarely/pavage_degrade.eps
File diff suppressed because it is too large
View File


+ 225
- 0
FUN/Vasarely/projet_colore.py View File

@@ -0,0 +1,225 @@
#! /usr/bin/env python3
"""
auteur: Titouan Biteau
date: 24/10/2019
but du programme:
construire un pavage d'hexagone prenant en compte une déformation
"""

# 1) Importation des différents modules utilisés

import turtle
from math import pi, sin, cos
from deformation import deformation

# 3) Définition des fonctions

def losange1(point, longueur, col, centre, rayon):
"""Construit le premier losange de l'hexagone
à partir de ses différents paramètres
"""

turtle.pencolor(col) # on applique la couleur
turtle.begin_fill() # on commence le remplissage
IX, IY, IZ = x, y, z = point

point = (IX+longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(5*pi/3)*longueur, IY+sin(5*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(4*pi/3)*longueur, IY+sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill() # fin du remplissage


def losange2(point, longueur, col, centre, rayon):
"""Construit le second losange de l'hexagone à partir de ses paramètres
"""

turtle.pencolor(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(5*pi/3)*longueur, IY + sin(2*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def losange3(point, longueur, col, centre, rayon):
"""Construit le 3ème losange de l'hexagone à partir de ses paramètres
"""

turtle.pencolor(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + cos(4*pi/3)*longueur, IY + sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX - longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def hexagone(point, longueur, col, centre, rayon):
"""Construit un hexagone selon différents paramètres:

point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.up()
x, y, z = deformation(point, centre, rayon) # on déballe les coordonnées du point
turtle.goto(x, y) # on se rend en ces coordonnées
turtle.down()

# on trace successivement les losanges composant l'hexagone
losange1(point, longueur, col, centre, rayon)
losange2(point, longueur, col, centre, rayon)
losange3(point, longueur, col, centre, rayon)
turtle.up()


def pavage(inf_gauche, sup_droit, longueur, centre, rayon):
"""Construit le pavage complet selon différents paramètres:

inf_gauche: tuple des coordonnées du coin inférieur gauche du pavage
sup_gauche: tuple des coordonnées du coin supérieur droit du pavage
longueur: la longueur des côtés des hexagones, du centre aux coins
col: typle contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

x_inf, y_inf = inf_gauche
# on déballe le tuple du départ (coin inférieur gauche)
x_sup, y_sup = sup_droit
# on déballe le tuple de la fin (coin supérieur droit)
count = 1 # on initialise un compteur
i = longueur # i prend la valeur de la longueur des côtés


# De la bonne couleur !

colors = [
# reddish colors
(1.00, 0.00, 0.00),(1.00, 0.03, 0.00),(1.00, 0.05, 0.00),(1.00, 0.07, 0.00),(1.00, 0.10, 0.00),(1.00, 0.12, 0.00),(1.00, 0.15, 0.00),(1.00, 0.17, 0.00),(1.00, 0.20, 0.00),(1.00, 0.23, 0.00),(1.00, 0.25, 0.00),(1.00, 0.28, 0.00),(1.00, 0.30, 0.00),(1.00, 0.33, 0.00),(1.00, 0.35, 0.00),(1.00, 0.38, 0.00),(1.00, 0.40, 0.00),(1.00, 0.42, 0.00),(1.00, 0.45, 0.00),(1.00, 0.47, 0.00),
# orangey colors
(1.00, 0.50, 0.00),(1.00, 0.53, 0.00),(1.00, 0.55, 0.00),(1.00, 0.57, 0.00),(1.00, 0.60, 0.00),(1.00, 0.62, 0.00),(1.00, 0.65, 0.00),(1.00, 0.68, 0.00),(1.00, 0.70, 0.00),(1.00, 0.72, 0.00),(1.00, 0.75, 0.00),(1.00, 0.78, 0.00),(1.00, 0.80, 0.00),(1.00, 0.82, 0.00),(1.00, 0.85, 0.00),(1.00, 0.88, 0.00),(1.00, 0.90, 0.00),(1.00, 0.93, 0.00),(1.00, 0.95, 0.00),(1.00, 0.97, 0.00),
# yellowy colors
(1.00, 1.00, 0.00),(0.95, 1.00, 0.00),(0.90, 1.00, 0.00),(0.85, 1.00, 0.00),(0.80, 1.00, 0.00),(0.75, 1.00, 0.00),(0.70, 1.00, 0.00),(0.65, 1.00, 0.00),(0.60, 1.00, 0.00),(0.55, 1.00, 0.00),(0.50, 1.00, 0.00),(0.45, 1.00, 0.00),(0.40, 1.00, 0.00),(0.35, 1.00, 0.00),(0.30, 1.00, 0.00),(0.25, 1.00, 0.00),(0.20, 1.00, 0.00),(0.15, 1.00, 0.00),(0.10, 1.00, 0.00),(0.05, 1.00, 0.00),
# greenish colors
(0.00, 1.00, 0.00),(0.00, 0.95, 0.05),(0.00, 0.90, 0.10),(0.00, 0.85, 0.15),(0.00, 0.80, 0.20),(0.00, 0.75, 0.25),(0.00, 0.70, 0.30),(0.00, 0.65, 0.35),(0.00, 0.60, 0.40),(0.00, 0.55, 0.45),(0.00, 0.50, 0.50),(0.00, 0.45, 0.55),(0.00, 0.40, 0.60),(0.00, 0.35, 0.65),(0.00, 0.30, 0.70),(0.00, 0.25, 0.75),(0.00, 0.20, 0.80),(0.00, 0.15, 0.85),(0.00, 0.10, 0.90),(0.00, 0.05, 0.95),
# blueish colors
(0.00, 0.00, 1.00),(0.05, 0.00, 1.00),(0.10, 0.00, 1.00),(0.15, 0.00, 1.00),(0.20, 0.00, 1.00),(0.25, 0.00, 1.00),(0.30, 0.00, 1.00),(0.35, 0.00, 1.00),(0.40, 0.00, 1.00),(0.45, 0.00, 1.00),(0.50, 0.00, 1.00),(0.55, 0.00, 1.00),(0.60, 0.00, 1.00),(0.65, 0.00, 1.00),(0.70, 0.00, 1.00),(0.75, 0.00, 1.00),(0.80, 0.00, 1.00),(0.85, 0.00, 1.00),(0.90, 0.00, 1.00),(0.95, 0.00, 1.00)
]
c = 0
x = 0

while count <= (y_sup-y_inf) // (longueur*sin(pi/3)):

# COULEUR
idx = int(c)
color = colors[idx]

# on répète l'opération jusqu'à atteindre le haut

nombre = (x_sup-x_inf) // (longueur*3)
# nombre d'hexagone pouvant être mis sur une ligne

for i in range(nombre + 1):
# on construit la première ligne composés de 'nombre+1' hexagones
hexagone(
(x_inf + i*longueur*3, y_inf + count*sin(pi/3)*longueur, 0),
longueur, (color), centre, rayon)
i += i + longueur # on incrémente i de la longueur des côtés
count += 1 # le compteur prend +1

c += 1.00
idx = int(c)
color = colors[idx]

for i in range(nombre):
# on construit la 2ème ligne composés de 'nombre' hexagones
hexagone(
(x_inf + i*longueur*3 + longueur*(3/2),
y_inf + count*sin(pi/3)*longueur, 0),
longueur, (color), centre, rayon)
# la ligne est décalée en abscisse par rapport à la première
count += 1 # le compteur prend encore +1

# COULEUR
x += 1
c += 1.25
# 'c' est à réduire légèrement si la taille des coordonnées est > 300


# 4) Corps principal

inf_gauche = int(input("Entrez la valeur des coordonnées du coin inférieur gauche : "))

sup_droit = int(input("Entrez la valeur des coordonnées du coin supérieur droit : "))

longueur = int(input("Entrez la longueur des côtés : "))

centre1 = int(input("Entrez la valeur de la coordonnée 'x' de la déformation : "))
centre2 = int(input("Entrez la valeur de la coordonnée 'y' de la déformation : "))
centre3 = int(input("Entrez la valeur de la coordonnée 'z' de la déformation : "))
centre = (centre1, centre2, centre3)

r = int(input("Entrez le rayon de la déformation sphérique : "))

turtle.setup(width=sup_droit-inf_gauche+longueur, height=sup_droit-inf_gauche+longueur)
# on gère correctement la taille du cadre
turtle.reset()
turtle.bgcolor('black') # le fond est noir
turtle.hideturtle() # on cache la tortue
turtle.speed(0) # on veut dessiner rapidement
turtle.tracer(9, 0)

pavage( # enfin on appel la fonction pavage avec les paramètres adaptés:
(inf_gauche, inf_gauche), # coin bas à gauche
(sup_droit, sup_droit), # coin haut à droite
longueur, # largeur de côté de 10
centre, # centre de la déformation
r # taille de la déformation
)

turtle.getcanvas().postscript(file="pavage_degrade.eps")
# on enregistre l'image dans un fichier
turtle.done()

+ 228
- 0
FUN/Vasarely/projet_finalisee.py View File

@@ -0,0 +1,228 @@
#! /usr/bin/env python3
"""
auteur: Titouan Biteau
date: 24/10/2019
but du programme:
construire un pavage d'hexagone avec une déformation sphérique
"""

# ----------------------------------------------------
# 1) Importation des différents modules utilisés -----
# ----------------------------------------------------

import turtle
from math import pi, sin, cos
from deformation import deformation

# ----------------------------------------------------
# 2) Définition des fonctions ------------------------
# ----------------------------------------------------


def losange1(point, longueur, col, centre, rayon):
"""Construit le premier losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col) # on applique la couleur
turtle.begin_fill() # on commence le remplissage
IX, IY, IZ = x, y, z = point # on déballe les coordonnées

point = (IX+longueur, IY, 0) # on se déplace successivement aux coins
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(5*pi/3)*longueur, IY+sin(5*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(4*pi/3)*longueur, IY+sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill() # fin du remplissage


def losange2(point, longueur, col, centre, rayon):
"""Construit le second losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(5*pi/3)*longueur, IY + sin(2*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def losange3(point, longueur, col, centre, rayon):
"""Construit le 3ème losange de l'hexagone à partir de ses paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.color(col)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + cos(4*pi/3)*longueur, IY + sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX - longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def hexagone(point, longueur, col, centre, rayon):
"""Construit un hexagone selon différents paramètres
Entrées:
point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
col: tuple contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

couleur1, couleur2, couleur3 = col # on déballe le tuple des couleurs
turtle.up()
x, y, z = deformation(point, centre, rayon)
# on déballe les coordonnées du point
turtle.goto(x, y) # on se rend en ces coordonnées
turtle.down()

# on trace successivement les losanges composant l'hexagone
losange1(point, longueur, couleur1, centre, rayon)
losange2(point, longueur, couleur2, centre, rayon)
losange3(point, longueur, couleur3, centre, rayon)
turtle.up()


def pavage(inf_gauche, sup_droit, longueur, col, centre, rayon):
"""Construit le pavage complet selon différents paramètres:
Entrées:
inf_gauche: tuple des coordonnées du coin inférieur gauche du pavage
sup_gauche: tuple des coordonnées du coin supérieur droit du pavage
longueur: la longueur des côtés des hexagones, du centre aux coins
col: typle contenant les trois couleurs (couleur1, couleur2, couleur3)
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

x_inf, y_inf = inf_gauche
# on déballe le tuple du départ (coin inférieur gauche)
x_sup, y_sup = sup_droit
# on déballe le tuple de la fin (coin supérieur droit)
count = 1 # on initialise un compteur
i = longueur # i prend la valeur de la longueur des côtés

while count <= (y_sup-y_inf) // (longueur*sin(pi/3)):
# on répète l'opération jusqu'à atteindre le haut

nombre = (x_sup-x_inf) // (longueur*3)
# nombre d'hexagone pouvant être mis sur une ligne

for i in range(nombre + 1):
# on construit la première ligne composés de 'nombre+1' hexagones
hexagone(
(x_inf + i*longueur*3, y_inf + count*sin(pi/3)*longueur, 0),
longueur, col, centre, rayon)
i += i + longueur # on incrémente i de la longueur des côtés
count += 1 # le compteur prend +1

for i in range(nombre):
# on construit la 2ème ligne composés de 'nombre' hexagones
hexagone(
(x_inf + i*longueur*3 + longueur*(3/2),
y_inf + count*sin(pi/3)*longueur, 0),
# la ligne est décalée en x par rapport à la première
longueur,
col,
centre,
rayon)

count += 1 # le compteur prend encore +1


# ----------------------------------------------------
# 3) Corps principal ---------------------------------
# ----------------------------------------------------

inf_gauche = int(input("Coordonnée du coin inférieur gauche : "))

sup_droit = int(input("Coordonnée du coin supérieur droit : "))

longueur = int(input("Entrez la longueur des côtés : "))

col1 = input('Entrez la couleur du premier losange : ')
col2 = input('Entrez la couleur du deuxième losange : ')
col3 = input('Entrez la couleur du troisième losange : ')
col = (col1, col2, col3)

centre1 = int(input("Coordonnée 'x' de la déformation : "))
centre2 = int(input("Coordonnée 'y' de la déformation : "))
centre3 = int(input("Coordonnée 'z' de la déformation : "))
centre = (centre1, centre2, centre3)

r = int(input("Entrez le rayon de la déformation sphérique : "))

turtle.setup(width=sup_droit-inf_gauche+longueur,
height=sup_droit-inf_gauche+longueur)
# on gère correctement la taille du cadre
turtle.reset()
turtle.hideturtle() # on cache la tortue
turtle.speed(0) # on dessine rapidement

pavage( # enfin on appel la fonction pavage avec les paramètres adaptés:
(inf_gauche, inf_gauche), # coin bas à gauche
(sup_droit, sup_droit), # coin haut à droite
longueur, # largeur de côté de 10
col, # palette de couleurs
centre, # centre de la déformation
r # taille de la déformation
)

turtle.getcanvas().postscript(file="pavage.eps")
# on enregistre l'image dans un fichier
turtle.done()

+ 208
- 0
FUN/Vasarely/projet_random.py View File

@@ -0,0 +1,208 @@
#! /usr/bin/env python3
"""
auteur: Titouan Biteau
date: 24/10/2019
but du programme:
construire un pavage d'hexagone prenant en compte une déformation
"""

# 1) Importation des différents modules utilisés

import turtle
from math import pi, sin, cos
from deformation import deformation
from random import randint # on a besoin de random

# 3) Définition des fonctions

def losange1(point, longueur, col, centre, rayon):
"""Construit le premier losange de l'hexagone
à partir de ses différents paramètres
"""

r, g, b = col
turtle.pencolor(r, g, b) # on applique la couleur
turtle.begin_fill() # on commence le remplissage
IX, IY, IZ = x, y, z = point

point = (IX+longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(5*pi/3)*longueur, IY+sin(5*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX+cos(4*pi/3)*longueur, IY+sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill() # fin du remplissage


def losange2(point, longueur, col, centre, rayon):
"""Construit le second losange de l'hexagone à partir de ses paramètres
"""

r, g, b = col
turtle.pencolor(r, g, b)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(5*pi/3)*longueur, IY + sin(2*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def losange3(point, longueur, col, centre, rayon):
"""Construit le 3ème losange de l'hexagone à partir de ses paramètres
"""

r, g, b = col
turtle.pencolor(r, g, b)
turtle.begin_fill()
IX, IY, IZ = x, y, z = point

point = (IX + cos(4*pi/3)*longueur, IY + sin(4*pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX - longueur, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX + cos(4*pi/3)*longueur, IY + sin(pi/3)*longueur, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)

point = (IX, IY, 0)
x, y, z = deformation(point, centre, rayon)
turtle.goto(x, y)
turtle.end_fill()


def hexagone(point, longueur, centre, rayon):
"""Construit un hexagone selon différents paramètres:

point: le centre de l'hexagone (tuple de 3 composantes)
longueur: la longueur des côtés de l'hexagone, du centre aux coins
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

turtle.up()
x, y, z = deformation(point, centre, rayon) # on déballe les coordonnées du point
turtle.goto(x, y) # on se rend en ces coordonnées
turtle.down()

# on trace successivement les losanges composant l'hexagone

# 16 777 216 couleurs différentes
r = randint(0,255) # On génère des nombres aléatoires qui vont être,
g = randint(0,255) # attribués successivement à R, G, B
b = randint(0,255) # Changement à chaque nouvelle boucle
losange1(point, longueur, (r, g, b), centre, rayon)
r = randint(0,255) # On génère des nombres aléatoires qui vont être,
g = randint(0,255) # attribués successivement à R, G, B
b = randint(0,255) # Changement à chaque nouvelle boucle
losange2(point, longueur, (r, g, b), centre, rayon)
r = randint(0,255) # On génère des nombres aléatoires qui vont être,
g = randint(0,255) # attribués successivement à R, G, B
b = randint(0,255) # Changement à chaque nouvelle boucle
losange3(point, longueur, (r, g, b), centre, rayon)
turtle.up()


def pavage(inf_gauche, sup_droit, longueur, centre, rayon):
"""Construit le pavage complet selon différents paramètres:

inf_gauche: tuple des coordonnées du coin inférieur gauche du pavage
sup_gauche: tuple des coordonnées du coin supérieur droit du pavage
longueur: la longueur des côtés des hexagones, du centre aux coins
centre: centre de la sphère déformation (tuple de 3 composantes)
rayon: rayon de la sphère de déformation
"""

x_inf, y_inf = inf_gauche
# on déballe le tuple du départ (coin inférieur gauche)
x_sup, y_sup = sup_droit
# on déballe le tuple de la fin (coin supérieur droit)
count = 1 # on initialise un compteur
i = longueur # i prend la valeur de la longueur des côtés

while count <= (y_sup-y_inf) // (longueur*sin(pi/3)):

# on répète l'opération jusqu'à atteindre le haut

nombre = (x_sup-x_inf) // (longueur*3)
# nombre d'hexagone pouvant être mis sur une ligne

for i in range(nombre + 1):
# on construit la première ligne composés de 'nombre+1' hexagones
hexagone(
(x_inf + i*longueur*3, y_inf + count*sin(pi/3)*longueur, 0),
longueur, centre, rayon)
i += i + longueur # on incrémente i de la longueur des côtés
count += 1 # le compteur prend +1

for i in range(nombre):
# on construit la 2ème ligne composés de 'nombre' hexagones
hexagone(
(x_inf + i*longueur*3 + longueur*(3/2),
y_inf + count*sin(pi/3)*longueur, 0),
longueur, centre, rayon)
# la ligne est décalée en abscisse par rapport à la première
count += 1 # le compteur prend encore +1

# 4) Corps principal

inf_gauche = int(input("Entrez la valeur des coordonnées du coin inférieur gauche : "))

sup_droit = int(input("Entrez la valeur des coordonnées du coin supérieur droit : "))

longueur = int(input("Entrez la longueur des côtés : "))

centre1 = int(input("Entrez la valeur de la coordonnée 'x' de la déformation : "))
centre2 = int(input("Entrez la valeur de la coordonnée 'y' de la déformation : "))
centre3 = int(input("Entrez la valeur de la coordonnée 'z' de la déformation : "))