def kernel_density(pnt_feat, popField, radius, template, outRst):
"""
Kernel density estimation. If any point is currently
in selection only selected points are taken into account.
"""
import os
from gasp.gt.torst import saga_to_tif
from gasp.gt.prop.rst import rst_ext, get_cellsize
from gasp.pyt.oss import fprop
left, right, bottom, top = rst_ext(template)
cellsize = get_cellsize(template)
SAGA_RASTER = os.path.join(os.path.dirname(outRst),
'saga_{}.sgrd'.format(fprop(outRst, 'fn')))
cmd = ("saga_cmd grid_gridding 6 -POINTS {} -POPULATION {} "
"-RADIUS {} -TARGET_DEFINITION 0 -TARGET_USER_SIZE {} "
"-TARGET_USER_XMIN {} -TARGET_USER_XMAX {} "
"-TARGET_USER_YMIN {} -TARGET_USER_YMAX {} "
"-TARGET_OUT_GRID {}").format(pnt_feat, popField, str(radius),
str(abs(cellsize)), str(left),
str(right), str(bottom), str(top),
SAGA_RASTER)
outcmd = exec_cmd(cmd)
# Convert to tiff
saga_to_tif(SAGA_RASTER, outRst)
return outRst
def get_ext(inFile, outEpsg=None):
"""
Get Extent of any GIS Data
return None if inFile is not a GIS File
"""
from gasp.gt.prop.ff import check_isRaster, check_isShp
if check_isRaster(inFile):
from gasp.gt.prop.rst import rst_ext
extent = rst_ext(inFile)
else:
if check_isShp(inFile):
from gasp.gt.prop.feat import get_ext as gext
extent = gext(inFile)
else:
return None
if outEpsg:
from gasp.gt.prop.prj import get_epsg
fileEpsg = get_epsg(inFile)
if not fileEpsg:
raise ValueError('cannot get EPSG of input file')
if fileEpsg != outEpsg:
from gasp.g.to import new_pnt
from gasp.g.prj import prj_ogrgeom
bt_left = prj_ogrgeom(new_pnt(extent[0], extent[2]), fileEpsg,
outEpsg)
top_right = prj_ogrgeom(new_pnt(extent[1], extent[3]), fileEpsg,
outEpsg)
left, bottom = bt_left.GetX(), bt_left.GetY()
right, top = top_right.GetX(), top_right.GetY()
extent = [left, right, bottom, top]
return extent
def rstext_to_shp(inRst, outShp, epsg=None):
"""
Raster Extent to Feature Class
"""
from gasp.gt.prop.rst import rst_ext
# Get Raster Extent
left, right, bottom, top = rst_ext(inRst)
# Get EPSG
if not epsg:
from gasp.gt.prop.prj import get_rst_epsg
epsg = get_rst_epsg(inRst)
# Create Boundary
return coords_to_boundshp((left, top), (right, bottom), epsg, outShp)
def adjust_ext_to_snap(outExt, snapRst):
"""
Adjust extent for a output raster to snap with other raster
"""
from gasp.gt.prop.ff import check_isShp, check_isRaster
from gasp.gt.prop.rst import rst_ext, get_cellsize
from gasp.g.to import new_pnt, create_polygon
# Check if outExt is a raster or not
isRst = check_isRaster(outExt)
if isRst:
shpAExt = rst_ext(outExt)
else:
isShp = check_isShp(outExt)
if isShp:
from gasp.gt.prop.feat import get_ext
shpAExt = get_ext(outExt)
else:
raise ValueError((
"outExt value should be a path to a SHP or to a Raster file"
))
# Check if snapRst is a raster
isRst = check_isRaster(snapRst)
if not isRst:
raise ValueError((
"snapRst should be a path to a raster file"
))
# Get snapRst Extent
snapRstExt = rst_ext(snapRst)
# Get cellsize
csize = get_cellsize(snapRst)
# Find extent point of outExt inside the two extents
# This will be used as pseudo origin
snapRstPnt = [
new_pnt(snapRstExt[0], snapRstExt[3]),
new_pnt(snapRstExt[1], snapRstExt[3]),
new_pnt(snapRstExt[1], snapRstExt[2]),
new_pnt(snapRstExt[0], snapRstExt[2]),
new_pnt(snapRstExt[0], snapRstExt[3]),
]
poly_snap_rst = create_polygon(snapRstPnt)
outExtPnt = {
'top_left' : new_pnt(shpAExt[0], shpAExt[3]),
'top_right' : new_pnt(shpAExt[1], shpAExt[3]),
'bottom_right' : new_pnt(shpAExt[1], shpAExt[2]),
'bottom_left' : new_pnt(shpAExt[0], shpAExt[2])
}
out_rst_pseudo = {}
for pnt in outExtPnt:
out_rst_pseudo[pnt] = outExtPnt[pnt].Intersects(poly_snap_rst)
pseudoOrigin = outExtPnt['top_left'] if out_rst_pseudo['top_left'] else \
outExtPnt['bottom_left'] if out_rst_pseudo['bottom_left'] else \
outExtPnt['top_right'] if out_rst_pseudo['top_right'] else \
outExtPnt['bottom_right'] if out_rst_pseudo['bottom_right'] else None
if not pseudoOrigin:
raise ValueError((
'Extents doesn\'t have overlapping areas'
))
pseudoOriginName = 'top_left' if out_rst_pseudo['top_left'] else \
'bottom_left' if out_rst_pseudo['bottom_left'] else \
'top_right' if out_rst_pseudo['top_right'] else \
'bottom_right' if out_rst_pseudo['bottom_right'] else None
# Get out Raster Shape
n_col = int((shpAExt[1] - shpAExt[0]) / csize)
n_row = int((shpAExt[3] - shpAExt[2]) / csize)
# Get Output Raster real origin/top left
yName, xName = pseudoOriginName.split('_')
if xName == 'left':
# Obtain left of output Raster
left_out_rst = snapRstExt[0] + (
csize * int((shpAExt[0] - snapRstExt[0]) / csize))
else:
# obtain right of output Raster
right_out_rst = snapRstExt[1] - (
csize * int((snapRstExt[1] - shpAExt[1]) / csize))
# Use right to obtain left coordinate
left_out_rst = right_out_rst - (n_col * csize)
if yName == 'top':
# Obtain top of output Raster
top_out_rst = snapRstExt[3] - (
csize * int((snapRstExt[3] - shpAExt[3]) / csize))
else:
# obtain bottom of output raster
bot_out_rst = snapRstExt[2] + (
csize * int((shpAExt[2] - snapRstExt[2]) / csize))
# use bottom to find the top of the output raster
top_out_rst = bot_out_rst + (n_row * csize)
return left_out_rst, top_out_rst, n_row, n_col, csize
def download_by_boundary(input_boundary, folder_out, osm_name, epsg,
GetUrl=True, db_name=None, geomCol=None,
justOneFeature=None):
"""
Download data from OSM using a bounding box
"""
import os
from osgeo import ogr
from gasp.to.web import get_file
from gasp.pyt.oss import os_name
OS_NAME = os_name()
EXTENTS = []
if db_name and geomCol:
"""
Assuming input_boundary is a PostgreSQL Table
"""
from gasp.pyt import obj_to_lst
from gasp.gql.prop import tbl_ext
for t in obj_to_lst(input_boundary):
EXTENTS.append(tbl_ext(db_name, t, geomCol))
else:
if type(input_boundary) == dict:
if 'top' in input_boundary and 'bottom' in input_boundary \
and 'left' in input_boundary and 'right' in input_boundary:
EXTENTS.append([
input_boundary['left'],input_boundary['right'],
input_boundary['bottom'], input_boundary['top']
])
else:
raise ValueError((
'input_boundary is a dict but the keys are not correct. '
'Please use left, right, top and bottom as keys'
))
elif type(input_boundary) == list:
if len(input_boundary) == 4:
EXTENTS.append(input_boundary)
else:
raise ValueError((
'input boundary is a list with more than 4 objects. '
'The list should be like: '
'l = [left, right, bottom, top]'
))
elif type(input_boundary) == ogr.Geometry:
EXTENTS.append(input_boundary.GetEnvelope())
else:
# Assuming input boundary is a file
#Check if file exists
if not os.path.exists(input_boundary):
raise ValueError((
"Sorry, but the file {} does not exist inside the folder {}!"
).format(
os.path.basename(input_boundary),
os.path.dirname(input_boundary)
))
# Check if is a raster
from gasp.gt.prop.ff import check_isRaster
isRst = check_isRaster(input_boundary)
# Get EPSG
if not epsg:
from gasp.gt.prop.prj import get_epsg
epsg = get_epsg(input_boundary)
if isRst:
from gasp.gt.prop.rst import rst_ext
# Get raster extent
EXTENTS.append(rst_ext(input_boundary))
else:
from gasp.gt.prop.ff import drv_name
# Todo: check if it is shape
# Open Dataset
inSrc = ogr.GetDriverByName(drv_name(
input_boundary)).Open(input_boundary)
lyr = inSrc.GetLayer()
i = 1
for feat in lyr:
geom = feat.GetGeometryRef()
featext = geom.GetEnvelope()
EXTENTS.append(featext)
if justOneFeature:
break
if epsg != 4326:
from gasp.g.to import new_pnt
from gasp.g.prj import prj_ogrgeom
for i in range(len(EXTENTS)):
bottom_left = prj_ogrgeom(new_pnt(
EXTENTS[i][0], EXTENTS[i][2]), epsg, 4326)
top_right = prj_ogrgeom(new_pnt(
EXTENTS[i][1], EXTENTS[i][3]), epsg, 4326)
left , bottom = bottom_left.GetX(), bottom_left.GetY()
right, top = top_right.GetX() , top_right.GetY()
EXTENTS[i] = [left, right, bottom, top]
#url = "https://overpass-api.de/api/map?bbox={}"
url = "https://lz4.overpass-api.de/api/interpreter?bbox={}"
RESULTS = []
for e in range(len(EXTENTS)):
bbox_str = ','.join([str(p) for p in EXTENTS[e]])
if GetUrl:
RESULTS.append(url.format(bbox_str))
continue
if len(EXTENTS) == 1:
outOsm = os.path.join(folder_out, osm_name + '.xml')
else:
outOsm = os.path.join(folder_out, "{}_{}.xml".format(osm_name, str(e)))
osm_file = get_file(
url.format(bbox_str), outOsm,
useWget=None if OS_NAME == 'Windows' else None
)
RESULTS.append(osm_file)
return RESULTS[0] if len(RESULTS) == 1 else RESULTS