Étiquette : SVT

Projets

Une brève navigation dans l’espace sur python

Naviguez au cœur du système solaire, et découvrez les caractéristiques de chaque planètes qui le composent, soit, la période de révolution, la distance au soleil, la masse, le rayon et enfin les satellites connus (leur nombre) …

Ce projet est un programme réalisé sur python permettant de naviguer dans l’espace, et plus précisément dans notre système solaire. Il permet de découvrir les caractéristiques des planètes qui le compose, soit, la période de révolution, la distance au soleil, la masse, le rayon et enfin les satellites connus (nombre). Ce programme a été developpé sur omega et peut être téléchargeable sur la calculatrice Numworks via les liens hypertextes en bas de l’article.

Difficultés rencontrées…

À la genèse de notre projet, nous fûmes légèrement idéaliste quant à nos capacités, et à celles de la calculatrice ; nous voulions créer une animation, tel un court-métrage, avec l’histoire du big bang se déroulant sous nos yeux ébahis, puis la galaxie, et enfin atterrir dans notre système solaire, qui aurait été animé… Après un dur retour à la réalité, nous nous sommes accordées pour simplifier notre concept originel. Malgré avoir réalisé une deuxième couche graphique composée d’un trou noir ; Saggitarius A*, au centre de notre galaxie, et du système solaire, nous n’avons pu l’insérer dans le code initial.

Comment tout a commencé…

Notre programme a été conçu en deux grandes phases :

  • la couche graphique
  • l’interaction

La couche graphique

Premièrement, il a fallu tracer des cercles pour retrouver la forme des planètes, et insérer des dégradés afin de s’approcher au plus des couleurs initiales, en adoptant les modules mathkandinsky et random.Retour ligne automatique
Cette image a été le pilier de la création du fond graphique :

Pour ce faire, du à nos faibles connaissances en python, nous sommes allées nous renseigner auprès du célèbre Philippe Moutou.

def cercle(x0,y0,r,c,e):# fonction pour tracer contour du cercle
 for i in range(2*e):
   xd=x0-int((r-i*0.5)/sqrt(2))
   xf=x0+int((r-i*0.5)/sqrt(2))
   for x in range(xd,xf+1):
     x1=x
     y1=y0+int(sqrt((r-i*0.5)**2-(x-x0)**2))
     set_pixel(x,y1,c)
     for j in range(3):
       x2=x0+y1-y0
       y2=y0+x0-x1
       set_pixel(x2,y2,c)
       x1,y1=x2,y2
 
def cercle_plein(x0,y0,r,c1,e,c2): #remplir le cercle
 cercle(x0,y0,r,c1,e)
 cercle(x0,y0,r-e,c2,r-e)
 
def cercle_grade(x0,y0,R,c1,e,c2):#faire un dégradé de couleur
 for i in range(R):
   r=c1[0]+i*(c2[0]-c1[0])//R
   g=c1[1]+i*(c2[1]-c1[1])//R
   b=c1[2]+i*(c2[2]-c1[2])//R
   cercle(x0,y0,i,color(r,g,b),1)

Grâce à son génie, nous n’avons eu qu’à changer couleurs, rayons ou encore coordonnées dans les diverses fonctions, et créer des listes pour regrouper les différents globes, soit neuf au total en comptant l’astre qui nous fournit en énergie. Pour trouver les couleurs appropriées, nous nous sommes servies de code couleur html, afin de concevoir le plus précisément possible les textures.

Voici un exemple d’appel de fonction, qui a été fait pour chaque planète, et mis dans une liste pour simplifier le code :

cExt=[251,136,7]
cInt= [106,73,32]
cercle_grade(197,95,8,cExt,10,cInt)

Ensuite nous sommes passées à la conception du fond étoilé avec toujours l’aide de notre cher Moutou :

def degrade(c1,c2,k):
 dr=c2[0]-c1[0]
 dg=c2[1]-c1[1]
 db=c2[2]-c1[2]
 return color(c1[0]+int(k*dr),c1[1]+int(k*dg),c1[2]+int(k*db))
 
def tirage(n):
 for i in range(n):
   x=randint(0,320)
   y=randint(0,222)
   c=couleur(x,y)
   set_pixel(x,y,c)
   set_pixel(x+1,y,c)
   set_pixel(x,y+1,c)
   set_pixel(x+1,y+1,c)
 
def couleur(x,y):
 d=sqrt((x-160)**2+(y-111)**2)/32.5
 return degrade(c[int(d)],c[(int(d)+1)%6],d-int(d))

Il nous a suffit de changer les couleurs pour faire un magnifique dégradé galactique, et effectuer un tirage non exhaustif afin de révéler des points blancs.

c=[[235,128,0],[13,89,175],[13,89,175],[44,122,211],[207,230,230],[207,230,230]]
tirage(250)

Pour afficher les anneaux blancs qui représentent l’orbite de chaque planète, rien de plus simple, il suffit d’appeler la fonction traçant le contour d’un cercle.

Etant donné qu’il y a 8 planètes on se sert de la variable for in range :

c_blanc=[119,135,135]
r_orb = [22,32,42,52,62,76,92,109]
for i in range(8):
   cercle(160,111,r_orb[i],c_blanc,1)

Bien évidemment cet appel de fonction doit se faire après celui du fond étoilé, mais avant celui des planètes, pour que tout se superpose parfaitement.

Voici le résultat escompté après de maints efforts :

L’interactivité :

Méconnus du grand public, les modules time et ion ont été le support de cette interaction, utilisée pour naviguer entre les diverses planètes, grâce aux flèches du keyboard, numérotées de 0 à 3. En effet, grâce au getkey, disponible sur omega, qui est la capacité de la calculatrice à détecter si une touche est pressée, le déplacement devient envisageable.

Après plusieurs essais désastreux pour cette tâche plus complexe, nous avons chercher de l’aide auprès d’une source externe ; un grand mage.

Nous avons alors pu avoir accès à un fragment d’un de ses sortilèges que nous avons dû comprendre de nous même pour la suite de notre programme.

On définit tout d’abord dans une liste toutes les caractéristiques des planètes étudiées :

systeme = [ ("Soleil",'centre du sytème solaire','dis soleil: 0','masse: 1,989 × 10^30 kg','rayon: 696340 km', 'satellites connus: 0'),
           ("Venus",'periode de revo: 225 jours','dis soleil: 104 millions km','masse: 4,867 × 10^24 kg','rayon: 6051.8 km', 'satellites connus: 0'),
           #etc pour toutes les planètes
           ]
 
coord = [(160,111,16), (185,95,8)#etc...]
couleur1 = [[255,255,0], [190,183,150]#etc...]
couleur2 = [[235,128,0], [121,104,83]#etc...]

Ensuite on crée une fonction qui permet de tracer un rond blanc à la place de l’astre choisi lorsque degrade n’est pas égal à 1 (égal à un de base), sinon les astres restent tel quel.

def solar_systeme_dessine(n, degrade=1):
 # Affiche un corps du sytème solaire, numéro du corps dans systeme[], degradé
 p = 2 + 9 * (n != 0)
 if degrade == 1:
   cercle_grade(coord[n][0], coord[n][1], coord[n][2], couleur1[n], p, couleur2[n])
 else:
   cercle_grade(coord[n][0], coord[n][1], coord[n][2], [255,255,255], p, [255,255,255])

Avec l’ajout d’un code pour définir les touches et leur mouvement, ainsi qu’un autre pour afficher le texte voulu, on peut désormais naviguer entre les différents astres et voir leurs caractéristiques !

Conclusion

Pour pouvoir profiter du système solaire, il vous faudra donc télécharger le code via le lien en bas de page, et manipuler les flèches pour vous déportez sur les diverses planètes. Pour afficher les informations liées à chaque globe, vous manipulerez les flèches du haut et du bas. 
Bon exode planétaire !

La prochaine fois que quelqu’un se plaint que vous avez fait une erreur, dites-lui que c’est peut-être une bonne chose. Parce que sans imperfections, ni toi ni moi n’existerions.
Stephen Hawking

Télécharger et tester

Serveur Workshop de NumWorks tiplanet.org nsi.xyz 
RemarquesPermet un téléchargement rapide sur la calculatriceTéléchargement .pyTéléchargement .zip
Liens hypertexteslienNumWorks > Physique > Lien