PyGTS es un paquete de Python que se puede utilizar para

PyGTS es un paquete de Python que se puede utilizar para construir, manipular y
realizar cálculos en 3D de superficies triangulares. Es un hecho a mano y pythonic
vinculante para la superficie triangulada GNU (GTS) Biblioteca.
GTS representa la superficie triangulada GNU Biblioteca. Se trata de un Open Source
Software Libre biblioteca destinada a proporcionar un conjunto de funciones útiles para
hacer frente a las superficies 3D de malla de triángulos conectados entre sí. El código
fuente está disponible de forma gratuita bajo la licencia LGPL del Software Libre.
El código está escrito enteramente en C, con un enfoque orientado a objetos basado
sobre todo en el diseño de GTK +. Se presta una atención a las cuestiones relacionadas
con el rendimiento como el objetivo inicial de GTS es proporcionar una biblioteca
sencilla y eficaz a los científicos se ocupan de mallas 3D de superficie de cálculo.
Un breve resumen de sus principales características:
 Objeto simple estructura orientada a dar fácil acceso a las propiedades
topológicas.
 2D Delaunay dinámica y triangulaciones de Delaunay restringida.
 Robusto predicados geométricas (orientación, en el círculo) con rápida
adaptación aritmética de punto flotante (adaptación de la excelente labor
realizada por Jonathan R. Shewchuk).
 Robusto las operaciones establecidas en las superficies (unión, intersección,
diferencia).
El refinamiento y la brutalidad de superficie (modelos multiresolución).
 Vista dinámica continua de nivel independiente-de-detalle.
 Anteproyecto de apoyo para ver el nivel dependiente-de-detalle.
 Coordenadas de cajas de árboles y KD-árboles para la localización del punto de
colisión eficiente y detección de intersección.
 Operaciones Gráfico: recorrido, la partición de gráfico.
 Operaciones métricas (área, volumen, curvatura ...).
 Triángulo de la generación de tiras para el renderizado rápido.
Pygts es Una herramienta libre de Python para la manipulación de las superficies de
triangulación
PyGTS es un paquete de código abierto y basado en Python utilizados para construir,
manipular y realizar cálculos sobre las superficies triangulares.
PyGTS es un hecho a mano y pythonic vinculante para la superficie triangulada GNU
(GTS) Biblioteca.
Principales características:
- Objeto simple estructura orientada a dar fácil acceso a las propiedades topológicas.
- 2D Delaunay dinámica y triangulaciones de Delaunay restringida.
- Robusto predicados geométricas (orientación, en el círculo) con rápida adaptación
aritmética de punto flotante.
- Robusto conjunto de las operaciones en las superficies (unión, intersección, diferencia).
- Superficie refinamiento y la brutalidad (modelos multiresolución).
- Vista dinámica continua de nivel independiente-de-detalle.
- Anteproyecto de apoyo para ver el nivel dependiente-de-detalle.
- Coordenadas de cajas de árboles y KD-árboles para la localización del punto de
colisión eficiente y detección de intersección.
- Las operaciones Gráfico: recorrido, la partición de gráfico.
- Las operaciones de métricas (área, volumen, curvatura ...).
- Triángulo de generación de tiras para el renderizado rápido.
Requisitos del sistema:
Mejoras
- Corregido encasillamiento interior de los vértices. Esto soluciona problemas
- Con el uso de lista de números como vértices.
- Mejora de código de limpieza
- Construir específicamente para i386 de PPC en Mac OS X
Programa ejemplo
from gts import*
def get_coords_and_face_indices(s, descomprimir = False):
"" "Devuelve las coordenadas y los índices de la cara
de la superficie S.
if descomprimir is True then cuatro tuplas se devuelven.
Los tres primeros
son las X, Y y Z las coordenadas de cada vértice en la
superficie.
La última es una lista de tuplas, una para cada cara en
la superficie,
que contiene 3 índices que une los vértices de cara a
la coordinación de
listas.
if descomprimir is false, then las coordenadas que
figuran en una lista única
de 3-tuplas.
"" "
vértices = s.vertices ()
coords = [v.coords () para v en vértices]
face_indices = s.face_indices (vértices)
si descomprimir:
x, y, z = zip (* coords)
return x, y, z, face_indices
otra cosa:
vértices de retorno, coords
def cubo ():
"" "Devuelve un cubo de la longitud de la cara 2
centrado en el origen". ""
#
#
#
#
#
#
#
#
#
#
V8 ------ v5
/ / |
/ V1 / |
V4 ------ |
| | V6
| (V7) | /
| | /
V3 ------ v2
v1,
Vértice
V5,
Vértice
v2, v3, v4 = vértice (1,1,1), Vértice (1,1, -1),
(1, -1, -1), Vértice (1, -1,1)
V6, V7, V8 = Vértice (-1,1,1), Vértice (-1,1, -1),
(-1, -1, -1), Vértice (-1, -1,1 )
E12, E23, E34, E14 =
(v3, v4), Edge (v4, v1)
E56, E67, E78, E58 =
Edge (v7, v8), EDGE (V8,
E15, E26, E37, E48 =
(v3, v7), Edge (v4, v8)
E13, E16, E18 = Edge
v8)
E27, E47, E57 = Edge
v5)
Edge (v1, v2), Edge (V2, V3), Edge
Edge (V5, V6), Edge (V6 y V7),
V5)
Edge (v1, v5), Edge (v2, V6), Edge
(v1, v3), Edge (v1, V6), Edge (v1,
(v7, v2), Edge (v7, v4), Edge (v7,
caras = [Cara (E12, E23, E13), Cara (E13, E34, E14),
Face (E12, E26, E16), Cara (E15, E56, E16),,
Face (E15, E58, E18), Cara (E14, E48, E18),,
Face (E58, E78, E57), Cara (E56, E67, E57),,
Face (E26, E67, E27), Cara (E37, E23, E27),,
Face (E37, E47, E34), Cara (E78, E48, E47)]
se enfrenta a [0]. revertir () # Establecer la
orientación de la primera cara
s = superficie ()
para la cara en la cara:
si no face.is_compatible (s):
face.revert ()
s.add (Presencial)
return s
tetraedro def ():
"" "Devuelve un tetraedro de longitud lateral 2 * sqrt
(2) centrada en el origen.
Los bordes del tetraedro son perpendiculares al
cardenal
direcciones.
"" "
#
#
#
#
#
#
#
#
#
#
V4
| \ E6
E5 '| e4!
V1. -e3-v3
/.
./e1. e2
/.
V2
# Crear vértices
v1 = vértice (1,1,1)
v2 = vértice (-1, -1,1)
v3 = Vértice (-1,1, -1)
v4 = Vértice (1, -1, -1)
# Crear bordes
e1 = Edge (v1,
E2 = Edge (V2,
E3 = Edge (v3,
e4 = Edge (v1,
e5 = Edge (v4,
E6 = Edge (v4,
v2)
V3)
v1)
v4)
v2)
v3)
# Crear caras
f1 = Face (E1,
f2 = Face (e1,
f3 = Face (E2,
f4 = Face (e3,
E2,
e4,
E5,
e4,
E3)
e5)
E6)
e6)
de cara inferior #
se enfrentan a la izquierda #
# Derecho cara
# Volver cara
# Establezca la orientación de la cara primero
f1.revert ()
# Superficie Ensamble
s = superficie ()
para la cara en [F1, F2, F3, F4]:
si no face.is_compatible (s):
face.revert ()
s.add (Presencial)
return s