Code snippets/ro: Difference between revisions

From FreeCAD Documentation
(Updating to match new version of source page)
(Updating to match new version of source page)
Line 1: Line 1:
<languages/>
<languages/>
<div class="mw-translate-fuzzy">
{{docnav/ro|[[Embedding FreeCAD/ro|Embedding FreeCAD]]|[[Line drawing function/ro|Line drawing function]]}}
{{docnav/ro|[[Embedding FreeCAD/ro|Embedding FreeCAD]]|[[Line drawing function/ro|Line drawing function]]}}
</div>


{{TutorialInfo/ro
{{TutorialInfo/ro
Line 15: Line 17:
=== Un fișier tipic InitGui.py ===
=== Un fișier tipic InitGui.py ===
Fiecare modul trebuie să conțină, pe lângă fișierul modulului principal, un fișier InitGui.py, responsabil pentru înserarea modulului GUI principal. Acesta este un exemplu simplu.
Fiecare modul trebuie să conțină, pe lângă fișierul modulului principal, un fișier InitGui.py, responsabil pentru înserarea modulului GUI principal. Acesta este un exemplu simplu.

{{Code|code=
{{Code|code=
class ScriptWorkbench (Workbench):
class ScriptWorkbench (Workbench):
Line 28: Line 31:
=== Un fișier modul tipic ===
=== Un fișier modul tipic ===
Acesta este un exemplu al unui fișier modul principal, care conține tot ceea ce face modul dvs. Acesta este fișierul Scripts.py invocat în exemplul anterior. Puteți să aveți toate comenzile personalizate aici.
Acesta este un exemplu al unui fișier modul principal, care conține tot ceea ce face modul dvs. Acesta este fișierul Scripts.py invocat în exemplul anterior. Puteți să aveți toate comenzile personalizate aici.

{{Code|code=
{{Code|code=
import FreeCAD, FreeCADGui
import FreeCAD, FreeCADGui
Line 46: Line 50:


Această linie trebuie adăugată în fișierul InitGui.py pentru a adăuga noua extensie de fișier în listă de extensii:
Această linie trebuie adăugată în fișierul InitGui.py pentru a adăuga noua extensie de fișier în listă de extensii:

{{Code|code=
{{Code|code=
# Assumes Import_Ext.py is the file that has the code for opening and reading .ext files
# Assumes Import_Ext.py is the file that has the code for opening and reading .ext files
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext")
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext")
}}
}}

Then in the Import_Ext.py file:
Then in the Import_Ext.py file:

{{Code|code=
{{Code|code=
def open(filename):
def open(filename):
Line 57: Line 64:
doc.recompute()
doc.recompute()
}}
}}

Pentru a exporta documentul la unele tipuri de fișiere noi funcționează în același mod, cu excepția faptului că utilizați:
Pentru a exporta documentul la unele tipuri de fișiere noi funcționează în același mod, cu excepția faptului că utilizați:
FreeCAD.addExportType("Your new File Type (*.ext)","Export_Ext")
FreeCAD.addExportType("Your new File Type (*.ext)","Export_Ext")
Line 62: Line 70:
=== Adăugarea unei linii (segment)===
=== Adăugarea unei linii (segment)===
O linie este definită doar de 2 puncte.
O linie este definită doar de 2 puncte.

{{Code|code=
{{Code|code=


Line 76: Line 85:
=== Adăugarea unui poligon ===
=== Adăugarea unui poligon ===
Un poligon este pur și simplu un set de segmente de linie conectate (o polilinie în AutoCAD). Nu este obligatoriu să fie închisă.
Un poligon este pur și simplu un set de segmente de linie conectate (o polilinie în AutoCAD). Nu este obligatoriu să fie închisă.

{{Code|code=
{{Code|code=
import Part,PartGui
import Part,PartGui
Line 93: Line 103:


=== Adăugarea și îndepărtarea unui obiect într-un grup ===
=== Adăugarea și îndepărtarea unui obiect într-un grup ===

{{Code|code=
{{Code|code=
doc=App.activeDocument()
doc=App.activeDocument()
Line 100: Line 111:
grp.removeObject(lin) # removes the lin object from the group grp
grp.removeObject(lin) # removes the lin object from the group grp
}}
}}

Notă: Puteți chiar să adăugați un alt grup la un grup...
Notă: Puteți chiar să adăugați un alt grup la un grup...


=== Adăugarea unei plase ===
=== Adăugarea unei plase ===

{{Code|code=
{{Code|code=
import Mesh
import Mesh
Line 129: Line 142:


=== Adăugarea unui cerc sau a unui arc de cerc ===
=== Adăugarea unui cerc sau a unui arc de cerc ===

{{Code|code=
{{Code|code=
import Part
import Part
Line 141: Line 155:
=== Accesarea și schimbarea reprezentării unui obiect ===
=== Accesarea și schimbarea reprezentării unui obiect ===
Fiecare obiect dintr-un document FreeCAD are un obiect vederii asociat, care stochează toți parametrii care definesc proprietățile obiectului, cum ar fi culoarea, lățimea liniei etc.
Fiecare obiect dintr-un document FreeCAD are un obiect vederii asociat, care stochează toți parametrii care definesc proprietățile obiectului, cum ar fi culoarea, lățimea liniei etc.

{{Code|code=
{{Code|code=
gad=Gui.activeDocument() # access the active document containing all
gad=Gui.activeDocument() # access the active document containing all
Line 153: Line 168:
=== Observarea evenimentelor mouse-ului în vizualizatorul 3D via Python ===
=== Observarea evenimentelor mouse-ului în vizualizatorul 3D via Python ===
Cadrul Inventor permite adăugarea unuia sau mai multor noduri de apel invers(callback) la scena grafică vizualizată. În mod implicit, în FreeCAD, un nod de apel invers este instalat per vizualizator(fereastra de afișare grafică), ceea ce permite adăugarea funcțiilor globale sau statice C ++. Metode de legarea adecvată sunt furnizate de Python, pentru a permite utilizarea acestei tehnici plecând de la codul Python.
Cadrul Inventor permite adăugarea unuia sau mai multor noduri de apel invers(callback) la scena grafică vizualizată. În mod implicit, în FreeCAD, un nod de apel invers este instalat per vizualizator(fereastra de afișare grafică), ceea ce permite adăugarea funcțiilor globale sau statice C ++. Metode de legarea adecvată sunt furnizate de Python, pentru a permite utilizarea acestei tehnici plecând de la codul Python.

{{Code|code=
{{Code|code=
App.newDocument()
App.newDocument()
Line 169: Line 185:
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)
}}
}}

Acum, alegeți undeva în zona din ecran (suprafață de lucru)vizualizatorul 3D și observați mesajele din fereastra de ieșire. Pentru a termina observația, trebuie doar să sunați
Acum, alegeți undeva în zona din ecran (suprafață de lucru)vizualizatorul 3D și observați mesajele din fereastra de ieșire. Pentru a termina observația, trebuie doar să sunați

{{Code|code=
{{Code|code=
v.removeEventCallback("SoMouseButtonEvent",c)
v.removeEventCallback("SoMouseButtonEvent",c)
}}
}}

Următoarele tipuri de evenimente sunt suportate
Următoarele tipuri de evenimente sunt suportate
* SoEvent -- orice tip de evenimente
* SoEvent -- orice tip de evenimente
Line 214: Line 233:
=== Afișați tastele apăsate și evenimentele comenzi ===
=== Afișați tastele apăsate și evenimentele comenzi ===
Această macrocomandă afișează în vizualizarea raportului tastele apăsate și comanda tuturor evenimentelor
Această macrocomandă afișează în vizualizarea raportului tastele apăsate și comanda tuturor evenimentelor

{{Code|code=
{{Code|code=
App.newDocument()
App.newDocument()
Line 232: Line 252:
#v.removeEventCallback("SoEvent",c) # remove ViewObserver
#v.removeEventCallback("SoEvent",c) # remove ViewObserver
}}
}}

=== Manipularea de scene grafice în Python ===
=== Manipularea de scene grafice în Python ===
De asemenea, este posibil să se afișeze și să se schimbe scen în programul Python, cu modulul "pivy" - în combinație cu Coin.
De asemenea, este posibil să se afișeze și să se schimbe scen în programul Python, cu modulul "pivy" - în combinație cu Coin.

{{Code|code=
{{Code|code=
from pivy.coin import * # load the pivy module
from pivy.coin import * # load the pivy module
Line 241: Line 263:
view.fitAll()
view.fitAll()
}}
}}

API-ul Python API-ul de tip pivy este creat folosind instrumentul SWIG. Pe măsură ce folosim în FreeCAD niște noduri scrise automat, pe care nu le puteți crea direct în Python.
API-ul Python API-ul de tip pivy este creat folosind instrumentul SWIG. Pe măsură ce folosim în FreeCAD niște noduri scrise automat, pe care nu le puteți crea direct în Python.
Cu toate acestea, este posibil să creați un nod prin numele său intern. Un exemplu de tipul "SoFCSelection" poate fi creată cu:
Cu toate acestea, este posibil să creați un nod prin numele său intern. Un exemplu de tipul "SoFCSelection" poate fi creată cu:

{{Code|code=
{{Code|code=
type = SoType.fromName("SoFCSelection")
type = SoType.fromName("SoFCSelection")
Line 250: Line 274:
=== Adăugarea și eliminarea obiectelor în / de la scena de grafică ===
=== Adăugarea și eliminarea obiectelor în / de la scena de grafică ===
Adăugarea de noi noduri în scena grafică poate fi făcută astfel. Aveți grijă să adăugați mereu un SoSeparator pentru a conține proprietățile formei geometrice, coordonatele și informațiile despre material ale aceluiași obiect. Următorul exemplu adaugă o linie roșie de la (0,0,0) până la (10,0,0):
Adăugarea de noi noduri în scena grafică poate fi făcută astfel. Aveți grijă să adăugați mereu un SoSeparator pentru a conține proprietățile formei geometrice, coordonatele și informațiile despre material ale aceluiași obiect. Următorul exemplu adaugă o linie roșie de la (0,0,0) până la (10,0,0):

{{Code|code=
{{Code|code=
from pivy import coin
from pivy import coin
Line 266: Line 291:
sg.addChild(no)
sg.addChild(no)
}}
}}

Pentru a șerge pe acesta, este cimplu:
Pentru a șerge pe acesta, este cimplu:
{{Code|code=
{{Code|code=
sg.removeChild(no)
sg.removeChild(no)
}}
}}

===Salvați sceneGraph cu o rotație într-o serie de 36 fișiere în axele X Y Z ===
===Salvați sceneGraph cu o rotație într-o serie de 36 fișiere în axele X Y Z ===


Line 351: Line 378:


Codul python produs de compilatorul Ui python (instrumentul care convertește fișierele qt-designer .ui în codul python), în general, arată astfel (este simplu, puteți, de asemenea, să îl codificați direct în Python):
Codul python produs de compilatorul Ui python (instrumentul care convertește fișierele qt-designer .ui în codul python), în general, arată astfel (este simplu, puteți, de asemenea, să îl codificați direct în Python):

{{Code|code=
{{Code|code=
class myWidget_Ui(object):
class myWidget_Ui(object):
Line 365: Line 393:
self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))
self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))
}}
}}

Apoi, tot ce trebuie să faceți este să creați o referință la fereastra Qt FreeCAD, să-i inserați un widget personalizat în ea și să transferați codul Ui al acestui widget pe care tocmai l-am făcut:
Apoi, tot ce trebuie să faceți este să creați o referință la fereastra Qt FreeCAD, să-i inserați un widget personalizat în ea și să transferați codul Ui al acestui widget pe care tocmai l-am făcut:

{{Code|code=
{{Code|code=
app = QtGui.qApp
app = QtGui.qApp
Line 378: Line 408:
===Adăugarea unui tab în vizualizarea Combo===
===Adăugarea unui tab în vizualizarea Combo===
Următorul cod vă permite să adăugați o filă în FreeCAD ComboView, pe lângă filele "Project" și "Tasks". De asemenea, utilizează modulul uic pentru a încărca un fișier ui direct în acea filă.
Următorul cod vă permite să adăugați o filă în FreeCAD ComboView, pe lângă filele "Project" și "Tasks". De asemenea, utilizează modulul uic pentru a încărca un fișier ui direct în acea filă.

{{Code|code=
{{Code|code=
# create new Tab in ComboView
# create new Tab in ComboView
Line 413: Line 444:


}}
}}

===Activați sau dezactivați o fereastră===
===Activați sau dezactivați o fereastră===

{{Code|code=
{{Code|code=
from PySide import QtGui
from PySide import QtGui
Line 439: Line 472:


===Deschiderea unei pagini web personalizate===
===Deschiderea unei pagini web personalizate===

{{Code|code=
{{Code|code=
import WebGui
import WebGui
Line 445: Line 479:


===Obținerea conținutului HTML al unei pagini Web deschise===
===Obținerea conținutului HTML al unei pagini Web deschise===

{{Code|code=
{{Code|code=
from PySide import QtGui,QtWebKit
from PySide import QtGui,QtWebKit
Line 455: Line 490:


===Recuperați și utilizați coordonatele a 3 puncte sau obiecte selectate===
===Recuperați și utilizați coordonatele a 3 puncte sau obiecte selectate===

{{Code|code=
{{Code|code=
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
Line 482: Line 518:


===Listarea tuturor obeictelor===
===Listarea tuturor obeictelor===

{{Code|code=
{{Code|code=
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
Line 502: Line 539:
#doc.removeObject("Box") # Clears the designated object
#doc.removeObject("Box") # Clears the designated object
}}
}}

===Listează dimensiunile unui obiect, având în vedere numele acestuia===
===Listează dimensiunile unui obiect, având în vedere numele acestuia===

{{Code|code=
{{Code|code=
for edge in FreeCAD.ActiveDocument.MyObjectName.Shape.Edges: # replace "MyObjectName" for list
for edge in FreeCAD.ActiveDocument.MyObjectName.Shape.Edges: # replace "MyObjectName" for list
print edge.Length
print edge.Length
}}
}}



===Funcția rezidentă cu acțiunea clicului mouse-ului===
===Funcția rezidentă cu acțiunea clicului mouse-ului===

Here with '''SelObserver''' on a object select
Here with '''SelObserver''' on a object select

{{Code|code=
{{Code|code=
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
Line 542: Line 582:


Other example with '''ViewObserver''' on a object select or view
Other example with '''ViewObserver''' on a object select or view

{{Code|code=
{{Code|code=
App.newDocument()
App.newDocument()
Line 566: Line 607:


}}
}}

===căutarea și selecția tuturor elementelor de sub cursor===
===căutarea și selecția tuturor elementelor de sub cursor===

{{Code|code=
{{Code|code=
from pivy import coin
from pivy import coin
Line 606: Line 649:


===Lista componentelor unui obiect===
===Lista componentelor unui obiect===

{{Code|code=
{{Code|code=
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
Line 705: Line 749:


===Lista PropertiesList===
===Lista PropertiesList===

{{Code|code=
{{Code|code=
import FreeCADGui
import FreeCADGui
Line 713: Line 758:
Console.PrintMessage("Property: "+ str(p)+ " Value: " + str(o.getPropertyByName(p))+"\r\n")
Console.PrintMessage("Property: "+ str(p)+ " Value: " + str(o.getPropertyByName(p))+"\r\n")
}}
}}

===Adăugarea unei proprietăți "Comentariu"===
===Adăugarea unei proprietăți "Comentariu"===

{{Code|code=
{{Code|code=
import Draft
import Draft
Line 728: Line 775:


Afișajul se face în fereastra "View Report" (View > Views > View report)
Afișajul se face în fereastra "View Report" (View > Views > View report)

{{Code|code=
{{Code|code=

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from __future__ import unicode_literals
Line 744: Line 790:
# Displayed on Report view : Menu View > Views > report view
# Displayed on Report view : Menu View > Views > report view
#
#
# rev:30/08/2014:29/09/2014:17/09/2015
# rev:30/08/2014:29/09/2014:17/09/2015 22/11/2019
from FreeCAD import Base
from FreeCAD import Base
import DraftVecUtils, Draft, Part
import DraftVecUtils, Draft, Part

# search the name of the active document
mydoc = FreeCAD.activeDocument().Name # Name of active Document
mydoc = FreeCAD.activeDocument().Name # Name of active Document
App.Console.PrintMessage("Active docu : "+(mydoc)+"\n")
App.Console.PrintMessage("Active docu : "+(mydoc)+"\n")
##################################################################################
##################################################################################

# search the label of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
object_Label = sel[0].Label # Label of the object (modifiable)
object_Label = sel[0].Label # Label of the object (modifiable)
App.Console.PrintMessage("object_Label : "+(object_Label)+"\n")
App.Console.PrintMessage("object_Label : "+(object_Label)+"\n")
##################################################################################
##################################################################################

#TypeID object FreeCAD selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
App.Console.PrintMessage("sel : "+str(sel[0])+"\n\n") # sel[0] first object selected
App.Console.PrintMessage("sel : "+str(sel[0])+"\n\n") # sel[0] first object selected
##################################################################################
##################################################################################

# search the Name of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
object_Name = sel[0].Name # Name of the object (not modifiable)
object_Name = sel[0].Name # Name of the object (not modifiable)
App.Console.PrintMessage("object_Name : "+str(object_Name)+"\n\n")
App.Console.PrintMessage("object_Name : "+str(object_Name)+"\n\n")
##################################################################################
##################################################################################

# search the Sub Element Name of the sub object selected
try:
try:
SubElement = FreeCADGui.Selection.getSelectionEx() # sub element name with getSelectionEx()
SubElement = FreeCADGui.Selection.getSelectionEx() # sub element name with getSelectionEx()
Line 773: Line 824:
except:
except:
App.Console.PrintMessage("Oups"+"\n\n")
App.Console.PrintMessage("Oups"+"\n\n")
##################################################################################
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
App.Console.PrintMessage("sel : "+str(sel[0])+"\n\n") # sel[0] first object selected
##################################################################################
SubElement = FreeCADGui.Selection.getSelectionEx() # sub element name with getSelectionEx()
App.Console.PrintMessage("SubElement : "+str(SubElement[0])+"\n\n") # name of sub element
##################################################################################
##################################################################################


# give the length of the subObject selected
SubElement = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length # sub element or element name with getSelectionEx()
SubElementLength = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length # sub element or element name with getSelectionEx()
App.Console.PrintMessage("SubElement length: "+str(length)+"\n") # length
App.Console.PrintMessage("SubElement length: "+str(SubElementLength)+"\n")# length
##################################################################################
##################################################################################


# list the edges and the coordinates of the object[0] selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
i = 0
i = 0
Line 794: Line 839:
a = sel[0].Shape.Edges[j[0]].Vertexes[0]
a = sel[0].Shape.Edges[j[0]].Vertexes[0]
App.Console.PrintMessage("X1 : "+str(a.Point.x)+"\n") # coordinate XYZ first point
App.Console.PrintMessage("X1 : "+str(a.Point.x)+"\n") # coordinate XYZ first point
App.Console.PrintMessage("Y1 : "+str(a.Point.y)+"\n")
App.Console.PrintMessage("Y1 : "+str(a.Point.y)+"\n") #
App.Console.PrintMessage("Z1 : "+str(a.Point.z)+"\n")
App.Console.PrintMessage("Z1 : "+str(a.Point.z)+"\n") #
try:
try:
a = sel[0].Shape.Edges[j[0]].Vertexes[1]
a = sel[0].Shape.Edges[j[0]].Vertexes[1]
App.Console.PrintMessage("X2 : "+str(a.Point.x)+"\n") # coordinate XYZ second point
App.Console.PrintMessage("X2 : "+str(a.Point.x)+"\n") # coordinate XYZ second point
App.Console.PrintMessage("Y2 : "+str(a.Point.y)+"\n")
App.Console.PrintMessage("Y2 : "+str(a.Point.y)+"\n") #
App.Console.PrintMessage("Z2 : "+str(a.Point.z)+"\n")
App.Console.PrintMessage("Z2 : "+str(a.Point.z)+"\n") #
except:
except:
App.Console.PrintMessage("Oups"+"\n")
App.Console.PrintMessage("Oups"+"\n")
App.Console.PrintMessage("\n")
App.Console.PrintMessage("\n")
##################################################################################
##################################################################################

# give the sub element name, length, coordinates, BoundBox, BoundBox.Center, Area of the SubObjects selected
try:
try:
SubElement = FreeCADGui.Selection.getSelectionEx() # sub element name with getSelectionEx()
SubElement = FreeCADGui.Selection.getSelectionEx() # sub element name with getSelectionEx()
Line 842: Line 888:
App.Console.PrintMessage("Oups"+"\n\n")
App.Console.PrintMessage("Oups"+"\n\n")
##################################################################################
##################################################################################

# give the area of the object
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
surface = sel[0].Shape.Area # Area object complete
surface = sel[0].Shape.Area # Area object complete
App.Console.PrintMessage("surfaceObjet : "+str(surface)+"\n\n")
App.Console.PrintMessage("surfaceObjet : "+str(surface)+"\n\n")
##################################################################################
##################################################################################

# give the Center Of Mass and coordinates of the object
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
CenterOfMass = sel[0].Shape.CenterOfMass # Center of Mass of the object
CenterOfMass = sel[0].Shape.CenterOfMass # Center of Mass of the object
App.Console.PrintMessage("CenterOfMass : "+str(CenterOfMass)+"\n")
App.Console.PrintMessage("CenterOfMass : "+str(CenterOfMass)+"\n")
App.Console.PrintMessage("CenterOfMassX : "+str(CenterOfMass[0])+"\n") # coordinates [0]=X [1]=Y [2]=Z
App.Console.PrintMessage("CenterOfMassX : "+str(CenterOfMass[0])+"\n") # coordinates [0]=X [1]=Y [2]=Z
App.Console.PrintMessage("CenterOfMassY : "+str(CenterOfMass[1])+"\n")
App.Console.PrintMessage("CenterOfMassY : "+str(CenterOfMass[1])+"\n") # or CenterOfMass.x, CenterOfMass.y, CenterOfMass.z
App.Console.PrintMessage("CenterOfMassZ : "+str(CenterOfMass[2])+"\n\n")
App.Console.PrintMessage("CenterOfMassZ : "+str(CenterOfMass[2])+"\n\n")
##################################################################################
##################################################################################

# list the all faces of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
for j in enumerate(sel[0].Shape.Faces): # List alles faces of the object
for j in enumerate(sel[0].Shape.Faces): # List alles faces of the object
Line 861: Line 910:
App.Console.PrintMessage("\n\n")
App.Console.PrintMessage("\n\n")
##################################################################################
##################################################################################

# give the volume of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
volume_ = sel[0].Shape.Volume # Volume of the object
volume_ = sel[0].Shape.Volume # Volume of the object
Line 867: Line 917:
##################################################################################
##################################################################################
# give the BoundBox of the oject selected all type
objs = FreeCADGui.Selection.getSelection() # select object with getSelection()
objs = FreeCADGui.Selection.getSelection() # select object with getSelection()
if len(objs) >= 1: # serch the object type

if len(objs) >= 1:
if hasattr(objs[0], "Shape"):
if hasattr(objs[0], "Shape"):
s = objs[0].Shape
s = objs[0].Shape
Line 877: Line 927:
s = objs[0].Points
s = objs[0].Points


#sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
boundBox_= s.BoundBox # BoundBox of the object
App.Console.PrintMessage("boundBox_ : "+str(boundBox_)+"\n") #
#boundBox_= sel[0].Shape.BoundBox # BoundBox of the object
boundBox_= s.BoundBox # BoundBox of the object
App.Console.PrintMessage("boundBox_ : "+str(boundBox_)+"\n")
boundBoxLX = boundBox_.XLength # Length x boundBox rectangle
boundBoxLX = boundBox_.XLength # Length x boundBox rectangle
boundBoxLY = boundBox_.YLength # Length y boundBox rectangle
boundBoxLY = boundBox_.YLength # Length y boundBox rectangle
boundBoxLZ = boundBox_.ZLength # Length z boundBox rectangle
boundBoxLZ = boundBox_.ZLength # Length z boundBox rectangle

boundBoxXMin = boundBox_.XMin # coordonate XMin
boundBoxYMin = boundBox_.YMin # coordonate YMin
boundBoxZMin = boundBox_.ZMin # coordonate ZMin
boundBoxXMax = boundBox_.XMax # coordonate XMax
boundBoxYMax = boundBox_.YMax # coordonate YMax
boundBoxZMax = boundBox_.ZMax # coordonate ZMax

boundBoxDiag= boundBox_.DiagonalLength # Diagonal Length boundBox rectangle
boundBoxDiag= boundBox_.DiagonalLength # Diagonal Length boundBox rectangle
boundBoxCenter = boundBox_.Center # BoundBox Center


App.Console.PrintMessage("boundBoxLX : "+str(boundBoxLX)+"\n")
App.Console.PrintMessage("boundBoxLX : "+str(boundBoxLX)+"\n")
App.Console.PrintMessage("boundBoxLY : "+str(boundBoxLY)+"\n")
App.Console.PrintMessage("boundBoxLY : "+str(boundBoxLY)+"\n")
App.Console.PrintMessage("boundBoxLZ : "+str(boundBoxLZ)+"\n")
App.Console.PrintMessage("boundBoxLZ : "+str(boundBoxLZ)+"\n\n")

App.Console.PrintMessage("boundBoxDiag : "+str(boundBoxDiag)+"\n\n")
App.Console.PrintMessage("boundBoxXMin : "+str(boundBoxXMin)+"\n")
App.Console.PrintMessage("boundBoxYMin : "+str(boundBoxYMin)+"\n")
App.Console.PrintMessage("boundBoxZMin : "+str(boundBoxZMin)+"\n")
App.Console.PrintMessage("boundBoxXMax : "+str(boundBoxXMax)+"\n")
App.Console.PrintMessage("boundBoxYMax : "+str(boundBoxYMax)+"\n")
App.Console.PrintMessage("boundBoxZMax : "+str(boundBoxZMax)+"\n\n")

App.Console.PrintMessage("boundBoxDiag : "+str(boundBoxDiag)+"\n")
App.Console.PrintMessage("boundBoxCenter : "+str(boundBoxCenter)+"\n\n")


##################################################################################
##################################################################################

# give the complete placement of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
pl = sel[0].Shape.Placement # Placement Vector XYZ and Yaw-Pitch-Roll
pl = sel[0].Shape.Placement # Placement Vector XYZ and Yaw-Pitch-Roll
App.Console.PrintMessage("Placement : "+str(pl)+"\n")
App.Console.PrintMessage("Placement : "+str(pl)+"\n")
##################################################################################
##################################################################################

# give the placement Base (xyz) of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
pl = sel[0].Shape.Placement.Base # Placement Vector XYZ
pl = sel[0].Shape.Placement.Base # Placement Vector XYZ
Line 904: Line 972:
##################################################################################
##################################################################################
# give the placement Base (xyz) of the object selected
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
oripl_X = sel[0].Placement.Base[0] # decode Placement X
oripl_X = sel[0].Placement.Base[0] # decode Placement X
oripl_Y = sel[0].Placement.Base[1] # decode Placement Y
oripl_Y = sel[0].Placement.Base[1] # decode Placement Y
oripl_Z = sel[0].Placement.Base[2] # decode Placement Z
oripl_Z = sel[0].Placement.Base[2] # decode Placement Z

# same
#oripl_X = sel[0].Placement.Base.x # decode Placement X
#oripl_Y = sel[0].Placement.Base.y # decode Placement Y
#oripl_Z = sel[0].Placement.Base.z # decode Placement Z
App.Console.PrintMessage("oripl_X : "+str(oripl_X)+"\n")
App.Console.PrintMessage("oripl_X : "+str(oripl_X)+"\n")
Line 913: Line 987:
App.Console.PrintMessage("oripl_Z : "+str(oripl_Z)+"\n\n")
App.Console.PrintMessage("oripl_Z : "+str(oripl_Z)+"\n\n")
##################################################################################
##################################################################################

# give the placement rotation of the object selected (x, y, z, angle rotation)
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
rotation = sel[0].Placement.Rotation # decode Placement Rotation
rotation = sel[0].Placement.Rotation # decode Placement Rotation
App.Console.PrintMessage("rotation : "+str(rotation)+"\n\n")
App.Console.PrintMessage("rotation : "+str(rotation)+"\n\n")
##################################################################################
##################################################################################

# give the placement rotation of the object selected (x, y, z, angle rotation)
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation # decode Placement Rotation other method
pl = sel[0].Shape.Placement.Rotation # decode Placement Rotation other method
App.Console.PrintMessage("Placement Rot : "+str(pl)+"\n\n")
App.Console.PrintMessage("Placement Rot : "+str(pl)+"\n\n")
##################################################################################
##################################################################################

# give the rotation of the object selected (angle rotation)
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation.Angle # decode Placement Rotation Angle
pl = sel[0].Shape.Placement.Rotation.Angle # decode Placement Rotation Angle
App.Console.PrintMessage("Placement Rot Angle : "+str(pl)+"\n\n")
App.Console.PrintMessage("Placement Rot Angle : "+str(pl)+"\n\n")
##################################################################################
##################################################################################

# give the rotation.Q of the object selected (angle rotation in Radian) for convert: math.degrees(angleInRadian)
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
Rot = sel[0].Placement.Rotation.Q # Placement Rotation Q
App.Console.PrintMessage("Rot : "+str(Rot)+ "\n")
Rot_0 = sel[0].Placement.Rotation.Q[0] # decode Placement Rotation Q
Rot_0 = sel[0].Placement.Rotation.Q[0] # decode Placement Rotation Q
App.Console.PrintMessage("Rot_0 : "+str(Rot_0)+ " rad , "+str(180 * Rot_0 / 3.1416)+" deg "+"\n")
App.Console.PrintMessage("Rot_0 : "+str(Rot_0)+ " rad , "+str(180 * Rot_0 / 3.1416)+" deg "+"\n") # or math.degrees(angle)
Rot_1 = sel[0].Placement.Rotation.Q[1] # decode Placement Rotation 1
Rot_1 = sel[0].Placement.Rotation.Q[1] # decode Placement Rotation 1
App.Console.PrintMessage("Rot_1 : "+str(Rot_1)+ " rad , "+str(180 * Rot_1 / 3.1416)+" deg "+"\n")
App.Console.PrintMessage("Rot_1 : "+str(Rot_1)+ " rad , "+str(180 * Rot_1 / 3.1416)+" deg "+"\n") # or math.degrees(angle)
Rot_2 = sel[0].Placement.Rotation.Q[2] # decode Placement Rotation 2
Rot_2 = sel[0].Placement.Rotation.Q[2] # decode Placement Rotation 2
App.Console.PrintMessage("Rot_2 : "+str(Rot_2)+ " rad , "+str(180 * Rot_2 / 3.1416)+" deg "+"\n")
App.Console.PrintMessage("Rot_2 : "+str(Rot_2)+ " rad , "+str(180 * Rot_2 / 3.1416)+" deg "+"\n") # or math.degrees(angle)

Rot_3 = sel[0].Placement.Rotation.Q[3] # decode Placement Rotation 3
Rot_3 = sel[0].Placement.Rotation.Q[3] # decode Placement Rotation 3
App.Console.PrintMessage("Rot_3 : "+str(Rot_3)+"\n\n")
App.Console.PrintMessage("Rot_3 : "+str(Rot_3)+"\n\n")

##################################################################################
Rot_Axis = sel[0].Placement.Rotation.Axis # Placement Rotation .Axis
App.Console.PrintMessage("Rot_Axis : "+str(Rot_Axis)+ "\n")
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
Rot_Angle = sel[0].Placement.Rotation.Angle # Placement Rotation .Angle
App.Console.PrintMessage("Rot_Angle : "+str(Rot_Angle)+ "\n\n")
Yaw = sel[0].Shape.Placement.Rotation.toEuler()[0] # decode angle Euler Yaw (Z)
##################################################################################

# give the rotation of the object selected toEuler (angle rotation in degrees)
sel = FreeCADGui.Selection.getSelection() # select object with getSelection()
angle = sel[0].Shape.Placement.Rotation.toEuler() # angle Euler
App.Console.PrintMessage("Angle : "+str(angle)+"\n")
Yaw = sel[0].Shape.Placement.Rotation.toEuler()[0] # decode angle Euler Yaw (Z) lacet (alpha)
App.Console.PrintMessage("Yaw : "+str(Yaw)+"\n")
App.Console.PrintMessage("Yaw : "+str(Yaw)+"\n")
Pitch = sel[0].Shape.Placement.Rotation.toEuler()[1] # decode angle Euler Pitch (Y)
Pitch = sel[0].Shape.Placement.Rotation.toEuler()[1] # decode angle Euler Pitch (Y) tangage (beta)
App.Console.PrintMessage("Pitch : "+str(Pitch)+"\n")
App.Console.PrintMessage("Pitch : "+str(Pitch)+"\n")
Roll = sel[0].Shape.Placement.Rotation.toEuler()[2] # decode angle Euler Roll (X)
Roll = sel[0].Shape.Placement.Rotation.toEuler()[2] # decode angle Euler Roll (X) roulis (gamma)
App.Console.PrintMessage("Roll : "+str(Roll)+"\n\n")
App.Console.PrintMessage("Roll : "+str(Roll)+"\n\n")
##################################################################################
##################################################################################


# find Midpoint of the selected line
import DraftGeomUtils
import Draft, DraftGeomUtils
sel = FreeCADGui.Selection.getSelection()
sel = FreeCADGui.Selection.getSelection()
vecteur = DraftGeomUtils.findMidpoint(sel[0].Shape.Edges[0]) # find Midpoint
vecteur = DraftGeomUtils.findMidpoint(sel[0].Shape.Edges[0]) # find Midpoint
Line 959: Line 1,050:
##################################################################################
##################################################################################
}}
}}

===Căutarea Manuală a unui element având eticheta sa===
===Căutarea Manuală a unui element având eticheta sa===

{{Code|code=
{{Code|code=
# Extract the coordinate X,Y,Z and Angle giving the label
# Extract the coordinate X,Y,Z and Angle giving the label (here "Cylindre")
App.Console.PrintMessage("Base.x : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.x)+"\n")
App.Console.PrintMessage("Base.x : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.x)+"\n")
App.Console.PrintMessage("Base.y : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.y)+"\n")
App.Console.PrintMessage("Base.y : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.y)+"\n")
Line 984: Line 1,077:


Modificați valoarea "numberOfPoints" dacă doriți o precizie mai mare sau mai mică
Modificați valoarea "numberOfPoints" dacă doriți o precizie mai mare sau mai mică

{{Code|code=
{{Code|code=
numberOfPoints = 100 # Decomposition number (or precision you can change)
numberOfPoints = 100 # Decomposition number (or precision you can change)
Line 993: Line 1,087:
print i, " X", p.x, " Y", p.y, " Z", p.z
print i, " X", p.x, " Y", p.y, " Z", p.z
}}
}}

Altă metodă de afișarea a "Int" și "Float"
Altă metodă de afișarea a "Int" și "Float"

{{Code|code=
{{Code|code=
import Part
import Part
Line 1,049: Line 1,145:


}}
}}

===Selectați toate obiectele în document===
===Selectați toate obiectele în document===

{{Code|code=
{{Code|code=
import FreeCAD
import FreeCAD
Line 1,058: Line 1,156:
Gui.Selection.addSelection(obj) # select the object
Gui.Selection.addSelection(obj) # select the object
}}
}}

===Selectarea fațetei unui obiect===
===Selectarea fațetei unui obiect===

{{Code|code=
{{Code|code=
# select one face of the object
# select one face of the object
Line 1,071: Line 1,171:
#Draft.makeFacebinder(s) #
#Draft.makeFacebinder(s) #
}}
}}

===Crearea unui obiect față de poziția Camerei foto===
===Crearea unui obiect față de poziția Camerei foto===

{{Code|code=
{{Code|code=
# create one object of the position to camera with "getCameraOrientation()"
# create one object of the position to camera with "getCameraOrientation()"
Line 1,106: Line 1,208:
print rec.Name
print rec.Name
}}
}}

aici avem același sod simplificat
aici avem același sod simplificat

{{Code|code=
{{Code|code=
import Draft
import Draft
Line 1,118: Line 1,222:


Acest exemplu arată modul de găsire a vectorului normal() a unei suprafețe prin căutarea parametrilor u, v ai unui punct de pe suprafață și folosirea parametrilor u, v pentru a găsi vectorul normal()
Acest exemplu arată modul de găsire a vectorului normal() a unei suprafețe prin căutarea parametrilor u, v ai unui punct de pe suprafață și folosirea parametrilor u, v pentru a găsi vectorul normal()

{{Code|code=
{{Code|code=
def normal(self):
def normal(self):
Line 1,135: Line 1,240:
Part.show(line)
Part.show(line)
}}
}}

===Citirea și Scrierea unei Expresii===
===Citirea și Scrierea unei Expresii===

{{Code|code=
{{Code|code=
import Draft
import Draft
Line 1,159: Line 1,266:


}}
}}



===Get the normal vector of a surface from a STL file===
===Get the normal vector of a surface from a STL file===
Line 1,182: Line 1,288:
}}
}}


<div class="mw-translate-fuzzy">
{{docnav/ro|[[Embedding FreeCAD/ro|Embedding FreeCAD]]|[[Line drawing function/ro|Line drawing function]]}}
{{docnav/ro|[[Embedding FreeCAD/ro|Embedding FreeCAD]]|[[Line drawing function/ro|Line drawing function]]}}
</div>


{{Userdocnavi}}
{{Userdocnavi}}

Revision as of 13:41, 22 November 2019

Tutorial
Topic
Python
Level
Beginner
Time to complete
Authors
FreeCAD version
Example files
See also
None

Această pagină conține exemple, extrase, fragmente de cod Python de la FreeCAD, colectate din experiențele utilizatorilor și discuțiile pe forumuri. Citește și folosește-o ca un început pentru scripturile tale ...

Un fișier tipic InitGui.py

Fiecare modul trebuie să conțină, pe lângă fișierul modulului principal, un fișier InitGui.py, responsabil pentru înserarea modulului GUI principal. Acesta este un exemplu simplu.

class ScriptWorkbench (Workbench): 
    MenuText = "Scripts"
    def Initialize(self):
        import Scripts # assuming Scripts.py is your module
        list = ["Script_Cmd"] # That list must contain command names, that can be defined in Scripts.py
        self.appendToolbar("My Scripts",list) 
        
Gui.addWorkbench(ScriptWorkbench())

Un fișier modul tipic

Acesta este un exemplu al unui fișier modul principal, care conține tot ceea ce face modul dvs. Acesta este fișierul Scripts.py invocat în exemplul anterior. Puteți să aveți toate comenzile personalizate aici.

import FreeCAD, FreeCADGui 
 
class ScriptCmd: 
   def Activated(self): 
       # Here your write what your ScriptCmd does...
       FreeCAD.Console.PrintMessage('Hello, World!')
   def GetResources(self): 
       return {'Pixmap' : 'path_to_an_icon/myicon.png', 'MenuText': 'Short text', 'ToolTip': 'More detailed text'} 
       
FreeCADGui.addCommand('Script_Cmd', ScriptCmd())

Importul unui nou tip de fișier

Efectuarea unui import pentru un nou tip de fișier în FreeCAD este ușoară. FreeCAD nu ia în considerare că importați orice date într-un document deschis, pentru că nu puteți deschide direct un nou tip de fișier. Deci, ceea ce trebuie să faceți este să adăugați noua extensie de fișiere în lista de extensii cunoscute a FreeCAD și să scrieți codul care va citi fișierul și va crea obiectele FreeCAD pe care le doriți:

Această linie trebuie adăugată în fișierul InitGui.py pentru a adăuga noua extensie de fișier în listă de extensii:

# Assumes Import_Ext.py is the file that has the code for opening and reading .ext files
FreeCAD.addImportType("Your new File Type (*.ext)","Import_Ext")

Then in the Import_Ext.py file:

def open(filename): 
   doc=App.newDocument()
   # here you do all what is needed with filename, read, classify data, create corresponding FreeCAD objects
   doc.recompute()

Pentru a exporta documentul la unele tipuri de fișiere noi funcționează în același mod, cu excepția faptului că utilizați:

FreeCAD.addExportType("Your new File Type (*.ext)","Export_Ext") 

Adăugarea unei linii (segment)

O linie este definită doar de 2 puncte.

import Part,PartGui 
doc=App.activeDocument() 
# add a line element to the document and set its points 
l=Part.LineSegment()
l.StartPoint=(0.0,0.0,0.0)
l.EndPoint=(1.0,1.0,1.0)
doc.addObject("Part::Feature","Line").Shape=l.toShape() 
doc.recompute()

Adăugarea unui poligon

Un poligon este pur și simplu un set de segmente de linie conectate (o polilinie în AutoCAD). Nu este obligatoriu să fie închisă.

import Part,PartGui 
doc=App.activeDocument()
n=list() 
# create a 3D vector, set its coordinates and add it to the list 
v=App.Vector(0,0,0) 
n.append(v) 
v=App.Vector(10,0,0) 
n.append(v) 
#... repeat for all nodes 
# Create a polygon object and set its nodes 
p=doc.addObject("Part::Polygon","Polygon") 
p.Nodes=n 
doc.recompute()

Adăugarea și îndepărtarea unui obiect într-un grup

doc=App.activeDocument() 
grp=doc.addObject("App::DocumentObjectGroup", "Group") 
lin=doc.addObject("Part::Feature", "Line")
grp.addObject(lin) # adds the lin object to the group grp
grp.removeObject(lin) # removes the lin object from the group grp

Notă: Puteți chiar să adăugați un alt grup la un grup...

Adăugarea unei plase

import Mesh
doc=App.activeDocument()
# create a new empty mesh
m = Mesh.Mesh()
# build up box out of 12 facets
m.addFacet(0.0,0.0,0.0, 0.0,0.0,1.0, 0.0,1.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,1.0, 0.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,0.0, 1.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 1.0,0.0,1.0, 0.0,0.0,1.0)
m.addFacet(0.0,0.0,0.0, 0.0,1.0,0.0, 1.0,1.0,0.0)
m.addFacet(0.0,0.0,0.0, 1.0,1.0,0.0, 1.0,0.0,0.0)
m.addFacet(0.0,1.0,0.0, 0.0,1.0,1.0, 1.0,1.0,1.0)
m.addFacet(0.0,1.0,0.0, 1.0,1.0,1.0, 1.0,1.0,0.0)
m.addFacet(0.0,1.0,1.0, 0.0,0.0,1.0, 1.0,0.0,1.0)
m.addFacet(0.0,1.0,1.0, 1.0,0.0,1.0, 1.0,1.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,1.0,1.0, 1.0,0.0,1.0)
m.addFacet(1.0,1.0,0.0, 1.0,0.0,1.0, 1.0,0.0,0.0)
# scale to a edge langth of 100
m.scale(100.0)
# add the mesh to the active document
me=doc.addObject("Mesh::Feature","Cube")
me.Mesh=m

Adăugarea unui cerc sau a unui arc de cerc

import Part
doc = App.activeDocument()
c = Part.Circle() 
c.Radius=10.0  
f = doc.addObject("Part::Feature", "Circle") # create a document with a circle feature 
f.Shape = c.toShape() # Assign the circle shape to the shape property 
doc.recompute()

Accesarea și schimbarea reprezentării unui obiect

Fiecare obiect dintr-un document FreeCAD are un obiect vederii asociat, care stochează toți parametrii care definesc proprietățile obiectului, cum ar fi culoarea, lățimea liniei etc.

gad=Gui.activeDocument()   # access the active document containing all 
                          # view representations of the features in the
                          # corresponding App document 

v=gad.getObject("Cube")    # access the view representation to the Mesh feature 'Cube' 
v.ShapeColor               # prints the color to the console 
v.ShapeColor=(1.0,1.0,1.0) # sets the shape color to white

Observarea evenimentelor mouse-ului în vizualizatorul 3D via Python

Cadrul Inventor permite adăugarea unuia sau mai multor noduri de apel invers(callback) la scena grafică vizualizată. În mod implicit, în FreeCAD, un nod de apel invers este instalat per vizualizator(fereastra de afișare grafică), ceea ce permite adăugarea funcțiilor globale sau statice C ++. Metode de legarea adecvată sunt furnizate de Python, pentru a permite utilizarea acestei tehnici plecând de la codul Python.

App.newDocument()
v=Gui.activeDocument().activeView()
 
#This class logs any mouse button events. As the registered callback function fires twice for 'down' and
#'up' events we need a boolean flag to handle this.
class ViewObserver:
   def logPosition(self, info):
       down = (info["State"] == "DOWN")
       pos = info["Position"]
       if (down):
           FreeCAD.Console.PrintMessage("Clicked on position: ("+str(pos[0])+", "+str(pos[1])+")\n")
       
o = ViewObserver()
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

Acum, alegeți undeva în zona din ecran (suprafață de lucru)vizualizatorul 3D și observați mesajele din fereastra de ieșire. Pentru a termina observația, trebuie doar să sunați

v.removeEventCallback("SoMouseButtonEvent",c)

Următoarele tipuri de evenimente sunt suportate

  • SoEvent -- orice tip de evenimente
  • SoButtonEvent -- toate evenimentele butoanele /rotiță mouse
  • SoLocation2Event -- evenimente mișcări 2D (mișcările normale ale mouse-lui)
  • SoMotion3Event -- evenimentele mișcări 3D (normale pentru spaceball)
  • SoKeyboardEvent -- evenimente de tastare a tastelor cu săgeți sus/jos
  • SoMouseButtonEvent -- evenimentul de tastare și eliberare a butoanelor mouse
  • SoSpaceballButtonEvent -- evenimentul de tastare și eliberare a butoanelor spaceball

Funcțiile Python care pot fi înregistrate cu addEventCallback() așteaptă definirea unei bilbioteci. Funcție de modul în care evenimentul survine , biblioteca poate dispunde diferite taste. Este alocată câte o tastă pentru fiecare eveniment:

În funcție de eveniment, dicționarul poate conține diferite taste alocate.

Pentru toate evenimentele are tastele:

  • Type -- the name of the event type i.e. SoMouseEvent, SoLocation2Event, ...
  • Time -- timpul curent ca șir de caractere
  • Position -- tuple de două numere întregi, reprezentând poziția mouse-ului
  • ShiftDown -- un indicator boolean, adevărat dacă Shift a fost apăsat altfel fals
  • CtrlDown -- un indicator boolean, adevărat dacă Ctrl a fost apăsat altfel fals
  • AltDown -- un indicator boolean, adevărat dacă Alt a fost apăsat altfel fals

Pentru toate evenimentele gen apăsare de buton, adică evenimente de tip tastatură, mouse sau spațiu

  • State -- Un șir text dacă butonul este 'UP' , 'DOWN' dacă butonul este jos, sau pentru orice alt caz 'UNKNOWN'

pentru evenimentele tip apăsare tastatură:

  • Key -- caracterul tastei apăsate

pentru evenimente buton de mouse

  • Button -- Butonul apăsat, poate lua valorile BUTTON1, ..., BUTTON5 sau oricare dintre ele

pentru evenimente tip spaceball:

  • Button -- butonul apăsat poate lua valorile, BUTTON1, ..., BUTTON7 sau oricare dintre ele ANY

Și în sfârșit, evenimentele legate de deplasare:

  • Translation -- o tuplă de trei numere cu virgulă float()
  • Rotation -- un quaternion pentru rotație, adică o tuplă de patru valori exprimate cu virgulă float()

Afișați tastele apăsate și evenimentele comenzi

Această macrocomandă afișează în vizualizarea raportului tastele apăsate și comanda tuturor evenimentelor

App.newDocument()
v=Gui.activeDocument().activeView()
class ViewObserver:
   def logPosition(self, info):
       try:
           down = (info["Key"])
           FreeCAD.Console.PrintMessage(str(down)+"\n") # here the character pressed
           FreeCAD.Console.PrintMessage(str(info)+"\n") # list all events command
           FreeCAD.Console.PrintMessage("_______________________________________"+"\n")
       except Exception:
           None
 
o = ViewObserver()
c = v.addEventCallback("SoEvent",o.logPosition)

#v.removeEventCallback("SoEvent",c) # remove ViewObserver

Manipularea de scene grafice în Python

De asemenea, este posibil să se afișeze și să se schimbe scen în programul Python, cu modulul "pivy" - în combinație cu Coin.

from pivy.coin import *                # load the pivy module
view = Gui.ActiveDocument.ActiveView   # get the active viewer
root = view.getSceneGraph()            # the root is an SoSeparator node
root.addChild(SoCube())
view.fitAll()

API-ul Python API-ul de tip pivy este creat folosind instrumentul SWIG. Pe măsură ce folosim în FreeCAD niște noduri scrise automat, pe care nu le puteți crea direct în Python. Cu toate acestea, este posibil să creați un nod prin numele său intern. Un exemplu de tipul "SoFCSelection" poate fi creată cu:

type = SoType.fromName("SoFCSelection")
node = type.createInstance()

Adăugarea și eliminarea obiectelor în / de la scena de grafică

Adăugarea de noi noduri în scena grafică poate fi făcută astfel. Aveți grijă să adăugați mereu un SoSeparator pentru a conține proprietățile formei geometrice, coordonatele și informațiile despre material ale aceluiași obiect. Următorul exemplu adaugă o linie roșie de la (0,0,0) până la (10,0,0):

from pivy import coin
sg = Gui.ActiveDocument.ActiveView.getSceneGraph()
co = coin.SoCoordinate3()
pts = [[0,0,0],[10,0,0]]
co.point.setValues(0,len(pts),pts)
ma = coin.SoBaseColor()
ma.rgb = (1,0,0)
li = coin.SoLineSet()
li.numVertices.setValue(2)
no = coin.SoSeparator()
no.addChild(co)
no.addChild(ma)
no.addChild(li)
sg.addChild(no)

Pentru a șerge pe acesta, este cimplu:

sg.removeChild(no)

Salvați sceneGraph cu o rotație într-o serie de 36 fișiere în axele X Y Z

import math
import time
from FreeCAD import Base
from pivy import coin

size=(1000,1000)
dirname = "C:/Temp/animation/"
steps=36
angle=2*math.pi/steps

matX=Base.Matrix()
matX.rotateX(angle)
stepsX=Base.Placement(matX).Rotation

matY=Base.Matrix()
matY.rotateY(angle)
stepsY=Base.Placement(matY).Rotation

matZ=Base.Matrix()
matZ.rotateZ(angle)
stepsZ=Base.Placement(matZ).Rotation

view=Gui.ActiveDocument.ActiveView
cam=view.getCameraNode()
rotCamera=Base.Rotation(*cam.orientation.getValue().getValue())

# this sets the lookat point to the center of circumsphere of the global bounding box
view.fitAll()

# the camera's position, i.e. the user's eye point
position=Base.Vector(*cam.position.getValue().getValue())
distance=cam.focalDistance.getValue()

# view direction
vec=rotCamera.multVec(Base.Vector(0,0,-1))

# this is the point on the screen the camera looks at
# when rotating the camera we should make this point fix
lookat=position+vec*distance

# around x axis
for i in range(steps):
    rotCamera=stepsX.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"x-%d.png" % i,*size)

# around y axis
for i in range(steps):
    rotCamera=stepsY.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"y-%d.png" % i,*size)

# around z axis
for i in range(steps):
    rotCamera=stepsZ.multiply(rotCamera)
    cam.orientation.setValue(*rotCamera.Q)
    vec=rotCamera.multVec(Base.Vector(0,0,-1))
    pos=lookat-vec*distance
    cam.position.setValue(pos.x,pos.y,pos.z)
    Gui.updateGui()
    time.sleep(0.3)
    view.saveImage(dirname+"z-%d.png" % i,*size)

Adăugarea de widget-uri personalizate la interfață

Puteți crea widget-uri personalizate cu designerul Qt, le puteți transforma într-un script python și apoi le puteți încărca în interfața FreeCAD cu PySide.

Codul python produs de compilatorul Ui python (instrumentul care convertește fișierele qt-designer .ui în codul python), în general, arată astfel (este simplu, puteți, de asemenea, să îl codificați direct în Python):

class myWidget_Ui(object):
    def setupUi(self, myWidget):
        myWidget.setObjectName("my Nice New Widget")
        myWidget.resize(QtCore.QSize(QtCore.QRect(0,0,300,100).size()).expandedTo(myWidget.minimumSizeHint())) # sets size of the widget
 
        self.label = QtGui.QLabel(myWidget) # creates a label
        self.label.setGeometry(QtCore.QRect(50,50,200,24)) # sets its size
        self.label.setObjectName("label") # sets its name, so it can be found by name

    def retranslateUi(self, draftToolbar): # built-in QT function that manages translations of widgets
        myWidget.setWindowTitle(QtGui.QApplication.translate("myWidget", "My Widget", None, QtGui.QApplication.UnicodeUTF8))
        self.label.setText(QtGui.QApplication.translate("myWidget", "Welcome to my new widget!", None, QtGui.QApplication.UnicodeUTF8))

Apoi, tot ce trebuie să faceți este să creați o referință la fereastra Qt FreeCAD, să-i inserați un widget personalizat în ea și să transferați codul Ui al acestui widget pe care tocmai l-am făcut:

app = QtGui.qApp
FCmw = app.activeWindow() # the active qt window, = the freecad window since we are inside it
# FCmw = FreeCADGui.getMainWindow() # use this line if the 'addDockWidget' error is declared
myNewFreeCADWidget = QtGui.QDockWidget() # create a new dckwidget
myNewFreeCADWidget.ui = myWidget_Ui() # load the Ui script
myNewFreeCADWidget.ui.setupUi(myNewFreeCADWidget) # setup the ui
FCmw.addDockWidget(QtCore.Qt.RightDockWidgetArea,myNewFreeCADWidget) # add the widget to the main window

Adăugarea unui tab în vizualizarea Combo

Următorul cod vă permite să adăugați o filă în FreeCAD ComboView, pe lângă filele "Project" și "Tasks". De asemenea, utilizează modulul uic pentru a încărca un fișier ui direct în acea filă.

# create new Tab in ComboView
from PySide import QtGui,QtCore
#from PySide import uic

def getMainWindow():
   "returns the main window"
   # using QtGui.qApp.activeWindow() isn't very reliable because if another
   # widget than the mainwindow is active (e.g. a dialog) the wrong widget is
   # returned
   toplevel = QtGui.qApp.topLevelWidgets()
   for i in toplevel:
       if i.metaObject().className() == "Gui::MainWindow":
           return i
   raise Exception("No main window found")

def getComboView(mw):
   dw=mw.findChildren(QtGui.QDockWidget)
   for i in dw:
       if str(i.objectName()) == "Combo View":
           return i.findChild(QtGui.QTabWidget)
       elif str(i.objectName()) == "Python Console":
           return i.findChild(QtGui.QTabWidget)
   raise Exception ("No tab widget found")

mw = getMainWindow()
tab = getComboView(getMainWindow())
tab2=QtGui.QDialog()
tab.addTab(tab2,"A Special Tab")

#uic.loadUi("/myTaskPanelforTabs.ui",tab2)
tab2.show()
#tab.removeTab(2)

Activați sau dezactivați o fereastră

from PySide import QtGui
mw=FreeCADGui.getMainWindow()
dws=mw.findChildren(QtGui.QDockWidget)

# objectName may be :
# "Report view"
# "Tree view"
# "Property view"
# "Selection view"
# "Combo View"
# "Python console"
# "draftToolbar"

for i in dws:
  if i.objectName() == "Report view":
    dw=i
    break

va=dw.toggleViewAction()
va.setChecked(True)        # True or False
dw.setVisible(True)        # True or False

Deschiderea unei pagini web personalizate

import WebGui
WebGui.openBrowser("http://www.example.com")

Obținerea conținutului HTML al unei pagini Web deschise

from PySide import QtGui,QtWebKit
a = QtGui.qApp
mw = a.activeWindow()
v = mw.findChild(QtWebKit.QWebFrame)
html = unicode(v.toHtml())
print html

Recuperați și utilizați coordonatele a 3 puncte sau obiecte selectate

# -*- coding: utf-8 -*-
# the line above to put the accentuated in the remarks
# If this line is missing, an error will be returned
# extract and use the coordinates of 3 objects selected
import Part, FreeCAD, math, PartGui, FreeCADGui
from FreeCAD import Base, Console
sel = FreeCADGui.Selection.getSelection() # " sel " contains the items selected
if len(sel)!=3 :
  # If there are no 3 objects selected, an error is displayed in the report view
  # The \r and \n at the end of line mean return and the newline CR + LF.
  Console.PrintError("Select 3 points exactly\r\n")
else :
  points=[]
  for obj in sel:
    points.append(obj.Shape.BoundBox.Center)

  for pt in points:
    # display of the coordinates in the report view
    Console.PrintMessage(str(pt.x)+"\r\n")
    Console.PrintMessage(str(pt.y)+"\r\n")
    Console.PrintMessage(str(pt.z)+"\r\n")

  Console.PrintMessage(str(pt[1]) + "\r\n")

Listarea tuturor obeictelor

# -*- coding: utf-8 -*-
import FreeCAD,Draft
# List all objects of the document
doc = FreeCAD.ActiveDocument
objs = FreeCAD.ActiveDocument.Objects
#App.Console.PrintMessage(str(objs) + "\n")
#App.Console.PrintMessage(str(len(FreeCAD.ActiveDocument.Objects)) + " Objects"  + "\n")

for obj in objs:
    a = obj.Name                                             # list the Name  of the object  (not modifiable)
    b = obj.Label                                            # list the Label of the object  (modifiable)
    try:
        c = obj.LabelText                                    # list the LabeText of the text (modifiable)
        App.Console.PrintMessage(str(a) +" "+ str(b) +" "+ str(c) + "\n") # Displays the Name the Label and the text
    except:
        App.Console.PrintMessage(str(a) +" "+ str(b) + "\n") # Displays the Name and the Label of the object

#doc.removeObject("Box") # Clears the designated object

Listează dimensiunile unui obiect, având în vedere numele acestuia

for edge in FreeCAD.ActiveDocument.MyObjectName.Shape.Edges: # replace "MyObjectName" for list
    print edge.Length

Funcția rezidentă cu acțiunea clicului mouse-ului

Here with SelObserver on a object select

# -*- coding: utf-8 -*-
# causes an action to the mouse click on an object
# This function remains resident (in memory) with the function "addObserver(s)"
# "removeObserver(s) # Uninstalls the resident function
class SelObserver:
    def setPreselection(self,doc,obj,sub):                # Preselection object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name

    def addSelection(self,doc,obj,sub,pnt):               # Selection object
        App.Console.PrintMessage("addSelection"+ "\n")
        App.Console.PrintMessage(str(doc)+ "\n")          # Name of the document
        App.Console.PrintMessage(str(obj)+ "\n")          # Name of the object
        App.Console.PrintMessage(str(sub)+ "\n")          # The part of the object name
        App.Console.PrintMessage(str(pnt)+ "\n")          # Coordinates of the object
        App.Console.PrintMessage("______"+ "\n")

    def removeSelection(self,doc,obj,sub):                # Delete the selected object
        App.Console.PrintMessage("removeSelection"+ "\n")

    def setSelection(self,doc):                           # Selection in ComboView
        App.Console.PrintMessage("setSelection"+ "\n")

    def clearSelection(self,doc):                         # If click on the screen, clear the selection
        App.Console.PrintMessage("clearSelection"+ "\n")  # If click on another object, clear the previous object
s =SelObserver()
FreeCADGui.Selection.addObserver(s)                       # install the function mode resident
#FreeCADGui.Selection.removeObserver(s)                   # Uninstall the resident function

Other example with ViewObserver on a object select or view

App.newDocument()
v=Gui.activeDocument().activeView()
 
#This class logs any mouse button events. As the registered callback function fires twice for 'down' and
#'up' events we need a boolean flag to handle this.
class ViewObserver:
   def __init__(self, view):
       self.view = view
   
   def logPosition(self, info):
       down = (info["State"] == "DOWN")
       pos = info["Position"]
       if (down):
           FreeCAD.Console.PrintMessage("Clicked on position: ("+str(pos[0])+", "+str(pos[1])+")\n")
           pnt = self.view.getPoint(pos)
           FreeCAD.Console.PrintMessage("World coordinates: " + str(pnt) + "\n")
           info = self.view.getObjectInfo(pos)
           FreeCAD.Console.PrintMessage("Object info: " + str(info) + "\n")

o = ViewObserver(v)
c = v.addEventCallback("SoMouseButtonEvent",o.logPosition)

căutarea și selecția tuturor elementelor de sub cursor

from pivy import coin
import FreeCADGui

def mouse_over_cb( event_callback):
    event = event_callback.getEvent()
    pos = event.getPosition().getValue()
    listObjects = FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo((int(pos[0]),int(pos[1])))
    obj = []
    if listObjects:
        FreeCAD.Console.PrintMessage("\n *** Objects under mouse pointer ***")
        for o in listObjects:
            label = str(o["Object"])
            if not label in obj:
                obj.append(label)
        FreeCAD.Console.PrintMessage("\n"+str(obj))


view = FreeCADGui.ActiveDocument.ActiveView

mouse_over = view.addEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over_cb )

# to remove Callback :
#view.removeEventCallbackPivy( coin.SoLocation2Event.getClassTypeId(), mouse_over)

####
#The easy way is probably to use FreeCAD's selection.
#FreeCADGui.ActiveDocument.ActiveView.getObjectsInfo(mouse_coords)

####
#you get that kind of result :
#'Document': 'Unnamed', 'Object': 'Box', 'Component': 'Face2', 'y': 8.604081153869629, 'x': 21.0, 'z': 8.553047180175781

####
#You can use this data to add your element to FreeCAD's selection :
#FreeCADGui.Selection.addSelection(FreeCAD.ActiveDocument.Box,'Face2',21.0,8.604081153869629,8.553047180175781)

Lista componentelor unui obiect

# -*- coding: utf-8 -*-
# This function list the components of an object
# and extract this object its XYZ coordinates,
# its edges and their lengths center of mass and coordinates
# its faces and their center of mass
# its faces and their surfaces and coordinates
# 8/05/2014

import Draft,Part
def detail():
    sel = FreeCADGui.Selection.getSelection()   # Select an object
    if len(sel) != 0:                           # If there is a selection then
        Vertx=[]
        Edges=[]
        Faces=[]
        compt_V=0
        compt_E=0
        compt_F=0
        pas    =0
        perimetre = 0.0   
        EdgesLong = []

        # Displays the "Name" and the "Label" of the selection
        App.Console.PrintMessage("Selection > " + str(sel[0].Name) + "  " + str(sel[0].Label) +"\n"+"\n")

        for j in enumerate(sel[0].Shape.Edges):                                     # Search the "Edges" and their lengths
            compt_E+=1
            Edges.append("Edge%d" % (j[0]+1))
            EdgesLong.append(str(sel[0].Shape.Edges[compt_E-1].Length))
            perimetre += (sel[0].Shape.Edges[compt_E-1].Length)                     # calculates the perimeter

            # Displays the "Edge" and its length
            App.Console.PrintMessage("Edge"+str(compt_E)+" Length > "+str(sel[0].Shape.Edges[compt_E-1].Length)+"\n")

            # Displays the "Edge" and its center mass
            App.Console.PrintMessage("Edge"+str(compt_E)+" Center > "+str(sel[0].Shape.Edges[compt_E-1].CenterOfMass)+"\n")

            num = sel[0].Shape.Edges[compt_E-1].Vertexes[0]
            Vertx.append("X1: "+str(num.Point.x))
            Vertx.append("Y1: "+str(num.Point.y))
            Vertx.append("Z1: "+str(num.Point.z))
            # Displays the coordinates 1
            App.Console.PrintMessage("X1: "+str(num.Point[0])+" Y1: "+str(num.Point[1])+" Z1: "+str(num.Point[2])+"\n")

            try:
                num = sel[0].Shape.Edges[compt_E-1].Vertexes[1]
                Vertx.append("X2: "+str(num.Point.x))
                Vertx.append("Y2: "+str(num.Point.y))
                Vertx.append("Z2: "+str(num.Point.z))
            except:
                Vertx.append("-")
                Vertx.append("-")
                Vertx.append("-")
            # Displays the coordinates 2
            App.Console.PrintMessage("X2: "+str(num.Point[0])+" Y2: "+str(num.Point[1])+" Z2: "+str(num.Point[2])+"\n")

            App.Console.PrintMessage("\n")
        App.Console.PrintMessage("Perimeter of the form  : "+str(perimetre)+"\n") 

        App.Console.PrintMessage("\n")
        FacesSurf = []
        for j in enumerate(sel[0].Shape.Faces):                                      # Search the "Faces" and their surface
            compt_F+=1
            Faces.append("Face%d" % (j[0]+1))
            FacesSurf.append(str(sel[0].Shape.Faces[compt_F-1].Area))

            # Displays 'Face' and its surface
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Surface "+str(sel[0].Shape.Faces[compt_F-1].Area)+"\n")

            # Displays 'Face' and its CenterOfMass
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Center  "+str(sel[0].Shape.Faces[compt_F-1].CenterOfMass)+"\n")

            # Displays 'Face' and its Coordinates
            FacesCoor = []
            fco = 0
            for f0 in sel[0].Shape.Faces[compt_F-1].Vertexes:                        # Search the Vertexes of the face
                fco += 1
                FacesCoor.append("X"+str(fco)+": "+str(f0.Point.x))
                FacesCoor.append("Y"+str(fco)+": "+str(f0.Point.y))
                FacesCoor.append("Z"+str(fco)+": "+str(f0.Point.z))

            # Displays 'Face' and its Coordinates
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Coordinate"+str(FacesCoor)+"\n")

            # Displays 'Face' and its Volume
            App.Console.PrintMessage("Face"+str(compt_F)+" >  Volume  "+str(sel[0].Shape.Faces[compt_F-1].Volume)+"\n")
            App.Console.PrintMessage("\n")

        # Displays the total surface of the form
        App.Console.PrintMessage("Surface of the form    : "+str(sel[0].Shape.Area)+"\n")

        # Displays the total Volume of the form
        App.Console.PrintMessage("Volume  of the form    : "+str(sel[0].Shape.Volume)+"\n")

detail()

Lista PropertiesList

import FreeCADGui
from FreeCAD import Console
o = App.ActiveDocument.ActiveObject
op = o.PropertiesList
for p in op:
    Console.PrintMessage("Property: "+ str(p)+ " Value: " + str(o.getPropertyByName(p))+"\r\n")

Adăugarea unei proprietăți "Comentariu"

import Draft
obj = FreeCADGui.Selection.getSelection()[0]
obj.addProperty("App::PropertyString","GComment","Draft","Font name").GComment = "Comment here"
App.activeDocument().recompute()

Căutarea și extracția datelor

Example de cautare și decodare a informației despre un obiect.

Fiecare secțiune este independentă și este separată de diezi "############" poate fi copiată direct în consola Python sau într-o macrocomandă sau poate folosi această macrocomandă. Descrierea macrocomenzii în comentariu.

Afișajul se face în fereastra "View Report" (View > Views > View report)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
 
# Exemples de recherche et de decodage d'informations sur un objet
# Chaque section peut etre copiee directement dans la console Python ou dans une macro ou utilisez la macro tel quel
# Certaines commandes se repetent seul l'approche est differente
# L'affichage se fait dans la Vue rapport : Menu Affichage > Vues > Vue rapport
#
# Examples of research and decoding information on an object
# Each section can be copied directly into the Python console, or in a macro or uses this macro
# Certain commands as repeat alone approach is different
# Displayed on Report view : Menu View > Views > report view
#
# rev:30/08/2014:29/09/2014:17/09/2015 22/11/2019
 
from FreeCAD import Base
import DraftVecUtils, Draft, Part

# search the name of the active document 
mydoc = FreeCAD.activeDocument().Name                                     # Name of active Document
App.Console.PrintMessage("Active docu    : "+(mydoc)+"\n")
##################################################################################

# search the label of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Label = sel[0].Label                                               # Label of the object (modifiable)
App.Console.PrintMessage("object_Label   : "+(object_Label)+"\n")
##################################################################################

#TypeID object FreeCAD selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
App.Console.PrintMessage("sel            : "+str(sel[0])+"\n\n")          # sel[0] first object selected
##################################################################################

# search the Name of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
object_Name  = sel[0].Name                                                # Name of the object (not modifiable)
App.Console.PrintMessage("object_Name    : "+str(object_Name)+"\n\n")
##################################################################################

# search the Sub Element Name of the sub object selected
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                    # sub element name with getSelectionEx()
    element_ = SubElement[0].SubElementNames[0]                           # name of 1 element selected
    App.Console.PrintMessage("elementSelec   : "+str(element_)+"\n\n")            
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################

# give the length of the subObject selected
SubElementLength = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length # sub element or element name with getSelectionEx()
App.Console.PrintMessage("SubElement length: "+str(SubElementLength)+"\n")# length
##################################################################################

# list the edges and the coordinates of the object[0] selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
i = 0
for j in enumerate(sel[0].Shape.Edges):                                   # list all Edges
    i += 1
    App.Console.PrintMessage("Edges n : "+str(i)+"\n")
    a = sel[0].Shape.Edges[j[0]].Vertexes[0]
    App.Console.PrintMessage("X1             : "+str(a.Point.x)+"\n")     # coordinate XYZ first point
    App.Console.PrintMessage("Y1             : "+str(a.Point.y)+"\n")     #
    App.Console.PrintMessage("Z1             : "+str(a.Point.z)+"\n")     #
    try:
        a = sel[0].Shape.Edges[j[0]].Vertexes[1]
        App.Console.PrintMessage("X2             : "+str(a.Point.x)+"\n") # coordinate XYZ second point
        App.Console.PrintMessage("Y2             : "+str(a.Point.y)+"\n") #
        App.Console.PrintMessage("Z2             : "+str(a.Point.z)+"\n") #
    except:
        App.Console.PrintMessage("Oups"+"\n")    
App.Console.PrintMessage("\n")    
##################################################################################

# give the sub element name, length, coordinates, BoundBox, BoundBox.Center, Area of the SubObjects selected
try:
    SubElement = FreeCADGui.Selection.getSelectionEx()                                        # sub element name with getSelectionEx()
    subElementName = Gui.Selection.getSelectionEx()[0].SubElementNames[0]                     # sub element name with getSelectionEx()
    App.Console.PrintMessage("subElementName : "+str(subElementName)+"\n")
    
    subObjectLength = Gui.Selection.getSelectionEx()[0].SubObjects[0].Length                  # sub element Length
    App.Console.PrintMessage("subObjectLength: "+str(subObjectLength)+"\n\n")
    
    subObjectX1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.x         # sub element coordinate X1
    App.Console.PrintMessage("subObject_X1   : "+str(subObjectX1)+"\n")
    subObjectY1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.y         # sub element coordinate Y1
    App.Console.PrintMessage("subObject_Y1   : "+str(subObjectY1)+"\n")
    subObjectZ1 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[0].Point.z         # sub element coordinate Z1
    App.Console.PrintMessage("subObject_Z1   : "+str(subObjectZ1)+"\n\n")

    try:
        subObjectX2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.x     # sub element coordinate X2
        App.Console.PrintMessage("subObject_X2   : "+str(subObjectX2)+"\n")
        subObjectY2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.y     # sub element coordinate Y2
        App.Console.PrintMessage("subObject_Y2   : "+str(subObjectY2)+"\n")
        subObjectZ2 = Gui.Selection.getSelectionEx()[0].SubObjects[0].Vertexes[1].Point.z     # sub element coordinate Z2
        App.Console.PrintMessage("subObject_Z2   : "+str(subObjectZ2)+"\n\n")
    except:
        App.Console.PrintMessage("Oups"+"\n\n")            

    subObjectBoundBox = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox              # sub element BoundBox coordinates
    App.Console.PrintMessage("subObjectBBox  : "+str(subObjectBoundBox)+"\n")
    
    subObjectBoundBoxCenter = Gui.Selection.getSelectionEx()[0].SubObjects[0].BoundBox.Center # sub element BoundBoxCenter
    App.Console.PrintMessage("subObjectBBoxCe: "+str(subObjectBoundBoxCenter)+"\n")
    
    surfaceFace = Gui.Selection.getSelectionEx()[0].SubObjects[0].Area                        # Area of the face selected
    App.Console.PrintMessage("surfaceFace    : "+str(surfaceFace)+"\n\n")
except:
    App.Console.PrintMessage("Oups"+"\n\n")            
##################################################################################

# give the area of the object
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
surface = sel[0].Shape.Area                                               # Area object complete
App.Console.PrintMessage("surfaceObjet   : "+str(surface)+"\n\n")
##################################################################################

# give the Center Of Mass and coordinates of the object
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
CenterOfMass = sel[0].Shape.CenterOfMass                                  # Center of Mass of the object
App.Console.PrintMessage("CenterOfMass   : "+str(CenterOfMass)+"\n")
App.Console.PrintMessage("CenterOfMassX  : "+str(CenterOfMass[0])+"\n")   # coordinates [0]=X [1]=Y [2]=Z
App.Console.PrintMessage("CenterOfMassY  : "+str(CenterOfMass[1])+"\n")   # or CenterOfMass.x, CenterOfMass.y, CenterOfMass.z
App.Console.PrintMessage("CenterOfMassZ  : "+str(CenterOfMass[2])+"\n\n")
##################################################################################

# list the all faces of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
for j in enumerate(sel[0].Shape.Faces):                                   # List alles faces of the object
    App.Console.PrintMessage("Face           : "+str("Face%d" % (j[0]+1))+"\n")
App.Console.PrintMessage("\n\n")
##################################################################################

# give the volume of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
volume_ = sel[0].Shape.Volume                                             # Volume of the object
App.Console.PrintMessage("volume_        : "+str(volume_)+"\n\n")
##################################################################################
 
# give the BoundBox of the oject selected all type
objs = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
if len(objs) >= 1:                                                         # serch the object type
    if hasattr(objs[0], "Shape"):
        s = objs[0].Shape
    elif hasattr(objs[0], "Mesh"):      # upgrade with wmayer thanks #http://forum.freecadweb.org/viewtopic.php?f=13&t=22331
        s = objs[0].Mesh
    elif hasattr(objs[0], "Points"):
        s = objs[0].Points

boundBox_= s.BoundBox                                                     # BoundBox of the object
App.Console.PrintMessage("boundBox_      : "+str(boundBox_)+"\n")         # 
 
boundBoxLX   = boundBox_.XLength                                          # Length x boundBox rectangle
boundBoxLY   = boundBox_.YLength                                          # Length y boundBox rectangle
boundBoxLZ   = boundBox_.ZLength                                          # Length z boundBox rectangle

boundBoxXMin = boundBox_.XMin                                             # coordonate XMin
boundBoxYMin = boundBox_.YMin                                             # coordonate YMin
boundBoxZMin = boundBox_.ZMin                                             # coordonate ZMin
boundBoxXMax = boundBox_.XMax                                             # coordonate XMax
boundBoxYMax = boundBox_.YMax                                             # coordonate YMax
boundBoxZMax = boundBox_.ZMax                                             # coordonate ZMax

boundBoxDiag= boundBox_.DiagonalLength                                    # Diagonal Length boundBox rectangle
boundBoxCenter = boundBox_.Center                                         # BoundBox Center

App.Console.PrintMessage("boundBoxLX     : "+str(boundBoxLX)+"\n")
App.Console.PrintMessage("boundBoxLY     : "+str(boundBoxLY)+"\n")
App.Console.PrintMessage("boundBoxLZ     : "+str(boundBoxLZ)+"\n\n")

App.Console.PrintMessage("boundBoxXMin   : "+str(boundBoxXMin)+"\n")
App.Console.PrintMessage("boundBoxYMin   : "+str(boundBoxYMin)+"\n")
App.Console.PrintMessage("boundBoxZMin   : "+str(boundBoxZMin)+"\n")
App.Console.PrintMessage("boundBoxXMax   : "+str(boundBoxXMax)+"\n")
App.Console.PrintMessage("boundBoxYMax   : "+str(boundBoxYMax)+"\n")
App.Console.PrintMessage("boundBoxZMax   : "+str(boundBoxZMax)+"\n\n")

App.Console.PrintMessage("boundBoxDiag   : "+str(boundBoxDiag)+"\n")
App.Console.PrintMessage("boundBoxCenter : "+str(boundBoxCenter)+"\n\n")

##################################################################################

# give the complete placement of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement                                               # Placement Vector XYZ and Yaw-Pitch-Roll
App.Console.PrintMessage("Placement      : "+str(pl)+"\n")
##################################################################################

# give the placement Base (xyz) of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Base                                          # Placement Vector XYZ
App.Console.PrintMessage("PlacementBase  : "+str(pl)+"\n\n")
##################################################################################
 
# give the placement Base (xyz) of the object selected
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
oripl_X = sel[0].Placement.Base[0]                                        # decode Placement X
oripl_Y = sel[0].Placement.Base[1]                                        # decode Placement Y
oripl_Z = sel[0].Placement.Base[2]                                        # decode Placement Z

# same 
#oripl_X = sel[0].Placement.Base.x                                        # decode Placement X
#oripl_Y = sel[0].Placement.Base.y                                        # decode Placement Y
#oripl_Z = sel[0].Placement.Base.z                                        # decode Placement Z
 
App.Console.PrintMessage("oripl_X        : "+str(oripl_X)+"\n")
App.Console.PrintMessage("oripl_Y        : "+str(oripl_Y)+"\n")
App.Console.PrintMessage("oripl_Z        : "+str(oripl_Z)+"\n\n")
##################################################################################

# give the placement rotation of the object selected (x, y, z, angle rotation)
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
rotation = sel[0].Placement.Rotation                                      # decode Placement Rotation
App.Console.PrintMessage("rotation              : "+str(rotation)+"\n\n")
##################################################################################

# give the placement rotation of the object selected (x, y, z, angle rotation)
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation                                      # decode Placement Rotation other method
App.Console.PrintMessage("Placement Rot         : "+str(pl)+"\n\n")
##################################################################################

# give the rotation of the object selected (angle rotation)
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
pl = sel[0].Shape.Placement.Rotation.Angle                                # decode Placement Rotation Angle
App.Console.PrintMessage("Placement Rot Angle   : "+str(pl)+"\n\n")
##################################################################################

# give the rotation.Q of the object selected (angle rotation in Radian) for convert: math.degrees(angleInRadian)
sel = FreeCADGui.Selection.getSelection()                                 # select object with getSelection()
Rot   = sel[0].Placement.Rotation.Q                                       # Placement Rotation Q
App.Console.PrintMessage("Rot           : "+str(Rot)+ "\n")
 
Rot_0 = sel[0].Placement.Rotation.Q[0]                                    # decode Placement Rotation Q
App.Console.PrintMessage("Rot_0         : "+str(Rot_0)+ " rad ,  "+str(180 * Rot_0 / 3.1416)+" deg "+"\n") # or math.degrees(angle)
 
Rot_1 = sel[0].Placement.Rotation.Q[1]                                    # decode Placement Rotation 1
App.Console.PrintMessage("Rot_1         : "+str(Rot_1)+ " rad ,  "+str(180 * Rot_1 / 3.1416)+" deg "+"\n") # or math.degrees(angle)
 
Rot_2 = sel[0].Placement.Rotation.Q[2]                                    # decode Placement Rotation 2
App.Console.PrintMessage("Rot_2         : "+str(Rot_2)+ " rad ,  "+str(180 * Rot_2 / 3.1416)+" deg "+"\n") # or math.degrees(angle)

Rot_3 = sel[0].Placement.Rotation.Q[3]                                    # decode Placement Rotation 3
App.Console.PrintMessage("Rot_3         : "+str(Rot_3)+"\n\n")

Rot_Axis = sel[0].Placement.Rotation.Axis                                 # Placement Rotation .Axis
App.Console.PrintMessage("Rot_Axis      : "+str(Rot_Axis)+ "\n")
 
Rot_Angle = sel[0].Placement.Rotation.Angle                               # Placement Rotation .Angle
App.Console.PrintMessage("Rot_Angle     : "+str(Rot_Angle)+ "\n\n")
##################################################################################

# give the rotation of the object selected toEuler (angle rotation in degrees)
sel = FreeCADGui.Selection.getSelection()                             # select object with getSelection()
angle   = sel[0].Shape.Placement.Rotation.toEuler()                   # angle Euler
App.Console.PrintMessage("Angle          : "+str(angle)+"\n")
Yaw   = sel[0].Shape.Placement.Rotation.toEuler()[0]                  # decode angle Euler Yaw (Z) lacet (alpha)
App.Console.PrintMessage("Yaw            : "+str(Yaw)+"\n")
Pitch = sel[0].Shape.Placement.Rotation.toEuler()[1]                  # decode angle Euler Pitch (Y) tangage (beta)
App.Console.PrintMessage("Pitch          : "+str(Pitch)+"\n")
Roll  = sel[0].Shape.Placement.Rotation.toEuler()[2]                  # decode angle Euler Roll (X) roulis (gamma)
App.Console.PrintMessage("Roll           : "+str(Roll)+"\n\n")
##################################################################################

# find Midpoint of the selected line
import Draft, DraftGeomUtils
sel = FreeCADGui.Selection.getSelection()
vecteur = DraftGeomUtils.findMidpoint(sel[0].Shape.Edges[0])              # find Midpoint
App.Console.PrintMessage(vecteur)
Draft.makePoint(vecteur)
##################################################################################

Căutarea Manuală a unui element având eticheta sa

# Extract the coordinate X,Y,Z and Angle giving the label (here "Cylindre")
App.Console.PrintMessage("Base.x       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.x)+"\n")
App.Console.PrintMessage("Base.y       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.y)+"\n")
App.Console.PrintMessage("Base.z       : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Base.z)+"\n")
App.Console.PrintMessage("Base.Angle   : "+str(FreeCAD.ActiveDocument.getObjectsByLabel("Cylindre")[0].Placement.Rotation.Angle)+"\n\n")
##################################################################################

PS: De obiecei unghiurile sunt dat în Radian, pentru a face conversia :

  1. angle in Degrees to Radians :
    • Angle in radian = pi * (angle in degree) / 180
    • Angle in radian = math.radians(angle in degree)
  2. angle in Radians to Degrees :
    • Angle in degree = 180 * (angle in radian) / pi
    • Angle in degree = math.degrees(angle in radian)

Coordonate Carteziene

Acest cod afișează coordonatele cartesiene ale elementului selectat.

Modificați valoarea "numberOfPoints" dacă doriți o precizie mai mare sau mai mică

numberOfPoints = 100                                                         # Decomposition number (or precision you can change)
selectedEdge = FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy() # select one element
points  = selectedEdge.discretize(numberOfPoints)                            # discretize the element
i=0
for p in points:                                                             # list and display the coordinates
    i+=1
    print i, " X", p.x, " Y", p.y, " Z", p.z

Altă metodă de afișarea a "Int" și "Float"

import Part
from FreeCAD import Base

c=Part.makeCylinder(2,10)        # create the circle
Part.show(c)                     # display the shape

# slice accepts two arguments:
#+ the normal of the cross section plane
#+ the distance from the origin to the cross section plane. Here you have to find a value so that the plane intersects your object
s=c.slice(Base.Vector(0,1,0),0)  # 

# here the result is a single wire
# depending on the source object this can be several wires
s=s[0]

# if you only need the vertexes of the shape you can use
v=[]
for i in s.Vertexes:
    v.append(i.Point)

# but you can also sub-sample the section to have a certain number of points (int) ...
p1=s.discretize(20)
ii=0
for i in p1:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode
Draft.makeWire(p1,closed=False,face=False,support=None)  # to see the difference accuracy (20)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"


# ... or define a sampling distance (float)
p2=s.discretize(0.5)
ii=0
for i in p2:
    ii+=1
    print i                                              # Vector()
    print ii, ": X:", i.x, " Y:", i.y, " Z:", i.z        # Vector decode 
Draft.makeWire(p2,closed=False,face=False,support=None)  # to see the difference accuracy (0.5)

## uncomment to use
#import Draft
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # first transform the DWire in Wire         "downgrade"
#Draft.downgrade(App.ActiveDocument.ActiveObject,delete=True)  # second split the Wire in single objects   "downgrade"
#
##Draft.upgrade(FreeCADGui.Selection.getSelection(),delete=True) # to attach lines contiguous SELECTED use "upgrade"

Selectați toate obiectele în document

import FreeCAD
for obj in FreeCAD.ActiveDocument.Objects:
    print obj.Name                                # display the object Name
    objName = obj.Name
    obj = App.ActiveDocument.getObject(objName)
    Gui.Selection.addSelection(obj)               # select the object

Selectarea fațetei unui obiect

# select one face of the object
import FreeCAD, Draft
App=FreeCAD
nameObject = "Box"                             # objet
faceSelect = "Face3"                           # face to selection
loch=App.ActiveDocument.getObject(nameObject)  # objet
Gui.Selection.clearSelection()                 # clear all selection
Gui.Selection.addSelection(loch,faceSelect)    # select the face specified
s = Gui.Selection.getSelectionEx()
#Draft.makeFacebinder(s)                       #

Crearea unui obiect față de poziția Camerei foto

# create one object of the position to camera with "getCameraOrientation()"
# the object is still facing the screen
import Draft

plan = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
plan = str(plan)
###### extract data
a    = ""
for i in plan:
    if i in ("0123456789e.- "):
        a+=i
a = a.strip(" ")
a = a.split(" ")
####### extract data

#print a
#print a[0]
#print a[1]
#print a[2]
#print a[3]

xP = float(a[0])
yP = float(a[1])
zP = float(a[2])
qP = float(a[3])

pl = FreeCAD.Placement()
pl.Rotation.Q = (xP,yP,zP,qP)         # rotation of object
pl.Base = FreeCAD.Vector(0.0,0.0,0.0) # here coordinates XYZ of Object
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None) # create rectangle
#rec = Draft.makeCircle(radius=5,placement=pl,face=False,support=None)                   # create circle
print rec.Name

aici avem același sod simplificat

import Draft
pl = FreeCAD.Placement()
pl.Rotation = FreeCADGui.ActiveDocument.ActiveView.getCameraOrientation()
pl.Base = FreeCAD.Vector(0.0,0.0,0.0)
rec = Draft.makeRectangle(length=10.0,height=10.0,placement=pl,face=False,support=None)

Determinarea vectorului normal() la o suprafață

Acest exemplu arată modul de găsire a vectorului normal() a unei suprafețe prin căutarea parametrilor u, v ai unui punct de pe suprafață și folosirea parametrilor u, v pentru a găsi vectorul normal()

def normal(self):
   ss=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[0].copy()#SubObjects[0] is the edge list
   points  = ss.discretize(3.0)#points on the surface edge, 
             #this example just use points on the edge for example. 
             #However point is not necessary on the edge, it can be anywhere on the surface. 
   face=FreeCADGui.Selection.getSelectionEx()[0].SubObjects[1]
   for pp in points:
      pt=FreeCAD.Base.Vector(pp.x,pp.y,pp.z)#a point on the surface edge
      uv=face.Surface.parameter(pt)# find the surface u,v parameter of a point on the surface edge
      u=uv[0]
      v=uv[1]
      normal=face.normalAt(u,v)#use u,v to find normal vector
      print normal
      line=Part.makeLine((pp.x,pp.y,pp.z), (normal.x,normal.y,normal.z))
      Part.show(line)

Citirea și Scrierea unei Expresii

import Draft
doc = FreeCAD.ActiveDocument

pl=FreeCAD.Placement()
pl.Rotation.Q=(0.0,-0.0,-0.0,1.0)
pl.Base=FreeCAD.Vector(0.0,0.0,0.0)
obj = Draft.makeCircle(radius=1.0,placement=pl,face=False,support=None)    # create circle

print obj.PropertiesList                                                   # properties disponible in the obj

doc.getObject(obj.Name).setExpression('Radius', u'2mm')                    # modify the radius
doc.getObject(obj.Name).setExpression('Placement.Base.x', u'10mm')         # modify the placement 
doc.getObject(obj.Name).setExpression('FirstAngle', u'90')                 # modify the first angle
doc.recompute()

expressions = obj.ExpressionEngine                                         # read the expression list
print expressions

for i in expressions:                                                      # list and separate the data expression
    print i[0]," = ",i[1]

Get the normal vector of a surface from a STL file

def getNormal(cb):
    if cb.getEvent().getState() == coin.SoButtonEvent.UP:
        pp = cb.getPickedPoint()
        if pp:
            vec = pp.getNormal().getValue()
            index = coin.cast(pp.getDetail(), "SoFaceDetail").getFaceIndex()
            print ("Normal: {}, Face index: {}".format(str(vec), index))

from pivy import coin
meth=Gui.ActiveDocument.ActiveView.addEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), getNormal)

you are done then run for quit:

Gui.ActiveDocument.ActiveView.removeEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(), meth)