Lorsque j'ai été recherché sur Google en pensant que ce serait plus facile si je pouvais créer un modèle sans permission en entrant des nombres, j'ai découvert ce qu'on appelle numpy-stl, alors je l'ai résumé sous forme de mémo.
Une traduction approximative du Document officiel ressemble à ceci.
Une bibliothèque simple pour travailler rapidement et facilement avec des fichiers STL (ainsi que des modèles 3D courants). Toutes les opérations reposent fortement sur numpy et sont l'une des bibliothèques STL les plus rapides pour Python.
En bref, c'est une bibliothèque où vous pouvez créer des modèles 3D comme numpy et jouer avec des fichiers STL existants.
Fondamentalement, pip est OK. Cette fois, je l'ai exécuté sur macOS Catalina 10.15.6, python 3.7.7.
install
pip3 install numpy-stl
Si vous souhaitez vérifier le modèle 3D généré, installez également les bibliothèques suivantes.
install
pip3 install mpl_toolkits
pip3 install matplotlib
Je l'ajouterai quand j'aurai envie de tourner. (Cependant, si vous recherchez sur Google avec numpy-stl, vous verrez pas mal d'articles comme celui-là.)
J'en ai fait une fonction parce que c'était un gros problème. Entrez la taille dans les arguments scale_x, scale_y, scale_z. En fonction du système d'unités, vous devriez pouvoir créer un cube avec une hauteur et une largeur de 1 dans l'état par défaut sans arguments.
cube_model.py
import numpy as np
from stl import mesh
def cube_model(scaleX=1, scaleY=1, scaleZ=1):
scaleX = scaleX / 2
scaleY = scaleY / 2
scaleZ = scaleZ / 2
vertices = np.array([\
[-1*scaleX, -1*scaleY, -1*scaleZ],
[+1*scaleX, -1*scaleY, -1*scaleZ],
[+1*scaleX, +1*scaleY, -1*scaleZ],
[-1*scaleX, +1*scaleY, -1*scaleZ],
[-1*scaleX, -1*scaleY, +1*scaleZ],
[+1*scaleX, -1*scaleY, +1*scaleZ],
[+1*scaleX, +1*scaleY, +1*scaleZ],
[-1*scaleX, +1*scaleY, +1*scaleZ]])
faces = np.array([\
[0,3,1],
[1,3,2],
[0,4,7],
[0,7,3],
[4,5,6],
[4,6,7],
[5,1,2],
[5,2,6],
[2,3,6],
[3,7,6],
[0,1,5],
[0,5,4]])
cube = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype))
cube.remove_duplicate_polygons=True
for i, f in enumerate(faces):
for j in range(3):
cube.vectors[i][j] = vertices[f[j],:]
return cube
Cliquez ici pour le programme à charger
test_plot.py
import numpy as np
from stl import mesh
from mpl_toolkits import mplot3d
from matplotlib import pyplot
from cube_model import cube_model
figure = pyplot.figure()
axes = mplot3d.Axes3D(figure)
your_mesh = cube_model(10,10,10)
axes.add_collection3d(mplot3d.art3d.Poly3DCollection(your_mesh.vectors))
scale = your_mesh.points.flatten()
print(scale)
axes.auto_scale_xyz(scale, scale, scale)
pyplot.show()
Spécifiez votre propre fichier STL dans your_stl_model.stl.
read_stl_file.py
import numpy as np
from stl import mesh
from mpl_toolkits import mplot3d
from matplotlib import pyplot
figure = pyplot.figure()
axes = mplot3d.Axes3D(figure)
your_mesh = mesh.Mesh.from_file('your_stl_model.stl')
axes.add_collection3d(mplot3d.art3d.Poly3DCollection(your_mesh.vectors))
scale = cube_comb.points.flatten()
axes.auto_scale_xyz(scale, scale, scale)
pyplot.show()
Il est utilisé pour aligner le centre du modèle avec (0,0,0) lorsque la STL lue vole dans une direction étrange. Dans l'argument my_mesh, mettez l'objet mesh lors de la lecture du fichier STL etc.
mesh_location_zero.py
import numpy as np
from stl import mesh
def mesh_location_zero(my_mesh):
midPosRel = (my_mesh.max_ - my_mesh.min_)/2
my_mesh.x = my_mesh.x - (midPosRel[0] + my_mesh.min_[0])
my_mesh.y = my_mesh.y - (midPosRel[1] + my_mesh.min_[1])
my_mesh.z = my_mesh.z - (midPosRel[2] + my_mesh.min_[2])
return my_mesh
Étant donné que les membres de l'objet maillé sont mis à jour, cela est également exécuté lors du déplacement, y compris l'ajustement du système de coordonnées, ou lorsque le modèle est agrandi, pivoté ou modifié. Les arguments sont les mêmes.
mesh_update.py
import numpy as np
from stl import mesh
def mesh_update(my_mesh):
my_mesh.update_areas()
my_mesh.update_max()
my_mesh.update_min()
my_mesh.update_units()
return my_mesh
L'élargissement / réduction a également été transformé en fonction. Mettez votre propre modèle 3D dans my_mesh et mettez 1.0 comme 100% dans scale_x, scale_y et scale_z.
mesh_scale.py
import numpy as np
from stl import mesh
def mesh_scale(my_mesh, scale_x, scale_y, scale_z):
my_mesh.x = my_mesh.x * scale_x
my_mesh.y = my_mesh.y * scale_y
my_mesh.z = my_mesh.z * scale_z
return my_mesh
Vous pouvez le déplacer avec mesh.translate. L'argument est spécifié dans numpy.array. (Cette fois, j'utilise également cube_model.py.)
move_model.py
import numpy as np
from stl import mesh
from mpl_toolkits import mplot3d
from matplotlib import pyplot
from cube_model import cube_model
figure = pyplot.figure()
axes = mplot3d.Axes3D(figure)
your_mesh = cube_model(5,20,5)
your_mesh.translate(np.array([1,3,1]))
axes.add_collection3d(mplot3d.art3d.Poly3DCollection(your_mesh.vectors))
scale = cube_comb.points.flatten()
print(scale)
axes.auto_scale_xyz(scale, scale, scale)
pyplot.show()
Vous pouvez combiner des modèles avec numpy.concatenate. Je vends juste que je puisse faire un modèle avec numpy. (Cette fois, j'utilise également cube_model.py.)
mesh_scale.py
import numpy as np
from stl import mesh
from mpl_toolkits import mplot3d
from matplotlib import pyplot
from cube_model import cube_model
figure = pyplot.figure()
axes = mplot3d.Axes3D(figure)
your_mesh = cube_model(10,10,10)
your_mesh2 = cube_model(5,20,5)
your_mesh2.translate(np.array([1,1,1]))
cube_comb = mesh.Mesh(np.concatenate([
your_mesh.data.copy(),
your_mesh2.data.copy(),
]))
axes.add_collection3d(mplot3d.art3d.Poly3DCollection(cube_comb.vectors))
scale = cube_comb.points.flatten()
print(scale)
axes.auto_scale_xyz(scale, scale, scale)
pyplot.show()
Peut être enregistré avec mesh.save. Les arguments sont le chemin de destination de l'enregistrement et le nom du fichier.
save_model.py
import numpy as np
from stl import mesh
from cube_model import cube_model
your_mesh = cube_model(10,10,10)
your_mesh2 = cube_model(5,20,5)
your_mesh2.translate(np.array([1,1,1]))
cube_comb = mesh.Mesh(np.concatenate([
your_mesh.data.copy(),
your_mesh2.data.copy(),
]))
cube_comb.save('your_model.stl')
J'ai essayé de diffuser les données STL créées dans le logiciel "XYZprint" utilisé pour diffuser les données de modélisation avec une imprimante 3D fabriquée par XYZprinting. Je suis heureux de pouvoir créer correctement les données laminées.
Cette fois, j'ai essayé d'utiliser numpy-stl. S'il y a d'autres opérations que vous pourriez utiliser en général, ajoutez-les quand vous en avez envie.
Recommended Posts