def InitVariables(self):
"""!Initialize any variables nneded by application"""
self.currentRaster = None
self.statitistics = dict()
# use WIND_OVERRIDE region not to affect current region
gcore.use_temp_region()
def main():
options, flags = gcore.parser()
probability = options['probability']
output = options['output']
count = int(options['count'])
gcore.use_temp_region()
# probability map
probab_01 = 'probability_01_' + str(os.getpid())
TMP_RAST.append(probab_01)
info = grast.raster_info(probability)
gcore.write_command('r.recode', flags='d', input=probability, output=probab_01,
title="Recoded probability map to 0 to 1",
rules='-', stdin='{minim}:{maxim}:0:1'.format(minim=info['min'], maxim=info['max']))
mean = gcore.parse_key_val(gcore.read_command('r.univar', map=probab_01, flags='g'),
val_type=float)['mean']
resolution = count / (mean * (info['north'] - info['south'] + info['east'] - info['west']))
resolution = sqrt((mean * (info['north'] - info['south']) * (info['east'] - info['west'])) / count)
gcore.run_command('g.region', res=resolution)
random_name = 'random_' + str(os.getpid())
point_map = 'points_' + str(os.getpid())
point_grid = 'points_' + str(os.getpid())
TMP_RAST.append(random_name)
TMP_RAST.append(point_map)
TMP_VECT.append(point_grid)
gcore.run_command('r.surf.random', output=random_name, min=0, max=1)
grast.mapcalc(exp='{point_map} = if({rand} <= {prob}, 1, null())'.format(rand=random_name,
prob=probab_01,
point_map=point_map))
gcore.run_command('r.to.vect', flags='t', input=point_map, output=point_grid, type='point')
gcore.run_command('v.perturb', input=point_grid, output=output,
parameter=resolution / 2., seed=os.getpid())
def InitVariables(self):
"""!Initialize any variables nneded by application"""
self.currentRaster = None
self.statitistics = dict()
# use WIND_OVERRIDE region not to affect current region
gcore.use_temp_region()
def writeCircle(self, circle, rasterName):
coords = self.mapWindow.Pixel2Cell(circle.point)
RunCommand('r.circle', output=rasterName, max=circle.radius,
coordinate=coords, flags="b")
grass.use_temp_region()
grass.run_command('g.region', zoom=rasterName)
region = grass.region()
marea = MaskedArea(region, rasterName, circle.radius)
return marea
def writeCircle(self, circle, rasterName):
coords = self.mapWindow.Pixel2Cell(circle.point)
RunCommand('r.circle', output=rasterName, max=circle.radius,
coordinate=coords, flags="b")
grass.use_temp_region()
grass.run_command('g.region', zoom=rasterName)
region = grass.region()
marea = MaskedArea(region, rasterName, circle.radius)
return marea
def writeArea(self, coords, rasterName):
polyfile = tempfile.NamedTemporaryFile(delete=False)
polyfile.write("AREA\n")
for coor in coords:
east, north = coor
point = " %s %s\n" % (east, north)
polyfile.write(point)
catbuf = "=%d a\n" % self.catId
polyfile.write(catbuf)
self.catId = self.catId + 1
polyfile.close()
region_settings = grass.parse_command("g.region",
flags="p",
delimiter=":")
pname = polyfile.name.split("/")[-1]
tmpraster = "rast_" + pname
tmpvector = "vect_" + pname
wx.BeginBusyCursor()
wx.GetApp().Yield()
RunCommand(
"r.in.poly",
input=polyfile.name,
output=tmpraster,
rows=region_settings["rows"],
overwrite=True,
)
RunCommand("r.to.vect",
input=tmpraster,
output=tmpvector,
type="area",
overwrite=True)
RunCommand("v.to.rast",
input=tmpvector,
output=rasterName,
value=1,
use="val")
wx.EndBusyCursor()
grass.use_temp_region()
grass.run_command("g.region", vector=tmpvector)
region = grass.region()
marea = MaskedArea(region, rasterName)
RunCommand("g.remove", flags="f", type="raster", name=tmpraster)
RunCommand("g.remove", flags="f", type="vector", name=tmpvector)
os.unlink(polyfile.name)
return marea
def writeArea(self, coords, rasterName):
polyfile = tempfile.NamedTemporaryFile(delete=False)
polyfile.write("AREA\n")
for coor in coords:
east, north = coor
point = " %s %s\n" % (east, north)
polyfile.write(point)
catbuf = "=%d a\n" % self.catId
polyfile.write(catbuf)
self.catId = self.catId + 1
polyfile.close()
region_settings = grass.parse_command('g.region',
flags='p',
delimiter=':')
pname = polyfile.name.split('/')[-1]
tmpraster = "rast_" + pname
tmpvector = "vect_" + pname
wx.BeginBusyCursor()
wx.Yield()
RunCommand('r.in.poly',
input=polyfile.name,
output=tmpraster,
rows=region_settings['rows'],
overwrite=True)
RunCommand('r.to.vect',
input=tmpraster,
output=tmpvector,
type='area',
overwrite=True)
RunCommand('v.to.rast',
input=tmpvector,
output=rasterName,
value=1,
use='val')
wx.EndBusyCursor()
grass.use_temp_region()
grass.run_command('g.region', vector=tmpvector)
region = grass.region()
marea = MaskedArea(region, rasterName)
RunCommand('g.remove', flags='f', type='raster', name=tmpraster)
RunCommand('g.remove', flags='f', type='vector', name=tmpvector)
os.unlink(polyfile.name)
return marea
def _rectangleDrawn(self):
"""When drawing finished, get region values"""
mouse = self.mapWindow.mouse
item = self._registeredGraphics.GetItem(0)
p1 = self.mapWindow.Pixel2Cell(mouse["begin"])
p2 = self.mapWindow.Pixel2Cell(mouse["end"])
item.SetCoords([p1, p2])
region = {
"n": max(p1[1], p2[1]),
"s": min(p1[1], p2[1]),
"w": min(p1[0], p2[0]),
"e": max(p1[0], p2[0]),
}
item.SetPropertyVal("hide", False)
self.mapWindow.ClearLines()
self._registeredGraphics.Draw()
if self.samplingtype in [SamplingType.MUNITSR, SamplingType.MMVWINR]:
dlg = wx.MessageDialog(
self,
"Is this area ok?",
"select sampling unit",
wx.YES_NO | wx.ICON_QUESTION,
)
ret = dlg.ShowModal()
if ret == wx.ID_YES:
grass.use_temp_region()
grass.run_command(
"g.region",
n=region["n"],
s=region["s"],
e=region["e"],
w=region["w"],
)
tregion = grass.region()
self.sampleFrameChanged.emit(region=tregion)
self.mapWindow.ClearLines()
item = self._registeredGraphics.GetItem(0)
item.SetPropertyVal("hide", True)
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers,
ignoreNulls=False,
render=True)
else:
self.nextRegion(next=False)
dlg.Destroy()
elif self.samplingtype != SamplingType.WHOLE:
"""When drawing finished, get region values"""
self.sampleFrameChanged.emit(region=region)
def run_modules_in_temp_region(module_list, q):
"""Run the modules in a temporary region environment
This function is the argument for multiprocessing.Process class
in the MultiModule asynchronous execution.
:param module_list: The list of modules to run in serial
:param q: The process queue to put the finished process list
"""
use_temp_region()
try:
for proc in module_list:
proc.run()
proc.wait()
finally:
q.put(module_list)
del_temp_region()
def run_modules_in_temp_region(module_list, q):
"""Run the modules in a temporary region environment
This function is the argument for multiprocessing.Process class
in the MultiModule asynchronous execution.
:param module_list: The list of modules to run in serial
:param q: The process queue to put the finished process list
"""
use_temp_region()
try:
for proc in module_list:
proc.run()
proc.wait()
except:
raise
finally:
q.put(module_list)
del_temp_region()
def writeArea(self, coords, rasterName):
polyfile = tempfile.NamedTemporaryFile(delete=False)
polyfile.write("AREA\n")
for coor in coords:
east, north = coor
point = " %s %s\n" % (east, north)
polyfile.write(point)
catbuf = "=%d a\n" % self.catId
polyfile.write(catbuf)
self.catId = self.catId + 1
polyfile.close()
region_settings = grass.parse_command('g.region', flags='p',
delimiter=':')
pname = polyfile.name.split('/')[-1]
tmpraster = "rast_" + pname
tmpvector = "vect_" + pname
wx.BeginBusyCursor()
wx.Yield()
RunCommand('r.in.poly', input=polyfile.name, output=tmpraster,
rows=region_settings['rows'], overwrite=True)
RunCommand('r.to.vect', input=tmpraster, output=tmpvector,
type='area', overwrite=True)
RunCommand('v.to.rast', input=tmpvector, output=rasterName,
value=1, use='val')
wx.EndBusyCursor()
grass.use_temp_region()
grass.run_command('g.region', vector=tmpvector)
region = grass.region()
marea = MaskedArea(region, rasterName)
RunCommand('g.remove', flags='f', type='raster', name=tmpraster)
RunCommand('g.remove', flags='f', type='vector', name=tmpvector)
os.unlink(polyfile.name)
return marea
def _rectangleDrawn(self):
"""When drawing finished, get region values"""
mouse = self.mapWindow.mouse
item = self._registeredGraphics.GetItem(0)
p1 = self.mapWindow.Pixel2Cell(mouse['begin'])
p2 = self.mapWindow.Pixel2Cell(mouse['end'])
item.SetCoords([p1, p2])
region = {'n': max(p1[1], p2[1]),
's': min(p1[1], p2[1]),
'w': min(p1[0], p2[0]),
'e': max(p1[0], p2[0])}
item.SetPropertyVal('hide', False)
self.mapWindow.ClearLines()
self._registeredGraphics.Draw(self.mapWindow.pdcTmp)
if self.samplingtype in [SamplingType.MUNITSR, SamplingType.MMVWINR]:
dlg = wx.MessageDialog(self, "Is this area ok?",
"select sampling unit",
wx.YES_NO | wx.ICON_QUESTION)
ret = dlg.ShowModal()
if ret == wx.ID_YES:
grass.use_temp_region()
grass.run_command('g.region', n=region['n'], s=region['s'],
e=region['e'], w=region['w'])
tregion = grass.region()
self.sampleFrameChanged.emit(region=tregion)
self.mapWindow.ClearLines()
item = self._registeredGraphics.GetItem(0)
item.SetPropertyVal('hide', True)
layers = self.map_.GetListOfLayers()
self.mapWindow.ZoomToMap(layers=layers, ignoreNulls=False,
render=True)
else:
self.nextRegion(next=False)
dlg.Destroy()
elif self.samplingtype != SamplingType.WHOLE:
"""When drawing finished, get region values"""
self.sampleFrameChanged.emit(region=region)
def main():
size = int(options["size"])
gamma = scale = None
if options["gamma"]:
gamma = float(options["gamma"])
if options["scaling_factor"]:
scale = float(options["scaling_factor"])
input_dev = options["input"]
output = options["output"]
method = options["method"]
if method in ("gravity", "kernel") and (gamma is None or scale is None):
gcore.fatal(
_("Methods gravity and kernel require options scaling_factor and gamma"
))
temp_map = "tmp_futures_devPressure_" + str(os.getpid()) + "_copy"
temp_map_out = "tmp_futures_devPressure_" + str(os.getpid()) + "_out"
temp_map_nulls = "tmp_futures_devPressure_" + str(os.getpid()) + "_nulls"
global TMP, TMPFILE
if flags["n"]:
gcore.message(_("Preparing data..."))
region = gcore.region()
gcore.use_temp_region()
gcore.run_command(
"g.region",
n=region["n"] + size * region["nsres"],
s=region["s"] - size * region["nsres"],
e=region["e"] + size * region["ewres"],
w=region["w"] - size * region["ewres"],
)
TMP.append(temp_map)
TMP.append(temp_map_nulls)
TMP.append(temp_map_out)
exp = "{temp_map_nulls} = if(isnull({inp}), 1, null())".format(
temp_map_nulls=temp_map_nulls, inp=input_dev)
grast.mapcalc(exp=exp)
grast.mapcalc(exp="{temp} = if(isnull({inp}), 0, {inp})".format(
temp=temp_map, inp=input_dev))
rmfilter_inp = temp_map
rmfilter_out = temp_map_out
else:
rmfilter_inp = input_dev
rmfilter_out = output
matrix = distance_matrix(size)
if method == "occurrence":
matrix[matrix > 0] = 1
elif method == "gravity":
with np.errstate(divide="ignore"):
denom = np.power(matrix, gamma)
matrix = scale / denom
matrix[denom == 0] = 0
else:
matrix_ = scale * np.exp(-2 * matrix / gamma)
matrix = np.where(matrix > 0, matrix_, 0)
path = gcore.tempfile()
global TMPFILE
TMPFILE = path
with open(path, "w") as f:
f.write(write_filter(matrix))
gcore.message(_("Running development pressure filter..."))
gcore.run_command("r.mfilter",
input=rmfilter_inp,
output=rmfilter_out,
filter=path)
if flags["n"]:
gcore.run_command(
"g.region",
n=region["n"],
s=region["s"],
e=region["e"],
w=region["w"],
)
grast.mapcalc(
exp="{out} = if(isnull({temp_null}), {rmfilter_out}, null())".
format(temp_null=temp_map_nulls,
rmfilter_out=rmfilter_out,
out=output))
gcore.del_temp_region()
grast.raster_history(output)
def main():
options, flags = gcore.parser()
aspect = options['aspect']
speed = options['speed']
probability = options['probability']
if options['particle_base']:
particle_base = options['particle_base'] + '_'
else:
particle_base = None
if options['particles']:
particles = options['particles']
min_size = float(options['min_size'])
max_size = float(options['max_size'])
comet_length = int(options['comet_length'])
else:
particles = min_size = max_size = comet_length = None
try:
total_time = int(options['total_time'])
step = int(options['step'])
age = int(options['age'])
count = int(options['count'])
except ValueError:
gcore.fatal(_("Parameter should be integer"))
gcore.use_temp_region()
# create aspect in x and y direction
aspect_x = 'aspect_x_' + str(os.getpid())
aspect_y = 'aspect_y_' + str(os.getpid())
xshift_tmp = 'xshift_tmp_' + str(os.getpid())
yshift_tmp = 'yshift_tmp_' + str(os.getpid())
TMP_RAST.append(aspect_x)
TMP_RAST.append(aspect_y)
grast.mapcalc(exp="{aspect_x} = cos({aspect})".format(aspect_x=aspect_x, aspect=aspect))
grast.mapcalc(exp="{aspect_y} = sin({aspect})".format(aspect_y=aspect_y, aspect=aspect))
grast.mapcalc(exp="{xshift} = {aspect_x}*{speed}*{t}".format(xshift=xshift_tmp, t=step, speed=speed,
aspect_x=aspect_x), overwrite=True)
grast.mapcalc(exp="{yshift} = {aspect_y}*{speed}*{t}".format(yshift=yshift_tmp, t=step, speed=speed,
aspect_y=aspect_y), overwrite=True)
# initialize
vector_tmp1 = 'vector_tmp1_' + str(os.getpid())
vector_tmp2 = 'vector_tmp2_' + str(os.getpid())
vector_tmp3 = 'vector_tmp3_' + str(os.getpid())
vector_region = 'vector_region_' + str(os.getpid())
TMP_VECT.extend([vector_tmp1, vector_tmp2, vector_tmp3, vector_region])
random_tmp = 'random_tmp_' + str(os.getpid())
TMP_RAST.extend([xshift_tmp, yshift_tmp, random_tmp])
gcore.run_command('v.in.region', output=vector_region, type='area')
loop = 0
vector_1 = particle_base + "{0:03d}".format(loop)
generate_points(name=vector_1, probability_map=probability, count=count)
grast.mapcalc(exp="{random} = int(rand(1, {maxt}))".format(random=random_tmp, maxt=age + 1))
gcore.run_command('v.what.rast', map=vector_1, raster=random_tmp, column='t')
write_vect_history('v.particles', options, flags, vector_1)
vector_names = [vector_1, ]
for time in range(0, total_time + step, step):
vector_1 = particle_base + "{0:03d}".format(loop)
vector_2 = particle_base + "{0:03d}".format(loop + 1)
vector_names.append(vector_2)
gcore.run_command('v.what.rast', map=vector_1, raster=xshift_tmp, column='xshift')
gcore.run_command('v.what.rast', map=vector_1, raster=yshift_tmp, column='yshift')
gcore.run_command('v.transform', layer=1, input=vector_1, output=vector_2,
columns='xshift:xshift,yshift:yshift', quiet=True)
# increase age
gcore.info("Increasing age...")
sql = 'UPDATE {table} SET t=t+1;'.format(table=vector_2)
gcore.run_command('db.execute', sql=sql)
# remove old points
gcore.info("Removing old points...")
gcore.run_command('v.select', overwrite=True, ainput=vector_2, atype='point',
binput=vector_region, btype='area', operator='within', output=vector_tmp1)
gcore.run_command('v.extract', input=vector_tmp1, layer=1, type='point',
where="t <= " + str(age) + " AND xshift IS NOT NULL", output=vector_tmp2, overwrite=True)
# generate new points
gcore.info("Generating new points...")
count_to_generate = count - gvect.vector_info(vector_tmp2)['points']
if count_to_generate > 0:
generate_points(name=vector_tmp3, probability_map=probability,
count=count_to_generate, overwrite=True)
gcore.info("Patchig new and old points...")
gcore.run_command('v.patch', flags='e', input=[vector_tmp2, vector_tmp3],
output=vector_2, overwrite=True)
sql = 'UPDATE {table} SET t={t} WHERE t IS NULL;'.format(table=vector_2, t=0)
gcore.run_command('db.execute', sql=sql)
write_vect_history('v.particles', options, flags, vector_2)
loop += 1
# Make sure the temporal database exists
tgis.init()
tgis.open_new_space_time_dataset(particle_base[:-1], type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=gcore.overwrite())
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particle_base[:-1], maps=','.join(vector_names),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
# create one vector map with multiple layers
fd, path = tempfile.mkstemp(text=True)
tmpfile = open(path, 'w')
k = 0
for vector in vector_names:
k += 1
layers = [x for x in range(k - comet_length + 1, k + 1) if x > 0]
categories = list(range(len(layers), 0, -1))
text = ''
for layer, cat in zip(layers, categories):
text += '{l} {c}\n'.format(l=layer, c=cat)
coords = gcore.read_command('v.to.db', flags='p', quiet=True, map=vector,
type='point', option='coor', separator=" ").strip()
for coord in coords.split('\n'):
coord = coord.split()
tmpfile.write('P 1 {n_cat}\n{x} {y}\n'.format(n_cat=len(categories), x=coord[1], y=coord[2]))
tmpfile.write(text)
tmpfile.close()
gcore.run_command('v.in.ascii', flags='n', overwrite=True, input=path, output=particles,
format='standard', separator=" ")
os.close(fd)
os.remove(path)
k = 0
sql = []
sizes = get_sizes(max_size, min_size, comet_length)
temporal_maps = []
for vector in vector_names:
k += 1
table = 't' + str(k)
gcore.run_command('v.db.addtable', map=particles, table=table, layer=k,
column="width double precision")
temporal_maps.append(particles + ':' + str(k))
for i in range(comet_length):
sql.append("UPDATE {table} SET width={w:.1f} WHERE cat={c}".format(table=table,
w=sizes[i][1], c=sizes[i][0]))
gcore.write_command('db.execute', input='-', stdin=';\n'.join(sql))
tgis.open_new_space_time_dataset(particles, type='stvds',
temporaltype='relative',
title="title", descr='desc',
semantic='mean', dbif=None,
overwrite=True)
# TODO: we must start from 1 because there is a bug in register_maps_in_space_time_dataset
tgis.register_maps_in_space_time_dataset(
type='vect', name=particles, maps=','.join(temporal_maps),
start=str(1), end=None, unit='seconds', increment=step,
interval=False, dbif=None)
write_vect_history('v.particles', options, flags, particles)
def setUpClass(cls):
gcore.use_temp_region()
gcore.run_command("g.region", raster="elevation")
def main():
options, flags = gcore.parser()
location = options["location"]
mapset = options["mapset"]
dbase = options["dbase"]
resolution = options["resolution"]
if resolution:
resolution = float(resolution)
method = options["method"]
curr_region = flags["r"]
transform_z = flags["z"]
overwrite = flags["o"]
if not curr_region:
gcore.use_temp_region()
atexit.register(gcore.del_temp_region)
if overwrite or gcore.overwrite():
overwrite = True
else:
overwrite = False
#
# r.proj
#
parameters = dict(location=location,
mapset=mapset,
flags="l",
overwrite=overwrite)
if dbase:
parameters.update(dict(dbase=dbase))
# first run r.proj to see if it works
try:
gcore.run_command("r.proj", quiet=True, **parameters)
except CalledModuleError:
gcore.fatal(
_("Module r.proj failed. Please check the error messages above."))
# run again to get the raster maps
rasters = gcore.read_command("r.proj", **parameters)
rasters = rasters.strip().split()
gcore.info(
_("{num} raster maps will be reprojected from mapset <{mapsetS}> "
"to mapset <{mapsetT}>.").format(num=len(rasters),
mapsetS=mapset,
mapsetT=gcore.gisenv()["MAPSET"]))
parameters = dict(location=location,
mapset=mapset,
method=method,
overwrite=overwrite)
if resolution:
parameters.update(dict(resolution=resolution))
if dbase:
parameters.update(dict(dbase=dbase))
for raster in rasters:
if not curr_region:
bounds = gcore.read_command("r.proj",
input=raster,
flags="g",
**parameters)
bounds = parse_key_val(bounds, vsep=" ")
gcore.run_command("g.region", **bounds)
gcore.run_command("r.proj", input=raster, **parameters)
#
# v.proj
#
parameters = dict(location=location,
mapset=mapset,
flags="l",
overwrite=overwrite)
if dbase:
parameters.update(dict(dbase=dbase))
# first run v.proj to see if it works
try:
gcore.run_command("v.proj", quiet=True, **parameters)
except CalledModuleError:
gcore.fatal(
_("Module v.proj failed. Please check the error messages above."))
# run again to get the vector maps
vectors = gcore.read_command("v.proj", **parameters)
vectors = vectors.strip().split()
gcore.info(
_("{num} vectors maps will be reprojected from mapset <{mapsetS}> "
"to mapset <{mapsetT}>.").format(num=len(vectors),
mapsetS=mapset,
mapsetT=gcore.gisenv()["MAPSET"]))
parameters = dict(location=location, mapset=mapset, overwrite=overwrite)
if transform_z:
parameters.update(dict(flags="z"))
for vector in vectors:
gcore.run_command("v.proj", input=vector, **parameters)
def main():
options, flags = gcore.parser()
# it does not check if pngs and other files exists,
# maybe it could check the any/all file(s) dir
if options['raster'] and options['strds']:
gcore.fatal(_("Options raster and strds cannot be specified together."
" Please decide for one of them."))
if options['raster'] and options['where']:
gcore.fatal(_("Option where cannot be combined with the option raster."
" Please don't set where option or use strds option"
" instead of raster option."))
if options['raster']:
if ',' in options['raster']:
maps = options['raster'].split(',') # TODO: skip empty parts
else:
maps = [options['raster']]
elif options['strds']:
# import and init only when needed
# init is called anyway when the generated form is used
import grass.temporal as tgis
strds = options['strds']
where = options['where']
# make sure the temporal database exists
tgis.init()
# create the space time raster object
ds = tgis.open_old_space_time_dataset(strds, 'strds')
# check if the dataset is in the temporal database
if not ds.is_in_db():
gcore.fatal(_("Space time dataset <%s> not found") % strds)
# we need a database interface
dbiface = tgis.SQLDatabaseInterfaceConnection()
dbiface.connect()
# the query
rows = ds.get_registered_maps(columns='id', where=where, order='start_time')
if not rows:
gcore.fatal(_("Cannot get any maps for spatio-temporal raster"
" dataset <%s>."
" Dataset is empty or you temporal WHERE"
" condition filtered all maps out."
" Please, specify another dataset,"
" put maps into this dataset"
" or correct your WHERE condition.") % strds)
maps = [row['id'] for row in rows]
else:
gcore.fatal(_("Either raster or strds option must be specified."
" Please specify one of them."))
# get the number of maps for later use
num_maps = len(maps)
out_dir = options['output']
if not os.path.exists(out_dir):
# TODO: maybe we could create the last dir on specified path?
gcore.fatal(_("Output path <%s> does not exists."
" You need to create the (empty) output directory"
" yourself before running this module.") % out_dir)
epsg = int(options['epsg'])
if ',' in options['opacity']:
opacities = [float(opacity)
for opacity in options['opacity'].split(',')]
if len(opacities) != num_maps:
gcore.fatal(_("Number of opacities <{no}> does not match number"
" of maps <{nm}>.").format(no=len(opacities),
nm=num_maps))
else:
opacities = [float(options['opacity'])] * num_maps
if ',' in options['info']:
infos = options['info'].split(',')
else:
infos = [options['info']]
# r.out.png options
compression = int(options['compression'])
# flag w is passed to r.out.png.proj
# our flag n is inversion of r.out.png.proj's t flag
# (transparent NULLs are better for overlay)
# we always need the l flag (ll .wgs84 file)
routpng_flags = ''
if not flags['n']:
routpng_flags += 't'
if flags['w']:
routpng_flags += 'w'
# r.out.png.proj l flag for LL .wgs84 file is now function parameter
# and is specified bellow
if flags['m']:
use_region = False
# we will use map extent
gcore.use_temp_region()
else:
use_region = True
# hard coded file names
data_file_name = 'data_file.csv'
js_data_file_name = 'data_file.js'
data_file = open(os.path.join(out_dir, data_file_name), 'w')
js_data_file = open(os.path.join(out_dir, js_data_file_name), 'w')
js_data_file.write('/* This file was generated by r.out.leaflet GRASS GIS'
' module. */\n\n')
js_data_file.write('var layerInfos = [\n')
for i, map_name in enumerate(maps):
if not use_region:
if gcore.run_command('g.region', rast=map_name):
raise RuntimeError("Cannot set region from map <%s>."
% map_name)
if '@' in map_name:
pure_map_name = map_name.split('@')[0]
else:
pure_map_name = map_name
# TODO: mixing current and map's mapset at this point
if '@' in map_name:
map_name, src_mapset_name = map_name.split('@')
else:
# TODO: maybe mapset is mandatory for those out of current mapset?
src_mapset_name = gcore.gisenv()['MAPSET']
image_file_name = pure_map_name + '.png'
image_file_path = os.path.join(out_dir, image_file_name)
# TODO: skip writing to file and extract the information from
# function, or use object if function is so large
wgs84_file = image_file_path + '.wgs84'
export_png_in_projection(map_name=map_name,
src_mapset_name=src_mapset_name,
output_file=image_file_path,
epsg_code=epsg,
compression=compression,
routpng_flags=routpng_flags,
wgs84_file=wgs84_file,
use_region=True)
data_file.write(pure_map_name + ',' + image_file_name + '\n')
# it doesn't matter in which location we are, it just uses the current
# location, not tested for LL loc, assuming that to be nop.
map_extent = get_map_extent_for_file(wgs84_file)
bounds = map_extent_to_js_leaflet_list(map_extent)
extra_attributes = []
generate_infos(map_name=map_name,
projected_png_file=image_file_path,
required_infos=infos,
output_directory=out_dir,
attributes=extra_attributes)
# http://www.w3schools.com/js/js_objects.asp
js_data_file.write(""" {{title: "{title}", file: "{file_}","""
""" bounds: {bounds}, opacity: {opacity}"""
.format(title=pure_map_name,
file_=image_file_name,
bounds=bounds,
opacity=opacities[i]))
if extra_attributes:
extra_js_attributes = [pair[0] + ': "' +
escape_quotes(
escape_endlines(
escape_backslashes(
pair[1]
)))
+ '"'
for pair in extra_attributes]
js_data_file.write(', ' + ', '.join(extra_js_attributes))
js_data_file.write("""}\n""")
# do not write after the last item
if i < num_maps - 1:
js_data_file.write(',')
js_data_file.write('];\n')
data_file.close()
def setUpClass(cls):
gcore.use_temp_region()
gcore.run_command('g.region', rast='elevation')
def main():
size = int(options['size'])
gamma = scale = None
if options['gamma']:
gamma = float(options['gamma'])
if options['scaling_factor']:
scale = float(options['scaling_factor'])
input_dev = options['input']
output = options['output']
method = options['method']
if method in ('gravity', 'kernel') and (gamma is None or scale is None):
gcore.fatal(
_("Methods gravity and kernel require options scaling_factor and gamma"
))
temp_map = 'tmp_futures_devPressure_' + str(os.getpid()) + '_copy'
temp_map_out = 'tmp_futures_devPressure_' + str(os.getpid()) + '_out'
temp_map_nulls = 'tmp_futures_devPressure_' + str(os.getpid()) + '_nulls'
global TMP, TMPFILE
if flags['n']:
gcore.message(_("Preparing data..."))
region = gcore.region()
gcore.use_temp_region()
gcore.run_command('g.region',
n=region['n'] + size * region['nsres'],
s=region['s'] - size * region['nsres'],
e=region['e'] + size * region['ewres'],
w=region['w'] - size * region['ewres'])
TMP.append(temp_map)
TMP.append(temp_map_nulls)
TMP.append(temp_map_out)
exp = "{temp_map_nulls} = if(isnull({inp}), 1, null())".format(
temp_map_nulls=temp_map_nulls, inp=input_dev)
grast.mapcalc(exp=exp)
grast.mapcalc(exp="{temp} = if(isnull({inp}), 0, {inp})".format(
temp=temp_map, inp=input_dev))
rmfilter_inp = temp_map
rmfilter_out = temp_map_out
else:
rmfilter_inp = input_dev
rmfilter_out = output
matrix = distance_matrix(size)
if method == 'occurrence':
matrix[matrix > 0] = 1
elif method == 'gravity':
with np.errstate(divide='ignore'):
denom = np.power(matrix, gamma)
matrix = scale / denom
matrix[denom == 0] = 0
else:
matrix_ = scale * np.exp(-2 * matrix / gamma)
matrix = np.where(matrix > 0, matrix_, 0)
path = gcore.tempfile()
global TMPFILE
TMPFILE = path
with open(path, 'w') as f:
f.write(write_filter(matrix))
gcore.message(_("Running development pressure filter..."))
gcore.run_command('r.mfilter',
input=rmfilter_inp,
output=rmfilter_out,
filter=path)
if flags['n']:
gcore.run_command(
'g.region',
n=region['n'],
s=region['s'],
e=region['e'],
w=region['w'],
)
grast.mapcalc(
exp="{out} = if(isnull({temp_null}), {rmfilter_out}, null())".
format(temp_null=temp_map_nulls,
rmfilter_out=rmfilter_out,
out=output))
gcore.del_temp_region()
grast.raster_history(output)
