Manual:Creating and manipulating geometry/it: Difference between revisions

From FreeCAD Documentation
(Created page with "Oppure, il punto iniziale e il punto finale di ogni lato:")
(Updating to match new version of source page)
 
(66 intermediate revisions by 4 users not shown)
Line 1: Line 1:
<languages/>
{{Manual:TOC/it}}

{{Docnav/it
|[[Manual:A_gentle_introduction/it|Una breve introduzione a Python]]
|[[Manual:Creating_parametric_objects/it|Creare oggetti parametrici]]
|[[Manual:Introduction/it|Pagina iniziale del manuale]]
|IconC=Crystal_Clear_manual.png
}}

{{Manual:TOC}}


Nei capitoli precedenti, abbiamo imparato a conoscere i diversi ambienti di FreeCAD, e che ciascuno di essi implementa i suoi propri strumenti e tipi di geometria. Gli stessi concetti si applicano quando si lavora con il codice Python.
Nei capitoli precedenti, abbiamo imparato a conoscere i diversi ambienti di FreeCAD, e come ciascuno di essi implementa i suoi propri strumenti e tipi di geometria. Gli stessi concetti si applicano quando si lavora con il codice Python.


Abbiamo anche visto che la grande maggioranza degli ambienti di FreeCAD dipendono da uno fondamentale: l'ambiente [[Part Workbench/it|Part]]. Infatti, molti altri ambienti di lavoro, come ad esempio [[Draft_Module/it|Draft]] o [[Arch_Module/it|Arch]], fanno esattamente quello che faremo in questo capitolo: usano del codice Python per creare e manipolare della geometria Part.
Abbiamo anche visto che la grande maggioranza degli ambienti di FreeCAD dipendono da uno fondamentale: l'ambiente [[Part_Workbench/it|Part]]. Infatti, molti altri ambienti di lavoro, come ad esempio [[Draft_Workbench/it|Draft]] e [[Arch_Workbench/it|Arch]], fanno esattamente quello che faremo in questo capitolo: usano del codice Python per creare e manipolare della geometria Part.


Quindi la prima cosa da fare per lavorare con la geometria Part, è di fare l'equivalente in Python passando all'ambiente Parte: importare il modulo Parte:
Quindi la prima cosa da fare per lavorare con la geometria Part, è di fare l'equivalente in Python passando all'ambiente Parte: importare il modulo Parte:


{{Code|code=
import Part
import Part
}}


Dedicare un minuto per esplorare il contenuto del modulo parte, digitando Part. e navigare attraverso i diversi metodi proposti. Il modulo Parte offre diversi funzioni di convenienza, come makeBox, makeCircle, ecc ... che costruiscono immediatamente un oggetto. Provare questo, come esempio:
Dedicare un minuto per esplorare il contenuto del modulo parte, digitando Part. e navigare attraverso i diversi metodi disponibili. Il modulo Parte offre diversi funzioni di convenienza, come makeBox, makeCircle, ecc ... che costruiscono immediatamente un oggetto. Provare questo, come esempio:


{{Code|code=
Part.makeBox(3,5,7)
Part.makeBox(3,5,7)
}}


Quando si preme Invio dopo aver digitato la linea precedente, nella vista 3D non appare nulla, ma nella console di Python viene stampato qualcosa di simile:
Quando si preme Invio dopo aver digitato la linea precedente, nella vista 3D non appare nulla, ma nella console di Python viene stampato qualcosa di simile:


{{Code|code=
<Solid object at 0x5f43600>
<Solid object at 0x5f43600>
}}


Questo è dove avviene un concetto importante. Quello che abbiamo creato qui è una forma parte, una Part Shape. Non si tratta ancora di un document object di FreeCAD. In FreeCAD, gli oggetti e loro geometria sono indipendenti. Pensiamo a un document object di FreeCAD come un contenitore, destinato a ospitare una forma. Gli oggetti parametrici hanno anche delle proprietà, come lunghezza e larghezza, e la loro forma viene '''ricalcolata''' al-volo, ogni volta che cambia una delle proprietà. Quì abbiamo calcolato una forma manualmente.
Questo è dove avviene un concetto importante. Quello che abbiamo creato qui è una forma parte, una Part Shape. Non si tratta ancora di un document object di FreeCAD. In FreeCAD, gli oggetti e loro geometria sono indipendenti. Pensiamo a un document object di FreeCAD come un contenitore, destinato a ospitare una forma. Gli oggetti parametrici hanno anche delle proprietà, come lunghezza e larghezza, e la loro forma viene '''ricalcolata''' al-volo, ogni volta che cambia una delle proprietà. Quì abbiamo calcolato una forma manualmente.
Line 21: Line 36:
Ora possiamo creare facilmente un "generico" document object nel documento corrente (assicuratevi di avere almeno un nuovo documento aperto), e assegnargli la forma box che abbiamo appena creato:
Ora possiamo creare facilmente un "generico" document object nel documento corrente (assicuratevi di avere almeno un nuovo documento aperto), e assegnargli la forma box che abbiamo appena creato:


{{Code|code=
boxShape = Part.makeBox(3,5,7)
boxShape = Part.makeBox(3,5,7)
myObj = FreeCAD.ActiveDocument.addObject("Part::Feature","MyNewBox")
myObj = FreeCAD.ActiveDocument.addObject("Part::Feature","MyNewBox")
myObj.Shape = boxShape
myObj.Shape = boxShape
FreeCAD.ActiveDocument.recompute()
FreeCAD.ActiveDocument.recompute()
}}


Notare come abbiamo gestito myObj.Shape, vedere che abbiamo fatto esattamente come abbiamo fatto nel capitolo precedente, quando abbiamo cambiato altre proprietà di un oggetto, come ad esempio box.Height = 5. Infatti, '''Shape''' è anche una proprietà, proprio come '''Height'''. Solo che prende una Part Shape, non un numero. Nel prossimo capitolo daremo uno sguardo più approfondito su come sono costruiti tali oggetti parametrici.
Notare come abbiamo gestito myObj.Shape, vedere che abbiamo fatto esattamente come abbiamo fatto nel capitolo precedente, quando abbiamo cambiato altre proprietà di un oggetto, come ad esempio box.Height = 5. Infatti, '''Shape''' è anche una proprietà, proprio come '''Height'''. Solo che prende una Part Shape, non un numero. Nel prossimo capitolo daremo uno sguardo più approfondito su come sono costruiti tali oggetti parametrici.


Per il momento, esploriamo la Part Shape più in dettaglio. Alla fine del capitolo in merito alla [Manual:Traditional modeling, the CSG way/it|modellazione tradizionale con l'ambiente Parte] abbiamo mostrato una tabella che spiega come sono costruiti le forme Parte, e le loro diverse componenti (vertici, spigoli, facce, ecc). Quì esistono gli stessi esatti componenti e possono essere recuperati da Python. Tutte le Part Shape hanno sempre i seguenti attributi: Vertici, Bordi, Wire, Facce, Shell e Solid. Sono tutti elenchi, che possono contenere qualsiasi numero di elementi o essere vuoti:
Per il momento, esploriamo la Part Shape più in dettaglio. Alla fine del capitolo in merito alla [[Manual:Traditional modeling, the CSG way/it|modellazione tradizionale con l'ambiente Parte]] abbiamo mostrato una tabella che spiega come sono costruiti le forme Parte, e le loro diverse componenti (vertici, spigoli, facce, ecc). Quì esistono gli stessi esatti componenti e possono essere recuperati da Python. Tutte le Part Shape hanno sempre i seguenti attributi: Vertici, Bordi, Wire, Facce, Shell e Solid. Sono tutti elenchi, che possono contenere qualsiasi numero di elementi o essere vuoti:


{{Code|code=
print(boxShape.Vertexes)
print(boxShape.Edges)
print(boxShape.Vertexes)
print(boxShape.Wires)
print(boxShape.Edges)
print(boxShape.Faces)
print(boxShape.Wires)
print(boxShape.Shells)
print(boxShape.Faces)
print(boxShape.Solids)
print(boxShape.Shells)
print(boxShape.Solids)
}}


Per esempio, troviamo l'area di ogni faccia della nostra forma box:
Per esempio, troviamo l'area di ogni faccia della nostra forma box: (Assicuratevi di rientrare la seconda riga, come appare sotto. Premete Invio due volte dopo l'ultima riga per eseguire il comando Python).


{{Code|code=
for f in boxShape.Faces:
for f in boxShape.Faces:
print(f.Area)
print(f.Area)
}}


Oppure, il punto iniziale e il punto finale di ogni lato:
Oppure, il punto iniziale e il punto finale di ogni lato:


{{Code|code=
for e in boxShape.Edges:
for e in boxShape.Edges:
print("New edge")
print("New edge")
print("Start point:")
print("Start point:")
Line 50: Line 72:
print("End point:")
print("End point:")
print(e.Vertexes[1].Point)
print(e.Vertexes[1].Point)
}}


As you see, if our boxShape has a "Vertexes" attribute, each Edge of the boxShape also has a "Vertexes" attribute. As we can expect, the boxShape will have 8 vertices, while the edge will only have 2, which are both part of the list of 8.
Come si vede, se il nostro boxShape ha un attributo "Vertexes", ogni Bordo del boxShape ha anche un attributo "Vertexes". Come ci si può aspettare, il boxShape ha 8 vertici, mentre il Bordo ne ha solo 2, che sono entrambi parte della lista degli 8.


Possiamo sempre controllare il tipo di una forma:
We can always check what is the type of a shape:


{{Code|code=
print(boxShape.ShapeType)
print(boxShape.Faces[0].ShapeType)
print(boxShape.ShapeType)
print (boxShape.Vertexes[2].ShapeType)
print(boxShape.Faces[0].ShapeType)
print(boxShape.Vertexes[2].ShapeType)
}}


So to resume the whole diagram of Part Shapes: Everything starts with Vertices. With one or two vertices, you form an Edge (full circles have only one vertex). With one or more Edges, you form a Wire. With one or more closed Wires, you form a Face (the additional Wires become "holes" in the Face). With one or more Faces, you form a Shell. When a Shell is fully closed (watertight), you can form a Solid from it. And finally, you can join any number of Shapes of any types together, which is then called a Compound.
Quindi, per riassumere l'intero schema di una Part Shapes: Tutto comincia con i Vertici. Con uno o due vertici, si forma un bordo (i cerchi completi hanno un solo vertice). Con uno o più bordi, si forma un contorno, un Wire. Con uno o più contorni chiusi, si forma una faccia (i bordi aggiuntivi diventano "buchi" in una faccia). Con una o più facce, si forma un Guscio, un Shell. Quando un Shell è completamente chiusa (stagno), è possibile formare da esso un solido. E, infine, è possibile unire qualsiasi numero di forme di qualsiasi tipo, e produrre un Compoud, un Composto.


Ora proviamo a creare da zero forme complesse, con la costruzione di tutte le loro componenti una per una. Per esempio, cerchiamo di creare un volume come questo:
We can now try creating complex shapes from scratch, by constructing all their components one by one. For example, let's try to create a volume like this:


[[Image:Exercise_python_03.jpg]]
[[Image:Exercise_python_03.jpg]]


Inizieremo con la creazione di una forma planare come questa:
We will start by creating a planar shape like this:


[[Image:Wire.png]]
[[Image:Wire.png]]


In primo luogo, creiamo i quattro punti di base:
First, let's create the four base points:


{{Code|code=
V1 = FreeCAD.Vector(0,10,0)
V2 = FreeCAD.Vector(30,10,0)
V1 = FreeCAD.Vector(0,10,0)
V3 = FreeCAD.Vector(30,-10,0)
V2 = FreeCAD.Vector(30,10,0)
V4 = FreeCAD.Vector(0,-10,0)
V3 = FreeCAD.Vector(30,-10,0)
V4 = FreeCAD.Vector(0,-10,0)
}}


Poi possiamo creare i due segmenti lineari:
Then we can create the two linear segments:


[[Image:Line.png]]
[[Image:Line.png]]


{{Code|code=
L1 = Part.Line(V1,V2)
L2 = Part.Line(V4,V3)
L1 = Part.LineSegment(V1,V2)
L2 = Part.LineSegment(V4,V3)
}}


Note that we didn't need to create Vertices? We could immediately create Part.Lines from FreeCAD Vectors. This is because here we haven't created Edges yet. A Part.Line (as well as Part.Circle, Part.Arc, Part.Ellipse or Part.BSpline) does not create an Edge, but rather a base geometry on which an Edge will be created. Edges are always made from such a base geometry, which is stored its Curve attribute. So if you have an Edge, doing:
Notare che non è necessario creare dei vertici. Si può creare subito una Part.LineSegments dai vettori di FreeCAD. Questo è perché qui non abbiamo ancora creato un Edge. Una Part.LineSegment (così come una Part.Circle, Part.Arc, Part.Ellipse o Part.BSpline) non crea un bordo, ma piuttosto una geometria di base su cui viene creato un bordo. Gli Edges sono sempre costituiti su una tale geometria di base, che memorizza il suo attributo Curve.
Quindi, se si dispone di un bordo, facendo:


{{Code|code=
print(Edge.Curve)
print(Edge.Curve)
}}


will show you what kind of Edge this is, that is, if it is based on a line, an arc, etc... But let's come back to our exercise, and build the arc segments. For this, we will need a third point, so we can use the convenient Part.Arc, which takes 3 points:
mostra di che tipo di bordo si tratta, cioè, se si basa su una linea, un arco, ecc ... Ma torniamo all'esercizio, e creiamo i segmenti di arco. Per questo, serve un terzo punto, in modo da poter utilizzare il comodo Part.Arc, che prende 3 punti:


[[Image:Circel.png]]
[[Image:Circel.png]]


{{Code|code=
VC1 = FreeCAD.Vector(-10,0,0)
C1 = Part.Arc(V1,VC1,V4)
VC1 = FreeCAD.Vector(-10,0,0)
VC2 = FreeCAD.Vector(40,0,0)
C1 = Part.Arc(V1,VC1,V4)
C2 = Part.Arc(V2,VC2,V3)
VC2 = FreeCAD.Vector(40,0,0)
C2 = Part.Arc(V2,VC2,V3)
}}


Now we have 2 lines (L1 and L2) and 2 arcs (C1 and C2). We need to turn them into edges:
Ora abbiamo 2 linee (L1 e L2) e 2 archi (C1 e C2). Bisogna trasformarli in bordi:


{{Code|code=
E1 = Part.Edge(L1)
E2 = Part.Edge(L2)
E1 = Part.Edge(L1)
E3 = Part.Edge(C1)
E2 = Part.Edge(L2)
E4 = Part.Edge(C2)
E3 = Part.Edge(C1)
E4 = Part.Edge(C2)
}}


Alternatively, base geometries also have a toShape() function that do exactly the same thing:
In alternativa, le geometrie di base hanno anche una funzione toShape() che fa esattamente la stessa cosa:


{{Code|code=
E1 = L1.toShape()
E2 = L2.toShape()
E1 = L1.toShape()
E2 = L2.toShape()
...
...
}}


Ottenuta una serie di bordi, si può formare un contorno, dandogli un elenco di bordi. Bisogna stare attenti all'ordine. Inoltre, notare le parentesi.
Once we have a series of Edges, we can now form a Wire, by giving it a list of Edges. We don't need to take care of the order. [https://en.wikipedia.org/wiki/Open_Cascade_Technology OpenCasCade], the geometry "engine" of FreeCAD, is extraordinarily tolerant to unordered geometry. It will sort out what to do:


{{Code|code=
W = Part.Wire([E1,E2,E3,E4])
W = Part.Wire([E1,E4,E2,E3])
}}


E siamo in grado di verificare se il nostro contorno è stato compreso e chiuso correttamente:
And we can check if our Wire was correctly understood, and that it is correclty closed:


{{Code|code=
print( W.isClosed() )
print( W.isClosed() )
}}


Which will print "True" or "False". In order to make a Face, we need closed Wires, so it is always a good idea to check that before creating the Face. Now we can create a Face, by giving it a single Wire (or a list of Wires if we had holes):
Che stampa "True" o "False". Per creare una faccia, servono dei contorni chiusi, quindi è sempre una buona idea controllare questo prima di creare la faccia. Ora possiamo creare una faccia, dandogli un unico Wire (o una lista di Wire se vogliamo dei fori):


{{Code|code=
F = Part.Face(W)
F = Part.Face(W)
}}


Poi la estrudiamo:
Then we extrude it:


{{Code|code=
P = F.extrude(FreeCAD.Vector(0,0,10))
P = F.extrude(FreeCAD.Vector(0,0,10))
}}


Note that P is already a Solid:
Si noti che P è già un solido:


{{Code|code=
print(P.ShapeType)
print(P.ShapeType)
}}


Questo perché quando si estrude una sola faccia, si ottiene sempre una solido. Non è così se, ad esempio, si estrude invece un contorno
Because when extruding a single Face, we always get a Solid. This wouldn't be the case, for example, if we had extruded the Wire instead:


{{Code|code=
S = W.extrude(FreeCAD.Vector(0,0,10))
S = W.extrude(FreeCAD.Vector(0,0,10))
print(s.ShapeType)
print(S.ShapeType)
}}


Che ovviamente ci dà un guscio vuoto, con le facce superiore e inferiore mancanti.
Which will of course give us a hollow shell, with the top and bottom faces missing.


Ora che abbiamo la forma finale, siamo ansiosi di vederla sullo schermo! Quindi creiamo un oggetto generico, a cui attribuire il nostro nuovo Solid:
Now that we have our final Shape, we are anxious to see it on screen! So let's create a generic object, and attribute it our new Solid:


{{Code|code=
myObj2 = FreeCAD.ActiveDocument.addObject("Part::Feature","My_Strange_Solid")
myObj2 = FreeCAD.ActiveDocument.addObject("Part::Feature","My_Strange_Solid")
myObj2.Shape = P
myObj2.Shape = P
FreeCAD.ActiveDocument.recompute()
FreeCAD.ActiveDocument.recompute()
}}


In alternativa, il modulo Parte fornisce anche una scorciatoia che esegue più velocemente l'operazione descritta sopra (ma non è possibile scegliere il nome dell'oggetto):
Altenatively, the Part module also provides a shortcut that does the above operation quicker (but you cannot choose the name of the object):


{{Code|code=
Part.show(P)
Part.show(P)
}}


All of the above, and much more, is explained in detail on the [[Topological_data_scripting|Part Scripting]] page, together with examples.
Tutto quanto detto sopra, e molto altro ancora, è spiegato in dettaglio nella pagina [[Topological_data_scripting/it|Script di Parti]], insieme agli esempi.


'''Read more''':
'''Approfondimenti''':


* [[Part_Workbench|The Part Workbench]]
* [[Part_Workbench/it|L'ambiente Parte]]
* [[Topological_data_scripting|Part scripting]]
* [[Topological_data_scripting/it|Script di Parti]]



<languages/>
{{Docnav/it
|[[Manual:A_gentle_introduction/it|Una breve introduzione a Python]]
|[[Manual:Creating_parametric_objects/it|Creare oggetti parametrici]]
|[[Manual:Introduction/it|Pagina iniziale del manuale]]
|IconC=Crystal_Clear_manual.png
}}

{{Powerdocnavi{{#translation:}}}}
[[Category:Developer Documentation{{#translation:}}]]
[[Category:Python Code{{#translation:}}]]
{{clear}}

Latest revision as of 19:28, 4 November 2023

Nei capitoli precedenti, abbiamo imparato a conoscere i diversi ambienti di FreeCAD, e come ciascuno di essi implementa i suoi propri strumenti e tipi di geometria. Gli stessi concetti si applicano quando si lavora con il codice Python.

Abbiamo anche visto che la grande maggioranza degli ambienti di FreeCAD dipendono da uno fondamentale: l'ambiente Part. Infatti, molti altri ambienti di lavoro, come ad esempio Draft e Arch, fanno esattamente quello che faremo in questo capitolo: usano del codice Python per creare e manipolare della geometria Part.

Quindi la prima cosa da fare per lavorare con la geometria Part, è di fare l'equivalente in Python passando all'ambiente Parte: importare il modulo Parte:

import Part

Dedicare un minuto per esplorare il contenuto del modulo parte, digitando Part. e navigare attraverso i diversi metodi disponibili. Il modulo Parte offre diversi funzioni di convenienza, come makeBox, makeCircle, ecc ... che costruiscono immediatamente un oggetto. Provare questo, come esempio:

Part.makeBox(3,5,7)

Quando si preme Invio dopo aver digitato la linea precedente, nella vista 3D non appare nulla, ma nella console di Python viene stampato qualcosa di simile:

<Solid object at 0x5f43600>

Questo è dove avviene un concetto importante. Quello che abbiamo creato qui è una forma parte, una Part Shape. Non si tratta ancora di un document object di FreeCAD. In FreeCAD, gli oggetti e loro geometria sono indipendenti. Pensiamo a un document object di FreeCAD come un contenitore, destinato a ospitare una forma. Gli oggetti parametrici hanno anche delle proprietà, come lunghezza e larghezza, e la loro forma viene ricalcolata al-volo, ogni volta che cambia una delle proprietà. Quì abbiamo calcolato una forma manualmente.

Ora possiamo creare facilmente un "generico" document object nel documento corrente (assicuratevi di avere almeno un nuovo documento aperto), e assegnargli la forma box che abbiamo appena creato:

boxShape = Part.makeBox(3,5,7)
myObj = FreeCAD.ActiveDocument.addObject("Part::Feature","MyNewBox")
myObj.Shape = boxShape
FreeCAD.ActiveDocument.recompute()

Notare come abbiamo gestito myObj.Shape, vedere che abbiamo fatto esattamente come abbiamo fatto nel capitolo precedente, quando abbiamo cambiato altre proprietà di un oggetto, come ad esempio box.Height = 5. Infatti, Shape è anche una proprietà, proprio come Height. Solo che prende una Part Shape, non un numero. Nel prossimo capitolo daremo uno sguardo più approfondito su come sono costruiti tali oggetti parametrici.

Per il momento, esploriamo la Part Shape più in dettaglio. Alla fine del capitolo in merito alla modellazione tradizionale con l'ambiente Parte abbiamo mostrato una tabella che spiega come sono costruiti le forme Parte, e le loro diverse componenti (vertici, spigoli, facce, ecc). Quì esistono gli stessi esatti componenti e possono essere recuperati da Python. Tutte le Part Shape hanno sempre i seguenti attributi: Vertici, Bordi, Wire, Facce, Shell e Solid. Sono tutti elenchi, che possono contenere qualsiasi numero di elementi o essere vuoti:

print(boxShape.Vertexes)
print(boxShape.Edges)
print(boxShape.Wires)
print(boxShape.Faces)
print(boxShape.Shells)
print(boxShape.Solids)

Per esempio, troviamo l'area di ogni faccia della nostra forma box: (Assicuratevi di rientrare la seconda riga, come appare sotto. Premete Invio due volte dopo l'ultima riga per eseguire il comando Python).

for f in boxShape.Faces:
   print(f.Area)

Oppure, il punto iniziale e il punto finale di ogni lato:

for e in boxShape.Edges:
   print("New edge")
   print("Start point:")
   print(e.Vertexes[0].Point)
   print("End point:")
   print(e.Vertexes[1].Point)

Come si vede, se il nostro boxShape ha un attributo "Vertexes", ogni Bordo del boxShape ha anche un attributo "Vertexes". Come ci si può aspettare, il boxShape ha 8 vertici, mentre il Bordo ne ha solo 2, che sono entrambi parte della lista degli 8.

Possiamo sempre controllare il tipo di una forma:

print(boxShape.ShapeType)
print(boxShape.Faces[0].ShapeType)
print(boxShape.Vertexes[2].ShapeType)

Quindi, per riassumere l'intero schema di una Part Shapes: Tutto comincia con i Vertici. Con uno o due vertici, si forma un bordo (i cerchi completi hanno un solo vertice). Con uno o più bordi, si forma un contorno, un Wire. Con uno o più contorni chiusi, si forma una faccia (i bordi aggiuntivi diventano "buchi" in una faccia). Con una o più facce, si forma un Guscio, un Shell. Quando un Shell è completamente chiusa (stagno), è possibile formare da esso un solido. E, infine, è possibile unire qualsiasi numero di forme di qualsiasi tipo, e produrre un Compoud, un Composto.

Ora proviamo a creare da zero forme complesse, con la costruzione di tutte le loro componenti una per una. Per esempio, cerchiamo di creare un volume come questo:

Inizieremo con la creazione di una forma planare come questa:

In primo luogo, creiamo i quattro punti di base:

V1 = FreeCAD.Vector(0,10,0)
V2 = FreeCAD.Vector(30,10,0)
V3 = FreeCAD.Vector(30,-10,0)
V4 = FreeCAD.Vector(0,-10,0)

Poi possiamo creare i due segmenti lineari:

L1 = Part.LineSegment(V1,V2)
L2 = Part.LineSegment(V4,V3)

Notare che non è necessario creare dei vertici. Si può creare subito una Part.LineSegments dai vettori di FreeCAD. Questo è perché qui non abbiamo ancora creato un Edge. Una Part.LineSegment (così come una Part.Circle, Part.Arc, Part.Ellipse o Part.BSpline) non crea un bordo, ma piuttosto una geometria di base su cui viene creato un bordo. Gli Edges sono sempre costituiti su una tale geometria di base, che memorizza il suo attributo Curve. Quindi, se si dispone di un bordo, facendo:

print(Edge.Curve)

mostra di che tipo di bordo si tratta, cioè, se si basa su una linea, un arco, ecc ... Ma torniamo all'esercizio, e creiamo i segmenti di arco. Per questo, serve un terzo punto, in modo da poter utilizzare il comodo Part.Arc, che prende 3 punti:

VC1 = FreeCAD.Vector(-10,0,0)
C1 = Part.Arc(V1,VC1,V4)
VC2 = FreeCAD.Vector(40,0,0)
C2 = Part.Arc(V2,VC2,V3)

Ora abbiamo 2 linee (L1 e L2) e 2 archi (C1 e C2). Bisogna trasformarli in bordi:

E1 = Part.Edge(L1)
E2 = Part.Edge(L2)
E3 = Part.Edge(C1)
E4 = Part.Edge(C2)

In alternativa, le geometrie di base hanno anche una funzione toShape() che fa esattamente la stessa cosa:

E1 = L1.toShape()
E2 = L2.toShape()
 ...

Ottenuta una serie di bordi, si può formare un contorno, dandogli un elenco di bordi. Bisogna stare attenti all'ordine. Inoltre, notare le parentesi.

W = Part.Wire([E1,E4,E2,E3])

E siamo in grado di verificare se il nostro contorno è stato compreso e chiuso correttamente:

print( W.isClosed() )

Che stampa "True" o "False". Per creare una faccia, servono dei contorni chiusi, quindi è sempre una buona idea controllare questo prima di creare la faccia. Ora possiamo creare una faccia, dandogli un unico Wire (o una lista di Wire se vogliamo dei fori):

F = Part.Face(W)

Poi la estrudiamo:

P = F.extrude(FreeCAD.Vector(0,0,10))

Si noti che P è già un solido:

print(P.ShapeType)

Questo perché quando si estrude una sola faccia, si ottiene sempre una solido. Non è così se, ad esempio, si estrude invece un contorno

S = W.extrude(FreeCAD.Vector(0,0,10))
print(S.ShapeType)

Che ovviamente ci dà un guscio vuoto, con le facce superiore e inferiore mancanti.

Ora che abbiamo la forma finale, siamo ansiosi di vederla sullo schermo! Quindi creiamo un oggetto generico, a cui attribuire il nostro nuovo Solid:

myObj2 = FreeCAD.ActiveDocument.addObject("Part::Feature","My_Strange_Solid")
myObj2.Shape = P
FreeCAD.ActiveDocument.recompute()

In alternativa, il modulo Parte fornisce anche una scorciatoia che esegue più velocemente l'operazione descritta sopra (ma non è possibile scegliere il nome dell'oggetto):

Part.show(P)

Tutto quanto detto sopra, e molto altro ancora, è spiegato in dettaglio nella pagina Script di Parti, insieme agli esempi.

Approfondimenti: