コード例 #1
0
ファイル: duplicate.py プロジェクト: stpsomad/DynamicPCDMS
def writeFile(directory,name,header,coords):
    """Write a laz file using laspy and numpy arrays"""
    output = File(directory + name, mode = "w", header=header)
    output.x = coords[0]
    output.y = coords[1]
    output.z = coords[2]
    output.close()
コード例 #2
0
def store_point_cloud(filepath: str, points: np.ndarray, header):

    outFile = File(filepath, mode="w", header=header)
    outFile.x = points[:, 0] + header.min[0]
    outFile.y = points[:, 1] + header.min[1]
    outFile.z = points[:, 2] + header.min[2]
    outFile.close()
コード例 #3
0
 def write_las_grid(self,filename, lb = -10, ub = 10, granularity = 0.1):
     out_file = File(filename, mode = "w", header = Header())
     out_file.header.scale = (0.001,0.001,0.001)
     grid = self.get_3d_grid(lb, ub, granularity)
     out_file.x = grid[:,0]* 300
     out_file.y = grid[:,1] * 300
     out_file.z = grid[:,2] * 300
     out_file.intensity = grid[:,2] * 300
     return(out_file)
コード例 #4
0
 def write_las_grid(self, filename, lb=-10, ub=10, granularity=0.1):
     out_file = File(filename, mode="w", header=Header())
     out_file.header.scale = (0.001, 0.001, 0.001)
     grid = self.get_3d_grid(lb, ub, granularity)
     out_file.x = grid[:, 0] * 300
     out_file.y = grid[:, 1] * 300
     out_file.z = grid[:, 2] * 300
     out_file.intensity = grid[:, 2] * 300
     return (out_file)
コード例 #5
0
def make_las_file(data, file_name=''):
    my_header = header.Header()
    outFile = File(file_name, mode='w', header=my_header)

    # outFile.header.offset = np.amin(data, axis=0)[0:3]
    outFile.header.scale = [1, 1, 1]

    outFile.x = data[:, 0]
    outFile.y = data[:, 1]
    outFile.z = data[:, 2]
    outFile.raw_classification = data[:, 3]

    outFile.close()
コード例 #6
0
min_x = np.min(in_pc_nparray[:, 0]) + shift
max_x = np.max(in_pc_nparray[:, 0]) + shift
step_x = resolution

min_y = np.min(in_pc_nparray[:, 1]) + shift
max_y = np.max(in_pc_nparray[:, 1]) + shift
step_y = resolution

bound_x = np.arange(min_x, max_x, step_x)
bound_y = np.arange(min_y, max_y, step_y)

target_x, target_y = np.meshgrid(bound_x, bound_y, indexing='ij')

# export as XYZ pcloud

x = np.ravel(target_x)
y = np.ravel(target_y)
z = np.ones(len(x))

false_intensity = np.zeros(len(x))

out_LAS = File(filename + "_target.las", mode="w", header=in_pc.header)
out_LAS.x = x
out_LAS.y = y
out_LAS.z = z
out_LAS.intensity = false_intensity
out_LAS.close()

end1 = time.time()
difftime1 = end1 - start1
print(("create target point: %f sec") % (difftime1))
コード例 #7
0
pointCloud = VtkPointCloud()

sliced = naive_slice_from_las(
    input_file, AxisAlignedBox3D([204.24, -6.7, -1.9], [208.46, -3.24, 3.5]))
# sliced = [[1, 1, 1]]
print("Number of points sliced: %d" % len(sliced))
# for point in sliced:
#     pointCloud.addPoint(point)
#
#     outFile.write(point)
# pdb.set_trace()
allx = np.array([sliced[i][0] for i in range(len(sliced))])
ally = np.array([sliced[i][1] for i in range(len(sliced))])
allz = np.array([sliced[i][2] for i in range(len(sliced))])
outFile.x = allx
outFile.y = ally
outFile.z = allz
# print("Number of points: %d" % len(sliced))
# print('Plotting')
# # Renderer
# renderer = vtk.vtkRenderer()
# renderer.AddActor(pointCloud.vtkActor)
# renderer.SetBackground(.2, .3, .4)
# renderer.ResetCamera()
#
# # Render Window
# renderWindow = vtk.vtkRenderWindow()
# renderWindow.AddRenderer(renderer)
#
# # Interactor
コード例 #8
0
# Prepare data for writing
pred_data = pred_data.assign(preds_write = 0)
pred_data.loc[pred_data['preds'] == 'barren', 'preds_write'] = 1  
pred_data.loc[pred_data['preds'] == 'cropland', 'preds_write'] = 2  
pred_data.loc[pred_data['preds'] == 'grassland', 'preds_write'] = 3  
pred_data.loc[pred_data['preds'] == 'road', 'preds_write'] = 4  
pred_data.loc[pred_data['preds'] == 'shadow', 'preds_write'] = 5  
pred_data.loc[pred_data['preds'] == 'shrubland', 'preds_write'] = 6  
pred_data.loc[pred_data['preds'] == 'trees', 'preds_write'] = 7  
pred_data.loc[pred_data['preds'] == 'water', 'preds_write'] = 8 
pred_data.loc[pred_data['preds'] == 'waterveg', 'preds_write'] = 9 

pred_data['preds_write'].value_counts() 

# Save to las
headfile = File(os.path.join(direct, '0-0-0-0.las'), mode="r")
header = headfile.header
outfile = File("classified_pc.las", mode="w", header=header)
outfile.x = pred_data['x'].to_numpy()
outfile.y = pred_data['y'].to_numpy()
outfile.z = pred_data['z'].to_numpy()
outfile.red = pred_data['red'].to_numpy()
outfile.green = pred_data['green'].to_numpy()
outfile.blue = pred_data['blue'].to_numpy()
outfile.classification = pred_data['preds_write'].to_numpy()
outfile.close()

# Clean
del bound, bound_mask, coords, direct, dsm_sd9, pred_X, pred_data, prednames
del preds
コード例 #9
0
                                 data_type=9,
                                 description="Spatial feature")
    out_LAS.define_new_dimension(name="eigenentropy" + "_" + str(k),
                                 data_type=9,
                                 description="Spatial feature")
    out_LAS.define_new_dimension(name="sum_eigenvalues" + "_" + str(k),
                                 data_type=9,
                                 description="Spatial feature")
    out_LAS.define_new_dimension(name="curvature" + "_" + str(k),
                                 data_type=9,
                                 description="Spatial feature")
    #out_LAS.define_new_dimension(name="classification"+"_"+str(k),data_type=9, description="reference")

    print(point_cloud.columns)

    out_LAS.x = point_cloud['x']
    #point_cloud.drop('x')

    out_LAS.y = point_cloud['y']
    out_LAS.z = point_cloud['z']
    out_LAS.intensity = point_cloud['intensity']
    out_LAS.return_num = point_cloud['return_number']
    #print(point_cloud["number_of_returns"])
    point_cloud["number_of_returns"] = point_cloud["number_of_returns"]
    #print(point_cloud["number_of_returns"])
    out_LAS.num_returns = point_cloud['number_of_returns']

    #Setting attributes Maybe do this with "try" ?
    setattr(out_LAS, 'delta_z' + "_" + str(k), point_cloud['delta_z'])
    #point_cloud.drop('delta_z')
    setattr(out_LAS, 'std_z' + "_" + str(k), point_cloud['std_z'])