Un rafale en AxiDraw

Il est parfois compliqué de se motiver pour travailler surtout en période de vacance scolaire. C’est pourquoi j’ai choisis lors de ce projet de NSI de mêler travail et passion en vous proposant un projet en lien avec l’aéronautique.

Naissance du projet :

Lorsque nos professeurs ont présenté les différentes possibilités parmi lesquelles nous pourrions réaliser notre projet, j’ai tout de suite pensé à utiliser l’ Axidraw et ce pour plusieurs raisons.

Tout d’abord, pour découvrir cette machine mais aussi pour les nombreuses possibilités d’utilisation que cette mécanique avait à m’offrir.

Ensuite, j’ai utilisé la maxime  » Il faut joindre l’utile à l’agréable » en choisissant d’utiliser ma passion, qui est celle de l’aéronautique, afin de pouvoir travailler sans regret durant les vacances.

C’ est ainsi que je me suis mis à coder un Rafale ( un célèbre avion de chasse Français ), en python !

Développement du projet

Pour commencer, il me fallait une image sur papier, une sorte de plan, de ce à quoi je voulais que mon Rafale ressemble, et ce tout en traits puisque l’Axidraw ne peut tracer de courbes.

Ma « feuille de route », une véritable œuvre d’art…

Mise en place

Une fois après avoir réalisé mon esquisse, il ne restait plus qu’à mettre à l’échelle mes différentes valeurs que je pouvais dès maintenant mesurer à la règle.

Ainsi, on obtenait :

• 1cm sur la feuille en longueur -> 30 de longueur pour l’AXIDRAW
• 1cm sur la feuille en largeur -> 36.5 de largeur pour l’AXIDRAW.

Ensuite, j’ai crée de nombreuses listes que j’ai ensuite appelé en utilisant les fonctions mises à notre disposition par nos professeurs de NSI :

percheravito = [[153,317.55], [141,295.65],[141,295.65], [117,292], [117,288.35], [147,292],[156,313.9]]
haut_aileron = [[759,193,45],[828,193.45],[804,175.2],[784.5,175.2]]
segments(percheravito)
polygone(haut_aileron)

Ainsi, dans l’exemple ci-dessus nous pouvons voir la liste permettant de faire la perche qui sert au ravitaillement en vol du rafale avec son appellation par la fonctions segments qui relie les points aux coordonnées x et y définis dans ma liste. L’appellation de la fonction polygone va elle rajouter un segment qui ira de mon premier point au dernier présent dans la liste haut_aileron afin de former un polygone.

Création des verrières du rafale.

Comme vous avez pu le voir dans mon esquisse de l’œuvre que je voulais produire, les verrières du rafale devaient être constellées de traits afin de donner un esthétique au rendu final mais aussi afin d’introduire quelques fonctions dans ma création.

Mais, je ne pouvais pas créer une seule et même fonction que j’appellerai pour les trois verrières puisque ces mêmes verrières étaient disposées à des endroits différents et séparés par l’armature de l’avion.

image des différentes verrières que je voulais remplir

Ainsi, j’ai du créer trois verrières :

Première verrière :

Pour cette première verrière, vu sa configuration, je n’avais pas besoin de créer un code trop important. En effet, une simple boucle for permettrait de répéter x fois en fonction du nombre de répétitions des segments, grâce à la fonctions segments fournie, en décalant x_depart, y_depart et y_arrivee à chaque répétition. Ainsi, nous obtenons ce code :

def trait(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float, repetitions: int):
    for i in range(repetitions):
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 4.5
        y_depart -= 2.25
        y_arrivee -= 2.25

Seconde verrière :

Pour cette verrière, il n’était cette fois plus question de prendre une boucle for puisque si vous regardez bien elle se compose de deux parties. J’ai donc utilisé une succession de deux boucles while consécutives qui détermineraient les variations des points x et y en fonction des coordonnées d’arrivée des points de mes segments.

def traits(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float, ):
    while x_depart >= 209 and y_depart >= 270:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart -= 1
        x_arrivee += 0.75
        y_depart -= 2.25
        y_arrivee -= 2.25

    while x_depart <= 255 and y_depart >= 273.75:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 6.5
        x_arrivee += 0.25
        y_depart -= 2.25
        y_arrivee -= 2.25

Troisième verrière :

Pour cette troisième verrière, j’ai réutilisé le code de ma seconde verrière en changeant les points x_depart, x_arrivee, y_depart, y_arrivee ainsi que les variations de ces points en fonction des boucles while ce qui nous donne :

def traittss(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float):
    while x_arrivee <= 360 and y_arrivee >= 290.75:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0.8
        x_arrivee += 1.2
        y_depart -= 2.25
        y_arrivee -= 2.25

    while y_depart >= 278:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0.3
        x_arrivee -= 8
        y_depart -= 2.25
        y_arrivee -= 2.25

Compte rendu final des verrières :

Ainsi, après avoir appelé ces fonctions j’obtenais les verrières en image ci-dessous :

Néanmoins, comme vous vous en doutez surement, cette réalisation n’a pas été aussi facile que ce qu’il vous a été présenté puisque il a fallu calculer les variations des points x et tester différentes variations des points y afin d’obtenir le meilleur rendu visuel.

Création du réacteur :

Pour le réacteur, j’ai souhaité ajouter des segments de la même manière que pour mes verrières. J’ai donc repris le code utilisant les boucles while que j’ai développé puisqu’il ma fallu créer une troisième boucle while pour obtenir le rendu souhaité.

def react(x_depart: float, y_depart: float, x_arrivee: float, y_arrivee: float):
    while  y_arrivee >= 405.15:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0
        x_arrivee += 10
        y_depart -= 5
        y_arrivee -= 5

    while y_arrivee >= 372:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart += 0
        x_arrivee += 0
        y_depart -= 5
        y_arrivee -= 5
        
    while y_arrivee >= 355.875:
        segment(x_depart, y_depart, x_arrivee, y_arrivee)
        x_depart -= 0
        x_arrivee -= 10
        y_depart -= 5
        y_arrivee -= 5

L’exécution de ce code ma ensuite donné ce rendu :

Dernières finitions :

Maintenant que les parties complexes de mon code ont été réalisées, il ne me restait plus que deux choses à faire :

• Positionner la fameuse cocarde tricolore ( qui sera unicolore sur mon rendu graphique car l’Axidraw ne prend pas en charge les couleurs ) sur mon rafale.
• « Légender » mon œuvre en écrivant le nom de l’avion représenté en dessous.

Pour la cocarde, je n’eu qu’à utiliser la fonction cercle déjà donnée et en tracer deux consécutivement, avec le même centre mais avec le rayon du second cercle moitié moins grand que le rayon du premier cercle.

Pour légender le dessin obtenu, il ne me restait seulement qu’ à exécuter une succession de segments formant le mot RAFALE.

Conclusion :

Ainsi, ce projet m’a permis de normaliser mon utilisation des fonctions et des listes. Néanmoins, je pense que de nombreuses améliorations auraient pu être possible avec un peu plus de temps notamment en ajoutant des segments pour rendre mon image plus précise mais aussi en modifiant la bordure dessinée par l’Axidraw afin qu’elle mette plus en valeur le rafale représenté.

Mais je dois quand même ajouter que je suis fier de ce que j’ai déjà réalisé car jamais je ne me serais attendu à un rendu comme celui là en n’ utilisant que des segments !

Télécharger le .py :

L’image finale :

Samuel V.

Elève de 1ère au lycée Louis Pasteur en spé MATHS, PHYSIQUE et NSI (2022).

Passionné d’aviation et de sport.