Part scripting/it: Difference between revisions
Renatorivo (talk | contribs) (Created page with "{{Part Tools navi/it}}") |
No edit summary |
||
(43 intermediate revisions by 3 users not shown) | |||
Line 1: | Line 1: | ||
<languages/> |
<languages/> |
||
{{Docnav |
|||
== Script == |
|||
|[[FreeCAD_Scripting_Basics/it|Script di base per FreeCAD]] |
|||
|[[Topological_data_scripting/it|Script di dati topologici]] |
|||
}} |
|||
{{TOCright}} |
|||
The main data structure used in the Part module is the [http://en.wikipedia.org/wiki/Boundary_representation BRep] data type from OpenCascade. |
|||
Almost all contents and object types of the Part module are available by [[Python|Python]] scripting. This includes geometric primitives, such as Line and Circle (or Arc), and the whole range of TopoShapes, like Vertexes, Edges, Wires, Faces, Solids and Compounds. For each of those objects, several creation methods exist, and for some of them, especially the TopoShapes, advanced operations like boolean union/difference/intersection are also available. Explore the contents of the Part module, as described in the [[FreeCAD Scripting Basics|FreeCAD Scripting Basics]] page, to know more. |
|||
<span id="Introduction"></span> |
|||
=== Esempi === |
|||
==Introduzione== |
|||
La struttura dati principale utilizzata nel modulo Parte è il tipo di dati [https://it.wikipedia.org/wiki/B-Rep BRep] da [[OpenCASCADE/it|OpenCASCADE]]. Quasi tutti i contenuti e i tipi di oggetti del modulo Part sono disponibili per lo scripting con [[Python/it|Python]]. Ciò include le primitive geometriche, come linee, cerchi e archi, e l'intera gamma di forme topografiche, come vertici, bordi, fili, facce, solidi e composti. Per ciascuno di questi oggetti esistono diversi metodi di creazione e per alcuni di essi, in particolare TopoShapes, sono disponibili anche operazioni avanzate come unione/differenza/intersezione booleana. Si possono esplorare i contenuti del modulo Parte, come descritto nella pagina [[FreeCAD_Scripting_Basics/it|Script di base per FreeCAD]], per saperne di più. |
|||
L'oggetto più semplice che può essere creato è [[Part_Feature/it|Part]], che ha una semplice proprietà {{PropertyData|Placement}} e le proprietà di base per definirne il colore e l'aspetto. |
|||
Un altro oggetto semplice utilizzato negli oggetti geometrici 2D è il [[Part_Part2DObject/it|Part Part2DObject]], che è la base di [[Sketcher_SketchObject/it|Sketcher SketchObject]] e della maggior parte dei [[Draft_Workbench|Draft elements]]. |
|||
<span id="See_also"></span> |
|||
===Vedere anche=== |
|||
* [[Topological_data_scripting/it|Script di dati topologici]] |
|||
* [[OpenCASCADE/it|OpenCASCADE]] |
|||
<span id="Test_script"></span> |
|||
==Script di test== |
|||
Testare la creazione di [[Part_Primitives/it|Primitive Part]] con uno script. |
|||
To create a line element switch to the Python console and type in: |
|||
{{Code|code= |
{{Code|code= |
||
import parttests.part_test_objects as pto |
|||
import Part,PartGui |
|||
pto.create_test_file("example_file") |
|||
doc=App.newDocument() |
|||
}} |
|||
l=Part.LineSegment() |
|||
l.StartPoint=(0.0,0.0,0.0) |
|||
Questo script si trova nella cartella d'installazione del programma e può essere esaminato per vedere come vengono costruite le primitive di base. |
|||
l.EndPoint=(1.0,1.0,1.0) |
|||
doc.addObject("Part::Feature","Line").Shape=l.toShape() |
|||
{{Code|code= |
|||
$INSTALL_DIR/Mod/Part/parttests/part_test_objects.py |
|||
}} |
|||
<span id="Examples"></span> |
|||
==Esempi== |
|||
<span id="Line"></span> |
|||
===Linea=== |
|||
Per creare un elemento di linea, passa alla [[Python_console/it|console Python]] e inserisci: |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.newDocument() |
|||
line = Part.LineSegment() |
|||
line.StartPoint = (0.0, 0.0, 0.0) |
|||
line.EndPoint = (1.0, 1.0, 1.0) |
|||
obj = doc.addObject("Part::Feature", "Line") |
|||
obj.Shape= line.toShape() |
|||
doc.recompute() |
doc.recompute() |
||
}} |
}} |
||
Esaminiamo passo dopo passo l'esempio Python sopra: |
|||
Let's go through the above python example step by step: |
|||
{{Code|code= |
{{Code|code= |
||
import |
import FreeCAD as App |
||
import Part |
|||
doc=App.newDocument() |
|||
doc = App.newDocument() |
|||
}} |
}} |
||
Questo carica i moduli di FreeCAD e Part e crea un nuovo documento. |
|||
loads the Part module and creates a new document |
|||
{{Code|code= |
{{Code|code= |
||
line = Part.LineSegment() |
|||
line.StartPoint = (0.0, 0.0, 0.0) |
|||
line.EndPoint = (1.0, 1.0, 1.0) |
|||
}} |
}} |
||
La linea è in realtà un segmento di retta, quindi ha un inizio e un punto finale. |
|||
Line is actually a line segment, hence the start and endpoint. |
|||
{{Code|code= |
{{Code|code= |
||
doc.addObject("Part::Feature","Line" |
obj = doc.addObject("Part::Feature", "Line") |
||
obj.Shape= line.toShape() |
|||
}} |
}} |
||
Questo aggiunge un tipo di oggetto Parte al documento e assegna la rappresentazione della forma del segmento di linea alla proprietà {{Incode|Shape}} dell'oggetto aggiunto. È importante capire qui che usiamo una primitiva geometrica (il {{Incode|Part.LineSegment}}) per creare un TopoShape da esso (con il metodo {{Incode|toShape()}}). Solo le forme possono essere aggiunte al documento. In FreeCAD le primitive geometriche sono usate come "strutture edilizie" per le forme. |
|||
{{Code|code= |
{{Code|code= |
||
doc.recompute() |
doc.recompute() |
||
}} |
}} |
||
Aggiorna il documento. Questo prepara anche la rappresentazione visiva del nuovo oggetto Part. |
|||
Updates the document. This also prepares the visual representation of the new part object. |
|||
Si noti che un segmento di linea può anche essere creato specificandone l'inizio e il punto finale direttamente nel costruttore, ad esempio {{Incode|Part.LineSegment(point1, point2)}}, oppure possiamo creare una linea predefinita e impostarne le proprietà in seguito, come abbiamo fatto qui. |
|||
È inoltre possibile creare una linea utilizzando: |
|||
A circle can be created in a similar way: |
|||
{{Code|code= |
{{Code|code= |
||
import FreeCAD as App |
|||
import Part |
import Part |
||
def my_create_line(pt1, pt2, obj_name): |
|||
obj = App.ActiveDocument.addObject("Part::Line", obj_name) |
|||
obj.X1 = pt1[0] |
|||
obj.Y1 = pt1[1] |
|||
obj.Z1 = pt1[2] |
|||
obj.X2 = pt2[0] |
|||
obj.Y2 = pt2[1] |
|||
obj.Z2 = pt2[2] |
|||
App.ActiveDocument.recompute() |
|||
return obj |
|||
line = my_create_line((0, 0, 0), (0, 10, 0), "LineName") |
|||
}} |
|||
<span id="Circle"></span> |
|||
===Cerchio=== |
|||
Un cerchio può essere creato in modo simile: |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.activeDocument() |
doc = App.activeDocument() |
||
c = Part.Circle() |
|||
circle = Part.Circle() |
|||
c.Radius=10.0 |
|||
circle.Radius = 10.0 |
|||
f = doc.addObject("Part::Feature", "Circle") |
|||
obj = doc.addObject("Part::Feature", "Circle") |
|||
f.Shape = c.toShape() |
|||
obj.Shape = circle.toShape() |
|||
doc.recompute() |
doc.recompute() |
||
}} |
}} |
||
oppure usando: |
|||
Note again, we used the circle (geometry primitive) to construct a shape out of it. We can of course still access our construction geometry afterwards, by doing: |
|||
{{Code|code= |
{{Code|code= |
||
import FreeCAD as App |
|||
s = f.Shape |
|||
import Part |
|||
e = s.Edges[0] |
|||
c = e.Curve |
|||
def my_create_circle(rad, obj_name): |
|||
obj = App.ActiveDocument.addObject("Part::Circle", obj_name) |
|||
obj.Radius = rad |
|||
App.ActiveDocument.recompute() |
|||
return obj |
|||
circle = my_create_circle(5.0, "CircleName") |
|||
}} |
}} |
||
In alternativa possiamo creare un cerchio definendone il centro, l'asse e il raggio: |
|||
Here we take the shape of our object f, then we take its list of edges. In this case there will be only one because we made the whole shape out of a single circle, so we take only the first item of the Edges list, and we takes its curve. Every Edge has a Curve, which is the geometry primitive it is based on. |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.activeDocument() |
|||
Head to the [[Topological data scripting|Topological data scripting]] page if you would like to know more. |
|||
center = App.Vector(1, 2, 3) |
|||
{{Part Tools navi/it}} |
|||
axis = App.Vector(1, 1, 1) |
|||
radius = 10 |
|||
circle = Part.Circle(center, axis, radius) |
|||
obj = doc.addObject("Part::Feature", "Circle") |
|||
obj.Shape = circle.toShape() |
|||
doc.recompute() |
|||
}} |
|||
Oppure definendo tre punti sulla sua circonferenza: |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.activeDocument() |
|||
p1 = App.Vector(10, 0, 0) |
|||
p2 = App.Vector(0, 10, 0) |
|||
p3 = App.Vector(0, 0, 10) |
|||
circle = Part.Circle(p1, p2, p3) |
|||
obj = doc.addObject("Part::Feature", "Circle") |
|||
obj.Shape = circle.toShape() |
|||
doc.recompute() |
|||
}} |
|||
Si noti ancora, che abbiamo usato il cerchio (primitiva geometrica) per costruire una forma. Ovviamente possiamo ancora accedere alla nostra geometria di costruzione in seguito, facendo: |
|||
{{Code|code= |
|||
shape = obj.Shape |
|||
edge = shape.Edges[0] |
|||
curve = edge.Curve |
|||
}} |
|||
Qui prendiamo il {{Incode|Shape}} del nostro oggetto {{Incode|obj}} e poi la sua lista di {{Incode|Edges}}. In questo caso ci sarà un solo bordo perché abbiamo ricavato la forma da un unico cerchio. Quindi prendiamo solo il primo elemento nell'elenco {{Incode|Edges}}, successivamente prendiamo la sua curva. Ogni bordo ha un {{Incode|Curve}}, che è la primitiva geometrica su cui si basa. |
|||
<span id="Arc"></span> |
|||
===Arco=== |
|||
Un arco può essere creato in questo modo: |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.activeDocument() |
|||
p1 = App.Vector(10, 0, 0) |
|||
p2 = App.Vector(0, 10, 0) |
|||
p3 = App.Vector(-10, 0, 0) |
|||
arc = Part.Arc(p1, p2, p3) |
|||
obj = doc.addObject("Part::Feature", "Arc") |
|||
obj.Shape = arc.toShape() |
|||
doc.recompute() |
|||
}} |
|||
Così si disegna un semicerchio. Il centro è a (0, 0, 0). Il raggio è 10. P1 è il punto iniziale sull'asse +X. P2 è il punto medio sull'asse +Y e P3 è il punto finale sull'asse -X. |
|||
Possiamo anche creare un arco da un cerchio: |
|||
{{Code|code= |
|||
import FreeCAD as App |
|||
import Part |
|||
doc = App.activeDocument() |
|||
p1 = App.Vector(10, 0, 0) |
|||
p2 = App.Vector(0, 10, 0) |
|||
p3 = App.Vector(-10, 0, 0) |
|||
circle = Part.Circle(p1, p2, p3) |
|||
arc = Part.ArcOfCircle(circle, 0.0, 0.7854) |
|||
obj = doc.addObject("Part::Feature", "Arc") |
|||
obj.Shape = arc.toShape() |
|||
doc.recompute() |
|||
}} |
|||
È necessario un cerchio, un angolo iniziale e un angolo finale in radianti. |
|||
{{Docnav |
|||
|[[FreeCAD_Scripting_Basics/it|Script di base per FreeCAD]] |
|||
|[[Topological_data_scripting/it|Script di dati topologici]] |
|||
}} |
|||
{{Powerdocnavi{{#translation:}}}} |
|||
{{Userdocnavi}} |
|||
[[Category:Developer Documentation{{#translation:}}]] |
|||
[[Category:Python Code{{#translation:}}]] |
|||
{{Part Tools navi{{#translation:}}}} |
Latest revision as of 20:04, 20 May 2023
Introduzione
La struttura dati principale utilizzata nel modulo Parte è il tipo di dati BRep da OpenCASCADE. Quasi tutti i contenuti e i tipi di oggetti del modulo Part sono disponibili per lo scripting con Python. Ciò include le primitive geometriche, come linee, cerchi e archi, e l'intera gamma di forme topografiche, come vertici, bordi, fili, facce, solidi e composti. Per ciascuno di questi oggetti esistono diversi metodi di creazione e per alcuni di essi, in particolare TopoShapes, sono disponibili anche operazioni avanzate come unione/differenza/intersezione booleana. Si possono esplorare i contenuti del modulo Parte, come descritto nella pagina Script di base per FreeCAD, per saperne di più.
L'oggetto più semplice che può essere creato è Part, che ha una semplice proprietà DatiPlacement e le proprietà di base per definirne il colore e l'aspetto.
Un altro oggetto semplice utilizzato negli oggetti geometrici 2D è il Part Part2DObject, che è la base di Sketcher SketchObject e della maggior parte dei Draft elements.
Vedere anche
Script di test
Testare la creazione di Primitive Part con uno script.
import parttests.part_test_objects as pto
pto.create_test_file("example_file")
Questo script si trova nella cartella d'installazione del programma e può essere esaminato per vedere come vengono costruite le primitive di base.
$INSTALL_DIR/Mod/Part/parttests/part_test_objects.py
Esempi
Linea
Per creare un elemento di linea, passa alla console Python e inserisci:
import FreeCAD as App
import Part
doc = App.newDocument()
line = Part.LineSegment()
line.StartPoint = (0.0, 0.0, 0.0)
line.EndPoint = (1.0, 1.0, 1.0)
obj = doc.addObject("Part::Feature", "Line")
obj.Shape= line.toShape()
doc.recompute()
Esaminiamo passo dopo passo l'esempio Python sopra:
import FreeCAD as App
import Part
doc = App.newDocument()
Questo carica i moduli di FreeCAD e Part e crea un nuovo documento.
line = Part.LineSegment()
line.StartPoint = (0.0, 0.0, 0.0)
line.EndPoint = (1.0, 1.0, 1.0)
La linea è in realtà un segmento di retta, quindi ha un inizio e un punto finale.
obj = doc.addObject("Part::Feature", "Line")
obj.Shape= line.toShape()
Questo aggiunge un tipo di oggetto Parte al documento e assegna la rappresentazione della forma del segmento di linea alla proprietà Shape
dell'oggetto aggiunto. È importante capire qui che usiamo una primitiva geometrica (il Part.LineSegment
) per creare un TopoShape da esso (con il metodo toShape()
). Solo le forme possono essere aggiunte al documento. In FreeCAD le primitive geometriche sono usate come "strutture edilizie" per le forme.
doc.recompute()
Aggiorna il documento. Questo prepara anche la rappresentazione visiva del nuovo oggetto Part.
Si noti che un segmento di linea può anche essere creato specificandone l'inizio e il punto finale direttamente nel costruttore, ad esempio Part.LineSegment(point1, point2)
, oppure possiamo creare una linea predefinita e impostarne le proprietà in seguito, come abbiamo fatto qui.
È inoltre possibile creare una linea utilizzando:
import FreeCAD as App
import Part
def my_create_line(pt1, pt2, obj_name):
obj = App.ActiveDocument.addObject("Part::Line", obj_name)
obj.X1 = pt1[0]
obj.Y1 = pt1[1]
obj.Z1 = pt1[2]
obj.X2 = pt2[0]
obj.Y2 = pt2[1]
obj.Z2 = pt2[2]
App.ActiveDocument.recompute()
return obj
line = my_create_line((0, 0, 0), (0, 10, 0), "LineName")
Cerchio
Un cerchio può essere creato in modo simile:
import FreeCAD as App
import Part
doc = App.activeDocument()
circle = Part.Circle()
circle.Radius = 10.0
obj = doc.addObject("Part::Feature", "Circle")
obj.Shape = circle.toShape()
doc.recompute()
oppure usando:
import FreeCAD as App
import Part
def my_create_circle(rad, obj_name):
obj = App.ActiveDocument.addObject("Part::Circle", obj_name)
obj.Radius = rad
App.ActiveDocument.recompute()
return obj
circle = my_create_circle(5.0, "CircleName")
In alternativa possiamo creare un cerchio definendone il centro, l'asse e il raggio:
import FreeCAD as App
import Part
doc = App.activeDocument()
center = App.Vector(1, 2, 3)
axis = App.Vector(1, 1, 1)
radius = 10
circle = Part.Circle(center, axis, radius)
obj = doc.addObject("Part::Feature", "Circle")
obj.Shape = circle.toShape()
doc.recompute()
Oppure definendo tre punti sulla sua circonferenza:
import FreeCAD as App
import Part
doc = App.activeDocument()
p1 = App.Vector(10, 0, 0)
p2 = App.Vector(0, 10, 0)
p3 = App.Vector(0, 0, 10)
circle = Part.Circle(p1, p2, p3)
obj = doc.addObject("Part::Feature", "Circle")
obj.Shape = circle.toShape()
doc.recompute()
Si noti ancora, che abbiamo usato il cerchio (primitiva geometrica) per costruire una forma. Ovviamente possiamo ancora accedere alla nostra geometria di costruzione in seguito, facendo:
shape = obj.Shape
edge = shape.Edges[0]
curve = edge.Curve
Qui prendiamo il Shape
del nostro oggetto obj
e poi la sua lista di Edges
. In questo caso ci sarà un solo bordo perché abbiamo ricavato la forma da un unico cerchio. Quindi prendiamo solo il primo elemento nell'elenco Edges
, successivamente prendiamo la sua curva. Ogni bordo ha un Curve
, che è la primitiva geometrica su cui si basa.
Arco
Un arco può essere creato in questo modo:
import FreeCAD as App
import Part
doc = App.activeDocument()
p1 = App.Vector(10, 0, 0)
p2 = App.Vector(0, 10, 0)
p3 = App.Vector(-10, 0, 0)
arc = Part.Arc(p1, p2, p3)
obj = doc.addObject("Part::Feature", "Arc")
obj.Shape = arc.toShape()
doc.recompute()
Così si disegna un semicerchio. Il centro è a (0, 0, 0). Il raggio è 10. P1 è il punto iniziale sull'asse +X. P2 è il punto medio sull'asse +Y e P3 è il punto finale sull'asse -X.
Possiamo anche creare un arco da un cerchio:
import FreeCAD as App
import Part
doc = App.activeDocument()
p1 = App.Vector(10, 0, 0)
p2 = App.Vector(0, 10, 0)
p3 = App.Vector(-10, 0, 0)
circle = Part.Circle(p1, p2, p3)
arc = Part.ArcOfCircle(circle, 0.0, 0.7854)
obj = doc.addObject("Part::Feature", "Arc")
obj.Shape = arc.toShape()
doc.recompute()
È necessario un cerchio, un angolo iniziale e un angolo finale in radianti.
- FreeCAD scripting: Python, Introduction to Python, Python scripting tutorial, FreeCAD Scripting Basics
- Modules: Builtin modules, Units, Quantity
- Workbenches: Workbench creation, Gui Commands, Commands, Installing more workbenches
- Meshes and Parts: Mesh Scripting, Topological data scripting, Mesh to Part, PythonOCC
- Parametric objects: Scripted objects, Viewproviders (Custom icon in tree view)
- Scenegraph: Coin (Inventor) scenegraph, Pivy
- Graphical interface: Interface creation, Interface creation completely in Python (1, 2, 3, 4, 5), PySide, PySide examples beginner, intermediate, advanced
- Macros: Macros, How to install macros
- Embedding: Embedding FreeCAD, Embedding FreeCADGui
- Other: Expressions, Code snippets, Line drawing function, FreeCAD vector math library (deprecated)
- Hubs: User hub, Power users hub, Developer hub
- Primitives: Box, Cylinder, Sphere, Cone, Torus, Tube, Create primitives, Shape builder
- Creation and modification: Extrude, Revolve, Mirror, Fillet, Chamfer, Make face from wires, Ruled Surface, Loft, Sweep, Section, Cross sections, 3D Offset, 2D Offset, Thickness, Projection on surface, Attachment
- Boolean: Make compound, Explode Compound, Compound Filter, Boolean, Cut, Fuse, Common, Connect, Embed, Cutout, Boolean fragments, Slice apart, Slice, XOR
- Measure: Measure Linear, Measure Angular, Measure Refresh, Clear All, Toggle All, Toggle 3D, Toggle Delta