def get_stats_by_geom(filename, poly): inFile = File(filename, mode="r") results = spatial.las_within(inFile, poly["rings"], ["z"]) inFile.close() stats = spatial.las_statistics(results["points"]) json = js.dumps(stats) return json
def read_files(files, srs, group_name): """ Open a .las file and extract information from header block. Then add information to a record in the database. """ for las_file in files: las = File(las_file.file.name, mode='r') lidar_obj = LidarFiles() lidar_obj.name = las_file lidar_obj.group = group_name lidar_obj.srs = SpatialReference( srs) # srs saved as user selection TXSP lidar_obj.bbox = get_bbox(las, srs) # srs saved as 3857 for web maps lidar_obj.web_srs = lidar_obj.bbox.srid lidar_obj.centroid = lidar_obj.bbox.centroid # srs saved as 3857 for web maps lidar_obj.point_count = get_point_count(las) lidar_obj.epsg = lidar_obj.srs.srid lidar_obj.file_size = float(las_file.size) x_scale, y_scale, z_scale = get_scale(las) lidar_obj.scale = (x_scale, y_scale, z_scale) offsets = get_offset(las) lidar_obj.offset = offsets mins_maxs = get_min_max(las) lidar_obj.min_max_XYZ = mins_maxs lidar_obj.version = get_version(las) lidar_obj.date_created = get_creation_date(las) lidar_obj.las_file = las_file lidar_obj.sys_id = get_system_identifier(las) lidar_obj.software_id = get_software_id(las) lidar_obj.save() las.close() return
def load_lidar_info(lidar_directory): print("Loading LIDARs data...") f = open(l_file, "w") for base, dirs, files in os.walk(lidar_directory): for lidar_file in files: lidar_file = lidar_directory + lidar_file f.write(lidar_file) os.system(laszip + " -i " + lidar_file + " -o " + lidar_file[:-3] + "LAS") inFile = File(lidar_file[:-3] + "LAS", mode='r') x_min = inFile.header.min[0] x_max = inFile.header.max[0] y_min = inFile.header.min[1] y_max = inFile.header.max[1] f.write(" " + str(x_min) + " " + str(y_min) + " " + str(x_max) + " " + str(y_max) + "\n") inFile.close() os.system("rm " + lidar_file[:-3] + "LAS") f.close() print("Load successful")
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()
def importLidarDataToScene(context, filepath): # Get a reference to the scene scn = bpy.context.scene # Create a new mesh me = bpy.data.meshes.new("LiDARMesh") # Create a new object with the mesh obj = bpy.data.objects.new("LiDARObj", me) # Link the object to the scene scn.collection.objects.link(obj) # Read the file inFile = File(filepath, mode="r") # Get all the points point_records = inFile.points # X,Y,Z Coords Array coords = np.vstack((inFile.x, inFile.y, inFile.z)).transpose() # Update the Mesh me.from_pydata(coords, [], []) me.update() # Center to Origin obj.select_set(True) bpy.ops.object.origin_set(type='GEOMETRY_ORIGIN', center='MEDIAN') # Close the File inFile.close() return {'FINISHED'}
def write_las_file(self): """ Create and write a new lidar file with the desirable points """ if self.surfaces: self.out_full_path = os.path.join( self.out_dir, ('Surfaces_' + self.templates_dict['las'].format(self.name))) elif self.terrain: self.out_full_path = os.path.join( self.out_dir, ('Terrain_' + self.templates_dict['las'].format(self.name))) out_file = File(self.out_full_path, mode='w', header=self.in_file.header) if self.terrain: class_2_points, class_2_bool = self.get_points_by_class( self.class_flag) out_file.points = self.in_file.points[class_2_bool] elif self.surfaces: out_file.points = self.in_file.points[self.in_file.return_num == 1] out_file.close()
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()
def __init__(self, points_file, class_file=''): # Load points file if points_file.endswith('.las') or points_file.endswith('.laz'): lfile = LasFile(points_file, mode='r') self.x = np.copy(lfile.X).astype('f8') * lfile.header.scale[0] self.y = np.copy(lfile.Y).astype('f8') * lfile.header.scale[1] self.z = np.copy(lfile.Z).astype('f8') * lfile.header.scale[2] self.i = np.copy(lfile.Intensity).astype('f8') self.r = np.copy(lfile.return_num).astype('f8') self.c = np.copy(lfile.Classification) lfile.close() elif points_file.endswith('.txt'): data = np.loadtxt(points_file, delimiter=',', dtype='f8') self.x = data[:, 0] self.y = data[:, 1] self.z = data[:, 2] self.i = data[:, 3] self.r = data[:, 4] if not class_file: if data.shape[1] > 5: self.c = data[:, 5].astype('uint8') else: self.c = np.zeros(self.x.shape, dtype='uint8') else: self.c = np.loadtxt(class_file, dtype='uint8') else: raise ValueError('Unknown file type extension: ' + points_file) self.filepath = points_file self.filename = os.path.splitext(os.path.basename(points_file))[0] if self.filename.endswith('_PC3'): self.filename = self.filename[:-4]
def readlas_convertgpd(file, epsg, luclass): """Reads a las file and converts it to a geopandas object""" # Read file pcloud = File(file, mode="r") # Convert to numpy pcloud_np = np.array( (pcloud.x, pcloud.y, pcloud.z, pcloud.red, pcloud.green, pcloud.blue, pcloud.raw_classification)).transpose() # Transform to pandas DataFrame pcloud_df = pd.DataFrame(pcloud_np) pcloud_df.columns = ['x', 'y', 'z', 'red', 'green', 'blue', 'ground'] pcloud_df['ground'] = pcloud_df['ground'].apply(int).apply(str) pcloud_df['class'] = luclass # Transform to geopandas GeoDataFrame crs = None geometry = [Point(xyz) for xyz in zip(pcloud.x, pcloud.y, pcloud.z)] pcloud_geodf = gpd.GeoDataFrame(pcloud_df, crs=crs, geometry=geometry) epsg_str = 'epsg:' + epsg pcloud_geodf.crs = {'init': epsg_str} # Close file pcloud.close() return pcloud_geodf
def save(self, output_file, class_file=''): if output_file.endswith('.txt'): if (not class_file and self.c.any()): np.savetxt( output_file, np.stack([self.x, self.y, self.z, self.i, self.r, self.c], axis=1), fmt='%.2f,%.2f,%.2f,%d,%d,%d') else: np.savetxt(output_file, np.stack([self.x, self.y, self.z, self.i, self.r], axis=1), fmt='%.2f,%.2f,%.2f,%d,%d') if class_file: self.save_classifications_txt(class_file) elif output_file.endswith('.las') or output_file.endswith('.laz'): lfile = LasFile(output_file, mode='w', header=LasHeader(x_scale=0.01, y_scale=0.01, z_scale=0.01)) lfile.X = self.x / 0.01 lfile.Y = self.y / 0.01 lfile.Z = self.z / 0.01 lfile.Intensity = self.i lfile.flag_byte = self.r lfile.Classification = self.c lfile.close() else: raise ValueError('Unknown file type extension: ' + output_file)
def do_hm(target_tile_path): # load tile for matching target_tile_name = target_tile_path.stem + target_tile_path.suffix try: target_tile = File(target_tile_path, mode='r') # this can take some time # use global to get the info, apologize to programming teachers global ref_tile global ky_lidar_fix_path # match histograms new_dist = hist_match(target_tile.intensity, ref_tile.intensity) # apply transformation new_tile_path = ky_lidar_fix_path / target_tile_name new_tile = File(new_tile_path, mode='w', header=target_tile.header) new_tile.points = target_tile.points new_tile.intensity = new_dist new_tile.close() return (True, new_tile_path) except: # if we can't load the file, that's a big problem, but it seems to happen # sometimes. return (False, target_tile_path)
def write(self): output = self.configs["paths"]["output"] points = np.array(self.points, dtype=self.dtype) #print self.header outfile = File(output + self.filename, mode="w", header=self.header) outfile.points = points outfile.close()
def save_las(xyzc, header, path): # header = Header() outfile = File(path, mode="w", header=header) outfile.X = xyzc[:, 0] outfile.Y = xyzc[:, 1] outfile.Z = xyzc[:, 2] outfile.Classification = xyzc[:, 3].astype(np.uint8) outfile.close()
def write_LAS(pc_xyz, v, output_las_fn, input_las_fn, cmap=cm.terrain, rescale='none'): import datetime from laspy.file import File from skimage import exposure import copy inFile = File(input_las_fn, mode='r') #normalize input and generate colors for height using colormap #stretch to 10-90th percentile #v_1090p = np.percentile(v, [10, 90]) #stretch to 2-98th percentile v_0298p = np.percentile(v, [2, 98]) if rescale == 'none': v_rescale = exposure.rescale_intensity(v, in_range=(v_0298p[0], v_0298p[1])) elif rescale == 'median': bounds = np.round(np.median(np.abs(v_0298p)), decimals=2) v_rescale = exposure.rescale_intensity(v, in_range=(-bounds, bounds)) colormap_terrain = cmap rgb = colormap_terrain(v_rescale) #remove last column - alpha value rgb = (rgb[:, :3] * (np.power(2, 16) - 1)).astype('uint16') outFile = File(output_las_fn, mode='w', header=inFile.header) new_header = copy.copy(outFile.header) #setting some variables new_header.created_year = datetime.datetime.now().year new_header.created_day = datetime.datetime.now().timetuple().tm_yday new_header.x_max = pc_xyz[:, 0].max() new_header.x_min = pc_xyz[:, 0].min() new_header.y_max = pc_xyz[:, 1].max() new_header.y_min = pc_xyz[:, 1].min() new_header.z_max = pc_xyz[:, 2].max() new_header.z_min = pc_xyz[:, 2].min() new_header.point_records_count = pc_xyz.shape[0] new_header.point_return_count = 0 outFile.header.count = v.shape[0] new_header.scale = inFile.header.scale new_header.offset = inFile.header.offset outFile.X = (pc_xyz[:, 0] - inFile.header.offset[0]) / inFile.header.scale[0] outFile.Y = (pc_xyz[:, 1] - inFile.header.offset[1]) / inFile.header.scale[1] outFile.Z = (pc_xyz[:, 2] - inFile.header.offset[2]) / inFile.header.scale[2] outFile.Red = rgb[:, 0] outFile.Green = rgb[:, 1] outFile.Blue = rgb[:, 2] outFile.close()
def write_las_file(self): """ Create and write a new lidar file with the desirable points """ self.dirs.set_output_dir() full_path = self.dirs.out_paths['las_terrain'] self.dirs.create_dir(self.dirs.out_dirs['las']) out_file = File(full_path, mode='w', header=self.in_file.header) class_2_points, class_2_bool = self.get_points_by_class( self.class_flag) out_file.points = self.in_file.points[class_2_bool] out_file.close()
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()
def write_cloud(header, point_cloud, output_point_cloud_path, write_extra_dimensions=False): (h, scale, offset, evlrs, vlrs) = header # Open output file output_las_file = File(output_point_cloud_path, mode='w', header=h, evlrs=evlrs, vlrs=vlrs) if write_extra_dimensions: # Create new dimensions for name, dimension in point_cloud.extra_dimensions_metadata.items(): output_las_file.define_new_dimension( name=name, data_type=dimension.get_las_type(), description="Dimension added by Ground Extend") # Assign dimension values for dimension_name, values in point_cloud.extra_dimensions.items(): setattr(output_las_file, dimension_name, values) # Adapt points to scale and offset [x_scale, y_scale, z_scale] = scale [x_offset, y_offset, z_offset] = offset [x, y] = np.hsplit(point_cloud.xy, 2) output_las_file.X = (x.ravel() - x_offset) / x_scale output_las_file.Y = (y.ravel() - y_offset) / y_scale output_las_file.Z = (point_cloud.z - z_offset) / z_scale # Set color [red, green, blue] = np.hsplit(point_cloud.rgb, 3) output_las_file.red = red.ravel() output_las_file.green = green.ravel() output_las_file.blue = blue.ravel() # Set classification output_las_file.Classification = point_cloud.classification.astype( np.uint8) # Set header output_las_file.header.scale = scale output_las_file.header.offset = offset # Close files output_las_file.close()
def add_data(infile, configs): t_i = time.time() database = configs["paths"]["db"] conn = sqlite3.connect(database) #conn.execute("PRAGMA busy_timeout = 30000") c = conn.cursor() indata = File(infile, mode="r") filename = infile.split("/")[-1] points = indata.points return_num = indata.return_num num_returns = indata.num_returns scale = indata.header.scale data = [] count = 0 for i, elem in enumerate(points): X,Y,Z,intensity,flag_byte,raw_classification,scan_angle_rank,user_data,pt_src_id,gps_time=elem[0] #print data_text row = ( filename, window(elem, 10, scale), window(elem, 5, scale), window(elem, 1, scale), int(num_returns[i]), int(return_num[i]), int(X), int(Y), int(Z), int(intensity), int(flag_byte), int(raw_classification), int(scan_angle_rank), int(user_data), int(pt_src_id), float(gps_time) ) data.append(row) #row = (window_index, elem) count +=1 c.executemany('INSERT INTO pointcloud VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)', data) conn.commit() indata.close() conn.close() t_f = time.time() print "Time for {} with {} records took {} minutes.".format( filename, count, (t_f-t_i)/60.0 )
def get_first_returns_array(self): # Guardo el archivo para poder leerlo if self.partials_create: full_path = self.dirs.out_paths['las_surfaces'] self.dirs.create_dir(self.dirs.out_dirs['las']) else: full_path = self.dirs.temp_full_paths['las_surfaces'] self.dirs.create_dir(self.dirs.temp_dirs['temp_dir']) out_file = File(full_path, mode='w', header=self.in_file.header) out_file.points = self.in_file.points[ self.in_file.return_num == 1] out_file.close() #leo el archivo in_file = File(full_path, mode='r') scale = in_file.header.scale offset = in_file.header.offset x = in_file.X y = in_file.Y z = in_file.Z x_dimension = x * scale[0] + offset[0] y_dimension = y * scale[1] + offset[1] z_dimension = z * scale[-1] + offset[-1] size = x_dimension.shape[0] x_array = x_dimension.reshape(size, 1) y_array = y_dimension.reshape(size, 1) z_array = z_dimension # Cerrar archivo para poder eliminarlo in_file.close() if not self.partials_create: self.dirs.remove_temp_file(full_path) self.dirs.remove_temp_dir(self.dirs.temp_dirs['temp_dir']) xy_array = np.concatenate((x_array, y_array), axis=1) self.surfaces_arrays_list = [xy_array, z_array]
def lidar_stats(request, lidar_id): """ Loads statistics page for selected file """ # get file from db lidar_file = LidarFiles.objects.get(pk=lidar_id) # setup file access rstr_name = lidar_file.name.replace('.las', '_intensity.png') rstr_file = os.path.join(MEDIA_ROOT, 'rasters', rstr_name) tif_name = lidar_file.name.replace('.las', '_intensity.tif') tif_file = os.path.join(MEDIA_ROOT, 'rasters', tif_name) contour_name = lidar_file.name.replace('.las', '_contour_plot.png') contour_file = os.path.join(MEDIA_ROOT, 'rasters', contour_name) scatter_name = lidar_file.name.replace('.las', '_scatter_plot.png') scatter_file = os.path.join(MEDIA_ROOT, 'rasters', scatter_name) # create rasters if they do not already exist if not os.path.isfile(rstr_file): # open las file las = File(lidar_file.las_file.path, mode='r') # create raster and stats stuff create_rasters(las, tif_file, lidar_file.srs) make_z_contour_img(las, contour_file) make_z_scatter_plot(las, scatter_file) # create png save_as_png(tif_file) # close las file las.close() # save django raster_field # lidar_file.z_raster = z_raster # lidar_file.save() # render stats with images of rasters as <img/> context = { 'lidar_file': lidar_file, 'intensity': rstr_name, 'scatter': scatter_name, 'contour': contour_name, } return render(request, 'stats.html', context=context)
def data(fname): from laspy.file import File print('loading %s ..' % fname) f = File(fname, mode='r') x = f.x y = f.y z = f.z f.close() print('we have %.2e points' % len(x)) print('add low noise ..') x += np.random.random(len(x)) / 1000.0 y += np.random.random(len(x)) / 1000.0 z += np.random.random(len(x)) / 1000.0 print('remove points that are closer than 10cm ..') x, y, z = thinning(x, y, z, 0.1) print('we have %.2e points' % len(x)) return (x, y, z)
def write_las(self, file_name: str, alt_header: File = None): """ Writes the current points in a las format Header used will be the same as the one provided during loading otherwise given. """ f = File(file_name, mode='w', header=alt_header if alt_header else self.header) data = self.data(transformed=False) f.X = data[:, 0] f.Y = data[:, 1] f.Z = data[:, 2] f.Red = data[:, 3] f.Green = data[:, 4] f.Blue = data[:, 5] f.close()
def readlas(fname): from laspy.file import File from subprocess import call r = call(['laszip', fname]) if r: sys.exit('laszip ' + fname + ' failed') fn = '%s.las' % fname[:-4] f = File(fn) x = f.x y = f.y z = f.z l = f.classification f.close() r = call(['rm', fn]) if r: sys.exit('rm ' + fn + ' failed') return np.transpose((x, y, z, l))
def __init__(self, file, output_file, scale=1): inFile = File(file, mode="r") header_file = inFile.header self.x, self.y, self.z = inFile.x, inFile.y, inFile.z self.rn = inFile.return_num try: self.red, self.green, self.blue = inFile.red, inFile.green, inFile.blue print('LiDar file containing RGB channels') except: pass inFile.close() coords = np.vstack((self.z, self.y, self.x)).transpose() self.max_values = np.max(coords, axis=0).astype(int) self.min_values = np.min(coords, axis=0).astype(int) self.xr = np.array((1 / scale) * (coords[:, 2] - self.min_values[2]), dtype=np.int) self.yr = np.array((1 / scale) * (self.max_values[1] - coords[:, 1]), dtype=np.int) self.output_file = output_file self.scale = scale self.dimension = np.array( (1 / scale) * (self.max_values - self.min_values), dtype=np.int) self.n_points = len(self.xr) print('Metadata: ', header_file) print('Number of LiDar points: ', self.n_points) print('Maximum values in axis (z,y,x) are: ', self.max_values) print('Minimum values in axis (z,y,x) are: ', self.min_values) print('Cubic dimensions are: ', self.dimension)
def save_cloud(inFile, dir_out, filename, classif, conf): # Problème dans les données, certaines labels sont à 0 label = inFile.classification ind = np.argwhere(label != 0) new_header = copy.copy(inFile.header) #Modification du point format id pour accéder au dimensions RGB new_header.data_format_id = 3 #Create outfile outFile = dir_out + filename.replace('.laz', '_classify' + '.laz') outCloud = File(outFile, mode="w", header=new_header, vlrs=inFile.header.vlrs) outCloud.define_new_dimension(name='classif', data_type=9, description="ntd") outCloud.define_new_dimension(name='conf', data_type=9, description="ntd") for dimension in inFile.point_format: if (dimension == inFile.point_format[13]): break dat = inFile.reader.get_dimension(dimension.name)[ind].reshape(-1) # dat = dat[ind] outCloud.writer.set_dimension(dimension.name, dat) multiscale_features_raw = pd.DataFrame() features_raw = np.hstack([classif.reshape(-1, 1), conf.reshape(-1, 1)]) features_raw = pd.DataFrame(features_raw) features_raw.columns = np.array(["classif", "conf"]) multiscale_features_raw = pd.concat( [multiscale_features_raw, features_raw], axis=1) outCloud.classif = multiscale_features_raw.as_matrix(['classif']).ravel() outCloud.conf = multiscale_features_raw.as_matrix(['conf']).ravel() outCloud.close()
def read_cloud(point_cloud_path): # Open point cloud and read its properties las_file = File(point_cloud_path, mode='r') header = (las_file.header.copy(), las_file.header.scale, las_file.header.offset, las_file.header.evlrs, las_file.header.vlrs) [x_scale, y_scale, z_scale] = las_file.header.scale [x_offset, y_offset, z_offset] = las_file.header.offset # Calculate the real coordinates x = las_file.X * x_scale + x_offset y = las_file.Y * y_scale + y_offset z = las_file.Z * z_scale + z_offset cloud = PointCloud.with_dimensions(x, y, z, las_file.Classification, las_file.red, las_file.green, las_file.blue) # Close the file las_file.close() # Return the result return header, cloud
def z_adjustData(tile, source_data,target_data,filetype,outputfolder): tilename = tile.name source_tile = os.path.join(source_data, '{0}.{1}'.format(tilename,filetype)).replace('\\','/') target_tile = os.path.join(target_data, '{0}.{1}'.format(tilename,filetype)).replace('\\','/') temp_outputfile = os.path.join(outputfolder, '{0}.{1}'.format(tilename,'las')).replace('\\','/') outputfile = os.path.join(outputfolder, '{0}.{1}'.format(tilename,filetype)).replace('\\','/') #read the obfuscated tile sourcefile = File(source_tile, mode='r') targetfile = File(target_tile, mode='r') #get z values from source z_values=sourcefile.get_z_scaled() outfile = File(temp_outputfile, mode="w", header=targetfile.header) outfile.points=targetfile.points #Replace the z values from source file outfile.set_z_scaled(z_values) outfile.close() sourcefile.close() targetfile.close() #lascopy all x,y,z,classification based on the corrected gps time subprocessargs=['C:/LAStools/bin/las2las.exe', '-i', temp_outputfile, '-olaz', '-o', outputfile] subprocessargs=list(map(str,subprocessargs)) p = subprocess.run(subprocessargs,stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False, check=True, universal_newlines=True) if os.path.isfile(outputfile): #read the obfuscated tile log = f'Z replaced from {source_tile} -> {target_tile}' os.remove(temp_outputfile) print(log) return(True,outputfile,log) else: log = f'Failed replacing Z from {source_tile} -> {target_tile}' #os.remove(temp_outputfile) print(log) return(False,None,log)
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))
def convertFile(tilename, inputfolder, outputfolder, filetype): inputfile = os.path.join(inputfolder, '{0}.{1}'.format(tilename, filetype)).replace('\\', '/') temp_outputfile = os.path.join(outputfolder, '{0}.{1}'.format(tilename, 'las')).replace('\\', '/') outputfile = os.path.join(outputfolder, '{0}.{1}'.format(tilename, filetype)).replace('\\', '/') try: inFile = File(inputfile, mode='r') header = inFile.header outfile = File( temp_outputfile, mode="w", header=header, ) outfile.header.offset = [0.0, 0.0, 0.0] tic = time.perf_counter() X = inFile.get_x_scaled() Y = inFile.get_y_scaled() Z = inFile.get_z_scaled() E, N = transGDA94_to_ArgyleGrid(X, Y) outfile.points = inFile.points outfile.set_x_scaled(E) outfile.set_y_scaled(N) print(E, N, Z) toc = time.perf_counter() outfile.close() subprocessargs = [ 'C:/LAStools/bin/las2las.exe', '-i', temp_outputfile, '-olaz', '-o', outputfile ] subprocessargs = list(map(str, subprocessargs)) p = subprocess.run(subprocessargs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False, check=True, universal_newlines=True) log = f"{tilename} : Convertion completed in {toc - tic:0.4f}s" print(log) if os.path.isfile(outputfile): os.remove(temp_outputfile) return (True, outputfile, log) except: log = f"{tilename} : Convertion Failed" print(log) outfile.close() return (False, tilename, log)
return (r, c[0], c[1], c[2]) if __name__ == '__main__': from laspy.file import File fname = \ 'data/mavicpro2_nadir_15deg_highq_dense_PC_10cm_aligned2_c2cdistances.las' print('reading', fname) f = File(fname) x = f.x y = f.y z = f.z classification = f.classification dz = getattr(f, 'c2c_absolute_distances_(z)').copy() f.close() print('c2c absolute distances (z):') print('pre min, mean, max:', dz.min(), dz.mean(), dz.max()) j = (-2 <= dz) * (dz <= 2) xj, yj, dzj = x[j], y[j], dz[j] dzj *= 10 print('post min, mean, max:', dzj.min(), dzj.mean(), dzj.max()) print('extract ground class ..') pts = np.transpose((xj, yj, dzj)) pts = pts[classification[j] == 2] print('fit spherical error model to ground component ..') ptsmin = pts.min(axis=0) R, x0, y0, z0 = fitsphere(pts - ptsmin)
methodpointy = [] methodpointz = [] for point in methodpoints: methodpointx.append(point[0]) methodpointy.append(point[1]) methodpointz.append(point[2]) print newoutput_file = File('method.las', mode="w", header=inFile.header) newoutput_file.X = methodpointx newoutput_file.Y = methodpointy newoutput_file.Z = methodpointz newoutput_file.close() inFile.close() ####################### convertLasZip('out.las', 'out.laz') convertLasZip('method.las', 'method.laz') uploadToS3('out.laz', 'jippe-greyhound-to-las-test-dense', 'potree_original.laz') uploadToS3('method.laz', 'jippe-greyhound-to-las-test-dense', 'potree_method.laz') removeFile('out.las') removeFile('out.laz') removeFile('method.las') removeFile('method.laz')