def main(args): ''' Main function ''' try: pargs = parser.parse_args(args[1:]) except TypeError as error_msg: print(str(error_msg)) return 1 kmname = constants.get_tilename(pargs.las_file) wkt = constants.tilename_to_extent(kmname, return_wkt=True) print("Running %s on block: %s, %s" % (PROGNAME, kmname, time.asctime())) reporter = report.ReportUniqueDates(pargs.use_local) las = laspy.read(pargs.las_file) datetimes = find_unique_days(las.gps_time) datestrings = [d.strftime('%Y%m%d') for d in datetimes] unique_dates = ';'.join(datestrings) min_date = np.min(las.gps_time) max_date = np.max(las.gps_time) reporter.report(kmname, str(to_datetime(min_date)), str(to_datetime(max_date)), unique_dates, len(datestrings), wkt_geom=wkt) return 0
def main(args): ''' Core functionality. Called by qc_wrap.py and __file__ ''' try: pargs = parser.parse_args(args[1:]) except Exception as error_msg: print(str(error_msg)) return 1 kmname = constants.get_tilename(pargs.las_file) print('Running %s on block: %s, %s' % (PROGNAME, kmname, time.asctime())) if not os.path.exists(pargs.outdir): os.mkdir(pargs.outdir) path = pargs.las_file filename = os.path.basename(path) out_path = os.path.join(pargs.outdir, filename) las_in = laspy.read(path) las_out = laspy.LasData(las_in.header) points = las_in.points las_out.points = points xy = np.column_stack((las_in.x, las_in.y)) geoid = grid.fromGDAL(GEOID_GRID, upcast=True) geoid_offset = geoid.interpolate(xy) # Apply vertical offset from geoid grid las_out.z -= geoid_offset las_out.write(out_path) return 0
def init(filename): if filename is None: raise Exception("File name not provided") with open(filename, 'rb') as f: in_file = laspy.read(f) point_count = in_file.header.point_count m_out_views = [] return in_file, point_count, m_out_views
def get_from_cache_or_download(lidar_tile_filename, cache_dir, bounds, logger=None): local_tile_filepath = path.join(cache_dir, lidar_tile_filename) if not path.exists(local_tile_filepath): lidar_uri = BASE_URI + lidar_tile_filename if logger is not None: logger.info("Downloading LIDAR data from %s to %s", lidar_uri, local_tile_filepath) request.urlretrieve(lidar_uri, local_tile_filepath) las = laspy.read(local_tile_filepath) c = np.array(las.classification) x = np.array(las.x) y = np.array(las.y) cond = ((c == 4) ^ (c == 5)) & ((x >= bounds.left) & (x <= bounds.right) & (y >= bounds.bottom) & (y <= bounds.top)) return pd.DataFrame({"class_val": c[cond], "x": x[cond], "y": y[cond]})
def main(args): ''' Core function. Called either stand-alone or from qc_wrap. ''' try: pargs = parser.parse_args(args[1:]) except Exception as error_str: print(str(error_str)) return 1 kmname = constants.get_tilename(pargs.las_file) print("Running %s on block: %s, %s" % (PROGNAME, kmname, time.asctime())) cell_size = pargs.cs ncols_f = TILE_SIZE / cell_size ncols = int(ncols_f) if ncols != ncols_f: print("TILE_SIZE: %d must be divisible by cell size..." % (TILE_SIZE)) usage() return 1 print("Using cell size: %.2f" % cell_size) use_local = pargs.use_local if pargs.schema is not None: report.set_schema(pargs.schema) reporter = report.ReportDensity(use_local) outdir = pargs.outdir if not os.path.exists(outdir): os.mkdir(outdir) lasname = pargs.las_file waterconnection = pargs.ref_data outname_base = "den_{0:.0f}_".format( cell_size) + os.path.splitext(os.path.basename(lasname))[0] + ".tif" outname = os.path.join(outdir, outname_base) print("Reading %s, writing %s" % (lasname, outname)) try: (x_min, y_min, x_max, y_max) = constants.tilename_to_extent(kmname) except Exception as error_str: print("Exception: %s" % str(error_str)) print("Bad 1km formatting of las file: %s" % lasname) return 1 las_file = laspy.read(lasname) nx = int((x_max - x_min) / cell_size) ny = int((y_max - y_min) / cell_size) ds_grid = gdal.GetDriverByName('GTiff').Create(outname, nx, ny, 1, gdal.GDT_Float32) georef = (x_min, cell_size, 0, y_max, 0, -cell_size) ds_grid.SetGeoTransform(georef) band = ds_grid.GetRasterBand(1) band.SetNoDataValue(ND_VAL) # make local copies so we don't have to call the x and y getter functions # of las_file a nx*ny times xs = las_file.x ys = las_file.y # determine densities den_grid = np.ndarray(shape=(nx, ny), dtype=float) for i in range(nx): for j in range(ny): I = np.ones(las_file.header.point_count, dtype=bool) if i < nx-1: I &= np.logical_and(xs >= x_min+i*cell_size, xs < x_min+(i+1)*cell_size) else: I &= np.logical_and(xs >= x_min+i*cell_size, xs <= x_min+(i+1)*cell_size) if j < ny-1: I &= np.logical_and(ys >= y_min+j*cell_size, ys < y_min+(j+1)*cell_size) else: I &= np.logical_and(ys >= y_min+j*cell_size, ys <= y_min+(j+1)*cell_size) den_grid[ny-j-1][i] = np.sum(I) / (cell_size*cell_size) band.WriteArray(den_grid) t1 = time.process_time() if pargs.lakesql is None and pargs.seasql is None: print('No layer selection specified!') print('Assuming that all water polys are in first layer of connection...') lake_mask = vector_io.burn_vector_layer( waterconnection, georef, den_grid.shape, None, None, ) else: lake_mask = np.zeros(den_grid.shape, dtype=np.bool) if pargs.lakesql is not None: print("Burning lakes...") lake_mask |= vector_io.burn_vector_layer( waterconnection, georef, den_grid.shape, None, pargs.lakesql, ) if pargs.seasql is not None: print("Burning sea...") lake_mask |= vector_io.burn_vector_layer( waterconnection, georef, den_grid.shape, None, pargs.seasql, ) t2 = time.process_time() print("Burning 'water' took: %.3f s" % (t2 - t1)) # what to do with nodata?? nd_mask = (den_grid == ND_VAL) den_grid[den_grid == ND_VAL] = 0 n_lake = lake_mask.sum() print("Number of no-data densities: %d" % (nd_mask.sum())) print("Number of water cells : %d" % (n_lake)) if n_lake < den_grid.size: not_lake = den_grid[np.logical_not(lake_mask)] den = not_lake.min() mean_den = not_lake.mean() else: den = ALL_LAKE mean_den = ALL_LAKE print("Minumum density : %.2f" % den) wkt = constants.tilename_to_extent(kmname, return_wkt=True) reporter.report(kmname, den, mean_den, cell_size, wkt_geom=wkt) return 0
def __init__(self, bytes): self.las = laspy.read(bytes)