def leesUitXML(self, xml):
self.polygonAttr = None
point = None
try:
xmlGeometrie = xml.find('./' +
tagVolledigeNS(self._tag, xml.nsmap))
if xmlGeometrie is not None:
gmlNode = xmlGeometrie.find(
'./' + tagVolledigeNS("gml:Point", xml.nsmap))
if gmlNode is not None:
gmlStr = etree.tostring(gmlNode)
self._geometrie = ogr.CreateGeometryFromGML(str(gmlStr))
else:
# Forceer punt uit Polygoon
gmlNode = xmlGeometrie.find(
'./' + tagVolledigeNS("gml:Polygon", xml.nsmap))
if gmlNode is not None:
gmlStr = etree.tostring(gmlNode)
self._geometrie = ogr.CreateGeometryFromGML(
str(gmlStr))
self._geometrie = self._geometrie.Centroid()
except:
Log.log.error(
"ik kan hier echt geen POINT van maken: %s (en zet dit op 0,0,0)"
% str(point.text))
def leesUitXML(self, xml):
gmlNode = None
# Attribuut vinden, bijv. bag_LVC:woonplaatsGeometrie
xmlGeometrie = xml.find('./' + tagVolledigeNS(self._tag, xml.nsmap))
if xmlGeometrie is not None:
# Probeer eerst een MultiSurface te vinden
gmlNode = xmlGeometrie.find('./' + tagVolledigeNS("gml:MultiSurface", xml.nsmap))
if gmlNode is None:
# Geen MultiSurface: probeer een Polygon te vinden
gmlNode = xmlGeometrie.find('./' + tagVolledigeNS("gml:Polygon", xml.nsmap))
if gmlNode is not None:
gmlStr = etree.tostring(gmlNode)
polygon = ogr.CreateGeometryFromGML(str(gmlStr))
self._geometrie = ogr.Geometry(ogr.wkbMultiPolygon)
self._geometrie.AddGeometryDirectly(polygon)
else:
# MultiSurface
gmlStr = etree.tostring(gmlNode)
self._geometrie = ogr.CreateGeometryFromGML(str(gmlStr))
if self._geometrie is None:
Log.log.warn("Null MultiSurface in BAGmultiPolygoon: tag=%s parent=%s" % (self._tag, self._parentObj.identificatie()))
if self._geometrie is None:
Log.log.warn("Null geometrie in BAGmultiPolygoon: tag=%s identificatie=%s" % (self._tag, self._parentObj.identificatie()))
def Geometry(*args, **kwargs):
"""Returns an ogr.Geometry instance optionally created from a geojson str
or dict. The spatial reference may also be provided.
"""
# Look for geojson as a positional or keyword arg.
arg = kwargs.pop('geojson', None) or len(args) and args[0]
try:
srs = kwargs.pop('srs', None) or arg.srs.wkt
except AttributeError:
srs = SpatialReference(4326)
if hasattr(arg, 'keys'):
geom = ogr.CreateGeometryFromJson(json.dumps(arg))
elif hasattr(arg, 'startswith'):
if arg.startswith('{'):
geom = ogr.CreateGeometryFromJson(arg)
# WKB as hexadecimal string.
elif ord(arg[0]) in [0, 1]:
geom = ogr.CreateGeometryFromWkb(arg)
elif arg.startswith('<gml'):
geom = ogr.CreateGeometryFromGML(arg)
elif hasattr(arg, 'wkb'):
geom = ogr.CreateGeometryFromWkb(bytes(arg.wkb))
else:
geom = ogr.Geometry(*args, **kwargs)
if geom:
if not isinstance(srs, SpatialReference):
srs = SpatialReference(srs)
geom.AssignSpatialReference(srs)
return geom
def leesUitXML(self, xml):
xmlGeometrie = xml.find('./' + tagVolledigeNS(self._tag, xml.nsmap))
if xmlGeometrie is not None:
gmlNode = xmlGeometrie.find('./' + tagVolledigeNS("gml:Polygon", xmlGeometrie.nsmap))
if gmlNode is not None:
gmlStr = etree.tostring(gmlNode)
self._geometrie = ogr.CreateGeometryFromGML(str(gmlStr))
def _generateGeometryFromBbox(bbox):
"""private function! returns an ogr-Geometry for a boundingbox
:param bbox boundingbox to be converted
:returns: bbox as ogr-geometry in WGS84 Mercator Projection
"""
# initialize Referencesystems for transformation
import pyproj
source = pyproj.Proj(init='epsg:4326')
target = pyproj.Proj(init='epsg:25832')
minx1, miny1 = bbox[0], bbox[1]
maxx1, maxy1 = bbox[2], bbox[3]
minx2, miny2 = pyproj.transform(source, target, minx1, miny1)
maxx2, maxy2 = pyproj.transform(source, target, maxx1, maxy1)
boxA = ogr.CreateGeometryFromGML("""
<gml:Polygon xmlns:gml="http://www.opengis.net/gml" srsName="http://www.opengis.net/def/crs/EPSG/0/25832">
<gml:outerBoundaryIs>
<gml:LinearRing>
<gml:coordinates>
%(minX)f,%(minY)f %(minX)f,%(maxY)f %(maxX)f,%(maxY)f %(maxX)f,%(minY)f %(minX)f,%(minY)f
</gml:coordinates>
</gml:LinearRing>
</gml:outerBoundaryIs>
</gml:Polygon>
""" % ({
'minX': minx2,
'minY': miny2,
'maxX': maxx2,
'maxY': maxy2
}))
return boxA
def ogr_intersect(lon, lat, chipsize, footprint):
# footprint expected as GML
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(lon, lat)
logging.debug(point)
source = osr.SpatialReference()
source.ImportFromEPSG(4326)
# Do all calcs in EPSG:3857
target = osr.SpatialReference()
target.ImportFromEPSG(3857)
transform = osr.CoordinateTransformation(source, target)
point.Transform(transform)
# env = [minX, maxX, minY, maxY]
env = point.Buffer(chipsize // 2).GetEnvelope()
chip = ogr.Geometry(ogr.wkbLinearRing)
chip.AddPoint(env[0], env[2])
chip.AddPoint(env[0], env[3])
chip.AddPoint(env[1], env[3])
chip.AddPoint(env[1], env[2])
chip.AddPoint(env[0], env[2])
chipPoly = ogr.Geometry(ogr.wkbPolygon)
chipPoly.AddGeometry(chip)
imagePoly = ogr.CreateGeometryFromGML(footprint)
imagePoly.Transform(transform)
intersection = imagePoly.Intersection(chipPoly)
return intersection.GetArea() / chipPoly.GetArea()
def _generateGeometryFromBbox(bbox):
import pyproj
source = pyproj.Proj(init='epsg:4326')
target = pyproj.Proj(init='epsg:25832')
minx1, miny1 = bbox[0], bbox[1]
maxx1, maxy1 = bbox[2], bbox[3]
minx2, miny2 = pyproj.transform(source, target, minx1, miny1)
maxx2, maxy2 = pyproj.transform(source, target, maxx1, maxy1)
boxA = ogr.CreateGeometryFromGML("""
<gml:Polygon xmlns:gml="http://www.opengis.net/gml" srsName="http://www.opengis.net/def/crs/EPSG/0/25832">
<gml:outerBoundaryIs>
<gml:LinearRing>
<gml:coordinates>
%(minX)f,%(minY)f %(minX)f,%(maxY)f %(maxX)f,%(maxY)f %(maxX)f,%(minY)f %(minX)f,%(minY)f
</gml:coordinates>
</gml:LinearRing>
</gml:outerBoundaryIs>
</gml:Polygon>
""" % ({
'minX': minx2,
'minY': miny2,
'maxX': maxx2,
'maxY': maxy2
}))
return boxA
def gml_to_geom(gml):
'''
for some gml block (from iso, likely),
try to convert to gml
'''
if not isinstance(gml, basestring):
gml = etree.tostring(gml)
return ogr.CreateGeometryFromGML(gml)
def gmlToPolygon(gmlStr):
footprint1 = ogr.CreateGeometryFromGML(gmlStr)
coords = []
if footprint1.GetGeometryCount() == 1:
g0 = footprint1.GetGeometryRef(0)
for i in range(0, g0.GetPointCount()):
pt = g0.GetPoint(i)
coords.append((pt[1], pt[0]))
return Polygon(coords)
def gml2json(gml):
"""Convert GML geometry to GeoJSON.
:param str gml: GML string
:return str: JSON geometry
"""
geom = ogr.CreateGeometryFromGML(gml)
return geom.ExportToJson()
def __init__(self, region, region_type='json'):
region = region.encode('utf-8');
if region_type.lower() == 'gml':
self.geom = ogr.CreateGeometryFromGML(region)
elif region_type.lower() == 'wkt':
self.geom = ogr.CreateGeomgeryFromWkt(region)
else:
self.geom = ogr.CreateGeometryFromJson(region.encode('utf-8'))
def _create_base_map(self, ):
'''
Deal with different types way to define the AOI, if none is specified, then the image bound is used.
'''
gdal.UseExceptions()
ogr.UseExceptions()
if self.aoi is not None:
if os.path.exists(self.aoi):
try:
g = gdal.Open(self.aoi)
subprocess.call([
'gdaltindex', '-f', 'GeoJSON', '-t_srs', 'EPSG:4326',
self.toa_dir + '/AOI.json', self.aoi
])
except:
try:
gr = ogr.Open(self.aoi)
l = gr.GetLayer(0)
f = l.GetFeature(0)
g = f.GetGeometryRef()
except:
raise IOError(
'AOI file cannot be opened by gdal, please check it or transform into format can be opened by gdal'
)
else:
try:
g = ogr.CreateGeometryFromJson(self.aoi)
except:
try:
g = ogr.CreateGeometryFromGML(self.aoi)
except:
try:
g = ogr.CreateGeometryFromWkt(self.aoi)
except:
try:
g = ogr.CreateGeometryFromWkb(self.aoi)
except:
raise IOError(
'The AOI has to be one of GeoJSON, GML, Wkt or Wkb.'
)
gjson_str = '''{"type":"FeatureCollection","features":[{"type":"Feature","properties":{},"geometry":%s}]}''' % g.ExportToJson(
)
with open(self.toa_dir + '/AOI.json', 'wb') as f:
f.write(gjson_str.encode())
ogr.DontUseExceptions()
gdal.DontUseExceptions()
if not os.path.exists(self.toa_dir + '/AOI.json'):
subprocess.call([
'gdaltindex', '-f', 'GeoJSON', '-t_srs', 'EPSG:4326',
self.toa_dir + '/AOI.json', self.toa_bands[0]
])
self.logger.warning(
'AOI is not created and full band extend is used')
self.aoi = self.toa_dir + '/AOI.json'
else:
self.aoi = self.toa_dir + '/AOI.json'
def _geom_from_gml(self, gml):
"""Create geometry from GML.
May be there is a better way, but I didn't find it.
Fix it if you know how.
"""
# import ipdb; ipdb.set_trace()
gml = str(gml)
# CreateGeometryFromGML can't do unicode
ogr_geo = ogr.CreateGeometryFromGML(gml)
return shapely.wkt.loads(ogr_geo.ExportToWkt())
def get_ruian_au_feature_geometry_from_wfs(gml_id):
url = 'https://services.cuzk.cz/wfs/inspire-au-wfs.asp?service=WFS&request=GetFeature&typeName=au:AdministrativeUnit&maxFeatures=1&featureID=%s&version=2.0.0' % gml_id
r = requests.get(url, stream=False)
if r.status_code == 200:
tree = etree.parse(BytesIO(r.content))
root = tree.getroot()
geom = root.find('.//{http://www.opengis.net/gml/3.2}MultiSurface')
geom_ogr = ogr.CreateGeometryFromGML(etree.tostring(geom).decode())
return geom_ogr.ExportToWkt()
else:
return 'WFS no works'
def convertGMLShapetoWKT(gml):
# Export geometry to WKT
try:
wkt = ogr.CreateGeometryFromGML(gml)
except Exception as e:
pass
if wkt:
# IF we have an valid WKT we first convert the WKT to a linear geometry.
wktLinear = wkt.GetLinearGeometry()
wktLinear.Transform(transform)
return wktLinear.ExportToWkt()
else:
return ""
def gml2bbox(gml):
"""Convert GML geometry to bbox.
:param str gml: GML string
:return list: bbox
"""
geom = ogr.CreateGeometryFromGML(gml)
# return list(geom.GetEnvelope())
# get Envelope returns a tuple (minX, maxX, minY, maxY)
# but it doesn't seems to be like that (GDAL 2.4)
evp = geom.GetEnvelope()
return [evp[2], evp[0], evp[3], evp[1]]
def json2geojson(json_file):
# TODO: Has to be updated, doesn't work really well (use xml2geojson)
"""Convert file in json format to geoJSON.
:param json_file: Response from SOS server in json format
:return json.dumps: Parsed response in geoJSON
"""
json_file = json.loads(
json_file.decode('utf-8'))['ObservationCollection']['member']
a = {"type": "FeatureCollection", "features": []}
if 'srsName=' in json_file[0]['featureOfInterest']['geom']:
epsg_part = json_file[0]['featureOfInterest']['geom'].split(
'srsName=')[1]
crs = ''
i = 0
while epsg_part[i] != '>':
crs += epsg_part[i]
i += 1
crs = crs[1:-1]
a.update({"crs": {"type": "name", "properties": {"name": crs}}})
for feature in json_file:
geom = feature['featureOfInterest']['geom']
point = ogr.CreateGeometryFromGML(geom)
data = {}
for i in range(int(feature['result']['DataArray']['elementCount'])):
values = []
for j in feature['result']['DataArray']['values']:
values.append(j[i])
data.update(
{feature['result']['DataArray']['field'][i]['name']: values})
data.update({'name': feature['name']})
a['features'].append({
"type": "Feature",
"geometry": {
"type": point.GetGeometryName(),
"coordinates": [point.GetX(), point.GetY()]
},
"properties": {key: value
for key, value in data.items()}
})
return json.dumps(a, indent=4, sort_keys=True)
def gml_to_geometry(gml: str) -> Geometry:
""" Handle json to qgis geometry
"""
# Lookup for srsName
geom = ogr.CreateGeometryFromGML(gml)
if not geom:
raise InvalidParameterValue("Invalid gml format")
geom = QgsGeometry.fromWkt(geom.ExportToWkt())
# Check for crs
m = SRSNAME_EXPR.search(gml)
if m:
crs = QgsCoordinateReferenceSystem(m.groups('')[0])
if crs.isValid():
geom = QgsReferencedGeometry(geom, crs)
return geom
def main():
parser = HTMLParser.HTMLParser()
#get our data as an gml string from read_in()
gml = """<gml:Point xmlns:gml="http://www.opengis.net/gml"><gml:coordinates>108420.33,753808.59</gml:coordinates></gml:Point>"""
#unescape our input data string
gml_unescape = parser.unescape(gml)
#create features
targets = ogr.CreateGeometryFromGML(gml_unescape)
#export features to GeoJSON
Feature_GeoJSON = targets.ExportToJson()
#return the sum to the output stream
print Feature_GeoJSON
def getUTMRefTiles(xfdumanifest):
#use utmref shape
shapeSource = ogr.Open(utmShape)
shapeLayer = shapeSource.GetLayer()
#create empty geometry collection
queryColl = ogr.Geometry(ogr.wkbGeometryCollection)
#parse xfdumanifest.xml for gml-poslist
for line in open(xfdumanifest):
if "<gml:posList>" in line:
posList = line
#inject poslist to gml-skeleton
footprintGML = '''<gml:Polygon xmlns:gml="http://www.opengis.net/gml">
<gml:exterior>
<gml:LinearRing>
{posList}
</gml:LinearRing>
</gml:exterior>
</gml:Polygon>'''.format(posList=posList)
#define source-srs and target srs
s_srs = osr.SpatialReference()
#gml source has flipped lat lon values
s_srs.ImportFromProj4("+proj=latlong +datum=WGS84 +axis=neu +wktext")
t_srs = osr.SpatialReference()
#target geom shall use "normal" coords
t_srs.ImportFromProj4("+proj=latlong +datum=WGS84 +axis=enu +wktext")
#define coordinate transform
transform = osr.CoordinateTransformation(s_srs, t_srs)
#create ogr geometry from GML
footprintGeom = ogr.CreateGeometryFromGML(footprintGML)
#apply transform
footprintGeom.Transform(transform)
#add transformed geom to collection
queryColl.AddGeometry(footprintGeom)
#apply spatial filter & create utm zone/row list
shapeLayer.SetSpatialFilter(queryColl)
tiles = []
for feature in shapeLayer:
zone = feature.GetField("UTMREF")
tiles.append(zone)
return tiles
def _wkbFromGml(tree, swap_xy):
# extract the srid
srid = None
srid_axis_swapped = False
srs_name = _get_srs_name(tree)
if srs_name is None:
# No SRID found, force to 4326
srid = 4326
srid_axis_swapped = True
else:
sr = osr.SpatialReference()
# EPSG:4326
# urn:EPSG:geographicCRS:4326
# urn:ogc:def:crs:EPSG:4326
# urn:ogc:def:crs:EPSG::4326
# urn:ogc:def:crs:EPSG:6.6:4326
# urn:x-ogc:def:crs:EPSG:6.6:4326
# http://www.opengis.net/gml/srs/epsg.xml#4326
# http://www.epsg.org/6.11.2/4326
# get the last number
m = re.search('([0-9]+)/?$', srs_name)
srid = int(m.group(1))
sr.ImportFromEPSGA(srid)
srid_axis_swapped = sr.EPSGTreatsAsLatLong(
) or sr.EPSGTreatsAsNorthingEasting()
# inversion
swap_xy = swap_xy ^ srid_axis_swapped
# call ogr for GML parsing
s = ET.tostring(tree, encoding="unicode")
g = ogr.CreateGeometryFromGML(s)
if g is None:
return None, None
qgsgeom = QgsGeometry()
wkb = g.ExportToWkb()
qgsgeom.fromWkb(wkb)
if swap_xy:
qgsgeom = _swap_qgs_geometry(qgsgeom)
return qgsgeom, srid
def ogr_geometry2layer(self, _geoms, _format="wkt", _proj=None):
"""
Create layer from ogr polygon geometry:
_geoms = input geometry or geometry list
_format =:
wkt - postgis geometry as ST_AsText() (DEFAULT)
geojson
gml
wkb
_proj = None or projection in format:
str:WKT, int:EPSG, dict:{'proj_type':'proj_data'}
"""
# geometry
if not isinstance(_geoms, list):
_ = []
_.append(_geoms)
_geoms = _
# find projection
if _proj is None and self.Projection == '':
raise Exception('projection for geometry not found')
elif _proj is None and self.Projection != '':
_proj = {'wkt': self.Projection}
srs = proj_conv(None, _proj).get_srs()
# create features list
features = []
for _geom in _geoms:
# create geometry
if _format.lower() == "wkt":
geom = ogr.CreateGeometryFromWkt(_geom)
elif _format.lower() in ("geojson", "gjson", "json"):
geom = ogr.CreateGeometryFromJson(_geom)
elif _format.lower() == "gml":
geom = ogr.CreateGeometryFromGML(_geom)
elif _format.lower() == "wkb":
geom = ogr.CreateGeometryFromWkb(b64decode(_geom))
else:
raise Exception("Format {} is not found".format(_format))
features.append(geom)
self.create_layer(srs, *features)
# reprojection imput layer
self.layer_reproj()
def input_to_point( inp: WPSInput ):
""" Handle point from complex input
"""
data_format = inp.data_format
geom = None
if data_format.mime_type == FORMATS.GEOJSON.mime_type:
geom = ogr.CreateGeometryFromJson(inp.data)
elif data_format.mime_type == FORMATS.GML.mime_type:
geom = ogr.CreateGeometryFromGML(inp.data)
if geom:
srs = geom.GetSpatialReference()
geom = QgsGeometry.fromWkt(geom.ExportToWkt())
if srs:
srs = QgsCoordinateReferenceSystem.fromWkt(srs.ExportToWkt())
if srs and srs.isValid():
geom = QgsReferencedPointXY( geom.centroid().asPoint(), srs )
return geom
raise NoApplicableCode("Unsupported data format: %s" % data_format)
def ISOCase(filepath):
"""Method for extracting the boundingbox of an ISO19xxx standardized file
@param filepath Full path to the ISO19xxx standardized file
@returns a boundingbox as an array in a tuple in WGS84, formated like ([minLong, minLat, maxLong, maxLat], None)
@see https://gis.stackexchange.com/questions/39080/using-ogr2ogr-to-convert-gml-to-shapefile-in-python
"""
try: # in case GDAL works
ogr.UseExceptions()
isofile = ogr.CreateGeometryFromGML(filepath)
crs = isofile.GetSpatialRef()
if crs.IsProjected() == 1:
crs = int(crs.GetAttrValue("PROJCS|AUTHORITY", 1))
elif crs.IsGeographic() == 1:
crs = int(crs.GetAttrValue("GEOGCS|AUTHORITY", 1))
else:
return (None, "CRS is missing!")
bbox = isofile.GetEnvelope()
result = CRSTransform(bbox[1], bbox[0], crs)
result.extend(CRSTransform(bbox[3], bbox[2], crs))
ogr.DontUseExceptions()
return (result, None)
except:
try:
# convert the gml file to a GeoJSON file
with tempfile.TemporaryDirectory() as tmpdirname:
curDir = os.getcwd()
os.chdir(tmpdirname)
ogr2ogr.main(
["", "-f", "GeoJSON", "output.json", filepath])
# get boundingbox from generated GeoJSON file
result = ogr2ogrCase("output.json")
os.chdir(curDir)
# delete generated GeoJSON file
return result
# errors
except:
return (None,
"file not found or your gml/xml/kml data is not valid")
def _wkbFromGml(tree, swap_xy, default_srs=None):
# extract the srid
srid = None
srid_axis_swapped = False
srs_name = _get_srs_name(tree)
if srs_name is None and default_srs is not None:
srid, srid_axis_swapped = _get_srid_from_name(default_srs)
elif srs_name is not None:
srid, srid_axis_swapped = _get_srid_from_name(srs_name)
else:
# No SRID found, force to 4326
srid, srid_axis_swapped = 4326, True
# inversion
swap_xy = swap_xy ^ srid_axis_swapped
# call ogr for GML parsing
s = ET.tostring(tree, encoding="unicode")
g = ogr.CreateGeometryFromGML(s)
if g is None:
return None
wkb = g.ExportToWkb()
if g.GetGeometryType() in (ogr.wkbPolyhedralSurface, ogr.wkbTIN):
# Polyhedral and TIN are not supported by QGIS
# So we convert them to multipolygon by poking the geometry type
# It works only because the memory structure is the same
wkb = wkb[:4] + b"\x06" + wkb[5:]
qgsgeom = QgsGeometry()
qgsgeom.fromWkb(wkb)
if swap_xy:
qgsgeom = _swap_qgs_geometry(qgsgeom)
return qgsgeom, srid
def filter_on_tile_coverage(self, products):
products_filtered = []
# update tile coverage and refilter
tile_wkt = self.mgrs_to_wkt(self.configuration.get('tile'))
if tile_wkt is None:
return products_filtered
tile_polygon = ogr.CreateGeometryFromWkt(tile_wkt)
coverage = self.configuration.getfloat('coverage')
if coverage is None:
coverage = 0.1
for product in products:
if product.instrument == 'S2' and product.gml_geometry:
product_polygon = ogr.CreateGeometryFromGML(product.gml_geometry)
logger.debug(
'PRODUCT/TILE_COVERAGE: {}/{}'.format(os.path.basename(product.path), product.tile_coverage))
product.tile_coverage = 100 * product_polygon.Intersection(
tile_polygon).GetArea() / tile_polygon.GetArea()
logger.debug('PRODUCT/TILE_COVERAGE (UPDATED): {}/{}'.format(os.path.basename(product.path),
product.tile_coverage))
if product.tile_coverage > 100 * coverage:
products_filtered.append(product)
else:
products_filtered.append(product)
return products_filtered
def _wkbFromGml(tree):
# extract the srid
srid = 4326
for k, v in tree.attrib.items():
if no_prefix(k) == 'srsName':
# EPSG:4326
# urn:EPSG:geographicCRS:4326
# urn:ogc:def:crs:EPSG:4326
# urn:ogc:def:crs:EPSG::4326
# urn:ogc:def:crs:EPSG:6.6:4326
# urn:x-ogc:def:crs:EPSG:6.6:4326
# http://www.opengis.net/gml/srs/epsg.xml#4326
# http://www.epsg.org/6.11.2/4326
# get the last number
m = re.search('([0-9]+)/?$', v)
srid = m.group(1)
break
# call ogr for GML parsing
s = ET.tostring(tree, encoding="unicode")
g = ogr.CreateGeometryFromGML(s)
if g is None:
return None
return (g.ExportToWkb(), srid)
def geom_from_gml(el):
value = etree.tostring(el)
ogr_geom = ogr.CreateGeometryFromGML(ensure_str(value))
return geom_from_wkb(ogr_geom.ExportToWkb())
def ogr_interlis_arc1():
if not gdaltest.have_ili_reader:
return 'skip'
ds = ogr.Open('data/ili/Beispiel.itf,data/ili/Beispiel.imd')
length_0_1_deg = 72.7181992353 # Line length with 0.1 degree segments
#Read Area lines
lyr = ds.GetLayerByName('Bodenbedeckung__BoFlaechen_Form')
if lyr.GetFeatureCount() != 4:
gdaltest.post_reason('feature count wrong.')
return 'fail'
#Get 3rd feature
feat = lyr.GetNextFeature()
feat = lyr.GetNextFeature()
feat = lyr.GetNextFeature()
geom = feat.GetGeometryRef()
length = geom.Length()
if abs(length - length_0_1_deg) > 0.001: #72.7177335946
gdaltest.post_reason('Length() result wrong, got %g.' % length)
return 'fail'
if ogrtest.check_feature_geometry(
geom,
'MULTILINESTRING ((186.38 206.82 0,186.460486424448106 206.327529546107257 0,186.532365795904212 205.833729416057821 0,186.595616219215486 205.338750026154884 0,186.650218427690277 204.84274215191553 0,186.696155788966905 204.345856882143238 0,186.733414310080178 203.848245572904574 0,186.761982641723563 203.350059801424834 0,186.781852081706546 202.851451319916038 0,186.793016577605215 202.352572009351746 0,186.795472728605944 201.853573833202773 0,186.789219786541395 201.354608791147427 0,186.774259656118232 200.855828872771127 0,186.75059689433715 200.357386011268773 0,186.718238709104583 199.859432037164538 0,186.677194957037244 199.362118632062675 0,186.627478140459601 198.865597282444014 0,186.569103403595591 198.370019233521532 0,186.502088527955578 197.875535443169724 0,186.426453926919834 197.382296535941265 0,186.342222639520543 196.890452757185443 0,186.249420323423806 196.400153927281849 0,186.148075247114093 195.911549396003693 0,186.038218281283434 195.424787997024453 0,185.919882889427811 194.940018002581581 0,185.793105117653909 194.457387078311513 0,185.65792358369913 193.977042238269064 0,185.514379465168304 193.499129800145766 0,185.362516486990415 193.023795340699877 0,185.202380908099769 192.551183651412458 0,185.034021507344988 192.081438694382314 0,184.857489568630456 191.614703558473906 0,184.672838865294779 191.151120415730986 0,184.480125643730986 190.690830478069671 0,184.279408606253213 190.233973954263888 0,184.070748893215466 189.780690007236473 0,183.854210064387644 189.331116711668756 0,183.629858079594698 188.885391011941635 0,183.397761278624529 188.44364868042112 0,183.26 188.19 0,183.157990360411077 188.006024276100675 0,182.910618361498763 187.572651103613168 0,182.655720633794772 187.143661172625173 0,182.393374821616248 186.719185157625333 0,182.123660838038973 186.299352358119819 0,181.846660840555074 185.884290659246403 0,181.562459206047208 185.474126492819352 0,181.271142505086345 185.06898479881707 0,180.972799475561658 184.668988987324269 0,180.667520995650023 184.274260900939993 0,180.355400056133732 183.884920777663154 0,180.036531732074565 183.501087214266903 0,179.711013153852946 183.122877130172981 0,179.378943477581203 182.750405731836764 0,179.040423854899558 182.383786477654411 0,178.695557402164354 182.023131043402287 0,178.344449169037915 181.668549288219367 0,177.987206106489339 181.320149221143225 0,177.623937034216141 180.978036968209295 0,177.254752607496783 180.642316740123988 0,176.879765283484062 180.313090800520911 0,176.499089286949413 179.990459434810589 0,176.112840575489088 179.674520919632386 0,175.721136804202303 179.365371492918626 0,175.324097289852261 179.063105324579453 0,174.921842974521269 178.767814487817873 0,174.514496388770482 178.479588931083327 0,174.102181614316009 178.198516450672486 0,173.685024246232274 177.924682663985692 0,173.26315135469477 177.658170983447064 0,172.836691446272965 177.399062591096254 0,172.405774424786216 177.147436413859566 0,171.970531551733643 176.903369099508211 0,171.531095406310641 176.666934993310434 0,171.087599845024073 176.438206115385384 0,170.64017996091809 176.217252138765019 0,170.188972042423671 176.004140368171022 0,170.18 176.0 0,170.18 176.0 0,140.69 156.63 0))'
) != 0:
gdaltest.post_reason('Ili curve not correctly read')
print(geom.ExportToWkt())
return 'fail'
line = geom.GetGeometryRef(0)
points = line.GetPoints()
if len(points) != 80:
gdaltest.post_reason('line point count wrong.')
return 'fail'
#Get 4th feature
feat = lyr.GetNextFeature()
geom = feat.GetGeometryRef()
length = geom.Length()
if abs(length - 98.0243498288) > 0.0000000001:
gdaltest.post_reason('Length() result wrong, got %g.' % length)
return 'fail'
if ogrtest.check_feature_geometry(
geom,
'MULTILINESTRING ((186.38 206.82 0,194.26 208.19 0,194.363742877465398 207.560666258887778 0,194.456486566153643 206.929617805490125 0,194.538202815438581 206.297046863278979 0,194.608866733759072 205.663146119491216 0,194.66845679620107 205.028108666434122 0,194.716954851054254 204.392127942667628 0,194.754346125341328 203.755397674081081 0,194.780619229317949 203.118111814882468 0,194.795766159942076 202.48046448851801 0,194.799782303311986 201.842649928540311 0,194.792666436071414 201.204862419443032 0,194.774420725782534 200.567296237479837 0,194.745050730265405 199.930145591485967 0,194.704565395905178 199.293604563720407 0,194.652977054926907 198.657867050746546 0,194.590301421638998 198.023126704369332 0,194.516557587646503 197.389576872647183 0,194.431768016035619 196.757410540996148 0,194.335958534531215 196.126820273404775 0,194.229158327629534 195.497998153777246 0,194.111399927708163 194.87113572742274 0,193.982719205116467 194.246423942708901 0,193.843155357249145 193.624053092897014 0,193.692750896606185 193.004212758177033 0,193.531551637843307 192.387091747919413 0,193.359606683816367 191.772878043162052 0,193.176968410623942 191.161758739349466 0,192.983692451653383 190.553919989341608 0,192.779837680634046 189.949546946710058 0,192.565466193703969 189.348823709338234 0,192.340643290494768 188.751933263343574 0,192.105437454240644 188.159057427338212 0,191.859920330917817 187.570376797045014 0,191.604166707420404 186.986070690286709 0,191.338254488779711 186.406317092363707 0,191.062264674433465 185.831292601838129 0,190.776281333552674 185.261172376740149 0,190.75 185.21 0,190.480391579433388 184.696130081213255 0,190.174685542961015 184.136337832614316 0,189.859256345155728 183.581966149085105 0,189.534200068806825 183.033183897610741 0,189.199615729204936 182.490158242581202 0,188.855605243981131 181.953054594871418 0,188.502273402061718 181.422036561455485 0,188.139727831748502 180.897265895570513 0,187.768078967934287 180.378902447444887 0,187.387440018463224 179.867104115606367 0,186.997926929646695 179.362026798784797 0,186.599658350944793 178.863824348423634 0,186.192755598824732 178.372648521815478 0,185.777342619806575 177.88864893587521 0,185.35354595270789 177.411973021565359 0,184.921494690098939 176.94276597898704 0,184.481320438979651 176.481170733150748 0,184.033157280690972 176.027327890439949 0,183.577141730072384 175.58137569578102 0,183.113412693878161 175.143449990532446 0,182.642111428464915 174.713684171106365 0,182.163381496763719 174.292209148334592 0,181.677368724549325 173.879153307591992 0,181.184221156020271 173.47464246968903 0,180.684089008703126 173.078799852545501 0,180.177124627694894 172.691746033657182 0,179.663482439257081 172.313598913366803 0,179.143318903776049 171.944473678950402 0,178.616792468103654 171.584482769530155 0,178.084063517292776 171.233735841824398 0,177.545294325742475 170.8923397367451 0,177.000649007767692 170.560398446852986 0,176.450293467608361 170.238013084680574 0,175.894395348893454 169.925281851932226 0,175.333123983575007 169.622300009570893 0,174.766650340348065 169.329159848800828 0,174.195146972571933 169.045950662954681 0,174.1 169.0 0,174.1 169.0 0,145.08 149.94 0,140.69 156.63 0))'
) != 0:
gdaltest.post_reason('Ili curve not correctly read')
print(geom.ExportToWkt())
return 'fail'
line = geom.GetGeometryRef(0)
points = line.GetPoints()
if len(points) != 81:
gdaltest.post_reason('line point count wrong.')
return 'fail'
#0.1 deg instead of default (1 deg) (max deg for ili sementizer is about 1.3 degrees)
os.environ['ARC_DEGREES'] = '0.1'
#GML: gdal.SetConfigOption('OGR_ARC_STEPSIZE','0.1')
ds = ogr.Open('data/ili/Beispiel.itf,data/ili/Beispiel.imd')
#Read Area lines
lyr = ds.GetLayerByName('Bodenbedeckung__BoFlaechen_Form')
#Get 3rd feature
feat = lyr.GetNextFeature()
feat = lyr.GetNextFeature()
feat = lyr.GetNextFeature()
geom = feat.GetGeometryRef()
length = geom.Length()
if abs(length - length_0_1_deg) > 0.0000000001:
gdaltest.post_reason('Length() result wrong, got %g.' % length)
return 'fail'
line = geom.GetGeometryRef(0)
points = line.GetPoints()
if len(points) != 755: #80 for 1 deg
gdaltest.post_reason('line point count wrong.')
return 'fail'
#Compare with GML segmentation
gml = """<gml:Curve xmlns:gml="http://www.opengis.net/gml" srsName="foo">
<gml:segments>
<gml:Arc interpolation="circularArc3Points" numArc="1">
<gml:pos>186.38 206.82</gml:pos>
<gml:pos>183.26 188.19</gml:pos>
<gml:pos>170.18 176.00</gml:pos>
</gml:Arc>
<gml:LineStringSegment interpolation="linear">
<gml:pos>170.18 176.00</gml:pos>
<gml:pos>140.69 156.63</gml:pos>
</gml:LineStringSegment>
</gml:segments>
</gml:Curve>"""
gdal.SetConfigOption(
'OGR_ARC_STEPSIZE',
'6') #Default: 4 [The largest step in degrees along the arc]
geom = ogr.CreateGeometryFromGML(gml)
gdal.SetConfigOption('OGR_ARC_STEPSIZE', None)
length = geom.Length()
if abs(length - length_0_1_deg) > 0.7: #72.7016803283
gdaltest.post_reason('Length() result wrong, got %g.' % length)
return 'fail'
if ogrtest.check_feature_geometry(
geom,
'COMPOUNDCURVE (CIRCULARSTRING (186.38 206.82,183.26 188.19,170.18 176.0),(170.18 176.0,140.69 156.63))'
) != 0:
gdaltest.post_reason('<gml:Curve> not correctly parsed')
print(geom.ExportToWkt())
return 'fail'
gdal.SetConfigOption('OGR_ARC_STEPSIZE', '10') #Default: 4
geom = ogr.CreateGeometryFromGML(gml)
gdal.SetConfigOption('OGR_ARC_STEPSIZE', None)
length = geom.Length()
if abs(length - length_0_1_deg) > 0.7: #72.6745269621
gdaltest.post_reason('Length() result wrong, got %g.' % length)
return 'fail'
if ogrtest.check_feature_geometry(
geom,
'COMPOUNDCURVE (CIRCULARSTRING (186.38 206.82,183.26 188.19,170.18 176.0),(170.18 176.0,140.69 156.63))'
) != 0:
gdaltest.post_reason('<gml:Curve> not correctly parsed')
print(geom.ExportToWkt())
return 'fail'
return 'success'
def _to_ogr(source, srid=None):
geom = None
if isinstance(source, dict):
# GeoJSON
if not 'coordinates' in source:
if 'features' in source:
raise ValueError(
f'FeatureCollection {repr(source)} cannot be converted to a single OGR Geometry'
)
if 'geometry' in source:
source = source['geometry']
else:
raise ValueError(
f'{repr(source)} doesn\'t look like a valid GeoJSON')
geom_str = json.dumps(source)
geom = ogr.CreateGeometryFromJson(geom_str)
if geom is None:
raise ValueError(
f'Failed to convert {repr(source)} to OGR Geometry')
elif isinstance(source, str):
try:
jsn = json.loads(source)
except json.JSONDecodeError:
pass
else:
# GeoJSON string
return OgrWrapper._to_ogr(jsn, srid)
wkt = source
m = re.match(r'\s*SRID=(\d*)\s*;(.*)$', wkt) # Extended WKT
if m:
srid = int(m.group(1))
wkt = m.group(2)
# Try WKT
geom = ogr.CreateGeometryFromWkt(wkt)
if geom is None:
geom = ogr.CreateGeometryFromGML(source)
if geom is None:
raise ValueError(
f'{repr(source)} doesn\'t look like neither of GeoJSON, WKT nor GML'
)
elif isinstance(source, ET.Element):
xml = ET.tostring(source, encoding='utf-8').decode()
try:
return OgrWrapper._to_ogr(xml)
except ValueError:
raise ValueError(
f'{repr(source)} is not representing a valid GML')
else:
raise TypeError(
f'{repr(source)} cannot be converted to OGR Geometry')
if srid is not None:
OgrWrapper._set_srs(geom, srid)
return geom
