forgeo-gmlib 0.6.2__cp311-cp311-musllinux_1_2_x86_64.whl

forgeo/gmlib/tesselate_deprecated.py

@@ -0,0 +1,249 @@
+#
+# 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 copy
+
+import numpy as np
+
+import forgeo.gmlib.pypotential3D as potential
+from forgeo.gmlib.common import OrientedEvaluation
+
+try:
+    from skimage.measure import marching_cubes
+except ImportError:
+    raise
+
+try:
+    from pycgal.Polygon_mesh_processing import corefine
+    from pycgal.Surface_mesh import Surface_mesh
+except ImportError:
+    raise
+
+
+# FIXME: to be moved elsewhere
+def zmap_to_tsurf(zmap, origin, steps):
+    nx, ny = zmap.shape
+    assert nx > 1
+    assert ny > 1
+    xy = np.vstack(
+        [
+            a.ravel()
+            for a in np.meshgrid(
+                origin[0] + steps[0] * np.arange(0, nx),
+                origin[1] + steps[1] * np.arange(0, ny),
+            )
+        ]
+    )
+    vertices = np.vstack([xy, zmap.ravel(order="F")])
+    vertices = np.transpose(vertices)
+    tmp = np.hstack(
+        [
+            np.reshape(a, (-1, 1))
+            for a in [
+                np.arange(0, nx - 1),
+                np.arange(1, nx),
+                nx + np.arange(0, nx - 1),  # triangle 1
+                np.arange(1, nx),
+                nx + np.arange(1, nx),
+                nx + np.arange(0, nx - 1),  # triangle 2
+            ]
+        ]
+    )
+    triangles = np.vstack([tmp + k * nx for k in range(ny - 1)])
+    triangles.shape = (-1, 3)
+    return Surface_mesh(vertices, triangles)
+
+
+def _remove_faces_on_side(surface, side, centroid_value):
+    if side < 0:
+        removed_faces = [f for f, cv in zip(surface.faces(), centroid_value) if cv > 0]
+    else:
+        removed_faces = [f for f, cv in zip(surface.faces(), centroid_value) if cv < 0]
+    for f in removed_faces:
+        surface.remove_face(f)
+
+
+class TopographyClipper:
+    def __init__(self, field, tesselation):
+        self.field = field
+        self.tesselation = tesselation
+
+    def clip(self, surface):
+        corefine(self.tesselation, surface)
+        self.field(surface.centroids())
+        _remove_faces_on_side(surface, 1, self.field(surface.centroids()))
+        return surface
+
+
+class Tesselator:
+    def __init__(self, box, shape):
+        self.reset(box, shape)
+
+    def reset(self, box, shape):
+        assert all(n > 0 for n in shape)
+        nx, ny, nz = shape
+        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")
+        points = np.stack(coordinates, axis=-1)
+        points.shape = (-1, 3)
+        self.box = box
+        self.shape = shape
+        self.points = points
+
+    def rescale(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(f, v):
+        return self(f, v)
+
+    def __call__(self, f, v):
+        field_value = f(self.points)
+        field_value.shape = self.shape
+        isocontour = marching_cubes(field_value, level=v)
+        verts, faces, _normals, _values = isocontour
+        verts = self.rescale(verts)
+        return Surface_mesh(verts, faces)
+
+    def tesselate_topography(self, model):
+        assert model.topography is not None
+        topography = model.topography
+        zmap = topography.z
+        if hasattr(zmap, "shape"):
+            return zmap_to_tsurf(zmap, topography.origin, topography.steps)
+        return self(topography, 0)
+
+    def tesselate_faults(self, model, topography=None):
+        fault_tesselations = {
+            name: self(field, 0) for name, field in model.faults.items()
+        }
+        for name, surface in fault_tesselations.items():
+            if topography:
+                surface = topography.clip(surface)
+            data = model.faults_data[name]
+            assert len(data.potential_data.interfaces) == 1
+            fault_points = data.potential_data.interfaces[0]
+            for limit_name in data.stops_on:
+                try:
+                    limit_surface = fault_tesselations[limit_name]
+                    corefine(surface, limit_surface)
+                    limit_fault = model.faults[limit_name]
+                    _remove_faces_on_side(
+                        surface,
+                        np.mean(limit_fault(fault_points)),
+                        limit_fault(surface.centroids()),
+                    )
+                except KeyError:
+                    pass
+        return fault_tesselations
+
+    def tesselate_interfaces(self, model, topography=None):
+        fault_tesselations = self.tesselate_faults(model, topography)
+        interface_tesselations = {}
+        for serie in model.series_info:
+            sinfo = model.series_info[serie]
+            serie_faults_names = list(sinfo.active_faults)
+            serie_faults = [model.faults[name] for name in serie_faults_names]
+            faults_limits = [
+                [
+                    serie_faults_names.index(limit)
+                    for limit in model.faults_data[name].stops_on
+                ]
+                for name in serie_faults_names
+            ]
+            fault_network = gmlib.fault_network.build(serie_faults, faults_limits)
+            # for interface in sinfo.interfaces:
+            #    name, _ = interface
+            #    interface_tesselations[name] = []
+            if fault_network is not None:
+                nodes, _roots, evaluations = fault_network
+                node_tesselation = [
+                    fault_tesselations[fault] for fault in serie_faults_names
+                ]
+                # fault drift indexes
+                fdi = [sinfo.active_faults[fault] for fault in serie_faults_names]
+                interface_patches = {name: [] for name, _ in sinfo.interfaces}
+                for evaluation in evaluations:
+                    drifts = copy.copy(sinfo.drifts)
+                    for fk, side in enumerate(evaluation):
+                        if side > 0:
+                            orientation = OrientedEvaluation.always_positive
+                        elif side < 0:
+                            orientation = OrientedEvaluation.always_negative
+                        else:
+                            assert side == 0
+                            orientation = OrientedEvaluation.always_outside
+                        drifts[fdi[fk]] = potential.make_drift(
+                            nodes[fk].fault, orientation
+                        )
+                    S = potential.alternate_drifts(sinfo.field, drifts)
+                    for interface in sinfo.interfaces:
+                        interface_name, interface_value = interface
+                        patch_tesselation = self(S, interface_value)
+                        if topography:
+                            topography.clip(patch_tesselation)
+                        for fk, side in enumerate(evaluation):
+                            if side != 0:
+                                corefine(patch_tesselation, node_tesselation[fk])
+                                nk = nodes[fk]
+                                _remove_faces_on_side(
+                                    patch_tesselation,
+                                    side,
+                                    nk.fault(patch_tesselation.centroids()),
+                                )
+                        interface_patches[interface_name].append(patch_tesselation)
+                for interface_name, patches in interface_patches.items():
+                    assert patches
+                    tesselation = Surface_mesh(patches[0])
+                    for patch in patches[1:]:
+                        tesselation.join(patch)
+                    interface_tesselations[interface_name] = tesselation
+            else:  # serie is not affected by faults
+                for interface in sinfo.interfaces:
+                    interface_name, interface_value = interface
+                    tesselation = self(sinfo.field, interface_value)
+                    if topography:
+                        topography.clip(tesselation)
+                    interface_tesselations[interface_name] = tesselation
+        return fault_tesselations, interface_tesselations
+
+
+def tesselate_topography(box, shape, model):
+    return Tesselator(box, shape).tesselate_topography(model)
+
+
+def tesselate_faults(box, shape, model, clip_topography=True):
+    tesselator = Tesselator(box, shape)
+    topography = (
+        TopographyClipper(model.topography, tesselator.tesselate_topography(model))
+        if clip_topography
+        else None
+    )
+    return tesselator.tesselate_faults(model, topography)
+
+
+def tesselate_interfaces(box, shape, model, clip_topography=True):
+    tesselator = Tesselator(box, shape)
+    topography = (
+        TopographyClipper(model.topography, tesselator.tesselate_topography(model))
+        if clip_topography
+        else None
+    )
+    faults, interfaces = tesselator.tesselate_interfaces(model, topography)
+    if topography:
+        assert "topography" not in interfaces
+        interfaces["topography"] = topography.tesselation
+    return faults, interfaces

forgeo/gmlib/topography_reader.py

@@ -0,0 +1,198 @@
+#
+# 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
+
+import numpy as np
+
+from .utils.tools import BBox3
+
+
+class ImplicitElevationSurface:
+    def __call__(self, P):
+        P = np.reshape(np.asarray(P), (-1, 3))
+        res = P[:, 2] - self.evaluate_z(P[:, :2])
+        assert res.shape[0] > 0
+        if res.shape[0] == 1:
+            return res[0]
+        return res
+
+    def underlying_dtm(self):
+        return None
+
+
+class ImplicitHorizontalPlane(ImplicitElevationSurface):
+    def __init__(self, zvalue):
+        self.z = float(zvalue)
+
+    def evaluate_z(self, P):
+        P = np.reshape(np.asarray(P), (-1, 2))
+        assert P.shape[0] > 0
+        if P.shape[0] == 1:
+            return self.z
+        return np.tile(self.z, P.shape[0])
+
+    def bbox(self):
+        return BBox3(zmin=self.z, zmax=self.z)
+
+
+class ImplicitDTM(ImplicitElevationSurface):
+    def __init__(self, origin, steps, zmap):
+        self.origin = np.array(origin, dtype="d")
+        assert self.origin.shape == (2,)
+        self.steps = np.array(steps, copy=True, dtype="d")
+        self.invsteps = np.array([(1.0 / ds) for ds in steps], dtype="d")
+        assert self.invsteps.shape == (2,)
+        self.z = np.array(zmap, copy=True, dtype="d")
+
+    def bbox(self):
+        Ox, Oy = self.origin
+        ny, nx = self.z.shape
+        dx, dy = self.steps
+        return BBox3(Ox, Ox + nx * dx, Oy, Oy + ny * dy, self.z.min(), self.z.max())
+
+    def in_square_interpolation(self, P):
+        P = np.asarray(P, dtype="d")
+        assert P.shape == (2,)
+        DX = P - self.origin
+        DX *= self.invsteps
+        DX[DX < 0] = 0
+        i, j = DX
+        zmap = self.z
+        nx, ny = zmap.shape
+        i = min(i, nx - 1)
+        j = min(j, ny - 1)
+        ii, ij = int(i), int(j)
+        i -= ii
+        j -= ij
+        if j == 0:
+            if i == 0:
+                return zmap[ii, ij]
+            zl, zr = zmap[ii : ii + 2, ij]
+            return (1 - i) * zl + i * zr
+        if i == 0:
+            zl, zr = zmap[ii, ij : ij + 2]
+            return (1 - j) * zl + j * zr
+        # We divide the square into two triangles
+        # to be consistent with the DTM 3D representation
+        # and possible topography clipping
+        assert 0 < i < 1
+        assert 0 < j < 1
+        if i + j <= 1:  # lower triangle
+            z = (1 - i - j) * zmap[ii, ij]
+            z += i * zmap[ii + 1, ij]
+            z += j * zmap[ii, ij + 1]
+        else:  # upper triangle
+            z = (i + j - 1) * zmap[ii + 1, ij + 1]
+            z += (1 - i) * zmap[ii, ij + 1]
+            z += (1 - j) * zmap[ii + 1, ij]
+        return z
+        raise AssertionError()
+
+    def underlying_dtm(self):
+        zmap = self.z
+        nx, ny = zmap.shape
+        dx, dy = self.steps
+        x = np.arange(0, nx * dx, dx) + self.origin[0]
+        y = np.arange(0, ny * dy, dy) + self.origin[1]
+        xy = np.meshgrid(x, y, indexing="ij")
+        vertices = np.empty((nx * ny, 3), dtype=zmap.dtype)
+        for i, xi in enumerate(xy):
+            vertices[:, i] = xi.ravel()
+        vertices[:, -1] = zmap.ravel()
+        # Two triangles in the lower left cell
+        llc = np.array([[0, ny, 1], [ny, ny + 1, 1]], dtype=np.int64)
+        # Triangles stip on the left side
+        strip = np.vstack([llc + k for k in range(ny - 1)])
+        triangles = np.vstack([strip + ny * k for k in range(nx - 1)])
+        return vertices, triangles
+
+    def evaluate_z(self, P):
+        P = np.reshape(np.asarray(P), (-1, 2))
+        res = np.array([self.in_square_interpolation(xy) for xy in P])
+        try:
+            return float(res)
+        except TypeError:
+            pass
+        return res
+
+
+def extract_plane(f):
+    # we already have read the code character (first character on the line)
+    l = f.readline().strip().split()
+    point = tuple(float(s) for s in l[:3])
+    normal = tuple(float(s) for s in l[3:6])
+    #    ux = tuple(float(s) for s in l[6:9])
+    #    uy = tuple(float(s) for s in l[9:]:)
+    return point, normal
+
+
+def extract_mnt(f, decimals=8):
+    # we already have read the code character (first character on the line)
+    l = f.readline().strip().split()
+    nx, ny = (int(s) for s in l[6:8])
+    assert int(l[8]) + 2 == nx
+    assert int(l[9]) + 2 == ny
+    zmap = []
+    line = l[10:]
+    while line:
+        zmap.append(np.array([float(s) for s in line]))
+        line = f.readline().strip().split()
+    zmap = np.array(zmap)
+    x, y, z = (zmap[:, k::3] for k in range(3))
+
+    def clean(a):
+        a = np.delete(a, [1, nx - 2], axis=0)
+        return np.delete(a, [1, ny - 2], axis=1)
+
+    x, y, z = (clean(a) for a in (x, y, z))
+    dx = np.unique(np.round(x[1:, :] - x[:-1, :], decimals))
+    assert dx.shape == (1,)
+    dy = np.unique(np.round(y[:, 1:] - y[:, :-1], decimals))
+    assert dy.shape == (1,)
+    xmin, ymin = x.min(), y.min()
+    return (xmin, ymin), (float(dx), float(dy)), z
+
+
+def sec_extract(filename):
+    if os.path.exists(filename):
+        with open(filename) as f:
+            line = f.readline()
+            while not line.startswith("Surfaces"):
+                line = f.readline()
+            code = int(f.read(1))
+            if code == 1:
+                point, normal = extract_plane(f)
+                assert normal[0] == 0
+                assert normal[1] == 0
+                return ImplicitHorizontalPlane(point[2])
+            if code == 9:
+                return ImplicitDTM(*extract_mnt(f))
+    raise OSError(filename + " not found")
+
+
+if __name__ == "__main__":
+    from matplotlib import pyplot as plt
+
+    zmap = np.array([[0, 1], [0, 2]])
+    origin = (1, 1)
+    steps = (2, 2)
+    dtm = ImplicitDTM(origin, steps, zmap)
+    nx, ny = 20, 20
+    xmin, xmax = 0, 4
+    ymin, ymax = 0, 4
+    xy = np.meshgrid(np.linspace(xmin, xmax, nx), np.linspace(ymin, ymax, ny))
+    x, y = (a.ravel() for a in xy)
+    z = np.array([dtm.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)
+    O = origin
+    d = steps
+    cell = np.array(
+        [O, (O[0] + d[0], O[0]), (O[0] + d[0], O[0] + d[1]), (O[0], O[0] + d[1]), O]
+    )
+    plt.plot(cell[:, 0], cell[:, 1], "r")