Modélisateur CAO 3D paramétrique Open Source

Premiers pas avec FreeCAD

FreeCAD est disponible sous forme d'installateurs précompilés pour Windows, macOS et Linux sur la page des dernières versions. Sous Linux, il est souvent disponible via le gestionnaire de paquets ou le centre logiciel de votre distribution. Pour les développeurs et les utilisateurs avancés, la compilation à partir du code source est prise en charge à l'aide de CMake. Le Manuel du développeur officiel fournit des instructions détaillées de compilation. Une fois installé, lancez FreeCAD et explorez les ateliers via la barre d'outils. La console Python et le système de macros permettent l'automatisation et la personnalisation. Pour des ressources d'apprentissage, consultez le guide Guide de démarrage sur le wiki FreeCAD.

# Ubuntu/Debian
sudo apt install freecad

# macOS (Homebrew)
brew install --cask freecad

# Windows: Download from https://github.com/FreeCAD/FreeCAD/releases/latest

Modélisation 3D paramétrique avec l'API Python

Le moteur de modélisation paramétrique de FreeCAD permet aux utilisateurs de définir des objets avec des paramètres modifiables, facilitant les itérations de conception en ajustant simplement les valeurs. L'API Python expose l'ensemble de la pile de modélisation, permettant aux développeurs de créer des géométries complexes de manière programmatique. En utilisant les ateliers Part et PartDesign, vous pouvez générer des primitives, effectuer des opérations booléennes, ajouter des congés/chanfreins, et créer des fonctionnalités telles que des bosses, des poches et des révolutions — le tout via Python. Cette capacité est essentielle pour la conception générative, l'optimisation topologique et l'intégration du CAO avec les flux de travail de simulation ou de fabrication. L'API prend en charge à la fois les approches orientées objet et fonctionnelles, ce qui la rend adaptée au scripting, aux macros et aux plugins complets. Avec l'accès au noyau OpenCASCADE sous-jacent, FreeCAD offre des opérations géométriques de niveau professionnel tout en restant facile d'utilisation pour les débutants.

import FreeCAD as App
import Part

# Create document and object
doc = App.newDocument()
cube = doc.addObject("Part::Box", "Cube")
cube.Length = 10
cube.Width = 20
cube.Height = 30
App.ActiveDocument.recompute()

# Modify dimensions later
cube.Length = 15
App.ActiveDocument.recompute()

Atelier de croquis 2D et de dessin

FreeCAD comprend un environnement de croquis 2D robuste intégré à la chaîne de modélisation 3D. L'atelier Sketcher permet aux utilisateurs de dessiner des profils 2D contraints géométriquement en utilisant des lignes, des arcs, des cercles et des splines. Des contraintes telles que horizontale, verticale, parallèle, perpendiculaire et dimensionnelle garantissent un contrôle précis de la géométrie du croquis. Une fois terminés, ces croquis servent de base aux fonctions 3D telles que les extrusions, les révolutions et les lofts. De plus, l'atelier Draft offre des outils pour créer des dessins vectoriels 2D sans contraintes, idéal pour les plans d'étage architecturaux ou les illustrations techniques. L'atelier Drawing permet de générer des projections orthographiques, des vues en coupe et des dessins annotés à partir de modèles 3D, en supportant une documentation technique conforme aux normes ISO avec des fonctions de cotation, de tolérancement et de nomenclature.

import FreeCAD as App
import Sketcher
import PartDesign

doc = App.newDocument()
Part = doc.addObject("PartDesign::Body")
Sketch = doc.addObject("Sketcher::SketchObject", "Sketch")
Sketch.Placement = App.Placement(App.Vector(0,0,0), App.Rotation(App.Vector(0,0,1),0))

# Add geometry
Sketch.addGeometry(Part.LineSegment(App.Vector(-10,0,0),App.Vector(10,0,0)),False)
Sketch.addGeometry(Part.LineSegment(App.Vector(10,0,0),App.Vector(10,10,0)),False)
Sketch.addGeometry(Part.LineSegment(App.Vector(10,10,0),App.Vector(-10,10,0)),False)
Sketch.addGeometry(Part.LineSegment(App.Vector(-10,10,0),App.Vector(-10,0,0)),False)

# Add constraints
Sketch.addConstraint(Sketcher.Constraint('Coincident',0,2,1,1))
Sketch.addConstraint(Sketcher.Constraint('Coincident',1,2,2,1))
Sketch.addConstraint(Sketcher.Constraint('Coincident',2,2,3,1))
Sketch.addConstraint(Sketcher.Constraint('Coincident',3,2,0,1))
Sketch.addConstraint(Sketcher.Constraint('Horizontal',0))
Sketch.addConstraint(Sketcher.Constraint('Vertical',1))

# Extrude
Pad = doc.addObject("PartDesign::Pad", "Pad")
Pad.Profile = Sketch
Pad.Length = 5
doc.recompute()

Conception d'assemblage et résolution de contraintes

FreeCAD prend en charge la modélisation d'assemblages complexes via les ateliers Assembly4 et Assembly3, permettant aux utilisateurs de combiner plusieurs pièces en mécanismes fonctionnels. Les assemblages sont construits à l'aide de contraintes telles que coïncidente, parallèle, perpendiculaire, tangentielle et de distance pour définir les positions relatives et les mouvements entre les composants. Le solveur met automatiquement à jour l'assemblage lorsqu'une pièce ou une contrainte est modifiée, garantissant l'intégrité du design. Cette capacité est essentielle pour les tâches d'ingénierie mécanique telles que les trains d'engrenages, les liaisons et les conceptions d'enceintes. Les assemblages peuvent être exportés au format STEP pour collaborer avec d'autres systèmes CAD, et la simulation de mouvement est possible grâce à l'intégration d'outils externes comme Yade ou des scripts Python personnalisés. La nature paramétrique de FreeCAD assure que les modifications des pièces individuelles se propagent automatiquement à l'assemblage, réduisant les mises à jour manuelles et minimisant les erreurs.

import FreeCAD as App
import Assembly4

doc = App.newDocument("Assembly")
# Add parts
Part1 = doc.addObject("Part::Box", "Block1")
Part1.Length, Part1.Width, Part1.Height = 10, 10, 10
Part2 = doc.addObject("Part::Cylinder", "Cylinder1")
Part2.Radius, Part2.Height = 3, 15

# Create assembly
asm = doc.addObject("App::Part", "Assembly")
asm.Type = "Assembly"
asm.addObject(Part1)
asm.addObject(Part2)

# Apply constraint (simplified)
# In practice, use Assembly4's Constraint class for full functionality
App.ActiveDocument.recompute()

Outils BIM et de modélisation architecturale

FreeCAD comprend des outils spécialisés pour la modélisation des informations du bâtiment (BIM) et la conception architecturale via l'atelier Arch. Les utilisateurs peuvent créer des murs, des planchers, des toits, des fenêtres, des portes et des éléments structurels à l'aide d'objets paramétriques intuitifs. Ces objets se mettent à jour automatiquement lorsque leurs paramètres changent, favorisant une conception itérative et la conformité aux codes du bâtiment. L'atelier prend en charge l'import/export IFC (Industry Foundation Classes), permettant l'interopérabilité avec les logiciels BIM standards de l'industrie tels que Revit et Archicad. Des fonctionnalités comme la planification du site, la configuration d'analyses énergétiques et les quantitatifs de matériaux rendent FreeCAD adapté à la conception architecturale précoce et à la documentation. De plus, les ateliers Draft et Sketcher s'intègrent parfaitement pour créer des plans d'étage et des élévations précis, tandis que l'atelier Drawing génère des documents de construction avec annotations, dimensions et plannings.

import FreeCAD as App
import Arch

doc = App.newDocument("Building")
# Create wall
Wall = Arch.makeWall(length=5000, width=200, height=3000)
Wall.Base = Arch.makeSketch([0,0,0], [5000,0,0], [5000,200,0], [0,200,0])

# Create window
Window = Arch.makeWindow(1200, 1500)
Window.Base = Arch.makeSketch([1000,100,0], [2200,100,0], [2200,1600,0], [1000,1600,0])
Window.Host = Wall

App.ActiveDocument.recompute()