misc_group.add_argument('--override_defaults', action='store_true', help="""Use this flag to not use any default attribute selection parameters: prod_code, sensors, spec_type, max_cc, max_off_nadir""") misc_group.add_argument('--dryrun', action='store_true', help='Print information about selection, but do not write.') misc_group.add_argument('-v', '--verbose', action='store_true', help='Set logging level to DEBUG.') args = parser.parse_args() # Logging if args.verbose: handler_level = 'DEBUG' else: handler_level = 'INFO' logger = create_logger(__name__, 'sh', handler_level) # Parse args variables out_path = args.out_path selector = args.selector input_ids = args.ids id_field = args.id_field selector_field = args.selector_field join_field = args.join_field secondary_selector = args.secondary_selector sjoin = args.sjoin prod_code = args.prod_code sensors = args.sensors spec_type = args.spec_type min_date = args.min_date max_date = args.max_date
max_date = args.max_date multispec = args.multispectral out_filepaths = args.out_filepaths out_dem_fp = args.out_dem_footprint copy_to = args.copy_to dems_only = args.dems_only skip_ortho = args.skip_ortho flat = args.flat dryrun = args.dryrun verbose = args.verbose if verbose: log_lvl = 'DEBUG' else: log_lvl = 'INFO' logger = create_logger(__name__, 'sh', log_lvl) # Param dem_path = 'dem_path' if v4_only: strip_types = ['strips_v4'] else: strip_types = ['strips', 'strips_v4'] # Locate DEMs that match logger.info('Locating matching DEMs...') dems = dems_from_stereo(aoi_path=aoi_path, coords=coords, strip_types=strip_types, months=months, min_date=min_date,
from tqdm import tqdm from dem_utils.dem_selector import dem_selector # from dem_selector import dem_selector from dem_utils.dem_utils import (dems2aoi_ovlp, dems2dems_ovlp, get_matchtag_path, combined_density, get_dem_path, get_filepath_field, nunatak2windows) # from dem_utils import (dems2aoi_ovlp, dems2dems_ovlp, # get_matchtag_path, combined_density, # get_dem_path, get_filepath_field) from misc_utils.raster_clip import clip_rasters from misc_utils.logging_utils import create_logger from misc_utils.gpd_utils import remove_unused_geometries, write_gdf logger = create_logger(__name__, 'sh', 'DEBUG') sub_logger = create_logger('dem_utils', 'sh', 'INFO') # Params id_col = 'pair' lsuffix = 'd1' rsuffix = 'd2' dem_name = 'dem_name' dem_path = 'dem_filepath' combo_dens = 'combo_dens' date_diff = 'date_diff' doy_diff = 'DOY_diff' inters_geom = 'inters_geom' ovlp_perc = 'aoi_ovlp_perc' rank = 'rank' mtp = 'matchtag_filepath'
# -*- coding: utf-8 -*- """ Created on Tue May 12 15:09:00 2020 @author: disbr007 """ from dem_utils.dem_utils import combined_density from misc_utils.logging_utils import create_logger sublog = create_logger('dem_utils.dem_utils', 'sh', 'DEBUG') mt1 = r'V:\pgc\data\scratch\jeff\ms\2020apr30\dems\raw\WV02_20120729_103001001A29A200_103001001B348300\WV02_20120729_103001001A29A200_103001001B348300_seg1_2m_matchtag.tif' mt2 = r'V:\pgc\data\scratch\jeff\ms\2020apr30\dems\raw\W2W2_20100720_103001000677DF00_1030010006ACB500\W2W2_20100720_103001000677DF00_1030010006ACB500_seg2_2m_matchtag.tif' aoi = r'V:\pgc\data\scratch\jeff\ms\2020apr30\aois\aoi1.shp' cd = combined_density(mt1, mt2, aoi, clip=True)
import time import os from tqdm import tqdm from pprint import pprint from otb_grm import otb_grm, create_outname from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'INFO') create_logger('misc_utils.gdal_tools', 'sh', 'WARNING') create_logger('otb_grm', 'sh', 'WARNING') thesholds = [750] iterations = [0] specs = [0.5, 0.7] spats = [100, 300] od = r'E:\disbr007\umn\2020sep27_eureka\otb_grm_testing' fmt = 'vector' img = r'E:\disbr007\umn' \ r'\2020sep27_eureka\img\ortho_WV02_20140703_test_aoi' \ r'\WV02_20140703013631_1030010032B54F00_14JUL03013631-' \ r'M1BS-500287602150_01_P009_u16mr3413_pansh_test_aoi.tif' criterion = 'bs' logger.info('starting...') for s in tqdm(specs, desc='spectral'): for t in tqdm(thesholds, desc='thresholds'): for i in tqdm(iterations, desc='iterations'): for p in tqdm(spats, desc='spatial'):
# -*- coding: utf-8 -*- """ Created on Tue Jan 21 15:35:32 2020 @author: disbr007 """ import argparse import os from archive_analysis_utils import grid_aoi from misc_utils.logging_utils import create_logger logger = create_logger(__file__, 'sh') logger = create_logger('archive_analysis_utils', 'sh', 'DEBUG') if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('aoi', type=os.path.abspath, help='Path to AOI to create grid of.') parser.add_argument('out_path', type=os.path.abspath, help='Path to write grid to.') parser.add_argument('--n_pts_x', type=int, help='Number of rows to create.') parser.add_argument('--n_pts_y', type=int,
""" Created on Wed Jul 3 14:50:14 2019 @author: disbr007 """ import argparse import os import pandas as pd import geopandas as gpd from shapely.geometry import Point from coord_converter import remove_symbols from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh') def process_tasking(xlsx, out_name): ''' Takes an excel workbook with a sheet named 'Targets' and converts the latitude and longitude points into a shapefile. Also write out a renamed excel file. xlsx: path to excel file out_name: name according to convention [first_initial][last_name][award_number][year] e.g.: bsmith_123456_2019-20 ''' # Read excel as pandas dataframe, store original column names for writing out logger.info("Reading excel sheet...") request = pd.read_excel(xlsx, sheet_name='Targets', dtype=str) cols = list(request) # Remove any degrees symbols
def main(selection, destination, source_loc, high_res, med_res, tm, list_drives, list_missing_paths, write_copied, write_footprint, exclude_list, dryrun, verbose): #### Logging setup if verbose == False: log_level = 'INFO' else: log_level = 'DEBUG' logger = create_logger('ahap_copier.py', 'sh', handler_level=log_level) ## Params if platform.system() == 'Windows': SERVER_LOC = os.path.normpath(r'V:\pgc\data\aerial\usgs\ahap\photos') FOOTPRINT_LOC = r'E:\disbr007\general\aerial\AHAP\AHAP_Photo_Extents\AHAP_Photo_Extents.shp' elif platform.system() == 'Linux': SERVER_LOC = os.path.normpath(r'/mnt/pgc/data/aerial/usgs/ahap/photos') FOOTPRINT_LOC = r'/mnt/pgc/data/aerial/usgs/ahap/index/AHAP_Photo_Extents.shp' PHOTO_EXTENTS = 'Photo_Extents' FLIGHTLINES = 'Flightlines' CAMPAIGN = 'AHAP' JOIN_SEL = 'PHOTO_ID' JOIN_FP = 'unique_id' FP = 'usgs_index_aerial_image_archive' DB = 'imagery' FILEPATH = 'filepath' FILENAME = 'filename' SRC_DRIVE = 'src_drive' SERIES_FIELD = 'series' SERIES_BOTH = 'both' SERIES_HIGH = 'high_res' SERIES_MED = 'medium_res' DRIVE_PATH = 'drive_path' MNT_PATH = 'mounted_path' RELATIVE_PATH = 'relative_path' SERVER_PATH = 'server_path' FROM_DRIVE = 'drives' FROM_SERVER = 'server' if source_loc == FROM_DRIVE: NOT_MOUNTED = 'NOT_MOUNTED' elif source_loc == FROM_SERVER: NOT_MOUNTED = 'NOT_ON_SERVER' DST_PATH = 'dst' DST_EXISTS = 'dst_exists' SRC_PATH = 'src' # transfer methods tm_copy = 'copy' tm_link = 'link' def get_active_drives(): """ List all active drives. """ drive_list = [] for drive in range(ord('A'), ord('Z')): if os.path.exists(chr(drive) + ':'): drive_list.append(chr(drive) + ':') return drive_list ## Build server paths def create_relative_paths(row, FILENAME): """ Create relative path for each row """ # Determine series subdir (high or low) if row['series'] == 'high_res': resolution = 'high' elif row['series'] == 'medium_res': resolution = 'med' roll_dir = 'AB{}ROLL'.format(row[FILENAME][:-8]) relative_path = os.path.join(resolution, roll_dir, row[FILENAME]) return relative_path def find_drive_location(row, active_drives, DRIVE_PATH): """ Check if each row (file) is on any of the active drives. If so return that drive letter. """ # TODO: Figure out how to handle missing files -> subset aia before copying possible_filepaths = [ os.path.join(letter, row[DRIVE_PATH]) for letter in active_drives ] actual_filepath = [ fp for fp in possible_filepaths if os.path.exists(fp) ] if len(actual_filepath) == 0: filepath = NOT_MOUNTED elif len(actual_filepath) == 1: filepath = actual_filepath[0] else: filepath = 'TWO LOCATIONS?' return filepath def find_server_location(row): if os.path.exists(row[SERVER_PATH]): filepath = row[SERVER_PATH] else: filepath = NOT_MOUNTED return filepath def load_selection(input_path, JOIN_SEL, exclude_list=exclude_list): """ Loads the selection and returns a list of ids and count. """ logger.info('Loading selection...') ## Load selection footprint if input_path.endswith('shp'): selection = gpd.read_file(input_path) # selection_count = len(selection) if exclude_list: with open(exclude_list, 'r') as el: exclude_ids = el.readlines() exclude_ids = [ei.strip('\n') for ei in exclude_ids] logger.debug('Excluding IDs:\n{}'.format( '\n'.join(exclude_ids))) selection = selection[~selection[JOIN_SEL].isin(exclude_ids)] selection_unique_ids = list(selection[JOIN_SEL].unique()) elif input_path.endswith('txt'): selection_unique_ids = read_ids(input_path) selection_count = len(set(selection_unique_ids)) logger.info('Scenes in selection: {:,}'.format(selection_count)) selection_unique_ids_str = str(selection_unique_ids).replace( '[', '').replace(']', '') return selection_unique_ids_str, selection_count def load_table(FP, JOIN_FP, selection_unique_ids_str, SERIES, SERIES_BOTH, SERIES_FIELD): logger.debug('Loading danco AHAP table...') ## Load aerial source table # Build where clause, including selecting only ids in selection # where = "(sde.{}.{} IN ({}))".format(FP, JOIN_FP, selection_unique_ids_str) where = "({}.{} IN ({}))".format(FP, JOIN_FP, selection_unique_ids_str) # Add series if only medium or high is desired, else add nothing and load both if SERIES != SERIES_BOTH: # where += " AND (sde.{}.{} = '{}')".format(FP, SERIES_FIELD, SERIES) where += " AND ({}.{} = '{}')".format(FP, SERIES_FIELD, SERIES) aia = query_footprint(FP, db=DB, table=True, where=where) aia_ct = len(aia) # Remove duplicates - there are identical records, but on different src_drives # Mainly seen on src_drives: USGS_s31 and USGS_s71 # If this actually removes anything, a debug message will be logged. # TODO: Add option to keep all locations, only useful for copying from drives # as there should be one of each file on the server aia = aia.drop_duplicates(subset=JOIN_FP) aia_dd = len(aia) if aia_dd != aia_ct: logger.debug( 'Duplicates dropped, identical records on multiples drives.') logger.info('Records loaded in AHAP table: {:,}'.format(len(aia))) return aia ## TODO: Add support for FLIGHTLINES selection inputs ## Determine type of selection input #selection_fields = list(selection) #if "PHOTO_ID" in selection_fields: # selection_type = PHOTO_EXTENTS #else: # selection_type = FLIGHTLINES ## Check arguments if source_loc != FROM_DRIVE and source_loc != FROM_SERVER: logger.error('''Invalid "source_loc" argument. Must be one of {} or {}'''.format( FROM_DRIVE, FROM_SERVER)) raise ValueError() if not os.path.exists(selection): logger.error( '''Selection path does not exist.\n{}'''.format(selection)) raise ValueError() if not os.path.exists(destination) and not os.path.isdir(destination): logger.error('''Destination path does not exist or is not a directory, please provide an existing directory.\n{}'''.format( destination)) raise ValueError() if high_res is True and med_res is True: SERIES = SERIES_BOTH elif high_res is True: SERIES = SERIES_HIGH elif med_res is True: SERIES = SERIES_MED else: logger.error( 'Please specify one of high_resolution or med_resolution.') raise ValueError() ### Get drive paths ## Load input table and join to danco table to create filepaths selection_unique_ids_str, selection_count = load_selection( selection, JOIN_SEL=JOIN_SEL) aia = load_table(FP, JOIN_FP, selection_unique_ids_str, SERIES, SERIES_BOTH, SERIES_FIELD) #### Create source paths: if they existed on the drive and server # Convert unix path to os style -- only necessary/does anything for Windows aia[DRIVE_PATH] = aia[FILEPATH].apply(os.path.normpath) # Create a relative path for the destination directory, eg: 'high/ABxxxxROLL/xxxx.tif.gz aia[RELATIVE_PATH] = aia.apply( lambda x: create_relative_paths(x, FILENAME), axis=1) # Create the location the file would be at if it existed on the server aia[SERVER_PATH] = aia.apply( lambda x: os.path.join(SERVER_LOC, x[RELATIVE_PATH]), axis=1) #### Create destination path # Create full destination path aia[DST_PATH] = aia.apply( lambda x: os.path.join(destination, x[RELATIVE_PATH]), axis=1) # Check if destination exists aia[DST_EXISTS] = aia[DST_PATH].apply(lambda x: os.path.exists(x)) if source_loc == FROM_DRIVE: ## Get all active drives to use in check for files mounted on drives active_drives = get_active_drives() active_drives = [d for d in active_drives if os.path.ismount(d)] # ## Get letters of mounted aerial imagery drives # # first level subdirectories on drives are './hsm' or './AHAP Tif files' # aerial_imagery_subdirs = ['hsm{}'.format(x) for x in range(0,10)] # aerial_imagery_subdirs.append('hsm') # aerial_imagery_subdirs.append('AHAP Tif files') # # Check if either of the subdir patterns exist on all mounted drives to # # decide if the mounted drive is a drive containing AHAP, thus skipping # # C and other drives (..unless the above are at prefixes are at the root) # ahap_drives = [d for d in active_drives # if True in [os.path.exists(os.path.join(d, sd)) # for sd in aerial_imagery_subdirs]] aia[MNT_PATH] = aia.apply( lambda x: find_drive_location(x, active_drives, DRIVE_PATH), axis=1) SRC_PATH = MNT_PATH ahap_drives = set(list(aia[SRC_DRIVE])) logger.debug('Drives containing AHAP imagery:\n{}'.format( '\n'.join(ahap_drives))) elif source_loc == FROM_SERVER: aia[MNT_PATH] = aia.apply(lambda x: find_server_location(x), axis=1) SRC_PATH = SERVER_PATH #### Selected files for copying: #### only files that have a valid source drive mounted #### (n/a for FROM_SERVER -- all should be 'mounted', but this will skip missing) aia_mounted = copy.deepcopy(aia[aia[MNT_PATH] != NOT_MOUNTED]) # aia_mounted = aia_mounted[aia_mounted[DST_EXISTS] == True] high_status = 'Located {:,}/{:,} {} from selection on {}...'.format( len(aia_mounted[aia_mounted[SERIES_FIELD.lower()] == SERIES_HIGH]), selection_count, SERIES_HIGH, source_loc) med_status = 'Located {:,}/{:,} {} from selection on {}...'.format( len(aia_mounted[aia_mounted[SERIES_FIELD.lower()] == SERIES_MED]), selection_count, SERIES_MED, source_loc) # Print status messages if SERIES == SERIES_BOTH: logger.info(high_status) logger.info(med_status) elif SERIES == SERIES_HIGH: logger.info(high_status) elif SERIES == SERIES_MED: logger.info(med_status) ## If list drives, get src drive names, like 'USGS_s74'. ## These are labeled on the drives. ## Then exit if list_drives is True: src_drives = list(aia[SRC_DRIVE].unique()) logger.info('Drives required for copying selection to\n{}:\n{}'.format( destination, '\n'.join(src_drives))) if list_missing_paths is True: for sd in src_drives: missing_paths = list(aia[aia[DST_EXISTS] == False][FILEPATH]) logger.info('Drive: {}'.format(sd)) logger.info('Missing paths:\n{}'.format( '\n'.join(missing_paths))) sys.exit() ### Do copying # Create file of already copied to be use for excluding in subsequent copying if write_copied: if os.path.exists(write_copied): wc_open_mode = 'a' else: wc_open_mode = 'w' wc = open(write_copied, wc_open_mode) ## Copy loop # progress bar setup # manager = enlighten.get_manager() # pbar = manager.counter(total=len(aia_mounted[SRC_PATH]), desc='Copying:', unit='files') logger.info('Copying files from {} to {}...'.format( source_loc, destination)) for src, dst in zip(aia_mounted[SRC_PATH], aia_mounted[DST_PATH]): # Make directory tree if necessary dst_dir = os.path.dirname(dst) if not os.path.exists(dst_dir): logger.debug('Making directories: \n{}'.format(dst_dir)) os.makedirs(dst_dir) if not os.path.exists(dst): logger.debug('Copying \n{} -> \n{}\n'.format(src, dst)) if not dryrun: if tm == tm_copy: shutil.copyfile(src, dst) elif tm == tm_link: os.link(src, dst) if write_copied: wc.write(os.path.basename(src).split('.')[0]) wc.write('\n') else: logger.debug( 'Destination file already exists, skipping: \n{}\n{}'.format( src, dst)) # pbar.update() if write_copied: wc.close() if write_footprint: logger.info('Writing footprints...') aia_footprints = gpd.read_file(FOOTPRINT_LOC) aia_mounted = aia_mounted[[ 'unique_id', 'campaign', 'series', 'filename', 'flightline', 'file_sz_mb', 'photo_id', 'relative_path', ]] aia_footprints = aia_footprints.merge(aia_mounted, left_on='PHOTO_ID', right_on='unique_id', how='inner') aia_footprints.to_file(write_footprint) logger.debug('Done')
@author: disbr007 Creates a shapefile that is a refresh in the region selected """ import argparse import datetime import os import geopandas as gpd from selection_utils.query_danco import query_footprint, mono_noh, stereo_noh, generate_rough_aoi_where from misc_utils.id_parse_utils import date_words, remove_onhand, onhand_ids from misc_utils.logging_utils import create_logger from misc_utils.gpd_utils import select_in_aoi logger = create_logger(__name__, 'sh', 'DEBUG') # Params loc_name_fld = 'project' def refresh_region_lut(refresh_region='polar_hma_above'): ''' Uses a refresh region shortname to return relevent region names in AOI shapefile. refresh_region: string, supported types ['polar_hma_above', 'nonpolar', 'global'] ''' logger.debug('Refresh region: {}'.format(refresh_region)) supported_refreshes = ['polar_hma_above', 'nonpolar', 'global', 'polar'] # TODO: Check refresh_region = nonpolar to make sure it covers everything (HMA etc.) if refresh_region not in supported_refreshes: logger.warning(
args = parser.parse_args() image_source = args.image_source out = args.out out_dir = args.out_dir mode = args.mode spatialr = args.spatial_radius ranger = args.range_radius minsize = args.minsize tilesize_x = args.tilesize_x tilesize_y = args.tilesize_y overwrite = args.overwrite # Set up console logger handler_level = 'INFO' logger = create_logger(__name__, 'sh', handler_level=handler_level) # Build out path and determine mode if out: mode_lut = {'.shp': 'vector', '.tif': 'raster'} ext = os.path.splittext(out)[1] if not mode: mode = mode_lut[ext] else: if mode != mode_lut[ext]: logger.error( """Selected mode does not match out file extension: mode: {} != {}""".format(mode, ext)) sys.exit() if out is None:
Finds imagery in a directory based on an input list of scene_ids or catalog_ids. Moves the imagery files to destination directory. ***SKIPPING BROWSE FILES CURRENTLY*** TODO: Incorporate BROWSE files into parse_filename function """ import argparse import os import shutil import tqdm from misc_utils.id_parse_utils import parse_filename, read_ids, write_ids from misc_utils.logging_utils import create_logger logger = create_logger(os.path.basename(__file__), 'sh', handler_level='INFO') def match_and_move(ids, src_dir, dst_dir, match_field='catalog_id', dryrun=False): logger.info('{} IDs found.'.format(len(set(ids)))) logger.debug(ids) matches = [] catids_found = [] logger.info('Locating matching files...') for root, dirs, files in os.walk(src_dir): for f in files:
import obia_utils.otb_grm as otb_grm import obia_utils.otb_edge_extraction as otb_ee # from obia_utils.otb_edge_extraction import otb_edge_extraction from obia_utils.cleanup_objects import cleanup_objects from obia_utils.calc_zonal_stats import calc_zonal_stats from obia_utils.ImageObjects import ImageObjects from classify_rts import classify_rts, grow_rts_candidates, grow_rts_simple # TODO: # Standardize naming - make functions: # -seg_name() (exists) # -clean_name() # -zonal_stats_name() # %% logger = create_logger(__name__, 'sh', 'INFO') # External py scripts PANSH_PY = r'C:\code\imagery_utils\pgc_pansharpen.py' NDVI_PY = r'C:\code\imagery_utils\pgc_ndvi.py' # Config keys seg = 'seg' alg = 'algorithm' params = 'params' cleanup = 'cleanup' out_objects = 'out_objects' out_dir = 'out_dir' out_seg = 'out_seg' mask_on = 'mask_on' zonal_stats = 'zonal_stats'
import argparse import os from pathlib import Path from gdal_tools import clip_minbb from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'INFO') sublogger = create_logger('gdal_tools', 'sh', 'INFO') if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('-r', '--rasters', nargs='+', type=os.path.abspath, help='Paths to rasters to clip. Can be multiple' 'arguments, a text file of rasters, a ' 'directory of rasters, in which case "--ext" ' 'will be used to identify rasters, or a ' 'combination.') parser.add_argument('-o', '--out_dir', type=os.path.abspath, help='Directory to write clipped rasters to.') parser.add_argument('-s', '--suffix', type=str, help='Suffix to add to raster names when writing.') parser.add_argument('--ext', type=str, help='The extension to identify rasters when ' 'providing a directory.') args = parser.parse_args() args.rasters
# -*- coding: utf-8 -*- """ Created on Wed Dec 11 12:11:46 2019 @author: disbr007 """ import argparse import os import sys from misc_utils.id_parse_utils import read_ids, write_ids, parse_filename from misc_utils.logging_utils import create_logger logger = create_logger('id_verify.py', 'sh') def imagery_directory_IDs(img_dir, id_of_int): """ Parses the filenames of imagery in a given directory and returns a list of the specified ID type. Parameters: img_dir (str) : path to directory of imagery id_of_int (str) : the type of ID to return, one of CATALOG_ID or SCENE_ID Returns: (set) : list of IDs """ # PARSE IDS FROM IMG_DIR dir_ids = []
Created on Fri Mar 6 14:22:54 2020 @author: disbr007 """ import argparse import datetime import os from pathlib import Path import platform import subprocess from subprocess import PIPE from misc_utils.logging_utils import create_logger, create_logfile_path from misc_utils.gdal_tools import gdal_polygonize logger = create_logger(__name__, 'sh', 'DEBUG') # Constants # Init OTB env if platform.system() == 'Windows': otb_init = r"C:\OTB-7.1.0-Win64\OTB-7.1.0-Win64\otbenv.bat" elif platform.system() == 'Linux': otb_init = r"module load OTB" GRADIENT = 'gradient' SOBEL = 'sobel' TOUZI = 'touzi' # Function definition def run_subprocess(command):
import argparse import os from pathlib import Path, PurePath import subprocess from subprocess import PIPE from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'INFO') # Params wbt = 'whitebox_tools.exe' med = 'MaxElevationDeviation' def run_subprocess(command): proc = subprocess.Popen(command, stdout=PIPE, stderr=PIPE, shell=True) # proc.wait() output, error = proc.communicate() logger.debug('Output: {}'.format(output.decode())) logger.debug('Err: {}'.format(error.decode())) def wbt_med(dem, out_dir=None, out_mag=None, out_scale=None, min_scale=1, max_scale=50, step=5, vw=False, dryrun=False): logger.info('Setting up whitebox_tool.exe MaxElevationDeviation') if not isinstance(dem, PurePath): dem = Path(dem) if not isinstance(out_dir, PurePath):
# -*- coding: utf-8 -*- """ Created on Wed Nov 20 10:45:25 2019 @author: disbr007 """ import os import arcpy #from misc_utils.id_parse_utils import pgc_index_path from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'DEBUG') arcpy.env.overwriteOutput = True def pgc_index_path(ids=False): ''' Returns the path to the most recent pgc index from a manually updated text file containing the path. ''' with open(r'C:\code\pgc-code-all\config\pgc_index_path.txt', 'r') as src: content = src.readlines() if not ids: index_path = content[0].strip('\n') if ids: index_path = content[1].strip('\n') logger.debug('PGC index path loaded: {}'.format(index_path))
@author: disbr007 """ import os import logging import numpy as np from osgeo import gdal, ogr, osr from misc_utils.raster_clip import clip_rasters from misc_utils.gdal_tools import auto_detect_ogr_driver, remove_shp from misc_utils.logging_utils import create_logger #### Logging setup logger = create_logger('valid_data', 'sh', 'DEBUG') def valid_data(gdal_ds, band_number=1, valid_value=None, write_valid=False, out_path=None): """ Takes a gdal datasource and determines the number of valid pixels in it. Optionally, writing out the valid data as a binary raster. gdal_ds (osgeo.gdal.Dataset): osgeo.gdal.Dataset write_valid (boolean) : True to write binary raster, must supply out_path out_path (str) : Path to write binary raster Writes (Optional) Valid data mask as raster Returns
import argparse import os from pathlib import Path import geopandas as gpd import pandas as pd from shapely.geometry import Point, box from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'INFO') if __name__ == '__main__': parser = argparse.ArgumentParser() geom_type_group = parser.add_mutually_exclusive_group(required=True) src_file_args = parser.add_argument_group('Source file args.') parser.add_argument('-o', '--out_lyr', type=os.path.abspath, required=True, help='Path to write layer out to.') geom_type_group.add_argument('-p', '--point', nargs=2, action='append', type=float, help='Point to add: x y') geom_type_group.add_argument( '-bb', '--bounding_box',
import argparse import os from id_parse_utils import combine_ids from misc_utils.logging_utils import create_logger logger = create_logger(__name__, 'sh', 'INFO') sublogger = create_logger('id_parse_utils', 'sh', 'DEBUG') def main(args): id_lists = args.id_lists fields = args.fields out_ids = args.out_ids combine_ids(id_lists, fields=fields, write_path=out_ids) if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--id_lists', nargs='+', type=os.path.abspath, help='Paths to files with IDs to combine.') parser.add_argument('--fields', nargs='+', help='Ordered list of fields to use to locate IDs in files. "None" if just text file.') parser.add_argument('--out_ids', type=os.path.abspath, help='Path to write combined list of IDs .') args = parser.parse_args() print(args) main(args)