def _execute(self):
self._setup()
# Points and where statement are stored in self.request_data
strds_name = self.map_name
geojson = self.request_data
point_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
result_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
point_file.write(json_dumps(geojson).encode())
point_file.flush()
pc = dict()
pc["1"] = {
"module": "v.import",
"inputs": {
"input": point_file.name
},
"outputs": {
"output": {
"name": "input_points"
}
}
}
pc["2"] = {
"module": "t.rast.sample",
"inputs": {
"strds": "%s@%s" % (strds_name, self.mapset_name),
"points": "input_points"
},
"outputs": {
"output": {
"name": result_file.name
}
},
"flags": "rn",
"overwrite": True,
"verbose": True
}
self.request_data = pc
# Run the process chain
EphemeralProcessing._execute(self, skip_permission_check=True)
result = open(result_file.name, "r").readlines()
output_list = []
for line in result:
output_list.append(line.strip().split("|"))
self.module_results = output_list
point_file.close()
result_file.close()
def _execute(self):
self._setup()
where = None
# Points and where statement are stored in self.request_data
strds_name = self.map_name
points = self.request_data["points"]
if "where" in self.request_data:
where = self.request_data["where"]
if not points or len(points) == 0:
raise AsyncProcessError("Empty coordinate list")
point_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
result_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
for tuple in points:
if len(tuple) != 3:
raise AsyncProcessError("Wrong number of coordinate entries")
id, x, y = tuple
row = "%s|%s|%s\n" % (id, x, y)
point_file.write(row.encode())
point_file.flush()
pc = dict()
pc["1"] = {
"module": "v.in.ascii",
"inputs": {
"input": point_file.name,
"format": "point",
"column": "id text, x double precision, y double precision",
"x": 2,
"y": 3
},
"outputs": {
"output": {
"name": "input_points"
}
}
}
pc["2"] = {
"module": "t.rast.sample",
"inputs": {
"strds": "%s@%s" % (strds_name, self.mapset_name),
"points": "input_points",
"column": "id"
},
"outputs": {
"output": {
"name": result_file.name
}
},
"flags": "rn",
"overwrite": True,
"verbose": True
}
if where is not None:
pc["2"]["inputs"]["where"] = where
self.request_data = pc
# Run the process chain
EphemeralProcessing._execute(self, skip_permission_check=True)
result = open(result_file.name, "r").readlines()
output_list = []
for line in result:
output_list.append(line.strip().split("|"))
self.module_results = output_list
point_file.close()
result_file.close()
def __init__(self, *args):
EphemeralProcessing.__init__(self, *args)
self.response_model_class = STRDSSampleResponseModel
def __init__(self, *args):
EphemeralProcessing.__init__(self, *args)
self.response_model_class = RasterAreaStatsResponseModel
def _execute(self):
self._setup()
# Points are stored in self.request_data
raster_name = self.map_name
points = self.request_data["points"]
if not points or len(points) == 0:
raise AsyncProcessError("Empty coordinate list")
point_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
result_file = tempfile.NamedTemporaryFile(dir=self.temp_file_path,
delete=True)
for tuple in points:
if len(tuple) != 3:
raise AsyncProcessError("Wrong number of coordinate entries")
id, x, y = tuple
row = "%s|%s|%s\n" % (id, x, y)
point_file.write(row.encode())
point_file.flush()
pc = {
"list": [
{
"id":
"v_in_ascii",
"module":
"v.in.ascii",
"inputs": [
{
"param": "input",
"value": point_file.name
},
{
"param": "format",
"value": "point"
},
{
"param":
"column",
"value":
"id text, x double precision, y double precision",
},
{
"param": "x",
"value": "2"
},
{
"param": "y",
"value": "3"
},
],
"outputs": [{
"param": "output",
"value": "input_points"
}],
},
{
"id":
"g_region",
"module":
"g.region",
"inputs": [
{
"param": "vector",
"value": "input_points"
},
{
"param": "align",
"value": "%s@%s" % (raster_name, self.mapset_name),
},
],
"flags":
"p",
},
{
"id":
"r_what",
"module":
"r.what",
"inputs": [
{
"param": "map",
"value": "%s@%s" % (raster_name, self.mapset_name),
},
{
"param": "points",
"value": "input_points"
},
],
"outputs": [{
"param": "output",
"value": result_file.name
}],
"flags":
"nrf",
"overwrite":
True,
"superquiet":
True,
},
],
"version":
"1",
}
self.request_data = pc
# Run the process chain
EphemeralProcessing._execute(self, skip_permission_check=True)
result = open(result_file.name, "r").readlines()
output_list = []
raster_name_qualified = "%s@%s" % (raster_name, self.mapset_name)
# remove map name from columns
colum_name = [
col if raster_name_qualified not in col else col.replace(
f"{raster_name_qualified}_", "").replace(
raster_name_qualified, "value")
for col in result[0].strip().split("|")
]
for line, point in zip(result[1:], points):
entry = dict()
entry[point[0]] = {
key: value
for key, value in zip(colum_name,
line.strip().split("|"))
}
# remove site_name (always empty)
del entry[point[0]]["site_name"]
# add "map_name": raster_name
entry[point[0]]["map_name"] = raster_name
output_list.append(entry)
self.module_results = output_list
point_file.close()
result_file.close()
def __init__(self, *args):
EphemeralProcessing.__init__(self, *args)
self.response_model_class = RasterSamplingResponseModel
def _execute(self):
self._setup()
# Points are stored in self.request_data
vector_name = self.map_name
points = self.request_data["points"]
if not points or len(points) == 0:
raise AsyncProcessError("Empty coordinate list")
coordinates_string = ""
for tuple in points:
if len(tuple) != 3:
raise AsyncProcessError("Wrong number of coordinate entries")
id, x, y = tuple
coordinates_string += "%s,%s," % (x, y)
pc = {
"list": [
{
"id":
"g_region",
"module":
"g.region",
"inputs": [{
"param":
"vector",
"value":
"%s@%s" % (vector_name, self.mapset_name),
}],
"flags":
"p",
},
{
"id":
"v_what",
"module":
"v.what",
"inputs": [
{
"param": "map",
"value": "%s@%s" % (vector_name, self.mapset_name),
},
{
"param": "coordinates",
"value": coordinates_string[:-1]
},
],
"stdout": {
"id": "info",
"format": "list",
"delimiter": "|"
},
"flags":
"ag",
},
],
"version":
"1",
}
self.request_data = pc
# Run the process chain
EphemeralProcessing._execute(self, skip_permission_check=True)
count = -1
output_list = []
# Convert the result of v.what into actinia response format (list of points
# with point ID, coordinate pair and vector map attributes)
for entry in self.module_results["info"]:
if "=" in entry:
key, val = entry.split("=")
if key == "East":
count += 1
if "point" in locals():
output_list.append(point)
point = {points[count][0]: {key: val}}
else:
point[points[count][0]][key] = val
output_list.append(point)
self.module_results = output_list