def install_extension(): gisbase = os.getenv('GISBASE') if not gisbase: grass.fatal(_('$GISBASE not defined')) if options['extension'] in get_installed_extensions(force = True): grass.warning(_("Extension <%s> already installed. Re-installing...") % options['extension']) if sys.platform == "win32": ret = install_extension_win() else: ret = install_extension_other() if ret != 0: grass.warning(_('Installation failed, sorry. Please check above error messages.')) else: grass.message(_("Updating metadata file...")) install_extension_xml() grass.message(_("Installation of <%s> successfully finished") % options['extension']) # cleanup build cruft if not flags['s']: tidy_citizen() if not os.environ.has_key('GRASS_ADDON_PATH') or \ not os.environ['GRASS_ADDON_PATH']: grass.warning(_('This add-on module will not function until you set the ' 'GRASS_ADDON_PATH environment variable (see "g.manual variables")'))
def install_extension_win(): ### TODO: do not use hardcoded url - http://wingrass.fsv.cvut.cz/grassXX/addonsX.X.X version = grass.version()['version'].split('.') grass.message(_("Downloading precompiled GRASS Addons <%s>...") % options['extension']) url = "http://wingrass.fsv.cvut.cz/grass%s%s/addons" % (version[0], version[1]) if version[0] == '6' and version[1] == '4': url += '/grass-%s.%s.%s' % (version[0], version[1], version[2]) grass.debug("url=%s" % url, 1) try: f = urlopen(url + '/' + options['extension'] + '.zip') # create addons dir if not exists if not os.path.exists(options['prefix']): os.mkdir(options['prefix']) # download data fo = tempfile.TemporaryFile() fo.write(f.read()) zfobj = zipfile.ZipFile(fo) for name in zfobj.namelist(): if name.endswith('/'): d = os.path.join(options['prefix'], name) if not os.path.exists(d): os.mkdir(d) else: outfile = open(os.path.join(options['prefix'], name), 'wb') outfile.write(zfobj.read(name)) outfile.close() fo.close() except HTTPError: grass.fatal(_("GRASS Addons <%s> not found") % options['extension']) return 0
def main(): env = grass.gisenv() mapset = env['MAPSET'] ret = 0 vectors = grass.list_grouped('vect')[mapset] num_vectors = len(vectors) if grass.verbosity() < 2: quiet = True else: quiet = False i = 1 for vect in vectors: map = "%s@%s" % (vect, mapset) grass.message( _("%s\nBuilding topology for vector map <%s> (%d of %d)...\n%s") % ('-' * 80, map, i, num_vectors, '-' * 80)) grass.verbose(_("v.build map=%s") % map) try: grass.run_command("v.build", map=map, quiet=quiet) except CalledModuleError: grass.error( _("Building topology for vector map <%s> failed") % map) ret = 1 i += 1 return ret
def GetData(self, idx, server, query, output): """Download data""" grass.message(_("Downloading data (tile %d)...") % idx) grass.verbose("Requesting data: %s" % self.options['mapserver']) if not self.flags['g']: # -> post try: urllib.urlretrieve(server, output, data = query) except IOError: grass.fatal(_("Failed while downloading the data")) if not os.path.exists(output): grass.fatal(_("Failed while downloading the data")) # work-around for brain-dead ArcIMS servers which want POST-data as part of the GET URL # (this is technically allowed by OGC WMS def v1.3.0 Sec6.3.4) if os.path.getsize(output) == 0: grass.warning(_("Downloaded image file is empty -- trying another method")) self.flags['g'] = True if self.flags['g']: # -> get try: urllib.urlretrieve(server + '?' + query, output, data = None) except IOError: grass.fatal(_("Failed while downloading the data")) if not os.path.exists(output) or os.path.getsize(output) == 0: grass.fatal(_("Failed while downloading the data"))
def main(): try: global server from pycsw import server except ModuleNotFoundError as e: msg = e.msg grass.fatal( globalvar.MODULE_NOT_FOUND.format(lib=msg.split("'")[-2], url=globalvar.MODULE_URL)) path = options["path"] port = int(options["port"]) path = os.path.dirname(path) app_path = os.path.dirname(path) sys.path.append(app_path) from wsgiref.simple_server import make_server try: httpd = make_server("", port, application) grass.message("Serving on port %d..." % port) except Exception as e: grass.error(str(e)) sys.stdout.flush() sys.exit() httpd.serve_forever() sys.stdout.flush()
def import_files(directory, pattern): maps = [] if pattern: from glob import glob files = glob('{dir}{sep}{pat}'.format( dir=directory, sep=os.path.sep, pat=pattern) ) else: files = map(lambda x: os.path.join(directory, x), os.listdir(directory) ) start = time.time() import_module = Module('v.in.ascii', separator='space', z=3, flags='tbz', overwrite=overwrite(), quiet=True, run_=False) try: for f in files: basename = os.path.basename(f) mapname = os.path.splitext(basename)[0] maps.append(mapname) message("Importing <{}>...".format(f)) import_task = deepcopy(import_module) queue.put(import_task(input=f, output=mapname)) queue.wait() except CalledModuleError: return sys.exit(1) if not maps: fatal("No input files found") message("Import finished in {:.0f} sec".format(time.time() - start)) return maps
def install_extension_win(name): ### do not use hardcoded url - http://wingrass.fsv.cvut.cz/grassXX/addonsX.X.X grass.message(_("Downloading precompiled GRASS Addons <%s>...") % options['extension']) url = "http://wingrass.fsv.cvut.cz/grass%(major)s%(minor)s/addons/grass-%(major)s.%(minor)s.%(patch)s/" % \ { 'major' : version[0], 'minor' : version[1], 'patch' : version[2]} grass.debug("url=%s" % url, 1) try: f = urlopen(url + '/' + name + '.zip', proxies=PROXIES) # create addons dir if not exists if not os.path.exists(options['prefix']): os.mkdir(options['prefix']) # download data fo = tempfile.TemporaryFile() fo.write(f.read()) zfobj = zipfile.ZipFile(fo) for name in zfobj.namelist(): if name.endswith('/'): d = os.path.join(options['prefix'], name) if not os.path.exists(d): os.mkdir(d) else: outfile = open(os.path.join(options['prefix'], name), 'wb') outfile.write(zfobj.read(name)) outfile.close() fo.close() except HTTPError: grass.fatal(_("GRASS Addons <%s> not found") % name) return 0
def main(): env = grass.gisenv() mapset = env["MAPSET"] converted = 0 ret = 0 for vect in grass.list_grouped("oldvect")[mapset]: inmap = "%s@%s" % (vect, mapset) outmap = vect.replace(".", "_") try: grass.run_command("v.convert", input=inmap, output=outmap) except CalledModuleError: grass.warning(_("Error converting map <%s> to <%s>") % (inmap, outmap)) ret = 1 else: converted += 1 if converted < 1: grass.warning( _( "No vector maps converted as no old vector maps present in current mapset." ) ) else: grass.message( _("Total %u vector maps in current mapset converted.") % converted ) grass.message( _("Please verify new vector map(s) before deleting old vector map(s).") ) sys.exit(ret)
def main(): """Main function, called at execution time""" # parse arguments input = options['input'] var = options['var'] prefix = options['prefix'] # read NetCDF data nc = Dataset(input, 'r') data = nc.variables[var][:] nc.close() # set temporary region res = 32463.0 rows = 277 cols = 349 grass.run_command('g.region', n=res*(rows-0.5), s=res*-0.5, e=res*(cols-0.5), w=res*-0.5, rows=rows, cols=cols) # for each month a = garray.array() for (i, timeslice) in enumerate(data): mapname = prefix + '%02i' % (i+1) grass.message("Importing <%s> ..." % mapname) # import data with grass array a[:] = flipud(timeslice) a.write(mapname=mapname, overwrite=True, null=-32767)
def main(): env = grass.gisenv() mapset = env['MAPSET'] ret = 0 vectors = grass.list_grouped('vect')[mapset] num_vectors = len(vectors) if grass.verbosity() < 2: quiet = True else: quiet = False i = 1 for vect in vectors: map = "%s@%s" % (vect, mapset) grass.message(_("%s\nBuilding topology for vector map <%s> (%d of %d)...\n%s") % \ ('-' * 80, map, i, num_vectors, '-' * 80)) grass.verbose(_("v.build map=%s") % map) if grass.run_command("v.build", map = map, quiet = quiet) != 0: grass.error(_("Building topology for vector map <%s> failed") % map) ret = 1 i += 1 return ret
def main(): options, flags = gcore.parser() raster = options['raster'] raster_3d = options['raster_3d'] vector = options['vector'] sep = separator(options['separator']) perform_pre_checks = not flags['s'] dry_run = flags['d'] if perform_pre_checks: if raster: check_file(raster, 'raster', sep=sep) if raster_3d: check_file(raster_3d, 'raster_3d', sep=sep) if vector: check_file(vector, 'vector', sep=sep) if dry_run: gcore.message(_("Checks successful")) return if raster: rename_from_file(filename=raster, map_type='raster', sep=sep, safe_input=perform_pre_checks) if raster_3d: rename_from_file(filename=raster_3d, map_type='raster_3d', sep=sep, safe_input=perform_pre_checks) if vector: rename_from_file(filename=vector, map_type='vector', sep=sep, safe_input=perform_pre_checks)
def list_available_extensions_svn(): grass.message(_('Fetching list of extensions from GRASS-Addons SVN repository (be patient)...')) pattern = re.compile(r'(<li><a href=".+">)(.+)(</a></li>)', re.IGNORECASE) if flags['c']: grass.warning(_("Flag 'c' ignored, metadata file not available")) if flags['g']: grass.warning(_("Flag 'g' ignored, metadata file not available")) prefix = ['d', 'db', 'g', 'i', 'm', 'ps', 'p', 'r', 'r3', 's', 'v'] for d in prefix: modclass = expand_module_class_name(d) grass.verbose(_("Checking for '%s' modules...") % modclass) url = '%s/%s' % (options['svnurl'], modclass) grass.debug("url = %s" % url, debug = 2) try: f = urlopen(url, proxies=PROXIES) except HTTPError: grass.debug(_("Unable to fetch '%s'") % url, debug = 1) continue for line in f.readlines(): # list extensions sline = pattern.search(line) if not sline: continue name = sline.group(2).rstrip('/') if name.split('.', 1)[0] == d: print name
def main(): """Main function, called at execution time""" # parse arguments inputfile = options['input'] outputmap = options['output'] var = options['var'] # read NetCDF data nc = Dataset(inputfile, 'r') lon = nc.variables['longitude'][:] lat = nc.variables['latitude'][:] z = nc.variables[var][:] nc.close() # check that coordinates are regular dlon = np.diff(lon) dlat = np.diff(lat) dlon0 = dlon[0] dlat0 = dlat[0] assert (dlon == dlon0).all() assert (dlat == dlat0).all() # crop illegal latitudes lat = lat[np.abs(lat) < 90-np.abs(dlat0)/2] # rotate longitudes and sort lon -= (lon > 180)*360 lon_args = lon.argsort() lat_args = lat.argsort()[::-1] # crop and rotate data lat = lat[lat_args] lon = lon[lon_args] z = z[:, lat_args, :][:, :, lon_args] # set temporary region w = lon[-1] + dlon0/2 e = lon[0] - dlon0/2 s = lat[-1] - dlat0/2 n = lat[0] + dlat0/2 rows = len(lat) cols = len(lon) grass.run_command('g.region', w=w, e=e, s=s, n=n, rows=rows, cols=cols) # import time-independent data as such a = garray.array() if z.shape[0] == 1: a[:] = z[0] grass.message("Importing <%s> ..." % outputmap) a.write(mapname=outputmap, overwrite=True, null=-32767) # otherwise import each time slice else: for (i, data) in enumerate(z): mapname = outputmap + '%02i' % (i+1) grass.message("Importing <%s> ..." % mapname) a[:] = data a.write(mapname=mapname, overwrite=True, null=-32767)
def main(): """Main function, called at execution time""" # parse arguments inputfile = options['input'] outputmap = options['output'] var = options['var'] # read NetCDF data nc = Dataset(inputfile, 'r') lon = nc.variables['longitude'][:] lat = nc.variables['latitude'][:] z = nc.variables[var][:] nc.close() # check that coordinates are regular dlon = np.diff(lon) dlat = np.diff(lat) dlon0 = dlon[0] dlat0 = dlat[0] assert (dlon == dlon0).all() assert (dlat == dlat0).all() # crop illegal latitudes lat = lat[np.abs(lat) < 90 - np.abs(dlat0) / 2] # rotate longitudes and sort lon -= (lon > 180) * 360 lon_args = lon.argsort() lat_args = lat.argsort()[::-1] # crop and rotate data lat = lat[lat_args] lon = lon[lon_args] z = z[:, lat_args, :][:, :, lon_args] # set temporary region w = lon[-1] + dlon0 / 2 e = lon[0] - dlon0 / 2 s = lat[-1] - dlat0 / 2 n = lat[0] + dlat0 / 2 rows = len(lat) cols = len(lon) grass.run_command('g.region', w=w, e=e, s=s, n=n, rows=rows, cols=cols) # import time-independent data as such a = garray.array() if z.shape[0] == 1: a[:] = z[0] grass.message("Importing <%s> ..." % outputmap) a.write(mapname=outputmap, overwrite=True, null=-32767) # otherwise import each time slice else: for (i, data) in enumerate(z): mapname = outputmap + '%02i' % (i + 1) grass.message("Importing <%s> ..." % mapname) a[:] = data a.write(mapname=mapname, overwrite=True, null=-32767)
def clean_temp(): from grass.script import core as gcore gcore.message(_("Cleaning up temporary files...")) nul = open(os.devnull, "w") gisbase = os.environ["GISBASE"] call([os.path.join(gisbase, "etc", "clean_temp")], stdout=nul) nul.close()
def wkt2standards(self, prj_txt): try: from osgeo import osr except Exception, e: grass.message( 'GDAL python library is not installed: %s \n identifying of EPSG is disabled' % e) return None
def main(): input = options['input'] layer = options['layer'] format = options['format'] dsn = options['dsn'] table = options['table'] if format.lower() == 'dbf': format = "ESRI_Shapefile" if format.lower() == 'csv': olayer = basename(dsn, 'csv') else: olayer = None #is there a simpler way of testing for --overwrite? dbffile = input + '.dbf' if os.path.exists(dbffile) and not grass.overwrite(): grass.fatal(_("File <%s> already exists") % dbffile) if olayer: if grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer, dsn=dsn, format=format, type='point,line,area', olayer=olayer) != 0: sys.exit(1) else: if grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer, dsn=dsn, format=format, type='point,line,area') != 0: sys.exit(1) if format == "ESRI_Shapefile": exts = ['shp', 'shx', 'prj'] if dsn.endswith('.dbf'): outname = basename(dsn, 'dbf') for ext in exts: try_remove("%s.%s" % (outname, ext)) outname += '.dbf' else: for ext in exts: try_remove(os.path.join(dsn, "%s.%s" % (input, ext))) outname = os.path.join(dsn, input + ".dbf") elif format.lower() == 'csv': outname = dsn + '.csv' else: outname = input grass.message(_("Exported table <%s>") % outname)
def trails_combinations(scanned_elev, friction, walk_coeff, _lambda, slope_factor, walk, walking_dir, points, raster_route, vector_routes, mask, env): import itertools coordinates = gcore.read_command('v.out.ascii', input=points, format='point', separator=',', env=env).strip() coords_list = [] for coords in coordinates.split(os.linesep): coords_list.append(coords.split(',')[:2]) combinations = itertools.combinations(coords_list, 2) combinations = [ list(group) for k, group in itertools.groupby(combinations, key=lambda x: x[0]) ] i = k = 0 vector_routes_list = [] walk_tmp = 'walk_tmp' walk_dir_tmp = 'walk_dir_tmp' raster_route_tmp = 'raster_route_tmp' if mask: gcore.message('Activating mask') gcore.run_command('r.mask', raster=mask, overwrite=True, env=env) for points in combinations: i += 1 point_from = ','.join(points[0][0]) points_to = [','.join(pair[1]) for pair in points] vector_routes_list_drain = [] for each in points_to: vector_route_tmp = 'route_path_' + str(k) vector_routes_list_drain.append(vector_route_tmp) k += 1 vector_routes_list.extend(vector_routes_list_drain) trail(scanned_elev, friction, walk_coeff, _lambda, slope_factor, walk_tmp, walk_dir_tmp, point_from, points_to, raster_route_tmp, vector_routes_list_drain, env) gcore.run_command('v.patch', input=vector_routes_list, output=vector_routes, overwrite=True, env=env) gcore.run_command('g.remove', flags='f', type='raster', name=[walk_tmp, walk_dir_tmp, raster_route_tmp], env=env) gcore.message('Removing mask') if mask: gcore.run_command('r.mask', flags='r', env=env)
def main(): try: setmaps(options['sitesmap'], options['costmap'], flags['c'], options['inputmap'], options['outputmap'], flags['p']) # world.playground.setboundsfromlayer("costs") if not options['outrounds']: options['outrounds'] = 0 elif flags['s'] and options['outrounds'] > 0: world.addsequencenumber = True if flags['s']: world.antavoidsloops = True if options['lowcostlimit']: world.minpenalty = int(options['lowcostlimit']) if options['highcostlimit']: world.maxpenalty = int(options['highcostlimit']) if options['maxpheromone']: world.maxpheromone = int(options['maxpheromone']) world.maxrandom = world.maxpheromone if options['minpheromone']: world.minpheromone = int(options['minpheromone']) world.minrandom = world.minpheromone if options['volatilizationtime']: world.volatilizationtime = int(options['volatilizationtime']) if options['stepintensity']: world.stepintensity = int(options['stepintensity']) if options['pathintensity']: world.pathintensity = int(options['pathintensity']) if options['maxants']: world.maxants = int(options['maxants']) if options['antslife']: world.antslife = int(options['antslife']) if options['decisionalgorithm']: world.decisionbase = str(options['decisionalgorithm']) if options['evaluateposition']: world.evaluationbase = str(options['evaluateposition']) # if options['agentfreedom']: # world.globalfreedom = int(options['agentfreedom']) if options['pheromoneweight']: world.pheroweight = int(options['pheromoneweight']) if options['randomnessweight']: world.randomweight = int(options['randomnessweight']) if options['costweight']: world.costweight = int(options['costweight']) #if arglist[0] == "stability": #TODO ask silvia.. # world.checkvalues() except error.DataError: grass.fatal("Failed to parse args..") sys.exit(1) letantsdance(int(options['rounds']), int(options['outrounds'])) grass.message("FINISH")
def cleanup(rm_vectors): grass.message(_("Cleaning up...")) nuldev = open(os.devnull, 'w') for rm_v in rm_vectors: grass.run_command('g.remove', flags='f', type='vector', name=rm_v, quiet=True, stderr=nuldev)
def _createISODate(self, key): """Function for converting GRASS-generated date to ISO format if the format of date is different from GRASS-generated format - use it and print warning """ try: date = datetime.strptime(self.md_grass[key], "%a %b %d %H:%M:%S %Y") self.md_grass["dateofcreation"] = date.strftime("%Y-%m-%d") except: grass.message("date of creation: unknown date format") self.md_grass["dateofcreation"] = self.md_grass[key]
def _createISODate(self, key): '''Function for converting GRASS-generated date to ISO format if the format of date is different from GRASS-generated format - use it and print warning ''' try: date = datetime.strptime(self.md_grass[key], '%a %b %d %H:%M:%S %Y') self.md_grass['dateofcreation'] = date.strftime('%Y-%m-%d') except: grass.message('date of creation: unknown date format') self.md_grass['dateofcreation'] = self.md_grass[key]
def main(): start = time.time() maps = import_files(options['input'], options['pattern']) create_dmt_tiles(maps, float(options['resolution']), int(options['rst_nprocs'])) patch_tiles(maps, options['elevation'], options['resolution']) message("Done in {:.0f} min".format((time.time() - start) / 60.)) return 0
def run_one_combination(comb_count, comb_all, repeat, seed, development_start, compactness_mean, compactness_range, discount_factor, patches_file, fut_options, threshold, hist_bins_area_orig, hist_range_area_orig, hist_bins_compactness_orig, hist_range_compactness_orig, cell_size, histogram_area_orig, histogram_compactness_orig, tmp_name, queue): TMP_PROCESS = [] # unique name, must be sql compliant suffix = (str(discount_factor) + str(compactness_mean) + str(compactness_range)).replace('.', '') simulation_dev_end = tmp_name + 'simulation_dev_end_' + suffix simulation_dev_diff = tmp_name + 'simulation_dev_diff' + suffix tmp_clump = tmp_name + 'tmp_clump' + suffix TMP_PROCESS.append(simulation_dev_diff) TMP_PROCESS.append(simulation_dev_end) TMP_PROCESS.append(tmp_clump) sum_dist_area = 0 sum_dist_compactness = 0 # offset seed seed *= 10000 for i in range(repeat): f_seed = seed + i gcore.message(_("Running calibration combination {comb_count}/{comb_all}" " of simulation attempt {i}/{repeat} with random seed {s}...".format(comb_count=comb_count, comb_all=comb_all, i=i + 1, repeat=repeat, s=f_seed))) try: run_simulation(development_start=development_start, development_end=simulation_dev_end, compactness_mean=compactness_mean, compactness_range=compactness_range, discount_factor=discount_factor, patches_file=patches_file, seed=f_seed, fut_options=fut_options) except CalledModuleError as e: queue.put(None) cleanup(tmp=TMP_PROCESS) gcore.error(_("Running r.futures.pga failed. Details: {e}").format(e=e)) return new_development(simulation_dev_end, simulation_dev_diff) data = patch_analysis(simulation_dev_diff, threshold, tmp_clump) sim_hist_area, sim_hist_compactness = create_histograms(data, hist_bins_area_orig, hist_range_area_orig, hist_bins_compactness_orig, hist_range_compactness_orig, cell_size) sum_dist_area += compare_histograms(histogram_area_orig, sim_hist_area) sum_dist_compactness += compare_histograms(histogram_compactness_orig, sim_hist_compactness) mean_dist_area = sum_dist_area / repeat mean_dist_compactness = sum_dist_compactness / repeat data = {} data['input_discount_factor'] = discount_factor data['input_compactness_mean'] = compactness_mean data['input_compactness_range'] = compactness_range data['area_distance'] = mean_dist_area data['compactness_distance'] = mean_dist_compactness queue.put(data) cleanup(tmp=TMP_PROCESS)
def main(): # check dependecies if sys.platform != "win32": check_progs() # define path if flags['s']: options['prefix'] = os.environ['GISBASE'] if options['prefix'] == '$GRASS_ADDON_PATH': if not os.environ.has_key('GRASS_ADDON_PATH') or \ not os.environ['GRASS_ADDON_PATH']: major_version = int(grass.version()['version'].split('.', 1)[0]) grass.warning(_("GRASS_ADDON_PATH is not defined, " "installing to ~/.grass%d/addons/") % major_version) options['prefix'] = os.path.join(os.environ['HOME'], '.grass%d' % major_version, 'addons') else: path_list = os.environ['GRASS_ADDON_PATH'].split(os.pathsep) if len(path_list) < 1: grass.fatal(_("Invalid GRASS_ADDON_PATH value - '%s'") % os.environ['GRASS_ADDON_PATH']) if len(path_list) > 1: grass.warning(_("GRASS_ADDON_PATH has more items, using first defined - '%s'") % path_list[0]) options['prefix'] = path_list[0] # list available modules if flags['l'] or flags['c'] or flags['g']: list_available_extensions() return 0 elif flags['a']: elist = get_installed_extensions() if elist: grass.message(_("List of installed extensions:")) sys.stdout.write('\n'.join(elist)) sys.stdout.write('\n') else: grass.info(_("No extension installed")) return 0 else: if not options['extension']: grass.fatal(_('You need to define an extension name or use -l')) if flags['d']: if options['operation'] != 'add': grass.warning(_("Flag 'd' is relevant only to 'operation=add'. Ignoring this flag.")) else: global remove_tmpdir remove_tmpdir = False if options['operation'] == 'add': check_dirs() install_extension() else: # remove remove_extension(flags['f']) return 0
def GetTiles(self, requests): grass.message(_("Downloading tiles...")) i = 0 for item in requests: if os.path.exists(item['output']) and \ os.path.getsize(item['output']) > 0: grass.verbose("Tile already downloaded") else: self.GetData(i, item['server'], item['string'], item['output']) i += 1
def main(): input = options['input'] layer = options['layer'] format = options['format'] output = options['output'] table = options['table'] if format.lower() == 'dbf': format = "ESRI_Shapefile" if format.lower() == 'csv': olayer = basename(output, 'csv') else: olayer = None #is there a simpler way of testing for --overwrite? dbffile = input + '.dbf' if os.path.exists(dbffile) and not grass.overwrite(): grass.fatal(_("File <%s> already exists") % dbffile) if olayer: try: grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer, output=output, format=format, type='point,line,area', olayer=olayer) except CalledModuleError: grass.fatal(_("Module <%s> failed") % 'v.out.ogr') else: try: grass.run_command('v.out.ogr', quiet=True, input=input, layer=layer, output=output, format=format, type='point,line,area') except CalledModuleError: grass.fatal(_("Module <%s> failed") % 'v.out.ogr') if format == "ESRI_Shapefile": exts = ['shp', 'shx', 'prj'] if output.endswith('.dbf'): outname = basename(output, 'dbf') for ext in exts: try_remove("%s.%s" % (outname, ext)) outname += '.dbf' else: for ext in exts: try_remove(os.path.join(output, "%s.%s" % (input, ext))) outname = os.path.join(output, input + ".dbf") elif format.lower() == 'csv': outname = output + '.csv' else: outname = input grass.message(_("Exported table <%s>") % outname)
def main(): input = options['input'] layer = options['layer'] format = options['format'] output = options['output'] table = options['table'] if format.lower() == 'dbf': format = "ESRI_Shapefile" if format.lower() == 'csv': olayer = basename(output, 'csv') else: olayer = None # is there a simpler way of testing for --overwrite? dbffile = input + '.dbf' if os.path.exists(dbffile) and not gcore.overwrite(): gcore.fatal(_("File <%s> already exists") % dbffile) if olayer: try: gcore.run_command('v.out.ogr', quiet=True, input=input, layer=layer, output=output, format=format, type='point,line,area', olayer=olayer) except CalledModuleError: gcore.fatal(_("Module <%s> failed") % 'v.out.ogr') else: try: gcore.run_command('v.out.ogr', quiet=True, input=input, layer=layer, output=output, format=format, type='point,line,area') except CalledModuleError: gcore.fatal(_("Module <%s> failed") % 'v.out.ogr') if format == "ESRI_Shapefile": exts = ['shp', 'shx', 'prj'] if output.endswith('.dbf'): outname = basename(output, 'dbf') for ext in exts: try_remove("%s.%s" % (outname, ext)) outname += '.dbf' else: for ext in exts: try_remove(os.path.join(output, "%s.%s" % (input, ext))) outname = os.path.join(output, input + ".dbf") elif format.lower() == 'csv': outname = output + '.csv' else: outname = input gcore.message(_("Exported table <%s>") % outname)
def remove_extension(force = False): # try to read XML metadata file first fXML = os.path.join(options['prefix'], 'modules.xml') name = options['extension'] if name not in get_installed_extensions(): grass.warning(_("Extension <%s> not found") % name) if force: grass.verbose(_("List of removed files:")) else: grass.info(_("Files to be removed (use flag 'f' to force removal):")) if os.path.exists(fXML): f = open(fXML, 'r') tree = etree.fromstring(f.read()) flist = [] for task in tree.findall('task'): if name == task.get('name', default = '') and \ task.find('binary') is not None: for f in task.find('binary').findall('file'): flist.append(f.text) if flist: removed = False err = list() for fpath in flist: try: if force: grass.verbose(fpath) os.remove(fpath) removed = True else: print fpath except OSError: err.append((_("Unable to remove file '%s'") % fpath)) if force and not removed: grass.fatal(_("Extension <%s> not found") % options['extension']) if err: for e in err: grass.error(e) else: remove_extension_std(force) else: remove_extension_std(force) if force: grass.message(_("Updating metadata file...")) remove_extension_xml() grass.message(_("Extension <%s> successfully uninstalled.") % options['extension']) else: grass.warning(_("Extension <%s> not removed.\n" "Re-run '%s' with 'f' flag to force removal") % (options['extension'], 'g.extension'))
def make_links(dsn): layers = list_layers(dsn) for layer in layers: oname = layer.replace('.', '_') grass.message(_("%s\nCreating link for OGR layer <%s> as <%s>...\n%s") % \ ('-' * 80, layer, oname, '-' * 80)) try: grass.run_command('v.external', input = dsn, layer = layer, output = oname) except CalledModuleError: grass.warning(_("Unable to create link for OGR layer <%s>") % layer)
def remove_extension(): # is module available? bin_dir = os.path.join(options['prefix'], 'bin', options['extension']) scr_dir = os.path.join(options['prefix'], 'scripts', options['extension']) if not os.path.exists(bin_dir) and not os.path.exists(scr_dir): grass.fatal(_("Module <%s> not found") % options['extension']) for f in [bin_dir, scr_dir, os.path.join(options['prefix'], 'docs', 'html', options['extension'] + '.html'), os.path.join(options['prefix'], 'man', 'man1', options['extension'] + '.1')]: grass.try_remove(f) grass.message(_("Module <%s> successfully uninstalled") % options['extension'])
def main(): # check if input file exists infile = options['input'] gfile = grass.find_file(infile, element='vector') if not gfile['name']: grass.fatal(_("Vector map <%s> not found") % infile) # create tempfile and write ascii file of input temp_in = grass.tempfile() try: grass.run_command('v.out.ascii', overwrite=True, input=gfile['name'], output=temp_in) except CalledModuleError: grass.fatal(_("Failed to export vector in a temporary file")) # x and y of median point medx, medy = point_med(temp_in) try_remove(temp_in) # prepare the output output = "%f|%f" % (medx, medy) map_name = options['output'] overwrite = os.getenv('GRASS_OVERWRITE') # if output is not set return to stdout if map_name == '-': grass.message(output) # else else: # output file goutfile = grass.find_file(name=map_name, element='vector', mapset='.') # output tempfile temp_out = grass.tempfile() file_out = open(temp_out, 'w') file_out.write(output) file_out.close() # output file exists and not overwrite if goutfile['file'] and overwrite != '1': grass.fatal(_("Vector map <%s> already exists") % map_name) # output file exists and overwrite elif goutfile['file'] and overwrite == '1': grass.warning( _("Vector map <%s> already exists and will be overwritten") % map_name) grass.run_command('v.in.ascii', overwrite=True, input=temp_out, output=map_name) # output file not exists else: grass.run_command('v.in.ascii', input=temp_out, output=map_name) try_remove(temp_out)
def main(): out = options['output'] wfs_url = options['url'] tmp = grass.tempfile() tmpxml = tmp + '.xml' grass.message(_("Retrieving data...")) inf = urllib.urlopen(wfs_url) outf = file(tmpxml, 'wb') while True: s = inf.read() if not s: break outf.write(s) inf.close() outf.close() grass.message(_("Importing data...")) ret = grass.run_command('v.in.ogr', flags = 'o', dsn = tmpxml, out = out) grass.try_remove(tmpxml) if ret == 0: grass.message(_("Vector points map <%s> imported from WFS.") % out) else: grass.message(_("WFS import failed"))
def wkt2standards(self,prj_txt): try: from osgeo import osr except Exception as e: grass.message('GDAL python library is not installed: %s \n identifying of EPSG is disabled'%e) return None srs = osr.SpatialReference() srs.ImportFromESRI([prj_txt]) srs.AutoIdentifyEPSG() try : int(srs.GetAuthorityCode(None)) return srs.GetAuthorityCode(None) except: grass.message('Attempt of identifying EPSG is not successful') return None
def main(): path = options['path'] port = int(options['port']) path = os.path.dirname(path) app_path = os.path.dirname(path) sys.path.append(app_path) from wsgiref.simple_server import make_server try: httpd = make_server('', port, application) grass.message("Serving on port %d..." % port) except Exception, e: grass.error(str(e)) sys.stdout.flush() sys.exit()
def main(): input = options['input'] format = options['format'] dsn = options['dsn'] table = options['table'] if format.lower() == 'dbf': format = "ESRI_Shapefile" if format.lower() == 'csv': olayer = grass.basename(dsn, 'csv') else: olayer = None #is there a simpler way of testing for --overwrite? dbffile = input + '.dbf' if os.path.exists(dbffile) and not grass.overwrite(): grass.fatal(_("File <%s> already exists") % dbffile) if olayer: if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn, format = format, type = 'point', olayer = olayer) != 0: sys.exit(1) else: if grass.run_command('v.out.ogr', quiet = True, input = input, dsn = dsn, format = format, type = 'point') != 0: sys.exit(1) if format == "ESRI_Shapefile": exts = ['shp', 'shx', 'prj'] if dsn.endswith('.dbf'): outname = grass.basename(dsn, 'dbf') for ext in exts: grass.try_remove("%s.%s" % (outname, ext)) outname += '.dbf' else: for ext in exts: grass.try_remove(os.path.join(dsn, "%s.%s" % (input, ext))) outname = os.path.join(dsn, input + ".dbf") elif format.lower() == 'csv': outname = dsn + '.csv' else: outname = input grass.message(_("Exported table <%s>") % outname)
def list_available_extensions(url): if flags['t']: grass.message(_("List of available extensions (toolboxes):")) tlist = list_available_toolboxes(url) for toolbox_code, toolbox_data in tlist.iteritems(): if flags['g']: print 'toolbox_name=' + toolbox_data['name'] print 'toolbox_code=' + toolbox_code else: print '%s (%s)' % (toolbox_data['name'], toolbox_code) if flags['c'] or flags['g']: list_available_modules(url, toolbox_data['modules']) else: if toolbox_data['modules']: print os.linesep.join(map(lambda x: '* ' + x, toolbox_data['modules'])) else: grass.message(_("List of available extensions (modules):")) list_available_modules(url)
def clean_default_db(): # clean the default db if it is sqlite from grass.script import db as gdb from grass.script import core as gcore conn = gdb.db_connection() if conn and conn['driver'] == 'sqlite': # check if db exists gisenv = gcore.gisenv() database = conn['database'] database = database.replace('$GISDBASE', gisenv['GISDBASE']) database = database.replace('$LOCATION_NAME', gisenv['LOCATION_NAME']) database = database.replace('$MAPSET', gisenv['MAPSET']) if os.path.exists(database): gcore.message(_("Cleaning up default sqlite database ...")) gcore.start_command('db.execute', sql = 'VACUUM') # give it some time to start import time time.sleep(0.1)
def remove_extension(force = False): if flags['t']: mlist = get_toolbox_modules(options['extension']) else: mlist = [options['extension']] if force: grass.verbose(_("List of removed files:")) else: grass.info(_("Files to be removed (use flag 'f' to force removal):")) remove_modules(mlist, force) if force: grass.message(_("Updating metadata file...")) remove_extension_xml(mlist) grass.message(_("Extension <%s> successfully uninstalled.") % options['extension']) else: grass.warning(_("Extension <%s> not removed.\n" "Re-run '%s' with 'f' flag to force removal") % (options['extension'], 'g.extension'))
def clean_default_db(): # clean the default db if it is sqlite from grass.script import core as gcore from grass.script import db as gdb conn = gdb.db_connection() if conn and conn["driver"] == "sqlite": # check if db exists gisenv = gcore.gisenv() database = conn["database"] database = database.replace("$GISDBASE", gisenv["GISDBASE"]) database = database.replace("$LOCATION_NAME", gisenv["LOCATION_NAME"]) database = database.replace("$MAPSET", gisenv["MAPSET"]) if os.path.exists(database): gcore.message(_("Cleaning up default sqlite database ...")) gcore.start_command("db.execute", sql="VACUUM") # give it some time to start import time time.sleep(0.1)
def main(): env = grass.gisenv() mapset = env["MAPSET"] converted = 0 ret = 0 for vect in grass.list_grouped("oldvect")[mapset]: inmap = "%s@%s" % (vect, mapset) outmap = vect.replace(".", "_") if grass.run_command("v.convert", input=inmap, output=outmap) == 0: converted += 1 else: grass.warning(_("Error converting map <%s> to <%s>") % (inmap, outmap)) ret = 1 if converted < 1: grass.warning(_("No vector maps converted as no old vector maps present in current mapset.")) else: grass.message(_("Total %u vector maps in current mapset converted.") % converted) grass.message(_("Please verify new vector map(s) before deleting old vector map(s).")) sys.exit(ret)
def trails_combinations(scanned_elev, friction, walk_coeff, _lambda, slope_factor, walk, walking_dir, points, raster_route, vector_routes, mask, env): import itertools coordinates = gcore.read_command('v.out.ascii', input=points, format='point', separator=',', env=env).strip() coords_list = [] for coords in coordinates.split(os.linesep): coords_list.append(coords.split(',')[:2]) combinations = itertools.combinations(coords_list, 2) combinations = [list(group) for k, group in itertools.groupby(combinations, key=lambda x: x[0])] i = k = 0 vector_routes_list = [] walk_tmp = 'walk_tmp' walk_dir_tmp = 'walk_dir_tmp' raster_route_tmp = 'raster_route_tmp' if mask: gcore.message('Activating mask') gcore.run_command('r.mask', raster=mask, overwrite=True, env=env) for points in combinations: i += 1 point_from = ','.join(points[0][0]) points_to = [','.join(pair[1]) for pair in points] vector_routes_list_drain = [] for each in points_to: vector_route_tmp = 'route_path_' + str(k) vector_routes_list_drain.append(vector_route_tmp) k += 1 vector_routes_list.extend(vector_routes_list_drain) trail(scanned_elev, friction, walk_coeff, _lambda, slope_factor, walk_tmp, walk_dir_tmp, point_from, points_to, raster_route_tmp, vector_routes_list_drain, env) gcore.run_command('v.patch', input=vector_routes_list, output=vector_routes, overwrite=True, env=env) gcore.run_command('g.remove', flags='f', type='raster', name=[walk_tmp, walk_dir_tmp, raster_route_tmp], env=env) gcore.message('Removing mask') if mask: gcore.run_command('r.mask', flags='r', env=env)
def list_available_modules(): mlist = list() grass.message(_('Fetching list of modules from GRASS-Addons SVN (be patient)...')) pattern = re.compile(r'(<li><a href=".+">)(.+)(</a></li>)', re.IGNORECASE) i = 0 prefix = ['d', 'db', 'g', 'i', 'm', 'ps', 'p', 'r', 'r3', 's', 'v'] nprefix = len(prefix) for d in prefix: if flags['g']: grass.percent(i, nprefix, 1) i += 1 modclass = expand_module_class_name(d) grass.verbose(_("Checking for '%s' modules...") % modclass) url = '%s/%s' % (options['svnurl'], modclass) grass.debug("url = %s" % url, debug = 2) f = urllib.urlopen(url) if not f: grass.warning(_("Unable to fetch '%s'") % url) continue for line in f.readlines(): # list modules sline = pattern.search(line) if not sline: continue name = sline.group(2).rstrip('/') if name.split('.', 1)[0] == d: print_module_desc(name, url) mlist.append(name) mlist += list_wxgui_extensions() if flags['g']: grass.percent(1, 1, 1) return mlist
def create_dmt_tiles(maps, res, rst_nprocs, offset_multiplier=10): offset=res * offset_multiplier start = time.time() region_module = Module('g.region', n='n+{}'.format(offset), s='s-{}'.format(offset), e='e+{}'.format(offset), w='w-{}'.format(offset), quiet=True) rst_module = Module('v.surf.rst', nprocs=rst_nprocs, overwrite=overwrite(), quiet=True, run_=False) try: for mapname in maps: message("Interpolating <{}>...".format(mapname)) region_task = deepcopy(region_module) rst_task = deepcopy(rst_module) mm = MultiModule([region_task(vector=mapname), rst_task(input=mapname, elevation=mapname)], sync=False, set_temp_region=True) queue.put(mm) queue.wait() except CalledModuleError: return sys.exit(1) message("Interpolation finished in {:.0f} min".format((time.time() - start) / 60.))
def main(): # see https://grasswiki.osgeo.org/wiki/Convert_all_GRASS_6_vector_maps_to_GRASS_7 grass.message('Building topology') if grass.run_command('v.build.all') != 0: grass.warning('Cannot build topology') grass.message('Creating new DB connection') if grass.run_command('db.connect', flags='d') != 0: grass.warning('Cannot create new DB connection') return grass.message('Transferring tables to the new DB') if grass.run_command('v.db.reconnect.all', flags='cd') != 0: grass.warning('Cannot transfer tables')
def main(): # see https://grasswiki.osgeo.org/wiki/Convert_all_GRASS_6_vector_maps_to_GRASS_7 grass.message("Building topology") if grass.run_command("v.build.all") != 0: grass.warning("Cannot build topology") grass.message("Creating new DB connection") if grass.run_command("db.connect", flags="d") != 0: grass.warning("Cannot create new DB connection") return grass.message("Transferring tables to the new DB") if grass.run_command("v.db.reconnect.all", flags="cd") != 0: grass.warning("Cannot transfer tables")
def main(): test_file = options['test'] expected = grass.tempfile() result = grass.tempfile() dbconn = grassdb.db_connection() grass.message(_("Using DB driver: %s") % dbconn['driver']) infile = os.path.join(os.environ['GISBASE'], 'etc', 'db.test', test_file) inf = file(infile) while True: type = inf.readline() if not type: break type = type.rstrip('\r\n') sql = inf.readline().rstrip('\r\n') sys.stdout.write(sql + '\n') # Copy expected result to temp file try: if type == 'X': grass.write_command('db.execute', input = '-', stdin = sql + '\n') else: resf = file(result, 'w') grass.write_command('db.select', input = '-', flags = 'c', stdin = sql + '\n', stdout = resf) resf.close() except CalledModuleError: grass.error("EXECUTE: ******** ERROR ********") else: grass.message(_("EXECUTE: OK")) expf = file(expected, 'w') while True: res = inf.readline().rstrip('\r\n') if not res: break expf.write(res + '\n') expf.close() if type == 'S': if grass.call(['diff', result, expected]) != 0: grass.error("RESULT: ******** ERROR ********") else: grass.message(_("RESULT: OK"))
def main(): shell = flags['g'] image = {} for band in bands: image[band] = options['image%d' % band] # calculate the Stddev for TM bands grass.message(_("Calculating Standard deviations for all bands...")) stddev = {} for band in bands: grass.verbose("band %d" % band) s = grass.read_command('r.univar', flags = 'g', map = image[band]) kv = grass.parse_key_val(s) stddev[band] = float(kv['stddev']) grass.message(_("Calculating Correlation Matrix...")) correlation = {} s = grass.read_command('r.covar', flags = 'r', map = [image[band] for band in bands]) for i, row in zip(bands, s.splitlines()): for j, cell in zip(bands, row.split(' ')): correlation[i,j] = float(cell) # Calculate all combinations grass.message(_("Calculating OIF for the 20 band combinations...")) oif = [] for p in perms(): oif.append((oifcalc(stddev, correlation, *p), p)) oif.sort(reverse = True) grass.verbose(_("The Optimum Index Factor analysis result " "(Best combination comes first):")) if shell: fmt = "%d%d%d:%f\n" else: fmt = "%d%d%d: %f\n" outf = file('i.oif.result', 'w') for v, p in oif: sys.stdout.write(fmt % (p + (v,))) outf.write(fmt % (p + (v,))) outf.close()
def install_extension(url): gisbase = os.getenv('GISBASE') if not gisbase: grass.fatal(_('$GISBASE not defined')) if options['extension'] in get_installed_extensions(force = True): grass.warning(_("Extension <%s> already installed. Re-installing...") % options['extension']) if flags['t']: grass.message(_("Installing toolbox <%s>...") % options['extension']) mlist = get_toolbox_modules(url, options['extension']) else: mlist = [options['extension']] if not mlist: grass.warning(_("Nothing to install")) return ret = 0 for module in mlist: if sys.platform == "win32": ret += install_extension_win(module) else: ret += install_extension_other(module) if len(mlist) > 1: print '-' * 60 if flags['d']: return if ret != 0: grass.warning(_('Installation failed, sorry. Please check above error messages.')) else: grass.message(_("Updating metadata file...")) blist = install_extension_xml(url, mlist) for module in blist: update_manual_page(module) grass.message(_("Installation of <%s> successfully finished") % options['extension']) if not os.getenv('GRASS_ADDON_BASE'): grass.warning(_('This add-on module will not function until you set the ' 'GRASS_ADDON_BASE environment variable (see "g.manual variables")'))
def main(): env = grass.gisenv() mapset = env['MAPSET'] converted = 0 ret = 0 for site in grass.list_grouped('sites')[mapset]: inmap = "%s@%s" % (site, mapset) outmap = site.replace(".", "_") + "_points" grass.message(_("Processing %s -> %s") % (inmap, outmap)) if grass.run_command("v.in.sites", input = inmap, output = outmap) == 0: converted += 1 else: grass.warning(_("Error converting map %s to %s") % (inmap, outmap)) ret = 1 if converted < 1: grass.warning(_("No sites maps converted as no old sites maps present in current mapset.")) else: grass.message(_("Total %u sites maps in current mapset converted to vector maps (original names extended by '_points')") % converted) grass.message(_("Please verify new vector map(s) before deleting old sites map(s).")) sys.exit(ret)
def main(): infile = options['input'] compression_off = flags['c'] mapset = None if '@' in infile: infile, mapset = infile.split('@') if options['output']: outfile_path, outfile_base = os.path.split(os.path.abspath(options['output'])) else: outfile_path, outfile_base = os.path.split(os.path.abspath(infile + ".pack")) outfile = os.path.join(outfile_path, outfile_base) global tmp tmp = grass.tempdir() tmp_dir = os.path.join(tmp, infile) os.mkdir(tmp_dir) grass.debug('tmp_dir = %s' % tmp_dir) gfile = grass.find_file(name = infile, element = 'cell', mapset = mapset) if not gfile['name']: grass.fatal(_("Raster map <%s> not found") % infile) if os.path.exists(outfile): if os.getenv('GRASS_OVERWRITE'): grass.warning(_("Pack file <%s> already exists and will be overwritten") % outfile) try_remove(outfile) else: grass.fatal(_("option <output>: <%s> exists.") % outfile) grass.message(_("Packing <%s> to <%s>...") % (gfile['fullname'], outfile)) basedir = os.path.sep.join(os.path.normpath(gfile['file']).split(os.path.sep)[:-2]) olddir = os.getcwd() # copy elements for element in ['cats', 'cell', 'cellhd', 'colr', 'fcell', 'hist']: path = os.path.join(basedir, element, infile) if os.path.exists(path): grass.debug('copying %s' % path) shutil.copyfile(path, os.path.join(tmp_dir, element)) if os.path.exists(os.path.join(basedir, 'cell_misc', infile)): shutil.copytree(os.path.join(basedir, 'cell_misc', infile), os.path.join(tmp_dir, 'cell_misc')) if not os.listdir(tmp_dir): grass.fatal(_("No raster map components found")) # copy projection info # (would prefer to use g.proj*, but this way is 5.3 and 5.7 compat) gisenv = grass.gisenv() for support in ['INFO', 'UNITS', 'EPSG']: path = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'], 'PERMANENT', 'PROJ_' + support) if os.path.exists(path): shutil.copyfile(path, os.path.join(tmp_dir, 'PROJ_' + support)) # pack it all up os.chdir(tmp) if compression_off: tar = tarfile.TarFile.open(name = outfile_base, mode = 'w:') else: tar = tarfile.TarFile.open(name = outfile_base, mode = 'w:gz') tar.add(infile, recursive = True) tar.close() try: shutil.move(outfile_base, outfile) except shutil.Error as e: grass.fatal(e) os.chdir(olddir) grass.verbose(_("Raster map saved to '%s'" % outfile))