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 read_ply(self, file_name):
num_samples = self.num_samples // len(self.files_list)
if self.file_index == len(self.files_list) - 1:
num_samples = num_samples + (self.num_samples - (num_samples * len(self.files_list)))
root, ext = os.path.splitext(file_name)
if not os.path.isfile(root + ".npy"):
ply = PlyData.read(file_name)
vertex = ply['vertex']
(x, y, z) = (vertex[t] for t in ('x', 'y', 'z'))
points = zip(x.ravel(), y.ravel(), z.ravel())
np.save(root + ".npy", points)
else:
points = np.load(root + ".npy")
#load normals
if os.path.isfile(root + "_normals" + ".ply"):
if not os.path.isfile(root + "_normals" + ".npy"):
ply1 = PlyData.read(root + "_normals" + ".ply")
vertex = ply1['vertex']
(nx, ny, nz) = (vertex[t] for t in ('nx', 'ny', 'nz'))
self.normals = np.asarray(zip(nx.ravel(), ny.ravel(), nz.ravel()))
np.save(root + "_normals" + ".npy", self.normals)
else:
self.normals = np.load(root + "_normals" + ".npy")
if self.add_noise:
self.data = utils.add_noise_normal(points, std=self.nois_std)
else:
self.data = np.asarray(points)
self.pc_diameter = utils.get_pc_diameter(self.data)
self.l = self.relL*self.pc_diameter
rot = utils.angle_axis_to_rotation(self.rotation_angle, self.rotation_axis)
self.data = utils.transform_pc(self.data, rot)
#plotutils.show_pc(self.data)
#mlab.show()
#TODO: better sampling
print "sampling file: ", file_name
self.samples, self.sample_indices = Sampler.sample(self.data, -1, min_num_point=-1, file_name=file_name, sampling_algorithm=self.sampling_algorithm)
#self.samples, self.sample_indices = Sampler.sample(self.data, -1, num_samples, file_name=file_name, sampling_algorithm=self.sampling_algorithm)
#self.samples = self.samples[0:num_samples]
#self.sample_indices = self.sample_indices[0:num_samples]
self.tree = spatial.KDTree(self.data)
return self.data
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 ply_plot(ply_file, opacity = 1, color = (1,1,1)):
ply = PlyData.read(ply_file)
'''
Plot vertices and triangles from a PlyData instance. Assumptions:
`ply' has a 'vertex' element with 'x', 'y', and 'z'
properties;
`ply' has a 'face' element with an integral list property
'vertex_indices', all of whose elements have length 3.
'''
vertex = ply['vertex'].data
(x, y, z) = (vertex[t] for t in ('x', 'y', 'z'))
# mlab.points3d(x, y, z, color=(1, 1, 1), mode='point')
tri_idx = ply['face'].data['vertex_indices']
idx_dtype = tri_idx[0].dtype
triangles = numpy.fromiter(tri_idx, [('data', idx_dtype, (3,))],
count=len(tri_idx))['data']
mesh = mlab.triangular_mesh(x, y, z, triangles,
color=color,
opacity = opacity)
return mesh
def main():
res_folder = opt.result_dir
ply_folder = opt.scan_path
output_dir = opt.output_dir
os.makedirs(output_dir, exist_ok=True)
reader_ins = Benchmark_reader(res_folder)
for folder in os.listdir(res_folder):
if os.path.isdir(os.path.join(res_folder, folder)):
continue
print(folder)
# ply reader
ply_file = os.path.join(ply_folder, folder.split('.')[0], folder.split('.')[0]+'_vh_clean_2.ply')
ply_data = PlyData.read(ply_file)
points = []
for point in ply_data.elements[0].data:
points.append([point[0], point[1], point[2]])
points = np.array(points)
colors = np.zeros_like(points)
# instance reader
instances = reader_ins[folder]
for instance_idx, instance_key in enumerate(instances.keys()):
r, g, b = create_color_palette()[int((instance_idx + 1)%41)]
colors[instances[instance_key]['points'].nonzero()[0].astype(np.int32)] = [r,g,b]
output_file = os.path.join(output_dir, folder.split('.')[0] + '.ply')
write_ply(points, colors, None, output_file)
def main():
parser = ArgumentParser()
parser.add_argument("ply_filename")
args = parser.parse_args()
plot(PlyData.read(args.ply_filename))
def readMesh_PLY(filename, output="soup"):
if output != "soup":
raise Exception("Mesh types other than soup not yet supported")
# Read the actual file
# TODO This takes a long time, maybe try to replace with something faster of my own?
plydata = PlyData.read(filename)
# Read vertices
# If the mesh has more than three columns of vertex data, ignore the later columns
# (for instance, Stanford Mesh Repo meshes store intensity and confidence here)
nVerts = plydata["vertex"].count
verts = np.zeros((nVerts, 3))
verts[:, 0] = np.array(plydata["vertex"].data["x"])
verts[:, 1] = np.array(plydata["vertex"].data["y"])
verts[:, 2] = np.array(plydata["vertex"].data["z"])
# Read faces
faces = make2d(plydata["face"].data["vertex_indices"])
# Build a mesh from these vertices and faces
mesh = TriSoupMesh(verts, faces)
return mesh
def main():
parser = ArgumentParser()
parser.add_argument('ply_filename')
args = parser.parse_args()
plot(PlyData.read(args.ply_filename))
mlab.show()
def read_ply(self, file_name, num_samples=1000, sample_class_start=0, add_noise =False,
noise_prob=0.3, noise_factor=0.02, noise_std=0.1, sampling_algorithm=SampleAlgorithm.Uniform,
rotation_axis=[0, 0, 1], rotation_angle=0):
root, ext = os.path.splitext(file_name)
if not os.path.isfile(root + ".npy"):
ply = PlyData.read(file_name)
vertex = ply['vertex']
(x, y, z) = (vertex[t] for t in ('x', 'y', 'z'))
points = zip(x.ravel(), y.ravel(), z.ravel())
np.save(root + ".npy", points)
else:
points = np.load(root + ".npy")
#load normals
if os.path.isfile(root + "_normals" + ".ply"):
if not os.path.isfile(root + "_normals" + ".npy"):
ply1 = PlyData.read(root + "_normals" + ".ply")
vertex = ply1['vertex']
(nx, ny, nz) = (vertex[t] for t in ('nx', 'ny', 'nz'))
self.normals = np.asarray(zip(nx.ravel(), ny.ravel(), nz.ravel()))
np.save(root + "_normals" + ".npy", self.normals)
else:
self.normals = np.load(root + "_normals" + ".npy")
if add_noise:
print "adding noise to model.."
mr = utils.model_resolution(np.array(points))
#mr = 0.404
print "model resolution: ", mr
self.data = utils.add_noise_normal(np.array(points), mr, noise_std)
else:
self.data = np.asarray(points)
rot = utils.angle_axis_to_rotation(rotation_angle, rotation_axis)
self.data = utils.transform_pc(self.data, rot)
#plotutils.show_pc(self.data)
#mlab.show()
#TODO: better sampling
self.samples, self.sample_indices = Sampler.sample(self.data, -1, num_samples-1, file_name=file_name, pose=rot, sampling_algorithm=sampling_algorithm)
self.tree = spatial.KDTree(self.data)
self.sample_class_start = sample_class_start
self.sample_class_current = sample_class_start
self.num_samples = self.samples.shape[0]
print "num samples: ", self.num_samples
logging.basicConfig(filename='example.log',level=logging.DEBUG)
return self.data
def read_ply_cloud(filename):
ply_data = PlyData.read(filename)
points = ply_data['vertex'].data.copy()
cloud = np.empty([2048, 3])
for i in range(len(points)):
point = points[i]
p = np.array([point[0], point[1], point[2]])
cloud[i] = p
return np.array(cloud)
def test_write_stream(tmpdir, tet_ply_txt):
ply0 = tet_ply_txt
test_file = tmpdir.join("test.ply")
with test_file.open("wb") as f:
tet_ply_txt.write(f)
ply1 = PlyData.read(str(test_file))
verify(ply0, ply1)
def read_str(string, tmpdir, name="test.ply"):
"""
Utility: create a PlyData instance from a string.
"""
filename = tmpdir.join(name)
with filename.open("wb") as f:
f.write(string)
return PlyData.read(str(filename))
def write_read(ply, tmpdir, name="test.ply"):
"""
Utility: serialize/deserialize a PlyData instance through a
temporary file.
"""
filename = tmpdir.join(name)
ply.write(str(filename))
return PlyData.read(str(filename))
def read_mesh_vertices(filename):
assert os.path.isfile(filename)
with open(filename, 'rb') as f:
plydata = PlyData.read(f)
num_verts = plydata['vertex'].count
vertices = np.zeros(shape=[num_verts, 3], dtype=np.float32)
vertices[:,0] = plydata['vertex'].data['x']
vertices[:,1] = plydata['vertex'].data['y']
vertices[:,2] = plydata['vertex'].data['z']
return vertices
def load_ply(self, path):
plyData = PlyData.read(path)
data = plyData['vertex']
vertex_number = len(data[:])
vertex_data = np.zeros((vertex_number,3),dtype='int64')
for i in range(0, vertex_number):
vertex_data[i][0] = data[i][0]
vertex_data[i][1] = data[i][1]
vertex_data[i][2] = data[i][2]
#print(vertex_data)
return vertex_data
def main():
parser = ArgumentParser()
parser.add_argument('ply_filename')
args = parser.parse_args()
# file1 = open(args.ply_filename,'r')
# plot(PlyData.read())
# plot(file1)
plot(PlyData.read(args.ply_filename))
def convert(inputfp, outputfp):
print 'converting %s to %s'%(inputfp, outputfp)
plydata = PlyData.read(inputfp)
vertex = np.array([each for each in plydata.elements[0].data.tolist()], dtype=np.float32)
faces = plydata.elements[1].data.tolist()
faces = np.array([each[0] for each in faces], dtype=np.int32)
gv = gifti.GiftiDataArray.from_array(vertex, intent=1008)
gf = gifti.GiftiDataArray.from_array(faces, intent=1009)
g = gifti.GiftiImage()
g.add_gifti_data_array(gv)
g.add_gifti_data_array(gf)
gio.write(g, outputfp)
def load_from_ply(self, filename, rotationFlag):
plydata = PlyData.read(filename)
self.plydata = plydata
self.f = np.vstack(plydata['face'].data['vertex_indices'])
if rotationFlag is not None:
x = -plydata['vertex'].data['z']
y = plydata['vertex'].data['x']
z = -plydata['vertex'].data['y']
else:
x = plydata['vertex'].data['x']
y = plydata['vertex'].data['y']
z = plydata['vertex'].data['z']
self.v = np.zeros([x.size, 3])
self.v[:,0] = x
self.v[:,1] = y
self.v[:,2] = z
def ply_to_patch(ply_file_path,connection_string,pcid,writing_query,additional_offset,grouping_rules):
""" This function read a ply file, group points into 1M3 patches, convert patches
"""
from plyfile import PlyData
import datetime
print '\t working on ply file : ',ply_file_path
print '\t importing ply file ',datetime.datetime.now()
plydata = PlyData.read(ply_file_path)
print '\t grouping points',datetime.datetime.now()
numpy_spec_patch = grouping_ply_data(plydata, grouping_rules)
#to order the patch
#sorted_points = np.sort(patch[1], axis=0, kind='quicksort', order=('GPS_time'))
#send patch to database*
print '\t sending patch to database ply file ',datetime.datetime.now()
return making_pgpatch( numpy_spec_patch, connection_string, pcid, writing_query, ply_file_path, additional_offset)
def readPLY(fileName):
plydata = PlyData.read(fileName)
verts = []
faces = []
for ele in plydata.elements:
if ele.name == 'vertex':
for v in plydata['vertex']:
if len(v) == 3:
verts.append(np.asarray([v[0], v[1], v[2]]))
else:
verts.append(np.asarray([v[0][0], v[0][1], v[0][2]]))
if ele.name == 'face':
for f in plydata['face']:
if len(f) == 3:
faces.append(np.asarray([f[0], f[1], f[2]]))
else:
faces.append(np.asarray([f[0][0], f[0][1], f[0][2]]))
normals = []
return verts, faces,normals
def readPlyFile(filename):
"""
Usese plyfile python pacakage to read a ply file.
Gets around issues with pcl having a bad ply writer for pointclouds
:param filename:
:type filename: str
:return: vtkPolyData
:rtype:
"""
from plyfile import PlyData
plydata = PlyData.read(filename)
vertex_data = plydata['vertex'].data # numpy array with fields ['x', 'y', 'z']
pts = np.zeros([vertex_data.size, 3])
pts[:, 0] = vertex_data['x']
pts[:, 1] = vertex_data['y']
pts[:, 2] = vertex_data['z']
return vnp.numpyToPolyData(pts)
def run_point_cloud(self, voxel_world_id, threshold):
import voxel_globe.tools
import voxel_globe.meta.models as models
import boxm2_adaptor
import boxm2_mesh_adaptor
from plyfile import PlyData
voxel_world = models.VoxelWorld.objects.get(id=voxel_world_id)
with voxel_globe.tools.task_dir("voxel_viewer") as processing_dir:
scene_path = os.path.join(voxel_world.directory, "scene.xml")
scene, cache = boxm2_adaptor.load_cpp(scene_path)
ply_filename = os.path.join(processing_dir, "model.ply")
boxm2_mesh_adaptor.gen_color_point_cloud(scene, cache, ply_filename, 0.5, "")
ply = PlyData.read(str(ply_filename))
return ply.elements[0].data
def sample_ISS(file_name, min_num_point, pose):
root, ext = os.path.splitext(file_name)
in_file = root + ".ply"
out_file = root + "_iss.ply"
if (not os.path.isfile(out_file)):
print "file doen't exits.................."
args = ["./iss_detect", in_file, out_file]
popen = subprocess.Popen(args, stdout=subprocess.PIPE)
popen.wait()
output = popen.stdout.read()
print output
pc = np.load(root + '.npy')
tree = spatial.KDTree(pc)
ply = PlyData.read(out_file)
vertex = ply['vertex']
(x, y, z) = (vertex[t] for t in ('x', 'y', 'z'))
pc_iss = np.asarray(zip(x.ravel(), y.ravel(), z.ravel()))
indices = np.zeros((pc_iss.shape[0],))
for pt_i, samplept in enumerate(pc_iss):
_, index = tree.query(samplept, k=1)
indices[pt_i] = index
pc_iss = utils.transform_pc(pc_iss, pose)
#min_num_point = min(int(pc_iss.shape[0] / 10), 200)
if min_num_point < 0:
#min_num_point = min(int(pc_iss.shape[0] / 10), 200)
#min_num_point = min(int(pc_iss.shape[0] / 1), 300)
#min_num_point = min(int(pc_iss.shape[0] / 1), 500)
min_num_point = int(pc_iss.shape[0] / 1)
if min_num_point >= pc_iss.shape[0]:
return pc_iss, indices
sample_step = int(pc_iss.shape[0] / min_num_point)
pc_iss_samples, _ = Sampler.sample_uniform(pc_iss, sample_step)
indices_samples, _ = Sampler.sample_uniform(indices, sample_step)
assert(pc_iss_samples.shape[0] == indices_samples.shape[0])
print ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,pc_iss shape:", pc_iss_samples.shape
return pc_iss_samples, indices_samples
def Slab_SVM(file_name, v, sigma):
plydata = PlyData.read(open(file_name))
vertexes = plydata['vertex'][:]
x = np.zeros((len(vertexes),3))
for i in range(len(vertexes)):
x[i] = np.array([vertexes[i][0],vertexes[i][1],vertexes[i][2]])
file_name_points = len(x)
x_0 = plydata['vertex']['x']
x_1 = plydata['vertex']['y']
x_2 = plydata['vertex']['z']
#createPlot(x_0,x_1,x_2,file_name)
y = np.zeros(len(x))
x,ignore_x,y,ignore_y=train_test_split(x,y,train_size=0.01,random_state=8)
len_x = len(x)
risk = createHyperPlane(x,v,sigma)
print file_name,'points:',file_name_points,'subsample:',len_x,'v',v,'sigma',sigma,'risk',risk
def create_polygons(file, seg_id, which_type):
#print("Detecting convex hull")
try:
plydata = PlyData.read(file)
x = plydata.elements[0].data['x']
y = plydata.elements[0].data['y']
z = plydata.elements[0].data['z']
seg = plydata.elements[0].data['segment_id']
#import las file
#data = File(file, mode = "r")
#x = data.x
#y = data.y
#z = data.z
#seg = data.segment_id
points = np.vstack([x, y, z, seg]).transpose()
#print(points)
xy = points[:,0:2]
#shift_value = np.mean(xy, axis = 0)
#xy_shift = xy - shift_value
#print(points)
if len(points) != 0:
un_seg = np.unique(points[:,3])
#print(un_seg)
#print('hoi')
for i in range(len(un_seg)):
if un_seg[i] in seg_id:
#print('checkkk')
seg_p_i = np.where(points[:,3]==un_seg[i]) # indexes of points belonging to this segment
xy_seg = xy[seg_p_i]
#print(xy_seg)
#print('len unique x: ', len(np.unique(xy_seg[:,0])))
#print('len unique y: ', len(np.unique(xy_seg[:,1])))
#print('check')
if len(xy_seg) < 3 or len(np.unique(xy_seg[:,0])) == 1 or len(np.unique(xy_seg[:,1])) == 1:
pass
#hull_pts = xy_seg # or should we then skip the segment?
else:
hull = ConvexHull(xy_seg)
hull_indices = hull.vertices
#print(hull_indices)
#print('check2')
'''
## plot them
plt.plot(points[:,0], points[:,1], 'o')
for simplex in hull.simplices:
plt.plot(xy_seg[simplex, 0], xy_seg[simplex, 1], 'k-')
plt.plot(xy_seg[hull.vertices,0], xy_seg[hull.vertices,1], 'r--', lw=2)
plt.plot(xy_seg[hull.vertices[0],0], xy_seg[hull.vertices[0],1], 'ro')
plt.show()
'''
hull_pts = xy_seg[hull_indices]
#print(hull_pts)
#hull_pts = hull_pts_shifted + shift_value
poly.append(Polygon(hull_pts))
#make_np = np.array(seg_id)
#make_np_t = np.array(which_type)
loct = seg_id.index(un_seg[i])
#print('test seg id = ', seg_id[loct])
#print('test un_seg[i]= ', un_seg[i])
#loct = np.where(make_np == un_seg[i])
t = which_type[loct]
#print(t)
#print('loc t = ', loct)
#t = make_np_t[loct]
#tt = t.tolist()
#t = tt[0]
#print(t)
attr.append([inputFileName, un_seg[i], t])
except Exception as e:
print(e)
# write to file
with fiona.open('objects_1906.shp', 'w', 'ESRI Shapefile', schema) as c:
for j in range(len(poly)):
c.write({
'geometry': mapping(poly[j]),
'properties': {'id': attr[j][0] , 'seg': attr[j][1], 'type' : attr[j][2]}})
# plt.draw()
# fig = plt.figure()
# ax = fig.gca(projection='3d')
# ax.plot_trisurf(x, y, np.array(v).flatten(), cmap=cm.jet, linewidth=0.2)
# ax.set_title('Actual')
# plt.draw()
# plt.show()
return a, D, indices_chosen
def main(x, y, z, ftype):
if (ftype == 'quad'):
a = QuadSurfFit(x, y, z)
elif (ftype == 'lin'):
a = LinSurfFit(x, y, z)
return a
if __name__ == "__main__":
plydata = PlyData.read('example-1.ply')
x = (plydata['vertex']['x'])
y = (plydata['vertex']['y'])
z = (plydata['vertex']['z'])
a = main(x, y, z, 'quad')
print 'final a = '
print a
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 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)
os.makedirs(args.outdir, exist_ok=True)
# Read mesh data
fn, ext = os.path.splitext(args.input)
pn, fn = os.path.split(fn)
fn = os.path.join(pn, os.path.basename(fn).rsplit('_', 1)[0])
if args.edge_length is None:
args.edge_length = fn + "_edge.csv"
if args.boundary_vertex is None and args.lambda_bdvert > 0:
cfn = fn + "_boundary.csv"
if os.path.isfile(cfn):
args.boundary_vertex = cfn
#
plydata = PlyData.read(args.input)
vert = np.vstack(
[plydata['vertex']['x'], plydata['vertex']['y'],
plydata['vertex']['z']]).astype(np.float64).T
face = plydata['face']['vertex_indices']
print("reading edge length from ", args.edge_length)
edgedat = np.loadtxt(args.edge_length, delimiter=",")
if edgedat.shape[1] == 4: ## with weight information
edgedat = np.array(
[[i, j, l, w]
for i, j, l, w in zip(edgedat[:,
0], edgedat[:,
1], edgedat[:,
2], edgedat[:,
3])
if i < j])
return normal_pca.transform(df)
def do_random_pca(df):
# Import the libraries required for PCA:
from sklearn.decomposition import PCA
# Reduce to 2D randomized:
random_pca = PCA(n_components=2, svd_solver='randomized')
# Train PCA on the armadillo and Project to 2D:
return random_pca.fit_transform(df)
plt.style.use('ggplot')
reduce_factor = 100
# Load up the scanned armadillo:
ply = PlyData.read('datasets/stanford_armadillo.ply')
armadillo = pd.DataFrame({
'x': ply['vertex']['z'][::reduce_factor],
'y': ply['vertex']['x'][::reduce_factor],
'z': ply['vertex']['y'][::reduce_factor]
})
# Render the original armadillo:
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_title('Armadillo 3D')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.scatter(armadillo['x'],
armadillo['y'],
armadillo['z'],
]
print((len(filenames_training)))
print((len(filenames_testing)))
f_training = h5py.File("./hdf5_data/data_training.h5", 'w')
f_testing = h5py.File("./hdf5_data/data_testing.h5", 'w')
a_data_training = np.zeros((len(filenames_training), 512, 3))
a_pid_training = np.zeros((len(filenames_training), 512), dtype=np.uint8)
a_data_testing = np.zeros((len(filenames_testing), 512, 3))
a_pid_testing = np.zeros((len(filenames_testing), 512), dtype=np.uint8)
for i in range(0, len(filenames_training)):
print(filenames_training[i])
plydata = PlyData.read("./ply_dir/" + filenames_training[i] + ".ply")
piddata = [
line.rstrip()
for line in open("./seg_dir/" + filenames_training[i] + ".seg", 'r')
]
for j in range(0, 512):
a_data_training[i, j] = [
plydata['vertex']['x'][j], plydata['vertex']['y'][j],
plydata['vertex']['z'][j]
]
a_pid_training[i, j] = piddata[j]
data = f_training.create_dataset("data", data=a_data_training)
pid = f_training.create_dataset("pid", data=a_pid_training)
for i in range(0, len(filenames_testing)):
plydata = PlyData.read("./ply_dir/" + filenames_testing[i] + ".ply")
import matplotlib
import datetime
from mpl_toolkits.mplot3d import Axes3D
from plyfile import PlyData, PlyElement
# Every 100 data samples, we save 1. If things run too
# slow, try increasing this number. If things run too fast,
# try decreasing it... =)
reduce_factor = 100
# Look pretty...
matplotlib.style.use('ggplot')
# Load up the scanned armadillo
plyfile = PlyData.read('Datasets/stanford_armadillo.ply')
armadillo = pd.DataFrame({
'x': plyfile['vertex']['z'][::reduce_factor],
'y': plyfile['vertex']['x'][::reduce_factor],
'z': plyfile['vertex']['y'][::reduce_factor]
})
def do_PCA(armadillo):
#
# TODO: Write code to import the libraries required for PCA.
# Then, train your PCA on the armadillo dataframe. Finally,
# drop one dimension (reduce it down to 2D) and project the
# armadillo down to the 2D principal component feature space.
#
# NOTE: Be sure to RETURN your projected armadillo!
def train(param):
torch.manual_seed(0)
np.random.seed(0)
print("**********Initiate Netowrk**********")
model = graphAE.Model(param)
model.cuda()
optimizer = torch.optim.Adam(params=model.parameters(),
lr=param.lr,
weight_decay=param.weight_decay)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
param.lr_decay_epoch_step,
gamma=param.lr_decay)
if (param.read_weight_path != ""):
print("load " + param.read_weight_path)
checkpoint = torch.load(param.read_weight_path)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
model.compute_param_num()
model.train()
print("**********Get training ply fn list from**********", param.pcs_train)
##get ply file lst
pc_lst_train = np.load(param.pcs_train)
param.iter_per_epoch = int(len(pc_lst_train) / param.batch)
param.end_iter = param.iter_per_epoch * param.epoch
print("**********Get evaluating ply fn list from**********",
param.pcs_evaluate)
pc_lst_evaluate = np.load(param.pcs_evaluate)
#print ("**********Get test ply fn list from**********", param.pcs_evaluate)
#pc_lst_test = np.load(param.pcs_test)
np.random.shuffle(pc_lst_train)
np.random.shuffle(pc_lst_evaluate)
pc_lst_train[:, :, 0:3] -= pc_lst_train[:, :, 0:3].mean(1).reshape(
(-1, 1, 3)).repeat(param.point_num, 1)
pc_lst_evaluate[:, :, 0:3] -= pc_lst_evaluate[:, :, 0:3].mean(1).reshape(
(-1, 1, 3)).repeat(param.point_num, 1)
#pc_lst_test[:,:,0:3] -= pc_lst_test[:,:,0:3].mean(1).reshape((-1,1,3)).repeat(param.point_num, 1)
template_plydata = PlyData.read(param.template_ply_fn)
print("**********Start Training**********")
min_geo_error = 123456
for i in range(param.start_epoch, param.epoch + 1):
if (((i % param.evaluate_epoch == 0) and (i != 10))
or (i == param.epoch)):
print("###Evaluate", "epoch", i, "##########################")
with torch.no_grad():
torch.manual_seed(0)
np.random.seed(0)
geo_error = evaluate(param,
model,
pc_lst_evaluate,
i,
template_plydata,
suffix="_eval")
if (geo_error < min_geo_error):
min_geo_error = geo_error
print("###Save Weight")
path = param.write_weight_folder + "model_epoch%04d" % i + ".weight"
torch.save(
{
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict()
}, path)
torch.manual_seed(i)
np.random.seed(i)
for j in range(param.iter_per_epoch):
train_one_iteration(param, model, optimizer, pc_lst_train, i, j)
scheduler.step()
from plyfile import PlyData, PlyElement
import sys
from auto_rotate import make_rotator, gen_ply_vectrices, apply_rotation, write_rotated_ply
if __name__ == '__main__':
path = sys.argv[1]
degree = float(sys.argv[2])
rotator = make_rotator(degree * 0.0174533)
rotated_vertrices = []
input_ply = PlyData.read(path)
#apply rotation
for t in gen_ply_vectrices(input_ply):
x, y, z = t[0], t[1], t[2]
newx, newy, newz = apply_rotation(x, y, z, rotator)
rotated_vertrices.append((newx, newy, newz))
#make new ply
write_rotated_ply(rotated_vertrices, input_ply, 'rotated_by_degree.ply')
import datetime
from mpl_toolkits.mplot3d import Axes3D
from plyfile import PlyData, PlyElement
# Every 100 data samples, we save 1. If things run too
# slow, try increasing this number. If things run too fast,
# try decreasing it... =)
reduce_factor = 100
# Look pretty...
matplotlib.style.use('ggplot')
# Load up the scanned armadillo
plyfile = PlyData.read(
'/Users/zmandell/Downloads/DAT210x-master/Module4/Datasets/stanford_armadillo.ply'
)
armadillo = pd.DataFrame({
'x': plyfile['vertex']['z'][::reduce_factor],
'y': plyfile['vertex']['x'][::reduce_factor],
'z': plyfile['vertex']['y'][::reduce_factor]
})
def do_PCA(armadillo):
#
# TODO: Write code to import the libraries required for PCA.
# Then, train your PCA on the armadillo dataframe. Finally,
# drop one dimension (reduce it down to 2D) and project the
# armadillo down to the 2D principal component feature space.
#
def load_ply_data(filename, point_num):
plydata = PlyData.read(filename)
pc = plydata['vertex'].data[:point_num]
pc_array = np.array([[pc[i][0], pc[i][1], pc[i][2]]
for i in range(len(pc))])
return pc_array
q = model["trs"]["rotation"]
s = model["trs"]["scale"]
id_cad = model["id_cad"]
catid_cad = model["catid_cad"]
outdir = os.path.abspath(opt.out + "/" + id_scan)
pathlib.Path(outdir).mkdir(parents=True, exist_ok=True)
if scan_file == "": # <-- do just once, because scene is same for all cad models
scan_file = params["scannet"] + "/" + id_scan + "/" + id_scan + "_vh_clean_2.ply"
Mscan = make_M_from_tqs(r["trs"]["translation"], r["trs"]["rotation"], r["trs"]["scale"])
assert os.path.exists(scan_file), scan_file + " does not exist."
with open(scan_file, 'rb') as read_file:
mesh_scan = PlyData.read(read_file)
for v in mesh_scan["vertex"]:
v1 = np.array([v[0], v[1], v[2], 1])
v1 = np.dot(Mscan, v1)
v[0] = v1[0]
v[1] = v1[1]
v[2] = v1[2]
with open(outdir + "/scan.ply", mode='wb') as f:
PlyData(mesh_scan).write(f)
cad_file = params["shapenet"] + "/" + catid_cad + "/" + id_cad + "/models/model_normalized.obj"
cad_mesh = pywavefront.Wavefront(cad_file, collect_faces=True, parse=True)
Mcad = make_M_from_tqs(t, q, s)
def parse_ply_file(ply_fn):
'''
element vertex 1522546
property float x
property float y
property float z
property float nx
property float ny
property float nz
property float tx
property float ty
property uchar red
property uchar green
property uchar blue
element face 3016249
property list uchar int vertex_indices
property int material_id
property int segment_id
property int category_id
'''
with open(ply_fn, 'r') as ply_fo:
plydata = PlyData.read(ply_fo)
num_ele = len(plydata.elements)
num_vertex = plydata['vertex'].count
num_face = plydata['face'].count
data_vertex = plydata['vertex'].data
data_face = plydata['face'].data
## vertex
vertex_eles = [
'x', 'y', 'z', 'nx', 'ny', 'nz', 'tx', 'ty', 'red', 'green', 'blue'
]
datas_vertex = {}
for e in vertex_eles:
datas_vertex[e] = np.expand_dims(data_vertex[e], axis=-1)
vertex_xyz = np.concatenate(
[datas_vertex['x'], datas_vertex['y'], datas_vertex['z']], axis=1)
vertex_nxnynz = np.concatenate(
[datas_vertex['nx'], datas_vertex['ny'], datas_vertex['nz']],
axis=1)
vertex_rgb = np.concatenate(
[datas_vertex['red'], datas_vertex['green'], datas_vertex['blue']],
axis=1)
## face
vertex_idx_per_face = data_face['vertex_indices']
vertex_idx_per_face = np.concatenate(vertex_idx_per_face, axis=0)
vertex_idx_per_face = np.reshape(vertex_idx_per_face, [-1, 3])
datas = {}
datas['xyz'] = vertex_xyz # (N,3)
datas['nxnynz'] = vertex_nxnynz # (N,3)
datas['color'] = vertex_rgb # (N,3)
datas['vidx_per_face'] = vertex_idx_per_face # (F,3)
datas['label_material'] = np.expand_dims(data_face['material_id'],
1) # (F,1)
datas['label_instance'] = np.expand_dims(data_face['segment_id'], 1)
datas['label_raw_category'] = np.expand_dims(data_face['category_id'],
1)
label_category = get_cat40_from_rawcat(data_face['category_id'])
datas['label_category'] = np.expand_dims(label_category, 1)
return datas
def extract_ply_data(filenames, min_points=1024):
"""
Collects all the point data from ply files, and places it into a list.
If the file does not contain enough points, ignore the file.
Param:
filenames: A list of filenames to extract data from. Use collect_files to get this list.
min_points: The minimum number of points needed to allow the file to be extracted.
"""
data_list = [] #(x,y,z,dtype=np.float32)
normal_list = [] #(normal,dtype=np.float32)
label_list = [] #(dtype=uint8)
point_labels = []
face_list = []
data_lengths = []
data = None
face_length = 0
for file_count in range(0, len(filenames)):
#get the filename (purely for print)
file_name = filenames[file_count][filenames[file_count].rfind('\\') +
1:]
plydata = PlyData.read(filenames[file_count])
#collect all of the data from the ply [[x,y,z,r,g,b][...]]
if (data != None):
face_length += len(data)
data = plydata['vertex'][:][:]
#print("Part number of points:" +str(len(data)))
#do not allow files that have less than min_points since this is our sample size.
if len(data) >= min_points:
#normal = calculate_normals(filenames[file_count])
label = get_label(filenames[file_count])
face = plydata['face'][:][:]
#add data and label to their respective lists.
if label != -1:
print(file_name + ": (" + label[0].capitalize() + ") " +
str(len(data)) + " points | " + str(len(face)) +
" faces")
label_val = [label[1]]
data_lengths.append(len(data))
data_list.extend(data)
label_list.append(label[1])
point_labels.extend(label_val * len(data))
#Offset Face indicies to the length of the last set of data
face = np.array(face.tolist())
if file_count != 0:
face += face_length
face_list.extend(face)
else:
print("Skipping " +
str(filenames[file_count] + ": Label Does Not Exist"))
else:
print("Skipping " +
str(filenames[file_count] + ": Not Enough Data"))
print("Number of Elements in Data: " + str(len(data_list)) +
" Total Faces: " + str(len(face_list)) + "\n")
#print(len(data_list))
return data_list, data_lengths, normal_list, label_list, point_labels, face_list
def process_file(i_mesh, f):
nonlocal i_sample
# Read the mesh
# libigl loader seems to leak memory in loop?
# verts, faces = utils.read_mesh(f)
plydata = PlyData.read(f)
verts = np.vstack((plydata['vertex']['x'], plydata['vertex']['y'],
plydata['vertex']['z'])).T
tri_data = plydata['face'].data['vertex_indices']
faces = np.vstack(tri_data)
# Compute total sample counts
n_vert_sample_tot = int(args.neigh_size / args.model_frac *
(1. - args.n_add))
n_surf_sample_tot = int(args.surface_size / (args.model_frac))
# sample points
vert_sample_pos, vert_sample_normal = get_samples(
verts, faces, n_vert_sample_tot)
if (args.n_add > 0):
n_vert_sample_noise = int(args.neigh_size / args.model_frac *
(args.n_add))
vert_sample_noise_pos, vert_sample_noise_normal = get_samples(
verts, faces, n_vert_sample_noise)
vert_sample_noise_pos += np.random.randn(n_vert_sample_noise,
3) * args.on_surface_dev
vert_sample_pos = np.concatenate(
(vert_sample_pos, vert_sample_noise_pos), axis=0)
vert_sample_normal = np.concatenate(
(vert_sample_normal, vert_sample_noise_normal), axis=0)
surf_sample_pos, surf_sample_normal = get_samples(
verts, faces, n_surf_sample_tot)
# Build nearest-neighbor structure
kd_tree_vert = spatial.KDTree(vert_sample_pos)
kd_tree_surf = spatial.KDTree(surf_sample_pos)
# Randomly sample vertices
last_sample = i_sample + counts[i_mesh]
while i_sample < last_sample:
print("generating sample {} / {} on mesh {}".format(
i_sample, args.n_samples, f))
# Random vertex
ind = np.random.randint(vert_sample_pos.shape[0])
center = surf_sample_pos[ind, :]
_, neigh_vert = kd_tree_vert.query(center, k=args.neigh_size)
_, neigh_surf = kd_tree_surf.query(center, k=args.surface_size)
result_vert_pos = vert_sample_pos[neigh_vert, :]
result_vert_normal = vert_sample_normal[neigh_vert, :]
result_surf_pos = surf_sample_pos[neigh_surf, :]
result_surf_normal = surf_sample_normal[neigh_surf, :]
# Write out the result
out_filename = os.path.join(
args.output_dir,
"neighborhood_points_{:06d}.npz".format(i_sample))
np.savez(out_filename,
vert_pos=result_vert_pos,
vert_normal=result_vert_normal,
surf_pos=result_surf_pos,
surf_normal=result_surf_normal)
i_sample = i_sample + 1
def read_ply_points(ply_path):
ply = PlyData.read(ply_path)
data = ply.elements[0].data
points = np.stack([data['x'], data['y'], data['z']], axis=1)
return points
def test_write_read(tet_ply_txt, tmpdir, text, byte_order):
ply0 = PlyData(tet_ply_txt.elements, text, byte_order,
tet_ply_txt.comments)
ply1 = write_read(ply0, tmpdir)
verify(ply0, ply1)
else:
assert (prop0 == prop1).all()
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')])
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 = '<'
def test_header_parse_error(s, line):
with Raises(PlyHeaderParseError) as e:
PlyData.read(BytesIO(s))
assert e.exc_val.line == line
def read_ply(filename):
""" read XYZ point cloud from filename PLY file """
plydata = PlyData.read(filename)
pc = plydata['vertex'].data
pc_array = np.array([[x, y, z] for x,y,z in pc])
return pc_array
def make_ply_string(dest_path, indices, vertices, rgba_color):
"""
Creates a ply str that can be included into a .k.zip for rendering
in KNOSSOS.
# TODO: write out normals
Parameters
----------
indices : np.array
vertices : np.array
rgba_color : Tuple[uint8] or np.array
Returns
-------
str
"""
# create header
vertices = vertices.astype(np.float32)
indices = indices.astype(np.int32)
if not indices.ndim == 2:
indices = np.array(indices, dtype=np.int).reshape((-1, 3))
if not vertices.ndim == 2:
vertices = np.array(vertices, dtype=np.float32).reshape((-1, 3))
if len(rgba_color) != len(vertices) and len(rgba_color) == 4:
# TODO: create per tree color instead of per vertex color
rgba_color = np.array([rgba_color for i in range(len(vertices))],
dtype=np.uint8)
else:
if not (len(rgba_color) == len(vertices) and len(rgba_color[0]) == 4):
msg = 'Color array has to be RGBA and to provide a color value f' \
'or every vertex!'
log_proc.error(msg)
raise ValueError(msg)
if not rgba_color.ndim == 2:
rgba_color = np.array(rgba_color, dtype=np.int).reshape((-1, 4))
if type(rgba_color) is list:
rgba_color = np.array(rgba_color, dtype=np.uint8)
log_proc.warn("Color input is list. It will now be converted "
"automatically, data will be unusable if not normalized"
" between 0 and 255. min/max of data:"
" {}, {}".format(rgba_color.min(), rgba_color.max()))
elif not np.issubdtype(rgba_color.dtype, np.uint8):
log_proc.warn("Color array is not of type integer or unsigned integer."
" It will now be converted automatically, data will be "
"unusable if not normalized between 0 and 255."
"min/max of data: {}, {}".format(rgba_color.min(),
rgba_color.max()))
rgba_color = np.array(rgba_color, dtype=np.uint8)
# ply file requires 1D object arrays,
vertices = np.concatenate(
[vertices.astype(np.object),
rgba_color.astype(np.object)], axis=1)
vertices = np.array([tuple(el) for el in vertices],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
('red', 'u1'), ('green', 'u1'), ('blue', 'u1'),
('alpha', 'u1')])
# ply file requires 1D object arrays.
indices = np.array([tuple([el], ) for el in indices],
dtype=[('vertex_indices', 'i4', (3, ))])
PlyData([
PlyElement.describe(vertices, 'vertex'),
PlyElement.describe(indices, 'face')
]).write(dest_path)
for m in image_metrics_network:
m.update_state(gt_probs, pred_probs)
q.put((tf.transpose(primitive_indices, (1, 0)).numpy(),
tf.transpose(pred_probs,
(1, 0, 2)).numpy(), index, color, gt_probs))
stream_out.stop()
print("Computing primitive annotations...")
pred_primitive_annotations = tf.convert_to_tensor(aggregator.get())
pred_primitive_dontcare = tf.reduce_sum(pred_primitive_annotations,
axis=-1) < dont_care_threshold
# Evaluate vertex metrics
if args.mode == "triangles" and args.mesh == "scannet" and float(
args.simplify) == 1.0:
gt_mesh = PlyData.read(
os.path.join(scene, name + "_vh_clean_2.labels.ply"))
# Load mapping from vertex to faces
print("Creating map between faces and vertices...")
keys = list(gt_mesh["face"].data.dtype.fields.keys())
if len(keys) != 1:
print(f"Invalid mesh file: {input_mesh_file}")
sys.exit(-1)
face_to_vertices = np.asarray(
[np.asarray(d) for d in gt_mesh["face"].data[keys[0]]])
vertex_to_faces_dict = defaultdict(set)
for face, vertices in enumerate(face_to_vertices):
for vertex in vertices:
vertex_to_faces_dict[vertex].add(face)
max_len = max([len(faces) for faces in vertex_to_faces_dict.values()])
vertex_to_faces = []
def load_ply_normal(filename, point_num):
plydata = PlyData.read(filename)
pc = plydata['normal'].data[:point_num]
pc_array = np.array([[x, y, z] for x, y, z in pc])
return pc_array
with open(ARGS_.scene_json) as f:
#skeleton = json.load(f)["frames"][60]["skeletons"][0]["bones"]
skeleton = json.load(f)["skeletons"][0]["pose_reference"]
pose_ref = None
#with open(ARGS_.pose_reference) as f:
# pose_reference = json.load(f)
pose_ref = pose_reference(skeleton, bones_names)
output_error = None
with open(ARGS_.output_error) as f:
output_error = json.load(f)
cloud = None
with open(ARGS_.pointcloud, 'rb') as f:
cloud = PlyData.read(f)
cloud = [
cloud['vertex']['x'], cloud['vertex']['y'], cloud['vertex']['z']
]
#np.vstack((cloud['vertex']['x'],
# cloud['vertex']['y'],
# cloud['vertex']['z']))
#pose = rebuild_pose_from_quaternion(pose_ref, output_error['output'])
pose = rebuild_pose_from_quaternion3(pose_ref,
output_error['output_ground_truth'])
print(len(pose))
plot_pose(pose, cloud, title="Pose")
plt.show()
import sys
import os
sys.path.insert(0, './src/core')
from numpy.random import uniform, seed
from matplotlib.mlab import griddata
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import axes3d
from matplotlib import cm
from pylab import *
import numpy as np
from plyfile import PlyData, PlyElement
import scipy
matplotlib.style.use('classic') #in matplotlib >= 1.5.1
plydata = PlyData.read(open(os.path.expanduser(decos_dem_file)))
vertex = plydata['vertex'].data
[px, py, pz] = (vertex[t] for t in ('x', 'y', 'z'))
# define grid.
npts=500
xi = np.linspace(min(px), max(px), npts)
yi = np.linspace(min(py), max(py), npts)
# grid the data.
zi = griddata(px, py, pz, xi, yi, interp='linear')
############
### PLOT ###
from mpl_toolkits.mplot3d import Axes3D
from plyfile import PlyData, PlyElement
# Every 100 data samples, we save 1. If things run too
# slow, try increasing this number. If things run too fast,
# try decreasing it... =)
reduce_factor = 10
# Look pretty...
matplotlib.style.use('ggplot')
# Load up the scanned armadillo
plyfile = PlyData.read('Datasets/stanford_armadillo.ply')
armadillo = pd.DataFrame({
'x':plyfile['vertex']['z'][::reduce_factor],
'y':plyfile['vertex']['x'][::reduce_factor],
'z':plyfile['vertex']['y'][::reduce_factor]
})
def do_PCA(armadillo):
#
# TODO: Write code to import the libraries required for PCA.
# Then, train your PCA on the armadillo dataframe. Finally,
# drop one dimension (reduce it down to 2D) and project the
# armadillo down to the 2D principal component feature space.
#
def get_point_cloud(point_cloud_id, number_points=None, history=None):
from voxel_globe.meta import models
from vpgl_adaptor import convert_local_to_global_coordinates_array, create_lvcs
import os
import numpy as np
from plyfile import PlyData
point_cloud = models.PointCloud.objects.get(id=point_cloud_id).history(history)
lvcs = create_lvcs(point_cloud.origin[1], point_cloud.origin[0], point_cloud.origin[2], 'wgs84')
ply = PlyData.read(str(os.path.join(point_cloud.directory, 'error.ply')))
data = ply.elements[0].data
if number_points:
try:
import heapq
data = np.array(heapq.nlargest(number_points, ply.elements[0].data,
key=lambda x:x['prob']))
except IndexError: #not a correctly formated ply file. HACK A CODE!
#This is a hack-a-code for Tom's ply file
data = ply.elements[0].data.astype([('x', '<f4'), ('y', '<f4'),
('z', '<f4'), ('red', 'u1'), ('green', 'u1'), ('blue', 'u1'),
('prob', '<f4')])
import copy
blah = copy.deepcopy(data['y'])
data['y'] = data['z']
data['z'] = -blah
blah = copy.deepcopy(data['blue'])
data['blue'] = data['green']
data['green'] = blah
data['prob'] = abs(data['x'] - 10 - sum(data['x'])/len(data['x'])) \
+ abs(data['y'] + 30 - sum(data['y'])/len(data['y'])) \
+ abs(data['z'] - sum(data['z'])/len(data['z']))
data['prob'] = max(data['prob']) - data['prob']
data = np.array(heapq.nlargest(number_points, data,
key=lambda x:x['prob']))
print data['prob']
lla = convert_local_to_global_coordinates_array(lvcs, data['x'].tolist(), data['y'].tolist(), data['z'].tolist());
latitude = np.array(lla[0])
longitude = np.array(lla[1])
altitude = np.array(lla[2])
color = map(lambda r,b,g:'#%02x%02x%02x' % (r, g, b), data['red'], data['green'], data['blue'])
return_data = {"latitude": latitude, "longitude": longitude,
"altitude": altitude, "color": color}
try:
return_data['le'] = data['le']
except ValueError:
return_data['le'] = (-np.ones(len(latitude))).tolist()
try:
return_data['ce'] = data['ce']
except ValueError:
return_data['ce'] = (-np.ones(len(latitude))).tolist()
return return_data
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)
import numpy as np
from numpy.linalg import norm
from plyfile import PlyData, make2d
import zipfile
filename = PINS.filename.get()
if filename.endswith(".zip"):
zipf = zipfile.ZipFile(filename)
assert len(zipf.namelist()) == 1
zply = zipf.open(zipf.namelist()[0])
plydata = PlyData.read(zply)
else:
plydata = PlyData.read(filename)
elements = {e.name: e for e in plydata.elements}
vertices = elements["vertex"].data
faces = elements["face"].data
#faces => indices + edges
indices = make2d(faces['vertex_indices']).astype(np.uint16)
assert indices.shape[1] == 3 #triangles only
edges = set()
for triangle in indices:
for p1, p2 in ((0, 1), (1, 2), (2, 0)):
i1, i2 = triangle[p1], triangle[p2]
if i2 < i1: i1, i2 = i2, i1
edges.add((i1, i2))
edges = np.array(list(edges), dtype=np.uint16)
#vertices => coordinates + normals
for n in range(len(vertices.dtype)):
elev = read_view_angle(view_file, i) * 40.
azim = read_view_angle(view_file, i, elev=False) * 180.
elev = elev[0][0]
#if elev < 0:
# elev += 360.
azim = azim[0][0]
#if azim < 0:
# azim += 360.
i = 0
t += 1
for path in paths:
target_path = os.path.join(PLOTS_PATH, tag + "-" + str(i) + ".png")
ply_file = os.path.join(path, tag + ".ply")
i += 1
ply_data = PlyData.read(ply_file)
points = ply_data['vertex']
pc = np.vstack([points['x'], points['y'], points['z']]).T
fig = plot_3d_point_cloud(pc[:, 0],
pc[:, 1],
pc[:, 2],
show=False,
elev=elev,
azim=azim,
colorize='rainbow',
filename=target_path)
#fig.close('all')
image = np.array(Image.open(target_path)) / 255.0
images.append(image)
print(str(t), view_file, ply_file, "-->", target_path, elev, azim)
plot_images(1, 5, images, tag + ".png", dir_name="point_clouds")
def filter_depth(scan_folder, out_folder, plyfilename):
# the pair file
pair_file = os.path.join(scan_folder, "pair.txt")
# for the final point cloud
vertexs = []
vertex_colors = []
pair_data = read_pair_file(pair_file)
score_data = read_score_file(pair_file)
nviews = len(pair_data)
# TODO: hardcode size
# used_mask = [np.zeros([296, 400], dtype=np.bool) for _ in range(nviews)]
# for each reference view and the corresponding source views
ct2 = -1
for ref_view, src_views in pair_data:
ct2 += 1
# load the camera parameters
ref_intrinsics, ref_extrinsics = read_camera_parameters(
os.path.join(scan_folder, 'cams/{:0>8}.txt'.format(ref_view)))
# load the reference image
ref_img = read_img(
os.path.join(scan_folder, 'images/{:0>8}.jpg'.format(ref_view)))
# load the estimated depth of the reference view
ref_depth_est = read_pfm(
os.path.join(out_folder,
'depth_est_0/{:0>8}.pfm'.format(ref_view)))[0]
import cv2
#ref_img=cv2.pyrDown(ref_img)
#ref_depth_est=cv2.pyrUp(ref_depth_est)
#ref_depth_est=cv2.pyrDown(ref_depth_est)
# load the photometric mask of the reference view
confidence = read_pfm(
os.path.join(out_folder,
'confidence_0/{:0>8}.pfm'.format(ref_view)))[0]
#confidence=cv2.pyrUp(confidence)
#confidence=cv2.pyrDown(confidence)
#ref_img=cv2.pyrDown(ref_img)
#ref_depth_est=cv2.resize(ref_depth_est,(ref_img.shape[1],ref_img.shape[0]))
#confidence=cv2.resize(confidence,(ref_img.shape[1],ref_img.shape[0]))
photo_mask = confidence > 0.3
# photo_mask = confidence>=0
# photo_mask = confidence > confidence.mean()
# ref_depth_est=ref_depth_est * photo_mask
all_srcview_depth_ests = []
all_srcview_x = []
all_srcview_y = []
all_srcview_geomask = []
# compute the geometric mask
geo_mask_sum = 0
geo_mask_sums = []
ct = 0
for src_view in src_views:
ct = ct + 1
# camera parameters of the source view
src_intrinsics, src_extrinsics = read_camera_parameters(
os.path.join(scan_folder, 'cams/{:0>8}.txt'.format(src_view)))
# the estimated depth of the source view
src_depth_est = read_pfm(
os.path.join(out_folder,
'depth_est_0/{:0>8}.pfm'.format(src_view)))[0]
#src_depth_est=cv2.resize(src_depth_est,(ref_img.shape[1],ref_img.shape[0]))
#src_depth_est=cv2.pyrUp(src_depth_est)
#src_depth_est=cv2.pyrDown(src_depth_est)
src_confidence = read_pfm(
os.path.join(out_folder,
'confidence_0/{:0>8}.pfm'.format(src_view)))[0]
# src_mask=src_confidence>0.1
# src_mask=src_confidence>src_confidence.mean()
# src_depth_est=src_depth_est*src_mask
masks, geo_mask, depth_reprojected, x2d_src, y2d_src = check_geometric_consistency(
ref_depth_est, ref_intrinsics, ref_extrinsics, src_depth_est,
src_intrinsics, src_extrinsics)
if (ct == 1):
for i in range(2, 11):
geo_mask_sums.append(masks[i - 2].astype(np.int32))
else:
for i in range(2, 11):
geo_mask_sums[i - 2] += masks[i - 2].astype(np.int32)
geo_mask_sum += geo_mask.astype(np.int32)
all_srcview_depth_ests.append(depth_reprojected)
# all_srcview_x.append(x2d_src)
# all_srcview_y.append(y2d_src)
# all_srcview_geomask.append(geo_mask)
geo_mask = geo_mask_sum >= 10
for i in range(2, 11):
geo_mask = np.logical_or(geo_mask, geo_mask_sums[i - 2] >= i)
depth_est_averaged = (sum(all_srcview_depth_ests) +
ref_depth_est) / (geo_mask_sum + 1)
if (not isinstance(geo_mask, bool)):
final_mask = np.logical_and(photo_mask, geo_mask)
os.makedirs(os.path.join(out_folder, "mask"), exist_ok=True)
save_mask(
os.path.join(out_folder,
"mask/{:0>8}_photo.png".format(ref_view)),
photo_mask)
save_mask(
os.path.join(out_folder,
"mask/{:0>8}_geo.png".format(ref_view)), geo_mask)
save_mask(
os.path.join(out_folder,
"mask/{:0>8}_final.png".format(ref_view)),
final_mask)
print(
"processing {}, ref-view{:0>2}, photo/geo/final-mask:{}/{}/{}".
format(scan_folder, ref_view, photo_mask.mean(),
geo_mask.mean(), final_mask.mean()))
if args.display:
import cv2
cv2.imshow('ref_img', ref_img[:, :, ::-1])
cv2.imshow('ref_depth', ref_depth_est / 800)
cv2.imshow('ref_depth * photo_mask',
ref_depth_est * photo_mask.astype(np.float32) / 800)
cv2.imshow('ref_depth * geo_mask',
ref_depth_est * geo_mask.astype(np.float32) / 800)
cv2.imshow('ref_depth * mask',
ref_depth_est * final_mask.astype(np.float32) / 800)
cv2.waitKey(0)
height, width = depth_est_averaged.shape[:2]
x, y = np.meshgrid(np.arange(0, width), np.arange(0, height))
# valid_points = np.logical_and(final_mask, ~used_mask[ref_view])
valid_points = final_mask
print("valid_points", valid_points.mean())
x, y, depth = x[valid_points], y[valid_points], depth_est_averaged[
valid_points]
color = ref_img[:, :, :][valid_points] # hardcoded for DTU dataset
xyz_ref = np.matmul(np.linalg.inv(ref_intrinsics),
np.vstack((x, y, np.ones_like(x))) * depth)
xyz_world = np.matmul(np.linalg.inv(ref_extrinsics),
np.vstack((xyz_ref, np.ones_like(x))))[:3]
vertexs.append(xyz_world.transpose((1, 0)))
vertex_colors.append((color * 255).astype(np.uint8))
# # set used_mask[ref_view]
# used_mask[ref_view][...] = True
# for idx, src_view in enumerate(src_views):
# src_mask = np.logical_and(final_mask, all_srcview_geomask[idx])
# src_y = all_srcview_y[idx].astype(np.int)
# src_x = all_srcview_x[idx].astype(np.int)
# used_mask[src_view][src_y[src_mask], src_x[src_mask]] = True
vertexs = np.concatenate(vertexs, axis=0)
vertex_colors = np.concatenate(vertex_colors, axis=0)
vertexs = np.array([tuple(v) for v in vertexs],
dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
vertex_colors = np.array([tuple(v) for v in vertex_colors],
dtype=[('red', 'u1'), ('green', 'u1'),
('blue', 'u1')])
vertex_all = np.empty(len(vertexs),
vertexs.dtype.descr + vertex_colors.dtype.descr)
for prop in vertexs.dtype.names:
vertex_all[prop] = vertexs[prop]
for prop in vertex_colors.dtype.names:
vertex_all[prop] = vertex_colors[prop]
el = PlyElement.describe(vertex_all, 'vertex')
PlyData([el]).write(plyfilename)
print("saving the final model to", plyfilename)
def outputPly(data, name):
d2 = np.empty(data.shape[0], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
for i in range(data.shape[0]):
d2[i] = tuple(data[i])
el = PlyElement.describe(d2, 'vertex')
PlyData([el]).write(name + '.ply')
def __init__(self, model_path, K, H, W, backend="pyglet"):
app.use_app(backend)
app.Canvas.__init__(self, show=False, size=(W,H))
self.size = (W,H) #(W,H)
self.K = K.copy()
fragment_code = """
#version 130
varying vec3 fragpos;
varying vec3 normal;
varying vec3 fragmentColor;
out vec4 color;
varying vec3 viewPos;
uniform vec3 light_direction;
void main()
{
vec3 norm = normal;
vec3 lightDirA = normalize(-light_direction - fragpos);
vec3 diffuseA = vec3(0.4, 0.4, 0.4) * max(dot(norm, lightDirA), 0.0);
vec4 colors = vec4(fragmentColor, 1);
vec3 light_3 = diffuseA + vec3(0.65, 0.65, 0.65);
vec4 light = vec4(light_3, 1.0f);
color = clamp(light * colors, 0.0, 1.0);
}
"""
vertex_code = """
#version 130
attribute vec3 a_position;
attribute vec3 a_color;
attribute vec3 a_normal;
varying vec3 fragmentColor;
varying vec3 normal;
varying vec3 fragpos;
varying vec3 viewPos;
uniform mat4 view;
uniform mat4 proj;
void main()
{
fragmentColor = a_color;
gl_Position = proj * view * vec4(a_position, 1.0);
fragpos = a_position;
viewPos = vec3(view);
normal = a_normal;
}
"""
print('model_path: ',model_path)
if '.ply' in model_path:
ply = PlyData.read(model_path)
vertices = np.stack((ply['vertex']['x'].reshape(-1), ply['vertex']['y'].reshape(-1), ply['vertex']['z'].reshape(-1)), axis=-1)
assert vertices.shape[1]==3
face_indices = ply['face']['vertex_indices']
face_indices = np.stack(face_indices, axis=0)
assert face_indices.shape[1]==3
vertex_color = np.stack((ply['vertex']['red'].reshape(-1), ply['vertex']['green'].reshape(-1), ply['vertex']['blue'].reshape(-1)), axis=-1)
vertex_normal = np.stack((ply['vertex']['nx'].reshape(-1), ply['vertex']['ny'].reshape(-1), ply['vertex']['nz'].reshape(-1)), axis=-1)
vertex_normal = vertex_normal/np.linalg.norm(vertex_normal, axis=1).reshape(-1,1)
else:
print('vispy model_path has to be a ply file')
raise RuntimeError
self.data = np.ones(vertices.shape[0], [('a_position', np.float32, 3),('a_color', np.float32, 3),('a_normal', np.float32, 3)])
self.data['a_position'] = vertices.copy()
self.data['a_color'] = vertex_color/255.0
self.data['a_normal'] = vertex_normal.copy()
self.vertex_buffer = gloo.VertexBuffer(self.data)
self.index_buffer = gloo.IndexBuffer(face_indices.reshape(-1).astype(np.uint32))
self.program = gloo.Program(vertex_code, fragment_code)
self.program.bind(self.vertex_buffer)
self.update_cam_mat(self.K, 0, self.size[0], self.size[1], 0)
self.fbo = gloo.FrameBuffer(gloo.Texture2D(shape=(self.size[1],self.size[0],3)), gloo.RenderBuffer(self.size[::-1]))
self.rgb = None
self.depth = None
parser = argparse.ArgumentParser(description='Modifies ply file to be used for rendering.\n Example: ./plyScale.py -f input.ply -o out.ply -r 210 -cutX 10.0')
parser.add_argument('-f','--inputFile', help='Input file name', required=True)
parser.add_argument('-o','--outputFile', help='Output file name', required=True)
parser.add_argument('--lx', help='Desired size of bounding box (X axis)', required=False, default="0")
parser.add_argument('--ly', help='Desired size of bounding box (Y axis)', required=False, default="0")
parser.add_argument('--lz', help='Desired size of bounding box (Z axis)', required=False, default="0")
parser.add_argument('-r','--order', help='Reorder axis. By default 012, to swap x and z use 210', required=False, default="012")
helpStringForCut = 'Remove all the faces which are above specified value for %s. The origin is in the center of mass. If axis reordering was applied, axis are in new coordinates.'
parser.add_argument('--cutX', help=helpStringForCut%('X'), required=False, default="none")
parser.add_argument('--cutY', help=helpStringForCut%('Y'), required=False, default="none")
parser.add_argument('--cutZ', help=helpStringForCut%('Z'), required=False, default="none")
args = vars(parser.parse_args())
desiredBox = [float(args['lx']), float(args['ly']), float(args['lz'])]
plydata = PlyData.read(args['inputFile'])
vertices = plydata['vertex'].data
# swap coords
order = args['order']
if (order != "012"):
idx = [int(order[i]) for i in range(0, len(order))]
assert(len(idx) == 3)
print "Swapping axis!"
for i in range(0, len(vertices)):
v = copy.deepcopy(vertices[i])
for dim in range(0, 3):
vertices[i][dim] = v[ idx[dim] ]
# Current box
def filter_depth(dataset_root, scan, out_folder, plyfilename):
print("Starting fusion for:"+out_folder)
# the pair file
pair_file = os.path.join(dataset_root,'Cameras/pair.txt')
# for the final point cloud
vertexs = []
vertex_colors = []
pair_data = read_pair_file(pair_file)
nviews = len(pair_data)
# for each reference view and the corresponding source views
for ref_view, src_views in pair_data:
# load the camera parameters
ref_intrinsics, ref_extrinsics = read_camera_parameters(
os.path.join(dataset_root, 'Cameras/{:0>8}_cam.txt'.format(ref_view)))
# load the reference image
ref_img = read_img(os.path.join(dataset_root, "Rectified",scan, 'rect_{:03d}_3_r5000.png'.format(ref_view+1))) # Image start from 1.
# load the estimated depth of the reference view
ref_depth_est, scale = read_pfm(os.path.join(out_folder, 'depth_est/{:0>8}.pfm'.format(ref_view)))
# load the photometric mask of the reference view
confidence, scale = read_pfm(os.path.join(out_folder, 'confidence/{:0>8}.pfm'.format(ref_view)))
photo_mask = confidence > 0.9
all_srcview_depth_ests = []
all_srcview_x = []
all_srcview_y = []
all_srcview_geomask = []
# compute the geometric mask
geo_mask_sum = 0
for src_view in src_views:
# camera parameters of the source view
src_intrinsics, src_extrinsics = read_camera_parameters(
os.path.join(dataset_root, 'Cameras/{:0>8}_cam.txt'.format(src_view)))
# the estimated depth of the source view
src_depth_est, scale = read_pfm(os.path.join(out_folder, 'depth_est/{:0>8}.pfm'.format(src_view)))
geo_mask, depth_reprojected, x2d_src, y2d_src = check_geometric_consistency(ref_depth_est, ref_intrinsics, ref_extrinsics,
src_depth_est,
src_intrinsics, src_extrinsics)
geo_mask_sum += geo_mask.astype(np.int32)
all_srcview_depth_ests.append(depth_reprojected)
all_srcview_x.append(x2d_src)
all_srcview_y.append(y2d_src)
all_srcview_geomask.append(geo_mask)
depth_est_averaged = (sum(all_srcview_depth_ests) + ref_depth_est) / (geo_mask_sum + 1)
# at least 3 source views matched
geo_mask = geo_mask_sum >= 3
final_mask = np.logical_and(photo_mask, geo_mask)
os.makedirs(os.path.join(out_folder, "mask"), exist_ok=True)
save_mask(os.path.join(out_folder, "mask/{:0>8}_photo.png".format(ref_view)), photo_mask)
save_mask(os.path.join(out_folder, "mask/{:0>8}_geo.png".format(ref_view)), geo_mask)
save_mask(os.path.join(out_folder, "mask/{:0>8}_final.png".format(ref_view)), final_mask)
print("processing {}, ref-view{:0>2}, photo/geo/final-mask:{}/{}/{}".format(scan, ref_view,
photo_mask.mean(),
geo_mask.mean(), final_mask.mean()))
height, width = depth_est_averaged.shape[:2]
x, y = np.meshgrid(np.arange(0, width), np.arange(0, height))
# valid_points = np.logical_and(final_mask, ~used_mask[ref_view])
valid_points = final_mask
print("valid_points", valid_points.mean())
x, y, depth = x[valid_points], y[valid_points], depth_est_averaged[valid_points]
ref_img = np.array(ref_img)
color = ref_img[valid_points]
xyz_ref = np.matmul(np.linalg.inv(ref_intrinsics),
np.vstack((x, y, np.ones_like(x))) * depth)
xyz_world = np.matmul(np.linalg.inv(ref_extrinsics),
np.vstack((xyz_ref, np.ones_like(x))))[:3]
vertexs.append(xyz_world.transpose((1, 0)))
vertex_colors.append((color).astype(np.uint8))
vertexs = np.concatenate(vertexs, axis=0)
vertex_colors = np.concatenate(vertex_colors, axis=0)
vertexs = np.array([tuple(v) for v in vertexs], dtype=[('x', 'f4'), ('y', 'f4'), ('z', 'f4')])
vertex_colors = np.array([tuple(v) for v in vertex_colors], dtype=[('red', 'u1'), ('green', 'u1'), ('blue', 'u1')])
vertex_all = np.empty(len(vertexs), vertexs.dtype.descr + vertex_colors.dtype.descr)
for prop in vertexs.dtype.names:
vertex_all[prop] = vertexs[prop]
for prop in vertex_colors.dtype.names:
vertex_all[prop] = vertex_colors[prop]
el = PlyElement.describe(vertex_all, 'vertex')
print("Saving the final model to", plyfilename)
PlyData([el], comments=['Model created by CVP-MVSNet.']).write(plyfilename)
print("Model saved.")
