Mesh Scripting/es: Difference between revisions

From FreeCAD Documentation
(Created page with '=== Introducción === En primer lugar usted tiene que importar el módulo Malla: import Mesh Después de eso, ya tendrá acceso al módulo Malla y la clase Malla, que ofrecen …')
 
(Created page with "Ver también: Interfaz de programación de aplicaciones Malla.")
 
(55 intermediate revisions by 6 users not shown)
Line 1: Line 1:
<languages/>
=== Introducción ===


{{TOCright}}
En primer lugar usted tiene que importar el módulo Malla:
import Mesh


==Introducción==
Después de eso, ya tendrá acceso al módulo Malla y la clase Malla, que ofrecen las funciones del nucleo FreeCAD C++ Mesh-Kernel.


Para obtener acceso al módulo {{incode|Malla}} hay que importarlo primero:


{{Code|code=
=== Creación y Carga ===
import Mesh
}}


==Creación==
Para crear un objeto malla vacío sólo tiene que utilizar el constructor estándar:
malla = Mesh.Mesh()
También puede crear un objeto desde un archivo
malla = Mesh.Mesh ('D: / temp / Something.stl')
Los formatos de archivos que puede utilizar para construir una malla se indican [[Feature_list#IO|here]].


Para crear un objeto de malla vacío basta con utilizar el constructor estándar:


{{Code|code=
O tambien puede crear la malla a partir de un conjunto de triángulos descrito por sus vértices:
mesh = Mesh.Mesh()
}}


También puede crear un objeto a partir de un archivo:
planarMesh = [
# triangle 1
[-0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],[-0.5000,0.5000,0.0000],
#triangle 2
[-0.5000,-0.5000,0.0000],[0.5000,-0.5000,0.0000],[0.5000,0.5000,0.0000],
]
planarMeshObject = Mesh.Mesh(planarMesh)


{{Code|code=
mesh = Mesh.Mesh("D:/temp/Something.stl")
}}


O crearla a partir de un conjunto de triángulos descritos por sus puntos de esquina:
El núcleo de mallas, Mesh-Kernel, se encarga de crear una estructura topológica de datos correcta, ordenando juntos puntos coincidentes y bordes.
Más adelante podrá ver cómo puede examinar y revisar los datos de la malla.


{{Code|code=
=== Modelado ===
triangles = [
# triangle 1
[-0.5000, -0.5000, 0.0000], [0.5000, 0.5000, 0.0000], [-0.5000, 0.5000, 0.0000],
#triangle 2
[-0.5000, -0.5000, 0.0000], [0.5000, -0.5000, 0.0000], [0.5000, 0.5000, 0.0000],
]
meshObject = Mesh.Mesh(triangles)
Mesh.show(meshObject)
}}


El Núcleo-Malla se encarga de crear una estructura de datos topológicamente correcta ordenando los puntos y aristas coincidentes.
Para crear geometrías regulares puede utilizar el script Python BuildRegularGeoms.py.
{{Top}}
import BuildRegularGeoms
==Modelización==
Esta secuencia de comandos proporciona métodos para definir cuerpos de revolución sencillos, como esferas, elipsoides, cilindros, toroides y conos. Y también tiene un método para crear un cubo simple.
Para crear un toroide, por ejemplo, se puede hacer de la siguiente manera:


Para crear geometrías regulares se puede utilizar uno de los métodos {{incode|create*()}}. Un toroide, por ejemplo, se puede crear de la siguiente manera:
t = BuildRegularGeoms.Toroid(8.0, 2.0, 50) # list with several thousands triangles
m = Mesh.mesh(t)


{{Code|code=
m = Mesh.createTorus(8.0, 2.0, 50)
Mesh.show(m)
}}


Los dos primeros parámetros definen los radios del toroide y el tercer parámetro es un factor de submuestreo relacionado con el número de triángulos que se han de crear. Cuanto mayor sea este valor, más suave es la forma y mejor acabado tiene el cuerpo.
Los dos primeros parámetros definen los radios del toroide y el tercer parámetro es un factor de submuestreo para saber cuántos triángulos se crean. Cuanto mayor sea este valor, más suave será la malla.


El módulo {{incode|Malla}} también proporciona tres métodos booleanos: {{incode|union()}}, {{incode|intersection()}} y {{incode|difference()}}:
m1, m2 # are the input mesh objects
m3 = Mesh.mesh(m1) # create a copy of m1
m3.unite(m2) # union of m1 and m2, the result is stored in m3
m4 = Mesh.mesh(m1)
m4.intersect(m2) # intersection of m1 and m2
m5 = Mesh.mesh(m1)
m5.difference(m2) # the difference of m1 and m2
m6 = Mesh.mesh(m2)
m6.difference(m1) # the difference of m2 and m1, usually the result is different to m5


{{Code|code=
m1, m2 # are the input mesh objects
m3 = Mesh.Mesh(m1) # create a copy of m1
m3.unite(m2) # union of m1 and m2, the result is stored in m3
m4 = Mesh.Mesh(m1)
m4.intersect(m2) # intersection of m1 and m2
m5 = Mesh.Mesh(m1)
m5.difference(m2) # the difference of m1 and m2
m6 = Mesh.Mesh(m2)
m6.difference(m1) # the difference of m2 and m1, usually the result is different to m5
}}


Este es un ejemplo que crea una tubería utilizando el método {{incode|difference()}}:
Por último, un ejemplo completo que calcula la intersección entre una esfera y un cilindro que corta a la esfera.


{{Code|code=
import Mesh, BuildRegularGeoms
import FreeCAD, Mesh
sphere = Mesh.mesh( BuildRegularGeoms.Sphere(5.0, 50) )
cylinder = Mesh.mesh( BuildRegularGeoms.Cylinder(2.0, 10.0, True, 1.0, 50) )
cylA = Mesh.createCylinder(2.0, 10.0, True, 1.0, 36)
cylB = Mesh.createCylinder(1.0, 12.0, True, 1.0, 36)
diff = sphere
cylB.Placement.Base = (FreeCAD.Vector(-1, 0, 0)) # move cylB to avoid co-planar faces
diff.difference(cylinder)
pipe = cylA
d = FreeCAD.newDocument()
pipe = pipe.difference(cylB)
d.addObject("Mesh::Feature","Diff_Sphere_Cylinder").Mesh=diff
pipe.flipNormals() # somehow required
d.recompute()
doc = FreeCAD.ActiveDocument
obj = d.addObject("Mesh::Feature", "Pipe")
obj.Mesh = pipe
doc.recompute()
}}
{{Top}}
==Notas==


Una fuente extensa, aunque difícil de usar, de scripts relacionados con la malla son los scripts de pruebas unitarias del módulo {{incode|Mesh}}.
En estas pruebas unitarias se llaman literalmente todos los métodos y se ajustan todas las propiedades/atributos.
Así que si eres lo suficientemente audaz, echa un vistazo al módulo [https://github.com/FreeCAD/FreeCAD/blob/master/src/Mod/Mesh/App/MeshTestsApp.py Unit Test].


Ver también: [[Mesh_API|Interfaz de programación de aplicaciones Malla]].
=== Examen y pruebas ===
{{Top}}

{{Powerdocnavi{{#translation:}}}}
=== Escriba sus propios algoritmos ===
[[Category:Developer Documentation{{#translation:}}]]

[[Category:Python Code{{#translation:}}]]
=== Exportación ===
{{Mesh Tools navi{{#translation:}}}}

{{clear}}
Usted puede incluso escribir la malla en un módulo Python:

m.write("D:/Develop/Projekte/FreeCAD/FreeCAD_0.7/Mod/Mesh/SavedMesh.py")
import SavedMesh
m2 = Mesh.mesh(SavedMesh.faces)

=== GUI relacionados ===

=== Ajustes y pruebas ===
Una extensa, aunque dificil de usar, librería de guiones relacionados con malla son los scripts de prueba del módulo Malla.
En esta unidad, literalmente todos los métodos son invocados, y se ajustan todas las propiedades y atributos.
Así que si es lo suficientemente audaz, eche un vistazo a [http://free-cad.svn.sourceforge.net/viewvc/free-cad/trunk/src/Mod/Mesh/App/MeshTestsApp.py?view=markup Unit Test module].




{{docnav/es|FreeCAD Scripting Basics/es|Topological data scripting/es}}

{{languages | {{se|Mesh Scripting/se}} }}

[[Category:Poweruser Documentation]]

Latest revision as of 13:32, 19 September 2021

Introducción

Para obtener acceso al módulo Malla hay que importarlo primero:

import Mesh

Creación

Para crear un objeto de malla vacío basta con utilizar el constructor estándar:

mesh = Mesh.Mesh()

También puede crear un objeto a partir de un archivo:

mesh = Mesh.Mesh("D:/temp/Something.stl")

O crearla a partir de un conjunto de triángulos descritos por sus puntos de esquina:

triangles = [
# triangle 1
[-0.5000, -0.5000, 0.0000], [0.5000, 0.5000, 0.0000], [-0.5000, 0.5000, 0.0000],
#triangle 2
[-0.5000, -0.5000, 0.0000], [0.5000, -0.5000, 0.0000], [0.5000, 0.5000, 0.0000],
]
meshObject = Mesh.Mesh(triangles)
Mesh.show(meshObject)

El Núcleo-Malla se encarga de crear una estructura de datos topológicamente correcta ordenando los puntos y aristas coincidentes.

Inicio

Modelización

Para crear geometrías regulares se puede utilizar uno de los métodos create*(). Un toroide, por ejemplo, se puede crear de la siguiente manera:

m = Mesh.createTorus(8.0, 2.0, 50)
Mesh.show(m)

Los dos primeros parámetros definen los radios del toroide y el tercer parámetro es un factor de submuestreo para saber cuántos triángulos se crean. Cuanto mayor sea este valor, más suave será la malla.

El módulo Malla también proporciona tres métodos booleanos: union(), intersection() y difference():

m1, m2              # are the input mesh objects
m3 = Mesh.Mesh(m1)  # create a copy of m1
m3.unite(m2)        # union of m1 and m2, the result is stored in m3
m4 = Mesh.Mesh(m1)
m4.intersect(m2)    # intersection of m1 and m2
m5 = Mesh.Mesh(m1)
m5.difference(m2)   # the difference of m1 and m2
m6 = Mesh.Mesh(m2)
m6.difference(m1)   # the difference of m2 and m1, usually the result is different to m5

Este es un ejemplo que crea una tubería utilizando el método difference():

import FreeCAD, Mesh
cylA = Mesh.createCylinder(2.0, 10.0, True, 1.0, 36)
cylB = Mesh.createCylinder(1.0, 12.0, True, 1.0, 36)
cylB.Placement.Base = (FreeCAD.Vector(-1, 0, 0)) # move cylB to avoid co-planar faces
pipe = cylA
pipe = pipe.difference(cylB)
pipe.flipNormals() # somehow required
doc = FreeCAD.ActiveDocument
obj = d.addObject("Mesh::Feature", "Pipe")
obj.Mesh = pipe
doc.recompute()

Inicio

Notas

Una fuente extensa, aunque difícil de usar, de scripts relacionados con la malla son los scripts de pruebas unitarias del módulo Mesh. En estas pruebas unitarias se llaman literalmente todos los métodos y se ajustan todas las propiedades/atributos. Así que si eres lo suficientemente audaz, echa un vistazo al módulo Unit Test.

Ver también: Interfaz de programación de aplicaciones Malla.

Inicio