forgeo-gmlib 0.6.2__cp314-cp314t-musllinux_1_2_x86_64.whl

forgeo/gmlib/geomodeller_project.py

@@ -0,0 +1,396 @@
+#
+# This file is part of gmlib. It is free software.
+# You can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3.
+#
+
+
+import os
+from collections import namedtuple
+
+import numpy as np
+from lxml.builder import ElementMaker
+
+from forgeo.gmlib import myxmltools as mx
+from forgeo.gmlib import topography_reader
+from forgeo.gmlib.geomodeller_data import (
+    CovarianceModel,
+    FaultData,
+    GradientData,
+    Pile,
+    PotentialData,
+    SeriesData,
+)
+
+Formation = namedtuple("Formation", ["name", "color", "is_dummy"])
+GmlCoord = namedtuple("GmlCoord", ["x", "y", "z"])
+DrillHole = namedtuple("DrillHole", ["name", "total_depth", "collar"])
+
+# FIXME: this sould not be static
+nsmap = {"geo": "http://www.geomodeller.com/geo", "gml": "http://www.opengis.net/gml"}
+geo = ElementMaker(namespace=nsmap["geo"])
+gml = ElementMaker(namespace=nsmap["gml"])
+
+
+def extract_coord(node, tag):
+    pts = []
+    coords = node.find(tag)
+    if coords is not None:
+        for coord in coords:
+            P = GmlCoord(
+                *tuple(
+                    np.double(coord.find(axis).text)
+                    for axis in (gml.X().tag, gml.Y().tag, gml.Z().tag)
+                )
+            )
+            pts.append(P)
+    return pts
+
+
+def extract_crs(xml_root):
+    assert xml_root.tag == geo.Project3DEdit().tag
+    try:
+        gmcrs = xml_root.attrib["CoordSystem"]
+    except KeyError:
+        gmcrs = None
+    try:
+        qgiscrs = xml_root.attrib["QGisCRS"]
+    except KeyError:
+        qgiscrs = None
+    return gmcrs, qgiscrs
+
+
+def read_box(xml_root):
+    extent = xml_root.find(geo.Extent3DOfProject().tag)
+    extentbox = extent.find(geo.ExtentBox3D().tag)
+    extent3D = extentbox.find(geo.Extent3D().tag)
+    xy = extent3D.find(geo.ExtentXY().tag)
+    limits = {}
+    for s, val in xy.items():
+        limits[s] = float(val)
+    z = extent3D.find(geo.ExtentZ().tag)
+    for s, val in z.items():
+        limits[s] = float(val)
+    return limits
+
+
+def read_color(root):
+    color = None
+    graphic = root.find(geo.Graphic().tag)
+    if graphic is not None:
+        shading = graphic.find(geo.ColorShading().tag)
+        color = tuple(
+            int(shading.attrib[name]) / 255.0  # convert to float RGB
+            for name in ("Red", "Green", "Blue")
+        )
+    return color
+
+
+def read_formations(xml_root):
+    formations = xml_root.find(geo.Formations().tag)
+    result = []
+
+    def extract_formation(formation, is_dummy=False):
+        name = formation.attrib["Name"]
+        color = read_color(formation)
+        return Formation(name, color, is_dummy)
+
+    if formations is not None:
+        for formation in formations.findall(geo.Formation().tag):
+            result.append(extract_formation(formation))
+        for formation in formations.findall(geo.DummyFormation().tag):
+            result.append(extract_formation(formation, True))
+    return result
+
+
+def find_topography_sections(xml_root):
+    topography_sections = []
+    sections = xml_root.find(geo.Sections().tag)
+    if sections is not None:
+        for section in sections.findall(geo.Section().tag):
+            if "IsTopography" in section:
+                if section.attrib["IsTopography"] == "true":
+                    topography_sections.append(section)
+    return topography_sections
+
+
+def extract_drillholes(xml_root):
+    drillholes = []
+    dhs = xml_root.find(geo.DrillHoles().tag)
+    if dhs is not None:
+        for dh in dhs.findall(geo.DrillholeWithFields().tag):
+            name = dh.attrib["Name"]
+            total_depth = float(dh.attrib["TotalDepth"])
+            collar_pos = extract_coord(dh, geo.Collar().tag)
+            assert len(collar_pos) == 1
+            drillholes.append(DrillHole(name, total_depth, collar_pos[0]))
+    return drillholes
+
+
+def read_topography_info(xml_root):
+    topography_sections = find_topography_sections(xml_root)
+    if not topography_sections:
+        return None
+    assert len(topography_sections) == 1  # only one topography section!!!
+    section = topography_sections[0]
+    shape = section.find(geo.Shape3DOfSection().tag)
+    return section.attrib["Name"], shape.attrib["FileName"]
+
+
+def read_data(xml_root):
+    data = xml_root.findall(geo.Data().tag)
+    return [d.attrib["Name"] for d in data]
+
+
+def read_potential_data(xml_root, box, scalardt, maximum_number_of_interfaces=None):
+    field = xml_root.find(geo.PotentialField().tag)
+    if field is None:
+        return None
+    glocs = []
+    gvals = []
+    interfaces = []
+    covariance_model = CovarianceModel(field.find(geo.covariance().tag), box)
+    constraints = field.find(geo.Constraints().tag)
+    if constraints is not None:
+        if any(constraint.attrib["value"] != "0" for constraint in constraints):
+            mess = "inequality constraints are not handled for now"
+            raise NotImplementedError(mess)
+    gradients = field.find(geo.Gradients().tag)
+    if gradients is not None:
+        for gradient in gradients.iterfind(geo.Gradient().tag):
+            V = tuple(scalardt.type(gradient.attrib[s]) for s in ("Gx", "Gy", "Gz"))
+            gvals.append(V)
+            P = tuple(scalardt.type(gradient.attrib[s]) for s in ("XGr", "YGr", "ZGr"))
+            glocs.append(P)
+    pts = extract_coord(field, geo.Points().tag)
+    interface_points = field.find(geo.InterfacePoints().tag)
+    for interface in interface_points:
+
+        def attr_as_int(s):
+            return int(interface.attrib[s])
+
+        interfaces.append((attr_as_int("pnt"), attr_as_int("npnt")))
+    if maximum_number_of_interfaces is not None:
+        assert len(interfaces) >= maximum_number_of_interfaces, (
+            "Not enough interfaces read."
+        )
+        del interfaces[maximum_number_of_interfaces:]
+
+    def array_of_scalars(v):
+        return np.array(v, dtype=scalardt)
+
+    potdata = PotentialData()
+    potdata.covariance_model = covariance_model
+    potdata.gradients = GradientData(array_of_scalars(glocs), array_of_scalars(gvals))
+    pts = array_of_scalars(pts)
+    potdata.interfaces = [pts[start : start + nb] for start, nb in interfaces]
+    return potdata
+
+
+def extract_raw_faults_data(root, scalardt):
+    faults_data = {}
+    faults = root.find(geo.Faults().tag)
+    if faults is not None:
+        for fault in faults.findall(geo.Fault().tag):
+            data = FaultData(fault.attrib["Name"])
+            geology = fault.find(geo.FaultGeology().tag).attrib
+            if int(geology["FAULT_TYPE"]) == 1:  # finite fault
+                data.infinite = False
+                data.center_type = None
+                center_type = geology["CENTER_TYPE"]
+                if center_type == "0":
+                    data.center_type = "mean_center"
+                elif center_type == "1":
+                    data.center_type = "databox_center"
+                else:
+                    assert center_type == "2"
+                    data.center_type = (
+                        scalardt.type(geology["CENTERX"]),
+                        scalardt.type(geology["CENTERY"]),
+                        scalardt.type(geology["CENTERZ"]),
+                    )
+                data.lateral_extent = scalardt.type(geology["LATERAL_EXTENT"])
+                data.vertical_extent = scalardt.type(geology["VERTICAL_EXTENT"])
+                data.influence_radius = scalardt.type(geology["RADIUS_OF_INFLUENCE"])
+            for other in fault.iterfind(geo.StopsOnFault().tag):
+                data.stops_on.append(other.attrib["Name"])
+            data.color = read_color(fault)
+            faults_data[data.name] = data
+    return faults_data
+
+
+def read_modeled_faults_data(root, box, scalardt):
+    faults_data = extract_raw_faults_data(root, scalardt)
+    if faults_data:
+        model = root.find(geo.GeologicalModel().tag)
+        if model is not None:
+            modelfaults = model.find(geo.ModelFaults().tag)
+            if modelfaults is not None:
+                faultpotentials = modelfaults.findall(geo.PotentialFault().tag)
+                for fault in faultpotentials:
+                    data = read_data(fault)
+                    assert len(data) == 1
+                    name = data[0]
+                    potdata = read_potential_data(fault, box, scalardt)
+                    faults_data[name].potential_data = potdata
+    deleted_faults = [
+        name for name, data in faults_data.items() if data.potential_data is None
+    ]
+    for name in deleted_faults:
+        del faults_data[name]
+    return faults_data
+
+
+def read_pile(root, box, scalardt):
+    pile = None
+    model = root.find(geo.GeologicalModel().tag)
+    if model is not None:
+        project_column = model.find(geo.ProjectStratigraphicColumn().tag)
+        #   modelseries = model.find(geo.ModelStratigraphicColumn().tag)
+        #   for serie in modelseries:
+        #       modelseries.find('geo:Data',ns)
+        #       name = serie.attrib['Name']
+        #       print (name)
+
+        reference = {"true": "base", "false": "top"}[project_column.attrib["IsBase"]]
+        pile = Pile(reference)
+        all_series = []
+        for serie in project_column:
+            # read data
+            name = serie.attrib["name"]
+            serie_data = SeriesData(name)
+            serie_data.relation = {"1": "onlap", "2": "erode"}[serie.attrib["relation"]]
+            serie_data.formations = read_data(serie)
+            all_influencing_faults = serie.findall(geo.InfluencedByFault().tag)
+            influenced_by_fault = [f.attrib["Name"] for f in all_influencing_faults]
+            if influenced_by_fault:
+                serie_data.influenced_by_fault = influenced_by_fault
+            serie_data.potential_data = read_potential_data(serie, box, scalardt)
+            if serie_data.potential_data is not None:
+                if len(serie_data.potential_data.interfaces) > len(
+                    serie_data.formations
+                ):
+                    if len(serie_data.formations) == 1:
+                        pass
+                    else:
+                        pass
+                    serie_data.potential_data = read_potential_data(
+                        serie, box, scalardt, len(serie_data.formations)
+                    )
+            assert serie_data.potential_data is None or len(
+                serie_data.potential_data.interfaces
+            ) == len(serie_data.formations), f"Inconsitent {name} series."
+            all_series.append(serie_data)
+        model_column = model.find(geo.ModelStratigraphicColumn().tag)
+        if model_column is not None:
+            selection = [data.attrib["Name"] for data in model_column]
+            series_selection = [
+                serie for serie in all_series if serie.name in selection
+            ]
+            for ref, loc in (("base", 0), ("top", -1)):
+                if pile.reference == ref:
+                    dummy_serie = all_series[loc]
+                    if (
+                        dummy_serie.name not in selection
+                        and dummy_serie.potential_data is None
+                    ):
+                        series_selection.insert(loc, dummy_serie)
+            all_series = series_selection
+        pile.all_series = all_series
+    return pile
+
+
+def extract_tree(filepath):
+    if os.path.islink(filepath):
+        filepath = os.readlink(filepath)
+    filepath = os.path.realpath(filepath)
+    tree = mx.parse(filepath)
+    root = tree.getroot()
+    for ns, uri in nsmap.items():
+        assert ns in root.nsmap
+        assert root.nsmap[ns] == uri
+    return tree
+
+
+def extract_project_data(filepath, scalardt=np.dtype("d"), skip_topography=False):
+    root = extract_tree(filepath).getroot()
+    crs = extract_crs(root)
+    box = read_box(root)
+    faults_data = read_modeled_faults_data(root, box, scalardt)
+    pile = read_pile(root, box, scalardt)
+    topography_info = None if skip_topography else read_topography_info(root)
+    if topography_info is None:
+        topography = topography_reader.ImplicitHorizontalPlane(box["Zmax"])
+    else:
+        _name, filename = topography_info
+        project_directory = os.path.split(filepath)[0]
+        topography = topography_reader.sec_extract(
+            os.path.join(project_directory, filename)
+        )
+    formations = read_formations(root)
+    return {
+        "box": box,
+        "crs": crs,
+        "pile": pile,
+        "faults_data": faults_data,
+        "topography": topography,
+        "formations": formations,
+    }
+
+
+def extract_project_drillholes(filepath):
+    root = extract_tree(filepath).getroot()
+    return extract_drillholes(root)
+
+
+def make_center(aSerie, xmin, xmax, ymin, ymax, zmin, zmax):
+    cx = (xmin + xmax) / 2
+    cy = (ymin + ymax) / 2
+    cz = (zmin + zmax) / 2
+    Themax = xmax - xmin
+    pts = aSerie.potential_data.interfaces.points
+    # interfaces
+    for p in pts:
+        x = 0.5 + (p[0] - cx) / Themax
+        y = 0.5 + (p[1] - cy) / Themax
+        z = 0.5 + (p[2] - cz) / Themax
+        p[0] = x
+        p[1] = y
+        p[2] = z
+
+    gpts = aSerie.potential_data.gradients.locations
+    # gradients
+    for p in gpts:
+        x = 0.5 + (p[0] - cx) / Themax
+        y = 0.5 + (p[1] - cy) / Themax
+        z = 0.5 + (p[2] - cz) / Themax
+        p[0] = x
+        p[1] = y
+        p[2] = z
+
+    cov = aSerie.potential_data.covariance_model
+    cov.range = cov.range / Themax
+
+
+if __name__ == "__main__":
+    import sys
+
+    from matplotlib import pyplot as plt
+
+    if len(sys.argv) > 1:
+        projectfile = sys.argv[1]
+        if os.path.exists(projectfile):
+            assert not os.path.islink(projectfile)
+            data = extract_project_data(projectfile)
+            box, pile, faults_data, topography, fcolors = data
+            nx, ny = 200, 200
+            xmin, xmax = box["Xmin"], box["Xmax"]
+            ymin, ymax = box["Ymin"], box["Ymax"]
+            xy = np.meshgrid(
+                np.linspace(xmin, xmax, nx), np.linspace(ymin, ymax, ny), indexing="ij"
+            )
+            x, y = (a.ravel() for a in xy)
+            z = np.array([topography.evaluate_z((xi, yi)) for xi, yi in zip(x, y)])
+            z.shape = nx, ny
+            plt.gca().set_aspect("equal")
+            box = (xmin, xmax, ymin, ymax)
+            plt.imshow(np.transpose(z)[::-1], extent=box)

forgeo/gmlib/myxmltools.py

@@ -0,0 +1,30 @@
+#
+# This file is part of gmlib. It is free software.
+# You can redistribute it and/or modify it under the terms of the GNU Affero General Public License version 3.
+#
+
+"""
+Created on Mon Jul 18 12:12:46 2016
+
+@author: lopez
+"""
+
+import os
+
+from lxml import etree
+
+
+def parse(filename):
+    assert os.path.exists(filename)
+    # cf. https://lxml.de/FAQ.html#why-doesn-t-the-pretty-print-option-reformat-my-xml-output
+    parser = etree.XMLParser(remove_blank_text=True)
+    return etree.parse(filename, parser)
+
+
+def create_child_if_needed(parent, tag):
+    """The parent namespace will be used."""
+    qname = etree.QName(etree.QName(parent).namespace, tag)
+    child = parent.find(qname)
+    if child is None:
+        child = etree.SubElement(parent, qname)
+    return child

forgeo/gmlib/tesselate.py

@@ -0,0 +1,236 @@
+import contextlib
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+from pycgal.Polygon_mesh_processing import (
+    border_halfedges,
+    connected_components,
+    extract_zmap_corners_and_borders,
+    isotropic_remeshing,
+    remove_connected_components,
+    split,
+    split_long_edges,
+    triangulate_faces,
+)
+from pycgal.Surface_mesh import Edges, Surface_mesh
+from skimage.measure import marching_cubes
+
+from .GeologicalModel3D import GeologicalModel
+
+
+def _remove_unvalid_side(S, limit, valid_side):
+    connected_components(S, "f:component")
+    components = S.face_property("f:component")
+    values = set()
+    faces = []
+    for f in S.faces():
+        compf = components[f]
+        if compf not in values:
+            values.add(compf)
+            face_center = np.array(S.centroid(f), copy=False)[None, :]
+            if valid_side * limit(face_center) <= 0:
+                faces.append(f)
+    remove_connected_components(S, faces)
+
+
+def _split_border_edges(S, ds2):
+    """
+    Check that border edges are compliant for isotropic remeshing.
+    """
+    border_edges = Edges(S, border_halfedges(S))
+    split_long_edges(S, (4 / 3) * ds2, border_edges)
+
+
+def _tesselate_horizontal_plane(box, z, target_squared_edge=None):
+    if box.zmin > z or box.zmax < z:
+        return Surface_mesh()
+    vertices = np.array(
+        [
+            (box.xmin, box.ymin, box.zmax),
+            (box.xmax, box.ymin, box.zmax),
+            (box.xmax, box.ymax, box.zmax),
+            (box.xmin, box.ymax, box.zmax),
+        ]
+    )
+    square = np.array([[0, 1, 2, 3]])
+    mesh = Surface_mesh(vertices, square)
+    corners, _borders = extract_zmap_corners_and_borders(mesh)
+    assert len(corners) == 4
+    triangulate_faces(mesh)
+    if target_squared_edge:
+        isotropic_remeshing(mesh, target_squared_edge, constrained_vertices=corners)
+    return mesh
+
+
+class FaultTesselator:
+    def __init__(self, box, shape, model):
+        self.shape = nx, ny, nz = shape
+        self.ds2 = min(
+            (box.xmax - box.xmin) / nx,
+            (box.ymax - box.ymin) / ny,
+            (box.zmax - box.zmin) / nz,
+        )
+        steps = (
+            np.linspace(box.xmin, box.xmax, nx),
+            np.linspace(box.ymin, box.ymax, ny),
+            np.linspace(box.zmin, box.zmax, nz),
+        )
+        coordinates = np.meshgrid(*steps, indexing="ij")
+        grid_points = np.stack(coordinates, axis=-1)
+        grid_points.shape = (-1, 3)
+        self.model = model
+        self.box = box
+        self.grid_points = grid_points
+        self.fault_surfaces = None
+        self.tesselate()
+
+    def rescale_into_box(self, pts):
+        box = self.box
+        nx, ny, nz = self.shape
+        return pts * np.array(
+            [
+                (box.xmax - box.xmin) / (nx - 1),
+                (box.ymax - box.ymin) / (ny - 1),
+                (box.zmax - box.zmin) / (nz - 1),
+            ]
+        ) + np.array([box.xmin, box.ymin, box.zmin])
+
+    def tesselate_functor(self, f, target_level=0):
+        """Will tesellate the target_level isolevel surface of the scalar functor f
+        using the discretization parameters of the self instance (grid_points, ds2...).
+        :param target_level: defaults to 0
+        """
+        field_value = f(self.grid_points)
+        if np.all(field_value < target_level) or np.all(field_value > target_level):
+            return Surface_mesh()
+        field_value.shape = self.shape
+        isocontour = marching_cubes(field_value, level=target_level)
+        vertices, faces, *_ = isocontour
+        vertices = self.rescale_into_box(vertices)
+        S = Surface_mesh(vertices, faces)
+        _split_border_edges(S, self.ds2)
+        isotropic_remeshing(S, self.ds2, do_project=True, protect_constraints=True)
+        return S
+
+    def sort_faults(self):
+        """
+        Will sort faults from the most subordinated to the major ones.
+        There is only a partial order relation between faults.
+        """
+        # find the faults that a given fault limits (reverse of stops on)
+        fault_limits = defaultdict(set)
+        model = self.model
+        for name, fault_data in model.faults_data.items():
+            fault_limits[name].update(set())
+            for limit in fault_data.stops_on:
+                fault_limits[limit].add(name)
+        sorted_faults = []
+        faults = set(model.faults.keys())
+        while len(faults) > 0:
+            subordinated_faults = {
+                fault for fault, limits in fault_limits.items() if len(limits) == 0
+            }
+            for limits in fault_limits.values():
+                limits -= subordinated_faults
+            for fault in subordinated_faults:
+                fault_limits.pop(fault)
+            sorted_faults.extend(subordinated_faults)
+            faults -= subordinated_faults
+        return sorted_faults
+
+    def tesselate_topography(self):
+        model = self.model
+        # Retrieve the exact DTM
+        # topography = Surface_mesh(*model.topography.underlying_dtm())
+        # or use a topography approximation
+        try:
+            z_plane = model.topography.z
+        except AttributeError:
+            z_plane = None
+        if type(z_plane) is float:
+            topography = _tesselate_horizontal_plane(self.box, z_plane, self.ds2)
+        else:
+            topography = self.tesselate_functor(model.topography)
+        self.topography = topography
+
+    def tesselate(self):
+        self.tesselate_topography()
+        topography = self.topography
+        model = self.model
+
+        fault_surfaces = {}
+
+        for name, field in model.faults.items():
+            fault_surfaces[name] = self.tesselate_functor(field)
+
+        for name in self.sort_faults():
+            fault_data = model.faults_data[name]
+            S = fault_surfaces[name]
+            if S.is_empty():
+                continue
+            points = fault_data.potential_data.interfaces[0]
+            # Clip with topography
+            split(S, topography)
+            # FIXME: as defined here the depth functor maybe inaccurate
+            #        we should project the point onto the tesselated DTM surface
+            _remove_unvalid_side(S, model.topography, -1)
+            # Clip with limiting faults
+            for limit in fault_data.stops_on:
+                FL = model.faults[limit]
+                SL = fault_surfaces[limit]
+                if SL.is_empty():
+                    continue
+                split(S, SL)
+                _remove_unvalid_side(S, FL, np.mean(FL(points)))
+            # Clip finite faults at the end
+            # that makes that the *infinite extension of finite faults*
+            # can limit other faults
+            if not fault_data.infinite:
+                assert model.is_finite_fault(name)
+                ellipsoid = model.fault_ellipsoids[name]
+                E = self.tesselate_functor(ellipsoid)
+                if not E.is_empty():
+                    split(S, E)
+                    _remove_unvalid_side(S, ellipsoid, -1)
+
+        self.fault_surfaces = fault_surfaces
+
+
+def tesselate_faults(box, shape, model, with_topography=False):
+    tesselator = FaultTesselator(box, shape, model)
+    if with_topography:
+        return tesselator.fault_surfaces, tesselator.topography
+    return tesselator.fault_surfaces
+
+
+if __name__ == "__main__":
+    import sys
+
+    filepath = Path(sys.argv[1])
+    if filepath.exists():
+        model = GeologicalModel(str(filepath.absolute()))
+    else:
+        msg = f"{filepath} not found!"
+        raise OSError(msg)
+
+    shape = (20,) * 3
+    fault_surfaces, topography = tesselate_faults(
+        model.getbox(), shape, model, with_topography=True
+    )
+
+    vtkw = None
+    with contextlib.suppress(ModuleNotFoundError):
+        import vtkwriters as vtkw
+
+    if vtkw is not None:
+
+        def to_vtu(S, name):
+            if S.number_of_faces() == 0:
+                return
+            v, t = S.as_arrays()
+            vtkw.write_vtu(vtkw.vtu_doc(v, t[0]), f"{name}.vtu")
+
+        to_vtu(topography, f"{filepath.stem}_topography")
+        for name, S in fault_surfaces.items():
+            to_vtu(S, f"{filepath.stem}_fault_surface_{name}")