def write_ply_file(points):
'''
Given a string of comma-separated values that represent 2d points, parse
the string, create a ply file in the temp storage directory representing
the shape formed by the string, and return the filepath.
'''
import voxel_globe.tools
with voxel_globe.tools.storage_dir('event_trigger_ply') as ply_dir:
num_files = len([name for name in os.listdir(ply_dir)])
filepath = os.path.join(ply_dir, 'mesh_%d.ply' % num_files)
import numpy
import plyfile
from plyfile import PlyData, PlyElement
vertex = numpy.array(points,
dtype=[('x', 'double'), ('y', 'double'),
('z', 'double')])
face = numpy.array([(range(len(points)),)], [('vertex_indices', '|O')])
el1 = PlyElement.describe(vertex, 'vertex')
el2 = PlyElement.describe(face, 'face')
PlyData([el1, el2], text=True, comments=['mesh-feature'],
obj_info=['a bmsh3d_mesh object']).write(filepath)
return filepath
def tet_ply(text, byte_order):
vertex = numpy.array([(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)], dtype=[("x", "f4"), ("y", "f4"), ("z", "f4")])
face = numpy.array(
[([0, 1, 2], 255, 255, 255), ([0, 2, 3], 255, 0, 0), ([0, 1, 3], 0, 255, 0), ([1, 2, 3], 0, 0, 255)],
dtype=[("vertex_indices", "i4", (3,)), ("red", "u1"), ("green", "u1"), ("blue", "u1")],
)
return PlyData(
[PlyElement.describe(vertex, "vertex", comments=["tetrahedron vertices"]), PlyElement.describe(face, "face")],
text=text,
byte_order=byte_order,
comments=["single tetrahedron with colored faces"],
)
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 get_face_ele(vidx_per_face, face_label, extra):
# face
num_face = vidx_per_face.shape[0]
vnpf = vidx_per_face.shape[1]
assert vnpf > 2
is_face_color = face_label is not None
if is_face_color:
if face_label is not None:
if extra == 'label_color_default':
face_label = np.squeeze(face_label)
face_color = np.take(color_dic.rgb_order, face_label, 0)
face = np.zeros(shape=(num_face)).astype(
dtype=[('vertex_indices', 'i4',
(vnpf, )), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
else:
face = np.zeros(shape=(num_face)).astype(dtype=[('vertex_indices',
'i4', (vnpf, ))])
for i in range(num_face):
if is_face_color:
face[i] = (vidx_per_face[i], face_color[i, 0], face_color[i, 1],
face_color[i, 2])
else:
face[i] = (vidx_per_face[i], )
el_face = PlyElement.describe(face, 'face')
return el_face
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 visualize(ids, mesh_file, output_file):
if not output_file.endswith('.ply'):
sys.stderr.write('ERROR: ' + 'output file must be a .ply file' + '\n')
colors = NYU40_colors.create_color_palette_legend()
num_colors = len(colors)
with open(mesh_file, 'rb') as f:
plydata = PlyData.read(f)
vert = plydata['vertex'] #same as plydata.elements[0]
faces = plydata.elements[1]
num_verts = plydata['vertex'].count
if num_verts != len(ids):
sys.stderr.write('ERROR: ' + '#predicted labels = ' + str(len(ids)) + 'vs #mesh vertices = ' + str(num_verts))
# *_vh_clean_2.ply has colors already, save label id instead of alpha value
for i in range(num_verts):
if ids[i]+1 >= num_colors:
sys.stderr.write('ERROR: ' + 'found predicted label ' + str(ids[i]) + ' not in nyu40 label set')
color = colors[ids[i]+1]
plydata['vertex']['red'][i] = color[0]
plydata['vertex']['green'][i] = color[1]
plydata['vertex']['blue'][i] = color[2]
#add the label field to the ply file
(x, y, z, r, g, b, alpha) = (vert[t] for t in ('x', 'y', 'z', 'red', 'green', 'blue', 'alpha'))
new_data = np.column_stack((x,y,z,r,g,b,ids))
points_tuple = list([tuple(row) for row in new_data])
new_points = np.core.records.fromrecords(points_tuple,
names='x,y,z,red,green,blue,label',
formats='f4,f4,f4,u1,u1,u1,u1')
el = PlyElement.describe(new_points, 'vertex')
PlyData([el, faces], text=False).write(output_file)
def merge_point_clouds(base_dir, out_path=None, adjustment=False):
print('merging point clouds for dir {}'.format(base_dir))
extrinsics_path = osp.join(base_dir, 'final_extrinsics.txt')
extrinsics = get_extrinsics(extrinsics_path)
all_pc = list()
for location_i, extrinsic in enumerate(extrinsics):
ply_path = osp.join(base_dir, 'derived/{}/output.ply'.format(location_i))
transformed_pc = pc_transfrom(read_file=True, pc_file=ply_path, trans_matrix=extrinsic)
all_pc.append(transformed_pc)
all_pc = np.concatenate(all_pc, axis=0)
adjustment_trans_mat = np.array([[1, 0, 0, 0],
[0, 0, 1, 0],
[0, -1, 0, 0],
[0, 0, 0, 1]])
all_pc = pc_transfrom(read_file=False, pc_file=all_pc, trans_matrix=adjustment_trans_mat, downsample=False)
vertex_el = PlyElement.describe(all_pc, 'vertex')
if not out_path:
out_path = osp.join(base_dir, 'output_all.ply')
PlyData([vertex_el]).write(out_path) # write the new ply file
print('write merged ply file to {}'.format(out_path))
def write_ply(points, filename, text=True):
""" input: Nx3, write points to filename as PLY format. """
points = [(points[i, 0], points[i, 1], points[i, 2])
for i in range(points.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
el = PlyElement.describe(vertex, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
def save_ply_data(filename, vertex, face):
""" save ply file, only vertices and faces """
vertices = np.zeros(vertex.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(vertex.shape[0]):
vertices[i] = (vertex[i][0], vertex[i][1], vertex[i][2])
faces = np.zeros(face.shape[0], dtype=[('vertex_indices', 'i4', (3, ))])
for i in range(face.shape[0]):
faces[i] = ([face[i][0], face[i][1], face[i][2]])
e1 = PlyElement.describe(vertices, 'vertex')
e2 = PlyElement.describe(faces, 'face')
PlyData([e1, e2], text=True).write(filename)
def cli_main():
parser = argparse.ArgumentParser(
description=
'Extract geometry from a trained model (only for learnable embeddings).'
)
parser.add_argument('--path', type=str, required=True)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--name', type=str, default='sparsevoxel')
parser.add_argument('--user-dir', default='fairnr')
args = options.parse_args_and_arch(parser)
models, model_args, task = checkpoint_utils.load_model_ensemble_and_task(
[args.path],
suffix=getattr(args, "checkpoint_suffix", ""),
)
model = models[0]
voxel_idx, voxel_pts = model.encoder.extract_voxels()
# write to ply file.
points = [(voxel_pts[k, 0], voxel_pts[k, 1], voxel_pts[k, 2], voxel_idx[k])
for k in range(voxel_idx.size(0))]
vertex = np.array(points,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('quality', 'f4')])
PlyData([PlyElement.describe(vertex, 'vertex')],
text=True).write(os.path.join(args.output, args.name + '.ply'))
def save_ply(scene,name):
scene_ply=[]
for elem in scene:
scene_ply.append(tuple(elem))
scene_ply=np.array(scene_ply,dtype=[('x','f4'),('y','f4'),('z','f4')])
el=PlyElement.describe(scene_ply,'vertex',comments=[name])
PlyData([el],text=True).write(name+'.ply')
def get_edge_ele(vidx_per_edge, edge_label, extra):
# edge
num_edge = vidx_per_edge.shape[0]
vnpf = vidx_per_edge.shape[1]
assert vnpf == 2
is_edge_color = edge_label is not None
if is_edge_color:
if edge_label is not None:
if extra == 'label_color_default':
edge_label = np.squeeze(edge_label)
edge_color = np.take(color_dic.rgb_order, edge_label, 0)
edge = np.zeros(shape=(num_edge)).astype(
dtype=[('vertex1', 'i4'), ('vertex2',
'i4'), ('red',
'u1'), ('green',
'u1'), ('blue', 'u1')])
else:
edge = np.zeros(shape=(num_edge)).astype(
dtype=[('vertex1', 'i4'), ('vertex2', 'i4')])
for i in range(num_edge):
if is_edge_color:
edge[i] = (vidx_per_edge[i][0], vidx_per_edge[i][1],
edge_color[i, 0], edge_color[i, 1], edge_color[i, 2])
else:
edge[i] = (vidx_per_edge[i][0], vidx_per_edge[i][1])
el_edge = PlyElement.describe(edge, 'edge')
return el_edge
def output_test_with_pc_and_views(
v_predict_acc,
v_predict_com,
v_gt_acc,
v_gt_com,
v_smith_error,
v_num_total_points,
v_views,
v_points, # (x,y,z)
):
# Write views
vertexes = v_points[:, :3]
vertexes_describer = PlyElement.describe(np.array(
[(item[0], item[1], item[2], item[3], item[4], item[5], item[6], item[7]) for item in
np.concatenate([vertexes,
v_predict_acc[:, np.newaxis],
v_predict_com[:, np.newaxis],
v_gt_acc[:, np.newaxis],
v_gt_com[:, np.newaxis],
v_smith_error[:, np.newaxis],
], axis=1)],
dtype=[('x', 'f8'), ('y', 'f8'), ('z', 'f8'),
('Predict_Recon', 'f8'), ('Predict_Gt', 'f8'),
('GT_Recon', 'f8'), ('GT_Gt', 'f8'),
('Smith_Recon', 'f8'),
]), 'vertex')
PlyData([vertexes_describer]).write('temp/test_scene_output/whole_point.ply')
# thread_map(write_views_to_txt_file, zip(v_views, v_points[:,3]), max_workers=16)
process_map(write_views_to_txt_file, list(enumerate(v_views)), max_workers=10, chunksize=1)
return
def write_ply_rgb_normal(points, colors, normals, filename, text=True):
""" input: Nx3, Nx3, Nx3 write points and colors to filename as PLY format. """
num_points = len(points)
assert len(colors) == num_points
points = [(points[i, 0], points[i, 1], points[i, 2])
for i in range(points.shape[0])]
colors = [(colors[i, 0], colors[i, 1], colors[i, 2])
for i in range(colors.shape[0])]
normals = [(normals[i, 0], normals[i, 1], normals[i, 2])
for i in range(normals.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
color = np.array(colors,
dtype=[('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
normal = np.array(normals,
dtype=[('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4')])
vertex_all = np.empty(
num_points,
vertex.dtype.descr + color.dtype.descr + normal.dtype.descr)
for prop in vertex.dtype.names:
vertex_all[prop] = vertex[prop]
for prop in color.dtype.names:
vertex_all[prop] = color[prop]
for prop in normal.dtype.names:
vertex_all[prop] = normal[prop]
el = PlyElement.describe(vertex_all, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
def write_ply_color(points,
labels,
filename,
num_classes=None,
colormap=pyplot.cm.jet):
""" Color (N,3) points with labels (N) within range 0 ~ num_classes-1 as OBJ file """
labels = labels.astype(int)
N = points.shape[0]
if num_classes is None:
num_classes = np.max(labels) + 1
else:
assert (num_classes > np.max(labels))
vertex = []
#colors = [pyplot.cm.jet(i/float(num_classes)) for i in range(num_classes)]
colors = [colormap(i / float(num_classes)) for i in range(num_classes)]
for i in range(N):
c = colors[labels[i]]
c = [int(x * 255) for x in c]
vertex.append(
(points[i, 0], points[i, 1], points[i, 2], c[0], c[1], c[2]))
vertex = np.array(vertex,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex', comments=['vertices'])
PlyData([el], text=True).write(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 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_point_cloud(points_3d,
filename,
binary=True,
with_label=False,
verbose=True):
"""Save an RGB point cloud as a PLY file.
Args:
points_3d: Nx6 matrix where points_3d[:, :3] are the XYZ coordinates and points_3d[:, 4:] are
the RGB values. If Nx3 matrix, save all points with [128, 128, 128] (gray) color.
"""
assert points_3d.ndim == 2
if with_label:
assert points_3d.shape[1] == 7
python_types = (float, float, float, int, int, int, int)
npy_types = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1'), ('label', 'u1')]
else:
if points_3d.shape[1] == 3:
gray_concat = np.tile(np.array([128], dtype=np.uint8),
(points_3d.shape[0], 3))
points_3d = np.hstack((points_3d, gray_concat))
assert points_3d.shape[1] == 6
python_types = (float, float, float, int, int, int)
npy_types = [('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')]
if binary is True:
# Format into NumPy structured array
vertices = []
for row_idx in range(points_3d.shape[0]):
cur_point = points_3d[row_idx]
vertices.append(
tuple(
dtype(point)
for dtype, point in zip(python_types, cur_point)))
vertices_array = np.array(vertices, dtype=npy_types)
el = PlyElement.describe(vertices_array, 'vertex')
# Write
PlyData([el]).write(filename)
else:
# PlyData([el], text=True).write(filename)
with open(filename, 'w') as f:
f.write('ply\n'
'format ascii 1.0\n'
'element vertex %d\n'
'property float x\n'
'property float y\n'
'property float z\n'
'property uchar red\n'
'property uchar green\n'
'property uchar blue\n'
'property uchar alpha\n'
'end_header\n' % points_3d.shape[0])
for row_idx in range(points_3d.shape[0]):
X, Y, Z, R, G, B = points_3d[row_idx]
f.write('%f %f %f %d %d %d 0\n' % (X, Y, Z, R, G, B))
if verbose is True:
print('Saved point cloud to: %s' % 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)
def savePointCloudToPly(pt_3d, pt_c, filename):
pt_3d_c = np.concatenate((pt_3d, pt_c), axis=1)
pt_3d_ct = [tuple(l) for l in pt_3d_c.tolist()]
pt_3d_ct = np.array(pt_3d_ct,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(pt_3d_ct, 'vertex')
PlyData([el], text=True).write(filename)
def write_color_ply(points, filename, text=True):
points = [(points[i, 0], points[i, 1], points[i, 2], points[i, 3],
points[i, 4], points[i, 5]) for i in range(points.shape[0])]
vertex = np.array(points,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
def write_ply(self, coords, normals, path):
l = []
size = coords.shape[0]
for i in range(0, size):
l.append((coords[i][0], coords[i][1], coords[i][2], normals[i][0], normals[i][1], normals[i][2]))
vertex = np.array(l, dtype=[('x', 'f4'),('y', 'f4'),('z', 'f4'),('nx','f4'),('ny','f4'),('nz','f4')])
el = PlyElement.describe(vertex, 'vertex')
PlyData([el]).write(path)
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 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 tet_ply(text, byte_order):
vertex = numpy.array([(0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = numpy.array([([0, 1, 2], 255, 255, 255), ([0, 2, 3], 255, 0, 0),
([0, 1, 3], 0, 255, 0), ([1, 2, 3], 0, 0, 255)],
dtype=[('vertex_indices', 'i4', (3, )), ('red', 'u1'),
('green', 'u1'), ('blue', 'u1')])
return PlyData([
PlyElement.describe(
vertex, 'vertex', comments=['tetrahedron vertices']),
PlyElement.describe(face, 'face')
],
text=text,
byte_order=byte_order,
comments=['single tetrahedron with colored faces'])
def write_ply(points, filename, text=True):
""" input: Nx3, write points to filename as PLY format. """
points = [
(points[i, 0], points[i, 1], points[i, 2]) for i in range(points.shape[0])
]
vertex = np.array(points, dtype=[("x", "f4"), ("y", "f4"), ("z", "f4")])
el = PlyElement.describe(vertex, "vertex", comments=["vertices"])
PlyData([el], text=text).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 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 to_ply_file(np_array):
data = np_array.transpose(2, 0, 1).reshape(3, -1).transpose(1, 0)
ply_faces = np.empty(len(data), dtype=[('vertex_indices', 'i4', (3,))])
ply_faces['vertex_indices'] = data
el = PlyElement.describe(ply_faces, 'sink')
PlyData([el]).write('sink_point_cloud.ply')
def write_ply_with_color(fname, coords, colors):
from plyfile import PlyData, PlyElement
vertex = np.array([
tuple(list(vert) + list(col[:3])) for vert, col in zip(coords, colors)
],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex')
PlyData([el]).write(fname)
def build_ply_single_triangle(self):
from plyfile import PlyElement, PlyData
points_dt = np.dtype([('x', float), ('y', float), ('z', float)])
face_dt = np.dtype([('vertex_indices', np.uint32, (3, ))])
# The numpy array data.
points = np.array([(-1, 0, 0), (0, 1, 0), (1, 0, 0)], dtype=points_dt)
triangles = np.array([
((1, 0, 2), ),
], dtype=face_dt) #The Tuple with a tuple inside is required Why !?!
elements = [
PlyElement.describe(points, "vertex"),
PlyElement.describe(triangles,
"face",
len_types={'vertex_indices': 'u1'},
val_types={'vertex_indices': 'u4'}),
]
ply_data = PlyData(elements, text=True)
return ply_data
def save_sparseCubes_2ply(vxl_mask_list, vxl_ijk_list, rgb_list, \
param, ply_filePath, normal_list=None):
"""
save sparse cube to ply file
---------
inputs:
vxl_mask_list[i]: np.bool (iN_voxels,)
vxl_ijk_list[i]: np.uint8 (iN_voxels, 3)
rgb_list[i]: np.uint8 (iN_voxels, 3)
normal_list[i]: np.float16 (iN_voxels, 3)
param: np.float32(N_nonempty_cubes, 4)
ply_filePath: 'xxx.ply'
outputs:
save to .ply file
"""
vxl_mask_np = np.concatenate(vxl_mask_list, axis=0)
N_voxels = vxl_mask_np.sum()
vxl_ijk_np = np.vstack(vxl_ijk_list)
rgb_np = np.vstack(rgb_list)
if not vxl_mask_np.shape[0] == vxl_ijk_np.shape[0] == rgb_np.shape[0]:
raise Warning('make sure # of voxels in each cube are consistent.')
if normal_list is None:
dt = np.dtype([('x', '<f4'), ('y', '<f4'), ('z', '<f4'), \
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
else:
dt = np.dtype([('x', '<f4'), ('y', '<f4'), ('z', '<f4'), \
('nx', '<f4'), ('ny', '<f4'), ('nz', '<f4'), \
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
normal_np = np.vstack(normal_list)[vxl_mask_np]
saved_pts = np.zeros(shape=(N_voxels, ), dtype=dt)
# calculate voxels' xyz
xyz_list = []
for _cube, _select in enumerate(vxl_mask_list):
resol = param[_cube]['resol']
xyz_list.append(vxl_ijk_list[_cube][_select] * resol +
param[_cube]['xyz'][None, :]) # (iN, 3) + (1, 3)
xyz_np = np.vstack(xyz_list)
vxl_ijk_np, rgb_np = vxl_ijk_np[vxl_mask_np], rgb_np[vxl_mask_np]
saved_pts['x'], saved_pts['y'], saved_pts[
'z'] = xyz_np[:, 0], xyz_np[:, 1], xyz_np[:, 2]
saved_pts['red'], saved_pts['green'], saved_pts[
'blue'] = rgb_np[:, 0], rgb_np[:, 1], rgb_np[:, 2]
if normal_list is not None:
saved_pts['nx'], saved_pts['ny'], saved_pts[
'nz'] = normal_np[:, 0], normal_np[:, 1], normal_np[:, 2]
el_vertex = PlyElement.describe(saved_pts, 'vertex')
outputFolder = '/'.join(ply_filePath.split('/')[:-1])
if not os.path.exists(outputFolder):
os.makedirs(outputFolder)
PlyData([el_vertex]).write(ply_filePath)
print('saved ply file: {}'.format(ply_filePath))
return 1
def export_ply_points_faces(pc, fc, filename):
vertex = np.zeros(pc.shape[0],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = np.zeros(fc.shape[0], dtype=[('vertex_indices', 'i4', (3, ))])
for i in range(pc.shape[0]):
vertex[i] = (pc[i][0], pc[i][1], pc[i][2])
for i in range(fc.shape[0]):
face[i] = (fc[i, 1], fc[i, 2], fc[i, 3])
ply_out = PlyData([
PlyElement.describe(vertex, 'vertex', comments=['vertices']),
PlyElement.describe(face, 'face', comments=['faces'])
])
ply_filename = filename[:-4] + '.ply'
ply_out.write(ply_filename)
def write_ply_rgb(points, colors, filename, text=True):
""" input: Nx3, write points to filename as PLY format. """
points = [(points[i, 0], points[i, 1], points[i, 2], colors[i, 0],
colors[i, 1], colors[i, 2]) for i in range(points.shape[0])]
vertex = np.array(points,
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
el = PlyElement.describe(vertex, 'vertex')
PlyData([el], text=text).write(filename)
def test_assign_elements(tet_ply_txt):
test = PlyElement.describe(numpy.zeros(1, dtype=[("a", "i4")]), "test")
tet_ply_txt.elements = [test]
assert len(tet_ply_txt.elements) == 1
assert len(tet_ply_txt) == 1
assert "vertex" not in tet_ply_txt
assert "face" not in tet_ply_txt
assert "test" in tet_ply_txt
for (k, elt) in enumerate(tet_ply_txt):
assert elt.name == "test"
assert k == 0
def CreatePLY(P1,parameters,filename,surf_type,originalPLYfile):
x1 = P1[:,0]
y1 = P1[:,1]
z1 = P1[:,2]
if surf_type == 'lin':
z1new = np.hstack((x1,y1,np.matrix(np.ones(np.size(P1,0))).T))*parameters
else:
z1new = np.hstack((np.multiply(x1,x1),np.multiply(y1,y1), np.multiply(x1,y1), x1, y1,np.matrix(np.ones(np.size(P1,0))).T))*parameters
originalPLY = PLYLoader(originalPLYfile)
point_cloud = (originalPLY.get_points()).T
color_matrix = (originalPLY.get_colors()).T
normals_matrix = (originalPLY.get_normals()).T
x1 = np.array(x1)
y1 = np.array(y1)
z1new = np.array(z1new)
x = point_cloud[:,0]
y = point_cloud[:,1]
z = point_cloud[:,2]
new_pointcloud = np.zeros((np.size(P1,0), 9))
pdb.set_trace()
for Prow in range(len(x1)):
print 'Prow = '
print Prow
for originalPLY_row in range(len(x)):
if ((x[originalPLY_row] == x1[Prow]) and (y[originalPLY_row] == y1[Prow])):
print 'found'
print Prow
#point_cloud[originalPLY_row,2] = z1new[Prow]
new_pointcloud[Prow,0:2] = (P1[Prow,0:2])
new_pointcloud[Prow,2] = (z1new[Prow])
new_pointcloud[Prow,3:6] = (normals_matrix[originalPLY_row,:])
new_pointcloud[Prow,6:9] = color_matrix[originalPLY_row,:]
pdb.set_trace()
#vertex = point_cloud
#new_mat = np.concatenate((vertex,normals_matrix,color_matrix),axis=1)
new_mat = new_pointcloud
vertex_new = map(tuple, new_mat)
vertex_new = np.array(vertex_new, dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4'),('nx','f4'),('ny','f4'),('nz','f4'),('diffuse_red', 'u1'), ('diffuse_green', 'u1'),('diffuse_blue', 'u1')])
el = PlyElement.describe(vertex_new, 'vertex')
PlyData([el], text=True).write(filename)
def test_list_property_type(tmpdir, np_type):
a = numpy.array([([0],), ([1, 2, 3],)], dtype=[("x", object)])
ply0 = PlyData([PlyElement.describe(a, "test", val_types={"x": np_type})])
assert ply0.elements[0].name == "test"
assert ply0.elements[0].properties[0].name == "x"
assert ply0.elements[0].properties[0].val_dtype == np_type
ply1 = write_read(ply0, tmpdir)
assert ply1.elements[0].name == "test"
assert ply1.elements[0].data[0]["x"].dtype == numpy.dtype(np_type)
verify(ply0, ply1)
def test_property_type(tmpdir, np_type):
dtype = [("x", np_type), ("y", np_type), ("z", np_type)]
a = numpy.array([(1, 2, 3), (4, 5, 6)], dtype=dtype)
ply0 = PlyData([PlyElement.describe(a, "test")])
assert ply0.elements[0].name == "test"
assert ply0.elements[0].properties[0].name == "x"
assert ply0.elements[0].properties[0].val_dtype == np_type
assert ply0.elements[0].properties[1].name == "y"
assert ply0.elements[0].properties[1].val_dtype == np_type
assert ply0.elements[0].properties[2].name == "z"
assert ply0.elements[0].properties[2].val_dtype == np_type
ply1 = write_read(ply0, tmpdir)
assert ply1.elements[0].name == "test"
assert ply1.elements[0].data.dtype == dtype
verify(ply0, ply1)
def write_ply(points, filename, text=True):
""" input: Nx3, write points to filename as PLY format. """
points = [(points[i,0], points[i,1], points[i,2]) for i in range(points.shape[0])]
vertex = np.array(points, dtype=[('x', 'f4'), ('y', 'f4'),('z', 'f4')])
el = PlyElement.describe(vertex, 'vertex', comments=['vertices'])
PlyData([el], text=text).write(filename)
vertex_normal[index3] = np.add(vertex_normal[index3], normal2)
# 3, normalize vector
for i in range(0, vertex_number):
vertex_normal[i] = normalize(vertex_normal[i])
# 4, write to ply
result = []
# The properties are 'x, y, z, nx, ny, nz'
for i in range(0, vertex_number):
record = (
plyData["vertex"][i][0],
plyData["vertex"][i][1],
plyData["vertex"][i][2],
vertex_normal[i][0],
vertex_normal[i][1],
vertex_normal[i][2],
)
result.append(record)
# print(result)
new_vertex_data = np.array(
result,
dtype=[("x", "float32"), ("y", "float32"), ("z", "float32"), ("nx", "float"), ("ny", "float"), ("nz", "float")],
)
elv = PlyElement.describe(new_vertex_data, "vertex")
PlyData([elv]).write("p1.ply")
# 5, write to txt
np.savetxt("test.txt", new_vertex_data, delimiter=" ", fmt="%.6f")
return face
if __name__ == "__main__":
# load image
img0 = np.array(Image.open("gargoyle/disp1.pgm"), dtype="int64")
img1 = np.array(Image.open("gargoyle/view3.png"))
img2 = np.array(Image.open("gargoyle/disp5.pgm"), dtype="int64")
# construct 3d coordinates
coords3d = []
coords3d1 = construct3D(img0, 1)
coords3d2 = construct3D(img2, 5)
coords3d = coords3d1 + coords3d2
# get disp map
# depth_map = project_nearest(coords3d)
disp_map = project_nearest(coords3d)
# scipy.misc.imsave('disp3.png', disp_map)
# connect
raw_face = generate_mesh(disp_map)
raw_vertex = construct_and_texture(disp_map, img1, 3)
vertex = np.array(
raw_vertex, dtype=[("x", "f4"), ("y", "f4"), ("z", "f4"), ("red", "u1"), ("green", "u1"), ("blue", "u1")]
)
face = np.array(raw_face, dtype=[("vertex_indices", "int32", (3,))])
elv = PlyElement.describe(vertex, "vertex")
elf = PlyElement.describe(face, "face")
PlyData([elv, elf]).write("mesh.ply")
'''
programSV3DRegion = glumpy_setting.ProgramSV3DRegion(data=data, name=None, point_size=1, anchor=anchor_matrix_whole)
gpyWindow.add_program(programSV3DRegion)
print(data['a_position'][0, 0, 0])
print(np.isnan(data['a_position'][0, 0, 0]))
print(~np.isnan(data['a_position'][0, 0, 0]))
data['a_color'] *= 255
data['a_color'].astype(int)
data = data[np.nonzero(~np.isnan(data['a_position'][:, :, 0]))]
xyzzz = np.zeros(len(data), dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('r', 'f4'), ('g', 'f4'), ('b', 'f4')])
xyzzz['x'] = data['a_position'][:, 0]
xyzzz['y'] = data['a_position'][:, 1]
xyzzz['z'] = data['a_position'][:, 2]
xyzzz['r'] = data['a_color'][:, 0]
xyzzz['g'] = data['a_color'][:, 1]
xyzzz['b'] = data['a_color'][:, 2]
el = PlyElement.describe(xyzzz, 'vertex')
PlyData([el]).write('some_binary.ply')
PlyData([el], text=True).write('some_ascii.ply')
programAxis = glumpy_setting.ProgramAxis(line_length=5)
gpyWindow.add_program(programAxis)
gpyWindow.run()
def match(self, perceivedpnts, perceivednormals, ddist = 5.0, dangle = 30.0):
"""
do a match
:return: rotmats of top matches
author: weiwei
date: 20170802
"""
# save txt
pverts = np.array([tuple(x) for x in perceivedpnts], dtype=[('x', 'f4'),('y', 'f4'),('z', 'f4')])
el = PlyElement.describe(pverts, 'vertex')
PlyData([el], text = True).write('perceivedpnts.ply')
# save txt
vandnarray = []
for i in range(len(self.temppnts)):
v = self.temppnts[i]
n = self.tempnormals[i]
vandn = (v[0],v[1],v[2],n[0],n[1],n[2])
vandnarray.append(vandn)
pverts = np.array(vandnarray, dtype=[('x', 'f4'),('y', 'f4'),('z', 'f4'),\
('nx','f4'),('ny','f4'),('nz','f4')])
el = PlyElement.describe(pverts, 'vertex')
PlyData([el], text = True).write('ttube.ply')
accspace = {}
# get the preceived global model descriptor
nperceivedpnts = perceivedpnts.shape[0]
i = np.argmax(perceivedpnts, axis = 0)[2]
for j in range(0,nperceivedpnts):
print j, nperceivedpnts
m_0 = np.asarray(perceivedpnts[i])
m_1 = np.asarray(perceivedpnts[j])
v_m0m1 = m_0-m_1
v_m1m0 = m_1-m_0
n_m0 = perceivednormals[i]
n_m1 = perceivednormals[j]
# f1, namely ||d||2
f1 = np.linalg.norm(m_0-m_1)
# f2, namely angle between n_m0 and v_m1m0
f2 = rm.degree_between(n_m0, v_m1m0)
# f3, namely angle between n_m1 and v_m0m1
f3 = rm.degree_between(n_m1, v_m0m1)
# f4, namely angle between n_m0 and n_m1
f4 = rm.degree_between(n_m0, n_m1)
# discretize the values
try:
f1d = int(math.floor(f1/ddist)*ddist+ddist)
f2d = int(math.floor(f2/dangle)*dangle+dangle)
f3d = int(math.floor(f3/dangle)*dangle+dangle)
f4d = int(math.floor(f4/dangle)*dangle+dangle)
except:
continue
key = (f1d, f2d, f3d, f4d)
# angle between n_m0 and x+
xplus = np.asarray([1,0,0])
yplus = np.asarray([0,1,0])
nm0xangle = math.degrees(rm.radian_between(n_m0, xplus))
rotax = np.cross(xplus, n_m0)
if np.isnan(rotax).any() or not rotax.any():
continue
rotmat = rm.rodrigues(rotax, nm0xangle)
v_m1m0onxplus = np.dot(v_m1m0, rotmat)
v_m1m0onxplusyzproj = np.asarray([0, v_m1m0onxplus[1], v_m1m0onxplus[2]])
alpha_m0 = rm.radian_between(v_m1m0onxplusyzproj, yplus)
if v_m1m0onxplus[2] < 0:
alpha_m0 = 2*math.pi - alpha_m0
if key in self.gmd.keys():
malist = self.gmd[key]
print len(malist)
for maslot in malist:
alpha = math.degrees(alpha_m0-maslot[2])
try:
alphadiscrete = int(math.floor(alpha/dangle)*dangle+dangle)
except:
continue
acckey = (maslot[0], alphadiscrete)
if acckey in accspace.keys():
accspace[acckey] += 1
else:
accspace[acckey] = 1
if len(accspace.keys()) is 0:
return (None, None)
# find top matches and rot matrices
maxn = sorted(accspace.iteritems(), key=operator.itemgetter(1), reverse=True)[:5]
rotmat4list = []
silist = []
milist = []
for maxnele in maxn:
mi, alpha = maxnele[0]
# step1 move to temppnts[mi]
displacement0 = -self.temppnts[mi]
rotmat4_0 = Mat4.translateMat(displacement0[0], displacement0[1], displacement0[2])
# step2 rotate to goal
normalangle = math.degrees(rm.radian_between(self.tempnormals[mi], perceivednormals[i]))
normalrotax = np.cross(self.tempnormals[mi], perceivednormals[i])
normalrotmat = rm.rodrigues(normalrotax, normalangle)
anglerotmat = rm.rodrigues(perceivednormals[i], -alpha)
rotmat = np.dot(anglerotmat, normalrotmat)
rotmat4_1 = pg.npToMat4(rotmat)
# step3 move to perceivedpnts[i]
displacement1 = perceivedpnts[i]
rotmat4_2 = Mat4.translateMat(displacement1[0], displacement1[1], displacement1[2])
rotmat4 = rotmat4_0*rotmat4_1*rotmat4_2
rotmat4list.append(rotmat4)
silist.append(i)
milist.append(mi)
return rotmat4list, silist, milist
if createSV and needOutput:
data = programSV3DRegion.data
data['a_color'] *= 255
data['a_color'].astype(int)
dataPLY = np.zeros(len(data), dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
dataPLY['x'] = data['a_position'][:, 0]
dataPLY['y'] = data['a_position'][:, 1]
dataPLY['z'] = data['a_position'][:, 2]
dataPLY['red'] = data['a_color'][:, 0]
dataPLY['green'] = data['a_color'][:, 1]
dataPLY['blue'] = data['a_color'][:, 2]
el = PlyElement.describe(dataPLY, 'vertex')
# PlyData([el], text=True).write('137_4_ascii.ply')
PlyData([el]).write('/home/andy/src/ply/' + fileID + '_non_ground_binary.ply')
if needGround:
dataGnd = programSV3DRegion.data
dataGnd['a_color'] *= 255
dataGnd['a_color'].astype(int)
dataPLY = np.zeros(len(dataGnd), dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
dataPLY['x'] = dataGnd['a_position'][:, 0]
dataPLY['y'] = dataGnd['a_position'][:, 1]
dataPLY['z'] = dataGnd['a_position'][:, 2]
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)
"""
ALL PLY EXPORT IN HERE
"""
data = programSV3DRegion.data
data['a_color'] *= 255
data['a_color'].astype(int)
xyzzz = np.zeros(len(data), dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
xyzzz['x'] = data['a_position'][:, 0]
xyzzz['y'] = data['a_position'][:, 1]
xyzzz['z'] = data['a_position'][:, 2]
xyzzz['red'] = data['a_color'][:, 0]
xyzzz['green'] = data['a_color'][:, 1]
xyzzz['blue'] = data['a_color'][:, 2]
el = PlyElement.describe(xyzzz, 'vertex')
face = np.zeros(len(tri), dtype=[('vertex_indices', 'i4', 3)])
face['vertex_indices'] = tri
tri = PlyElement.describe(face, 'face')
PlyData([el, tri], text=True).write('some_ascii.ply')
#PlyData([el]).write('over_simple_binary.ply')
"""
ALL PLY EXPORT IN HERE
"""
programAxis = glumpy_setting.ProgramAxis(line_length=5)
gpyWindow.add_program(programAxis)
gpyWindow.run()
def getMakerXYZ(self, markercolumnid, markerrowid, markerdepth):
if markerdepth > 0:
point3d = self.kinect.mapper().MapDepthPointToCameraSpace(
PyKinectV2._DepthSpacePoint(ctypes.c_float(markercolumnid), ctypes.c_float(markerrowid)),
ctypes.c_ushort(markerdepth))
return [point3d.x, point3d.y, point3d.z]
else:
return []
if __name__=='__main__':
base = pandactrl.World(camp=[0,0,3000], lookatp=[0,0,0])
kapi = KinectAPI()
# points
pntclds = kapi.getPointCloud()
colors = []
color = [np.random.rand(), np.random.rand(), np.random.rand(), np.random.rand()]
for pnt in pntclds:
colors.append(color)
pntsnp = pg.genPntsnp(pntclds, colors=colors)
pntsnp.reparentTo(base.render)
from plyfile import PlyData, PlyElement
verts = np.array(pntclds, dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
el = PlyElement.describe(verts, 'vertex')
PlyData([el], text=True).write('pythoncloud.ply')
base.run()
(0, 1, 1),
(1, 0, 1),
(1, 1, 0)],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
face = numpy.array([([0, 1, 2], 255, 255, 255),
([0, 2, 3], 255, 0, 0),
([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
