py4dgeo 1.0.0__cp314-cp314t-win_amd64.whl

py4dgeo/util.py

@@ -0,0 +1,348 @@
+import argparse
+import collections
+import logging
+import numpy as np
+import os
+import platform
+import psutil
+import pooch
+import requests
+import sys
+import warnings
+import xdg
+
+from importlib import metadata
+
+import _py4dgeo
+
+# The current data archive URL
+TEST_DATA_ARCHIVE = "doi:10.5281/zenodo.18378272/"
+PY4DGEO_REQUEST_HEADERS = {
+    "User-Agent": "py4dgeo (https://github.com/3dgeo-heidelberg/py4dgeo)"
+}
+
+# Read the version from package metadata
+__version__ = metadata.version(__package__)
+
+
+class Py4DGeoError(Exception):
+    def __init__(self, msg, loggername="py4dgeo"):
+        # Initialize the base class
+        super().__init__(msg)
+
+        # Also write the message to the error stream
+        logger = logging.getLogger(loggername)
+        logger.error(self)
+
+
+def get_test_data_dir():
+    return pooch.os_cache("py4dgeo")
+
+
+def download_test_data(path=None, filename=None):
+    """Download the test data"""
+
+    # Get the target path
+    if path is None:
+        path = get_test_data_dir()
+
+    # Create a pooch instance
+    p = pooch.create(path=path, base_url=TEST_DATA_ARCHIVE)
+    p.load_registry_from_doi()
+
+    # Decide which files to download, defaulting to all
+    files_to_download = (
+        [filename] if filename else ["usage_data.zip", "synthetic.zip", "pbm3c2.zip"]
+    )
+
+    # Download the files
+    for archive in files_to_download:
+        p.fetch(
+            archive,
+            downloader=pooch.DOIDownloader(
+                headers=PY4DGEO_REQUEST_HEADERS, timeout=(3, None)
+            ),
+            processor=pooch.Unzip(extract_dir="extracted"),
+        )
+
+    return path
+
+
+def find_file(filename, fatal=True):
+    """Find a file of given name on the file system.
+
+    This function is intended to use in tests and demo applications
+    to locate data files without resorting to absolute paths. You may
+    use it for your code as well.
+
+    It looks in the following locations:
+
+    * If an absolute filename is given, it is used
+    * Check whether the given relative path exists with respect to the current working directory
+    * Check whether the given relative path exists with respect to the specified XDG data directory (e.g. through the environment variable :code:`XDG_DATA_DIRS`).
+    * Check whether the given relative path exists in downloaded test data.
+    * If still not found, attempt to download test data and search again.
+
+    :param filename:
+        The (relative) filename to search for
+    :type filename: str
+    :param fatal:
+        Whether not finding the file should be a fatal error
+    :type fatal: bool
+    :return: An absolute filename
+    """
+
+    def search_candidates(filename):
+        """Search for the file in candidate locations, return path if found."""
+        # If the path is absolute, check it directly
+        if os.path.isabs(filename):
+            if os.path.exists(filename):
+                return filename
+            return None
+
+        # Gather a list of candidate paths for relative path
+        candidates = []
+
+        # Use the current working directory
+        candidates.append(os.path.join(os.getcwd(), filename))
+
+        data_dir = get_test_data_dir()
+        candidates.append(os.path.join(data_dir, filename))
+        if os.path.isdir(data_dir):
+            for root, _, files in os.walk(data_dir):
+                if filename in files:
+                    candidates.append(os.path.join(root, filename))
+
+        # Use the XDG data directories
+        if platform.system() in ["Linux", "Darwin"]:
+            for xdg_dir in xdg.xdg_data_dirs():
+                candidates.append(os.path.join(xdg_dir, filename))
+
+        # Iterate through the list to check for file existence
+        for candidate in candidates:
+            if os.path.exists(candidate):
+                return candidate
+
+        return None
+
+    # First attempt to find the file
+    result = search_candidates(filename)
+    if result:
+        return result
+
+    # File not found - try downloading test data
+    try:
+        download_test_data()
+    except Exception:
+        # Download failed, continue to error handling
+        pass
+
+    # Search again after download
+    result = search_candidates(filename)
+    if result:
+        return result
+
+    # Still not found
+    if fatal:
+        data_dir = get_test_data_dir()
+        candidates = [
+            os.path.join(os.getcwd(), filename),
+            os.path.join(data_dir, filename),
+        ]
+        if platform.system() in ["Linux", "Darwin"]:
+            for xdg_dir in xdg.xdg_data_dirs():
+                candidates.append(os.path.join(xdg_dir, filename))
+        raise FileNotFoundError(
+            f"Cannot locate file {filename}. Tried the following locations: {', '.join(candidates)}"
+        )
+
+    return filename
+
+
+class MemoryPolicy(_py4dgeo.MemoryPolicy):
+    """A descriptor for py4dgeo's memory usage policy
+
+    This can be used to describe the memory usage policy that py4dgeo
+    should follow. The implementation of py4dgeo checks the currently
+    set policy whenever it would make a memory allocation of the same order
+    of magnitude as the input pointcloud or the set of corepoints.
+    To globally set the policy, use :func:`~py4dgeo.set_memory_policy`.
+
+    Currently the following policies are available:
+
+    * :code:`STRICT`: py4dgeo is not allowed to do additional memory allocations.
+      If such an allocation would be required, an error is thrown.
+    * :code:`MINIMAL`: py4dgeo is allowed to do additional memory allocations if
+      and only if they are necessary for a seemless operation of the library.
+    * :code:`COREPOINTS`: py4dgeo is allowed to do additional memory allocations
+      as part of performance trade-off considerations (e.g. precompute vs. recompute),
+      but only if the allocation is on the order of the number of corepoints.
+      This is the default behaviour of py4dgeo.
+    * :code:`RELAXED`: py4dgeo is allowed to do additional memory allocations as
+      part of performance trade-off considerations (e.g. precompute vs. recompute).
+    """
+
+    pass
+
+
+# The global storage for the memory policy
+_policy = MemoryPolicy.COREPOINTS
+
+
+def set_memory_policy(policy: MemoryPolicy):
+    """Globally set py4dgeo's memory policy
+
+    For details about the memory policy, see :class:`~py4dgeo.MemoryPolicy`.
+    Use this once before performing any operations. Changing the memory policy
+    in the middle of the computation results in undefined behaviour.
+
+    :param policy: The policy value to globally set
+    :type policy: MemoryPolicy
+    """
+    global _policy
+    _policy = policy
+
+
+def get_memory_policy():
+    """Access the globally set memory policy"""
+    return _policy
+
+
+def memory_policy_is_minimum(policy: MemoryPolicy):
+    """Whether or not the globally set memory policy is at least the given one
+
+    :param policy: The policy value to compare against
+    :type policy: MemoryPolicy
+    :returns: Whether the globally set policy is at least the given one
+    :rtype: bool
+    """
+    return policy <= get_memory_policy()
+
+
+def make_contiguous(arr: np.ndarray):
+    """Make a numpy array contiguous
+
+    This is a no-op if the array is already contiguous and makes
+    a copy if it is not. It checks py4dgeo's memory policy before copying.
+
+    :param arr: The numpy array
+    :type arr: np.ndarray
+    """
+
+    if arr.flags["C_CONTIGUOUS"]:
+        return arr
+
+    if not memory_policy_is_minimum(MemoryPolicy.MINIMAL):
+        raise Py4DGeoError(
+            "Using non-contiguous memory layouts requires at least the MINIMAL memory policy"
+        )
+
+    return np.copy(arr, order="C")
+
+
+def _as_dtype(arr, dtype, policy_check):
+    if np.issubdtype(arr.dtype, dtype):
+        return arr
+
+    if policy_check and not memory_policy_is_minimum(MemoryPolicy.MINIMAL):
+        raise Py4DGeoError(
+            f"py4dgeo expected an input of type {np.dtype(dtype).name}, but got {np.dtype(arr.dtype).name}. Current memory policy forbids automatic cast."
+        )
+
+    return np.asarray(arr, dtype=dtype)
+
+
+def as_double_precision(arr: np.ndarray, policy_check=True):
+    """Ensure that a numpy array is double precision
+
+    This is a no-op if the array is already double precision and makes a copy
+    if it is not. It checks py4dgeo's memory policy before copying.
+
+    :param arr: The numpy array
+    :type arr: np.ndarray
+    """
+    return _as_dtype(arr, np.float64, policy_check)
+
+
+def set_num_threads(num_threads: int):
+    """Set the number of threads to use in py4dgeo
+
+    :param num_threads: The number of threads to use
+    "type num_threads: int
+    """
+
+    env_threads = os.environ.get("OMP_NUM_THREADS")
+    if env_threads:
+        try:
+            env_threads_int = int(env_threads)
+            if env_threads_int != num_threads:
+                warnings.warn(
+                    f"OMP_NUM_THREADS environment variable is set to {env_threads_int}, but set_num_threads({num_threads}) was called. The environment variable may override this setting."
+                )
+        except ValueError:
+            raise Py4DGeoError(f"Invalid value for OMP_NUM_THREADS: '{env_threads}'")
+    try:
+        _py4dgeo.omp_set_num_threads(num_threads)
+    except AttributeError:
+        # The C++ library was built without OpenMP!
+        if num_threads != 1:
+            raise Py4DGeoError("py4dgeo was built without threading support!")
+
+
+def get_num_threads():
+    """Get the number of threads currently used by py4dgeo
+
+    :return: The number of threads
+    :rtype: int
+    """
+
+    try:
+        return _py4dgeo.omp_get_max_threads()
+    except AttributeError:
+        # The C++ library was built without OpenMP!
+        return 1
+
+
+def append_file_extension(filename, extension):
+    """Append a file extension if and only if the original filename has none"""
+
+    _, ext = os.path.splitext(filename)
+    if ext == "":
+        return f"{filename}.{extension}"
+    else:
+        return filename
+
+
+def is_iterable(obj):
+    """Whether the object is an iterable (excluding a string)"""
+    return isinstance(obj, collections.abc.Iterable) and not isinstance(obj, str)
+
+
+def initialize_openmp_defaults():
+    """Set OpenMP environment variables for optimal performance on Windows with llvm OpenMP"""
+
+    # Only apply when using Windows
+    if platform.system() != "Windows":
+        return
+
+    # Only set if the user has not already
+    if "OMP_NUM_THREADS" not in os.environ:
+        num_cores = psutil.cpu_count(logical=False)
+        os.environ["OMP_NUM_THREADS"] = str(num_cores)
+
+
+def copy_test_data_entrypoint():
+    """A command line entry point to download test data"""
+
+    parser = argparse.ArgumentParser(description="Download py4dgeo test data")
+
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=os.getcwd(),
+        help="Target directory for test data (default: current working directory)",
+    )
+
+    args = parser.parse_args()
+
+    download_test_data(path=args.path)

py4dgeo-1.0.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.12.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qpltyhx6\\cp314t-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-v', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qpltyhx6\\cp314t-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qpltyhx6\\cp314t-win_amd64\\built_wheel\\py4dgeo-1.0.0-cp314-cp314t-win_amd64.whl']

py4dgeo-1.0.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: py4dgeo
+Version: 1.0.0
+Summary: Library for change detection in 4D point cloud data
+Keywords: point-cloud,change-detection,4D,geospatial,lidar
+Maintainer-Email: Dominic Kempf <ssc@iwr.uni-heidelberg.de>
+License-Expression: MIT
+License-File: LICENSE.md
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Intended Audience :: Science/Research
+Project-URL: homepage, https://github.com/3dgeo-heidelberg/py4dgeo/
+Project-URL: documentation, https://py4dgeo.readthedocs.io/
+Project-URL: repository, https://github.com/3dgeo-heidelberg/py4dgeo/
+Requires-Python: >=3.9
+Requires-Dist: dateparser
+Requires-Dist: laspy[lazrs]<3.0,>=2.0
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pooch
+Requires-Dist: requests
+Requires-Dist: seaborn
+Requires-Dist: scikit-learn
+Requires-Dist: xdg
+Requires-Dist: psutil
+Description-Content-Type: text/markdown
+
+# Welcome to py4dgeo
+
+<img src="https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/py4dgeo_logo.png?raw=true" alt="logo" style="width:500px;"/>
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/3dgeo-heidelberg/py4dgeo/ci.yml?branch=main)](https://github.com/3dgeo-heidelberg/py4dgeo/actions/workflows/ci.yml)
+[![PyPI Release](https://img.shields.io/pypi/v/py4dgeo.svg)](https://pypi.org/project/py4dgeo)
+[![Documentation Status](https://readthedocs.org/projects/py4dgeo/badge/)](https://py4dgeo.readthedocs.io/)
+[![codecov](https://codecov.io/gh/3dgeo-heidelberg/py4dgeo/branch/main/graph/badge.svg)](https://codecov.io/gh/3dgeo-heidelberg/py4dgeo)
+
+`py4dgeo` is a `C++` library with `Python` bindings for change analysis in multitemporal and 4D point clouds.
+
+Topographic 3D/4D point clouds are omnipresent in geosciences, environmental, ecological and archaeological sciences, robotics, and many more fields and applications. Technology to capture such data using laser scanning and photogrammetric techniques have evolved into standard tools. Dense time series of topographic point clouds are becoming increasing available and require tools for automatic analysis. Moreover, methods considering the full 4D (3D space + time) data are being developed in research and need to be made available in an accessible way with flexible integration into existent workflows.
+
+The **main objective** of `py4dgeo` is to bundle and provide different methods of 3D/4D change analysis in a dedicated, comprehensive Python library.
+`py4dgeo` is designed as an international open source project that can be integrated into almost any 3D and GIS software in the geodata domain supporting Python, e.g. as plugins.
+
+`py4dgeo` is under *ongoing active development*.
+Below, you find a list of [provided methods](#methods-provided-by-py4dgeo).
+
+
+## 🔨 Methods provided by py4dgeo
+
+* **M3C2 algorithm** ([Lague et al., 2013](#-literature)) for bitemporal point cloud distance computation.
+
+* **M3C2-EP** (M3C2-EP; [Winiwarter et al., 2021](#-literature)) for statistical signal-noise separation in change analysis through error propagation.
+
+* **4D objects-by-change** (4D-OBC; [Anders et al., 2021](#-literature)) for time series-based extraction of surface activities.
+
+* **Correspondence-driven plane-based M3C2** ([Zahs et al., 2022](#-literature)) for lower uncertainty in 3D topographic change quantification  *[under active development]*.
+
+* **Point cloud registration using standard ICP** by calculating and applying affine transformations to point clouds using a standard ICP implementations.
+
+* **Point cloud registration with automatic determination of stable areas** ([Yang et al., 2022](https://doi.org/10.1515/jag-2022-0031)) for multitemporal change detection.
+
+## 🎮 Examples
+
+### Demo notebooks using methods provided by py4dgeo
+|                                                                                                                                                              |                                                                                                                                                                 |
+|--------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [![Example 1](img/m3c2_change_analysis_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/m3c2-change_analysis.ipynb)       | [![Example 2](img/m3c2ep_change_analysis_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/m3c2ep_change_analysis.ipynb)      |
+| [![Example 3](img/4dobc_extraction_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/4dobc-change_analysis.ipynb)          | [![Example 4](img/kmeans_clustering_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/kmeans_clustering_of_time_series.ipynb) |
+| [![Example 5](img/pca_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/principal_component_analysis_of_time_series.ipynb) | [![Example 6](img/pbm3c2_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/jupyter/pbm3c2.ipynb)                                   |
+| [![Example 7](img/standard_icp_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/24fe2b105c1f05bc30dab02b16960ba09c3b0f0b/demo/registration_standard_ICP.ipynb)          |
+
+
+## 💻 Installation
+
+### Prerequisites
+
+Using py4dgeo requires the following software installed:
+
+* 64-bit Python `>= 3.9` (32-bit installations might cause trouble during installation of dependencies)
+
+In order to build the package from source, the following tools are also needed.
+
+* A C++17-compliant compiler
+* Doxygen (optional, documentation building is skipped if missing)
+
+### Installing py4dgeo
+
+The preferred way of installing `py4dgeo` is using `pip`.
+
+### Installing the release version using pip
+
+`py4dgeo` can be installed using `pip` to obtain the [current release](https://pypi.org/project/py4dgeo/):
+
+```
+python -m pip install py4dgeo
+```
+
+### Building from source using pip
+
+The following sequence of commands is used to build `py4dgeo` from source:
+
+```
+git clone --recursive https://github.com/3dgeo-heidelberg/py4dgeo.git
+cd py4dgeo
+python -m pip install -v --editable .
+```
+
+The `--editable` flag allows you to change the Python sources of `py4dgeo` without
+reinstalling the package. The `-v` flag enables verbose output which gives you
+detailed information about the compilation process that you should include into
+potential bug reports. To recompile the C++ source, please run `pip install` again.
+In order to enable multi-threading on builds from source, your compiler toolchain
+needs to support `OpenMP`.
+
+If you want to contribute to the library's development you should also install
+its additional Python dependencies for testing and documentation building:
+
+```
+python -m pip install -r requirements-dev.txt
+```
+
+### 🪟 Windows-specific Notes
+py4dgeo works on Windows, but optimal performance is typically achieved on Linux.
+
+If you want to experiment with performance on your system, you can tune OpenMP using environment variables such as ```OMP_NUM_THREADS```, ```OMP_PROC_BIND```, and ```OMP_PLACES```.
+
+The best settings depend on your system, so there is no single recommended configuration.
+
+### Setting up py4dgeo using Docker
+
+Additionally, `py4dgeo` provides a Docker image that allows to explore
+the library using JupyterLab. The image can be locally built and run with
+the following commands:
+
+```
+docker build -t py4dgeo:latest .
+docker run -t -p 8888:8888 py4dgeo:latest
+```
+
+## 🐍 Documentation of software usage
+
+As a starting point, please have a look to the [Jupyter Notebooks](jupyter) available in the repository and find the `py4dgeo` documentation [on readthedocs](https://py4dgeo.readthedocs.io/en/latest/intro.html).
+
+## 🌐 Published test data
+
+<!-- TODO: integrate example notebooks for these use cases and data -->
+
+If you are looking for data to test different methods, consider the following open data publications:
+
+### Hourly TLS point clouds of a sandy beach
+
+<a href="https://doi.org/10.1038/s41597-022-01291-9" target="_blank"><img src="https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/doc/img/data_vos_2022_kijkduin.png?raw=true" alt="" width="450" /></a>
+<br>
+Vos et al. (2022): [https://doi.org/10.1038/s41597-022-01291-9](https://doi.org/10.1038/s41597-022-01291-9).
+
+
+### By-weekly TLS point clouds of an Alpine rock glacier
+
+<a href="https://doi.org/10.11588/data/TGSVUI" target="_blank"><img src="https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/doc/img/data_zahs_2022_ahk_2019_tls.png?raw=true" alt="" width="450" /></a>
+<br>
+Zahs et al. (2022): [https://doi.org/10.11588/data/TGSVUI](https://doi.org/10.11588/data/TGSVUI).
+
+
+
+
+## 📑 Citation
+Please cite py4dgeo when using it in your research and reference the appropriate release version.
+
+<!-- TODO: All releases of py4dgeo are listed on Zenodo where you will find the citation information including DOI. -->
+
+```
+article{py4dgeo,
+author = {py4dgeo Development Core Team}
+title = {py4dgeo: library for change analysis in 4D point clouds},
+journal = {},
+year = {2022},
+number = {},
+volume = {},
+doi = {},
+url = {https://github.com/3dgeo-heidelberg/py4dgeo},
+}
+ ```
+
+## 💟 Funding / Acknowledgements
+The initial software development was supported by the [**Scientific Software Center (SSC)**](https://ssc.iwr.uni-heidelberg.de/) in the Open Call 2021. The scientific software project is further supported by the research projects [**CharAct4D**](https://www.uni-heidelberg.de/charact4d) and [**AImon5.0**](https://www.uni-heidelberg.de/aimon).
+
+## 🔔 Contact / Bugs / Feature Requests
+
+You think you have found a bug or have specific request for a new feature? Please open a new issue in the online code repository on Github. Also for general questions please use the issue system.
+
+Scientific requests can be directed to the [3DGeo Research Group Heidelberg](https://uni-heidelberg.de/3dgeo) and its respective members.
+
+## 📄 How to contribute
+
+We welcome contributions of new methods and usage demonstrations!
+Please see the full guidelines in our [CONTRIBUTING.md](./CONTRIBUTING.md) for details on how to get started.
+
+## 📜 License
+
+See [LICENSE.md](LICENSE.md).
+
+
+## 📚 Related literature
+
+* Anders, K., Winiwarter, L., Mara, H., Lindenbergh, R., Vos, S.E. & Höfle, B. (2021): Fully automatic spatiotemporal segmentation of 3D LiDAR time series for the extraction of natural surface changes. ISPRS Journal of Photogrammetry and Remote Sensing, 173, pp. 297-308. DOI: [10.1016/j.isprsjprs.2021.01.015](https://doi.org/10.1016/j.isprsjprs.2021.01.015).
+* Lague, D., Brodu, N., & Leroux, J. (2013). Accurate 3D comparison of complex topography with terrestrial laser scanner: Application to the Rangitikei canyon (N-Z). ISPRS Journal of Photogrammetry and Remote Sensing, 82, pp. 10-26. DOI: [10.1016/j.isprsjprs.2013.04.009](https://doi.org/10.1016/j.isprsjprs.2013.04.009).
+* Winiwarter, L., Anders, K., Höfle, B. (2021): M3C2-EP: Pushing the limits of 3D topographic point cloud change detection by error propagation. ISPRS Journal of Photogrammetry and Remote Sensing, 178, pp. 240–258. DOI: [10.1016/j.isprsjprs.2021.06.011](https://doi.org/10.1016/j.isprsjprs.2021.06.011).
+* Zahs, V., Winiwarter, L., Anders, K., Williams, J.G., Rutzinger, M. & Höfle, B. (2022): Correspondence-driven plane-based M3C2 for lower uncertainty in 3D topographic change quantification. ISPRS Journal of Photogrammetry and Remote Sensing, 183, pp. 541-559. DOI: [10.1016/j.isprsjprs.2021.11.018](https://doi.org/10.1016/j.isprsjprs.2021.11.018).

py4dgeo-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+_py4dgeo.cp314t-win_amd64.pyd,sha256=iITsIHNbQxoN_LOpU4EVWHJxvJ_1bDIJvSRQIeYqp2Q,941568
+py4dgeo/cloudcompare.py,sha256=Bit7dXXW0-EO8Aa55aLxspLdTtzlKgvjBfKxpOd-5Uk,1109
+py4dgeo/epoch.py,sha256=y-DR19Lcyc9fpvw33i3WKy6U16DnIvrdcK05xpV3lFw,31587
+py4dgeo/fallback.py,sha256=5fL4OK8MIA7IMdgneRAVpmk8BWY_6ppYXIdtSvBMyDo,5240
+py4dgeo/logger.py,sha256=JOvLQpgQ2cNQ1SfvX9Ym9VqmBeom7OUz3V54e1EEP3Y,2470
+py4dgeo/m3c2.py,sha256=v7JNkAKt-GVnomnfwAYiXPEztOoWAn7soBAAmzJWo1s,8449
+py4dgeo/m3c2ep.py,sha256=Xjwbjc8fIFFiEX6ulcVtZCt8MXnH_o5G7_HUmhIDlDw,29242
+py4dgeo/pbm3c2.py,sha256=-wmYetC9QPmHloYHIPCA5a8EwuVxIjONxvWrkiRKR3Q,26247
+py4dgeo/py4dgeo_python.cpp,sha256=v_qlpI_wFCr0aNW72whMUYg3yVPQ6mks6v9ctr9gOg0,30607
+py4dgeo/registration.py,sha256=aUdEas772buy31PVv-hA5Y3v-jGnnGeJB8Bo56eV4zg,17640
+py4dgeo/segmentation.py,sha256=au3EWQHE9aCQb0grSIqKVZ9nTZniPXinVd-1ZZyswqo,55193
+py4dgeo/UpdateableZipFile.py,sha256=aZVdQgAc_M-EWFDIEVukgrYQUtEb5fRoRMCVxZqpggc,2770
+py4dgeo/util.py,sha256=8ly8Kxo-1710xH80_J_xWHwqxJrVTELILmR8IzAq_pY,11280
+py4dgeo/__init__.py,sha256=E6XT0ZFCx_zUseRG4fu7ZmbzuguG6ykFniaEwBrYksw,1188
+py4dgeo-1.0.0.data/platlib/libomp-a12116ba72d1d6820407cf30be23da04.dll,sha256=oSEWunLR1oIEB88wviPaBM551ruKcaXucXWcWh-qbxw,768000
+py4dgeo-1.0.0.data/platlib/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
+py4dgeo-1.0.0.dist-info/DELVEWHEEL,sha256=7SCERVRsLj-5I4sioGmxyZGApnghT_E9DcEtwhMUdY8,410
+py4dgeo-1.0.0.dist-info/entry_points.txt,sha256=S8EHFVRD4deFJ_N6ZWst9v_ukH5lGnZY-f8NHjYoIfk,83
+py4dgeo-1.0.0.dist-info/METADATA,sha256=48UU9RFNnjwI-WlLV9Ng7gWO8mo9O9R-w-1rwhSmNNc,12320
+py4dgeo-1.0.0.dist-info/RECORD,,
+py4dgeo-1.0.0.dist-info/WHEEL,sha256=Wp6T4xrwRfJfFoFG_idqZkQJxYyHg92Cyiw2fzTnaZY,107
+py4dgeo-1.0.0.dist-info/licenses/LICENSE.md,sha256=Rza103klOvpFdEr8ed20dZErIT6Tm998uX2ai29wDl8,1028

py4dgeo-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp314-cp314t-win_amd64
+

py4dgeo-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+copy_py4dgeo_test_data = py4dgeo.util:copy_test_data_entrypoint
+

py4dgeo-1.0.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,5 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.