View Sierpinski tetrahedrons.stl  on viewstl.com

Resumen

Python source code

<source style="font-size:80%;height:20em;overflow:auto;" lang="python">

1. !/usr/bin/env python

header = 'A collection of level 0 to 7 tetrices or Sierpinski tetrahedra by CMG Lee.' separation_tetrix = 1.1

a = 3 ** -0.5 ## apex to centroid of equilateral triangle of side 1 b = a * -0.5 ## base to centroid of equilateral triangle of side 1 (negative) c = 0.5 ## half of base of equilateral triangle of side 1 normals = [None,0,0] ## set to ignore until support is apparent

import re, struct, math def fmt(string): ## string.format(**vars()) using tags {expression!format} by CMG Lee

def f(tag): i_sep = tag.rfind('!'); return (re.sub('\.0+$', , str(eval(tag[1:-1])))
 if (i_sep < 0) else ('{:%s}' % tag[i_sep + 1:-1]).format(eval(tag[1:i_sep])))
return (re.sub(r'(?<!{){[^{}]+}', lambda m:f(m.group()), string)
        .replace('{{', '{').replace('}}', '}'))

def append(obj, string): return obj.append(fmt(string)) def tabbify(cellss, separator='|'):

cellpadss = [list(rows) + [] * (len(max(cellss, key=len)) - len(rows)) for rows in cellss]
fmts = ['%%%ds' % (max([len(str(cell)) for cell in cols])) for cols in zip(*cellpadss)]
return '\n'.join([separator.join(fmts) % tuple(rows) for rows in cellpadss])

def hex_rgb(colour): ## convert [#]RGB to #RRGGBB and [#]RRGGBB to #RRGGBB

return '#%s' % (colour if len(colour) > 4 else .join([c * 2 for c in colour])).lstrip('#')

def viscam_colour(colour):

colour_hex      = hex_rgb(colour)
colour_top5bits = [int(colour_hex[i:i+2], 16) >> 3 for i in range(1,7,2)]
return (1 << 15) + (colour_top5bits[0] << 10) + (colour_top5bits[1] << 5) + colour_top5bits[2]

def roundm(x, multiple=1):

if   (isinstance(x, tuple)): return tuple(roundm(list(x), multiple))
elif (isinstance(x, list )): return [roundm(x_i, multiple) for x_i in x]
else: return int(math.floor(float(x) / multiple + 0.5)) * multiple

def flatten(lss): return [l for ls in lss for l in ls] def rotate(facetss, degs): ## around x then y then z axes

(deg_x,deg_y,deg_z) = degs
(sin_x,cos_x) = (math.sin(math.radians(deg_x)), math.cos(math.radians(deg_x)))
(sin_y,cos_y) = (math.sin(math.radians(deg_y)), math.cos(math.radians(deg_y)))
(sin_z,cos_z) = (math.sin(math.radians(deg_z)), math.cos(math.radians(deg_z)))
facet_rotatess = []
for facets in facetss:
 facet_rotates = []
 for i_point in range(4):
  (x, y, z) = [facets[3 * i_point + i_xyz] for i_xyz in range(3)]
  if (x is None or y is None or z is None):
   facet_rotates += [x, y, z]
  else:
   (y, z) = (y * cos_x - z * sin_x,  y * sin_x + z * cos_x) ## rotate about x
   (x, z) = (x * cos_y + z * sin_y, -x * sin_y + z * cos_y) ## rotate about y
   (x, y) = (x * cos_z - y * sin_z,  x * sin_z + y * cos_z) ## rotate about z
   facet_rotates += [round(value, 9) for value in [x, y, z]]
 facet_rotatess.append(facet_rotates)
return facet_rotatess

def translate(facetss, ds): ## ds = (dx,dy,dz)

return [facets[:3] + [facets[3 * i_point + i_xyz] + ds[i_xyz]
                      for i_point in range(1,4) for i_xyz in range(3)]
        for facets in facetss]

def make_tetrix(level, side, is_collection=False):

(a_side, b_side, c_side) = [value * side * (separation_tetrix if (is_collection) else
                                            1 if (level == 0) else 0.5) for value in [a, b, c]]
vertexs = [[ 0     ,0     ,a_side], ## apex
           [ c_side,b_side,b_side], ## left  on base
           [-c_side,b_side,b_side], ## right on base
           [ 0     ,a_side,b_side]] ## front on base
if (is_collection): return flatten([translate(make_tetrix(level + i_vertex, side),
                                     [xyz + ((separation_tetrix - 1) * 1.5 if (i == 2) else 0)
                                      for (i, xyz) in enumerate(vertex)])
                                    for (i_vertex, vertex) in enumerate(vertexs)])
if (level == 0): return([normals + vertexs[1] + vertexs[2] + vertexs[3],
                         normals + vertexs[0] + vertexs[1] + vertexs[3],
                         normals + vertexs[0] + vertexs[2] + vertexs[1],
                         normals + vertexs[0] + vertexs[3] + vertexs[2]])
childss = make_tetrix(abs(level) - 1, side * 0.5)
return flatten([translate(childss, vertex) for vertex in vertexs])

1. 1. Add facets

facetss = rotate(make_tetrix(0, 1, True), [180,0,0]) + make_tetrix(-7, 1, True)

1. 1. Calculate normals

for facets in facetss:

if (facets[0] is None or facets[1] is None or facets[2] is None):
 us      = [facets[i_xyz + 9] - facets[i_xyz + 6] for i_xyz in range(3)]
 vs      = [facets[i_xyz + 6] - facets[i_xyz + 3] for i_xyz in range(3)]
 normals = [us[1]*vs[2] - us[2]*vs[1], us[2]*vs[0] - us[0]*vs[2], us[0]*vs[1] - us[1]*vs[0]]
 normal_length = sum([component * component for component in normals]) ** 0.5
 facets[:3] = [round(component / normal_length, 10) for component in normals]

1. print(tabbify([['%s%d' % (xyz, n) for n in range(3) for xyz in list('XYZ')] +
2. ['N%s'  % (xyz) for xyz in list('xyz')] + ['s0f']] + facetss))
   1. Compile STL

outss = ([[('STL\n\n%-73s\n\n' % (header[:73])).encode('utf-8'), struct.pack('<L', len(facetss))]] +

        [[struct.pack('<f', float(value)) for value in facets[:12]] +
         [struct.pack('<H', 0 if (len(facets) <= 12) else
                            viscam_colour(facets[12]))] for facets in facetss])

out = b.join([bytes(out) for outs in outss for out in outs]) print("# bytes:%d\t# facets:%d\ttitle:\"%-73s\"" % (len(out), len(facetss), header[:73])) with open(__file__[:__file__.rfind('.')] + '.stl', 'wb') as f_out: f_out.write(out)

# f_out.write('%s\n## Python script to generate STL\n%s\n' % (.join(outs), open(__file__).read()))

</syntaxhighlight>

Licencia

La persona que subió este archivo aceptó la licencia de patente 3D de la Fundación Wikimedia: Este archivo y cualquier objeto en 3D representado en el archivo son fruto de mi propio trabajo. Por medio de la presente otorgo a cada usuario, fabricante o distribuidor del objeto representado en el archivo una licencia a nivel mundial, libre de regalías, plenamente liberada, no exclusiva, irrevocable y perpetua sin costo adicional en virtud de cualquier patente o solicitud de patente que sea de mi propiedad actualmente o en el futuro, para hacer, solicitar que se haga, usar, ofrecer en venta, vender, importar y distribuir este archivo y cualquier objeto 3D representado en el archivo que de otra manera infringiría cualquier reclamo de cualquier patente que yo tenga ahora o en el futuro. Téngase en cuenta que en caso de diferencias de significado o interpretación entre la versión original en inglés de esta licencia y una traducción, la versión original en inglés tiene prioridad.

Yo, titular de los derechos de autor de esta obra, la publico en los términos de las siguientes licencias:

Este archivo está disponible bajo la licencia Creative Commons Attribution-Share Alike 4.0 International.

Eres libre:

• de compartir – de copiar, distribuir y transmitir el trabajo
• de remezclar – de adaptar el trabajo

Bajo las siguientes condiciones:

• atribución – Debes otorgar el crédito correspondiente, proporcionar un enlace a la licencia e indicar si realizaste algún cambio. Puedes hacerlo de cualquier manera razonable pero no de manera que sugiera que el licenciante te respalda a ti o al uso que hagas del trabajo.
• compartir igual – En caso de mezclar, transformar o modificar este trabajo, deberás distribuir el trabajo resultante bajo la misma licencia o una compatible como el original.

https://creativecommons.org/licenses/by-sa/4.0CC BY-SA 4.0 Creative Commons Attribution-Share Alike 4.0 truetrue

Se autoriza la copia, distribución y modificación de este documento bajo los términos de la licencia de documentación libre GNU, versión 1.2 o cualquier otra que posteriormente publique la Fundación para el Software Libre; sin secciones invariables, textos de portada, ni textos de contraportada. Se incluye una copia de la dicha licencia en la sección titulada Licencia de Documentación Libre GNU.http://www.gnu.org/copyleft/fdl.htmlGFDLGNU Free Documentation Licensetruetrue

Puedes usar la licencia que prefieras.