======= Défi OpenSCAD Pyramide ======
<!-- Complétez la fiche projet ci dessous -->
{{{project
logiciels: OpenSCAD
fichiers:
usager: bully plogingenu
licence:cc-by-nc

}}}

{{:animations:ateliers_openscad:exercices:defiopenscad_pyramidemethodee.png?200  }}


**Consigne : Réaliser une pyramide à base carrée !**
  * méthode A : 1 ligne & 1 fonction différente //>Il s'agit du défi de fin de l'atelier d'initiation OpenSCAD. //
  * méthode B : 15 lignes & 3 fonctions différentes
  * méthode C : 3 lignes & 3 fonctions différentes
  * méthode D : 3 lignes & 3 fonctions différentes
  * méthode E : 1 lignes & 1 fonction différente


{{:animations:ateliers_openscad:exercices:defiopenscad_pyramide_methodee.stl | Voir l'objet en 3D}}


Besoin d'aide, lisez la suite !


===== Vidéo =====
// Ne présente pas la méthode E. //
{{:animations:ateliers_openscad:exercices:os_defi_pyramide.mp4|}}


===== Aides =====

==== 1. Réfléchissez ====

Prenez vraiment le temps de réfléchir (papier et crayon peuvent être utile )


==== 2. Phrase explicative  ====

Si vous ne savez pas par où commencer :

  * **méthode A :** Astuce OpenSCAD : Contraindre le nombre de facettes à 4 d'un cône
  * **méthode B :** Extruder les 4 faces d'un cube
  * **méthode C :** Relier en continu, un grand cube de base à un minuscule cube de sommet 
  * **méthode D :** Cumuler des parallélépipède de plus en plus petit
  * **méthode E :** Faites votre pyramide en mode polyèdre  


==== 3. Les fonctions utiles ====



**méthode A :**
  * le cylindre/cône : //cylinder(d1,d2,h);//
  * le paramètre du nombre de facettes : //$fn //

**méthode B :**
  * la différence : //difference(){...}//
  * le cube : //cube();//
  * la rotation : //rotate([x,y,z]){...}//

**méthode C :**
  * la fonction "Coque" : // hull(){...}//
  * le cube : //cube();//
  * le déplacement : //translate([x,y,z]){...}//

**méthode D :**
  * la boucle for : // for(){...}//
  * le cube : //cube();//
  * le déplacement : //translate([x,y,z]){...}//

**méthode E :**
  * le polyèdre : //polyhedron();//


<note tip>Si vous ne connaissez pas bien l'utilisation d'une de ces fonctions, il peut être utile d'aller voir les exercices du wiki ou la page Aide-Mémoire OpenSCAD.</note>



==== 4. Pièges à éviter ==== 

**En général :**
  * Le point-virgule
  * Bien ouvrir et fermer les parenthèses, crochets et accolades
  * Les erreurs de frappe

**méthode A :**
  - Connaitre l'astuce $fn=, qui contraint le nombre de faces d'un objet.

**méthode B :**
  - Créer un cube
  - Extrudé avec un autre parallélépipède sur un face
  - Puis généraliser le principe aux 3 autres faces

**méthode C :**
  - Créer un parallélépipède centrée, de faible hauteur (0.1mm ou moins) et d'une largeur de 20mm
  - Créer un parallélépipède centrée, de faible hauteur (0,1mm ou moins) et d'un faible largeur 0.1mm
  - Déplacer le petit parallélépipède jusqu'au sommet de la pyramide
  - Englober le code précédemment écrit dans un hull().

**méthode D :**
  - Créer un parallélépipède centrée, de faible hauteur (1 mm) et d'une largeur de 20mm
  - Créer un second, de la même hauteur (ou hauteur cumulée au choix) légèrement plus moins larges, qui est au dessus du premier (ou qui dépasse du premier)
  - Une fois la logique de passage, entre les différents cube comprises, généraliser la logique en utilisant une boucle for()

**méthode E :**
  - Partir sur une pyramide dont la base est centrée sur le plan XY
  - Déterminer les coordonnées des 5 points qui seront utilisés : les 4 points de la base (dont le z=0) et le sommet de la pyramide (dont le x=0 et le y=0)
  - Entrer les coordonnées de ces points dans l'ordre, points=[ [sommet], [point1],[point2] ,[point3] , [point4] ]
  - Entrer les combinaisons qui composent les différentes faces. Attention, OpenSCAD ne commence pas à compter à un 1 mais à 0. Le sommet est un ainsi égale à 0, le point 1 au  1, le point 2 au 2, le point 3 au 3 et le point 4 au 4. La première face est la base de la pyramide avec les 4 points, puis suivent les 4 faces de la pyramide chacune composé de 3 points, dont le sommet.



===== Solutions =====

Une pyramide de 20 mm de côté et de hauteur 

**méthode A :** 
<code java>
c=20;// côté de la pyramide, ici 20 mm
cylinder(r1=c,r2=0,h=c/2,$fn=4);
</code>


**méthode B :** 
<code java>
c=20;// côté de la pyramide, ici 20 mm

difference(){
    translate([0,0,c/5]){
            cube([c,c,c/2],center=true);
    }
    rotate([-45,0,0]){
        translate([0,0,c/2]){
            cube([c,c,c/2],center=true);
        }
    }
    rotate([45,0,0]){
        translate([0,0,c/2]){
            cube([c,c,c/2],center=true);
        }
    }
     rotate([0,45,0]){
        translate([0,0,c/2]){
            cube([c,c,c/2],center=true);
        }
    }
     rotate([0,-45,0]){
        translate([0,0,c/2]){
            cube([c,c,c/2],center=true);
        }
    }
}
</code>


**méthode C :** 
<code java>
c=20;// côté de la pyramide, ici 20 mm
hull(){
    cube([c,c,0.01], center=true);
    translate([0,0,c]){cube([0.01,0.01,1],center=true);}
 }
</code>


**méthode D :** 
<code java>
c=20;// côté de la pyramide, ici 20 mm
for(i=[0:c]){
    translate([0,0,i]){
        cube([c-i,c-i,1],center=true);
    }
}
</code>


**méthode E :** 
<code java>
c=20; //le côté de la pyramide, ici, 20mm
polyhedron (
 points=[[0,0,c/2], [-c/2,-c/2,0], [-c/2,c/2,0],[c/2,c/2,0], [c/2,-c/2,0] ],
 faces=[[1,2,3,4],[0,1,2],[0,2,3],[0,3,4],[0,1,4] ]
);
</code>