pygcd 0.3__py2.py3-none-any.whl

pygcd/__init__.py

@@ -0,0 +1,21 @@
+try:
+    from .__version__ import __version__, __version_tuple__, version, version_tuple
+except ImportError:
+    __version__ = version = None
+    __version_tuple__ = version_tuple = ()
+
+from .dataset import Dataset
+from .drivers import Drivers, to_geopandas, to_pyvista
+from .objects import Chunk, Geometry, Grid, Mesh, Well, decode
+
+find = Dataset.find
+load = Dataset.load
+read = Dataset.read
+
+
+def getCapabilities():
+    return list(Geometry.names)
+
+
+def getWrappers():
+    return list(Drivers.keys())

pygcd/__version__.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.3'
+__version_tuple__ = version_tuple = (0, 3)

pygcd/dataset.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from copy import copy
+from pathlib import Path
+from typing import Any
+
+from .drivers import Drivers
+from .objects import Chunk, Geometry, Object, decode
+from .readers import find_objects
+
+
+class Dataset(list):
+    """Container for GOCAD objects.
+
+    Each GOCAD project file is composed of (multiple) object(s).
+    All objects have a common structured header with general
+    properties (i.e. name, geometry type, version, ...).
+    These objects can be meshes, grids or wells ...
+    their geometry needs to be decoded accordingly !
+
+    A project file is read as follow:
+    - `find`: split objects (block parsing based on "GOCAD ... END" regex)
+    - `load`: identify object (parse headers, register {name, geometry, properties})
+    - `read`: extract the geometry (decode meshes/grids/wells structure and data)
+
+    Args:
+        filename (str): The file to read.
+            *! Only ASCII exports are currently supported !*
+    """
+
+    def __init__(self, obj=None, filename="") -> None:
+        super().__init__()
+        self.filename = filename
+        if isinstance(obj, Dataset):
+            self = copy(obj)
+        elif isinstance(obj, list):
+            for e in filter(None, obj):
+                self.append(copy(e))
+
+    def __getitem__(self, key) -> Chunk | Object:
+        if isinstance(key, str):
+            return self[self.names.index(key)]
+        else:
+            return super().__getitem__(key)
+
+    def __repr__(self) -> str:
+        cout = f'"{self.filename}"\n↳ ' if self.filename else ""
+        if self:
+            cout += f"{len(self)} objects : " + "{\n"
+            for obj in self:
+                cout += f"  {obj}\n"
+            cout += "}"
+        else:
+            cout += "[]"
+        return cout
+
+    def clear(self):
+        super().clear()
+        self.filename = ""
+
+    def empty(self):
+        super().clear()
+
+    @property
+    def names(self):
+        return [el.name for el in self]
+
+    @property
+    def geometries(self):
+        return [el.geometry for el in self]
+
+    @property
+    def properties(self):
+        return [el.properties for el in self]
+
+    def items(self):
+        yield from zip(self.names, self)
+
+    @property
+    def objects(self):
+        return [e for e in self if isinstance(e, Object)]
+
+    def filter(self, *, indices=[], names=[], geometries=[]):
+        """Filter a specific geometry.
+
+        Args:
+            indices (Iterable[int]): The indices to select.
+            names (Union[str, Iterable[str]]): The objects to select (list or regex).
+            geometries (Union[Geometry, str, int]): The geometries to select.
+
+        Returns:
+            Dataset: A subset of the dataset mathcing filter criterions.
+        """
+
+        # geometries can be
+        geometries = [
+            Geometry[g] if isinstance(g, str) else Geometry(g) for g in geometries
+        ]
+
+        valids = []
+        for i, el in enumerate(self):
+            if indices and i not in indices:
+                continue
+            elif names and el.name not in names:
+                continue
+            elif geometries and el.geometry not in geometries:
+                continue
+            valids.append(el)
+
+        return self.__class__(valids, self.filename)
+
+    def to(self, wrapper: str) -> Any:
+        if wrapper.lower() not in Drivers:
+            raise ValueError(f"Unsupported format: {wrapper}")
+        else:
+            driver = Drivers[wrapper.lower()]
+        return driver(self)
+
+    @classmethod
+    def find(cls, filename) -> list[str]:
+        """Open an ascii file and split objects in it.
+
+        Args:
+            filename (str): Ascii GOCAD export file.
+
+        Returns:
+            list[str]: List of single GOCAD objects text blocks.
+        """
+        # TODO: handle binary/projects files
+        path = Path(filename)
+        return find_objects(path.read_bytes().decode("ascii", "replace"))
+
+    @classmethod
+    def load(cls, filename: str, **kwargs) -> list[Chunk]:
+        """Open an ascii file and identify objects in it.
+
+        Args:
+            filename (str): Ascii GOCAD export file.
+            **kwargs: Reading options for `pathlib.Path.read_text()`.
+
+        Returns:
+            Dataset[Chunk]: Collection of identified GOCAD objects.
+        """
+
+        blocks = cls.find(filename, **kwargs)
+        n = len(blocks)
+        if n == 0:
+            return cls()
+
+        blocks = [Chunk(b) for b in blocks]
+
+        return cls(blocks, filename=filename)
+
+    @classmethod
+    def read(
+        cls,
+        filename: str,
+        *,
+        wrapper: str = None,
+        index=None,
+        indices=[],
+        names=[],
+        geometries=[],
+        encoding=None,
+    ) -> list[Object] | Object:
+        """Open an ascii file and read objects in it.
+
+        Args:
+            filename (str): Ascii GOCAD export file.
+            wrapper (str): The format to wrap the returned Dataset. Must be in `pygcd.getWrappers()`.
+            index (Union[int, str]): Index of the object to return.
+        Kwargs:
+            indices (Iterable[int]): The indices to select.
+            names (Union[str, Iterable[str]]): The objects to select (list or regex).
+            geometries (Union[Geometry, str, int]): The geometries to select.
+
+            geometries (Geometry): Filter objects to return based on the geometry.
+            **kwargs: Reading options for `pathlib.Path.read_text()`.
+
+        Returns:
+            Dataset[Object]: Collection of parsed GOCAD objects.
+        """
+
+        kwargs = {"filename": filename}
+
+        # identify ascii chunks
+        ds = cls.load(**kwargs)
+
+        # filter identified objects (avoid extensive parsing)
+        if len(indices + names + geometries):
+            filters = {"indices": indices, "names": names, "geometries": geometries}
+            ds = ds.filter(**filters)
+
+        # filter on index
+        if index is not None:
+            return decode(ds[index], **kwargs)
+
+        ds = cls([decode(e, **kwargs) for e in ds], **kwargs)
+
+        if wrapper:
+            return ds.to(wrapper)
+        else:
+            return ds

pygcd/drivers/__init__.py

@@ -0,0 +1,12 @@
+from .geopandas_driver import to_geopandas
+from .lasio_driver import to_lasio
+from .pyvista_driver import to_pyvista
+
+Drivers = {
+    "vtk": to_pyvista,
+    "pyvista": to_pyvista,
+    "gdf": to_geopandas,
+    "geopandas": to_geopandas,
+    "las": to_lasio,
+    "lasio": to_lasio,
+}

pygcd/drivers/_cells.py

@@ -0,0 +1,43 @@
+from itertools import chain
+from typing import List, Tuple
+
+
+def ravel_cells(nested_cells: List[List]) -> List:
+    """Converts nested lists of indices into a flat list of connectivities.
+
+    e.g. [[0,1,2],[0,2,3]]  -> [3,0,1,2,3,0,2,3]
+    """
+    flat_connectivity = chain.from_iterable([(len(c), *c) for c in nested_cells])
+    return list(flat_connectivity)
+
+
+def unravel_cells(flat_cells: List) -> List[List]:
+    """Converts a flat list of connectivities into nested lists of indices.
+
+    e.g. [3,0,1,2,3,0,2,3] -> [[0,1,2],[0,2,3]]
+    """
+    nested_cells = []
+    i, stop = 0, len(flat_cells)
+    while i < stop:
+        n = flat_cells[i]
+        i += 1
+        nested_cells.append([flat_cells[i : i + n]])
+        i += n
+    return nested_cells
+
+
+def nested_to_offconn(cells: List[List]) -> Tuple[List, List]:
+    """Ravel cells with new-school VTK cells format.
+
+    e.g. [[0,1,2],[0,2,3]] -> [0,1,2,0,2,3], [0,4]
+    """
+    connectivity, offsets = [], [0]
+    for cell in cells:
+        connectivity.extend(cell)
+        offsets.append(len(cell))
+    return offsets, connectivity
+
+
+def offconn_to_nested(offsets: List, connectivity: List) -> List[List]:
+    off, conn = offsets, connectivity
+    return [conn[i : i + 1] for i in off[:-1]]

pygcd/drivers/_utils.py

@@ -0,0 +1,9 @@
+def iterdict(d, prefix: str = ""):
+    queue = list(d.items())
+    while queue:
+        k, v = queue.pop()
+        if isinstance(v, dict):
+            for _k, _v in v.items():
+                queue.append((f"{k}:{_k}", _v))
+        else:
+            yield k, v

pygcd/drivers/geopandas_driver.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from warnings import warn
+
+import numpy as np
+
+from ..objects import Chunk, Grid, Mesh, Object, Well
+from ._utils import iterdict
+
+
+def build_df(obj: Object) -> GeoDataFrame:
+    from geopandas import GeoDataFrame
+
+    if isinstance(obj, Mesh):
+        geometries = _cast_mesh(obj)
+    elif isinstance(obj, Well):
+        geometries = _cast_well(obj)
+    elif isinstance(obj, Grid):
+        geometries = _cast_grid(obj)
+    else:
+        raise ValueError(f"Invalid object type: {type(obj)}")
+
+    if not isinstance(geometries, dict):
+        geometries = {obj.geometry.name: geometries}
+
+    n = len(geometries)
+
+    fields = obj.fields
+    crs = fields.pop("crs", {})  # handled separatly
+    epsg = crs.get("PROJECTION", "").strip('"')
+    fields["name"] = obj.name
+    fields["type"] = list(geometries.keys())
+    # flatten nested fields
+    fields = {k: [v] * n for k, v in iterdict(fields)}
+    gdf = GeoDataFrame(fields, geometry=list(geometries.values()), crs=epsg).set_index(
+        "name"
+    )
+
+    return gdf
+
+
+def _cast_mesh(mesh: Mesh) -> dict[Geometry]:
+
+    from shapely.geometry import (
+        LineString,
+        MultiLineString,
+        MultiPoint,
+        MultiPolygon,
+        Point,
+        Polygon,
+    )
+
+    assert isinstance(mesh, Mesh)
+
+    if mesh.geometry.name == "VSet":
+        geometry = (
+            MultiPoint(mesh.points) if len(mesh.points) > 1 else Point(mesh.points)
+        )
+    elif mesh.geometry.name == "PLine":
+        nodes = [[mesh.points[i] for i in cell] for cell in mesh.cells]
+        geometry = (
+            MultiLineString([LineString(pts) for pts in nodes])
+            if len(nodes) > 1
+            else LineString(nodes[0])
+        )
+    elif mesh.geometry.name == "TSurf":
+        points = np.asarray(mesh.points, dtype=float)
+        cells = np.asarray(mesh.cells, dtype=int)
+        nodes = points[
+            cells
+        ]  # 10x faster than list comprehesion `[[points[i] for i in cell] for cell in obj.cells]`
+        geometry = (
+            MultiPolygon([Polygon(pts) for pts in nodes])
+            if len(nodes) > 1
+            else Polygon(nodes[0])
+        )
+    else:  # FIXME: how to cast 'TSolid' to 2D format ?!
+        raise NotImplementedError(
+            f"Ignoring unsupported GOCAD object: {mesh.geometry.name} ('{mesh.name}')"
+        )
+    return {mesh.geometry.name: geometry}
+
+
+def _cast_well(well: Well) -> dict[Geometry]:
+
+    from shapely.geometry import LineString, MultiLineString, MultiPoint, Point
+
+    assert isinstance(well, Well)
+
+    geometries = {}
+    if well.collar:
+        geometries["WellCollars"] = Point(well.collar)
+    if well.path:
+        geometries["WellPath"] = LineString(np.asarray(well.path)[:, :3])
+    if well.markers:
+        geometries["WellMarkers"] = MultiPoint(
+            [well.coords(m.zm) for m in well.markers]
+        )
+    if well.zones:
+        geometries["WellZones"] = MultiLineString(
+            [
+                [
+                    (well.coords(z.zfrom), well.coords(z.zto)),
+                ]
+                for z in well.zones
+            ]
+        )
+
+    return geometries
+
+
+def _cast_grid(grid: Grid) -> dict[Geometry]:
+
+    raise NotImplementedError(
+        f"Ignoring unsupported GOCAD object: {grid.geometry.name} ('{grid.name}')"
+    )
+
+    return {mesh.geometry.name: geometry}
+
+
+def to_geopandas(obj):
+
+    from geopandas import GeoDataFrame
+    from pandas import concat
+
+    if isinstance(obj, list):
+        pieces = []
+        for piece in obj:
+            try:
+                pieces.append(to_geopandas(piece))
+            except NotImplementedError:
+                msg = f"Ignoring unsupported GOCAD object: {piece.geometry.name} ('{piece.name}')"
+                warn(
+                    msg,
+                    Warning,
+                )
+        return concat(pieces) if pieces else GeoDataFrame()
+
+    assert isinstance(obj, Object)
+
+    # build GeoDataFrame
+    if isinstance(obj, Chunk):
+        obj = obj.decode()
+    assert isinstance(obj, Object), f"Invalid object type: {type(obj)}"
+
+    gdf = build_df(obj)
+
+    return gdf

pygcd/drivers/lasio_driver.py

@@ -0,0 +1,74 @@
+from logging import warning
+from typing import Union
+
+from ..objects import Chunk, Layer, Object, Well
+
+
+def _cast(well: Well):
+
+    if isinstance(well, str):
+        well = Chunk(well)
+    if isinstance(well, Chunk):
+        well = well.decode()
+    if not isinstance(well, Well):
+        raise NotImplementedError(f"Wrong geometry type: {well.geometry.name}")
+
+    import pandas as pd
+    from lasio import LASFile
+
+    index = "DEPT"
+
+    las = LASFile()
+
+    for mnem in las.well.keys():
+        las.well[mnem] = well.fields.get(mnem.lower(), "")
+
+    las.well.WELL = well.name
+    las.well.SRVC = "GOCAD"
+    las.well.LOC = " ".join(str(e) for e in well.collar)
+
+    if len(well.curves) == 1:
+        for curve in well.curves:
+            las.append_curve(index, curve.zm, unit=curve.z_unit)
+            las.append_curve(curve.name, curve.values, unit=curve.v_unit)
+    elif len(well.curves) > 1:
+        curves = pd.concat(
+            [
+                pd.DataFrame({index: curve.zm, curve.name: curve.values}).set_index(
+                    index
+                )
+                for curve in well.curves
+            ]
+        )
+        las.set_data(curves)
+        for l, w in zip(las.curves[1:], well.curves):
+            l.unit = w.v_unit
+
+    extras = []
+    crs = well.fields.get("crs", {}).get("projection", None)
+    if crs:
+        extras.append(f"CRS: {crs}")
+    if well.path:
+        path = "\n\t".join(str(e) for e in well.path)
+        path = path.replace("(", "").replace(")", "")
+        extras.append(f"WELL PATH: (X Y Z)\n\t{path}")
+
+    las.other = "\n".join(extras)
+
+    return las
+
+
+def to_lasio(obj: Union[Object, list]):
+
+    if isinstance(obj, (str, Layer)):
+        obj = [obj]
+
+    files = []
+    for piece in obj:
+        try:
+            files.append(_cast(piece))
+        except NotImplementedError:
+            warning(
+                f"Ignoring unsupported GOCAD object: {piece.geometry.name} ('{piece.name}')"
+            )
+    return files

pygcd/drivers/pyvista_driver.py

@@ -0,0 +1,143 @@
+from typing import Union
+from warnings import warn
+
+import numpy as np
+
+from ..objects import Chunk, Grid, Mesh, Object, Well
+from ._cells import ravel_cells
+from ._utils import iterdict
+
+
+def reencode(s):
+    return str(s.encode("ascii", "replace"), "ascii")
+
+
+def _cast_mesh(mesh: Mesh):
+    assert isinstance(mesh, Mesh)
+
+    from pyvista import CellType, PolyData, UnstructuredGrid
+
+    if mesh.geometry.name == "VSet":
+        part = PolyData(mesh.points)
+    elif mesh.geometry.name == "PLine":
+        part = PolyData(mesh.points, lines=ravel_cells(mesh.cells))
+    elif mesh.geometry.name == "TSurf":
+        part = PolyData(mesh.points, faces=ravel_cells(mesh.cells))
+    elif mesh.geometry.name == "TSolid":
+        part = UnstructuredGrid(
+            ravel_cells(mesh.cells), [CellType.TETRA] * len(mesh.cells), mesh.points
+        )
+    else:
+        raise ValueError(f"Wrong geometry type: {mesh.geometry.name}")
+
+    # record cell_data
+    for name, value in mesh.cell_data.items():
+        part[reencode(name)] = value
+    # record point_data
+    for name, value in mesh.point_data.items():
+        part[reencode(name)] = value
+
+    return part
+
+
+def _cast_well(well: Well):
+
+    assert isinstance(well, Well)
+
+    # raise NotImplementedError(
+    #     f"Ignoring unsupported GOCAD object: {well.geometry.name} ('{well.name}')"
+    # )
+
+    from pyvista import MultiBlock, PolyData
+
+    vtm = MultiBlock()
+    # vtm["collar"] = PolyData(well.collar)
+    # if len(well.markers) > 0:
+    #     vtm["markers"] = PolyData(well.coords([wm.zm for wm in well.markers]))
+    #     for prop in WellMarker.__dataclass_fields__.keys():  # forward properties
+    #         array = np.array([wm.__getattribute__(prop) for wm in well.markers])
+    #         if array.dtype.type is np.str_:
+    #             array = np.array([reencode(el) for el in array])
+    #         vtm["markers"][reencode(prop)] = array
+    # if len(well.zones) > 0:
+    #     _from = well.coords([s.zfrom for s in well.zones])
+    #     _to = well.coords([s.zto for s in well.zones])
+    #     pts = np.empty((_from.size + _to.size,), dtype=float)
+    #     pts[0::2], pts[1::2] = _from, _to
+    #     lines = []
+    #     for i in range(len(_from)):
+    #         lines += [2, 2 * i, 2 * i + 1]
+    #     vtm["stratum"] = PolyData(pts, lines=lines)
+    #     for prop in WellZone.__dataclass_fields__.keys():  # forward properties
+    #         array = np.array([ws.__getattribute__(prop) for ws in well.zones])
+    #         if array.dtype.type is np.str_:
+    #             array = np.array([reencode(el) for el in array])
+    #         vtm["stratum"][reencode(prop)] = array
+    if len(well.path) > 0:
+        pts = np.asarray(well.path, float)[:, :3]
+        n = len(pts)
+        vtm["path"] = PolyData(pts, lines=[n] + list(range(n)))
+    return vtm
+
+
+def _cast_grid(grid: Grid):
+    from pyvista import StructuredGrid
+
+    raise NotImplementedError(
+        f"Ignoring unsupported GOCAD object: {grid.geometry.name} ('{grid.name}')"
+    )
+    return StructuredGrid()
+
+
+def to_pyvista(obj: Union[Object, list]):
+    from pyvista import DataObject, MultiBlock
+
+    if isinstance(obj, list):
+        assert len(obj) > 0
+        vtm = MultiBlock()
+        for piece in obj:
+            try:
+                part = to_pyvista(piece)
+                name = piece.name
+                if name and name not in vtm.keys():
+                    vtm[name] = part
+                else:
+                    vtm.append(part)
+            except NotImplementedError:
+                msg = f"Ignoring unsupported GOCAD object: {piece.geometry.name} ('{piece.name}')"
+                warn(
+                    msg,
+                    Warning,
+                )
+        return vtm
+
+    # build pv.DataSet
+    if isinstance(obj, Chunk):
+        obj = obj.decode()
+    assert isinstance(obj, Object), f"Invalid object type: {type(obj)}"
+
+    if isinstance(obj, Mesh):  # -> PolyData or UnstructuredGrid
+        part = _cast_mesh(obj)
+    elif isinstance(obj, Well):  # -> MultiBlock (of PolyData)
+        part = _cast_well(obj)
+    elif isinstance(obj, Grid):  # -> StructuredGrid
+        part = _cast_grid(obj)
+    else:
+        raise ValueError(f"Invalid object type: {type(obj)}")
+
+    assert isinstance(part, DataObject), f"Invalid object type: {type(obj)}"
+
+    # record field_data
+    part.add_field_data([reencode(obj.name)], "name")
+    part.add_field_data([reencode(obj.geometry.name)], "geometry")
+    for name, value in iterdict(obj.fields):
+        name = reencode(name).strip("*").replace("*", ":")
+        if name in part.field_data.keys():
+            warn(f"Duplicated property will be overwritten: {name}", Warning)
+        if isinstance(value, str):
+            value = [reencode(value)]
+        elif not hasattr(value, "__iter__"):
+            value = [value]
+        part.add_field_data(value, name)
+
+    return part

pygcd/objects/__init__.py

@@ -0,0 +1,6 @@
+from ..readers import read_grid, read_header, read_mesh, read_well
+from ..readers.well import WellCurve, WellMarker, WellZone
+from .abstract import Chunk, Geometry, Layer, Object, decode
+from .grid import Grid
+from .mesh import Mesh
+from .well import Well