def feat_to_pnt(inShp, outPnt, epsg=None):
"""
Get Centroid from each line in a PolyLine Feature Class
"""
import os
from osgeo import ogr
from gasp.gt.prop.ff import drv_name
from gasp.g.lyr.fld import copy_flds
from gasp.gt.prop.feat import lst_fld
# TODO: check if geometry is correct
# Open data
polyData = ogr.GetDriverByName(drv_name(outPnt)).Open(inShp)
polyLyr = polyData.GetLayer()
# Get SRS for the output
if not epsg:
from gasp.gt.prop.prj import get_shp_sref
srs = get_shp_sref(polyLyr)
else:
from gasp.gt.prop.prj import get_sref_from_epsg
srs = get_sref_from_epsg(epsg)
# Create output
pntData = ogr.GetDriverByName(drv_name(outPnt)).CreateDataSource(outPnt)
pntLyr = pntData.CreateLayer(os.path.splitext(os.path.basename(outPnt))[0],
srs,
geom_type=ogr.wkbPoint)
# Copy fields from input to output
fields = lst_fld(polyLyr)
copy_flds(polyLyr, pntLyr)
pntLyrDefn = pntLyr.GetLayerDefn()
for feat in polyLyr:
geom = feat.GetGeometryRef()
pnt = geom.Centroid()
new_feat = ogr.Feature(pntLyrDefn)
new_feat.SetGeometry(pnt)
for fld in fields:
new_feat.SetField(fld, feat.GetField(fld))
pntLyr.CreateFeature(new_feat)
new_feat.Destroy()
del pntLyr
del polyLyr
pntData.Destroy()
polyData.Destroy()
return outPnt
def sel_by_loc(shp, boundary_filter, filtered_output):
"""
Filter a shp using the location of a boundary_filter shp
For now the boundary must have only one feature
Writes the filter on a new shp
"""
import os
from osgeo import ogr
from gasp.gt.prop.ff import drv_name
from gasp.gt.prop.feat import get_gtype
from gasp.g.lyr.fld import copy_flds
from gasp.gt.toshp import copy_feat
from gasp.pyt.oss import fprop
# Open main data
dtSrc = ogr.GetDriverByName(drv_name(shp)).Open(shp, 0)
lyr = dtSrc.GetLayer()
# Get filter geom
filter_shp = ogr.GetDriverByName(drv_name(boundary_filter)).Open(
boundary_filter, 0)
filter_lyr = filter_shp.GetLayer()
c = 0
for f in filter_lyr:
if c:
break
geom = f.GetGeometryRef()
c += 1
filter_shp.Destroy()
# Apply filter
lyr.SetSpatialFilter(geom)
# Copy filter objects to a new shape
out = ogr.GetDriverByName(
drv_name(filtered_output)).CreateDataSource(filtered_output)
outLyr = out.CreateLayer(fprop(filtered_output, 'fn'),
geom_type=get_gtype(shp,
gisApi='ogr',
name=None,
py_cls=True))
# Copy fields
copy_flds(lyr, outLyr)
copy_feat(lyr,
outLyr,
outDefn=outLyr.GetLayerDefn(),
only_geom=False,
gisApi='ogrlyr')
def proj(inShp, outShp, outEPSG, inEPSG=None,
gisApi='ogr', sql=None, db_name=None):
"""
Project Geodata using GIS
API's Available:
* ogr;
* ogr2ogr;
* pandas;
* ogr2ogr_SQLITE;
* psql;
"""
import os
if gisApi == 'ogr':
"""
Using ogr Python API
"""
if not inEPSG:
raise ValueError(
'To use ogr API, you should specify the EPSG Code of the'
' input data using inEPSG parameter'
)
from osgeo import ogr
from gasp.g.lyr.fld import copy_flds
from gasp.gt.prop.feat import get_gtype
from gasp.gt.prop.ff import drv_name
from gasp.gt.prop.prj import get_sref_from_epsg, get_trans_param
from gasp.pyt.oss import fprop
def copyShp(out, outDefn, lyr_in, trans):
for f in lyr_in:
g = f.GetGeometryRef()
g.Transform(trans)
new = ogr.Feature(outDefn)
new.SetGeometry(g)
for i in range(0, outDefn.GetFieldCount()):
new.SetField(outDefn.GetFieldDefn(i).GetNameRef(), f.GetField(i))
out.CreateFeature(new)
new.Destroy()
f.Destroy()
# ####### #
# Project #
# ####### #
transP = get_trans_param(inEPSG, outEPSG)
inData = ogr.GetDriverByName(
drv_name(inShp)).Open(inShp, 0)
inLyr = inData.GetLayer()
out = ogr.GetDriverByName(
drv_name(outShp)).CreateDataSource(outShp)
outlyr = out.CreateLayer(
fprop(outShp, 'fn'), get_sref_from_epsg(outEPSG),
geom_type=get_gtype(
inShp, name=None, py_cls=True, gisApi='ogr'
)
)
# Copy fields to the output
copy_flds(inLyr, outlyr)
# Copy/transform features from the input to the output
outlyrDefn = outlyr.GetLayerDefn()
copyShp(outlyr, outlyrDefn, inLyr, transP)
inData.Destroy()
out.Destroy()
elif gisApi == 'ogr2ogr':
"""
Transform SRS of any OGR Compilant Data. Save the transformed data
in a new file
"""
if not inEPSG:
from gasp.gt.prop.prj import get_epsg_shp
inEPSG = get_epsg_shp(inShp)
if not inEPSG:
raise ValueError('To use ogr2ogr, you must specify inEPSG')
from gasp import exec_cmd
from gasp.gt.prop.ff import drv_name
cmd = (
'ogr2ogr -f "{}" {} {}{} -s_srs EPSG:{} -t_srs EPSG:{}'
).format(
drv_name(outShp), outShp, inShp,
'' if not sql else ' -dialect sqlite -sql "{}"'.format(sql),
str(inEPSG), str(outEPSG)
)
outcmd = exec_cmd(cmd)
elif gisApi == 'ogr2ogr_SQLITE':
"""
Transform SRS of a SQLITE DB table. Save the transformed data in a
new table
"""
from gasp import exec_cmd
if not inEPSG:
raise ValueError((
'With ogr2ogr_SQLITE, the definition of inEPSG is '
'demandatory.'
))
# TODO: Verify if database is sqlite
db, tbl = inShp['DB'], inShp['TABLE']
sql = 'SELECT * FROM {}'.format(tbl) if not sql else sql
outcmd = exec_cmd((
'ogr2ogr -update -append -f "SQLite" {db} -nln "{nt}" '
'-dialect sqlite -sql "{_sql}" -s_srs EPSG:{inepsg} '
'-t_srs EPSG:{outepsg} {db}'
).format(
db=db, nt=outShp, _sql=sql, inepsg=str(inEPSG),
outepsg=str(outEPSG)
))
elif gisApi == 'pandas':
# Test if input Shp is GeoDataframe
from gasp.gt.fmshp import shp_to_obj
from gasp.gt.toshp import df_to_shp
df = shp_to_obj(inShp)
# Project df
newDf = df.to_crs({'init' : 'epsg:{}'.format(str(outEPSG))})
# Save as file
return df_to_shp(df, outShp)
elif gisApi == 'psql':
from gasp.sql.db import create_db
from gasp.pyt.oss import fprop
from gasp.gql.to import shp_to_psql
from gasp.gt.toshp.db import dbtbl_to_shp
from gasp.gql.prj import sql_proj
# Create Database
if not db_name:
db_name = create_db(fprop(
outShp, 'fn', forceLower=True), api='psql'
)
else:
from gasp.sql.i import db_exists
isDb = db_exists(db_name)
if not isDb:
create_db(db_name, api='psql')
# Import Data
inTbl = shp_to_psql(db_name, inShp, api='shp2pgsql', encoding="LATIN1")
# Transform
oTbl = sql_proj(
db_name, inTbl, fprop(outShp, 'fn', forceLower=True),
outEPSG, geomCol='geom', newGeom='geom'
)
# Export
outShp = dbtbl_to_shp(
db_name, oTbl, 'geom', outShp, api='psql', epsg=outEPSG
)
else:
raise ValueError('Sorry, API {} is not available'.format(gisApi))
return outShp
def eachfeat_to_newshp(inShp, outFolder, epsg=None, idCol=None):
"""
Export each feature in inShp to a new/single File
"""
import os; from osgeo import ogr
from gasp.gt.prop.ff import drv_name
from gasp.gt.prop.feat import get_gtype, lst_fld
from gasp.g.lyr.fld import copy_flds
from gasp.pyt.oss import fprop
inDt = ogr.GetDriverByName(
drv_name(inShp)).Open(inShp)
lyr = inDt.GetLayer()
# Get SRS for the output
if not epsg:
from gasp.gt.prop.prj import get_shp_sref
srs = get_shp_sref(lyr)
else:
from gasp.gt.prop.prj import get_sref_from_epsg
srs = get_sref_from_epsg(epsg)
# Get fields name
fields = lst_fld(lyr)
# Get Geometry type
geomCls = get_gtype(inShp, gisApi='ogr', name=None, py_cls=True)
# Read features and create a new file for each feature
RESULT_SHP = []
for feat in lyr:
# Create output
ff = fprop(inShp, ['fn', 'ff'])
newShp = os.path.join(outFolder, "{}_{}{}".format(
ff['filename'],
str(feat.GetFID()) if not idCol else str(feat.GetField(idCol)),
ff['fileformat']
))
newData = ogr.GetDriverByName(
drv_name(newShp)).CreateDataSource(newShp)
newLyr = newData.CreateLayer(
fprop(newShp, 'fn'), srs, geom_type=geomCls
)
# Copy fields from input to output
copy_flds(lyr, newLyr)
newLyrDefn = newLyr.GetLayerDefn()
# Create new feature
newFeat = ogr.Feature(newLyrDefn)
# Copy geometry
geom = feat.GetGeometryRef()
newFeat.SetGeometry(geom)
# Set fields attributes
for fld in fields:
newFeat.SetField(fld, feat.GetField(fld))
# Save feature
newLyr.CreateFeature(newFeat)
newFeat.Destroy()
del newLyr
newData.Destroy()
RESULT_SHP.append(newShp)
return RESULT_SHP
def polyline_to_points(inShp, outShp, attr=None, epsg=None):
"""
Polyline vertex to Points
TODO: See if works with Polygons
"""
import os
from osgeo import ogr
from gasp.gt.prop.ff import drv_name
from gasp.g.lyr.fld import copy_flds
# Open Input
polyData = ogr.GetDriverByName(drv_name(inShp)).Open(inShp)
polyLyr = polyData.GetLayer()
# Get SRS for the output
if not epsg:
from gasp.gt.prop.prj import get_shp_sref
srs = get_shp_sref(polyLyr)
else:
from gasp.gt.prop.prj import get_sref_from_epsg
srs = get_sref_from_epsg(epsg)
# Create Output
pntData = ogr.GetDriverByName(drv_name(outShp)).CreateDataSource(outShp)
pntLyr = pntData.CreateLayer(os.path.splitext(os.path.basename(outShp))[0],
srs,
geom_type=ogr.wkbPoint)
# Copy fields from input to output
if attr:
if attr == 'ALL':
attr = None
else:
attr = [attr] if type(attr) != list else attr
copy_flds(polyLyr, pntLyr, __filter=attr)
# Polyline Vertex to Point Feature Class
pntLyrDefn = pntLyr.GetLayerDefn()
for feat in polyLyr:
geom = feat.GetGeometryRef()
# Get point count
nrPnt = geom.GetPointCount()
# Add point to a new feature
for p in range(nrPnt):
x, y, z = geom.GetPoint(p)
new_point = ogr.Geometry(ogr.wkbPoint)
new_point.AddPoint(x, y)
new_feature = ogr.Feature(pntLyrDefn)
new_feature.SetGeometry(new_point)
if attr:
for at in attr:
new_feature.SetField(at, feat.GetField(at))
pntLyr.CreateFeature(new_feature)
new_feature.Destroy()
del pntLyr
del polyLyr
pntData.Destroy()
polyData.Destroy()
return outShp
def connect_points_to_near_line(inPnt,
nearLines,
outLines,
tollerance=1000,
nearLinesWpnt=None):
"""
Connect all points to the nearest line in the perpendicular
"""
import os
import numpy as np
from osgeo import ogr
from shapely.geometry import LineString, Point
from gasp.gt.prop.ff import drv_name
from gasp.gt.prop.feat import get_gtype
from gasp.pyt.oss import fprop
# Check Geometries
inPntGeom = get_gtype(inPnt, gisApi='ogr')
nearLinesGeom = get_gtype(nearLines, gisApi='ogr')
if inPntGeom != 'POINT' or \
nearLinesGeom != 'LINESTRING':
raise ValueError('This method supports only LINESTRINGS')
# Open inLines
shpPnt = ogr.GetDriverByName(drv_name(inPnt)).Open(inPnt)
# Get Layer
lyrPnt = shpPnt.GetLayer()
# Open near
shpNear = ogr.GetDriverByName(drv_name(nearLines)).Open(nearLines)
# Create Output
outSrc = ogr.GetDriverByName(drv_name(outLines)).CreateDataSource(outLines)
outLyr = outSrc.CreateLayer(os.path.splitext(
os.path.basename(outLines))[0],
geom_type=ogr.wkbLineString)
if nearLinesWpnt:
newPointsInLines = {}
lineDefn = outLyr.GetLayerDefn()
# For each point in 'inLines', find the near point on the
# the 'nearLines' layer
for feat in lyrPnt:
FID = feat.GetFID()
# Get Geometry
pnt = feat.GetGeometryRef()
x, y = pnt.GetX(), pnt.GetY()
# Get point buffer
bufPnt = draw_buffer(pnt, tollerance)
# Apply a spatial filter based on the buffer
# to restrict the nearLines Layer
lyrNear = shpNear.GetLayer()
lyrNear.SetSpatialFilter(bufPnt)
# For line in the filtered 'nearLyr'
# Find point in the perpendicular
dist = 0
for __feat in lyrNear:
__FID = __feat.GetFID()
__geom = __feat.GetGeometryRef()
points = __geom.GetPointCount()
for _p in range(points - 1):
# Get line segment
x1, y1, z1 = __geom.GetPoint(_p)
x2, y2, z2 = __geom.GetPoint(_p + 1)
# Create Shapely Geometries
lnh = LineString([(x1, y1), (x2, y2)])
pnt = Point(x, y)
# Get distance between point and line
# Get near point of the line
d = pnt.distance(lnh)
npnt = lnh.interpolate(lnh.project(pnt))
if not dist:
dist = [d, npnt.x, npnt.y]
LINE_FID = __FID
else:
if d < dist[0]:
dist = [d, npnt.x, npnt.y]
LINE_FID = __FID
# Write a new line
line = ogr.Geometry(ogr.wkbLineString)
line.AddPoint(x, y)
line.AddPoint(dist[1], dist[2])
new_feature = ogr.Feature(lineDefn)
new_feature.SetGeometry(line)
outLyr.CreateFeature(new_feature)
new_feature.Destroy()
if nearLinesWpnt:
if LINE_FID not in newPointsInLines:
newPointsInLines[LINE_FID] = [Point(dist[1], dist[2])]
else:
newPointsInLines[LINE_FID].append(Point(dist[1], dist[2]))
del lyrNear
outSrc.Destroy()
shpPnt.Destroy()
shpNear.Destroy()
if nearLinesWpnt:
from gasp.g.lyr.fld import copy_flds
from shapely.ops import split as lnhSplit
shpNear = ogr.GetDriverByName(drv_name(nearLines)).Open(nearLines)
updateLines = ogr.GetDriverByName(
drv_name(nearLinesWpnt)).CreateDataSource(nearLinesWpnt)
upLnhLyr = updateLines.CreateLayer(fprop(nearLinesWpnt, 'fn'),
geom_type=ogr.wkbLineString)
# Create shpNear Layer Again
lyrNear = shpNear.GetLayer()
# Copy fields
copy_flds(lyrNear, upLnhLyr)
# Out lyr definition
upDefn = upLnhLyr.GetLayerDefn()
for feat in lyrNear:
LINE_FID = feat.GetFID()
geom = feat.GetGeometryRef()
new_feature = ogr.Feature(upDefn)
if LINE_FID not in newPointsInLines:
# Copy line to updateLines layer
new_feature.SetGeometry(geom)
else:
# Copy to Shapely Line String
points = geom.GetPointCount()
lstPnt = []
for _p in range(points):
x1, y1, z1 = geom.GetPoint(_p)
lstPnt.append((x1, y1))
shplyLnh = LineString(lstPnt)
# For new point:
# Line split and reconstruction
for pnt in newPointsInLines[LINE_FID]:
try:
splitted = lnhSplit(shplyLnh, pnt)
except:
shpTstL = ogr.GetDriverByName(
"ESRI Shapefile").CreateDataSource(
r'D:\gis\xyz\lnht.shp')
shpL = shpTstL.CreateLayer('lnht',
geom_type=ogr.wkbLineString)
shpTstP = ogr.GetDriverByName(
"ESRI Shapefile").CreateDataSource(
r'D:\gis\xyz\pntt.shp')
shpP = shpTstL.CreateLayer('pntt',
geom_type=ogr.wkbPoint)
defnL = shpL.GetLayerDefn()
defnP = shpP.GetLayerDefn()
featL = ogr.Feature(defnL)
featP = ogr.Feature(defnP)
geomL = ogr.Geometry(ogr.wkbLineString)
for i in list(shplyLnh.coords):
geomL.AddPoint(i[0], i[1])
geomP = ogr.Geometry(ogr.wkbPoint)
geomP.AddPoint(
list(pnt.coords)[0][0],
list(pnt.coords)[0][1])
featL.SetGeometry(geomL)
featP.SetGeometry(geomP)
shpL.CreateFeature(featL)
shpP.CreateFeature(featP)
shpTstL.Destroy()
shpTstP.Destroy()
return pnt, shplyLnh
c = 0
for l in splitted:
if not c:
newLnh = list(l.coords)
else:
newlnh += list(l.coords)[1:]
c += 1
shplyLnh = LineString(newLnh)
# Finally copy line to updateLines Layer
gLine = ogr.Geometry(ogr.wkbLineString)
for __pnt in list(shplyLnh.coords):
gLine.AddPoint(__pnt[0], __pnt[1])
for i in range(0, upDefn.GetFieldCount()):
new_feature.SetField(
upDefn.GetFieldDefn(i).GetNameRef(), feat.GetField(i))
upLnhLyr.CreateFeature(new_feature)
new_feature.Destroy()
shpNear.Destroy()
return outLines