Tutoriel OpenSCAD

Introduction

"OpenSCAD est un logiciel pour créer des objets CAD solides 3D. C'est un logiciel gratuit et disponible pour Linux / UNIX, MS Windows et Apples OS X. Contrairement à la plupart des logiciels libres pour créer des modèles 3D (comme Blender), il ne se concentre pas sur les aspects artistiques de la modélisation 3D, mais plutôt sur les aspects CAD. Ainsi, il pourrait être le logiciel à envisager pour créer des modèles 3D de pièces de machines, mais pas lorsque vous êtes plus intéressés par la création de films animés par ordinateur. OpenSCAD n'est pas un programme de modélisation interactif. Il est plus comme un compilateur 3D qui lit dans un fichier de script une description de l'objet et modélise le modèle 3D à partir de ce fichier de script (voir exemples ci-dessous). Cela permet de donner le contrôle total sur le processus de modélisation à l'utilisateur et permet de changer facilement toutes les étapes du processus de modélisation ou de faire du design qui soit défini par des paramètres configurables."(http://openscad.org/, récupéré 22h58 17 Mars 2010 (UTC)

Attention, ce tutoriel se base sur la version "2015.03", certaines choses sont donc sujettes à ne plus correspondre avec de prochaines versions

Voir aussi: l'usine Doblo (en), un ensemble de modules pour créer des structures, des briques et des mashups compatibles Lego/Duplo.

Création de notre premier modèle et l'interface

Premier modèle

Pour notre premier modèle, nous créerons un simple parallélépipède de 2 x 3 x 4. Dans l'éditeur OpenScad, tapez la commande suivante sur une ligne :

cube([2,3,4]);

Ceci va définir un simple cube de taille x=2, y=3 et z=4.

Image d'un Cube dans OpenScad 28.10.2015 (version 2015.03)

Le parallélépipède peut maintenant être compilé et rendu comme nous allons le montrer ci-dessous

Le logiciel - Compiler le code Scad

L'interface ressemble à cela :

• A gauche, il y a une fenêtre d'édition. Bien sûr, vous pouvez aussi utiliser un éditeur externe.
• A droite, il y a la fenêtre de rendu

Image de OpenScad 28.10.2015 (version 2015.03)

Pour ouvrir un fichier .scad

• menu: Fichier->Ouvrir

Pour avoir un aperçu du résultat

• menu: Conception->Aperçu ou F5
• Utiliser menu: Conception->Recharger et aperçu ou F4. Si vous préférez utiliser un éditeur externe pour éditer du code .scad, le programme va détecter le changement de date du fichier et va automatiquement le recharger.

Pour compiler et pour exporter

1. menu: Conception -> Rendu (CGAL)ou F6 .... cela peut prendre plusieurs minutes. Cependant, les différentes parties sont mises en cache et le prochain rendu pourrait être beaucoup plus rapide.
2. menu: Fichier -> Exporter --> Exporter comme un .STL

Une fois que vous avez compilé et fait le rendu (CGAL)

• Vous pouvez consulter uniquement la grille CGAL (Menu: Vue->Wireframe ou F11)

Le menu Vue

• Cochez "Afficher Axe"
• Vous pouvez basculer entre le mode "Open CSG"? et "Thrown together"? pour regarder le résultat
• Une fois qu'un objet est rendu (pas seulement compilé), vous pouvez explorer les autres options. Dans le même menu, vous trouverez différentes options à regarder comme compiler ou compiler modèles rendus. Explorez ceux-ci et rappelez-vous des raccourcis.

Des principes 3D

Il est bon de comprendre certaines terminologies du domaine de la 3D, afin d'être en mesure de suivre les instructions ou de comprendre pourquoi les choses peuvent mal se passer...

Modélisation polygonale : le modèle est assimilé à un ensemble de polygones : ce polyèdre est donc décrit par la liste des sommets et des arêtes. Si les polygones sont orientés, on pourra différencier l'extérieur et l'intérieur du modèle. Si l'on veut lever l'ambiguïté apportée par des polygones non plans, on utilisera uniquement des triangles : cette triangulation peut être forcée par le modeleur. Sans effet de lissage, l'objet apparaîtra anguleux, si la définition en facettes est faible. En général, le lissage de Gouraud, réalisé par la carte graphique 3D, est suffisant pour donner un aspect plus lisse au modèle. La modélisation polygonale se sert d'outils de base identiques sur tous les logiciels 3D, ainsi que certains outils spécifiques aux logiciels génériques, aux logiciels spécialisés et aux plug-ins et scripts. Parmi ces outils, les plus répandus sont l'extrusion, la coupe (cut, split…), la soudure/rétractation (weld/collapse) et la révolution. L'extrusion consiste à surélever une ou plusieurs faces (adjacentes ou non) ou un profil 2D le long d'une trajectoire et de créer les faces venant combler le vide occasionné par le déplacement de l'élément de départ. Par exemple, extruder un cercle donne un cylindre ouvert ou un tuyau qui suit la trajectoire. La coupe consiste à créer des arêtes (edges) sur un maillage, ainsi que les points correspondants aux intersections des arêtes déjà existantes et celles nouvellement créées. On peut ainsi affiner un modèle, en ajoutant des détails sur certaines régions, notamment par l'ajout de boucles d'arêtes (edgeloops) extrêmement utilisées en modélisation organique. La soudure/rétractation consiste à souder les sommets (vertices) entre eux, pour simplifier un maillage, boucher des trous ou faire converger des arêtes. La révolution consiste à faire tourner un profil 2D autour d'un axe 3D : on obtient ainsi un volume de révolution. C'est la technique majoritairement utilisée dans le jeu vidéo, et le cinéma d'animation. La modélisation polygonale induit une marge d'erreur de proportions et de dimensions le plus souvent invisible à l'œil nu. Dans le cinéma d'animation, les modèles 3D organiques sont le plus souvent lissés. Le lissage consiste à subdiviser un maillage (une itération correspond à une subdivision de chaque arête, soit dans le cas de face à quatre côtés, une subdivision en quatre faces) et arrondir les faces obtenues selon différents algorithmes, afin de gommer l'effet anguleux des modèles obtenus par modélisation polygonale." (Modélisation polygonale, Wikipedia, récupéré le 28 Octobre 2015)

"En géométrie, un sommet est un type spécial de point qui décrit les coins ou les intersections de formes géométriques. Les sommets sont couramment utilisés en infographie pour définir les coins de surfaces (triangles généralement) dans des modèles 3D, où chaque point est donné comme un vecteur. Un sommet d'un polygone est le point d'intersection entre deux bords, un sommet d'un polyèdre est le point d'intersection de trois ou plusieurs bords ou faces." (Vertex geometry, Wikipedia, récupéré à 17h25, le 23 Mars 2010 (UTC))

Les faces ou facettes définissent la surface d'un objet en 3 dimensions, à savoir ce qui est entre "l'extérieur" et "l'intérieur".

"De nombreux programmes de modélisation ne respectent pas strictement la théorie géométrique; par exemple, il est possible pour deux sommets d'avoir deux bords distincts qui les relie, occupant la même position spatiale. Il est également possible pour deux sommets d'exister dans les mêmes coordonnées spatiales, ou à deux faces d'exister au même endroit. De telles situations ne sont généralement pas souhaités et de nombreux logiciels 3D possèdent une fonction d'auto-nettoyage. Si l'auto-nettoyage est pas présent, ils doivent être supprimés manuellement." (Vertex geometry, Wikipedia, récupéré à 17h25, le 23 Mars 2010 (UTC))

"Un groupe de polygones qui sont reliés entre eux par des sommets partagés sont désignés par une maille. Pour avoir un bon maillage lors du rendu, il est souhaitable que ce soit une non auto-intersection, ce qui signifie qu'aucun bord passe par un polygone. Une autre façon de voir les choses est que le maillage ne peut pas se percer. Il est également souhaitable que le treillis ne contienne pas d'erreurs tel que des sommets, des arêtes ou des faces doublés. Pour certaines applications, il est important que le maillage soit un "manifold" c'est à dire qu'il ne contient pas de trous ou de singularités (endroits où deux sections distinctes de la maille sont reliés par un seul sommet)" (Vertex geometry, Wikipedia, récupéré à 17h25, le 23 Mars 2010 (UTC))

"Dans de nombreux formats, par exemple STL et OpenSCAD, le principe est le suivant: "(i) La normale et chaque sommet de chaque facette sont spécifiées par trois coordonnées chacun, donc il y a un total de 12 numéros mémorisés pour chaque facette. (ii) Chaque facette fait partie de la frontière entre l'intérieur et l'extérieur de l'objet. L'orientation des facettes (où est le `` sortir et où est le `` dedans) est spécifié redondante de deux manières qui doivent être conformes. En premier lieu, la direction de la normale est vers l'extérieur. Deuxièmement, les sommets sont répertoriés dans l'ordre dans le sens antihoraire quand on regarde l'objet de l'extérieur (règle de la main droite). (iii) Chaque triangle doit partager avec deux sommets de chacun de ses triangles adjacents. Ceci est connu comme règle sommet à sommet. (iv) L'objet représenté doit être situé dans l'octant tout-positive (toutes les coordonnées des sommets doivent être positifs)." (Daniel Rypl, Zdenek Bittnar 2004, récupéré Avril de 2010.

"La normale ou la surface normale est un vecteur qui est perpendiculaire à une face." Surface normale, Wikipedia, récupéré 15h07, le 20 Novembre 2011 (UTC)

Exemples de code

Utilisant des modèles existants

Il est préférable d'apprendre d'abord comment utiliser les modules OpenSCAD "ready-made". Télécharger à partir d'un endroit comme thingverse.

La plupart de ces fichiers définissent des modules (fonctions aka) que vous ne pouvez pas exécuter avec ou sans paramètre afin de faire un rendu d'un modèle.

Modules sans paramètre:

Les exemples "bloqueurs de porte" de Thingiverse que vous pouvez télécharger ici chose 2,154 sont définis comme deux modules en un seul fichier * .scad, porte-bouchon-2.scad. Télécharger ou copier / coller le code à partir d'ici. Bien sûr, ces modules d'arrêt de porte peuvent être paramétrés, mais cela peut être fait avec des variables comme vous pouvez le voir.

Modules avec paramètres:

Le bloc paramétrique Lego / Duplo, d'autre part, (chose 2014) peut inclure des paramètres, par exemple, vous pourriez l'appeler comme cela pour une petite brique de 2x2x3 avec des "nibbles".

 Duplo (1,1,3, true);

ou comme cela pour une plus grande brique sans "nibbles".

 Duplo (2,2,4, false);

Juste essayer: compiler et modifier les paramètres s'ils ne vous conviennent pas. Nous avons également créé une usine de Doblo plus sophistiquée qui peut aussi être étudiée.

Modules avec des paramètres nommés:

Vous pouvez également utiliser des noms de paramètres plutôt que de simplement utiliser des positions. L'exemple suivant peut être fait avec l'usine de Doblo.

doblo   (col=0,  
         row=4, 
         up=0,  
	 width=4, 
         length=2, 
         height=FULL, 
	 nibbles_on_off=true, 
         diamonds_on_off=false,
	 scale=LUGO);

Si les paramètres par défaut sont définis, vous pouvez tapez simplement

doblo ();

afin d'obtenir une hauteur typique des brique Lego compatible 4x2.

Si vous préférez apprendre plus sur OpenSCAD avant d'essayer, ignorez ces exemples et revenez y plus tard.

Un simple bloqueur de porte

Le code suivant va créer un butoir de porte. Au lieu d'essayer de comprendre cet exemple, vous pouvez aussi le sauter et lire le reste de cet article en premier.

Pour utiliser ce module, vous devrez ajouter la ligne suivante dans le code. C'est à dire que cela va appeler le module "door_stopper_simple":

  door_stopper_simple ();

// To use it, uncomment
// door_stopper_simple ();

module door_stopper_simple ()
{
    height = 20  ;
    length = 125 ;
    width= 40 ;
    half_width  = width / 2;
    
    borders = 10; // 1 cm on each side

    top_cube_length = length - 4 * borders;
    top_cube_width  = width - 2 * borders;
    top_cube_height = height ;  // make it big enough
    top_z = height/2 + 4 ; // adjust manually ;)

    tip_cut_pos = length/2 - 0.5;

    difference() {
	translate ([-length/2.0, 0, 0]) {
    	    polyhedron (	
	    		points = [[0, -half_width, height], [0, half_width, height], [0, half_width, 0], [0, -half_width, 0], [length, -half_width, 0], [length, half_width, 0]],
			triangles = [[0,3,2], [0,2,1], [3,0,4], [1,2,5], [0,5,4], [0,1,5],  [5,2,4], [4,2,3], ]);
	}

	// top inset
	translate ([-1 * borders, 0, top_z]) {
	    # cube ([top_cube_length,
		     top_cube_width,
		     top_cube_height],
		    center=true) ;
	}
	// cut of the tip a bit

	translate ([tip_cut_pos, 0, 0]) {
	    # cube ([20,
		     width + 1,
		     height],
		    center=true) ;
	}
    }
}

Bloqueur de porte

Le modèle suivant est un peu plus sophistiqué.

Pour l'utiliser: door_stopper ();

// To use it, uncomment
// door_stopper ();

module door_stopper ()
{
    height = 25  ;
    length = 120 ;
    width= 60 ;
    half_width  = width / 2;
    
    borders = 10; // 1 cm on each side

    // params for bottom inset
    bottom_cube_length = length - 4 * borders;
    bottom_cube_width = width - 2 * borders;
    bottom_cube_height = 6.0 ; // 3mm in / 3mm outsite
    bottom_z = 0;

    // params for top inset
    top_cube_length = length - 4 * borders;
    top_cube_width  = width - 2 * borders;
    top_cube_height = height ;  // make it big enough // 25
    top_z = height/2 + 7.5 ; //  12.5 + 7.5 = 10 ; 10 - 2.5 = 7.5

    // param for tip
    tip_cut_pos = length/2 - 0.5;

    // param for top tip
    top_tip_pos = height + 0.5; 

    difference() {
	translate ([-length/2.0, 0, 0]) {
    	    polyhedron (	
	    		points = [[0, -half_width, height], [0, half_width, height], [0, half_width, 0], [0, -half_width, 0], [length, -half_width, 0], [length, half_width, 0]],
			triangles = [[0,3,2], [0,2,1], [3,0,4], [1,2,5], [0,5,4], [0,1,5],  [5,2,4], [4,2,3], ]);
	}
	// bottom inset
	translate ([-1 * borders, 0, bottom_z]) {
	    # cube ([bottom_cube_length,
		     bottom_cube_width,
		     bottom_cube_height],
		    center=true) ;
	}
	// top inset
	translate ([-1 * borders, 0, top_z]) {
	    # cube ([top_cube_length,
		     top_cube_width,
		     top_cube_height],
		    center=true) ;
	}
	// cut of the top tip a bit
	translate ([- length/2 + 10, 0, top_tip_pos]) {
	    # cube ([length / 2,
		     width+2,
		     height / 2],
		    center=true) ;
	}
	// cut of the front tip a bit
	translate ([tip_cut_pos, 0, 0]) {
	    # cube ([20,
		   width + 1,
		   height],
		  center=true) ;
	}
    }	    
}

Le modèle de bloqueur de porte (source : http://edutechwiki.unige.ch/fr/Fichier:Openscad-doorstopper.png)

Vous pourriez alors aussi ajouter un texte comme celui-ci. Je l'ai fait en utilisant Netfabb Pro. Il permet de créer du texte en 3D et à assembler les différentes parties en un seul .STL.

Le modèle de bloqueur de porte imprimé avec PLA (source : http://edutechwiki.unige.ch/en/File:Doorstopper-webster-netfabb.png)

Le résultat une fois imprimé :

Le modèle de bloqueur de porte imprimé avec PLA (source : http://edutechwiki.unige.ch/fr/Fichier:800px-Doorstopper-webster.jpg)

Le bloc parametrique Lego Duplo

Ce code est un dérivé du bloc Lego Duplo paramétrique . C'est le code OpenSCAD le plus compliqué avec lequel nous ayons joué jusqu'ici. Domonoky. Nous l'avons également uploadé sur Thingyverse. Les personnes ayant une bonne formation en mathématiques peuvent obtenir beaucoup plus hors du logiciel OpenSCAD ....

//the duplo itself
// parameters are: 
// width: 1 =standard 4x4 duplo with.
// length: 1= standard 4x4 duplo length
// height: 1= minimal duplo height
// nibbles: true or false
 
duplo(1,1,3,true);


module duplo(width,length,height,nibbles) 
{
	//size definitions
	
	ns = 8.4;  //nibble start offset
	no = 6.53; //nibbleoffset
	nbo = 16; // nibble bottom offset
	
	duplowidth = 31.66;
	duplolength=31.66;
	duploheight=9.6;
	duplowall = 1.55;	
	
	
	//the cube
	difference() {
		cube([width*duplowidth,length*duplolength,height*duploheight],true);
		translate([0,0,-duplowall]) 	
			cube([width*duplowidth - 2*duplowall,length*duplolength-2*duplowall,height*duploheight],true);
	}

	//nibbles on top
         if  (nibbles)
     	   {
	    	for(j=[1:length])
		{
			for (i = [1:width])
			{
				translate([i*ns+(i-1)*no,j*ns+(j-1)*no,6.9+(height-1)*duploheight/2]) duplonibble();
				translate([i*-ns+(i-1)*-no,j*ns+(j-1)*no,6.9+(height-1)*duploheight/2]) duplonibble();
				translate([i*ns+(i-1)*no,j*-ns+(j-1)*-no,6.9+(height-1)*duploheight/2]) duplonibble();
				translate([i*-ns+(i-1)*-no,j*-ns+(j-1)*-no,6.9+(height-1)*duploheight/2]) duplonibble();
			}
		}
	        }

	//nibble bottom
	for(j=[1:length])
	{
		for (i = [1:width])
		{
			translate([(i-1)*nbo,(j-1)*nbo,0]) duplobottomnibble(height*duploheight);
			translate([(i-1)*-nbo,(j-1)*-nbo,0]) duplobottomnibble(height*duploheight);
			translate([(i-1)*-nbo,(j-1)*nbo,0]) duplobottomnibble(height*duploheight);
			translate([(i-1)*nbo,(j-1)*-nbo,0]) duplobottomnibble(height*duploheight);
		}
	}
	//little walls inside[http://www.thingiverse.com/Domonoky Domonoky]
	difference() 
	{
		union()
	 	{
			for(j=[1:length])
			{	
				for (i = [1:width])
				{
					translate([0,j*ns+(j-1)*no,0 ]) cube([width*duplowidth,1.35,height*duploheight],true);
					translate([0,j*-ns+(j-1)*-no,0 ]) cube([width*duplowidth,1.35,height*duploheight],true);
					translate([i*ns+(i-1)*no,0,0 ]) cube([1.35,length*duplolength,,height*duploheight],true);
					translate([i*-ns+(i-1)*-no,0,0 ]) cube([1.35,length*duplolength,height*duploheight],true);
				}
			}
		}
		cube([width*duplowidth - 4*duplowall,length*duplolength-4*duplowall,height*duploheight+2],true);
	}
}


module duplonibble()
{
	difference() {
		cylinder(r=4.7,h=4.5,center=true,$fs = 0.01);
		cylinder(r=3.4,h=5.5,center=true,$fs = 0.01);
	}
}

module duplobottomnibble(height)[http://www.thingiverse.com/Domonoky Domonoky]
{
	difference() {
		cylinder(r=6.6,h=height,center=true,$fs = 0.01);
		cylinder(r=5.3,h=height+1,center=true,$fs = 0.01);
	}

}

Le langage OpenScad

Modules

Les modules peuvent être grossièrement comparés aux fonctions, macros ou à des sous programmes dans un langage de programmation. Avec ces modules vous pouvez définir du code réutilisable.

Exemple:

• Le module appelé "thing" est appelé par le module appelé "demo_proj".

Source: Example021.scad livré avec la distribution du logiciel

module thing()
{
	$fa = 30;
	difference() {
		sphere(r = 25);
		cylinder(h = 62.5, r1 = 12.5, r2 = 6.25, center = true);
		rotate(90, [ 1, 0, 0 ]) cylinder(h = 62.5,
				r1 = 12.5, r2 = 6.25, center = true);
		rotate(90, [ 0, 1, 0 ]) cylinder(h = 62.5,
				r1 = 12.5, r2 = 6.25, center = true);
	}
}

module demo_proj()
{
	linear_extrude(center = true, height = 0.5) projection(cut = false) thing();
	thing();
}

demo_proj();

• Les modules peuvent être embarqués à l'intérieur d'autres modules et peuvent bien évidemment avoir des paramètres.

Contrôle du flux

Boucle For

Boucle For en utilisant un vecteur

Une boucle for itère sur les valeurs d'un vecteur ou sur un intervalle.

Syntaxe:

for (loop_variable_name = range or vector) {
   .....
   }

Paramètres

loop_variable_name = Nom de la variable à utiliser dans la boucle For.

range: [low : high]. Low et high peuvent être tout aussi bien des nombre ou des variables.

vector: Un vecteur comme [1,2,10,40.5]

Boucle For utilisant une intervalle

Exemples d'utilisation: Une boucle For utilisant un vecteur.

for ( z = [-1, 1, -2.5]) {
 translate( [0, 0, z] ) 
    cube(size = 1, center = false);
}

Une boucle For utilisant un intervalle

 for ( i = [0:5] ) {
  rotate( i*360/6, [1, 0, 0])
   translate( [0, 10, 0] ) sphere(r = 1);
 }

Intersection boucle For

OpenScad Intersection boucle For (rotation)

Une intersection boucle for itère sur un vecteur de vecteurs, entraînant une intersection/chevauchement de tous les objets générés.

Syntaxe:

intersection_for (loop_variable_name = vector_of_vectors) {
   .....
   }

Paramètres

loop_variable_name = Nom de la variable à utiliser dans la boucle For.

vector_of_vectors: Un vecteur comme [ [1,2,10],[14,-20.3,40.5] ]

Exemple d'utilisation 1 - rotation :

 intersection_for(i = [
 			[0, 0, 0],
 			[10, 20, 300],
 			[200, 40, 57],
 			[20, 88, 57]
 		])
 	rotate(i) cube([100, 20, 20], center = true);

OpenScad Intersection boucle For (translation). Remarque: Pour générer l'image de gauche ajoutez un # avant la translation, cela affichera les contours des volumes générés avant que l'intersection soit faite.

Exemple d'utilisation 2 - translation

 intersection_for(i = [
	[0, 0, 0],
	[2, 1, 1],
	[-2, 1, 0]
	])
	translate (i) cylinder(r=5, h=10, center = true);

La condition If

La condition if permet d'évaluer conditionnellement une sous-arborescence.

Syntaxe

if (boolean_expression) { .... }
if (boolean_expression) { .... } else {.... }
if (boolean_expression) { .... } else if (boolean_expression) {.... }
if (boolean_expression) { .... } else if (boolean_expression) {.... } else {....}

Paramètres

• L'expression booléenne qui devrait être utilisée en tant que condition.

Exemple d'utilisation 1:

 if (x > y) {
  cube(size = 1, center = false);
 }

Exemple d'utilisation 2:

SCALE = 0.5 ;
... autres variables .....

module doblonibble() {
    // Les Lego redimensionnés n'ont pas de trous dans les tétines
    if (SCALE < 0.6) {
	cylinder(r=NB_RADIUS, h=NH,  center=true,  $fs = 0.05);
    } else {
	difference() {
	    cylinder(r=NB_RADIUS,h=NH,  center=true,  $fs = 0.05);
	    cylinder(r=NB_RADIUS_INSIDE,h=NH+1,center=true, $fs = 0.05);
	}
    }
}

Variables et instructions d'affectation

Variables

L'affectation des variables prend la même syntaxe qu'en C. Exemple:

SCALE = 1;

ou

PART_HEIGHT  = ((SCALE < 0.6) && LEGO_DIV) ? 3.2 * LEGO_SCALE : 4.8 * SCALE ;

Cependant et n'oubliez pas ça:

• OpenScad calcule ses variables au moment de la compilation, et pas au moment de l'exécution du code, ce qui veut dire que la dernière affectation de la variable sera appliquée partout où la variable est utilisée..
• Cela devrait aider si on les considère plutôt comme des constantes dont la valeur est modifiable que des variables. Ceci veut dire que vous pouvez fixer des variables dans une librairie et ensuite les modifier dans le fichier qui chargera la librairie. Vous ne pouvez pas affecter deux valeurs différentes à la même variable quand vous calculez un model!

Assign

Fixe une nouvelle valeur à une variable dans une sous-arborescence. Cela peut être utilisé dans un module pour stocker des valeurs intermédiaires. Dans l'exemple

Syntaxe:

 assign (var1= expr1, var2= expr2, ....)

Exemple démontrant que les variables sont (re)affectables:

for (i = [10:50])
    assign (angle = i*360/20, distance = i*10, r = i*2) {
        rotate(angle, [1, 0, 0])
            translate( [0, distance, 0] ) sphere(r = r);
    }

La variable "angle" local, "distance" and "r" sont modifiées à chaque cycle de la boucle.

Remarque: La fonction assign sera supprimés dans les prochaines version d'OpenScad. Il est donc conseillé de faire une affectation classique: var1= expr1; var2= expr2; ...

et for (i = [10:50], angle = i*360/20, distance = i*10, r = i*2)

   {
       rotate(angle, [1, 0, 0])
           translate( [0, distance, 0] ) sphere(r = r);
   }

Opérateurs mathématiques et fonctions

Les opérateurs OpenScad semblent fonctionner comme dans les autres langages se basant sur C. Regardez les détails dans la manuel officiel:

• Mathematical Operators
• Mathematical Functions
• String Functions

Les conditions sont aussi implémentées. Exemple: condition ? if_true_expression : if_false_expression

Exemple:

HEIGHT = (SCALE < 0.5) ? 3 : 6*1/1 ;

If Ceci veut dire que si SCALE==0.6, alors HEIGHT vaudra 6. Si SCALE est plus petite que 0.5 alors HEIGHT==3.

Fonctions

Les fonctions peuvent être utilisées pour définir des modules utilitaires simples. À ne pas confondre avec les "modules".

Variables spéciales

Comme expliqué dans le wiki d' OpenScad , les variables commençant par un '$' sont des variables spéciales.

Avis pour les programmeurs: La sémantique des variables spéciales est similaire à celle des variables spéciales en lisp: Elles ont une portée dynamique plutôt qu'une portée lexicale. Ce qui veut dire que leur valeur est définie au moment de l'exécution du code. Par exemple, imaginons que vous commencez un code avec $fa = 5, puis vous appelez un module A dans lequel vous définissez $a = 7. Alors quand le module A appelle encore un autre module B, la seconde affectation ($a==7) sera utilisée.

Les variables spéciales $fa, $fs et $fn contrôlent le nombre de facettes utilisées pour générer un arc. Comme expliqué au-dessus, vous pouvez les modifier dans chaque module.

$fa

$fa est l'angle du fragment. Cela fixe l'angle minimum pour un fragment. Même un grand cercle n'a pas plus de fragments que 360 divisé par ce nombre. La valeur par défaut est de 12 (ce qui donne 30 fragments pour un cercle entier).

$fs

$fs est la taille du fragment and définit la taille minimum pour un fragment. À cause de cette variable, de très petits cercles ont un plus petit nombre de fragments que ceux qui sont spécifiés en utilisant $fa. Les valeur par défaut est 1.

$fn

$fn est le nombre de fragments. C'est souvent 0. Quand cette variable a une valeur plus grande que 0, les deux autres variables sont ignorées et un cercle entier est construit en utilisant ce nombre de fragments. La valeur par défaut est 0.

La forme d'un cercle peut être améliorée en fixant une des variables spéciales $fn, $fs et $fa. Lorsque $fa et $fs sont utilisées pour déterminer le nombre de fragments pour un cercle alors OpenScad n'utilisera jamais moins de 5 fragments.

Si vous voulez accélerer la construction pour un test, une bonne astuce est de fixer un nombre de facettes très bas au début du script. Tant que $fn est une variable spéciale, cela affectera tous les objets sauf si elle est remodifiée par la suite.

Exemple avec une basse résolution $fn=10; Exemple avec une haute résolution

$fn=100;

Haute résolution veut dire plus de triangles donc plus d'attente :) Dans la plus part des cas, 20-50 devrait être suffisant pour une impression 3D.

Solides primitifs

OpenScad a les primitives "habituelles", comme par exemple les cubes, les cylindres et les sphères.

Les coordonnées sont définies sous forme de tableaux. Par exemple [2,3,4] veut dire x = 2, y = 3 et z = 4.

Cube

La primitive cube permet de créer un cube à l'origine du système de coordonnées. Quand le paramètre "center" vaut true, alors le cube sera centré à l'origine, autrement il est créé dans le premier octant. Les noms des paramètres sont facultatifs si les paramètres sont donnés dans le même ordre qu'il est spécifié sous "paramètres".

Paramètres:

size

Décimale ou 3 valeurs sous forme de tableau. Si un seul nombre est donné, le résultat sera un cube avec tous les côtés ayant cette longueur. Si 3 valeurs sous forme de tableau sont données, alors les valeurs correspondront aux longueurs des côtés X, Y et Z. La valeur par défaut est 1.

center

Booléen. Cela détermine le positionnement de l'objet. Si ce paramètre prend la valeur true, l'objet sera alors centré à (0, 0, 0). Autrement, le cube est placé dans le quadrant positif avec un coin sur (0, 0, 0). La valeur par défaut est false.

Exemple 1:

cube ([2,3,4])

Exemple 2:

bottom_cube_length = 2;
bottom_cube_width = 3;
bottom_cube_height = 2;
cube ([bottom_cube_length,
	bottom_cube_width,
	bottom_cube_height],
	center=true) ;

Exemple 3:

cube(size = 1, center = false);
cube(size = [1,2,3], center = true);

Deux exemples de cubes. Source: OpenSCAD User Manual/Primitive Solids

Sphere

La primitive sphere crée une sphère à l'origine du système de coordonnées. Les noms des paramètres sont optionnels.

Paramètres

r

Décimal. C'est le rayon de la sphère. La résolution de la sphère sera baséee sur la taille de la sphère et sur les variables spéciales $fa, $fs et $fn.

Exemple d'utilisation

sphere(r = 1);
sphere(r = 5);
sphere(r = 10);
sphere(2, $fn=100); // Sphère avec 2mm de rayon en haute résolution
sphere(2, $fa=5, $fs=0.1); // Sphère avec 2mm de rayon en (moins) haute résolution

Trois exemples de sphères. Source: OpenSCAD User Manual/Primitive Solids

Cylinder

La primitive cylinder créé un cylindre à l'origine du système de coordonnées. Quand les deux rayons du cylindre sont égaux il est aussi possible de spécifier un seul rayon en spécifiant "r" comme nom de paramètre. Les noms des paramètres sont facultatifs si les valeurs sont données dans le même ordre qu'il est spécifié ci-dessous.

Paramètres

h

Décimal. C'est la hauteur du cylindre. La valeur par défaut est 1.

r1

Décimal. C'est le rayon de la partie haute du cylindre/cône. La valeur par défaut est 1.

r2

Décimal. C'est le rayon de la partie basse du cylindre/cône. La valeur par défaut est 1.

r

Décimal. C'est le rayon de la partie haute et la partie basse du cylindre. Utilisez ce paramètre si vous voulez un cylindre qui ressemble à un pilier et non pas à un cône. La valeur par défaut est 1.

Exemples d'utilisation

cylinder(h = 10, r1 = 10, r2 = 20, center = false);
cylinder(h = 10, r1 = 20, r2 = 10, center = true);
cylinder(h = 10, r=20);

Exemples de cylindres sur OpenScad. Source: OpenSCAD User Manual/Primitive Solids

Polyhedrons

Les polyèdre sont les formes les plus difficiles à traiter. A la place d'utiliser cette fonction, vous devriez (a) penser à comment vous pourriez combiner des formes simples pour arriver au même résultat ou (b) regarder sous l'extrusion 2D.

• Un polyèdre est souvent définit comment étant un solide géométrique avec des faces plates et des côtés droits.(Wikipedia, 17:25, 23 mars 2010 (UTC)).

Tout polyèdre peut être construit à partir de différentes sortes d'éléments ou entités, chacune associée avec différents nombres de dimensions.

• 3 dimensions: Le corps est limité par les faces, et est a normalement le volume enfermé dans ces surfaces.
• 2 dimensions: Une face est un polyèdre délimité par le contour des bords, et normalement inclut les régions plates (plan) dans la limite. Ces faces polygonales, ensembles forment la surface du polyèdre.
• 1 dimension: Un bord rejoint un sommet à un autre et une face à une autre. Il s'agit normalement d'un segment. Les bords ensemble forment le squelette du polyèdre.
• 0 dimensions: Un sommet (plural vertices) est un point.

(Wikipedia, 17:25, 23 mars 2010 (UTC)).

Syntaxe:

polyhedron(points = [ [x, y, z], ... ], triangles = [ [p1, p2, p3..], ... ], convexity = N);

La primitive polyhedron crée un polyèdre avec des points et triangles spécifiques. (Les composants des vecteurs des triangles 'pN' sont 0-indexés faisant référence aux éléments des points du vecteur.)

Exemple (voir l'image en dessous)

polyhedron ( points = [[0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60]], 
triangles = [[0,3,2], [0,2,1], [3,0,4], [1,2,5], [0,5,4], [0,1,5],  [5,2,4], [4,2,3], ]);

Un simple polyèdre artisanal

Remarquez qu'OpenSCAD crash si vos polygones ne sont pas orientés de la même façon. Faites attention à l'ordre des sommets (Ne comprenez pas ça!) Exemple:

  polyhedron(points=[[0,0,0],[100,0,0],[0,100,0],[0,100,100]], triangles=[[0,1,2],[0,1,3],[0,2,3],[1,2,3]]); //Crash
  polyhedron(points=[[0,0,0],[100,0,0],[0,100,0],[0,100,100]], triangles=[[0,1,2],[1,0,3],[0,2,3],[2,1,3]]); //Fonctionne

Un autre exemple:

Un polyèdre artisanal

Voyons maintenant comment réparer des polyèdres avec des polygones mal orientés. Quand vous sélectionnez 'Jeté ensemble' dans le menu Vue et que vous compilez le design (pas le compilé et rendu!) vous allez voir un aperçu avec les polygones mal orientés mis en évidence. Malheureusement cette mise en évidence n'est pas possible avec l'aperçu du mode OpenCSG parce que cela ferait une interférence avec la façon dont l'aperçu dans le mode OpenCSG est implémenté.

Ci-dessous vous pouvez voir un polyèdre problématique. Les mauvais triangles sont en violet.

// Mauvais polyèdre
polyhedron
    (points = [
	       [0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60], 
	       [10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50]
	       ], 
     triangles = [
		  [0,2,3],   [0,1,2],  [0,4,5],  [0,5,1],   [5,4,2],  [2,4,3],
                  [6,8,9],  [6,7,8],  [6,10,11], [6,11,7], [10,8,11],
		  [10,9,8], [0,3,9],  [9,0,6], [10,6, 0],  [0,4,10],
                  [3,9,10], [3,10,4], [1,7,11],  [1,11,5], [1,7,8],  
                  [1,8,2],  [2,8,11], [2,11,5]
		  ]
     );

Polyèdre avec des polygones mal orientés

Un polyèdre correcte serait le suivant:

polyhedron
    (points = [
	       [0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60], 
	       [10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50]
	       ], 
     triangles = [
		  [0,3,2],  [0,2,1],  [4,0,5],  [5,0,1],  [5,2,4],  [4,2,3],
                  [6,8,9],  [6,7,8],  [6,10,11],[6,11,7], [10,8,11],
		  [10,9,8], [3,0,9],  [9,0,6],  [10,6, 0],[0,4,10],
                  [3,9,10], [3,10,4], [1,7,11], [1,11,5], [1,8,7],  
                  [2,8,1],  [8,2,11], [5,11,2]
		  ]
     );

Astuces pour les débutants: Si vous ne comprenez pas vraiment l'"orientation", alors identifiez simplement les triangles mal orientés puis permutez l'ordre correspondant des triangles et les sommets jusqu'à ce que vous arriviez au résultat correcte. Par exemple dans l'exemple en dessus, le troisième vecteur de triangle ([0, 4, 5]) était mauvais et nous l'avons réparé en mettant [4, 0, 5]. De plus vous devriez sélectionner "Afficher les arrêtes" dans le menu "Vue", faire une capture d'écran, l'imprimer et numéroter les sommets (points) et les triangles. Dans notre exemple, les points sont en noir et les triangles sont en bleu. Ensuite, tournez autour de l'image sur OpenScad et faites une seconde copie du dos si besoin.

Polyèdre avec des polygones mal orientés

Remarque: Le paramètre triangle sera supprimé dans les prochaines versions d'OpenScad. Il est donc conseillé de mettre "faces" à la place. Exemple:

polyhedron
    (points = [
	       [0, -10, 60], [0, 10, 60], [0, 10, 0], [0, -10, 0], [60, -10, 60], [60, 10, 60], 
	       [10, -10, 50], [10, 10, 50], [10, 10, 30], [10, -10, 30], [30, -10, 50], [30, 10, 50]
	       ], 
     faces = [
		  [0,3,2],  [0,2,1],  [4,0,5],  [5,0,1],  [5,2,4],  [4,2,3],
                  [6,8,9],  [6,7,8],  [6,10,11],[6,11,7], [10,8,11],
		  [10,9,8], [3,0,9],  [9,0,6],  [10,6, 0],[0,4,10],
                  [3,9,10], [3,10,4], [1,7,11], [1,11,5], [1,8,7],  
                  [2,8,1],  [8,2,11], [5,11,2]
		  ]
     );

Transformations

scale

La commande scale redimensionne sont élément enfant en utilisant le vecteur spécifié. Le nom du paramètre v est facultatif.

Syntaxe

scale(v = [x, y, z]) { ... }

Exemple

Créé un ovale de longueur = 40 dans la direction de x; y et z restent pareils.

 scale (v=[2,1,1]) cylinder(h = 10, r=20);

rotate

La commande rotate accepte plusieurs versions de paramètres.

Syntaxe pour une rotation 2D autour de l'axe Z

rotate (deg)

Exemple:

rotate(45) square(10);

Syntaxe pour des rotations sur plus d'un axe

rotate(a = deg, v = [x, y, z]) { ... }

Effectue une rotation à son élément enfant de a degrés autour du vecteur v spécifié enraciné sur l'origine du système des coordonnées.

Paramètres:

a

Degrés

v

Un tableau de [x,y,z]

Exemple: Effectue une rotation sur l'objet produit par le module 8bit_char de 270 degrés autour de l'axe z.

rotate (a=270, v=[0,0,1]) {
   8bit_char(char, size_mm, height);
}

Syntaxe alternative

rotate(a = [deg_x,deg_y,deg_z] { ... }

Paramètres:

a

Vecteur de trois degrés. Dans ce cas les nœuds enfants effectuent une rotation autour de l'axe positif x, y et z (dans cet ordre) par les nombres spécifiés en degrés.

Par exemple, pour basculer un objet d'en haut à en bas, vous devriez faire cela:

rotate(a=[0,180,0]) { ... }

Astuce: Le nom des paramètres sont facultatifs s'ils sont donnés dans le même ordre qu'il est spécifié en dessus.

translate

Syntaxe

translate(v = [x, y, z]) { ... }

La commande translate applique une translation (déplace) à son élément enfant le long du vecteur spécifié. Le nom du paramètre est facultatif.

mirror

Opération miroir ([1,0,0] d'une brique de Lego (original vers la droite)

Syntaxe

mirror([ 1, 0, 0 ]) { ... }

La commande mirror effectue un miroir sur son élément enfant au travers de l'origine. Le paramètre pour effectuer la commande mirror() est le vecteur normal sur ce plan.

translate ([-100,0,0]) import("motivation.stl");

color ("red") {
  mirror ([1,0,0]) {
    translate ([-100,0,0]) import("motivation.stl");
  }	 
};

Opérations miroir sur une brique Lego (original = le gris à droite)

Imaginez un plan orthogonal à l'axe X qui passe au travers de l'origine. Ce sera le miroir.

translate ([-100,0,0]) import("motivation.stl");

color ("red") {
  mirror ([1,0,0]) {
    translate ([-100,0,0]) import("motivation.stl");
  }	 
};


color ("blue") {
  mirror ([0,1,0]) {
    translate ([-100,0,0]) import("motivation.stl");
  }
};	 

color ("cyan") {
  mirror ([1,1,0]) {
    translate ([-100,0,0]) import("motivation.stl");
  }
};	 


color ("yellow") {
  mirror ([0,0,1]) {
    translate ([-100,0,0]) import("motivation.stl");
  }
};	 
  
color ("magenta") {
  mirror ([0,1,1]) {
    translate ([-100,0,0]) import("motivation.stl");
  }
};	 

color ("green") {
  mirror ([1,1,1]) {
    translate ([-100,0,0]) import("motivation.stl");
  }
};

multmatrix

Syntaxe

multmatrix(m = [...]) { ... }

Exemple (translate par [10, 20, 30]):

 multmatrix(m = [ [1, 0, 0, 10],
                  [0, 1, 0, 20],
                  [0, 0, 1, 30],
                  [0, 0, 0,  1]
                ]) cylinder();

Multiplie la géométrie de tous les éléments enfant avec la matrice de transformation donnée 4x4.

color

Exemple d'utilisation:
color([r, g, b, a]) { ... }

La commande color affiche les éléments enfant en couleur en utilisant la couleur RGB spécifiée + la valeur alpha. C'est simplement utilisé pour le OpenCSG et le mode d'affichage jeté ensemble. La valeur d'alpha sera par défaut à 1.0 (opaque) si elle n'est pas spécifiée.

Notez bien que les valeurs r, g, b et a sont limitées à des valeurs décimales dans l'intervalle { 0.0 ... 1.0 } plutôt qu'aux entiers traditionnels { 0 ... 255 }. Cependant, si vous voulez mettre les entiers traditionnels, vous pouvez contourner cette contrainte en spécifiant vos valeurs dans des fractions. Par exemple pour les entiers R, G, B compris dans { 0 ... 255 } vous pouvez utiliser:

color([ R/255, G/255, B/255 ]) { ... }

Si vous avez juste besoin de couleurs simples, utilisez quelque chose comme (Toutes les CSS2/X11 devraient faire):

 color("red") cube () ;

Regardez la table CSS3 des noms de couleur

minkowski

Les sommes Minkowski permettent d'ajouter chaque élément de A à chaque élément de B. Ce n'est pas facile à comprendre. Vous devriez aussi lire somme minkowski sur cgal.org.

Provenant du Manuel OpenScad:

$fn=50;
minkowski() {
    cube([10,10,2]);
    // coins arrondis
    cylinder(r=2,h=2);
}

Arrondissement des coins avec la somme Minkowski

Pour avoir des coins arrondis partout, on pourrait utiliser une sphère.

Si vous fixez $fn=50, cela prendra du temps à calculer.

$fn=20;
minkowski() {
  cube([10,10,2]);
  // coins arrondis
  sphere(2);
}

Arrondissement des coins avec la somme Minkowski

hull

La commande hull va créer une coque à partir des objets qui se trouvent à l'intérieur. Lisez convex hull sur cgal.org si vous voulez comprendre le principe.

$fn = 20;
hull () {
  # translate([0,0,0]) cylinder(r=2,h=2);
  translate([10,0,0]) cylinder(r=2,h=2);
  translate([5,10,0]) cylinder(r=2,h=2);
}

Triangle arrondit créé avec hull

Modélisation CSG

Principe

CSG veut dire Constructive solid geometry.

Il est possible de créer un modèle 3D complexe en combinant de simples objets 3D primitifs, comme des cubes, des cylindres ou des sphères.

Fusion d'objets

Le résultat de l'union donnera une seule forme. Par exemple, si vous entassez des cubes alignés les uns contre les autres, le résultat donnera une forme (sans murs internes). C'est le comportement idéal pour une imprimante 3D. Notez cependant, que la juxtaposition d'objets peut se passer mal. Par exemple, deux cubes ne peuvent pas partager un seul même coin comme expliqué plus tard.

Notez que OpenScad unifie tous les objets au niveau supérieur. Donc le code suivant, on aurait pu omettre union() {}. Cette fonction est surtout utile lorsque l'on utilise en cascade avec les autres opérateurs décrits c-dessous.

Exemple 1:

 union() {
   translate(0,0,x) import_stl("duck.stl");
   duplo(2,2,1.5,false);
 }

Exemple 2 (voir l'image ci-dessous)

union() {
	cylinder (h = 4, r=1, center = true, $fn=100);
	rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

Union de deux cylindres - source: OpenSCAD User Manual/CSG Modelling

Difference

La commande difference soustrait le deuxième ( et les suivants) nœuds enfant à partir du premier

Exemple 1:

difference() {
	cylinder (h = 4, r=1, center = true, $fn=100);
	rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

différence de deux cylindres - source: OpenSCAD User Manual/CSG Modelling

Exemple 2:

difference() {
	// start objects
	cylinder (h = 4, r=1, center = true, $fn=100);
        // first object that will substracted
	rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
        // second object that will be substracted
	rotate ([90,90,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

Vous devriez toujours vous assurer que l'objet qui extrait est plus long ou plus court que l'objet qui subira les extractions. Sinon vous pouvez aller sous "problèmes d'objets non 2-manifold" décrits sous la section de dépannage.

Manifold veut dire que c'est "étanche à l'eau et qu'il n'y a pas de trous dans la géométrie. Dans un valide 2-manifold chaque coin doit connecter exactement deux facettes. Cela veut dire que le programme doit être capable de connecter une face avec un objet. Par exemple si vous utilisez un cube avec une hauteur de 10 pour extraire quelque chose d'un cube plus large que celui qui a 10 de hauteur, ce n'est pas évident de savoir à qui des deux cubes le sommet ou le bas appartient. Alors faites le petit cube d'extraction un peu plus grand.

difference() {
	// original
	cube (size = [2,2,2]);
	// objet qui extrait
	# translate ([0.5,0.5,-0.5]) {
	    cube (size = [1,1,3]);	
	}
}

Utilisation correcte de difference

Intersection

La commande intersection créé l'intersection des tous les nœuds enfant. Cela garde toutes les proportions que cela chevauche.

Exemple:

intersection() {
	cylinder (h = 4, r=1, center = true, $fn=100);
	rotate ([90,0,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

Intersection de deux cylindres - source: OpenSCAD User Manual/CSG Modelling

Modifier characters - aide pour composer

Aussi appelé modifier characters cela vous permet de mieux voir ce qu'il se passe. Si vous mettez un modifier characters avant une sous arborescence vous pouvez mieux comprendre ce que certains éléments du design font. C'est particulièrement le cas pour les opérations d'union (fusions), intersection et difference.

# Modificateur de Debug

• L'arborescence sera rendue, mais il y aura aussi des formes dessinés en violet.

Code d'exemple:

difference() {
	// objets de départ
	cylinder (h = 4, r=1, center = true, $fn=100);
        // premier objet qui sera soustrait
	# rotate ([90,0,0]) cylinder (h = 4, r=0.3, center = true, $fn=100);
        // deuxième objet qui sera soustrait
	# rotate ([0,90,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

exemple avec le modificateur de Debug

% Modificateur Background

• Montre une arborescence dans le background. Les objets seront montrés en gris clair et les transformations seront appliquées, mais on ne les verra pas.

Exemple:

difference() {
	// objets de départ
	cylinder (h = 4, r=1, center = true, $fn=100);
        // premier objet qui sera soustrait
	% rotate ([90,0,0]) cylinder (h = 4, r=0.3, center = true, $fn=100);
        // deuxième objet qui sera soustrait
	% rotate ([0,90,0]) cylinder (h = 4, r=0.9, center = true, $fn=100);
}

Exemple avec le modificateur Background

! Modificateur Root

Le modificateur root va ignorer le reste du design et va utiliser son arborescence comme racine du design. C'est utile pour regarder seulement un élément, sans avoir besoin de copier/coller dans un fichier test.

Exemple: ! { ... }

* Modificateur Disable

Le modificateur disable ignore simplement tout son arborescence. Cela a la même fonctionnalité que de commenter avec //. Exemple d'utilisation:

* { ... }

Exemples de CSG simples

L'opération suivante va couper le bas d'une sphère de façon plate par son milieu.

difference() {
  // Une sphère avec 5mm de rayon
  # sphere(r=5, $fn=100); 
  // pousse 5mm vers le bas
  translate(v=[0,0,-5]) {
    //Le cube servant à couper 
    # cube(size = 10, center = true);
   }
}

dôme

L'exemple suivant créé un simple petit bol.

Simple bol de 2cm x 2cm x 2cm+2mm

// Résolution
$fn=50;

//Bouge le tout vers le haut
translate (v=[0,0,12]) {

  difference() {
    difference() {
      // Sphère externe
      sphere(r=10, $fn=50); 
      translate(v=[0,0,2]) {
	//Sphère interne
	sphere(r=8, $fn=50); 
      }
    }
    translate(v=[0,0,5]) {
      // Cube servant à couper
      cube(size = [20,20,10], center = true);
    }
  }
  // Quelque chose pour porter le tout
  translate(v=[0,0,-10]) {
    cylinder (h=4, r1=5, r2=6, center = true);	
  }
}

L'exemple suivant créé un simple porte-clés

$fn = 20;
difference () {
hull () {
  # translate([0,0,0]) cylinder(r=2,h=3);
  translate([10,0,0]) cylinder(r=2,h=3);
  translate([5,40,0]) cylinder(r=4,h=3);
}
  translate([5,38,-1]) cylinder(r=1,h=5);
}

Porte-clé fait avecun hull (3 cylindres) et un cylindre pour faire un trou

Voir aussi: Doblo factory, le seul grand projet que nous avons tenté avec OpenScad.

Géométrie 2D et extrusion linéaire

Extruder des formes 2D en formes 3D est une autre manière de créer des objets complexes (mis à part la modélisation CSG). Il existe plusieurs possibilités et combinaisons :

• Type d'extrusion : linéaire (incluant une option de torsion) et rotation (la forme en 2D est tournée de 90 degrés et extrudée autour de l'axe Z)

• Source : graphiques 2D intégrés (cercle, carré, ellipse, polygones réguliers créés à partir de cercles avec $fn appliqué, et polygones)

Polygones

Les polygones peuvent avoir plusieurs trous, un seul ou aucun.

Exemple sans trou qui peut être utilisé pour définir la forme d'une structure de canapé :

color ("red") linear_extrude (height=19.2)
polygon(points=[[0,0],[16,0],
		[16,32],[80,32],[80,0],
		[96,0], [96,48],[0,48]
	     ]);

Exemple de polygone sans trou (l'image inclus une brique de l'usine de Doblo pour référence)

Exemple de code avec un trou :

polygon(points=[[0,0],[100,0],[0,100],[15,15],[65,15],[15,65]], paths=[[0,1,2],[3,4,5]]);

Exemple de polygone avec un trou

Dans cet exemple il y a exactement 6 points (3 pour le triangle "externe" et 3 pour le triangle "interne"). Puis on forme chaque triangle avec un chemin. Chaque élément d'un chemin doit correspondre à la position d'un point défini dans le vecteur de points (ex : ici "1" fait référence au point [100,0]).

Extrusion linéaire de 2D à 3D à partir de formes 2D intégrées

On peut extraire une forme 3D à partir de n'importe quel graphique 2D. Regardons ce qu'il en est pour les polygones.

Exemple : Polygone simple

color ("lightblue") linear_extrude (height=19.2)
#polygon(points=[[0,0],[16,0],
		[16,32],[80,32],[80,0],
		[96,0], [96,48],[0,48]
	     ]);

Exemple de polygone extrudé. Le Lego dans l'image a été réalisé avec l'usine de Doblo et est juste inclus pour avoir une référence de taille

Exemple : Polygone avec un trou

linear_extrude(height = 16, center = true, convexity = 10, twist = 0)
polygon(points=[[0,0],[100,0],[0,100],[15,15],[65,15],[15,65]], paths=[[0,1,2],[3,4,5]]);

Résultat : un triangle plat de 16mm de hauteur avec un triangle vide à l'intérieur.

Exemple de polygone extrudé

Exemple : Extrusion à partir de formes 2D créées en CSG

On peut aussi créer des formes 2D avec CSG. Par exemple, on pourrait créer une sorte de forme de lune en soustrayant un cercle à un autre cercle comme ceci :

difference () {
     circle (r=10);
     translate ([2,0,0]) circle(r=10);
}

Ou alors on pourrait proposer un exemple plus complet incluant des paramètres :

module half_moon (color="orange", size=16, thickness=4, fullness=0.5) {
     color (color)
	  rotate (a=[90,0,0])
	  linear_extrude (height=thickness)
	  difference () {
	  circle (r=size, $fs=0.2);
	  translate ([size*2*fullness,0,0]) {
	       circle (r=size,$fs=0.2);
	  }
     }
}

module moons () {
     half_moon(size=20,fullness=0.1,color="yellow");
     translate ([20,10,10]) half_moon(size=20,fullness=0.3,color="lightblue");
     translate ([40,20,20]) half_moon(size=10,fullness=0.5,color="red");
     }

moons ();

Polygone extrudé à partir d'une lune CSG en 2D

Importer et extruder des images 2D à partir d'une image SVG

Hamburger Lego-compatible imprimé en deux couleurs en PLA avec une imprimante Felix Pro 1

L'extrusion linéaire à partir d'images importées est un peu plus complexe, puisqu'il faudra partir d'un fichier DXF de bonne qualité. La plupart des cliparts sont disponibles au format SVG on partira de là, en se basant sur les instructions de Nudel (merci !).

Trouver des cliparts

Commençons par créer un personnage en 2D, comme ceux que l'on trouve dans certains jeux de plateforme. Il existe deux sources avec un bon catalogue de cliparts :

• http:openclipart.org (toutes sortes de thématiques) - Depuis été 2019 en panne
• https://thenounproject.com/ (très grande collection d'icônes)

Créer une extrusion avec une icône du NounProject peut se faire très rapidement une fois qu'on a habitude (moins d'une minute) car il suffit d'ouvrir l'objet dans InkScape et ensuite traduire le tout en série de segments. Ci-dessous on montre un exemple simple et un exemple plus compliqué

• Pour télécharger une image il faut s'enregistrer sur le site. Pour la plupart des icônes il y a une version publique et une version payante. Si on utilise la version publique il faut mentionner l'auteur, ce que nous faisons en insérant un commentaire dans le fichier scad et ici.
• Il faut prendre la version svg.

Transformer une fichier SVG en DXF - version courte

Exemple: Reading By Vectors Market

• Ouvrir dans InkScape
• Enlever le copyright (si nécessaire)
• CTRL-A
• Path -> Union
• Extension -> Modify Path -> Flatten Béziers (choisir le paramètre 0.2)
• Save as (choisir DXF, sans options)

Résultat avec un légo-compatible en prime: https://edutechwiki.unige.ch/fmediawiki/images/e/e7/Icon_reading_253716.stl

Transformer un fichier SVG en un fichier DXF utilisable à l'aide d'Inkscape (version longue)

Certains fichiers demandent plus travail avec plus d'étapes car il ne faut pas seulement transformer le dessin en une série de chemins fermés, ou chaque chemin est composé de segments rectilignes, mais également réparer et/ou modifier le SVG. Vous pouvez d'abord juste essayer l'étape 5 (transformer les courbes en segments droits) décrite aussi ci-dessus. Souvent, cela suffit.

En faisant une recherche pour "woman" sur le site du Nounproject nous avons trouvé cette dame que nous avons renommée en noun_woman.svg

(1) Ouvrir le SVG dans Inkscape et le nettoyer si vous pensez que le SVG est de mauvaise qualité (pas le cas pour nounp roject)

• Ajuster la taille du document à la taille de l'image : Menu Fichier > Propriétés du document
• Dans le panneau "taille personnalisée", ouvrir "redimensionner la page au contenu" puis cliquer sur "Ajuster la page au dessin ou à la sélection"
• Retirer les DEFs non utilisées : Fichier > Nettoyer le document
• Optimiser le SVG : Fichier > Enregistrer sous... > SVG optimisé
• Fichier > Enregistrer sous... > SVG simple

(2) Dégrouper et retirer le remplissage des formes (si nécessaire)

• Tout dégrouper (SHIFT CTRL-G)
• Sélectionner tous les objets (CTRL-A)
• Ajouter une couleur de ligne si nécessaire (SHIFT CTRL-F)
• Décocher le remplissage du fond.

Le résultat devrait ressembler à ça :

SVG nettoyé

(3) Si nécessaire, déplacer le contenu de tous les calques dans un seul. Supprimer les autres.

(4) Transformer tous les objets en chemins

• Sélectionner l(es)'objet(s) et faire une union si l'objet est simple. Sinon, nous suggérons de créer un chemin séparé pour chaque objet qui doit être rempli : Chemin > Union
• Sélectionner l'objet et le transformer en chemin : Chemin > Objet en chemin. Maintenant c'est un seul et unique chemin, même si cela représente visuellement plus d'un dessin. Nous suggérons de faire de l'édition de noeuds plus tard.
• Simplifier le chemin si nécessaire : Chemin > Simplifier

• Vérifier qu'il ne reste pas d'autre objet dans le fichier. Pour cela, ouvrir soit le panneau "Objects" soit l'éditeur XML (Edition > Editeur XML) et vérifier qu'il ne reste pas d'autre objet.

(5) Remplacer les courbes par des lignes droites

• Appuyer sur F2 (Editer le chemin par les noeuds)
• Sélectionner tous les noeuds (cliquer sur un noeud puis appuyer sur CTRL-A)
• Extensions -> Modify Path -> Flatten Beziers (fr: "Rendre rectilignes les segments sélectionnés") et choisir un paramètre comme 0.3 ou moins !

Répéter la procédure pour les autres chemins dans le dessin.

(6) Optionnel : faire de l'édition de chemin. Si vous avez besoin de relier deux chemins :

• Sélectionner deux noeuds d'un même chemin et cliquer sur "Briser le chemin aux noeuds sélectionnés"
• Faire la même chose avec l'autre chemin
• Supprimer quelques noeuds si nécessaire (sélectionner et cliquer sur "SUPPR")
• Rejoindre deux noeuds (deux fois, en prenant un noeud de chaque chemin à chaque fois) et cliquer sur "Joindre les noeuds terminaux sélectionnés par un nouveau segment"

Joindre les noeuds

(7) Modifier (optionnel)

• exemple : créer une plus jolie jupe
• Attention, si vous avez fait des changements (par exemple déplacer un noeud) il faut à nouveau rendre les segments rectilignes !

(8) Enregistrer en DXF

• Fichier > Enregistrer sous > DXF
• Décocher toutes les options

Une fois que vous avez un DXF propre vous pouvez importer les graphiques dans Openscad et extruder.

color ("pink") linear_extrude(height = 5, center = true, convexity = 10)
import (file = "noun_woman-clean.dxf");

Autre exemple plus compliqué

Femme rose SVG extrudée

Importer un dessin plus complexe sera plus délicat puisqu'il faudra traiter chaque sous-chemin séparément, et non pas créer une union.

• Cowgirl
• 

  Cowgirl originale par Simon Child

• 

  Cowgirl simplifiée (simplification du dessin, retrait de noeuds, sélection de sous-chemins, ajout de noeuds, transformation en segments rectilignes (mis à part quelques parties des cheveux)

• 

  Cowgirl simplifiée importée et extrudée

Cet objet peut être utilisé avec un bloc de Lego (soit déposé dessus, soit soustrait).

Cowgirl Lego compatible (voir l'usine de Doblo)

R2-D2 nettoyé de Lluis Pareras sur Nounproject

Si rien n'apparait

• Vérifier que tous les segments sont bien rectilignes. Pour rappel, si vous faites une union de tous les chemins ensuite cela peut être fait en une seule fois.
• Vérifier s'il reste du code Adobe dans le SVG. S'il y en a, il faut le supprimer manuellement (avec un éditeur de texte), après avoir simplifié, optimisé et unionisé votre image. Un bon exemple de cela est le fichier R2-D2 de Lluis Pareras. Il ne fonctionne qu'après avoir radicalement ôté tous les éléments mis à part le chemin.

Créer du texte 3D

Texte 2D extrudé

Depuis la version 2015.03 (Mars 2015), OpenScad possède un module pouvant produire du texte 2D qui peut ensuite être extrudé. Il fonctionne tel quel sous Windows, les autres systèmes d'exploitation n'ont pas été testés.

La fonction de texte accepte plusieurs arguments parmi lesquels :

• size : la taille approximative de la police
• font : le nom de la police, interne à OpenScad. Cette liste peut être obtenu dans le menu d'aide
• halign et valign
• spacing : pour gérer l'espacement des lettres (une bonne idée si l'on utilise une imprimante à filament)

Voici un exemple simple pour créer un texte :

 text("Text rocks")

Texte 2D extrudé utilisant la police Wingdings de Windows

Exemple de texte 3D :

content = "Text rocks";
font = "Liberation Sans";

translate ([-30,0,0]) {
   linear_extrude(height = 3) {
       text(content, font = font, size = 10);
     }
 }

L'exemple ci-contre dit que les araignées aiment leurs toiles et utilise la police Windings de Windows. Malheureusement cela n'est très certainement pas compatible avec les autres systèmes mais cela a le mérite de fonctionner.

content = "!Y\"";
font = "Webdings";

linear_extrude(height = 3) {
       text(content, font = font, spacing= 1.2, size = 10);
}

Dessins 2D DXF extraits de formes 3D STL

Solution de Giles BathGate, (récupérée le 28 décembre 2010)

projection(cut=false) import_stl(“/full/path/to/stl”);

or

projection(cut=true) translate([0,0,-10]) rotate([0,90,0]) import_stl(“file.stl”);

Puis, "export as" > DXF

Résolution de problèmes

Tracés

Echo Statements

Cette fonction renvoie le contenu dans la fenêtre de compilation. Utile pour débugger le code.

Exemples d'usages :

my_h=50;
my_r=100;
echo("This is a cylinder with h=", my_h, " and r=", my_r);
cylinder(h=my_h, r=my_r);

Objets "non simples"

Après avoir fait un rendu (F6), il arrive de voir ceci :

Parsing design (AST generation)...
Compiling design (CSG Tree generation)...
Compilation finished.
Rendering Polygon Mesh using CGAL...
Number of vertices currently in CGAL cache: 600
Number of objects currently in CGAL cache: 3
   Top level object is a 3D object:
   Simple:        '''no'''
   Valid:         yes
   Vertices:      200

Puis lorsque l'on tente d'exporter en .STL on obtient un message comme celui-ci :

Object isn't a valid 2-manifold! Modify your design..

Dans un objet valide "2-manifold", chaque arrête doit connecter exactement 2 faces. Voici un exemple tiré du forum d'OpenSCAD (récupéré 18:47, 22 March 2010 (UTC)) :

	module example1() {
		cube([20, 20, 20]);
		translate([-20, -20, 0]) cube([20, 20, 20]);
		cube([50, 50, 5], center = true);
	}

Ce module d'exemple n'est pas valide comme 2-manifold parce que les deux cubes partagent une arrête. Ils se touchent mais ne se croisent pas.

A not valid 2-manifold cube (simple = no)

Dans ce deuxième module d'exemple ce serait valide puisqu'il y a une intersection (les deux cubes se chevauchent un peu).

	module example2() {
		cube([20.1, 20.1, 20]);
		translate([-20, -20, 0]) cube([20.1, 20.1, 20]);
		cube([50, 50, 5], center = true);
	}

Donc quand on effectue des opérations géométriques sur les solides il est important de se souvenir que la pièce qui est soustraite doit s'étendre plus loin que la partie initiale. (OpenSCAD Tip: Manifold Space and Time, retrieved 18:47, 22 March 2010 (UTC)).

Thingiverse Customizer

Il permet de créer des fichiers OpenScad qui seront paramétrables par d'autres utilisateurs. Il faut pour cela respecter quelques règles qui sont expliquées dans la documentation.

Exemple de fragment de code :

/* [Running/Walking] */
RunningDistance=2; //[2:100]
RunningDuration=5; //[10:600]
/* [Dimensions] */
CutAway=0.5; //[0.5,0.7,0.8,1,1.5,2,3,4]]
HoleDiameter=3; //[1:5]
ScaleFactor=1; //[0.5,1,1.5,2,2.5,3]

/* [Hidden] */
$fn = 100; //sets the smoothness of the whole

Astuce

Dans le cas d'une importation d'un fichier 3D au format "stl" dans votre page OpenScad. Il peut arriver que celui-ci soit corrompu ou ne fonctionne pas correctement. Pour cela, vous pouvez utiliser NetFabb d'autodesk dont l'url est :https://www.autodesk.com/products/netfabb/overview. Cela permet de réparer le fichier et de pouvoir l'utiliser correctement dans OpenScad.

Liens

Sauf mention contraire, tous les liens proposés sont en anglais.

• http://openscad.org/
• http://en.wikibooks.org/wiki/OpenSCAD_User_Manual

Tutoriels

• Série de tutoriels OpenScad sur Makerbot (plusieurs bons articles de blog)

• La page d'acceuil d'OpenScad a quelques bonnes astuces sur la géométrie constructive avec les solides (CSG)

• Publications avec l'étiquette OpenSCAD sur le site "I Heart Robotics". L' astuce OpenSCAD : Linear and Rotational Extrusions est un "must read" pour les débutants.

• Hack a Day : How To : Make a Printable CES Badge

• Make: Projects - Simple 3D models with OpenSCAD. Explique comment créer un puzzle pentomino en semi 2D.

• OpenSCAD Tip: Manifold Space and Time A lire si vous voulez créer des modèles étanches à l'eau

Divers

• Mashups (discussion sur le forum de l'éducation BFB)
• Parametric Duplo (module par DKS sur Thingyverse)

Thingiverse Customizer

• Documentation
  • Guide de bonnes pratiques
  • Preview (vous pouvez copier-coller le code pour tester l'interface).

• [http://www.thingiverse.com/apps/customizer/run?thing_id=1663590&code=9f93ddb5a0fe5a8f70d48104565a3962

Formes géometriques / modèles 3D

• 3D modeling (Wikipedia)
• Polygon Mesh (Wikipedia)
• Vertex (Geometry), Wikipedia
• Edge (geometry) (Wikipedia)
• Face (geometry) (Wikipedia).
• polyhedronl (Wikipedia)

Logiciels

OpenScad

• http://www.openscad.org/ (Téléchargement d'OpenScad pour Win / Mac / Linux)

Utilitaires

• Inkscape to OpenSCAD converter v2. Une extension pour Inkscape permettant d'exporter des chemins Inscape vers OpenSCAD. Cette extension gère les arcs SVG, les clones, les cercles, les ellipses, les groupes, les lignes, les chemins, les polygones, les rectangles.. Il est possible d'exporter soit tout un document soit juste des portions de ce document.
• svgto3d Pour récupérer une liste de fichiers svg et les convertir en designs scad. Il ne restera plus qu'à modifier les tailes. C'est un script prêt à utiliser pour Linux/Unix (pour le faire fonctionner sous Win/Mac etc., du travail d'installation est nécessaire...). Sous Debian/Ubuntu, il faut faire : sudo apt-get install pstoedit

Alternatives à OpenSCAD

• https://emacstragic.net/programmatic-cad-openscad-alternatives/

Crédits et copyrights

• Certaines parties de cet article sont issues du guide d'utilisateur d'OpenSCAD
• Note : Par défaut, les images ont été créées par Daniel K. Schneider. Tout en rédigeant ce tutoriel en anglais, il a fait des mises à jour du manuel sur Wikibooks. Sinon les images sont issues du manuel d'OpenScad et cela est précisé dans les légendes.