LoopStructural 1.6.26__tar.gz → 1.7.0__tar.gz

{loopstructural-1.6.26 → loopstructural-1.7.0}/LoopStructural/__init__.py

@@ -5,14 +5,35 @@ LoopStructural
 """
 
 import logging
-from logging.config import dictConfig
-
 from dataclasses import dataclass
+from logging.config import dictConfig
 
-
-__all__ = ["GeologicalModel"]
+__all__ = [
+    "BoundingBox",
+    "FaultTopology",
+    "FileSink",
+    "GeologicalModel",
+    "InterpolatorBuilder",
+    "LogSink",
+    "LoopInterpolator",
+    "LoopStructuralConfig",
+    "SqliteSink",
+    "StratigraphicColumn",
+    "StreamSink",
+    "add_sink",
+    "getLogger",
+    "get_levels",
+    "log_to_console",
+    "log_to_file",
+    "remove_sink",
+    "rng",
+    "setLogging",
+    "timed",
+    "timed_stage",
+]
 import tempfile
 from pathlib import Path
+
 from .version import __version__
 
 experimental = False
@@ -21,6 +42,11 @@ formatter = logging.Formatter("%(levelname)s: %(asctime)s: %(filename)s:%(lineno
 ch.setFormatter(formatter)
 ch.setLevel(logging.WARNING)
 loggers = {}
+# Handlers attached via LoopStructural.utils.add_sink(); replayed onto every
+# logger getLogger() creates from here on, in addition to the default `ch`.
+_extra_sinks = []
+
+
 @dataclass
 class LoopStructuralConfig:
     """Configuration for LoopStructural package.
@@ -42,13 +68,27 @@ class LoopStructuralConfig:
    
     nelements: int = 10_000
 
+from .geometry import BoundingBox
+from .interpolators import InterpolatorBuilder
+from .interpolators._api import LoopInterpolator
+from .modelling.core.fault_topology import FaultTopology
 from .modelling.core.geological_model import GeologicalModel
 from .modelling.core.stratigraphic_column import StratigraphicColumn
-from .modelling.core.fault_topology import FaultTopology
-from .interpolators._api import LoopInterpolator
-from .interpolators import InterpolatorBuilder
-from .datatypes import BoundingBox
-from .utils import log_to_console, log_to_file, getLogger, rng, get_levels
+from .utils import (
+    FileSink,
+    LogSink,
+    SqliteSink,
+    StreamSink,
+    add_sink,
+    get_levels,
+    getLogger,
+    log_to_console,
+    log_to_file,
+    remove_sink,
+    rng,
+    timed,
+    timed_stage,
+)
 
 logger = getLogger(__name__)
 logger.info("Imported LoopStructural")

loopstructural-1.7.0/LoopStructural/datasets/__init__.py

@@ -0,0 +1,26 @@
+"""
+Demo Datasets
+=============
+
+Various datasets used for documentation and tutorials.
+"""
+
+from ._base import (
+    load_claudius,
+    load_duplex,
+    load_fault_trace,
+    load_geological_map_data,
+    load_grose2017,
+    load_grose2018,
+    load_grose2019,
+    load_horizontal,
+    load_horizontal_v,
+    load_intrusion,
+    load_laurent2016,
+    load_noddy_single_fold,
+    load_tabular_intrusion,
+    load_unconformity,
+    normal_vector_headers,
+    strike_dip_headers,
+    value_headers,
+)

{loopstructural-1.6.26 → loopstructural-1.7.0}/LoopStructural/datasets/_base.py

@@ -1,11 +1,11 @@
 from os.path import dirname, join
 from pathlib import Path
-from typing import Tuple
+
 import numpy as np
 import pandas as pd
 
 
-def load_horizontal() -> Tuple[pd.DataFrame, np.ndarray]:
+def load_horizontal() -> tuple[pd.DataFrame, np.ndarray]:
     """Synthetic model for horizontal layers
 
     Returns
@@ -41,7 +41,7 @@ def load_horizontal() -> Tuple[pd.DataFrame, np.ndarray]:
     return data, bb
 
 
-def load_horizontal_v(v=0.5) -> Tuple[pd.DataFrame, np.ndarray]:
+def load_horizontal_v(v=0.5) -> tuple[pd.DataFrame, np.ndarray]:
     """Synthetic model for horizontal layers
 
     Returns
@@ -152,7 +152,6 @@ def load_grose2017():
     tuple
         pandas data frame with loopstructural dataset and numpy array for bounding box
     """
-    pass
 
 
 def load_grose2018():
@@ -164,7 +163,6 @@ def load_grose2018():
     tuple
         pandas data frame with loopstructural dataset and numpy array for bounding box
     """
-    pass
 
 
 def load_grose2019():
@@ -176,7 +174,6 @@ def load_grose2019():
     tuple
         pandas data frame with loopstructural dataset and numpy array for bounding box
     """
-    pass
 
 
 def load_intrusion():

loopstructural-1.7.0/LoopStructural/datasets/_example_models.py

@@ -0,0 +1,11 @@
+from ..utils import getLogger
+
+logger = getLogger(__name__)
+
+vis = True
+
+# Visualization is optional for this module and is enabled by default.
+
+
+def _build_claudius():
+    pass

loopstructural-1.7.0/LoopStructural/datatypes/__init__.py

@@ -0,0 +1,27 @@
+"""Deprecated import path.
+
+``BoundingBox``, ``Surface``, ``ValuePoints`` and ``VectorPoints`` moved to
+:mod:`LoopStructural.geometry` in v1.6.x. This shim re-exports them so
+existing consumers (e.g. the LoopStructural QGIS plugin) keep working, and
+will be removed after two minor releases per the versioning policy in
+``ROADMAP.md``.
+"""
+
+import warnings
+
+from ..geometry import BoundingBox, Surface, ValuePoints, VectorPoints
+
+warnings.warn(
+    "LoopStructural.datatypes is deprecated and will be removed in a future "
+    "release; import BoundingBox, Surface, ValuePoints and VectorPoints from "
+    "LoopStructural.geometry instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+__all__ = [
+    "BoundingBox",
+    "Surface",
+    "ValuePoints",
+    "VectorPoints",
+]

{loopstructural-1.6.26 → loopstructural-1.7.0}/LoopStructural/export/exporters.py

@@ -3,14 +3,15 @@ Routines to export geological model data to file in a variety of formats
 """
 
 import os
-from pyevtk.hl import unstructuredGridToVTK, pointsToVTK
-from pyevtk.vtk import VtkTriangle
+
 import numpy as np
+from pyevtk.hl import pointsToVTK, unstructuredGridToVTK
+from pyevtk.vtk import VtkTriangle
 from skimage.measure import marching_cubes
 
-from LoopStructural.utils.helper import create_box
 from LoopStructural.export.file_formats import FileFormat
-from LoopStructural.datatypes import Surface
+from LoopStructural.geometry import Surface
+from LoopStructural.utils.helper import create_box
 
 from ..utils import getLogger
 
@@ -193,7 +194,7 @@ def _write_feat_surfs_evtk(surf, file_name):
             cell_types=cell_types,
             pointData={"values": pointData},
         )
-    except Exception as e:
+    except (OSError, ValueError) as e:
         logger.warning(f"Cannot export fault surface to VTK file {file_name}: {e}")
         return False
 
@@ -396,7 +397,7 @@ def _write_cubeface_evtk(model, file_name, data_label, nsteps, real_coords=True)
             cellData=None,
             pointData={data_label: val},
         )
-    except Exception as e:
+    except (OSError, ValueError) as e:
         logger.warning(f"Cannot export cuboid surface to VTK file {file_name}: {e}")
         return False
     return True
@@ -422,8 +423,9 @@ def _write_vol_evtk(model, file_name, data_label, nsteps, real_coords=True):
     True if successful
 
     """
-    # Define grid spacing
-    xyz = model.bounding_box.regular_grid(nsteps=nsteps)
+    # Define grid spacing (world coordinates -- evaluate_model/features now
+    # project world -> local internally)
+    xyz = model.bounding_box.regular_grid(nsteps=nsteps, local=False)
     vals = model.evaluate_model(xyz, scale=False)
     if real_coords:
         model.rescale(xyz)
@@ -438,7 +440,7 @@ def _write_vol_evtk(model, file_name, data_label, nsteps, real_coords=True):
     # Write to grid
     try:
         pointsToVTK(file_name, x, y, z, data={data_label: vals})
-    except Exception as e:
+    except (OSError, ValueError) as e:
         logger.warning(f"Cannot export volume to VTK file {file_name}: {e}")
         return False
     return True
@@ -464,8 +466,9 @@ def _write_vol_gocad(model, file_name, data_label, nsteps, real_coords=True):
     True if successful
 
     """
-    # Define grid spacing in model scale coords
-    xyz = model.bounding_box.regular_grid(nsteps=nsteps)
+    # Define grid spacing (world coordinates -- evaluate_model/features now
+    # project world -> local internally)
+    xyz = model.bounding_box.regular_grid(nsteps=nsteps, local=False)
 
     vals = model.evaluate_model(xyz, scale=False)
     # Use FORTRAN style indexing for GOCAD VOXET
@@ -539,7 +542,7 @@ PROP_OFFSET 1 0
 PROP_FILE 1 {data_filename}
 END\n"""
             )
-    except IOError as exc:
+    except OSError as exc:
         logger.warning(f"Cannot export volume to GOCAD VOXET file {vo_filename}: {exc}")
         return False
 
@@ -548,7 +551,7 @@ END\n"""
     try:
         with open(data_filename, "wb") as fp:
             export_vals.tofile(fp)
-    except IOError as exc:
+    except OSError as exc:
         logger.warning(f"Cannot export volume to GOCAD VOXET data file {data_filename}: {exc}")
         return False
     return True

{loopstructural-1.6.26 → loopstructural-1.7.0}/LoopStructural/export/geoh5.py

@@ -1,7 +1,26 @@
 import geoh5py
 import geoh5py.workspace
 import numpy as np
-from LoopStructural.datatypes import ValuePoints, VectorPoints
+
+from LoopStructural.geometry import ValuePoints, VectorPoints
+
+
+def add_group_to_geoh5(filename, groupname="Loop", parent=None, overwrite=True):
+    with geoh5py.workspace.Workspace(filename) as workspace:
+
+        group = workspace.get_entity(groupname)[0]
+        if group and overwrite:
+            group.allow_delete = True
+            workspace.remove_entity(group)
+        if not group:
+            group = geoh5py.groups.ContainerGroup.create(
+                workspace, name=groupname, allow_delete=True
+            )
+        if parent is not None:
+            parent = workspace.get_entity(parent)[0]
+        if parent:
+            parent.add_children(group)
+        return group.uid
 
 
 def add_surface_to_geoh5(filename, surface, overwrite=True, groupname="Loop"):
@@ -32,6 +51,7 @@ def add_surface_to_geoh5(filename, surface, overwrite=True, groupname="Loop"):
 
 def add_points_to_geoh5(filename, point, overwrite=True, groupname="Loop"):
     with geoh5py.workspace.Workspace(filename) as workspace:
+
         group = workspace.get_entity(groupname)[0]
         if not group:
             group = geoh5py.groups.ContainerGroup.create(
@@ -45,14 +65,15 @@ def add_points_to_geoh5(filename, point, overwrite=True, groupname="Loop"):
         data = {}
         if point.properties is not None:
             for k, v in point.properties.items():
-                data[k] = {'association': "VERTEX", "values": v}
+                data[k] = {'association': "VERTEX", "values": np.asarray(v)}
         if isinstance(point, VectorPoints):
-            data['vx'] = {'association': "VERTEX", "values": point.vectors[:, 0]}
-            data['vy'] = {'association': "VERTEX", "values": point.vectors[:, 1]}
-            data['vz'] = {'association': "VERTEX", "values": point.vectors[:, 2]}
+            vectors = np.asarray(point.vectors)
+            data['vx'] = {'association': "VERTEX", "values": vectors[:, 0]}
+            data['vy'] = {'association': "VERTEX", "values": vectors[:, 1]}
+            data['vz'] = {'association': "VERTEX", "values": vectors[:, 2]}
 
         if isinstance(point, ValuePoints):
-            data['val'] = {'association': "VERTEX", "values": point.values}
+            data['values'] = {'association': "VERTEX", "values": np.asarray(point.values)}
         point = geoh5py.objects.Points.create(
             workspace,
             name=point.name,
@@ -62,6 +83,78 @@ def add_points_to_geoh5(filename, point, overwrite=True, groupname="Loop"):
         point.add_data(data)
 
 
+def overwrite_object(workspace, name, overwrite):
+    if name in workspace.list_entities_name.values():
+        existing_entity = workspace.get_entity(name)
+        existing_entity[0].allow_delete = True
+        if overwrite:
+            workspace.remove_entity(existing_entity[0])
+
+
+def add_points_from_df(
+    filename,
+    df,
+    name='pointset',
+    overwrite=True,
+    columns=None,
+    groupname="Loop",
+    x_col='X',
+    y_col='Y',
+    z_col='Z',
+):
+    """
+    Add points to a geoh5 file from a pandas DataFrame. The DataFrame must have columns 'name', 'X', 'Y', 'Z' for the point locations.
+    Additional columns can be added as data associated with the points.
+    Parameters
+    ----------
+    filename: str
+        Path to the geoh5 file.
+    df: pandas.DataFrame
+        DataFrame containing point data. Must have columns 'name', 'X', 'Y', 'Z'. Additional columns will be added as data.
+    overwrite: bool, optional
+        Whether to overwrite existing points with the same name. Default is True.
+    columns: list of str, optional
+        List of columns in the DataFrame to add as data. If None, all columns except 'name', 'X', 'Y', 'Z' will be added. Default is None.
+
+    """
+    if columns is None:
+        columns = df.columns.tolist()
+    if x_col not in columns or y_col not in columns or z_col not in columns:
+        raise ValueError(
+            "DataFrame must contain 'name', 'X', 'Y', 'Z' columns. "
+            "Specify the column names using x_col, y_col, z_col parameters if they are different."
+        )
+    with geoh5py.workspace.Workspace(filename) as workspace:
+        if groupname:
+            group = workspace.get_entity(groupname)
+            group = group[0] if group else None
+            if not group:
+                group = geoh5py.groups.ContainerGroup.create(
+                    workspace,
+                    name=groupname,
+                    allow_delete=True,
+                )
+
+        location = np.array(df[[x_col, y_col, z_col]].values)  # shape (n,3)
+
+        overwrite_object(workspace, name, overwrite)
+
+        pts = geoh5py.objects.Points.create(
+            workspace,
+            name=name,
+            vertices=location,
+            parent=group,
+        )
+        data = {}
+        for col in columns:
+            if col in ['name', x_col, y_col, z_col]:
+                continue
+            data[col] = {"association": "VERTEX", "values": np.array(df[col]).flatten()}
+
+        if data:
+            pts.add_data(data)
+
+
 def add_structured_grid_to_geoh5(filename, structured_grid, overwrite=True, groupname="Loop"):
     with geoh5py.workspace.Workspace(filename) as workspace:
         group = workspace.get_entity(groupname)[0]

loopstructural-1.7.0/LoopStructural/export/gocad.py

@@ -0,0 +1,269 @@
+import re
+from pathlib import Path
+
+import numpy as np
+
+from LoopStructural.utils import getLogger
+
+logger = getLogger(__name__)
+
+
+def _normalise_voxet_property(values, property_name, nsteps):
+    array = np.asarray(values)
+    expected_shape = tuple(int(step) for step in nsteps)
+    expected_size = int(np.prod(expected_shape))
+
+    if array.shape == expected_shape:
+        flat_values = array.reshape(-1, order="F")
+    else:
+        flat_values = np.squeeze(array)
+        if flat_values.shape == expected_shape:
+            flat_values = flat_values.reshape(-1, order="F")
+        elif flat_values.ndim == 1 and flat_values.size == expected_size:
+            flat_values = flat_values.copy()
+        else:
+            raise ValueError(
+                f"Property '{property_name}' must have shape {expected_shape} or size {expected_size}"
+            )
+
+    if np.issubdtype(flat_values.dtype, np.integer):
+        if (
+            flat_values.size == 0
+            or flat_values.min() >= np.iinfo(np.int8).min
+            and flat_values.max() <= np.iinfo(np.int8).max
+        ):
+            export_dtype = np.int8
+            storage_type = "Octet"
+            element_size = 1
+        else:
+            export_dtype = np.dtype(">i4")
+            storage_type = "Integer"
+            element_size = 4
+        no_data_value = None
+    elif np.issubdtype(flat_values.dtype, np.floating):
+        export_dtype = np.dtype(">f4")
+        storage_type = "Float"
+        element_size = 4
+        no_data_value = -999999.0
+        flat_values = np.nan_to_num(flat_values, nan=no_data_value)
+    else:
+        raise ValueError(f"Property '{property_name}' has unsupported dtype {flat_values.dtype}")
+
+    return {
+        "values": np.asarray(flat_values, dtype=export_dtype),
+        "storage_type": storage_type,
+        "element_size": element_size,
+        "no_data_value": no_data_value,
+    }
+
+
+def _write_structured_grid_gocad(grid, file_name):
+    """Write a StructuredGrid to GOCAD VOXET format."""
+    vo_path = Path(file_name).with_suffix(".vo")
+    axis_n = np.asarray(grid.nsteps, dtype=int)
+    property_source = grid.properties
+    axis_min = np.min(grid.nodes, axis=0)
+    axis_max = np.max(grid.nodes, axis=0)
+
+    if property_source:
+        if grid.cell_properties:
+            logger.warning(
+                "StructuredGrid GOCAD export uses point properties; cell_properties were not exported"
+            )
+    elif grid.cell_properties:
+        axis_n = np.asarray(grid.nsteps, dtype=int) - 1
+        if np.any(axis_n <= 0):
+            raise ValueError("StructuredGrid cell_properties require at least two grid nodes per axis")
+        property_source = grid.cell_properties
+        axis_min = np.min(grid.cell_centres, axis=0)
+        axis_max = np.max(grid.cell_centres, axis=0)
+    else:
+        raise ValueError("StructuredGrid has no properties to export to GOCAD")
+
+    export_properties = []
+    for index, (property_name, values) in enumerate(property_source.items(), start=1):
+        export_info = _normalise_voxet_property(values, property_name, axis_n)
+        safe_name = re.sub(r"[^0-9A-Za-z_-]+", "_", property_name).strip("_") or f"property_{index}"
+        data_path = vo_path.with_name(f"{vo_path.stem}_{safe_name}@@")
+        export_properties.append(
+            {
+                "index": index,
+                "name": safe_name,
+                "data_path": data_path,
+                **export_info,
+            }
+        )
+
+    with open(vo_path, "w") as fp:
+        fp.write(
+            f"""GOCAD Voxet 1
+HEADER {{
+name: {grid.name}
+}}
+GOCAD_ORIGINAL_COORDINATE_SYSTEM
+NAME Default
+AXIS_NAME \"X\" \"Y\" \"Z\"
+AXIS_UNIT \"m\" \"m\" \"m\"
+ZPOSITIVE Elevation
+END_ORIGINAL_COORDINATE_SYSTEM
+AXIS_O 0.000000 0.000000 0.000000
+AXIS_U 1.000000 0.000000 0.000000
+AXIS_V 0.000000 1.000000 0.000000
+AXIS_W 0.000000 0.000000 1.000000
+AXIS_MIN {axis_min[0]} {axis_min[1]} {axis_min[2]}
+AXIS_MAX {axis_max[0]} {axis_max[1]} {axis_max[2]}
+AXIS_N {axis_n[0]} {axis_n[1]} {axis_n[2]}
+AXIS_NAME \"X\" \"Y\" \"Z\"
+AXIS_UNIT \"m\" \"m\" \"m\"
+AXIS_TYPE even even even
+"""
+        )
+        for export_property in export_properties:
+            fp.write(
+                f"""PROPERTY {export_property['index']} {export_property['name']}
+PROPERTY_CLASS {export_property['index']} {export_property['name']}
+PROP_UNIT {export_property['index']} {export_property['name']}
+PROPERTY_CLASS_HEADER {export_property['index']} {export_property['name']} {{
+}}
+PROPERTY_SUBCLASS {export_property['index']} QUANTITY {export_property['storage_type']}
+"""
+            )
+            if export_property["no_data_value"] is not None:
+                fp.write(
+                    f"PROP_NO_DATA_VALUE {export_property['index']} {export_property['no_data_value']}\n"
+                )
+            fp.write(
+                f"""PROP_ETYPE {export_property['index']} IEEE
+PROP_FORMAT {export_property['index']} RAW
+PROP_ESIZE {export_property['index']} {export_property['element_size']}
+PROP_OFFSET {export_property['index']} 0
+PROP_FILE {export_property['index']} {export_property['data_path'].name}
+"""
+            )
+        fp.write("END\n")
+
+    for export_property in export_properties:
+        with open(export_property["data_path"], "wb") as fp:
+            export_property["values"].tofile(fp)
+
+    return True
+
+
+def _write_feat_surfs_gocad(surf, file_name):
+    """
+    Writes out a GOCAD TSURF file for each surface in list
+
+    Parameters
+    ----------
+    surf_list: [ SimpleNamespace() ... ]
+        Details of the surfaces, as a list of SimpleNamespace() objects. Fields are:
+            verts: vertices, numpy ndarray with dtype = float64 & shape = (N,3)
+            faces: faces, numpy ndarray with dtype = int32 & shape = (M,3)
+            values: values, numpy ndarray with dtype = float32 & shape = (N,)
+            normals: normals, numpy ndarray with dtype = float32 & shape = (N,3)
+            name: name of feature e.g. fault or supergroup, string
+
+    file_name: string
+        Desired filename
+
+    Returns
+    -------
+    True if successful
+
+    """
+    properties_header = None
+    if surf.properties:
+
+        properties_header = f"""PROPERTIES {' '.join(list(surf.properties.keys()))}
+NO_DATA_VALUES -99999
+PROPERTY_CLASSES {' '.join(list(surf.properties.keys()))}
+        """
+
+    file_name = Path(file_name).with_suffix(".ts")
+    with open(f"{file_name}", "w") as fd:
+        fd.write(
+            f"""GOCAD TSurf 1 
+HEADER {{
+*solid*color: #ffa500
+ivolmap: false
+imap: false
+name: {surf.name}
+}}
+GOCAD_ORIGINAL_COORDINATE_SYSTEM
+NAME Default
+PROJECTION Unknown
+DATUM Unknown
+AXIS_NAME X Y Z
+AXIS_UNIT m m m
+ZPOSITIVE Elevation
+END_ORIGINAL_COORDINATE_SYSTEM
+GEOLOGICAL_FEATURE {surf.name}
+GEOLOGICAL_TYPE fault
+{properties_header if properties_header else ""}
+PROPERTY_CLASS_HEADER X {{
+kind: X
+unit: m
+}}
+PROPERTY_CLASS_HEADER Y {{
+kind: Y
+unit: m
+}}
+PROPERTY_CLASS_HEADER Z {{
+kind: Z
+unit: m
+is_z: on
+}}
+PROPERTY_CLASS_HEADER vector3d {{
+kind: Length
+unit: m
+}}
+TFACE
+"""
+        )
+        v_idx = 1
+        v_map = {}
+        for idx, vert in enumerate(surf.vertices):
+            if not np.isnan(vert[0]) and not np.isnan(vert[1]) and not np.isnan(vert[2]):
+                fd.write(f"VRTX {v_idx:} {vert[0]} {vert[1]} {vert[2]}")
+                if surf.properties:
+                    fd.writelines(f" {value[idx]}" for value in surf.properties.values())
+                fd.write("\n")
+                v_map[idx] = v_idx
+                v_idx += 1
+        for face in surf.triangles:
+            if face[0] in v_map and face[1] in v_map and face[2] in v_map:
+                fd.write(f"TRGL {v_map[face[0]]} {v_map[face[1]]} {v_map[face[2]]} \n")
+        fd.write("END\n")
+    return True
+
+
+# def _write_pointset(points, file_name):
+#     """
+#     Write out a GOCAD VS file for a pointset
+
+#     Parameters
+#     ----------
+#     points: SimpleNamespace()
+#         Details of the points, as a SimpleNamespace() object. Fields are:
+#             locations: locations, numpy ndarray with dtype = float64 & shape = (N,3)
+#             vectors: vectors, numpy ndarray with dtype = float64 & shape = (N,3)
+#             name: name of feature e.g. fault or supergroup, string
+
+#     file_name: string
+#         Desired filename
+
+#     Returns
+#     -------
+#     True if successful
+
+#     """
+#     file_name = Path(file_name).with_suffix(".vs")
+#     with open(f"{file_name}", "w") as fd:
+#         fd.write(
+#             f"""GOCAD VSet 1
+# HEADER {{
+# name: {points.name}
+# }}
+# GOCAD_ORIGINAL_COORDINATE_SYSTEM
+# NAME Default
+# PROJECTION Unknown