DM_geometry_ogr_wkt.py

## @package python.demo.DM_geometry_ogr_wkt
# 
# Example script showing the bidirectional conversion of pyDM and OGR geometry objects. This can be used to get WKT 
# representation (https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry) of pyDM geometry objects.
# 
 
import random, sys
 
from opals import pyDM
from osgeo import ogr
 
 
def point_conversion():
    print("-- point conversion test ---------------------------------")
    # create ogr point
    ogrPt = ogr.Geometry(ogr.wkbPoint)
    ogrPt.AddPoint(*[23.12, -5.21, 2.02])
    print(ogrPt)  # prints wkt representation
 
    dmPt = pyDM.OGRConverter.convert(ogrPt)  # convert ogr point to pyDM.Point
    print(f"{type(dmPt)} ({dmPt.x}  {dmPt.y} {dmPt.z})")
 
    ogrPtConv = pyDM.OGRConverter.convert(dmPt) # convert pyDM.Point to ogr point
    print(ogrPtConv) # print wkt representation again
 
 
def polyine_conversion():
 
    def ouput(titel, line):
        print(f"{titel} {type(line)} has {line.sizePoint()} point(s) in {line.sizePart()} part(s).")
 
    print("-- polyine conversion test -------------------------------")
 
    # create ogr linestring and multi linestring object
    # whereas simple lines are represented as LINESTRING, multi part lines need to be described as MULTILINESTRING
    # for more detail see https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry
    # In pyDM both cases are represented by the Polyline object class
    ogrLine = ogr.CreateGeometryFromWkt("LINESTRING (0 0, 5 5, 20 -3)")
    ogrMultiLine = ogr.CreateGeometryFromWkt("MULTILINESTRING ((0 0, 5 5, 20 -3), (0 -3, -5 -3))")
 
    # prints wkt representation
    print(ogrLine)
    print(ogrMultiLine)
 
    # convert ogr line and multiline objects
    dmLine = pyDM.OGRConverter.convert(ogrLine)            # convert ogr line to pyDM.Polyline
    dmMultiLine = pyDM.OGRConverter.convert(ogrMultiLine)  # convert ogr multiline to pyDM.Polyline
 
    ouput("dmLine:      ", dmLine)
    ouput("dmMultiLine: ", dmMultiLine)
 
    ogrLineConv = pyDM.OGRConverter.convert(dmLine)            # convert pyDM.Polyline or ogr line
    ogrMultiLineConv = pyDM.OGRConverter.convert(dmMultiLine)  # convert pyDM.Polyline or ogr multiline
 
    # print wkt representation of converted objects
    print(ogrLineConv)
    print(ogrMultiLineConv)
 
def polygon_conversion():
 
    def output(titel, poly):
        print(f"{titel} {type(poly)} has {poly.sizePoint()} point(s) in {poly.sizeFace()} faces(s).")
 
    print("-- polygon conversion test -------------------------------")
 
    # create ogr polygon and mulipolygon object
    # an ogr polygon object describes a connected region in space that may have an arbitrary number of holes.
    # multiple non-connected regions or nested polygons (island within hole) require multi polygon representation.
    # in pyDM all cases are represented by the Polygon object class
    ogrPolySimple    = ogr.CreateGeometryFromWkt("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))")
    ogrPolyWithHoles = ogr.CreateGeometryFromWkt("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0),(2 2, 4 2, 4 4, 2 4, 2 2),"\
                                                 "(5 5, 8 5, 8 8, 5 8, 5 5))")
    ogrPolyNested    = ogr.CreateGeometryFromWkt("MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0),(2 2, 4 2, 4 4, 2 4, 2 2),"\
                                                 "(5 5, 8 5, 8 8, 5 8, 5 5)), ((6 6, 7 6, 7 7, 6 7, 6 6)))")
    ogrPolyComplex  = ogr.CreateGeometryFromWkt("MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0),(5 5, 8 5, 8 8, 5 8, 5 5)),"\
                                                "((6 6, 7 6, 7 7, 6 7, 6 6)), ((-3 -5, -1 -5, -1 5, -3 5, -3 -5)))")
 
    # prints wkt representation
    print(ogrPolySimple)
    print(ogrPolyWithHoles)
    print(ogrPolyNested)
    print(ogrPolyComplex)
 
    # convert ogr (multi)polygon to pyDM.Polygon
    dmPolySimple    = pyDM.OGRConverter.convert(ogrPolySimple)
    dmPolyWithHoles = pyDM.OGRConverter.convert(ogrPolyWithHoles)
    dmPolyNested    = pyDM.OGRConverter.convert(ogrPolyNested)
    dmPolyComplex   = pyDM.OGRConverter.convert(ogrPolyComplex)
 
    output("dmPolySimple:    ", dmPolySimple)
    output("dmPolyWithHoles: ", dmPolyWithHoles)
    output("dmPolyNested:    ", dmPolyNested)
    output("dmPolyComplex:   ", dmPolyComplex)
 
    # convert pyDM.Polygon to ogr (multi)polygon
    ogrPolySimpleConv    = pyDM.OGRConverter.convert(dmPolySimple)
    ogrPolyWithHolesConv = pyDM.OGRConverter.convert(dmPolyWithHoles)
    ogrPolyNestedConv    = pyDM.OGRConverter.convert(dmPolyNested)
    ogrPolyComplexConv   = pyDM.OGRConverter.convert(dmPolyComplex)
 
    # prints wkt representation
    print(ogrPolySimpleConv)
    print(ogrPolyWithHolesConv)
    print(ogrPolyNestedConv)
    print(ogrPolyComplexConv)
 
 
# convert different geometries
point_conversion()
polyine_conversion()
polygon_conversion()