def _kappa_pixel(maps1, maps2, out, method, over):
from grass.pygrass.raster.buffer import Buffer
import sklearn
rasterout = RasterRow(out, overwrite=over)
rasterout.open('w','DCELL')
array1 = maps1.values()[0]
for row in range(len(array1)):
newrow = Buffer((len(array1[row]),), mtype='DCELL')
for col in range(len(array1[row])):
vals1 = np.ndarray(len(maps1.values()))
vals2 = np.ndarray(len(maps2.values()))
x = 0
for value in maps1.values():
vals1[x] = value[row][col]
x += 1
x = 0
for value in maps2.values():
vals2[x] = value[row][col]
x += 1
if sklearn.__version__ >= '0.18':
outval = sklearn.metrics.cohen_kappa_score(vals1, vals2,
weights=method)
else:
outval = sklearn.metrics.cohen_kappa_score(vals1, vals2)
newrow[col] = outval
rasterout.put_row(newrow)
rasterout.close()
return
def segment2map(self):
"""Transform the segment file to a map.
"""
row_buffer = Buffer((self._cols), self.mtype)
for row in range(self._rows):
row_buffer = self.segment.get_row(row, row_buffer)
libraster.Rast_put_row(self._fd, row_buffer.p, self._gtype)
def get_row(self, row, row_buffer=None):
"""This method returns the row using:
* the read mode and
* `rowcache` method
:param row: the number of row to obtain
:type row: int
:param row_buffer: Specify the Buffer object that will be instantiate
:type row_buffer: Buffer object
>>> elev = RasterRowIO(test_raster_name)
>>> elev.open('r')
>>> for row in elev:
... row
Buffer([11, 21, 31, 41], dtype=int32)
Buffer([12, 22, 32, 42], dtype=int32)
Buffer([13, 23, 33, 43], dtype=int32)
Buffer([14, 24, 34, 44], dtype=int32)
>>> elev.close()
"""
if row_buffer is None:
row_buffer = Buffer((self._cols, ), self.mtype)
rowio_buf = librowio.Rowio_get(ctypes.byref(self.rowio.c_rowio), row)
ctypes.memmove(row_buffer.p, rowio_buf, self.rowio.row_size)
return row_buffer
def map2segment(self):
"""Transform an existing map to segment file.
"""
row_buffer = Buffer((self._cols), self.mtype)
for row in range(self._rows):
libraster.Rast_get_row(self._fd, row_buffer.p, row, self._gtype)
self.segment.put_row(row, row_buffer)
def filter(method, names, winsize, order, prefix, itercount, fit_up):
current_mapset = grass.read_command('g.mapset', flags='p')
current_mapset = current_mapset.strip()
inputs = init_rasters(names)
output_names = [prefix + name for name in names]
outputs = init_rasters(output_names, mapset=current_mapset)
try:
open_rasters(outputs, write=True)
open_rasters(inputs)
reg = Region()
for i in range(reg.rows):
# import ipdb; ipdb.set_trace()
row_data = np.array([_get_row_or_nan(r, i) for r in inputs])
filtered_rows = _filter(method, row_data, winsize, order,
itercount, fit_up)
for map_num in range(len(outputs)):
map = outputs[map_num]
row = filtered_rows[map_num, :]
buf = Buffer(row.shape, map.mtype, row)
map.put_row(i, buf)
finally:
close_rasters(outputs)
close_rasters(inputs)
def get_row(self, row, row_buffer=None):
"""Return the row using the `segment.get_row` method
:param row: specify the row number
:type row: int
:param row_buffer: specify the Buffer object that will be instantiate
:type row_buffer: Buffer object
>>> elev = RasterRowIO(test_raster_name)
>>> elev.open('r')
>>> for row in elev:
... row
Buffer([11, 21, 31, 41], dtype=int32)
Buffer([12, 22, 32, 42], dtype=int32)
Buffer([13, 23, 33, 43], dtype=int32)
Buffer([14, 24, 34, 44], dtype=int32)
>>> elev.close()
>>> with RasterSegment(test_raster_name) as elev:
... for row in elev:
... row
Buffer([11, 21, 31, 41], dtype=int32)
Buffer([12, 22, 32, 42], dtype=int32)
Buffer([13, 23, 33, 43], dtype=int32)
Buffer([14, 24, 34, 44], dtype=int32)
"""
if row_buffer is None:
row_buffer = Buffer((self._cols), self.mtype)
return self.segment.get_row(row, row_buffer)
def random_map(mapname, mtype, overwrite=True, factor=100):
region = Region()
random_map = RasterRow(mapname)
random_map.open('w', mtype, overwrite)
for _ in range(region.rows):
row_buf = Buffer((region.cols, ), mtype,
buffer=(np.random.random(region.cols,) * factor).data)
random_map.put_row(row_buf)
random_map.close()
return random_map
def numpy2raster(array, mtype, name):
"""Save a numpy array to a raster map"""
reg = Region()
if (reg.rows, reg.cols) != array.shape:
msg = "Region and array are different: %r != %r"
raise TypeError(msg % ((reg.rows, reg.cols), array.shape))
with RasterRow(name, mode="w", mtype=mtype) as new:
newrow = Buffer((array.shape[1],), mtype=mtype)
for row in array:
newrow[:] = row[:]
new.put_row(newrow)
def get_row(self, row, row_buffer=None):
"""Return the row using the `segment.get_row` method
:param row: specify the row number
:type row: int
:param row_buffer: specify the Buffer object that will be instantiate
:type row_buffer: Buffer object
"""
if row_buffer is None:
row_buffer = Buffer((self._cols), self.mtype)
return self.segment.get_row(row, row_buffer)
def _predict_multi(self, estimator, region, indexes, class_labels, height,
func, output, overwrite):
# create and open rasters for writing if incremental reading
if height is not None:
dst = []
for i, label in enumerate(class_labels):
rastername = output + "_" + str(label)
dst.append(RasterRow(rastername))
dst[i].open("w", mtype="FCELL", overwrite=overwrite)
# create data reader generator
n_windows = len([i for i in self.row_windows(height=height)])
data_gen = (
(wi, self.read(rows=rows))
for wi, rows in enumerate(self.row_windows(height=height)))
# perform prediction
try:
if height is not None:
for wi, arr in data_gen:
gs.percent(wi, n_windows, 1)
result = func(arr, estimator)
result = np.ma.filled(result, np.nan)
# write multiple features to GRASS GIS rasters
for i, arr_index in enumerate(indexes):
for row in range(result.shape[1]):
newrow = Buffer((region.cols, ), mtype="FCELL")
newrow[:] = result[arr_index, row, :]
dst[i].put_row(newrow)
else:
arr = self.read()
result = func(arr, estimator)
result = np.ma.filled(result, np.nan)
for i, arr_index in enumerate(indexes):
numpy2raster(
result[arr_index, :, :],
mtype="FCELL",
rastname=rastername[i],
overwrite=overwrite,
)
except:
gs.fatal("Error in raster prediction")
finally:
if height is not None:
for i in dst:
i.close()
return RasterStack([i.name for i in dst])
def _write(self, name, overwrite):
"""Write the numpy array into map
"""
if not self.exist() or self.mode != 'r':
self.flush()
buff = Buffer(self[0].shape, mtype=self.mtype)
with RasterRow(name,
self.mapset,
mode='w',
mtype=self.mtype,
overwrite=overwrite) as rst:
for i in range(len(rst)):
buff[:] = self[i][:]
rst.put_row(buff[:])
self.name = name
def get_row(self, row, row_buffer=None):
"""This method returns the row using:
* the read mode and
* `rowcache` method
:param row: the number of row to obtain
:type row: int
:param row_buffer: Specify the Buffer object that will be instantiate
:type row_buffer: Buffer object
"""
if row_buffer is None:
row_buffer = Buffer((self._cols, ), self.mtype)
rowio_buf = librowio.Rowio_get(ctypes.byref(self.rowio.c_rowio), row)
ctypes.memmove(row_buffer.p, rowio_buf, self.rowio.row_size)
return row_buffer
def createRast(name, matrix, inverse=False):
"""Create the new raster map using the output matrix of calculateOblique"""
newscratch = RasterRow(name)
newscratch.open('w', overwrite=True)
try:
for r in matrix:
if inverse:
r.reverse()
newrow = Buffer((len(r), ), mtype='FCELL')
for c in range(len(r)):
newrow[c] = r[c]
newscratch.put_row(newrow)
newscratch.close()
return True
except:
return False
def numpy2raster(array, mtype, rastname, overwrite=False):
"""Save a numpy array to a raster map
:param obj array: a numpy array
:param obj mtype: the datatype of array
:param str rastername: the name of output map
:param bool overwrite: True to overwrite existing map
"""
reg = Region()
if (reg.rows, reg.cols) != array.shape:
msg = "Region and array are different: %r != %r"
raise TypeError(msg % ((reg.rows, reg.cols), array.shape))
with RasterRow(rastname, mode='w', mtype=mtype, overwrite=overwrite) as new:
newrow = Buffer((array.shape[1],), mtype=mtype)
for row in array:
newrow[:] = row[:]
new.put_row(newrow)
def get_row(self, row, row_buffer=None):
"""Private method that return the row using the read mode
call the `Rast_get_row` C function.
:param row: the number of row to obtain
:type row: int
:param row_buffer: Buffer object instance with the right dim and type
:type row_buffer: Buffer
>>> elev = RasterRow(test_raster_name)
>>> elev.open()
>>> elev[0]
Buffer([11, 21, 31, 41], dtype=int32)
>>> elev.get_row(0)
Buffer([11, 21, 31, 41], dtype=int32)
"""
if row_buffer is None:
row_buffer = Buffer((self._cols, ), self.mtype)
libraster.Rast_get_row(self._fd, row_buffer.p, row, self._gtype)
return row_buffer
def main():
options, flags = gscript.parser()
input = options['input']
output = options['output']
if (output is None or output == ""):
gscript.error(_("[h.in] ERROR: output is a mandatory parameter."))
exit()
# Load HexASCII raster into memory
hexASCII = HASC()
try:
hexASCII.loadFromFile(input)
except (ValueError, IOError) as ex:
gscript.error(
_("[h.in] ERROR: Failed to load raster %s: %s" % (input, ex)))
exit()
# Set region (note that it is tricking GRASS to think it is a squared raster)
gscript.run_command('g.region',
rows=hexASCII.nrows,
cols=hexASCII.ncols,
res=hexASCII.side)
# Create RasterRow object and iterate trough rows
newRast = raster.RasterRow(output)
newRast.open('w', 'FCELL')
for row in range(0, hexASCII.nrows):
newRow = Buffer(shape=(1, hexASCII.ncols)) #, dtype=float, order='F')
for col in range(0, hexASCII.ncols):
newRow[0, col] = hexASCII.get(col, row)
gscript.message(_("[h.in] DEBUG: Importing row: %s" % newRow))
newRast.put_row(newRow)
gscript.message(_("[h.in] DEBUG: Imported raster: %s" % (newRast)))
# Close RasterRow to force its creation
newRast.close()
gscript.message(_("[h.in] SUCCESS: HexASCII raster imported."))
def get_row(self, row, row_buffer=None):
"""Private method that return the row using the read mode
call the `Rast_get_row` C function.
:param row: the number of row to obtain
:type row: int
:param row_buffer: Buffer object instance with the right dim and type
:type row_buffer: Buffer
>>> elev = RasterRow('elevation')
>>> elev.open()
>>> elev[0] # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
Buffer([ 141.99613953, 141.27848816, 141.37904358, ..., 58.40825272,
58.30711365, 58.18310547], dtype=float32)
>>> elev.get_row(0) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
Buffer([ 141.99613953, 141.27848816, 141.37904358, ..., 58.40825272,
58.30711365, 58.18310547], dtype=float32)
"""
if row_buffer is None:
row_buffer = Buffer((self._cols, ), self.mtype)
libraster.Rast_get_row(self._fd, row_buffer.p, row, self._gtype)
return row_buffer
#!/usr/bin/env python3
import numpy
from grass.pygrass.raster import RasterRow
newscratch = RasterRow('newscratch')
newscratch.open('w', overwrite=True)
# get computational region info
from grass.pygrass.gis.region import Region
reg = Region()
# import buffer and create empty row
from grass.pygrass.raster.buffer import Buffer
newrow = Buffer((reg.cols,), mtype='CELL')
# we create a raster to fill all the GRASS GIS region
for r in range(reg.rows):
newrow[:] = numpy.random.random_integers(0, 1000, size=newrow.size)
newscratch.put_row(newrow)
newscratch.close()
def predict(self, estimator, output, height=None, overwrite=False):
"""Prediction method for RasterStack class
Parameters
----------
estimator : estimator object implementing 'fit'
The object to use to fit the data.
output : str
Output name for prediction raster.
height : int (opt).
Number of raster rows to pass to estimator at one time. If not
specified then the entire raster is read into memory.
overwrite : bool (opt). Default is False
Option to overwrite an existing raster.
Returns
-------
RasterStack
"""
reg = Region()
func = self._pred_fun
# determine dtype
test_window = list(self.row_windows(height=1))[0]
img = self.read(rows=test_window)
result = func(img, estimator)
try:
np.finfo(result.dtype)
mtype = "FCELL"
nodata = np.nan
except:
mtype = "CELL"
nodata = -2147483648
# determine whether multi-target
if result.shape[0] > 1:
n_outputs = result.shape[result.ndim - 1]
else:
n_outputs = 1
indexes = np.arange(0, n_outputs)
# chose prediction function
if len(indexes) == 1:
func = self._pred_fun
else:
func = self._predfun_multioutput
if len(indexes) > 1:
result_stack = self._predict_multi(estimator, reg, indexes,
indexes, height, func, output,
overwrite)
else:
if height is not None:
with RasterRow(output,
mode="w",
mtype=mtype,
overwrite=overwrite) as dst:
n_windows = len(
[i for i in self.row_windows(height=height)])
data_gen = ((wi, self.read(rows=rows))
for wi, rows in enumerate(
self.row_windows(height=height)))
for wi, arr in data_gen:
gs.percent(wi, n_windows, 1)
result = func(arr, estimator)
result = np.ma.filled(result, nodata)
# writing data to GRASS raster row-by-row
for i in range(result.shape[1]):
newrow = Buffer((reg.cols, ), mtype=mtype)
newrow[:] = result[0, i, :]
dst.put_row(newrow)
else:
arr = self.read()
result = func(arr, estimator)
result = np.ma.filled(result, nodata)
numpy2raster(result[0, :, :],
mtype=mtype,
rastname=output,
overwrite=overwrite)
result_stack = RasterStack(output)
return result_stack
def main():
# Get the options
inputs = options["inputs"]
output = options["output"]
basename = options["basename"]
where = options["where"]
pyfile = options["pyfile"]
nrows = int(options["nrows"])
input_name_list = inputs.split(",")
input_strds: List[StrdsEntry] = []
# Import the python code into the current function context
code = open(pyfile, "r").read()
projection_kv = gcore.parse_command("g.proj", flags="g")
epsg_code = projection_kv["epsg"]
tgis.init()
mapset = gcore.gisenv()["MAPSET"]
dbif = tgis.SQLDatabaseInterfaceConnection()
dbif.connect()
region = Region()
num_input_maps = 0
open_output_maps = []
for input_name in input_name_list:
sp = tgis.open_old_stds(input_name, "strds", dbif)
map_list = sp.get_registered_maps_as_objects(where=where,
order="start_time",
dbif=dbif)
if not map_list:
dbif.close()
gcore.fatal(_("Space time raster dataset <%s> is empty") % input)
if nrows == 0:
dbif.close()
gcore.fatal(_("Number of rows for the udf must be greater 0."))
num_input_maps = len(map_list)
input_strds.append(
StrdsEntry(dbif=dbif, strds=sp, map_list=map_list, region=region))
for strds in input_strds:
if len(strds.map_list) != num_input_maps:
dbif.close()
gcore.fatal(
_("The number of maps in the input STRDS must be equal"))
# Setup the input strds to compute the output maps and the resulting strds
mtype = None
for strds in input_strds:
strds.setup()
mtype = strds.mtype
num_output_maps = count_resulting_maps(input_strds=input_strds,
code=code,
epsg_code=epsg_code)
if num_output_maps == 1:
output_map = RasterRow(name=basename)
output_map.open(mode="w", mtype=mtype, overwrite=gcore.overwrite())
open_output_maps.append(output_map)
elif num_output_maps > 1:
for index in range(num_output_maps):
output_map = RasterRow(name=basename + f"_{index}", mapset=mapset)
output_map.open(mode="w", mtype=mtype, overwrite=gcore.overwrite())
open_output_maps.append(output_map)
else:
dbif.close()
gcore.fatal(_("No result generated") % input)
# Workaround because time reduction will remove the timestamp
result_start_times = [datetime.now()]
first = False
# Read several rows for each map of each input strds and load them into the udf
for index in range(0, region.rows, nrows):
if index + nrows > region.rows:
usable_rows = index + nrows - region.rows + 1
else:
usable_rows = nrows
# Read all input strds as cubes
datacubes = []
for strds in input_strds:
datacube = strds.to_datacube(index=index, usable_rows=usable_rows)
datacubes.append(datacube)
# Run the UDF code
data = run_udf(code=code, epsg_code=epsg_code, datacube_list=datacubes)
# Read only the first cube
datacubes = data.get_datacube_list()
first_cube_array: xarray.DataArray = datacubes[0].get_array()
if first is False:
if 't' in first_cube_array.coords:
result_start_times = first_cube_array.coords['t']
# Three dimensions
if first_cube_array.ndim == 3:
for count, slice in enumerate(first_cube_array):
output_map = open_output_maps[count]
# print(f"Write slice at index {index} \n{slice} for map {output_map.name}")
for row in slice:
# Write the result into the output raster map
b = Buffer(shape=(region.cols, ), mtype=mtype)
b[:] = row[:]
output_map.put_row(b)
# Two dimensions
elif first_cube_array.ndim == 2:
output_map = open_output_maps[0]
# print(f"Write slice at index {index} \n{slice} for map {output_map.name}")
for row in first_cube_array:
# Write the result into the output raster map
b = Buffer(shape=(region.cols, ), mtype=mtype)
b[:] = row[:]
output_map.put_row(b)
first = True
# Create new STRDS
new_sp = open_new_stds(
name=output,
type="strds",
temporaltype=input_strds[0].strds.get_temporal_type(),
title="new STRDS",
descr="New STRDS from UDF",
semantic="UDF",
overwrite=gcore.overwrite(),
dbif=dbif)
maps_to_register = []
for count, output_map in enumerate(open_output_maps):
output_map.close()
print(output_map.fullname())
rd = RasterDataset(output_map.fullname())
if input_strds[0].strds.is_time_absolute():
if hasattr(result_start_times, "data"):
d = pandas.to_datetime(result_start_times.data[count])
else:
d = result_start_times[count]
rd.set_absolute_time(start_time=d)
elif input_strds[0].strds.is_time_relative():
if hasattr(result_start_times, "data"):
d = result_start_times.data[count]
else:
d = result_start_times[count]
rd.set_relative_time(start_time=d, end_time=None, unit="seconds")
rd.load()
if rd.is_in_db(dbif=dbif):
rd.update(dbif=dbif)
else:
rd.insert(dbif=dbif)
maps_to_register.append(rd)
rd.print_info()
register_map_object_list(type="raster",
map_list=maps_to_register,
output_stds=new_sp,
dbif=dbif)
dbif.close()
