In [1]:
%matplotlib inline
import inspect, sys
In [2]:
# check pydov path
import pydov
In [3]:
from pydov.search.interpretaties import FormeleStratigrafieSearch
itp = FormeleStratigrafieSearch()
A description is provided for the 'Formele stratigrafie' datatype:
In [4]:
itp.get_description()
Out[4]:
The different fields that are available for objects of the 'Formele stratigrafie' datatype can be requested with the get_fields() method:
In [5]:
fields = itp.get_fields()
# print available fields
for f in fields.values():
print(f['name'])
You can get more information of a field by requesting it from the fields dictionary:
In [6]:
fields['Datum']
Out[6]:
Some fields have an additional item values that lists the possible values the field can have, and a definition describing what they mean:
In [7]:
fields['lid1']
Out[7]:
Get data for all the 'Formele stratigrafie' interpretations that are geographically located within the bounds of the specified box.
The coordinates are in the Belgian Lambert72 (EPSG:31370) coordinate system and are given in the order of lower left x, lower left y, upper right x, upper right y.
In [8]:
from pydov.util.location import Within, Box
df = itp.search(location=Within(Box(153145, 206930, 153150, 206935)))
df.head()
Out[8]:
The dataframe contains one 'Formele stratigrafie' interpretation where two layers ('laag') were identified. The available data are flattened to represent unique attributes per row of the dataframe.
Using the pkey_interpretatie field one can request the details of this interpretation in a webbrowser:
In [9]:
for pkey_interpretatie in set(df.pkey_interpretatie):
print(pkey_interpretatie)
Using the field's values information, we can translate the stratigraphical codes to human readable layers:
In [10]:
df['lid1_lb'] = df['lid1'].map(fields['lid1']['values'])
df['lid2_lb'] = df['lid2'].map(fields['lid2']['values'])
df[['pkey_interpretatie', 'diepte_laag_van', 'diepte_laag_tot', 'lid1', 'lid1_lb', 'relatie_lid1_lid2', 'lid2', 'lid2_lb']]
Out[10]:
Next to querying interpretations based on their geographic location within a bounding box, we can also search for interpretations matching a specific set of properties. For this we can build a query using a combination of the 'FormeleStratigrafie' fields and operators provided by the WFS protocol.
A list of possible operators can be found below:
In [11]:
[i for i,j in inspect.getmembers(sys.modules['owslib.fes'], inspect.isclass) if 'Property' in i]
Out[11]:
In this example we build a query using the PropertyIsGreaterThan and PropertyIsEqualTo operators to find all interpretations that are at least 20 m deep, that are deemed appropriate for a range of 1 km from a defined point:
In [12]:
from owslib.fes import And, PropertyIsGreaterThan, PropertyIsEqualTo
from pydov.util.location import WithinDistance, Point
query = And([PropertyIsEqualTo(propertyname='Betrouwbaarheid',
literal='goed'),
PropertyIsGreaterThan(propertyname='diepte_tot_m',
literal='20'),
])
df = itp.search(query=query,
location=WithinDistance(Point(153145, 206930), 1000))
df.head()
Out[12]:
Once again we can use the pkey_interpretatie as a permanent link to the information of these interpretations:
In [13]:
for pkey_interpretatie in set(df.pkey_interpretatie):
print(pkey_interpretatie)
We can combine a query on attributes with a query on geographic location to get the interpretations within a bounding box that have specific properties.
The following example requests the interpretations of boreholes only, within the given bounding box.
(Note that the datatype of the literal parameter should be a string, regardless of the datatype of this field in the output dataframe.)
In [14]:
from owslib.fes import PropertyIsEqualTo
query = PropertyIsEqualTo(
propertyname='Type_proef',
literal='Boring')
df = itp.search(
location=Within(Box(153145, 206930, 154145, 207930)),
query=query
)
df.head()
Out[14]:
We can look at one of the interpretations in a webbrowser using its pkey_interpretatie:
In [15]:
for pkey_interpretatie in set(df.pkey_interpretatie):
print(pkey_interpretatie)
We can limit the columns in the output dataframe by specifying the return_fields parameter in our search.
In this example we query all the 'Formele stratigrafie' interpretations in a distance of 1 km and return their date:
In [16]:
df = itp.search(location=WithinDistance(Point(153145, 206930), 1000),
return_fields=('Datum',))
df.head()
Out[16]:
In [17]:
df.describe()
Out[17]:
To keep the output dataframe size acceptable, not all available WFS fields are included in the standard output. However, one can use this information to select interpretations as illustrated below.
For example, make a selection of the interpretations in municipality the of Antwerp, before 1/1/1990:
!remark: mind that the municipality attribute is merely an attribute that is defined by the person entering the data. It can be ok, empty, outdated or wrong!
In [18]:
from owslib.fes import And, PropertyIsEqualTo, PropertyIsLessThan
query = And([PropertyIsEqualTo(propertyname='gemeente',
literal='Antwerpen'),
PropertyIsLessThan(propertyname='Datum',
literal='1990-01-01')]
)
df = itp.search(query=query,
return_fields=('pkey_interpretatie', 'Datum'))
df.head()
Out[18]:
As denoted in the previous example, not all available fields are available in the default output frame to keep its size limited. However, you can request any available field by including it in the return_fields parameter of the search:
In [19]:
query = PropertyIsEqualTo(
propertyname='gemeente',
literal='Leuven')
df = itp.search(query=query,
return_fields=('pkey_interpretatie', 'pkey_boring', 'pkey_sondering',
'x', 'y', 'Z_mTAW', 'gemeente', 'Auteurs', 'Proefnummer'))
df.head()
Out[19]:
Using Folium, we can display the results of our search on a map.
In [21]:
# import the necessary modules (not included in the requirements of pydov!)
import folium
from folium.plugins import MarkerCluster
from pyproj import Transformer
In [22]:
# convert the coordinates to lat/lon for folium
def convert_latlon(x1, y1):
transformer = Transformer.from_crs("epsg:31370", "epsg:4326", always_xy=True)
x2,y2 = transformer.transform(x1, y1)
return x2, y2
df['lon'], df['lat'] = zip(*map(convert_latlon, df['x'], df['y']))
# convert to list
loclist = df[['lat', 'lon']].values.tolist()
In [23]:
# initialize the Folium map on the centre of the selected locations, play with the zoom until ok
fmap = folium.Map(location=[df['lat'].mean(), df['lon'].mean()], zoom_start=12)
marker_cluster = MarkerCluster().add_to(fmap)
for loc in range(0, len(loclist)):
folium.Marker(loclist[loc], popup=df['Proefnummer'][loc]).add_to(marker_cluster)
fmap
Out[23]: