def render_wireframe(mesh, up_vector=(0, 1, 0)):
geometry = build_geometry(
mesh.triangles,
mesh.positions,
normals=getattr(mesh, "normals", None),
colors=getattr(mesh, "colors", None),
)
obj = three.LineSegments(
geometry=three.WireframeGeometry(geometry),
material=three.LineBasicMaterial(color="green"),
position=[0, 0, 0],
)
center = np.array(mesh.positions).reshape(-1, 3).mean(axis=0)
offset = 8 * np.array(mesh.positions).reshape(-1, 3).std(axis=0)
return render_scene(Scene(eye_pos=center + offset, obj_pos=center, obj=obj, up=up_vector))
def surf2mesh(S, P=(0, 0, 0), D=(0, 0, 0), wire=False):
color = "#ffff00"
points, polylist = S.polylist()
#Conversion para quethreejs la entienda
polylist = list(polylist)
lpoly = []
lpoints = []
for l in points:
lpoints.append(list(l))
for l in polylist:
lpoly.append(list(map(int, l)))
vertices = lpoints
faces = lpoly
# Map the vertex colors into the 'color' slot of the faces
# Map the normals
nfaces = []
for f in faces:
p0 = points[f[0]]
p1 = points[f[1]]
p2 = points[f[2]]
v0 = array(p1) - array(p0)
v1 = array(p2) - array(p0)
v3 = cross(v0, v1)
v3 = tuple(v3 / sqrt(v3[0]**2 + v3[1]**2 + v3[2]**2))
nfaces.append(f + [v3, color, None])
# Create the geometry:
surfaceGeometry = py3js.Geometry(
vertices=vertices,
faces=nfaces,
#colors=vertexcolors
)
#surfaceGeometry = py3js.SphereGeometry(radius=300, widthSegments=32, heightSegments=24)
if wire:
surfaceGeometry = py3js.WireframeGeometry(surfaceGeometry)
# Calculate normals per face, for nice crisp edges:
surfaceGeometry.exec_three_obj_method('computeFaceNormals')
surfaceMaterial = py3js.MeshPhongMaterial(color=color,
ambient="#050505",
specular="#ffffff",
shininess=15,
emissive="#000000",
side='DoubleSide',
transparent=True,
opacity=.8)
#surfaceMaterial = py3js.MeshLambertMaterial(color='red',side='DoubleSide')
# Create a mesh. Note that the material need to be told to use the vertex colors.
surfaceMesh = py3js.Mesh(
geometry=surfaceGeometry,
material=surfaceMaterial,
)
surfaceMesh.rotation = *D, "ZYX"
surfaceMesh.position = tuple(P)
return surfaceMesh
def add_mesh(self, v, f, c=None, uv=None, shading={}, texture_data=None):
sh = self.__get_shading(shading)
mesh_obj = {}
#it is a tet
if v.shape[1] == 3 and f.shape[1] == 4:
f_tmp = np.ndarray([f.shape[0]*4, 3], dtype=f.dtype)
for i in range(f.shape[0]):
f_tmp[i*4+0] = np.array([f[i][1], f[i][0], f[i][2]])
f_tmp[i*4+1] = np.array([f[i][0], f[i][1], f[i][3]])
f_tmp[i*4+2] = np.array([f[i][1], f[i][2], f[i][3]])
f_tmp[i*4+3] = np.array([f[i][2], f[i][0], f[i][3]])
f = f_tmp
if v.shape[1] == 2:
v = np.append(v, np.zeros([v.shape[0], 1]), 1)
# Type adjustment vertices
v = v.astype("float32", copy=False)
# Color setup
colors, coloring = self.__get_colors(v, f, c, sh)
# Type adjustment faces and colors
c = colors.astype("float32", copy=False)
# Material and geometry setup
ba_dict = {"color": p3s.BufferAttribute(c)}
if coloring == "FaceColors":
verts = np.zeros((f.shape[0]*3, 3), dtype="float32")
for ii in range(f.shape[0]):
#print(ii*3, f[ii])
verts[ii*3] = v[f[ii,0]]
verts[ii*3+1] = v[f[ii,1]]
verts[ii*3+2] = v[f[ii,2]]
v = verts
else:
f = f.astype("uint32", copy=False).ravel()
ba_dict["index"] = p3s.BufferAttribute(f, normalized=False)
ba_dict["position"] = p3s.BufferAttribute(v, normalized=False)
if type(uv) != type(None):
uv = (uv - np.min(uv)) / (np.max(uv) - np.min(uv))
if texture_data is None:
texture_data = gen_checkers(20, 20)
tex = p3s.DataTexture(data=texture_data, format="RGBFormat", type="FloatType")
material = p3s.MeshStandardMaterial(map=tex, reflectivity=sh["reflectivity"], side=sh["side"],
roughness=sh["roughness"], metalness=sh["metalness"], flatShading=sh["flat"],
polygonOffset=True, polygonOffsetFactor= 1, polygonOffsetUnits=5)
ba_dict["uv"] = p3s.BufferAttribute(uv.astype("float32", copy=False))
else:
material = p3s.MeshStandardMaterial(vertexColors=coloring, reflectivity=sh["reflectivity"],
side=sh["side"], roughness=sh["roughness"], metalness=sh["metalness"],
flatShading=sh["flat"],
polygonOffset=True, polygonOffsetFactor= 1, polygonOffsetUnits=5)
geometry = p3s.BufferGeometry(attributes=ba_dict)
if coloring == "VertexColors":
geometry.exec_three_obj_method('computeVertexNormals')
else:
geometry.exec_three_obj_method('computeFaceNormals')
# Mesh setup
mesh = p3s.Mesh(geometry=geometry, material=material)
# Wireframe setup
mesh_obj["wireframe"] = None
if sh["wireframe"]:
wf_geometry = p3s.WireframeGeometry(mesh.geometry) # WireframeGeometry
wf_material = p3s.LineBasicMaterial(color=sh["wire_color"], linewidth=sh["wire_width"])
wireframe = p3s.LineSegments(wf_geometry, wf_material)
mesh.add(wireframe)
mesh_obj["wireframe"] = wireframe
# Bounding box setup
if sh["bbox"]:
v_box, f_box = self.__get_bbox(v)
_, bbox = self.add_edges(v_box, f_box, sh, mesh)
mesh_obj["bbox"] = [bbox, v_box, f_box]
# Object setup
mesh_obj["max"] = np.max(v, axis=0)
mesh_obj["min"] = np.min(v, axis=0)
mesh_obj["geometry"] = geometry
mesh_obj["mesh"] = mesh
mesh_obj["material"] = material
mesh_obj["type"] = "Mesh"
mesh_obj["shading"] = sh
mesh_obj["coloring"] = coloring
mesh_obj["arrays"] = [v, f, c] # TODO replays with proper storage or remove if not needed
return self.__add_object(mesh_obj)
