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 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 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 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():
"""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():
# 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 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(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 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))
