def meshwrite_binary(filename, verts, faces):
# print "type(verts): ", type(verts)
# print "verts.shape: ", verts.shape
# print "faces.shape: ", faces.shape
#
# print "verts[0,:] = ", verts[0, :]
# print "faces[0,:] = ", faces[0, :]
# permute faces to get visualization
# faces = np.flip(faces, 1)
# converting numpy arrays to format for ply file
num_verts = verts.shape[0]
num_faces = faces.shape[0]
verts_tuple = np.zeros((num_verts, ),
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
faces_tuple = np.zeros((num_faces, ),
dtype=[('vertex_indices', 'i4', (3, ))])
for i in xrange(0, num_verts):
verts_tuple[i] = tuple(verts[i, :])
for i in xrange(0, num_faces):
faces_tuple[i] = faces[i, :].tolist()
# save it out
el_verts = PlyElement.describe(verts_tuple, 'vertex')
el_faces = PlyElement.describe(faces_tuple, 'face')
ply_data = PlyData([el_verts, el_faces])
# ply_data = PlyData([el_verts, el_faces], text=True)
ply_data.write(filename)
def visualize(coords, labels):
palette = create_color_palette()
nyu_to_scannet = get_nyu_to_scannet()
vertex = []
for i in range(coords.shape[0]):
vertex.append(
(
coords[i][0],
coords[i][1],
coords[i][2],
palette[SCANNET_LABELS[nyu_to_scannet[labels[i]]]][0],
palette[SCANNET_LABELS[nyu_to_scannet[labels[i]]]][1],
palette[SCANNET_LABELS[nyu_to_scannet[labels[i]]]][2]
)
)
vertex = np.array(
vertex,
dtype=[
("x", np.dtype("float32")),
("y", np.dtype("float32")),
("z", np.dtype("float32")),
("red", np.dtype("uint8")),
("green", np.dtype("uint8")),
("blue", np.dtype("uint8"))
]
)
output_pc = PlyElement.describe(vertex, "vertex")
output_pc = PlyData([output_pc])
os.makedirs(PC_LABEL_ROOT, exist_ok=True)
output_pc.write(PC_LABEL_PATH.format(args.scene_id))
def draw_building_no_windows():
counter = 0
ifc = getJson('duplex_A_reformat.json')
o = ifc['Objects']
r = ifc['ShapeRepresentations']
all_verts = []
all_faces = []
for id in o:
if o[id]['Class'] != 'Window':
shape_id = o[id]['Representations'][0]['ref']
shape_rep = r[shape_id]
tuple_verts = shape_rep['Vertices']
tuple_verts = [(x, y, z) for [x, y, z] in tuple_verts]
all_verts += tuple_verts
faces = shape_rep['Faces']
faces = [list(np.array(face) + counter) for face in faces]
counter += len(tuple_verts)
faces = [(f, 0, 0, 0) for f in faces]
all_faces += faces
all_verts = np.array(all_verts,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
all_faces = np.array(all_faces,
dtype=[('vertex_indices', 'i4', (3, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
v = PlyElement.describe(all_verts, 'vertex')
f = PlyElement.describe(all_faces, 'face')
ply1 = PlyData([v, f])
ply1.write('ply1.ply')
mesh = o3d.io.read_triangle_mesh("ply1.ply")
mesh.compute_vertex_normals()
o3d.visualization.draw_geometries([mesh])
def draw_building(o, r):
o = copy.deepcopy(o)
r = copy.deepcopy(r)
counter = 0
all_verts = []
all_faces = []
for id in o:
shape_id = o[id]['Representations'][0]['ref']
shape_rep = r[shape_id]
verts, faces, counter = format_faces_verts(shape_rep, counter)
all_verts += verts
all_faces += faces
all_verts = np.array(all_verts,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
all_faces = np.array(all_faces,
dtype=[('vertex_indices', 'i4', (3, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
v = PlyElement.describe(all_verts, 'vertex')
f = PlyElement.describe(all_faces, 'face')
ply1 = PlyData([v, f])
ply1.write('ply1.ply')
mesh = o3d.io.read_triangle_mesh("ply1.ply")
mesh.compute_vertex_normals()
o3d.visualization.draw_geometries([mesh], mesh_show_back_face=True)
return mesh
def main(filename):
# Load .PLY with "plyfile"
plydata = PlyData.read(filename)
vx = plydata['vertex']['x']
vy = plydata['vertex']['y']
vz = plydata['vertex']['z']
verts = np.stack([vx, vy, vz], axis=1).astype('double')
faces = np.concatenate(plydata['face']['vertex_indices']).astype('uint32')
# Construct halfedge structure by "tinymesh"
mesh = Mesh(verts, faces)
# Get vertices and indices back to Python
verts = mesh.get_vertices()
faces = mesh.get_vertex_indices()
verts = np.asarray(verts, dtype='float32')
faces = np.asarray(faces, dtype='int32').reshape((-1, 3))
vert_el = np.array([tuple(v) for v in verts], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face_el = np.array([(tuple(f), ) for f in faces], dtype=[('vertex_indices', 'i4', (3, ))])
plydata = PlyData(
[PlyElement.describe(vert_el, 'vertex'),
PlyElement.describe(face_el, 'face')], text=False)
base, ext = os.path.splitext(filename)
outfile = base + "_copy" + ext
plydata.write(outfile)
def export_ply(pc, filename):
vertex = np.zeros(pc.shape[0], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2])
ply_out = PlyData([PlyElement.describe(vertex, 'vertex', comments=['vertices'])])
ply_filename = filename[:-4] + '.ply'
ply_out.write(ply_filename)
def embedding2ply(filename, xyz, embeddings):
"""write a ply with colors corresponding to geometric features"""
if embeddings.shape[1] > 3:
pca = PCA(n_components=3)
#pca.fit(np.eye(embeddings.shape[1]))
pca.fit(
np.vstack((np.zeros(
(embeddings.shape[1], )), np.eye(embeddings.shape[1]))))
embeddings = pca.transform(embeddings)
#value = (embeddings-embeddings.mean(axis=0))/(2*embeddings.std())+0.5
#value = np.minimum(np.maximum(value,0),1)
#value = (embeddings)/(3 * embeddings.std())+0.5
value = np.minimum(np.maximum((embeddings + 1) / 2, 0), 1)
color = np.array(255 * value, dtype='uint8')
prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')]
vertex_all = np.empty(len(xyz), dtype=prop)
for i in range(0, 3):
vertex_all[prop[i][0]] = xyz[:, i]
for i in range(0, 3):
vertex_all[prop[i + 3][0]] = color[:, i]
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')], text=True)
ply.write(filename)
def visualize(args, preds):
vertex = []
for i in range(preds.shape[0]):
vertex.append((
preds[i][0],
preds[i][1],
preds[i][2],
preds[i][3],
preds[i][4],
preds[i][5],
))
vertex = np.array(vertex,
dtype=[("x", np.dtype("float32")),
("y", np.dtype("float32")),
("z", np.dtype("float32")),
("red", np.dtype("uint8")),
("green", np.dtype("uint8")),
("blue", np.dtype("uint8"))])
output_pc = PlyElement.describe(vertex, "vertex")
output_pc = PlyData([output_pc])
output_root = os.path.join(CONF.OUTPUT_ROOT, args.folder, "preds")
os.makedirs(output_root, exist_ok=True)
output_pc.write(os.path.join(output_root, "{}.ply".format(args.scene_id)))
def error2ply(filename, xyz, rgb, labels, prediction):
"""write a ply with green hue for correct classifcation and red for error"""
if len(prediction.shape) > 1 and prediction.shape[1] > 1:
prediction = np.argmax(prediction, axis = 1)
if len(labels.shape) > 1 and labels.shape[1] > 1:
labels = np.argmax(labels, axis = 1)
color_rgb = rgb/255;
for i_ver in range(0, len(labels)):
color_hsv = list(colorsys.rgb_to_hsv(color_rgb[i_ver,0], color_rgb[i_ver,1], color_rgb[i_ver,2]))
if (labels[i_ver] == prediction[i_ver]) or (labels[i_ver]==0):
color_hsv[0] = 0.333333
else:
color_hsv[0] = 0
color_hsv[1] = min(1, color_hsv[1] + 0.3);
color_hsv[2] = min(1, color_hsv[2] + 0.1);
color_rgb[i_ver,:] = list(colorsys.hsv_to_rgb(color_hsv[0], color_hsv[1], color_hsv[2]))
color_rgb = np.array(color_rgb*255, dtype='u1');
prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
vertex_all = np.empty(len(xyz), dtype=prop)
for i in range(0, 3):
vertex_all[prop[i][0]] = xyz[:, i]
for i in range(0, 3):
vertex_all[prop[i+3][0]] = color_rgb[:, i]
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')], text=True)
ply.write(filename)
def save_ply(path, points, colors=None):
if torch.is_tensor(points):
points = points.cpu().numpy()
if colors is not None:
if torch.is_tensor(colors):
colors = colors.cpu().numpy()
colors = (colors * 255.0).astype(np.uint8)
points_descr = [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]
if colors is None:
dtype_descr = points_descr
else:
colors_descr = [('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
dtype_descr = points_descr + colors_descr
vertex = np.empty(len(points), dtype=dtype_descr)
vertex['x'] = points[:, 0]
vertex['y'] = points[:, 1]
vertex['z'] = points[:, 2]
if colors is not None:
vertex['red'] = colors[:, 0]
vertex['green'] = colors[:, 1]
vertex['blue'] = colors[:, 2]
data = PlyData([
PlyElement.describe(
vertex,
'vertex',
),
], )
data.write(str(path))
def tet_ply():
vertices = []
faces = []
vb0, fb0 = writeBone(0, 0, 0, 0, 0, 0, 4)
vb1, fb1 = writeBone(1, 0, 0, 0, 1, 4, 2)
vertices += vb0
vertices += vb1
faces += fb0
faces += fb1
vertex = numpy.array(vertices,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = numpy.array(faces,
dtype=[('vertex_indices', 'i4', (4, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
data = PlyData([
PlyElement.describe(
vertex, 'vertex', comments=['a skeleton pfnn vertices']),
PlyElement.describe(face, 'face')
],
text="some text",
comments=['a skeleton pfnn'])
print(data['vertex'][0])
data.write('test.ply')
return data
def save_ply_cloud(points, gt, filename):
vertex_ = np.zeros(points.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
joints_position = np.zeros(int(gt.shape[0] / 3),
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
gto = np.zeros(gt.shape[0], dtype=[('gt', 'f4')])
for i in range(points.shape[0]):
vertex_[i] = (points[i][0], points[i][1], points[i][2])
for i in range(joints_position.shape[0]):
joints_position[i] = (gt[i * 3], gt[i * 3 + 1], gt[i * 3 + 2])
gto[i] = gt[i]
gto[i * 3 + 1] = gt[i * 3 + 1]
gto[i * 3 + 2] = gt[i * 3 + 2]
#gt_ = np.zeros(points.shape[0], dtype=[('gt', 'f4')])
#gt_ = gt
e1 = PlyElement.describe(vertex_, 'vertex', comments=['vertices'])
e2 = PlyElement.describe(gto, 'gt', comments=['GroundTruth'])
e3 = PlyElement.describe(joints_position,
'jointsp',
comments=['Joints Position'])
ply_out = PlyData([e1, e2, e3])
ply_out.write(filename)
def save_pointcloud_colored(point_cloud, filename, points_per_patch):
# Vertices
vertex = np.array([tuple(x) for x in point_cloud.tolist()],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
# Colors: 1 random color per patch
num_activated_voxels = vertex.shape[0] // points_per_patch
colors = np.random.randint(0, 255, (num_activated_voxels, 3)).repeat(
points_per_patch, axis=0)
vertex_color = np.array([tuple(x) for x in colors],
dtype=[('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
# Fuse verts+colors arrays
num_verts = len(vertex)
vertex_all = np.empty(num_verts,
vertex.dtype.descr + vertex_color.dtype.descr)
for prop in vertex.dtype.names:
vertex_all[prop] = vertex[prop]
for prop in vertex_color.dtype.names:
vertex_all[prop] = vertex_color[prop]
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')])
ply.write(filename)
def meshwrite_color_binary(filename, verts, faces, norms, colors):
# print "type(verts): ", type(verts)
# print "verts.shape: ", verts.shape
# print "faces.shape: ", faces.shape
#
# print "verts[0,:] = ", verts[0, :]
# print "faces[0,:] = ", faces[0, :]
# permute faces to get visualization
# faces = np.flip(faces, 1)
# converting numpy arrays to format for ply file
# num_verts = num_colors
num_verts = verts.shape[0]
num_colors = colors.shape[0]
assert num_verts == num_colors
num_faces = faces.shape[0]
num_norms = norms.shape[0]
verts_tuple = np.zeros((num_verts, ),
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
faces_tuple = np.zeros((num_faces, ),
dtype=[('vertex_indices', 'i4', (3, ))])
norms_tuple = np.zeros((num_norms, ),
dtype=[('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4')])
colors_tuple = np.zeros((num_colors, ),
dtype=[('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
for i in xrange(0, num_verts):
verts_tuple[i] = tuple(verts[i, :])
colors_tuple[i] = tuple(colors[i, :])
for i in xrange(0, num_norms):
norms_tuple[i] = tuple(norms[i, :])
for i in xrange(0, num_faces):
faces_tuple[i] = faces[i, :].tolist()
# merge color to vertex
vertex_all = np.empty(
num_verts, verts_tuple.dtype.descr + norms_tuple.dtype.descr +
colors_tuple.dtype.descr)
for prop in verts_tuple.dtype.names:
vertex_all[prop] = verts_tuple[prop]
for prop in norms_tuple.dtype.names:
vertex_all[prop] = norms_tuple[prop]
for prop in colors_tuple.dtype.names:
vertex_all[prop] = colors_tuple[prop]
# save it out
el_verts = PlyElement.describe(vertex_all, 'vertex')
el_faces = PlyElement.describe(faces_tuple, 'face')
ply_data = PlyData([el_verts, el_faces])
# ply_data = PlyData([el_verts, el_faces], text=True)
ply_data.write(filename)
def export_pointcloud(vertices, out_file, as_text=True):
assert (vertices.shape[1] == 3)
vertices = vertices.astype(np.float32)
vector_dtype = [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]
vertices = vertices.view(dtype=vector_dtype).flatten()
plyel = PlyElement.describe(vertices, 'vertex')
plydata = PlyData([plyel], text=as_text)
plydata.write(out_file)
def export_ply(pc, filename):
vertex = np.zeros(pc.shape[0],
dtype=[("x", "f4"), ("y", "f4"), ("z", "f4")])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2])
ply_out = PlyData(
[PlyElement.describe(vertex, "vertex", comments=["vertices"])])
ply_out.write(filename)
def save_ply_file(data, filename):
vertex = np.zeros(data.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(data.shape[0]):
vertex[i] = (data[i][0], data[i][1], data[i][2])
ply_out = PlyData(
[PlyElement.describe(vertex, 'vertex', comments=['vertices'])])
ply_out.write(filename)
def export_ply(pc, filename):
"""
export .ply from a point cloud
"""
vertex = np.zeros(pc.shape[0], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2])
ply_out = PlyData([PlyElement.describe(vertex, 'vertex', comments=['vertices'])])
ply_out.write(filename)
def scalar2ply(filename, xyz, scalar):
"""write a ply with an unisgned integer scalar field"""
prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('scalar', 'f4')]
vertex_all = np.empty(len(xyz), dtype=prop)
for i in range(0, 3):
vertex_all[prop[i][0]] = xyz[:, i]
vertex_all[prop[3][0]] = scalar
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')], text=True)
ply.write(filename)
def write_ply(filename, xyz, rgb):
"""write into a ply file"""
prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
vertex_all = np.empty(len(xyz), dtype=prop)
for i_prop in range(0, 3):
vertex_all[prop[i_prop][0]] = xyz[:, i_prop]
for i_prop in range(0, 3):
vertex_all[prop[i_prop+3][0]] = rgb[:, i_prop]
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')], text=True)
ply.write(filename)
def test_obj_info(tmpdir):
ply0 = PlyData([], text=True, obj_info=["test obj_info"])
test_file = tmpdir.join("test.ply")
ply0.write(str(test_file))
ply0_str = test_file.read("rb").decode("ascii")
assert ply0_str.startswith("ply\r\nformat ascii 1.0\r\n" "obj_info test obj_info\r\n")
ply1 = PlyData.read(str(test_file))
assert len(ply1.obj_info) == 1
assert ply1.obj_info[0] == "test obj_info"
def geof2ply(filename, xyz, geof):
"""write a ply with colors corresponding to geometric features"""
color = np.array(255 * geof[:, [0, 1, 3]], dtype='uint8')
prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')]
vertex_all = np.empty(len(xyz), dtype=prop)
for i in range(0, 3):
vertex_all[prop[i][0]] = xyz[:, i]
for i in range(0, 3):
vertex_all[prop[i+3][0]] = color[:, i]
ply = PlyData([PlyElement.describe(vertex_all, 'vertex')], text=True)
ply.write(filename)
def save_ply(self, filename):
vertex = np.array([tuple(i) for i in self.v],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = np.array([(tuple(i), 255, 255, 255) for i in self.f],
dtype=[('vertex_indices', 'i4', (3, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex')
el2 = PlyElement.describe(face, 'face')
plydata = PlyData([el, el2])
plydata.write(filename)
def spg2ply(filename, spg_graph):
"""write a ply displaying the SPG by adding edges between its centroid"""
vertex_prop = [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]
vertex_val = np.empty((spg_graph['sp_centroids']).shape[0], dtype=vertex_prop)
for i in range(0, 3):
vertex_val[vertex_prop[i][0]] = spg_graph['sp_centroids'][:, i]
edges_prop = [('vertex1', 'int32'), ('vertex2', 'int32')]
edges_val = np.empty((spg_graph['source']).shape[0], dtype=edges_prop)
edges_val[edges_prop[0][0]] = spg_graph['source'].flatten()
edges_val[edges_prop[1][0]] = spg_graph['target'].flatten()
ply = PlyData([PlyElement.describe(vertex_val, 'vertex'), PlyElement.describe(edges_val, 'edge')], text=True)
ply.write(filename)
def export_ply(pc, filename):
vertex = np.zeros(pc.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'uint8'), ('green', 'uint8'),
('blue', 'uint8')])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2], pc[i][3], pc[i][4],
pc[i][5])
ply_out = PlyData(
[PlyElement.describe(vertex, 'vertex', comments=['vertices'])],
text=True)
ply_out.write(filename)
def to_ply(dct, path):
verts = np.array(numpy_to_tuple_list(dct['verts']),
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
faces = np.array([(list(it), )
for it in numpy_to_tuple_list(dct['faces'])],
dtype=[('vertex_indices', 'i4', (3, ))])
plydata = PlyData([
PlyElement.describe(verts, 'vertex'),
PlyElement.describe(faces, 'face')
],
text=True)
plydata.write(path)
def test_comment_spaces(tmpdir):
ply0 = PlyData([], text=True, comments=[' test comment'])
test_file = tmpdir.join('test.ply')
ply0.write(str(test_file))
ply0_str = test_file.read('rb').decode('ascii')
assert ply0_str.startswith('ply\nformat ascii 1.0\n'
'comment test comment\n')
ply1 = PlyData.read(str(test_file))
assert len(ply1.comments) == 1
assert ply1.comments[0] == ' test comment'
def test_obj_info(tmpdir):
ply0 = PlyData([], text=True, obj_info=['test obj_info'])
test_file = tmpdir.join('test.ply')
ply0.write(str(test_file))
ply0_str = test_file.read('rb').decode('ascii')
assert ply0_str.startswith('ply\nformat ascii 1.0\n'
'obj_info test obj_info\n')
ply1 = PlyData.read(str(test_file))
assert len(ply1.obj_info) == 1
assert ply1.obj_info[0] == 'test obj_info'
def writePFNNSkeletonPly(poseData, outTextFile, scaleConstant, sizeFactor):
# Invert Y and Z axis and convert to meters
for i in range(31):
y = poseData[i * 3 + 1]
z = poseData[i * 3 + 2]
poseData[i * 3 + 1] = z
poseData[i * 3 + 2] = y
for j in range(3):
poseData[i * 3 + j] *= scaleConstant
parents = [
-1, 0, 1, 2, 3, 4, 0, 6, 7, 8, 9, 0, 11, 12, 13, 14, 15, 13, 17, 18,
19, 20, 21, 20, 13, 24, 25, 26, 27, 28, 27
]
vertices = []
faces = []
counter = 0
for boneId in range(31):
boneParent = parents[boneId]
if boneParent == -1:
continue
x0, y0, z0 = poseData[boneId * 3 +
0], poseData[boneId * 3 +
1], poseData[boneId * 3 + 2]
x1, y1, z1 = poseData[boneParent * 3 +
0], poseData[boneParent * 3 +
1], poseData[boneParent * 3 + 2]
vb, fb = writeBone(counter, x0, y0, z0, x1, y1, z1, sizeFactor)
counter += 1
vertices += vb
faces += fb
vertex = numpy.array(vertices,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = numpy.array(faces,
dtype=[('vertex_indices', 'i4', (4, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
data = PlyData([
PlyElement.describe(
vertex, 'vertex', comments=['a skeleton pfnn vertices']),
PlyElement.describe(face, 'face')
],
text="some text",
comments=['a skeleton pfnn'])
data.write(outTextFile)
def export_ply(vertices, diffuse, normals, filename):
names = 'x, y, z, nx, ny, nz, red, green, blue'
formats = 'f4, f4, f4, f4, f4, f4, u1, u1, u1'
arr = np.concatenate((vertices, normals, diffuse * 255), axis = -1)
vertices_s = np.core.records.fromarrays(arr.transpose(), names = names, formats = formats)
# Recreate the PlyElement instance
v = PlyElement.describe(vertices_s, 'vertex')
# Create the PlyData instance
p = PlyData([ v ], text = True)
p.write(filename)
def save_ply_cloud(points, colors, filename):
vertex = np.zeros(points.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
for i in range(points.shape[0]):
vertex[i] = (points[i][0], points[i][1], points[i][2], colors[i][0],
colors[i][1], colors[i][2])
ply_out = PlyData(
[PlyElement.describe(vertex, 'vertex', comments=['vertices'])])
ply_out.write(filename)
def save_ply(self, filename):
vertex = np.array([tuple(i) for i in self.v], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = np.array([(tuple(i), 0, 100, 255) for i in self.f] ,
dtype=[('vertex_indices', 'i4', (3,)),
('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
edge = np.array([(tuple(i)[0], tuple(i)[1], 255, 255, 255) for i in self.e] ,
dtype=[('vertex1', 'i4'), ('vertex2', 'i4'),
('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex')
el2 = PlyElement.describe(face, 'face')
el3 = PlyElement.describe(edge, 'edge')
plydata = PlyData([el, el2, el3])
plydata.write(filename)
def export_ply(pc, filename):
vertex = np.zeros(pc.shape[0], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2])
ply_out = PlyData([PlyElement.describe(vertex, 'vertex', comments=['vertices'])])
ply_out.write(filename)
([0, 1, 3], 0, 255, 0),
([1, 2, 3], 0, 0, 255)],
dtype=[('vertex_indices', 'i4', (3,)),
('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
print "Assembling initial PlyData instance..."
ply0 = PlyData([PlyElement.describe(vertex, 'vertex',
comments=['tetrahedron vertices']),
PlyElement.describe(face, 'face')],
text=True,
comments=['single tetrahedron with colored faces'])
print "Writing test0.ply (ascii)..."
ply0.write('test0.ply')
print "Reading test0.ply..."
ply1 = PlyData.read('test0.ply')
print "(verifying result...)"
verify(ply0, ply1)
print "Writing test1.ply (binary_little_endian)..."
ply1.text = False
ply1.byte_order = '<'
ply1.write('test1.ply')
print "Reading test1.ply..."
ply2 = PlyData.read('test1.ply')
