pygcd 0.3__py2.py3-none-any.whl

pygcd/objects/abstract.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from abc import abstractclassmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from logging import warning
+from typing import Any
+
+from . import read_header
+
+
+class Geometry(Enum):
+    """GOCAD object geometry type."""
+
+    Invalid = -1
+    # 0 <= mesh data < 10
+    VSet = 0
+    PLine = 1
+    TSurf = 2
+    TSolid = 3
+    # well data == 10
+    Well = 10
+    # grid data > 10
+    Voxet = 11
+    GSurf = 12
+    SGrid = 13
+
+    @classmethod
+    def names(cls):
+        return [el.name for el in cls]
+
+    @property
+    def instance(self):
+        from . import Grid, Mesh, Well
+
+        if self.value > 10:
+            return Grid
+        elif self.value == 10:
+            return Well
+        elif self.value >= 0:
+            return Mesh
+        else:
+            raise ValueError(f"{self.name} geometry !")
+
+    def read(self, text, *args, **kwargs):
+        return self.instance.from_chunk(text, *args, **kwargs)
+
+
+@dataclass
+class Layer:
+    """Generic GOCAD object (abstract class)"""
+
+    name: str = "Unknown object"
+    geometry: Geometry = Geometry(-1)
+    version: str = "?"
+    fields: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        """Make it abstract, any Layer() will fail"""
+        if self.__class__ == Layer:
+            raise TypeError("Cannot instantiate abstract class.")
+
+    def __getattr__(self, name: str) -> Any:
+        """Make self.fields accessible as class attributes.
+
+        Any failed `self.name` attempt will trigger a lookup in
+        self.fields.keys() and return self.fields[name] if match.
+
+        Args:
+            name (str): Field name.
+
+        Raises:
+            AttributeError: Non existing keys will raise AttributeError.
+
+        Returns:
+            Any: Identical to `self.fields[name]`.
+        """
+        if name in self.__getattribute__("fields"):
+            return self.fields[name]
+        else:
+            raise AttributeError(f"'{self.__class__}' object has no attribute '{name}'")
+
+    def __repr__(self) -> str:
+        """Textual representation of an object.
+
+        self.geometry.name ("self.name")
+            N Fields:   len(self.fields)
+            -> child classes will add informations
+
+        Returns:
+            str: Object string representation.
+        """
+        s = f'{self.geometry.name} ("{self.name}")\n'
+        s += f"\tN Fields:\t{len(self.fields)}"
+        return s
+
+
+class Object(Layer):
+    """Geometric object (abstract class)"""
+
+    def __post_init__(self):
+        """make it abstract"""
+        if self.__class__ == Object:
+            raise TypeError("Cannot instantiate abstract class.")
+
+    @abstractclassmethod
+    def from_chunk(cls, chunk: str, *args, **kwargs) -> Object:
+        return cls()
+
+    def to(self, wrapper: str):
+        from ..drivers import Drivers
+
+        if wrapper.lower() not in Drivers:
+            raise ValueError(f"Unsupported format: {wrapper}")
+        else:
+            driver = Drivers[wrapper.lower()]
+        return driver(self)
+
+
+class Chunk(Layer):
+    """Identified object (i.e. decoded header)"""
+
+    def __init__(self, raw: str):
+        self.load(raw)
+
+    def load(self, chunk: str):
+        header = read_header(chunk)
+        self.name = header.pop("name", self.name)
+        self.geometry = Geometry[header.pop("geometry", self.geometry.name)]
+        self.version = header.pop("version", self.version)
+        self.fields = header
+        self.chunk = chunk
+
+    def read(self, *args, **kwargs) -> Object:
+        new = self.geometry.read(self.chunk, *args, **kwargs)
+        for attr in self.__dataclass_fields__.keys():
+            if hasattr(new, attr):
+                new.__setattr__(attr, self.__getattribute__(attr))
+        return new
+
+    @staticmethod
+    def decode(chunk: str, *args, **kwargs) -> Chunk:
+        return Chunk(chunk).read(*args, **kwargs)
+
+
+def decode(chunk, *args, **kwargs):
+    if isinstance(chunk, str):
+        return Chunk.decode(str, *args, **kwargs)
+    if isinstance(chunk, Chunk):
+        return chunk.read(*args, **kwargs)
+    if isinstance(chunk, Object):
+        return chunk
+    warning(f"Ignoring unsupported GOCAD object: {chunk})")
+    return None

pygcd/objects/grid.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import Object, read_grid
+
+
+@dataclass
+class Grid(Object):
+    """Grid-geometry type object (Voxet, GSurf, SGrid)"""
+
+    origin: tuple[float] = field(default_factory=tuple)
+    dimension: tuple[float] = field(default_factory=tuple)
+    spacing: tuple[float] = field(default_factory=tuple)
+    data: list[float] = field(default_factory=list)
+
+    @classmethod
+    def from_chunk(cls, chunk: str, *args, **kwargs) -> Object:
+        self = cls()
+        params, self.data = read_grid(chunk, *args, **kwargs)
+        self.origin, self.dimension, self.spacing = params
+        return self
+
+    def __repr__(self) -> str:
+        s = super().__repr__() + "\n"
+        s += f"\tN Points:\t{len(self.points)}\n"
+        s += f"\tN Cells:\t{len(self.cells)}\n"
+        s += f"\tN Arrays:\t{len(self.data)}\n"
+        return s

pygcd/objects/mesh.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from . import Object, read_mesh
+
+
+@dataclass
+class Mesh(Object):
+    """Mesh-geometry type object (VSet, TSurf, TSolid)"""
+
+    points: list[tuple[float]] = field(default_factory=list)
+    cells: list[list[int]] = field(default_factory=list)
+    point_data: dict[str, list[str]] = field(default_factory=dict)
+    cell_data: dict[str, list[str]] = field(default_factory=dict)
+
+    @classmethod
+    def from_chunk(cls, chunk, *args, **kwargs) -> Object:
+        self = cls()
+        self.points, self.cells, self.point_data, self.cell_data = read_mesh(
+            chunk, *args, **kwargs
+        )
+        return self
+
+    # WIP: Make sure Layer.__getattr__ is called first !
+    # def __getattr__(self, name: str) -> Any:
+    #     """Make self.data accessible as class attributes.
+
+    #     Any failed `self.name` attempt will trigger a lookup in
+    #     self.data.keys() and return self.data[name] if match.
+
+    #     Args:
+    #         name (str): Point data attribute.
+
+    #     Raises:
+    #         AttributeError: Non existing keys will raise AttributeError.
+
+    #     Returns:
+    #         Any: Identical to `self.data[name]`.
+    #     """
+    #     if name in self.__getattribute__('data'):
+    #         return self.data[name]
+    #     else:
+    #         raise AttributeError(f"'{self.__class__}' object has no attribute '{name}'")
+
+    def __repr__(self) -> str:
+        s = super().__repr__() + "\n"
+        s += f"\tN Points:\t{len(self.points)}\n"
+        s += f"\tN Cells:\t{len(self.cells)}\n"
+        s += f"\tN Arrays:\t{len(self.arrays)}"
+        return s
+
+    @property
+    def arrays(self):
+        return list(self.point_data.keys()) + list(self.cell_data.keys())

pygcd/objects/well.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import cached_property
+
+import numpy as np
+from numpy.typing import ArrayLike
+from scipy.interpolate import splev, splprep
+
+from . import Object, WellCurve, WellMarker, WellZone, read_well
+
+
+@dataclass
+class Well(Object):
+    """Well object"""
+
+    collar: tuple[float] = field(default_factory=tuple)
+    path: list[tuple[float]] = field(default_factory=list)
+    markers: list[WellMarker] = field(default_factory=list)
+    zones: list[WellZone] = field(default_factory=list)
+    curves: list[WellCurve] = field(default_factory=list)
+
+    @classmethod
+    def from_chunk(cls, chunk, *args, **kwargs) -> Object:
+        self = cls()
+        self.collar, self.path, self.markers, self.zones, self.curves = read_well(
+            chunk, *args, **kwargs
+        )
+        return self
+
+    def __setattr__(self, __name: str, __value: list[tuple[float]]) -> None:
+        """Manage cached properties"""
+        if __name == "path" and "spline" in self.__dict__:
+            del self.__dict__["spline"]
+        return super().__setattr__(__name, __value)
+
+    def __repr__(self) -> str:
+        s = super().__repr__() + "\n"
+        s += f"\tCollar:\t{self.collar}\n"
+        s += f"\tN Path:\t{len(self.path)}\n"
+        s += f"\tN Markers:\t{len(self.markers)}\n"
+        s += f"\tN Strata:\t{len(self.zones)}\n"
+        s += f"\tN Curves:\t{len(self.curves)}\n"
+        return s
+
+    @cached_property
+    def spline(self):
+        points = np.array(self.path, float)
+        if len(points) == 0:  # no path : use vertical hole from collar
+            points = np.array((*self.collar, 0), float)
+        if len(points) == 0:  # empty well ... raise ValueError
+            raise ValueError(f"Well is empty: {self}")
+
+        # remove duplicates (should not exists ... but ...)
+        points = np.unique(points, axis=0)
+        # single point path : use vertical hole
+        if len(points) == 1:
+            ref = points.squeeze()
+
+            def spline(zm):  # wrapper around interpolator
+                xy = np.tile(ref[:2], (np.asarray(zm).size, 1))
+                z = ref[2] + ref[3] - zm
+                return np.c_[xy, z]
+
+        # multi point path : spline interpolation
+        else:
+            # splprep.u must be sorted
+            order = np.argsort(points[:, -1])
+            points = points[order, :]
+            # interpolate using spline
+            x = [points[:, 0], points[:, 1], points[:, 2]]
+            u = points[:, 3].flatten()
+            k = min(len(points) - 1, 3)
+            tck, _ = splprep(x, u=u, k=k, s=0)
+
+            def spline(zm):  # wrapper around interpolator
+                return np.column_stack(splev(zm, tck))
+
+        return spline
+
+    def coords(self, zm: ArrayLike) -> ArrayLike:
+        u = np.asarray(zm, float).flatten()
+        interp = self.spline
+        return interp(u)

pygcd/readers/__init__.py

@@ -0,0 +1,31 @@
+import re
+
+"""GOCAD Object file template:
+
+GOCAD <type> <version>
+HEADER {
+name: <name>
+[<key>: <value>]
+}
+[PROPERTIES <name> ... <name>]
+ATOM <ID> <X> <Y> <Z> [<PV> ...]
+[<SUBSET_TYPE>]
+[<CELL_TYPE> <ATOM> ... <ATOM>]
+END
+
+based on : http://paulbourke.net/dataformats/gocad/gocad.pdf
+"""
+
+OBJECT = re.compile(r"(?P<object>GOCAD.*?END)\s*?$", re.M | re.S)
+
+
+def find_objects(raw: str) -> list:
+    """Split raw text into object chunks"""
+    return OBJECT.findall(raw)
+
+
+# geometry readers
+from .grid import read_grid
+from .header import read_header
+from .mesh import read_mesh
+from .well import read_well

pygcd/readers/_utils.py

@@ -0,0 +1,40 @@
+def safesplit(string: str, splitchar: str = " ", escaping: str = "'\"") -> list:
+    """Split string with escaping capabilities.
+
+    Args:
+        string (str): The string to parse.
+        splitchar (str): The separator.
+        ignorechar (str): The character escaping splits.
+
+    Returns:
+        list: Splitted string
+    """
+    if splitchar in escaping:
+        raise ValueError("Cannot escape on splitting character !")
+
+    result = []
+    buffer = ""
+    escape = ""
+
+    for c in string:
+        if c in escaping:
+            if not escape:
+                escape = c
+                continue
+            elif escape == c:
+                escape = ""
+                continue
+
+        if c == splitchar and not escape:
+            if buffer:
+                result.append(buffer)
+                buffer = ""
+            else:
+                continue
+        else:
+            buffer += c
+
+    if buffer:
+        result.append(buffer)
+
+    return result

pygcd/readers/grid.py

@@ -0,0 +1,2 @@
+def read_grid(raw: str, *args, **kwargs):
+    raise NotImplementedError("Work in progress")

pygcd/readers/header.py

@@ -0,0 +1,80 @@
+import re
+
+from ._utils import safesplit
+
+# regex to parse ascii files
+
+HEADER = re.compile(r"HEADER\s*?{\s*?(?P<header>.*?)\s*?}", re.M | re.S)
+HDR = re.compile(r"HDR\s+(?P<property>.*?)\s*?$", re.M | re.S)
+CRS = re.compile(
+    r"GOCAD_ORIGINAL_COORDINATE_SYSTEM(?P<crs>.+?)END_ORIGINAL_COORDINATE_SYSTEM",
+    re.M | re.S,
+)
+
+
+def _parse_properties(block: str) -> dict:
+    """Parse GOCAD Object attributes.
+
+    Args:
+        block (str): Single GOCAD Object string "GOCAD ... END".
+
+    Returns:
+        dict: Object attributes.
+    """
+    attribs = {}
+    # get header block(s) and lines
+    properties = "\n".join(HEADER.findall(block) + HDR.findall(block))
+    for line in properties.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        key, value = line.split(":")
+        key = key.strip("*").strip().lower()
+        value = value.strip()
+        attribs[key] = value
+    return attribs
+
+
+def _parse_coordinate_system(block: str) -> dict:
+    crs = {}
+    match = CRS.search(block)
+    if match:
+        for line in match["crs"].strip().splitlines():
+            key, *value = safesplit(line)
+            crs[key.lower()] = " ".join(value)
+    return crs
+
+
+def _parse_geologic_information(block: str) -> dict:
+    info = {}
+    flags = ("GEOLOGICAL_TYPE", "GEOLOGICAL_FEATURE")
+    for flag in flags:
+        match = re.search(flag + r"\s+?(.+?)\s*?$", block, re.MULTILINE)
+        if match:
+            info[flag.lower()] = match.group(1)
+    strati = re.search(r"STRATIGRAPHIC_POSITION\s+?(.+?)\s*?$", block, re.MULTILINE)
+    if strati:
+        age, time = strati.group(1).split()
+        info["stratigraphic_age"], info["stratigraphic_time"] = age, float(time)
+    return info
+
+
+def read_header(block: str, *args, **kwargs):
+    block = block.strip()
+    if not block.startswith("GOCAD "):
+        raise OSError("Invalid GOCAD object")
+
+    first, block = block.split("\n", 1)
+    _, geometry, version = first.split()
+
+    attributes = _parse_properties(block)
+    header = {
+        "name": attributes.pop("name", "Unknown block"),
+        "geometry": geometry,
+        "version": version,
+    }
+    header.update(_parse_geologic_information(block))
+    header["crs"] = _parse_coordinate_system(block)
+    header.update(attributes)
+
+    return header

pygcd/readers/mesh.py

@@ -0,0 +1,101 @@
+POINTS = ("VRTX", "PVRTX", "ATOM", "PATOM")
+FIELDS = (
+    "PROPERTIES",
+    "FIELDS",
+    "NO_DATA_VALUES",
+    "ESIZES",
+)  # ignore "UNITS" since it wont be forwarded
+CELLS = ("SEG", "TRGL", "TETRA")
+SEP = ("ILINE", "TFACE", "TVOLUME")
+
+
+def read_mesh(block: str, *args, **kwargs):
+    nbp, nbc = 0, 0
+    points, cells = [], []
+    names, ndims, no_data_values, units = [], [], [], []
+    point_props, cell_splits = [], []
+    for line in block.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        what, *stuff = line.split()
+        if what in FIELDS:
+            if what in ("PROPERTIES", "FIELDS"):
+                assert not names, "Duplicated point properties definition"
+                names = stuff
+            elif what == "NO_DATA_VALUES":
+                assert not no_data_values, "Duplicated point data default values"
+                no_data_values = [float(x) for x in stuff]
+                if ndims:
+                    no_data_values = [
+                        x if y == 1 else [x] * y for x, y in zip(no_data_values, ndims)
+                    ]
+            elif what == "UNITS":
+                assert not units, "Duplicated point data units"
+                units = stuff
+            elif what == "ESIZES":
+                assert not ndims, "Duplicated point data dimensions"
+                ndims = (int(x) for x in stuff)
+                if no_data_values:
+                    no_data_values = [
+                        x if y == 1 else [x] * y for x, y in zip(no_data_values, ndims)
+                    ]
+        elif what in POINTS:
+            nbp += 1
+            i, *stuff = stuff
+            assert int(i) == nbp, f"Wrong indexing in points indices"
+            if what.endswith("VRTX"):
+                x, y, z, *props = stuff
+                points.append((float(x), float(y), float(z)))
+            else:
+                assert what.endswith("ATOM"), "Wrong point identifier"
+                idx, *props = stuff
+                points.append(points[int(idx) - 1])
+            if props or len(no_data_values) > 0:
+                point_props.append(props or no_data_values)
+        elif what in CELLS:
+            indices = [int(i) - 1 for i in stuff]
+            if what == "SEG":  # merge zones to build lines
+                if not cells:  # fist segment of first line
+                    cells.append(indices)
+                    nbc += 1
+                elif not cells[-1]:  # new line detected
+                    cells[-1] = indices
+                    nbc += 1
+                else:  # next zones extend last cell
+                    assert cells[-1][-1] == indices[0], "Inconsistent PLine !"
+                    cells[-1] += indices[1:]
+            else:
+                cells.append(indices)
+                nbc += 1
+
+        elif what in SEP:
+            cell_splits.append(nbc)
+            if what == "ILINE":  # new line forces a new cell
+                cells.append([])
+        else:
+            continue
+
+    if cells and not cells[-1]:  # clean up possibly empty last cell (only with PLine)
+        cells = cells[:-1]
+
+    assert nbp == len(points), "Number of points missmatch counter"
+    assert nbc == len(cells), "Number of cells missmatch counter"
+
+    cell_data = {}
+    if cell_splits:  # create a cell_data attribute with part index
+        cell_splits = cell_splits[::-1]
+        parts, rank, idx = [], 0, cell_splits.pop()
+        for i in range(nbc):
+            if i == idx and cell_splits:
+                idx = cell_splits.pop()
+                rank += 1
+            parts.append(rank)
+        cell_data = {"block_id": parts}
+
+    point_data = {}
+    if point_props:
+        for key, values in zip(names, zip(*point_props)):
+            point_data[key] = values
+
+    return points, cells, point_data, cell_data