GemGIS API Reference#

The API reference provides an overview of all functions and methods implemented in GemGIS.

Vector#

The following sections provide an overview of the methods implemented in the GemGIS Vector module.

Extracting Coordinates from GeoDataFrames#

The following methods are used to extract X and Y coordinates or X, Y, and Z coordinates from GeoDataFrames or Shapely Base Geometries for further usage.

gemgis.vector.extract_xy(gdf[, reset_index, ...])

Extracting X and Y coordinates from a GeoDataFrame (Points, LineStrings, MultiLineStrings, Polygons, Geometry Collections) and returning a GeoDataFrame with X and Y coordinates as additional columns

gemgis.vector.extract_xy_linestring(gdf[, ...])

Extracting the coordinates of Shapely LineStrings within a GeoDataFrame and storing the X and Y coordinates in lists per LineString

gemgis.vector.extract_xy_linestrings(gdf[, ...])

Extracting X and Y coordinates from a GeoDataFrame (LineStrings) and returning a GeoDataFrame with X and Y coordinates as additional columns

gemgis.vector.extract_xy_points(gdf[, ...])

Extracting X and Y coordinates from a GeoDataFrame (Points) and returning a GeoDataFrame with X and Y coordinates as additional columns

gemgis.vector.extract_xyz(gdf[, dem, minz, ...])

Extracting X and Y coordinates from a GeoDataFrame (Points, LineStrings, MultiLineStrings Polygons) and Z values from a NumPy nd.array or a Rasterio object and returning a GeoDataFrame with X, Y, and Z coordinates as additional columns

gemgis.vector.extract_xyz_array(gdf, dem, extent)

Extracting X and Y coordinates from a GeoDataFrame (Points, LineStrings, MultiLineStrings Polygons) and Z values from a NumPy nd.array and returning a GeoDataFrame with X, Y, and Z coordinates as additional columns

gemgis.vector.extract_xyz_rasterio(gdf, dem)

Extracting X and Y coordinates from a GeoDataFrame (Points, LineStrings, MultiLineStrings Polygons) and z values from a rasterio object and returning a GeoDataFrame with X, Y, and Z coordinates as additional columns

gemgis.vector.extract_xyz_points(gdf)

Extracting X, Y, and Z coordinates from a GeoDataFrame containing Shapely Points with Z components

gemgis.vector.extract_xyz_linestrings(gdf[, ...])

Extracting X, Y, and Z coordinates from a GeoDataFrame containing Shapely LineStrings with Z components

gemgis.vector.extract_xyz_polygons(gdf[, ...])

Extracting X, Y, and Z coordinates from a GeoDataFrame containing Shapely Polygons with Z components

Extracting Coordinates and Intersections from GeoDataFrames/Shapely Polygons#

The following methods are used to extract coordinates and intersections from GeoDataFrames containing Shapely Polygons or from single Shapely Polygons or multiple Shapely Polygons.

gemgis.vector.extract_xy_from_polygon_intersections(gdf)

Calculating the intersections between Polygons; the table must be sorted by stratigraphic age

gemgis.vector.intersection_polygon_polygon(...)

Calculating the intersection between to Shapely Polygons

gemgis.vector.intersections_polygon_polygons(...)

Calculating the intersections between one polygon and a list of polygons

gemgis.vector.intersections_polygons_polygons(...)

Calculating the intersections between a list of Polygons

Calculating and extracting coordinates from cross sections#

The following methods are used to calculate and extract coordinates from cross sections where data was stored as Shape Files and is now loaded as GeoDataFrames.

gemgis.vector.extract_interfaces_coordinates_from_cross_section(...)

Extracting coordinates of interfaces digitized on a cross section

gemgis.vector.extract_xyz_from_cross_sections(...)

Extracting X, Y, and Z coordinates from cross sections and digitized interfaces

gemgis.vector.calculate_coordinates_for_point_on_cross_section(...)

Calculating the coordinates for one point digitized on a cross section provided as Shapely LineString

gemgis.vector.calculate_coordinates_for_linestring_on_cross_sections(...)

Calculating the coordinates of vertices for a LineString on a straight cross section provided as Shapely LineString

gemgis.vector.calculate_coordinates_for_linestrings_on_cross_sections(...)

Calculating the coordinates of vertices for LineStrings on a straight cross section provided as Shapely LineString

gemgis.vector.extract_interfaces_coordinates_from_cross_section(...)

Extracting coordinates of interfaces digitized on a cross section

Calculating and extracting angles from cross sections and maps#

The following methods are used to calculate and extract angles from cross sections.

gemgis.vector.calculate_angle(linestring)

Calculating the angle of a LineString to the vertical

gemgis.vector.calculate_azimuth(gdf)

Calculating the azimuth for an orientation Geodataframe represented by LineStrings

gemgis.vector.calculate_strike_direction_straight_linestring(...)

Function to calculate the strike direction of a straight Shapely LineString.

gemgis.vector.calculate_strike_direction_bent_linestring(...)

Calculating the strike direction of a LineString with multiple elements

gemgis.vector.calculate_dipping_angle_linestring(...)

Calculating the dipping angle of a LineString digitized on a cross section

gemgis.vector.calculate_dipping_angles_linestrings(...)

Calculating the dipping angles of LineStrings digitized on a cross section

gemgis.vector.calculate_orientation_from_bent_cross_section(...)

Calculating the orientation of a LineString on a bent cross section provided as Shapely LineString

gemgis.vector.calculate_orientation_from_cross_section(...)

Calculating the orientation for one LineString on one cross sections

gemgis.vector.calculate_orientations_from_cross_section(...)

Calculating orientations from a cross sections using multiple LineStrings

gemgis.vector.extract_orientations_from_cross_sections(...)

Calculating orientations digitized from cross sections

gemgis.vector.extract_orientations_from_map(gdf)

Calculating orientations from LineStrings

gemgis.vector.calculate_orientations_from_strike_lines(gdf)

Calculating orientations based on LineStrings representing strike lines

gemgis.vector.calculate_orientation_for_three_point_problem(gdf)

Calculating the orientation for a three point problem

Exploding Geometries#

The following methods are used to explode geometries for further usage in GemGIS

gemgis.vector.explode_linestring(linestring)

Exploding a LineString to its vertices, also works for LineStrings with Z components

gemgis.vector.explode_linestring_to_elements(...)

Separating a LineString into its single elements and returning a list of LineStrings representing these elements, also works for LineStrings with Z components

gemgis.vector.explode_multilinestring(...)

Exploding a MultiLineString into a list of LineStrings

gemgis.vector.explode_multilinestrings(gdf)

Exploding Shapely MultiLineStrings stored in a GeoDataFrame to Shapely LineStrings

gemgis.vector.explode_polygon(polygon)

Exploding Shapely Polygon to list of Points

gemgis.vector.explode_polygons(gdf)

Converting a GeoDataFrame containing elements of geom_type Polygons to a GeoDataFrame with LineStrings

gemgis.vector.explode_geometry_collection(...)

Exploding a Shapely Geometry Collection to a List of Base Geometries

gemgis.vector.explode_geometry_collections(gdf)

Exploding Shapely Geometry Collections stored in GeoDataFrames to different Shapely Base Geometries

Removing Points within Buffers#

The following methods are used to remove Points within Buffers. This can be used to remove interface points in the vicinity of faults.

gemgis.vector.remove_object_within_buffer(...)

Removing object from a buffered object by providing a distance

gemgis.vector.remove_objects_within_buffer(...)

Removing objects from a buffered object by providing a distance

gemgis.vector.remove_interfaces_within_fault_buffers(...)

Function to create a buffer around a GeoDataFrame containing fault data and removing interface points that are located within this buffer

Vector Methods for Raster Data#

The following methods are used to work with raster data

gemgis.vector.interpolate_raster(gdf[, ...])

Interpolating a raster/digital elevation model from point or line Shape file

Working with GPX Data#

The following methods are used to work with GPX data

gemgis.vector.load_gpx(path[, layer])

Loading a GPX file as collection

gemgis.vector.load_gpx_as_dict(path[, layer])

Loading a GPX file as dict

gemgis.vector.load_gpx_as_geometry(path[, layer])

Loading a GPX file as Shapely Geometry

Miscellaneous vector data methods#

The following methods are further vector data methods used in GemGIS

gemgis.vector.calculate_distance_linestrings(...)

Calculating the minimal distance between two LineStrings

gemgis.vector.calculate_midpoint_linestring(...)

Calculating the midpoint of a LineString with two vertices

gemgis.vector.calculate_midpoints_linestrings(...)

Calculating the midpoints of LineStrings with two vertices each

gemgis.vector.clip_by_bbox(gdf, bbox[, ...])

Clipping vector data contained in a GeoDataFrame to a provided bounding box/extent

gemgis.vector.clip_by_polygon(gdf, polygon)

Clipping vector data contained in a GeoDataFrame to a provided bounding box/extent

gemgis.vector.create_bbox(extent)

Creating a rectangular polygon from the provided bounding box values, with counter-clockwise order by default.

gemgis.vector.create_buffer(geom_object, ...)

Creating a buffer around a Shapely LineString or a Point

gemgis.vector.create_unified_buffer(...)

Creating a unified buffer around Shapely LineStrings or Points

gemgis.vector.create_linestring_from_points(...)

Creating a LineString object from a GeoDataFrame containing surface points at a given altitude and for a given formation

gemgis.vector.create_linestring_from_xyz_points(points)

Create LineString from an array or GeoDataFrame containing X, Y, and Z coordinates of points.

gemgis.vector.create_linestring_gdf(gdf)

Creating LineStrings from Points

gemgis.vector.create_linestrings_from_contours(...)

Creating LineStrings from PyVista Contour Lines and save them as list or GeoDataFrame

gemgis.vector.create_linestrings_from_xyz_points(...)

Creating LineStrings from a GeoDataFrame containing X, Y, and Z coordinates of vertices of multiple LineStrings

gemgis.vector.create_polygons_from_faces(...)

Extracting faces from PyVista PolyData as Shapely Polygons

gemgis.vector.unify_linestrings(linestrings)

Unifying adjacent LineStrings to form LineStrings with multiple vertices

gemgis.vector.unify_polygons(polygons[, ...])

Unifying adjacent triangular polygons to form larger objects

Special Methods#

The following methods are special methods used in GemGIS

gemgis.vector.set_dtype(gdf[, dip, azimuth, ...])

Checking and setting the dtypes of the input data GeoDataFrame

gemgis.vector.sort_by_stratigraphy(gdf, ...)

Sorting a GeoDataFrame by a provided list of Stratigraphic Units

gemgis.vector.subtract_geom_objects(...)

Subtracting Shapely geometry objects from each other and returning the left over object

gemgis.vector.create_hexagon(center, radius)

Function to create one hexagon

gemgis.vector.create_hexagon_grid(gdf, radius)

Function to create a grid of hexagons based on a GeoDataFrame containing Polygons and a radius provided for the single hexagons

gemgis.vector.create_voronoi_polygons(gdf)

Function to create Voronoi Polygons from Point GeoDataFrame using the SciPy Spatial Voronoi class (https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.Voronoi.html#scipy.spatial.Voronoi)

Raster#

The following sections provide an overview of the methods implemented in the GemGIS Raster module.

Raster Calculations#

The following methods are used to perform calculations on rasters

gemgis.raster.calculate_aspect(raster[, ...])

Calculating the aspect based on a digital elevation model/raster

gemgis.raster.calculate_difference(raster1, ...)

Calculating the difference between two rasters

gemgis.raster.calculate_hillshades(raster[, ...])

Calculating Hillshades based on digital elevation model/raster

gemgis.raster.calculate_slope(raster[, ...])

Calculating the slope based on digital elevation model/raster

Sampling from a Raster#

The following methods are used to sample values from a raster

gemgis.raster.sample_from_array(array, ...)

Sampling the value of a np.ndarray at a given point and given the arrays true extent

gemgis.raster.sample_from_rasterio(raster, ...)

Sampling the value of a rasterio object at a given point within the extent of the raster

gemgis.raster.sample_interfaces(raster[, ...])

Sampling interfaces from a raster

gemgis.raster.sample_orientations(raster[, ...])

Sampling orientations from a raster

gemgis.raster.sample_randomly(raster[, n, ...])

Sampling randomly from a raster (array or rasterio object) using sample_from_array or sample_from_rasterio and a randomly drawn point within the array/raster extent

Reading different raster formats#

The following methods are used to read different raster formats into Python

gemgis.raster.read_asc(path)

Function to read GoCAD .asc files

gemgis.raster.read_msh(path)

Function to read Leapfrog .msh files - https://help.leapfrog3d.com/Geo/4.3/en-GB/Content/meshes/meshes.htm

gemgis.raster.read_ts(path)

Function to read GoCAD .ts files

gemgis.raster.read_zmap(path)

Reading Petrel ZMAP Files

Miscellaneous raster data methods#

The following methods are further raster data methods used in GemGIS

gemgis.raster.clip_by_bbox(raster, bbox[, ...])

Clipping a rasterio raster or np.ndarray by a given extent

gemgis.raster.clip_by_polygon(raster, polygon)

Clipping/masking a rasterio raster or np.ndarray by a given shapely Polygon

gemgis.raster.create_filepaths(dirpath, ...)

Retrieving the file paths of the tiles to load and to process them later

gemgis.raster.extract_contour_lines_from_raster(...)

Extracting contour lines from raster with a provided interval.

gemgis.raster.merge_tiles(src_files[, ...])

Merging downloaded tiles to mosaic

gemgis.raster.reproject_raster(path_in, ...)

Reprojecting a raster into different CRS

gemgis.raster.resize_by_array(raster, array)

Rescaling raster to the size of another raster

gemgis.raster.resize_raster(raster, width, ...)

Resizing raster to given dimensions

gemgis.raster.save_as_tiff(raster, path, ...)

Saving a np.array as tif file

Visualization#

The following sections provide an overview of the methods implemented in the GemGIS Visualization module.

Creating PolyData and Grid Data from GeoDataFrames, Rasters, and GemPy Models#

The following methods are used to create PolyData from various input data formats.

gemgis.visualization.create_depth_map(mesh)

Extracting the depth values of the vertices and add them as scalars to the mesh

gemgis.visualization.create_depth_maps_from_gempy(...)

Creating depth map of model surfaces, adapted from https://github.com/cgre-aachen/gempy/blob/20550fffdd1ccb3c6a9a402bc162e7eed3dd7352/gempy/plot/vista.py#L440-L477

gemgis.visualization.create_thickness_maps(...)

Creating a thickness map using https://docs.pyvista.org/examples/01-filter/distance-between-surfaces.html#sphx-glr-examples-01-filter-distance-between-surfaces-py

gemgis.visualization.create_temperature_map(...)

Creating a temperature map for a surface at depth taking the topography into account

gemgis.visualization.create_delaunay_mesh_from_gdf(gdf)

Creating a delaunay triangulated mesh from surface contour lines

gemgis.visualization.create_dem_3d(dem[, ...])

Plotting the dem in 3D with PyVista

gemgis.visualization.create_lines_3d_linestrings(...)

Creating lines with z-component (LineString Z)

gemgis.visualization.create_lines_3d_polydata(gdf)

Creating lines with z-component for the plotting with PyVista

gemgis.visualization.create_mesh_from_cross_section(...)

Creating a PyVista Mesh from one cross section

gemgis.visualization.create_meshes_from_cross_sections(gdf)

Creating PyVista Meshes from multiple cross section

gemgis.visualization.create_meshes_hypocenters(gdf)

Plotting earthquake hypocenters with PyVista

gemgis.visualization.create_points_3d(gdf)

Plotting points in 3D with PyVista

gemgis.visualization.create_polydata_from_dxf(gdf)

Converting loaded DXF object to PyVista PolyData

gemgis.visualization.create_polydata_from_msh(data)

Converting loaded Leapfrog mesh to PyVista PolyData

gemgis.visualization.create_polydata_from_ts(data)

Converting loaded GoCAD mesh to PyVista PolyData

gemgis.visualization.create_structured_grid_from_asc(data)

Converting loaded ASC object to PyVista StructuredGrid

gemgis.visualization.create_structured_grid_from_zmap(data)

Converting loaded ZMAP object to PyVista StructuredGrid

Working with Boreholes#

The following methods are used to work with boreholes in GemGIS.

gemgis.visualization.add_row_to_boreholes(...)

Adding additional row to each borehole for further processing for 3D visualization

gemgis.visualization.create_borehole_labels(df)

Create labels for borehole plots.

gemgis.visualization.create_borehole_tube(df, ...)

Creating a tube from a line for the 3D visualization of boreholes

gemgis.visualization.create_borehole_tubes(df, ...)

Creating PyVista Tubes for plotting boreholes in 3D

gemgis.visualization.create_boreholes_3d(df, ...)

Plotting boreholes in 3D

gemgis.visualization.create_lines_from_points(df)

Creating a line set from a Pandas DataFrame

gemgis.visualization.create_deviated_borehole_df(...)

Creating Pandas DataFrame containing parameters to create 3D boreholes

gemgis.visualization.create_deviated_boreholes_3d(...)

Plotting boreholes in 3D

gemgis.visualization.group_borehole_dataframe(df)

Grouping Borehole DataFrame by Index

gemgis.visualization.resample_between_well_deviation_points(...)

Resampling between points that define the path of a well

gemgis.visualization.show_well_log_along_well(...)

Function to return a tube representing well log values along a well path

Miscellaneous visualization methods#

The following methods are further visualization methods used in GemGIS.

gemgis.visualization.calculate_vector(dip, ...)

Calculating the plunge vector of a borehole section

gemgis.visualization.clip_seismic_data(...)

Clipping seismic data loaded with segysak to CDP defined start and end CDP values

gemgis.visualization.convert_to_rgb(array)

Converting array values to RGB values

gemgis.visualization.drape_array_over_dem(...)

Creating grid and texture to drape array over a digital elevation model

gemgis.visualization.get_batlow_cmap()

Returning the Batlow cmap from https://github.com/callumrollo/cmcrameri/blob/master/cmcrameri/cmaps/batlow.txt

gemgis.visualization.get_color_lot(geo_model)

Method to get the right color list depending on the type of plot.

gemgis.visualization.get_mesh_geological_map(...)

Getting the geological map of a GemPy Model draped over the topography as mesh.

gemgis.visualization.get_petrel_cmap()

Returning the Petrel cmap

gemgis.visualization.get_points_along_spline(...)

Returning the closest point on the spline a given a length along a spline.

gemgis.visualization.get_seismic_cmap()

Returning the seismic cmap from https://github.com/lperozzi/Seismic_colormaps/blob/master/colormaps.py

gemgis.visualization.plane_through_hypocenters(spheres)

Fitting a plane through the hypocenters of earthquakes using Eigenvector analysis

gemgis.visualization.plot_data(geo_data[, ...])

Plotting Input Data

gemgis.visualization.plot_orientations(gdf)

Plotting orientation values of a GeoDataFrame with mplstereonet

gemgis.visualization.polyline_from_points(points)

Creating PyVista PolyLine from points

gemgis.visualization.read_raster([path, ...])

Reading a raster and returning a mesh

gemgis.visualization.seismic_to_array(...[, ...])

Converting seismic data loaded with segysak to a NumPy array

gemgis.visualization.seismic_to_mesh(...[, ...])

Converting seismic data loaded with segysak to a PyVista Mesh

Utils#

The following sections provide an overview of the methods implemented in the GemGIS Utils module.

Miscellaneous utils methods#

The following methods are further visualization methods used in GemGIS.

gemgis.utils.assign_properties(lith_block, ...)

Replacing lith block IDs with physical properties

gemgis.utils.build_style_dict(classes)

Building a style dict based on extracted style classes

gemgis.utils.parse_categorized_qml(qml_name)

Parsing a QGIS style file to retrieve surface color values

gemgis.utils.load_surface_colors(path, gdf)

Loading surface colors from a QML file and storing the color values as list to be displayed with GeoPandas plots

gemgis.utils.create_surface_color_dict(path)

Creating GemPy surface color dict from a QML file

gemgis.utils.calculate_lines(gdf, increment)

Function to interpolate strike lines

gemgis.utils.calculate_number_of_isopoints(...)

Creating the number of isopoints to further interpolate strike lines

gemgis.utils.convert_location_dict_to_gdf(...)

Converting a location dict to a GeoDataFrame

gemgis.utils.convert_to_gempy_df(gdf[, dem, ...])

Converting a GeoDataFrame into a Pandas DataFrame ready to be read in for GemPy

gemgis.utils.convert_to_petrel_points_with_attributes(...)

Function to convert vertices of a PyVista Mesh to Petrel Points with Attributes

gemgis.utils.create_polygon_from_location(...)

Creating Shapely Polygon from bounding box coordinates

gemgis.utils.create_virtual_profile(...[, ...])

Function to filter and sort the resulting well tops

gemgis.utils.create_zmap_grid(surface, ...)

Function to write data to ZMAP Grid, This code is heavily inspired by https://github.com/abduhbm/zmapio

gemgis.utils.extract_zmap_data(surface, ...)

Function to extract a meshgrid of values from a PyVista mesh

gemgis.utils.get_location_coordinate(name)

Obtaining coordinates of a given city

gemgis.utils.get_locations(names[, crs])

Obtaining coordinates for one city or a list of given cities.

gemgis.utils.get_nearest_neighbor(x, y)

Function to return the index of the nearest neighbor for a given point Y

gemgis.utils.getfeatures(extent, crs_raster, ...)

Creating a list containing a dict with keys and values to clip a raster

gemgis.utils.interpolate_strike_lines(gdf, ...)

Interpolating strike lines to calculate orientations

gemgis.utils.ray_trace_multiple_surfaces(...)

Function to return the depth of multiple surfaces in one well using PyVista ray tracing

gemgis.utils.ray_trace_one_surface(surface, ...)

Function to return the depth of one surface in one well using PyVista ray tracing

gemgis.utils.read_csv_as_gdf(path, crs[, x, ...])

Reading CSV files as GeoDataFrame

gemgis.utils.save_zmap_grid(zmap_grid[, path])

Function to save ZMAP Grid information to file

gemgis.utils.set_extent([minx, maxx, miny, ...])

Setting the extent for a model

gemgis.utils.set_resolution(x, y, z)

Setting the resolution for a model

gemgis.utils.show_number_of_data_points(...)

Adding the number of Interfaces and Orientations to the GemPy Surface dataframe

gemgis.utils.to_section_dict(gdf[, ...])

Converting custom sections stored in Shape files to GemPy section_dicts

gemgis.utils.transform_location_coordinate(...)

Transforming coordinates of GeoPy Location

Web#

The following sections provide an overview of the methods implemented in the GemGIS Web module.

gemgis.web.create_request(wcs_url, version, ...)

Creating URL to request data from WCS Server

gemgis.web.load_as_array(url, layer, style, ...)

Loading a portion of a WMS as array

gemgis.web.load_as_file(url, path[, ...])

Executing WCS request and downloading file into specified folder

gemgis.web.load_as_files(wcs_url, version, ...)

Executing WCS requests and downloading files into specified folder

gemgis.web.load_as_gpd(url[, typename, ...])

Requesting data from a WFS Service

gemgis.web.load_as_map(url, layer, style, ...)

Loading a portion of a WMS as array

gemgis.web.load_wcs(url)

Loading Web Coverage Service

gemgis.web.load_wfs(url)

Loading a WFS Service by URL

gemgis.web.load_wms(url)

Loading a WMS Service by URL

Miscellaneous#

The following sections provide an overview of the methods implemented in the GemGIS Misc module.

gemgis.misc.get_meta_data(page)

This function is used to extract the name, coordinates and depths, of one page with one well provided by the Geological Survey NRW.

gemgis.misc.get_meta_data_df(data[, name, ...])

Function to create a dataframe with coordinates and meta data of the different boreholes

gemgis.misc.get_stratigraphic_data(text, ...)

Function to retrieve the stratigraphic data from borehole logs

gemgis.misc.get_stratigraphic_data_df(data, ...)

Function to create a dataframe with coordinates and the stratigraphy of the different boreholes

gemgis.misc.load_formations(path)

Loading formations for extraction of borehole data

gemgis.misc.load_pdf(path[, save_as_txt])

Load PDF file containing borehole data.

gemgis.misc.load_symbols(path)

Loading symbols for extraction of borehole data

Postprocessing#

The following section provides an overview of the methods implemented in the GemGIS postprocessing module.

gemgis.postprocessing.calculate_dip_and_azimuth_from_mesh(mesh)

Calculating dip and azimuth values for a mesh and setting them as scalars for subsequent plotting

gemgis.postprocessing.create_attributes(...)

Creating a list of attribute dicts

gemgis.postprocessing.create_subelement(...)

Creating Subelement

gemgis.postprocessing.create_symbol(parent, ...)

Creating symbol entry

gemgis.postprocessing.crop_block_to_topography(...)

Cropping GemPy solutions block to topography

gemgis.postprocessing.extract_borehole(...)

Extracting a borehole at a provided location from a recalculated GemPy Model

gemgis.postprocessing.extract_lithologies(...)

Extracting the geological map as GeoDataFrame

gemgis.postprocessing.extract_orientations_from_mesh(...)

Extracting orientations (dip and azimuth) from PyVista Mesh

gemgis.postprocessing.save_model(geo_model, path)

Function to save the model parameters to files

gemgis.postprocessing.save_qgis_qml_file(gdf)

Creating and saving a QGIS Style File/QML File based on a GeoDataFrame

gemgis.postprocessing.clip_fault_of_gempy_model(...)

Clip fault of a GemPy model.

gemgis.postprocessing.create_plane_from_interface_and_orientation_dfs(...)

Create PyVista plane from GemPy interface and orientations DataFrames.

gemgis.postprocessing.translate_clipping_plane(...)

Translate clipping plane.

Download GemGIS Data#

The following section provides an overview of the methods implemented in the GemGIS module that downloads the tutorial data.

gemgis.download_gemgis_data.create_pooch(...)

Create pooch class to fetch files from a website.

gemgis.download_gemgis_data.download_tutorial_data(...)

Download the GemGIS data for each tutorial.