def run_slope(tid, inrsts, outfolder, oname, percentage):
"""
Thread function
"""
iirsts = inrsts.mdt.tolist()
# Create GRASS GIS Location
loc_name = f'thread_{str(tid)}'
gbase = run_grass(
outfolder, location=loc_name, srs=iirsts[0]
)
# Start GRASS GIS Session
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, outfolder, loc_name, 'PERMANENT')
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.surf import slope
from glass.g.wenv.grs import rst_to_region
for rst in iirsts:
# Import data
mdt = rst_to_grs(rst, fprop(rst, 'fn'))
# Set region
rst_to_region(mdt)
# Get ID in name
mdt_id = re.search(r'\d+', mdt).group()
# Get slope
if percentage:
slope_perc = slope(
mdt, f"pp_{oname}_{mdt_id}",
data='percent'
)
slope_degr = slope(
mdt, f"{oname}_{mdt_id}", data='degrees'
)
# Export
if percentage:
grs_to_rst(slope_perc, os.path.join(
percentage, slope_degr + '.tif'
))
grs_to_rst(slope_degr, os.path.join(
outfolder, slope_degr + '.tif'
))
def run_viewshed_by_cpu(tid, obs, dem, output,
vis_basename='vis', maxdst=None, obselevation=None):
# Create GRASS GIS location
loc_name = 'loc_' + str(tid)
gbase = run_grass(output, location=loc_name, srs=dem)
# Start GRASS GIS Session
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, output, loc_name, 'PERMANENT')
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.surf import grs_viewshed
# Send DEM to GRASS GIS
grs_dem = rst_to_grs(dem, 'grs_dem', as_cmd=True)
# Produce Viewshed for each point in obs
for idx, row in obs.iterrows():
vrst = grs_viewshed(
grs_dem, (row.geometry.x, row.geometry.y),
'{}_{}'.format(vis_basename, str(row[obs_id])),
max_dist=maxdst, obs_elv=obselevation
)
frst = grs_to_rst(vrst, os.path.join(output, vrst + '.tif'))
def grscliprst(in_rst, clip_ext, outrst):
"""
Clip Raster using GRASS GIS
"""
import os
from glass.pys.oss import fprop
from glass.g.wenv.grs import run_grass
from glass.g.wenv.grs import rst_to_region
from glass.g.prop.prj import get_epsg
# Get EPSG From Raster
EPSG = get_epsg(in_rst)
if not EPSG:
raise ValueError(
'Cannot get EPSG code of Extent Template File ({})'.format(in_rst))
workspace = os.path.dirname(outrst)
loc = 'loc_' + fprop(outrst, 'fn')
# Create GRASS GIS Session
gbase = run_grass(workspace, location=loc, srs=EPSG)
import grass.script.setup as gsetup
gsetup.init(gbase, workspace, loc, 'PERMANENT')
# GRASS GIS modules
from glass.g.it.rst import rst_to_grs, grs_to_rst, grs_to_mask
# Add data to GRASS GIS
rst = rst_to_grs(in_rst, fprop(in_rst, 'fn'), as_cmd=True)
clip = rst_to_grs(clip_ext, fprop(clip_ext, 'fn'), as_cmd=True)
# Set New region
rst_to_region(clip)
# Set Mask
grs_to_mask(clip)
# Export result
return grs_to_rst(rst, outrst)
def shp_to_rst(shp,
inSource,
cellsize,
nodata,
outRaster,
epsg=None,
rst_template=None,
snapRst=None,
api='gdal'):
"""
Feature Class to Raster
cellsize will be ignored if rst_template is defined
* API's Available:
- gdal;
- pygrass;
- grass;
"""
if api == 'gdal':
from osgeo import gdal, ogr
from glass.g.prop import drv_name
if not epsg:
from glass.g.prop.prj import get_shp_sref
srs = get_shp_sref(shp).ExportToWkt()
else:
from glass.g.prop.prj import epsg_to_wkt
srs = epsg_to_wkt(epsg)
# Get Extent
dtShp = ogr.GetDriverByName(drv_name(shp)).Open(shp, 0)
lyr = dtShp.GetLayer()
if not rst_template:
if not snapRst:
x_min, x_max, y_min, y_max = lyr.GetExtent()
x_res = int((x_max - x_min) / cellsize)
y_res = int((y_max - y_min) / cellsize)
else:
from glass.g.prop.rst import adjust_ext_to_snap
x_min, y_max, y_res, x_res, cellsize = adjust_ext_to_snap(
shp, snapRst)
else:
from glass.g.rd.rst import rst_to_array
img_temp = gdal.Open(rst_template)
geo_transform = img_temp.GetGeoTransform()
y_res, x_res = rst_to_array(rst_template).shape
# Create output
dtRst = gdal.GetDriverByName(drv_name(outRaster)).Create(
outRaster, x_res, y_res, gdal.GDT_Byte)
if not rst_template:
dtRst.SetGeoTransform((x_min, cellsize, 0, y_max, 0, -cellsize))
else:
dtRst.SetGeoTransform(geo_transform)
dtRst.SetProjection(str(srs))
bnd = dtRst.GetRasterBand(1)
bnd.SetNoDataValue(nodata)
gdal.RasterizeLayer(dtRst, [1], lyr, burn_values=[1])
del lyr
dtShp.Destroy()
elif api == 'grass' or api == 'pygrass':
"""
Use GRASS GIS
- Start Session
- Import data
- Convert
- Export
"""
import os
from glass.pys.oss import fprop
from glass.g.wenv.grs import run_grass
from glass.g.prop.prj import get_epsg
# Create GRASS GIS Session
ws = os.path.dirname(outRaster)
loc = fprop(outRaster, 'fn')
epsg = get_epsg(shp)
gbase = run_grass(ws, location=loc, srs=epsg)
import grass.script.setup as gsetup
gsetup.init(gbase, ws, loc, 'PERMANENT')
# Import Packages
from glass.g.it.shp import shp_to_grs
from glass.g.it.rst import grs_to_rst
from glass.g.wenv.grs import shp_to_region
# Shape to GRASS GIS
gshp = shp_to_grs(shp, fprop(shp, 'fn'), asCMD=True)
# Set Region
shp_to_region(gshp, cellsize)
# Convert
grst = grsshp_to_grsrst(gshp, inSource, gshp + '__rst', api="grass")
# Export
grs_to_rst(grst, outRaster, as_cmd=True)
else:
raise ValueError('API {} is not available'.format(api))
return outRaster
def raster_based(osmdata, nomenclature, refRaster, lulcRst,
overwrite=None, dataStore=None, roadsAPI='POSTGIS'):
"""
Convert OSM Data into Land Use/Land Cover Information
An raster based approach.
TODO: Add detailed description
"""
# ************************************************************************ #
# Python Modules from Reference Packages #
# ************************************************************************ #
import datetime; import os; import pandas; import copy
# ************************************************************************ #
# glass dependencies #
# ************************************************************************ #
from glass.pys.oss import mkdir, fprop
from glass.g.prop import check_isRaster
from glass.g.prop.prj import get_rst_epsg
from glass.g.wenv.grs import run_grass
if roadsAPI == 'POSTGIS':
from glass.ng.sql.db import create_db
from glass.g.it.db import osm_to_psql
from glass.ete.osm2lulc.mod2 import roads_sqdb
from glass.ng.sql.bkup import dump_db
from glass.ng.sql.db import drop_db
else:
from glass.g.it.osm import osm_to_sqdb
from glass.ete.osm2lulc.mod2 import grs_rst_roads
from glass.ete.osm2lulc.utils import osm_project, add_lulc_to_osmfeat, osmlulc_rsttbl
from glass.ete.osm2lulc.utils import get_ref_raster
from glass.ete.osm2lulc.mod1 import grs_rst
from glass.ete.osm2lulc.m3_4 import rst_area
from glass.ete.osm2lulc.mod5 import basic_buffer
from glass.ete.osm2lulc.mod6 import rst_pnt_to_build
# ************************************************************************ #
# Global Settings #
# ************************************************************************ #
# Check if input parameters exists!
if not os.path.exists(os.path.dirname(lulcRst)):
raise ValueError('{} does not exist!'.format(os.path.dirname(lulcRst)))
if not os.path.exists(osmdata):
raise ValueError('File with OSM DATA ({}) does not exist!'.format(osmdata))
if not os.path.exists(refRaster):
raise ValueError('File with reference area ({}) does not exist!'.format(refRaster))
# Check if Nomenclature is valid
nomenclature = "URBAN_ATLAS" if nomenclature != "URBAN_ATLAS" and \
nomenclature != "CORINE_LAND_COVER" and \
nomenclature == "GLOBE_LAND_30" else nomenclature
time_a = datetime.datetime.now().replace(microsecond=0)
workspace = os.path.join(os.path.dirname(
lulcRst), 'osmtolulc') if not dataStore else dataStore
# Check if workspace exists
if os.path.exists(workspace):
if overwrite:
mkdir(workspace)
else:
raise ValueError('Path {} already exists'.format(workspace))
else:
mkdir(workspace)
# Get Ref Raster
refRaster, epsg = get_ref_raster(refRaster, workspace, cellsize=2)
from glass.ete.osm2lulc import PRIORITIES, osmTableData, LEGEND
__priorites = PRIORITIES[nomenclature]
__legend = LEGEND[nomenclature]
time_b = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# Convert OSM file to SQLITE DB or to POSTGIS DB #
# ************************************************************************ #
if roadsAPI == 'POSTGIS':
osm_db = create_db(fprop(
osmdata, 'fn', forceLower=True), overwrite=True)
osm_db = osm_to_psql(osmdata, osm_db)
else:
osm_db = osm_to_sqdb(osmdata, os.path.join(workspace, 'osm.sqlite'))
time_c = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# Add Lulc Classes to OSM_FEATURES by rule #
# ************************************************************************ #
add_lulc_to_osmfeat(osm_db, osmTableData, nomenclature, api=roadsAPI)
time_d = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# Transform SRS of OSM Data #
# ************************************************************************ #
osmTableData = osm_project(
osm_db, epsg, api=roadsAPI,
isGlobeLand=None if nomenclature != 'GLOBE_LAND_30' else True
)
time_e = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# Start a GRASS GIS Session #
# ************************************************************************ #
grass_base = run_grass(
workspace, grassBIN='grass78', location='grloc', srs=epsg)
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(grass_base, workspace, 'grloc', 'PERMANENT')
# ************************************************************************ #
# IMPORT SOME glass MODULES FOR GRASS GIS #
# ************************************************************************ #
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.mos import rsts_to_mosaic
from glass.g.wenv.grs import rst_to_region
# ************************************************************************ #
# SET GRASS GIS LOCATION EXTENT #
# ************************************************************************ #
extRst = rst_to_grs(refRaster, 'extent_raster')
rst_to_region(extRst)
time_f = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# MapResults #
mergeOut = {}
# ************************************************************************ #
# ************************************************************************ #
# 1 - Selection Rule #
# ************************************************************************ #
"""
selOut = {
cls_code : rst_name, ...
}
"""
selOut, timeCheck1 = grs_rst(osm_db, osmTableData['polygons'], api=roadsAPI)
for cls in selOut:
mergeOut[cls] = [selOut[cls]]
time_g = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# 2 - Get Information About Roads Location #
# ************************************************************************ #
"""
roads = {
cls_code : rst_name, ...
}
"""
if roadsAPI != 'POSTGIS':
roads, timeCheck2 = grs_rst_roads(
osm_db, osmTableData['lines'], osmTableData['polygons'],
workspace, 1221 if nomenclature != "GLOBE_LAND_30" else 801
)
else:
roadCls = 1221 if nomenclature != "GLOBE_LAND_30" else 801
roads, timeCheck2 = roads_sqdb(
osm_db, osmTableData['lines'], osmTableData['polygons'],
apidb='POSTGIS', asRst=roadCls
)
roads = {roadCls : roads}
for cls in roads:
if cls not in mergeOut:
mergeOut[cls] = [roads[cls]]
else:
mergeOut[cls].append(roads[cls])
time_h = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# 3 - Area Upper than #
# ************************************************************************ #
"""
auOut = {
cls_code : rst_name, ...
}
"""
if nomenclature != 'GLOBE_LAND_30':
auOut, timeCheck3 = rst_area(
osm_db, osmTableData['polygons'], UPPER=True, api=roadsAPI
)
for cls in auOut:
if cls not in mergeOut:
mergeOut[cls] = [auOut[cls]]
else:
mergeOut[cls].append(auOut[cls])
time_l = datetime.datetime.now().replace(microsecond=0)
else:
timeCheck3 = None
time_l = None
# ************************************************************************ #
# 4 - Area Lower than #
# ************************************************************************ #
"""
alOut = {
cls_code : rst_name, ...
}
"""
if nomenclature != 'GLOBE_LAND_30':
alOut, timeCheck4 = rst_area(
osm_db, osmTableData['polygons'], UPPER=None, api=roadsAPI
)
for cls in alOut:
if cls not in mergeOut:
mergeOut[cls] = [alOut[cls]]
else:
mergeOut[cls].append(alOut[cls])
time_j = datetime.datetime.now().replace(microsecond=0)
else:
timeCheck4 = None
time_j = None
# ************************************************************************ #
# 5 - Get data from lines table (railway | waterway) #
# ************************************************************************ #
"""
bfOut = {
cls_code : rst_name, ...
}
"""
bfOut, timeCheck5 = basic_buffer(
osm_db, osmTableData['lines'], workspace, apidb=roadsAPI
)
for cls in bfOut:
if cls not in mergeOut:
mergeOut[cls] = [bfOut[cls]]
else:
mergeOut[cls].append(bfOut[cls])
time_m = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# 7 - Assign untagged Buildings to tags #
# ************************************************************************ #
if nomenclature != "GLOBE_LAND_30":
buildsOut, timeCheck7 = rst_pnt_to_build(
osm_db, osmTableData['points'], osmTableData['polygons'],
api_db=roadsAPI
)
for cls in buildsOut:
if cls not in mergeOut:
mergeOut[cls] = buildsOut[cls]
else:
mergeOut[cls] += buildsOut[cls]
time_n = datetime.datetime.now().replace(microsecond=0)
else:
timeCheck7 = None
time_n = datetime.datetime.now().replace(microsecond=0)
# ************************************************************************ #
# Produce LULC Map #
# ************************************************************************ #
"""
Merge all results for one cls into one raster
mergeOut = {
cls_code : [rst_name, rst_name, ...], ...
}
into
mergeOut = {
cls_code : patched_raster, ...
}
"""
for cls in mergeOut:
if len(mergeOut[cls]) == 1:
mergeOut[cls] = mergeOut[cls][0]
else:
mergeOut[cls] = rsts_to_mosaic(
mergeOut[cls], 'mosaic_{}'.format(str(cls)), api="grass"
)
time_o = datetime.datetime.now().replace(microsecond=0)
"""
Merge all Class Raster using a priority rule
"""
__priorities = PRIORITIES[nomenclature]
lst_rst = []
for cls in __priorities:
if cls not in mergeOut:
continue
else:
lst_rst.append(mergeOut[cls])
outGrs = rsts_to_mosaic(lst_rst, os.path.splitext(
os.path.basename(lulcRst))[0], api="grass"
)
time_p = datetime.datetime.now().replace(microsecond=0)
# Ceck if lulc Rst has an valid format
outIsRst = check_isRaster(lulcRst)
if not outIsRst:
from glass.pys.oss import fprop
lulcRst = os.path.join(
os.path.dirname(lulcRst),
fprop(lulcRst, 'fn') + '.tif'
)
grs_to_rst(outGrs, lulcRst, as_cmd=True)
osmlulc_rsttbl(nomenclature, os.path.join(
os.path.dirname(lulcRst), os.path.basename(lulcRst) + '.vat.dbf'
))
time_q = datetime.datetime.now().replace(microsecond=0)
# Dump Database if PostGIS was used
# Drop Database if PostGIS was used
if roadsAPI == 'POSTGIS':
dump_db(osm_db, os.path.join(
workspace, osm_db + '.sql'
), api='psql')
drop_db(osm_db)
return lulcRst, {
0 : ('set_settings', time_b - time_a),
1 : ('osm_to_sqdb', time_c - time_b),
2 : ('cls_in_sqdb', time_d - time_c),
3 : ('proj_data', time_e - time_d),
4 : ('set_grass', time_f - time_e),
5 : ('rule_1', time_g - time_f, timeCheck1),
6 : ('rule_2', time_h - time_g, timeCheck2),
7 : None if not timeCheck3 else ('rule_3', time_l - time_h, timeCheck3),
8 : None if not timeCheck4 else ('rule_4', time_j - time_l, timeCheck4),
9 : ('rule_5', time_m - time_j if timeCheck4 else time_m - time_h, timeCheck5),
10 : None if not timeCheck7 else ('rule_7', time_n - time_m, timeCheck7),
11 : ('merge_rst', time_o - time_n),
12 : ('priority_rule', time_p - time_o),
13 : ('export_rst', time_q - time_p)
}
def match_cellsize_and_clip(rstBands, refRaster, outFolder,
clipShp=None):
"""
Resample images to make them with the same resolution and clip
Good to resample Sentinel bands with more than 10 meters.
Dependencies:
* GRASS GIS;
* GDAL/OGR.
"""
import os
from glass.g.prop.prj import get_rst_epsg
from glass.g.wenv.grs import run_grass
from glass.pys.oss import fprop, mkdir
# Check if outfolder exists
if not os.path.exists(outFolder):
mkdir(outFolder, overwrite=None)
# Get EPSG from refRaster
epsg = get_rst_epsg(refRaster, returnIsProj=None)
"""
Start GRASS GIS Session
"""
GRS_WORKSPACE = mkdir(os.path.join(outFolder, 'grswork'))
grsb = run_grass(
GRS_WORKSPACE, grassBIN='grass78', location='resample',
srs=epsg
)
import grass.script.setup as gsetup
gsetup.init(grsb, GRS_WORKSPACE, 'resample', 'PERMANENT')
"""
Import packages related with GRASS GIS
"""
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.wenv.grs import rst_to_region
from glass.g.it.shp import shp_to_grs
from glass.g.dp.torst import grsshp_to_grsrst as shp_to_rst
from glass.g.it.rst import grs_to_mask
# Send Ref Raster to GRASS GIS and set region
extRst = rst_to_grs(refRaster, 'ext_rst')
rst_to_region(extRst)
# Import all bands in rstBands
grs_bands = [rst_to_grs(i, fprop(i, 'fn')) for i in rstBands]
if clipShp:
# Add clipShp to GRASS
grs_clip = shp_to_grs(clipShp, fprop(clipShp, 'fn'), asCMD=True)
# SHP to Raster
rstClip = shp_to_rst(
grs_clip, 1, f'rst_{grs_clip}',
cmd=True
)
# Set region using
rst_to_region(rstClip)
# Set mask
grs_to_mask(rstClip)
# Export bands
return [grs_to_rst(
i, os.path.join(outFolder, i + '.tif')
) for i in grs_bands]
def make_dem(grass_workspace, data, field, output, extent_template,
method="IDW", cell_size=None, mask=None):
"""
Create Digital Elevation Model
Methods Available:
* IDW;
* BSPLINE;
* SPLINE;
* CONTOUR;
"""
from glass.pys.oss import fprop
from glass.g.wenv.grs import run_grass
from glass.g.prop.prj import get_epsg
LOC_NAME = fprop(data, 'fn', forceLower=True)[:5] + "_loc"
# Get EPSG From Raster
EPSG = get_epsg(extent_template)
if not EPSG:
raise ValueError(
'Cannot get EPSG code of Extent Template File ({})'.format(
extent_template
)
)
# Know if data geometry are points
if method == 'BSPLINE' or method == 'SPLINE':
from glass.g.prop.feat import get_gtype
data_gtype = get_gtype(data, gisApi='ogr')
# Create GRASS GIS Location
grass_base = run_grass(grass_workspace, location=LOC_NAME, srs=EPSG)
# Start GRASS GIS Session
import grass.script.setup as gsetup
gsetup.init(grass_base, grass_workspace, LOC_NAME, 'PERMANENT')
# Get Extent Raster
ref_template = ob_ref_rst(extent_template, os.path.join(
grass_workspace, LOC_NAME
), cellsize=cell_size)
# IMPORT GRASS GIS MODULES #
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.it.shp import shp_to_grs
from glass.g.wenv.grs import rst_to_region
# Configure region
rst_to_grs(ref_template, 'extent')
rst_to_region('extent')
# Convert elevation "data" to GRASS Vector
elv = shp_to_grs(data, 'elevation')
OUTPUT_NAME = fprop(output, 'fn', forceLower=True)
if method == "BSPLINE":
from glass.g.rst.itp import bspline
# Convert to points if necessary
if data_gtype != 'POINT' and data_gtype != 'MULTIPOINT':
from glass.g.dp.cg import feat_vertex_to_pnt
elev_pnt = feat_vertex_to_pnt(elv, "elev_pnt", nodes=None)
else:
elev_pnt = elv
outRst = bspline(elev_pnt, field, OUTPUT_NAME, mway='bicubic', lyrN=1, asCMD=True)
elif method == "SPLINE":
from glass.g.rst.itp import surfrst
# Convert to points if necessary
if data_gtype != 'POINT' and data_gtype != 'MULTIPOINT':
from glass.g.dp.cg import feat_vertex_to_pnt
elev_pnt = feat_vertex_to_pnt(elv, "elev_pnt", nodes=None)
else:
elev_pnt = elv
outRst = surfrst(elev_pnt, field, OUTPUT_NAME, lyrN=1, ascmd=True)
elif method == "CONTOUR":
from glass.g.dp.torst import grsshp_to_grsrst as shp_to_rst
from glass.g.rst.itp import surfcontour
# Apply mask if mask
if mask:
from glass.g.it.rst import grs_to_mask, rst_to_grs
rst_mask = rst_to_grs(mask, 'rst_mask', as_cmd=True)
grs_to_mask(rst_mask)
# Elevation (GRASS Vector) to Raster
elevRst = shp_to_rst(elv, field, 'rst_elevation')
# Run Interpolator
outRst = surfcontour(elevRst, OUTPUT_NAME, ascmd=True)
elif method == "IDW":
from glass.g.rst.itp import ridw
from glass.g.rst.alg import rstcalc
from glass.g.dp.torst import grsshp_to_grsrst as shp_to_rst
# Elevation (GRASS Vector) to Raster
elevRst = shp_to_rst(elv, field, 'rst_elevation')
# Multiply cells values by 100 000.0
rstcalc('int(rst_elevation * 100000)', 'rst_elev_int', api='pygrass')
# Run IDW to generate the new DEM
ridw('rst_elev_int', 'dem_int', numberPoints=15)
# DEM to Float
rstcalc('dem_int / 100000.0', OUTPUT_NAME, api='pygrass')
# Export DEM to a file outside GRASS Workspace
grs_to_rst(OUTPUT_NAME, output)
return output
def run_viewshed_by_cpu(tid, db, obs, dem, srs,
vis_basename='vis', maxdst=None, obselevation=None):
# Create Database
new_db = create_db("{}_{}".format(db, str(tid)), api='psql')
# Points to Database
pnt_tbl = df_to_db(
new_db, obs, 'pnt_tbl', api='psql',
epsg=srs, geomType='Point', colGeom='geometry')
# Create GRASS GIS Session
workspace = mkdir(os.path.join(
os.path.dirname(dem), 'work_{}'.format(str(tid))
))
loc_name = 'vis_loc'
gbase = run_grass(workspace, location=loc_name, srs=dem)
# Start GRASS GIS Session
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(gbase, workspace, loc_name, 'PERMANENT')
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.rst.surf import grs_viewshed
from glass.g.deldt import del_rst
# Send DEM to GRASS GIS
grs_dem = rst_to_grs(dem, 'grs_dem', as_cmd=True)
# Produce Viewshed for each point in obs
for idx, row in obs.iterrows():
# Get Viewshed raster
vrst = grs_viewshed(
grs_dem, (row.geometry.x, row.geometry.y),
'{}_{}'.format(vis_basename, str(row[obs_id])),
max_dist=maxdst, obs_elv=obselevation
)
# Export Raster to File
frst = grs_to_rst(vrst, os.path.join(workspace, vrst + '.tif'))
# Raster to Array
img = gdal.Open(frst)
num = img.ReadAsArray()
# Two Dimension to One Dimension
# Reshape Array
numone = num.reshape(num.shape[0] * num.shape[1])
# Get Indexes with visibility
visnum = np.arange(numone.shape[0]).astype(np.uint32)
visnum = visnum[numone == 1]
# Get Indexes intervals
visint = get_minmax_fm_seq_values(visnum)
# Get rows indexes
_visint = visint.reshape(visint.shape[0] * visint.shape[1])
visrow = _visint / num.shape[1]
visrow = visrow.astype(np.uint32)
# Get cols indexes
viscol = _visint - (visrow * num.shape[1])
# Reshape
visrow = visrow.reshape(visint.shape)
viscol = viscol.reshape(visint.shape)
# Split array
irow, erow = np.vsplit(visrow.T, 1)[0]
icol, ecol = np.vsplit(viscol.T, 1)[0]
# Visibility indexes to Pandas DataFrame
idxnum = np.full(irow.shape, row[obs_id])
visdf = pd.DataFrame({
'pntid' : idxnum, 'rowi' : irow, 'rowe' : erow,
'coli': icol, 'cole' : ecol
})
# Pandas DF to database
# Create Visibility table
df_to_db(
new_db, visdf, vis_basename,
api='psql', colGeom=None,
append=None if not idx else True
)
# Delete all variables
numone = None
visnum = None
visint = None
_visint = None
visrow = None
viscol = None
irow = None
erow = None
icol = None
ecol = None
idxnum = None
visdf = None
del img
# Delete GRASS GIS File
del_rst(vrst)
# Delete TIFF File
del_file(frst)
frst = None
def bnds_to_mosaic(bands, outdata, ref_raster, loc=None):
"""
Satellite image To mosaic
bands = {
'bnd_2' : [path_to_file, path_to_file],
'bnd_3' : [path_to_file, path_to_file],
'bnd_4' : [path_to_file, path_to_file],
}
"""
"""
Start GRASS GIS Session
"""
import os
from glass.pys.oss import fprop
from glass.g.prop.prj import get_rst_epsg
from glass.g.wenv.grs import run_grass
# Get EPSG from refRaster
epsg = get_rst_epsg(ref_raster, returnIsProj=None)
LOC = loc if loc else 'gr_loc'
grass_base = run_grass(outdata, grassBIN='grass78', location=LOC, srs=epsg)
import grass.script as grass
import grass.script.setup as gsetup
gsetup.init(grass_base, outdata, LOC, 'PERMANENT')
# ************************************************************************ #
# GRASS MODULES #
# ************************************************************************ #
from glass.g.it.rst import rst_to_grs, grs_to_rst
from glass.g.wenv.grs import rst_to_region
# ************************************************************************ #
# SET GRASS GIS LOCATION EXTENT #
# ************************************************************************ #
extRst = rst_to_grs(ref_raster, 'extent_raster')
rst_to_region(extRst)
# ************************************************************************ #
# SEND DATA TO GRASS GIS #
# ************************************************************************ #
grs_bnds = {}
for bnd in bands:
l = []
for b in bands[bnd]:
bb = rst_to_grs(b, fprop(b, 'fn'))
l.append(bb)
grs_bnds[bnd] = l
# ************************************************************************ #
# PATCH bands and export #
# ************************************************************************ #
for bnd in grs_bnds:
mosaic_band = rseries(grs_bnds[bnd], bnd, 'maximum')
grs_bnds[bnd] = grs_to_rst(mosaic_band,
os.path.join(outdata, mosaic_band + '.tif'),
as_cmd=True)
return grs_bnds