def main():
parser = argparse.ArgumentParser(description='GNAT',
# epilog="This is an epilog"
)
parser.add_argument('huc', help='HUC identifier', type=str)
parser.add_argument('output_folder', help='Output folder', type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger("GNAT")
log.setup(logPath=os.path.join(args.output, "gnat.log"),
verbose=args.verbose)
log.title('GNAT For HUC: {}'.format(args.huc))
try:
gnat(args.hu, args.output_folder)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(
description='RVD XML Augmenter',
# epilog="This is an epilog"
)
parser.add_argument('out_project_xml', help='Input XML file', type=str)
parser.add_argument('in_xmls', help='Comma-separated list of XMLs in decreasing priority', type=str)
parser.add_argument('--verbose', help='(optional) a little extra logging ', action='store_true', default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger('XML Augmenter')
log.setup(verbose=args.verbose)
log.title('XML Augmenter: {}'.format(args.out_project_xml))
try:
out_prj = RSProject(None, args.out_project_xml)
out_prj.rs_meta_augment(
args.in_xmls.split(','),
lyrs_in_out
)
out_prj.XMLBuilder.write()
report_path = out_prj.XMLBuilder.find('.//HTMLFile[@id="RVD_REPORT"]/Path').text
report = RVDReport(os.path.join(out_prj.project_dir, report_path), out_prj)
report.write()
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
""" Combined FIS
"""
parser = argparse.ArgumentParser()
parser.add_argument('database',
help='BRAT SQLite database',
type=argparse.FileType('r'))
parser.add_argument('maxdrainage',
help='Maximum drainage area',
type=float)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
logg = Logger("Combined FIS")
logfile = os.path.join(os.path.dirname(args.network.name),
"combined_fis.log")
logg.setup(logPath=logfile, verbose=args.verbose)
try:
combined_fis(args.database.name, 'existing', 'EX', args.maxdrainage)
# combined_fis(args.network.name, 'historic', 'HPE', args.maxdrainage)
except Exception as ex:
logg.error(ex)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('network',
help='Output network ShapeFile path',
type=argparse.FileType('r'))
parser.add_argument('flowaccum',
help='Flow accumulation raster',
type=argparse.FileType('r'))
parser.add_argument('buffer',
help='Distance to buffer reach midpoint',
type=float)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
logg = Logger("Reach Flow Accum")
logfile = os.path.join(os.path.dirname(args.network.name),
"reach_flowaccum.log")
logg.setup(logPath=logfile, verbose=args.verbose)
try:
reach_drainage_area(args.network.name, args.flowaccum.name,
args.buffer)
except Exception as e:
logg.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
""" Vegetation Suitability
"""
parser = argparse.ArgumentParser()
parser.add_argument('database',
help='BRAT database path',
type=argparse.FileType('r'))
parser.add_argument('buffer', help='buffer distance (metres)', type=float)
parser.add_argument('epoch', help='Existing or Historic', type=str)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
logg = Logger('Veg Summary')
logfile = os.path.join(os.path.dirname(args.database.name),
'vegetation_summary.log')
logg.setup(logPath=logfile, verbose=args.verbose)
try:
vegetation_suitability(args.database.name, args.raster.name,
args.buffer, args.table)
except Exception as e:
logg.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('dem', help='DEM raster', type=str)
parser.add_argument('flowaccum', help='Flow accumulation raster', type=str)
parser.add_argument('drainagearea', help='Drainage Area output raster', type=str)
parser.add_argument('--cleanup', help='Deletes temporary files', action='store_true', default=False)
parser.add_argument('--verbose', help='(optional) verbose logging mode', action='store_true', default=False)
parser.add_argument('--dinfinity', help='(optional) Use the Dinifinity algorthim. D8 used if omitted', action='store_true', default=False)
parser.add_argument('--pitfill', help='(optional) Fill DEM pits before flow direction', action='store_true', default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger("Flow Accum")
log.setup(logPath=os.path.join(os.path.dirname(args.flowaccum), "flow_accum.log"))
if os.path.isfile(args.flowaccum):
log.info('Deleting existing output raster {}'.format(args.flowaccum))
driver = gdal.GetDriverByName('GTiff')
gdal.Driver.Delete(driver, args.flowaccum)
try:
flow_accumulation(args.dem, args.flowaccum, args.cleanup, args.dinfinity, args.pitfill)
flow_accum_to_drainage_area(args.flowaccum, args.drainagearea)
except Exception as e:
print(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
""" Main hydrology routine
"""
parser = argparse.ArgumentParser()
parser.add_argument('database', help='BRAT SQLite database', type=str)
parser.add_argument('prefix', help='Q2 or Low prefix', type=str)
parser.add_argument('huc', help='HUC identification code', type=str)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
logg = Logger("Hydrology")
logfile = os.path.join(os.path.dirname(args.database), "hydrology.log")
logg.setup(logPath=logfile, verbose=args.verbose)
try:
hydrology(args.database, args.prefix, args.huc)
except Exception as ex:
logg.error(ex)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('vpuids',
help='Comma separated list of VPUs to process',
type=str)
parser.add_argument(
'data_folder',
help='Top level data folder containing riverscapes context projects',
type=str)
#parser.add_argument('user_name', help='Postgres user name', type=str)
#parser.add_argument('password', help='Postgres password', type=str)
args = dotenv.parse_args_env(
parser, os.path.join(os.path.dirname(__file__), '.env'))
# Initiate the log file
log = Logger('Load NHD')
log.setup(logPath=os.path.join(args.data_folder, 'load_nhd.log'),
verbose=True)
try:
load_nhd(args.vpuids,
args.data_folder) # , args.user_name, args.password)
log.info('Process completed successfully')
except Exception as ex:
log.error(ex)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('lst_xml_folder',
help='Top level data folder containing LST data',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
args = dotenv.parse_args_env(
parser, os.path.join(os.path.dirname(__file__), '.env'))
# Initiate the log file
log = Logger('Land Surface Temperature XML Generator')
log.setup(logPath=os.path.join(os.path.dirname(args.lst_xml_folder),
'lst_xml.log'),
verbose=args.verbose)
try:
process_lst(args.lst_xml_folder)
log.info('Process completed successfully')
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('dir',
help='Folder to search for image files',
type=str)
parser.add_argument('vrt', help='Output path for VRT file', type=str)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = parser.parse_args()
# make sure the output folder exists
results_folder = os.path.dirname(args.vrt)
if not os.path.isdir(results_folder):
os.mkdir(results_folder)
# Initiate the log file
logg = Logger("Build VRT")
logfile = os.path.join(results_folder, "build_vrt.log")
logg.setup(logPath=logfile, verbose=args.verbose)
try:
build_vrt(args.dir, args.vrt)
except Exception as e:
logg.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
""" Main BRAT Run
"""
parser = argparse.ArgumentParser(
description='Run brat against a pre-existing sqlite db:',
# epilog="This is an epilog"
)
parser.add_argument('project',
help='Riverscapes project folder or project xml file',
type=str,
default=None)
parser.add_argument(
'--csv_dir',
help='(optional) directory where we can find updated lookup tables',
action='store_true',
default=False)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
parser.add_argument(
'--debug',
help=
'(optional) more output about things like memory usage. There is a performance cost',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
if os.path.isfile(args.project):
logpath = os.path.dirname(args.project)
elif os.path.isdir(args.project):
logpath = args.project
else:
raise Exception(
'You must supply a valid path to a riverscapes project')
log = Logger('BRAT Run')
log.setup(logPath=os.path.join(logpath, "brat_run.log"),
verbose=args.verbose)
log.title('BRAT Run Tool')
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(logpath, 'brat_run_memusage.log')
retcode, max_obj = ThreadRun(brat_run, memfile, args.project,
args.csv_dir)
log.debug('Return code: {}, [Max process usage] {}'.format(
retcode, max_obj))
else:
brat_run(args.project, args.csv_dir)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(
description='RVD',
# epilog="This is an epilog"
)
parser.add_argument('huc', help='HUC identifier', type=str)
parser.add_argument('flowlines', help='Segmented flowlines input.', type=str)
parser.add_argument('existing', help='National existing vegetation raster', type=str)
parser.add_argument('historic', help='National historic vegetation raster', type=str)
parser.add_argument('valley_bottom', help='Valley bottom (.shp, .gpkg/layer_name)', type=str)
parser.add_argument('output_folder', help='Output folder input', type=str)
parser.add_argument('--reach_codes', help='Comma delimited reach codes (FCode) to retain when filtering features. Omitting this option retains all features.', type=str)
parser.add_argument('--flow_areas', help='(optional) path to the flow area polygon feature class containing artificial paths', type=str)
parser.add_argument('--waterbodies', help='(optional) waterbodies input', type=str)
parser.add_argument('--meta', help='riverscapes project metadata as comma separated key=value pairs', type=str)
parser.add_argument('--verbose', help='(optional) a little extra logging ', action='store_true', default=False)
parser.add_argument('--debug', help="(optional) save intermediate outputs for debugging", action='store_true', default=False)
args = dotenv.parse_args_env(parser)
reach_codes = args.reach_codes.split(',') if args.reach_codes else None
meta = parse_metadata(args.meta)
# Initiate the log file
log = Logger("RVD")
log.setup(logPath=os.path.join(args.output_folder, "rvd.log"), verbose=args.verbose)
log.title('RVD For HUC: {}'.format(args.huc))
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(args.output_dir, 'rvd_mem.log')
retcode, max_obj = ThreadRun(rvd, memfile, args.huc,
args.flowlines,
args.existing, args.historic, args.valley_bottom,
args.output_folder,
reach_codes,
args.flow_areas, args.waterbodies,
meta=meta)
log.debug('Return code: {}, [Max process usage] {}'.format(retcode, max_obj))
else:
rvd(args.huc,
args.flowlines,
args.existing, args.historic, args.valley_bottom,
args.output_folder,
reach_codes,
args.flow_areas, args.waterbodies,
meta=meta)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='Import point observation ShapeFile into PostGIS' )
parser.add_argument('shapefile', help='Point observation ShapeFile path', type=str, default=None)
parser.add_argument('host', help='Postgres password', type=str)
parser.add_argument('port', help='Postgres password', type=str)
parser.add_argument('db', help='Postgres password', type=str)
parser.add_argument('user_name', help='Postgres user name', type=str)
parser.add_argument('password', help='Postgres password', type=str)
parser.add_argument('--verbose', help='(optional) a little extra logging ', action='store_true', default=False)
args = dotenv.parse_args_env(parser)
log = Logger('Import')
log.setup(logPath=os.path.join(os.path.join(os.path.dirname(args.shapefile)), "shapefile_import.log"), verbose=args.verbose)
log.title('Point Observation ImportTool')
import_shapefile(args.shapefile, args.host, args.port, args.user_name, args.password, args.db)
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'expected',
help=
'Shapefile prepared by analysts possessing manually validated drainage area',
type=str)
parser.add_argument('nhdplushr',
help='Shapefile with NHDPlusHR drainage area values',
type=str)
args = dotenv.parse_args_env(
parser,
os.path.join(os.path.dirname(__file__), '..', '..', '.env.validation'))
log = Logger("BRAT Drainage Area")
log.setup(verbose=True)
drainage_area_validation(args.expected, args.nhdplushr)
def main():
# TODO Add transportation networks to vbet inputs
# TODO Prepare clipped NHD Catchments as vbet polygons input
parser = argparse.ArgumentParser(
description='Floodplain Connectivity (BETA)',
# epilog="This is an epilog"
)
parser.add_argument('vbet_network', help='Vector line network', type=str)
parser.add_argument('vbet_polygon', help='Vector polygon layer', type=str)
parser.add_argument('roads', help='Vector line network', type=str)
parser.add_argument('railroads', help='Vector line network', type=str)
parser.add_argument('output_dir',
help='Folder where output project will be created',
type=str)
parser.add_argument('--debug_gpkg', help='Debug geopackage', type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# make sure the output folder exists
safe_makedirs(args.output_dir)
# Initiate the log file
log = Logger('FLOOD_CONN')
log.setup(logPath=os.path.join(args.output_dir,
'floodplain_connectivity.log'),
verbose=args.verbose)
log.title('Floodplain Connectivity (BETA)')
try:
floodplain_connectivity(args.vbet_network, args.vbet_polygon,
args.roads, args.railroads, args.output_dir,
args.debug_gpkg)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('network',
help='Input stream network ShapeFile path',
type=str)
parser.add_argument('segmented',
help='Output segmented network ShapeFile path',
type=str)
parser.add_argument(
'interval',
help='Interval distance at which to segment the network',
type=float)
parser.add_argument('minimum',
help='Minimum feature length in the segmented network',
type=float)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
logg = Logger("Segment Network")
logfile = os.path.join(os.path.dirname(args.segmented),
"segment_network.log")
logg.setup(logPath=logfile, verbose=args.verbose)
if os.path.isfile(args.segmented):
logg.info('Deleting existing output {}'.format(args.segmented))
shpDriver = ogr.GetDriverByName("ESRI Shapefile")
shpDriver.DeleteDataSource(args.segmented)
try:
segment_network(args.network, args.segmented, args.interval,
args.minimum, args.tolerance)
except Exception as e:
logg.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('inraster', help='Input raster', type=str)
parser.add_argument('outraster', help='Output raster', type=str)
parser.add_argument('epsg', help='Output spatial reference EPSG', type=int)
parser.add_argument('clip',
help='Polygon ShapeFile to clip the output raster',
type=argparse.FileType('r'))
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = parser.parse_args()
# Initiate the log file
log = Logger("Raster Warp")
log.setup(logPath=os.path.join(os.path.dirname(args.outraster),
"raster_warp.log"))
# make sure the output folder exists
results_folder = os.path.dirname(args.outraster)
if not os.path.isdir(results_folder):
os.mkdir(results_folder)
if os.path.isfile(args.outraster):
log.info('Deleting existing output raster: {}'.format(args.outraster))
driver = gdal.GetDriverByName('GTiff')
gdal.Driver.Delete(driver, args.outraster)
try:
raster_warp(args.inraster, args.outraster, args.epsg,
args.clip.name if args.clip else None)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('out_sqlite', help='output sqlite file', type=str)
parser.add_argument('modis_folder',
help='Top level data folder containing MODIS data',
type=str)
parser.add_argument('nhd_folder',
help='Top level data folder containing nhd data',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
parser.add_argument('--debug',
help='(optional) a little extra logging ',
action='store_true',
default=False)
args = dotenv.parse_args_env(
parser, os.path.join(os.path.dirname(__file__), '.env'))
# Initiate the log file
log = Logger('Land Surface Temperature')
log.setup(logPath=os.path.join(
os.path.dirname(args.out_sqlite),
os.path.splitext(args.out_sqlite)[0] + 'process_LST.log'),
verbose=args.verbose)
try:
process_modis(args.out_sqlite, args.modis_folder, args.nhd_folder,
args.verbose, args.debug)
log.info('Process completed successfully')
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
""" Conservation
"""
parser = argparse.ArgumentParser()
parser.add_argument('database', help='BRAT SQLite database', type=str)
parser.add_argument('--verbose',
help='(optional) verbose logging mode',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
log = Logger('Conservation')
logfile = os.path.join(os.path.dirname(args.database), 'conservation.log')
log.setup(logPath=logfile, verbose=args.verbose)
try:
conservation(args.database)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='Riverscapes VBET Tool',
# epilog="This is an epilog"
)
parser.add_argument('huc', help='NHD flow line ShapeFile path', type=str)
parser.add_argument('flowlines',
help='NHD flow line ShapeFile path',
type=str)
parser.add_argument('flowareas',
help='NHD flow areas ShapeFile path',
type=str)
parser.add_argument('slope', help='Slope raster path', type=str)
parser.add_argument('dem', help='DEM raster path', type=str)
parser.add_argument('hillshade', help='Hillshade raster path', type=str)
parser.add_argument(
'output_dir',
help='Folder where output VBET project will be created',
type=str)
parser.add_argument(
'--reach_codes',
help=
'Comma delimited reach codes (FCode) to retain when filtering features. Omitting this option retains all features.',
type=str)
parser.add_argument('--max_slope',
help='Maximum slope to be considered',
type=float,
default=12)
parser.add_argument('--max_hand',
help='Maximum HAND to be considered',
type=float,
default=50)
parser.add_argument('--min_hole_area',
help='Minimum hole retained in valley bottom (sq m)',
type=float,
default=50000)
parser.add_argument(
'--meta',
help='riverscapes project metadata as comma separated key=value pairs',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
parser.add_argument(
'--debug',
help=
'Add debug tools for tracing things like memory usage at a performance cost.',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# make sure the output folder exists
safe_makedirs(args.output_dir)
# Initiate the log file
log = Logger('VBET')
log.setup(logPath=os.path.join(args.output_dir, 'vbet.log'),
verbose=args.verbose)
log.title('Riverscapes VBET For HUC: {}'.format(args.huc))
meta = parse_metadata(args.meta)
json_transform = json.dumps({
"Slope": 1,
"HAND": 2,
"Channel": 3,
"Flow Areas": 4
})
reach_codes = args.reach_codes.split(',') if args.reach_codes else None
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(args.output_dir, 'vbet_mem.log')
retcode, max_obj = ThreadRun(vbet, memfile, args.huc,
args.flowlines, args.flowareas,
args.slope, json_transform, args.dem,
args.hillshade, args.max_hand,
args.min_hole_area, args.output_dir,
reach_codes, meta)
log.debug('Return code: {}, [Max process usage] {}'.format(
retcode, max_obj))
else:
vbet(args.huc, args.flowlines, args.flowareas, args.slope,
json_transform, args.dem, args.hillshade, args.max_hand,
args.min_hole_area, args.output_dir, reach_codes, meta)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='Confinement Tool')
parser.add_argument('huc', help='HUC identifier', type=str)
parser.add_argument('flowlines',
help="NHD Flowlines (.shp, .gpkg/layer_name)",
type=str)
parser.add_argument(
'confining_polygon',
help=
'valley bottom or other polygon representing confining boundary (.shp, .gpkg/layer_name)',
type=str)
parser.add_argument('output_folder', help='Output folder', type=str)
parser.add_argument(
'buffer_field',
help='(optional) float field in flowlines with buffer values',
default=None)
parser.add_argument('confinement_type',
help='type of confinement',
default="Unspecified")
parser.add_argument(
'--reach_codes',
help=
'Comma delimited reach codes (FCode) to retain when filtering features. Omitting this option retains all features.',
type=str)
parser.add_argument(
'--meta',
help='riverscapes project metadata as comma separated key=value pairs',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
parser.add_argument(
'--debug',
help="(optional) save intermediate outputs for debugging",
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger("Confinement")
log.setup(logPath=os.path.join(args.output_folder, "confinement.log"),
verbose=args.verbose)
log.title('Confinement For HUC: {}'.format(args.huc))
meta = parse_metadata(args.meta)
reach_codes = args.reach_codes.split(',') if args.reach_codes else None
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(args.output_folder, 'confinement_mem.log')
retcode, max_obj = ThreadRun(confinement,
memfile,
args.huc,
args.flowlines,
args.confining_polygon,
args.output_folder,
args.buffer_field,
args.confinement_type,
reach_codes,
min_buffer=10.0,
bankfull_expansion_factor=2.5,
debug=args.debug,
meta=meta)
log.debug('Return code: {}, [Max process usage] {}'.format(
retcode, max_obj))
else:
confinement(args.huc,
args.flowlines,
args.confining_polygon,
args.output_folder,
args.buffer_field,
args.confinement_type,
reach_codes,
min_buffer=10.0,
bankfull_expansion_factor=2.5,
debug=args.debug,
meta=meta)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
""" Testing for the vector base class
"""
import unittest
import os
from shapely.geometry import LineString
from rscommons import Logger, initGDALOGRErrors, GeopackageLayer, ShapefileLayer
from rscommons.classes.vector_base import VectorBase, VectorBaseException
from rscommons.util import safe_remove_dir
initGDALOGRErrors()
log = Logger('RSCommons TEST')
log.setup(verbose=True)
datadir = os.path.join(os.path.dirname(__file__), 'data')
class VectorBaseTest(unittest.TestCase):
# def setUp(self):
# super(VectorBaseTest, self).setUp()
# self.outdir = mkdtemp()
# def tearDown(self):
# super(VectorBaseTest, self).tearDown()
# safe_remove_dir(self.outdir)
def test_path_sorter(self):
# Exception Cases
self.assertRaises(VectorBaseException,
def main():
""" Main BRAT Build routine
"""
parser = argparse.ArgumentParser(
description='Build the inputs for an eventual brat_run:',
# epilog="This is an epilog"
)
parser.add_argument('huc', help='huc input', type=str)
parser.add_argument('dem', help='dem input', type=str)
parser.add_argument('slope', help='slope input', type=str)
parser.add_argument('hillshade', help='hillshade input', type=str)
parser.add_argument('flowlines', help='flowlines input', type=str)
parser.add_argument('existing_veg', help='existing_veg input', type=str)
parser.add_argument('historical_veg', help='historical_veg input', type=str)
parser.add_argument('valley_bottom', help='Valley bottom shapeFile', type=str)
parser.add_argument('roads', help='Roads shapeFile', type=str)
parser.add_argument('rail', help='Railways shapefile', type=str)
parser.add_argument('canals', help='Canals shapefile', type=str)
parser.add_argument('ownership', help='Ownership shapefile', type=str)
parser.add_argument('streamside_buffer', help='streamside_buffer input', type=float)
parser.add_argument('riparian_buffer', help='riparian_buffer input', type=float)
parser.add_argument('elevation_buffer', help='elevation_buffer input', type=float)
parser.add_argument('output_folder', help='output_folder input', type=str)
parser.add_argument('--reach_codes', help='Comma delimited reach codes (FCode) to retain when filtering features. Omitting this option retains all features.', type=str)
parser.add_argument('--canal_codes', help='Comma delimited reach codes (FCode) representing canals. Omitting this option retains all features.', type=str)
parser.add_argument('--peren_codes', help='Comma delimited reach codes (FCode) representing perennial features', type=str)
parser.add_argument('--flow_areas', help='(optional) path to the flow area polygon feature class containing artificial paths', type=str)
parser.add_argument('--waterbodies', help='(optional) waterbodies input', type=str)
parser.add_argument('--max_waterbody', help='(optional) maximum size of small waterbody artificial flows to be retained', type=float)
parser.add_argument('--meta', help='riverscapes project metadata as comma separated key=value pairs', type=str)
parser.add_argument('--verbose', help='(optional) a little extra logging ', action='store_true', default=False)
parser.add_argument('--debug', help='(optional) more output about things like memory usage. There is a performance cost', action='store_true', default=False)
# Substitute patterns for environment varaibles
args = dotenv.parse_args_env(parser)
reach_codes = args.reach_codes.split(',') if args.reach_codes else None
canal_codes = args.canal_codes.split(',') if args.canal_codes else None
peren_codes = args.peren_codes.split(',') if args.peren_codes else None
# Initiate the log file
log = Logger("BRAT Build")
log.setup(logPath=os.path.join(args.output_folder, "brat_build.log"), verbose=args.verbose)
log.title('BRAT Build Tool For HUC: {}'.format(args.huc))
meta = parse_metadata(args.meta)
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(args.output_folder, 'brat_build_memusage.log')
retcode, max_obj = ThreadRun(brat_build, memfile,
args.huc, args.flowlines, args.dem, args.slope, args.hillshade,
args.existing_veg, args.historical_veg, args.output_folder,
args.streamside_buffer, args.riparian_buffer,
reach_codes, canal_codes, peren_codes,
args.flow_areas, args.waterbodies, args.max_waterbody,
args.valley_bottom, args.roads, args.rail, args.canals, args.ownership,
args.elevation_buffer,
meta
)
log.debug('Return code: {}, [Max process usage] {}'.format(retcode, max_obj))
else:
brat_build(
args.huc, args.flowlines, args.dem, args.slope, args.hillshade,
args.existing_veg, args.historical_veg, args.output_folder,
args.streamside_buffer, args.riparian_buffer,
reach_codes, canal_codes, peren_codes,
args.flow_areas, args.waterbodies, args.max_waterbody,
args.valley_bottom, args.roads, args.rail, args.canals, args.ownership,
args.elevation_buffer,
meta
)
except Exception as ex:
log.error(ex)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser(description='Riverscapes Context Tool',
# epilog="This is an epilog"
)
parser.add_argument('huc', help='HUC identifier', type=str)
parser.add_argument('existing',
help='National existing vegetation raster',
type=str)
parser.add_argument('historic',
help='National historic vegetation raster',
type=str)
parser.add_argument('ownership',
help='National land ownership shapefile',
type=str)
parser.add_argument('fairmarket',
help='National fair market value raster',
type=str)
parser.add_argument('ecoregions',
help='National EcoRegions shapefile',
type=str)
parser.add_argument('prism',
help='Folder containing PRISM rasters in BIL format',
type=str)
parser.add_argument('output', help='Path to the output folder', type=str)
parser.add_argument(
'download',
help=
'Temporary folder for downloading data. Different HUCs may share this',
type=str)
parser.add_argument('--force',
help='(optional) download existing files ',
action='store_true',
default=False)
parser.add_argument(
'--parallel',
help=
'(optional) for running multiple instances of this at the same time',
action='store_true',
default=False)
parser.add_argument('--temp_folder',
help='(optional) cache folder for downloading files ',
type=str)
parser.add_argument(
'--meta',
help='riverscapes project metadata as comma separated key=value pairs',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
parser.add_argument(
'--debug',
help=
'(optional) more output about things like memory usage. There is a performance cost',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger("RS Context")
log.setup(logPath=os.path.join(args.output, "rs_context.log"),
verbose=args.verbose)
log.title('Riverscapes Context For HUC: {}'.format(args.huc))
log.info('HUC: {}'.format(args.huc))
log.info('EPSG: {}'.format(cfg.OUTPUT_EPSG))
log.info('Existing veg: {}'.format(args.existing))
log.info('Historical veg: {}'.format(args.historic))
log.info('Ownership: {}'.format(args.ownership))
log.info('Fair Market Value Raster: {}'.format(args.fairmarket))
log.info('Output folder: {}'.format(args.output))
log.info('Download folder: {}'.format(args.download))
log.info('Force download: {}'.format(args.force))
# This is a general place for unzipping downloaded files and other temporary work.
# We use GUIDS to make it specific to a particular run of the tool to avoid unzip collisions
parallel_code = "-" + str(uuid.uuid4()) if args.parallel is True else ""
scratch_dir = args.temp_folder if args.temp_folder else os.path.join(
args.download, 'scratch', 'rs_context{}'.format(parallel_code))
safe_makedirs(scratch_dir)
meta = parse_metadata(args.meta)
try:
if args.debug is True:
from rscommons.debug import ThreadRun
memfile = os.path.join(args.output, 'rs_context_memusage.log')
retcode, max_obj = ThreadRun(
rs_context, memfile, args.huc, args.existing, args.historic,
args.ownership, args.fairmarket, args.ecoregions, args.prism,
args.output, args.download, scratch_dir, args.parallel,
args.force, meta)
log.debug('Return code: {}, [Max process usage] {}'.format(
retcode, max_obj))
else:
rs_context(args.huc, args.existing, args.historic, args.ownership,
args.fairmarket, args.ecoregions, args.prism,
args.output, args.download, scratch_dir, args.parallel,
args.force, meta)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
# Cleaning up the scratch folder is essential
safe_remove_dir(scratch_dir)
sys.exit(1)
# Cleaning up the scratch folder is essential
safe_remove_dir(scratch_dir)
sys.exit(0)
# do_work()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('arg1', help='Some Argument 1', type=str)
parser.add_argument('arg2', help='Some Argument 2', type=int)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
# dotenv.parse_args_env will parse and replace any environment variables with the pattern {env:MYENVNAME}
args = dotenv.parse_args_env(parser)
# Initiate the log file
log = Logger("My Awesome Tool")
log.setup(logPath=os.path.join(args.output, "LOGFILE.log"),
verbose=args.verbose)
log.title("My Awesome Tool")
# We catch the main call because it allows us to exit gracefully with an error message and stacktrace
try:
run(args.arg1, args.arg2)
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
parser.add_argument('projectpath',
help='NHD flow line ShapeFile path',
type=str)
parser.add_argument('--verbose',
help='(optional) a little extra logging ',
action='store_true',
default=False)
args = dotenv.parse_args_env(parser)
if args.projectpath is None or len(args.projectpath) < 10:
raise Exception('projectpath has invalid value')
safe_makedirs(args.projectpath)
# Initiate the log file
log = Logger('Inundation XML')
log.setup(logPath=os.path.join(args.projectpath, 'Inundation.log'),
verbose=args.verbose)
try:
log.info('Starting')
build_xml(args.projectpath)
edit_xml(args.projectpath)
log.info('Exiting')
except Exception as e:
log.error(e)
traceback.print_exc(file=sys.stdout)
sys.exit(1)
sys.exit(0)
