py4dgeo 0.7.0__cp39-cp39-win_amd64.whl → 0.8.0__cp39-cp39-win_amd64.whl

py4dgeo/__init__.py

@@ -1,3 +1,33 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_11_1():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, '.'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-py4dgeo-0.8.0')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-py4dgeo-0.8.0')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_11_1()
+del _delvewheel_patch_1_11_1
+# end delvewheel patch
+
 from py4dgeo.logger import set_py4dgeo_logfile
 from py4dgeo.cloudcompare import CloudCompareM3C2
 from py4dgeo.epoch import (
@@ -7,6 +37,7 @@ from py4dgeo.epoch import (
     save_epoch,
     load_epoch,
 )
+from _py4dgeo import SearchTree
 from py4dgeo.m3c2 import M3C2, write_m3c2_results_to_las
 from py4dgeo.m3c2ep import M3C2EP
 from py4dgeo.registration import (
@@ -27,6 +58,9 @@ from py4dgeo.util import (
     set_memory_policy,
     get_num_threads,
     set_num_threads,
+    initialize_openmp_defaults,
 )
 
+initialize_openmp_defaults()
+
 from py4dgeo.pbm3c2 import *

py4dgeo/epoch.py

@@ -115,6 +115,16 @@ class Epoch(_py4dgeo.Epoch):
             "The KDTree of an Epoch cannot be changed after initialization."
         )
 
+    @property
+    def octree(self):
+        return self._octree
+
+    @octree.setter
+    def octree(self, octree):
+        raise Py4DGeoError(
+            "The Octree of an Epoch cannot be changed after initialization."
+        )
+
     @property
     def normals(self):
         # Maybe calculate normals
@@ -137,9 +147,7 @@ class Epoch(_py4dgeo.Epoch):
             A vector to determine orientation of the normals. It should point "up".
         """
 
-        # Ensure that the KDTree is built
-        if self.kdtree.leaf_parameter() == 0:
-            self.build_kdtree()
+        self._validate_search_tree()
 
         # Reuse the multiscale code with a single radius in order to
         # avoid code duplication.
@@ -153,6 +161,18 @@ class Epoch(_py4dgeo.Epoch):
 
         return self.normals
 
+    def _validate_search_tree(self):
+        """ "Check if the default search tree is built"""
+
+        tree_type = self.get_default_radius_search_tree()
+
+        if tree_type == _py4dgeo.SearchTree.KDTreeSearch:
+            if self.kdtree.leaf_parameter() == 0:
+                self.build_kdtree()
+        else:
+            if self.octree.get_number_of_points() == 0:
+                self.build_octree()
+
     def normals_attachment(self, normals_array):
         """Attach normals to the epoch object
 
@@ -282,6 +302,12 @@ class Epoch(_py4dgeo.Epoch):
             logger.info(f"Building KDTree structure with leaf parameter {leaf_size}")
             self.kdtree.build_tree(leaf_size)
 
+    def build_octree(self):
+        """Build the search octree index"""
+        if self.octree.get_number_of_points() == 0:
+            logger.info(f"Building Octree structure")
+            self.octree.build_tree()
+
     def transform(
         self,
         transformation: typing.Optional[Transformation] = None,
@@ -343,6 +369,9 @@ class Epoch(_py4dgeo.Epoch):
         # Invalidate the KDTree
         self.kdtree.invalidate()
 
+        # Invalidate the Octree
+        self.octree.invalidate()
+
         if self._normals is None:
             self._normals = np.empty((1, 3))  # dummy array to avoid error in C++ code
         # Apply the actual transformation as efficient C++
@@ -453,6 +482,11 @@ class Epoch(_py4dgeo.Epoch):
                     self.kdtree.save_index(kdtreefile)
                 zf.write(kdtreefile, arcname="kdtree")
 
+                octreefile = os.path.join(tmp_dir, "octree")
+                with open(octreefile, "w") as f:
+                    self.octree.save_index(octreefile)
+                zf.write(octreefile, arcname="octree")
+
     @staticmethod
     def load(filename):
         """Construct an Epoch instance by loading it from a file
@@ -499,6 +533,15 @@ class Epoch(_py4dgeo.Epoch):
                 kdtreefile = zf.extract("kdtree", path=tmp_dir)
                 epoch.kdtree.load_index(kdtreefile)
 
+                # Restore the Octree object if present
+                try:
+                    octreefile = zf.extract("octree", path=tmp_dir)
+                    epoch.octree.load_index(octreefile)
+                except KeyError:
+                    logger.warning(
+                        "No octree found in the archive. Skipping octree loading."
+                    )
+
                 # Read the transformation if it exists
                 if version >= 3:
                     trafofile = zf.extract("trafo.json", path=tmp_dir)
@@ -578,6 +621,7 @@ def read_from_xyz(
     xyz_columns=[0, 1, 2],
     normal_columns=[],
     additional_dimensions={},
+    additional_dimensions_dtypes={},
     **parse_opts,
 ):
     """Create an epoch from an xyz file
@@ -603,6 +647,11 @@ def read_from_xyz(
         They will be read from the file and are accessible under their names from the
         created Epoch objects.
         Additional column indexes start with 3.
+    :type additional_dimensions: dict
+    :param additional_dimensions_dtypes:
+        A dictionary, mapping column names to numpy dtypes which should be used
+        in parsing the data.
+    :type additional_dimensions_dtypes: dict
     :type parse_opts: dict
     """
 
@@ -633,32 +682,29 @@ def read_from_xyz(
 
         try:
             normals = np.genfromtxt(
-                filename, dtype=np.float64, usecols=normal_columns, **parse_opts
+                filename,
+                dtype=np.float64,
+                usecols=normal_columns,
+                **parse_opts,
             )
         except ValueError:
             raise Py4DGeoError("Malformed XYZ file")
 
     # Potentially read additional_dimensions passed by the user
-    additional_columns = np.empty(
-        shape=(cloud.shape[0], 1),
-        dtype=np.dtype([(name, "<f8") for name in additional_dimensions.values()]),
-    )
-
-    add_cols = list(sorted(additional_dimensions.keys()))
-    try:
-        parsed_additionals = np.genfromtxt(
-            filename, dtype=np.float64, usecols=add_cols, **parse_opts
+    if additional_dimensions:
+        additional_columns = np.genfromtxt(
+            filename,
+            dtype=np.dtype(
+                [
+                    (name, additional_dimensions_dtypes.get(name, np.float64))
+                    for name in additional_dimensions.values()
+                ]
+            ),
+            usecols=additional_dimensions.keys(),
+            **parse_opts,
         )
-        # Ensure that the parsed array is two-dimensional, even if only
-        # one additional dimension was given (avoids an edge case)
-        parsed_additionals = parsed_additionals.reshape(-1, 1)
-    except ValueError:
-        raise Py4DGeoError("Malformed XYZ file")
-
-    for i, col in enumerate(add_cols):
-        additional_columns[additional_dimensions[col]] = parsed_additionals[
-            :, i
-        ].reshape(-1, 1)
+    else:
+        additional_columns = np.empty(shape=(cloud.shape[0], 1), dtype=[])
 
     # Finalize the construction of the new epoch
     new_epoch = Epoch(cloud, normals=normals, additional_dimensions=additional_columns)
@@ -675,6 +721,7 @@ def read_from_xyz(
                 xyz_columns=xyz_columns,
                 normal_columns=normal_columns,
                 additional_dimensions=additional_dimensions,
+                additional_dimensions_dtypes=additional_dimensions_dtypes,
                 **parse_opts,
             )
         )
@@ -725,16 +772,20 @@ def read_from_las(*filenames, normal_columns=[], additional_dimensions={}):
             ]
         ).transpose()
 
-    # set scan positions
     # build additional_dimensions dtype structure
     additional_columns = np.empty(
         shape=(cloud.shape[0], 1),
-        dtype=np.dtype([(name, "<f8") for name in additional_dimensions.values()]),
+        dtype=np.dtype(
+            [
+                (column_name, lasfile.points[column_id].dtype)
+                for column_id, column_name in additional_dimensions.items()
+            ]
+        ),
     )
+
+    # and fill it with the data from the lasfile
     for column_id, column_name in additional_dimensions.items():
-        additional_columns[column_name] = np.array(
-            lasfile.points[column_id], dtype=np.int32
-        ).reshape(-1, 1)
+        additional_columns[column_name] = lasfile.points[column_id].reshape(-1, 1)
 
     # Construct Epoch and go into recursion
     new_epoch = Epoch(

py4dgeo/fallback.py

@@ -7,7 +7,7 @@ import _py4dgeo
 
 
 def radius_workingset_finder(params: _py4dgeo.WorkingSetFinderParameters) -> np.ndarray:
-    indices = params.epoch._kdtree.radius_search(params.corepoint, params.radius)
+    indices = params.epoch._radius_search(params.corepoint, params.radius)
     return params.epoch._cloud[indices, :]
 
 
@@ -35,7 +35,7 @@ def cylinder_workingset_finder(
             params.corepoint[0, :]
             + (2 * i - N + 1) / N * max_cylinder_length * params.cylinder_axis[0, :]
         )
-        indices = params.epoch._kdtree.radius_search(qp, r_cyl)
+        indices = params.epoch._radius_search(qp, r_cyl)
 
         # Gather the points from the point cloud
         superset = params.epoch._cloud[indices, :]
@@ -85,12 +85,12 @@ def mean_stddev_distance(
             np.sqrt(
                 variance1 / params.workingset1.shape[0]
                 + variance2 / params.workingset2.shape[0]
-            )
+            ).item()
             + params.registration_error
         ),
-        spread1=np.sqrt(variance1),
+        spread1=np.sqrt(variance1).item(),
         num_samples1=params.workingset1.shape[0],
-        spread2=np.sqrt(variance2),
+        spread2=np.sqrt(variance2).item(),
         num_samples2=params.workingset2.shape[0],
     )
 

py4dgeo/m3c2.py

@@ -72,7 +72,9 @@ class M3C2LikeAlgorithm(abc.ABC):
         """The normal direction(s) to use for this algorithm."""
         raise NotImplementedError
 
-    def calculate_distances(self, epoch1, epoch2):
+    def calculate_distances(
+        self, epoch1, epoch2, searchtree: typing.Optional[str] = None
+    ):
         """Calculate the distances between two epochs"""
 
         if isinstance(self.cyl_radii, typing.Iterable):
@@ -80,7 +82,9 @@ class M3C2LikeAlgorithm(abc.ABC):
                 "DEPRECATION: use cyl_radius instead of cyl_radii. In a future version, cyl_radii will be removed!"
             )
             if len(self.cyl_radii) != 1:
-                Py4DGeoError("cyl_radii must be a list containing a single float!")
+                raise Py4DGeoError(
+                    "cyl_radii must be a list containing a single float!"
+                )
             elif self.cyl_radius is None:
                 self.cyl_radius = self.cyl_radii[0]
             self.cyl_radii = None
@@ -90,11 +94,9 @@ class M3C2LikeAlgorithm(abc.ABC):
                 f"{self.name} requires exactly one cylinder radius to be given as a float."
             )
 
-        # Ensure that the KDTree data structures have been built. This is no-op
-        # if it has already been triggered before - e.g. by a user with a custom
-        # leaf cutoff parameter.
-        epoch1.build_kdtree()
-        epoch2.build_kdtree()
+        # Ensure appropriate trees are built
+        epoch1._validate_search_tree()
+        epoch2._validate_search_tree()
 
         distances, uncertainties = _py4dgeo.compute_distances(
             self.corepoints,
@@ -174,8 +176,9 @@ class M3C2(M3C2LikeAlgorithm):
         if normals_epoch is None:
             normals_epoch = self.epochs[0]
         normals_epoch = as_epoch(normals_epoch)
-        # Ensure that the KDTree data structures have been built.
-        normals_epoch.build_kdtree()
+
+        # Ensure appropriate tree structures have been built
+        normals_epoch._validate_search_tree()
 
         # Trigger the precomputation
         self.corepoint_normals, self._directions_radii = (

py4dgeo/m3c2ep.py

@@ -61,8 +61,9 @@ class M3C2EP(M3C2):
                 f"{self.name} requires exactly one cylinder radius to be given"
             )
 
-        epoch1.build_kdtree()
-        epoch2.build_kdtree()
+        # Ensure appropriate trees are built
+        epoch1._validate_search_tree()
+        epoch2._validate_search_tree()
 
         p1_coords = epoch1.cloud
         p1_positions = epoch1.scanpos_id
@@ -837,13 +838,13 @@ def radius_search(epoch: Epoch, query: np.ndarray, radius: float):
     :type radius: float
     """
     if len(query.shape) == 1 and query.shape[0] == 3:
-        return [epoch.kdtree.radius_search(query, radius)]
+        return [epoch._radius_search(query, radius)]
 
     if len(query.shape) == 2 and query.shape[1] == 3:
         neighbors = []
         for i in range(query.shape[0]):
             q = query[i]
-            result = epoch.kdtree.radius_search(q, radius)
+            result = epoch._radius_search(q, radius)
             neighbors.append(result)
         return neighbors
 

py4dgeo/pbm3c2.py

@@ -182,7 +182,7 @@ def _extract_from_additional_dimensions(
     for column in column_names:
         if column in epoch.additional_dimensions.dtype.names:
             result = np.concatenate(
-                (result, epoch.additional_dimensions[column]), axis=1
+                (result, epoch.additional_dimensions[column].reshape(-1, 1)), axis=1
             )
         else:
             logger.debug(
@@ -572,19 +572,19 @@ def generate_extended_y_from_prior_knowledge(
 
     # generate kd-tree for each of the 2 sets
     epoch0 = Epoch(epoch0_set.T)
-    epoch0.build_kdtree()
+    epoch0._validate_search_tree()
     epoch1 = Epoch(epoch1_set.T)
-    epoch1.build_kdtree()
+    epoch1._validate_search_tree()
 
     # search for the near segments and build the 'extended y'
     for row in pairs_of_points:
         seg_epoch0, seg_epoch1, label = np.split(ary=row, indices_or_sections=[3, 6])
         label = label[0]
 
-        candidates_seg_epoch0 = epoch0.kdtree.radius_search(
+        candidates_seg_epoch0 = epoch0._radius_search(
             seg_epoch0, threshold_max_distance
         )
-        candidates_seg_epoch1 = epoch1.kdtree.radius_search(
+        candidates_seg_epoch1 = epoch1._radius_search(
             seg_epoch1, threshold_max_distance
         )
 
@@ -675,16 +675,16 @@ def add_no_corresponding_seg(
     epoch1_set = segments[epoch1_mask][X_Y_Z_Columns]
 
     epoch0_set = epoch0_set.T
-    # generate kd-tree
+    # generate search tree
     epoch1 = Epoch(epoch1_set.T)
-    epoch1.build_kdtree()
+    epoch1._validate_search_tree()
 
     # search for the near segments and build the 'extended y'
     # for row in pairs_of_points:
     for index, row in enumerate(epoch0_set):
         index_seg_epoch0 = epoch0_index[index]
 
-        candidates_seg_epoch1 = epoch1.kdtree.radius_search(row, threshold_max_distance)
+        candidates_seg_epoch1 = epoch1._radius_search(row, threshold_max_distance)
 
         indexes_seg_epoch1 = epoch1_index[candidates_seg_epoch1]
 
@@ -925,7 +925,7 @@ class PerPointComputation(BaseTransformer):
         ]
 
         for current_epoch in _epoch:
-            current_epoch.build_kdtree()
+            current_epoch._validate_search_tree()
 
         # add extra columns
         # Eigenvalues( 3 columns ) |
@@ -940,7 +940,7 @@ class PerPointComputation(BaseTransformer):
             lambda x: self._llsv_and_pca(
                 x,
                 _epoch[int(x[self.columns.EPOCH_ID_COLUMN])].cloud[
-                    _epoch[int(x[self.columns.EPOCH_ID_COLUMN])].kdtree.radius_search(
+                    _epoch[int(x[self.columns.EPOCH_ID_COLUMN])]._radius_search(
                         x[X_Y_Z_Columns], self.radius
                     )
                 ],
@@ -1201,7 +1201,7 @@ class Segmentation(BaseTransformer):
         ]
 
         for current_epoch in _epoch:
-            current_epoch.build_kdtree()
+            current_epoch._validate_search_tree()
 
         # sort by the "Lowest local surface variation"
         sort_indx_epoch0 = X[mask_epoch0, self.columns.LLSV_COLUMN].argsort()
@@ -1224,7 +1224,7 @@ class Segmentation(BaseTransformer):
                     cumulative_distance_for_std_deviation = 0
                     nr_points_for_std_deviation = 0
 
-                    indx_kd_tree_list = _epoch[epoch_id].kdtree.radius_search(
+                    indx_kd_tree_list = _epoch[epoch_id]._radius_search(
                         X[indx_row, X_Y_Z_Columns], self.radius
                     )[: self.max_nr_points_neighborhood]
                     for indx_kd_tree in indx_kd_tree_list:
@@ -1975,13 +1975,13 @@ class ClassifierWrapper(ClassifierMixin, BaseEstimator):
                 :, [self.columns.X_COLUMN, self.columns.Y_COLUMN, self.columns.Z_COLUMN]
             ]
         )
-        self.epoch1_segments.build_kdtree()
+        self.epoch1_segments._validate_search_tree()
 
         list_segments_pair = np.empty((0, epoch0_set.shape[1] + epoch1_set.shape[1]))
 
         # this operation can be parallelized
         for epoch0_set_row in epoch0_set:
-            list_candidates = self.epoch1_segments.kdtree.radius_search(
+            list_candidates = self.epoch1_segments._radius_search(
                 epoch0_set_row, self.neighborhood_search_radius
             )
 

py4dgeo/py4dgeo_python.cpp

@@ -8,18 +8,27 @@
 #include <omp.h>
 #endif
 
-#include "py4dgeo/compute.hpp"
-#include "py4dgeo/epoch.hpp"
-#include "py4dgeo/kdtree.hpp"
-#include "py4dgeo/py4dgeo.hpp"
-#include "py4dgeo/pybind11_numpy_interop.hpp"
-#include "py4dgeo/registration.hpp"
-#include "py4dgeo/segmentation.hpp"
-
+#include <py4dgeo/compute.hpp>
+#include <py4dgeo/epoch.hpp>
+#include <py4dgeo/kdtree.hpp>
+#include <py4dgeo/octree.hpp>
+#include <py4dgeo/py4dgeo.hpp>
+#include <py4dgeo/pybind11_numpy_interop.hpp>
+#include <py4dgeo/registration.hpp>
+#include <py4dgeo/searchtree.hpp>
+#include <py4dgeo/segmentation.hpp>
+
+#include <algorithm>
+#include <cstddef>
 #include <fstream>
+#include <ios>
+#include <optional>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <tuple>
+#include <utility>
+#include <vector>
 
 namespace py = pybind11;
 
@@ -37,6 +46,12 @@ PYBIND11_MODULE(_py4dgeo, m)
     .value("RELAXED", MemoryPolicy::RELAXED)
     .export_values();
 
+  // The enum class for the type of search tree
+  py::enum_<SearchTree>(m, "SearchTree")
+    .value("KDTreeSearch", SearchTree::KDTree)
+    .value("OctreeSearch", SearchTree::Octree)
+    .export_values();
+
   // Register a numpy structured type for uncertainty calculation. This allows
   // us to allocate memory in C++ and expose it as a structured numpy array in
   // Python. The given names will be usable in Python.
@@ -64,9 +79,86 @@ PYBIND11_MODULE(_py4dgeo, m)
   // garbage collected as long as the Epoch object is alive
   epoch.def(py::init<EigenPointCloudRef>(), py::keep_alive<1, 2>());
 
-  // We can directly access the point cloud and the kdtree
+  // We can directly access the point cloud, the kdtree and the octree
   epoch.def_readwrite("_cloud", &Epoch::cloud);
   epoch.def_readwrite("_kdtree", &Epoch::kdtree);
+  epoch.def_readwrite("_octree", &Epoch::octree);
+
+  epoch.def(
+    "_radius_search",
+    [](Epoch& self, py::array_t<double> qp, double radius) {
+      // Ensure appropriate search tree has been built
+      if (Epoch::get_default_radius_search_tree() == SearchTree::KDTree) {
+        if (self.kdtree.get_leaf_parameter() == 0) {
+          self.kdtree.build_tree(10);
+        }
+      } else {
+        if (self.octree.get_number_of_points() == 0) {
+          self.octree.build_tree();
+        }
+      }
+
+      // Get a pointer for the query point
+      auto ptr = static_cast<const double*>(qp.request().ptr);
+
+      // Now perform the radius search
+      RadiusSearchResult result;
+      auto radius_search_func = get_radius_search_function(self, radius);
+      Eigen::Vector3d query_point(ptr[0], ptr[1], ptr[2]);
+      radius_search_func(query_point, result);
+
+      return as_pyarray(std::move(result));
+    },
+    py::arg("query_point"),
+    py::arg("radius"),
+    "Perform a radius search");
+
+  // Set and get default search trees
+  epoch.def_static(
+    "set_default_radius_search_tree",
+    [](const std::string& tree_name_input) {
+      std::string tree_name = tree_name_input;
+      std::transform(
+        tree_name.begin(), tree_name.end(), tree_name.begin(), ::tolower);
+
+      if (tree_name == "kdtree") {
+        Epoch::set_default_radius_search_tree(SearchTree::KDTree);
+      } else if (tree_name == "octree") {
+        Epoch::set_default_radius_search_tree(SearchTree::Octree);
+      } else {
+        throw std::invalid_argument("Unknown search tree type: " +
+                                    tree_name_input);
+      }
+    },
+    py::arg("tree_name"),
+    "Set the default search tree for radius searches (\"kdtree\" or "
+    "\"octree\")");
+
+  epoch.def_static(
+    "set_default_nearest_neighbor_tree",
+    [](const std::string& tree_name_input) {
+      std::string tree_name = tree_name_input;
+      std::transform(
+        tree_name.begin(), tree_name.end(), tree_name.begin(), ::tolower);
+
+      if (tree_name == "kdtree") {
+        Epoch::set_default_nearest_neighbor_tree(SearchTree::KDTree);
+      } else if (tree_name == "octree") {
+        Epoch::set_default_nearest_neighbor_tree(SearchTree::Octree);
+      } else {
+        throw std::invalid_argument("Unknown search tree type: " +
+                                    tree_name_input);
+      }
+    },
+    py::arg("tree_name"),
+    "Set the default search tree for nearest neighbor searches (\"kdtree\" or "
+    "\"octree\")");
+
+  epoch.def_static("get_default_radius_search_tree",
+                   &Epoch::get_default_radius_search_tree);
+
+  epoch.def_static("get_default_nearest_neighbor_tree",
+                   &Epoch::get_default_nearest_neighbor_tree);
 
   // Pickling support for the Epoch class
   epoch.def(py::pickle(
@@ -101,15 +193,17 @@ PYBIND11_MODULE(_py4dgeo, m)
 
   // Allow building the KDTree structure
   kdtree.def(
-    "build_tree", &KDTree::build_tree, "Trigger building the search tree");
+    "build_tree", &KDTree::build_tree, "Trigger building the search k-d tree");
 
   // Allow invalidating the KDTree structure
-  kdtree.def("invalidate", &KDTree::invalidate, "Invalidate the search tree");
+  kdtree.def(
+    "invalidate", &KDTree::invalidate, "Invalidate the search k-d tree");
 
-  // Give access to the leaf parameter that the tree has been built with
-  kdtree.def("leaf_parameter",
-             &KDTree::get_leaf_parameter,
-             "Retrieve the leaf parameter that the tree has been built with.");
+  // Give access to the leaf parameter that the k-d tree has been built with
+  kdtree.def(
+    "leaf_parameter",
+    &KDTree::get_leaf_parameter,
+    "Retrieve the leaf parameter that the k-d tree has been built with.");
 
   // Add all the radius search methods
   kdtree.def(
@@ -118,7 +212,7 @@ PYBIND11_MODULE(_py4dgeo, m)
       // Get a pointer for the query point
       auto ptr = static_cast<const double*>(qp.request().ptr);
 
-      KDTree::RadiusSearchResult result;
+      RadiusSearchResult result;
       self.radius_search(ptr, radius, result);
 
       return as_pyarray(std::move(result));
@@ -128,7 +222,7 @@ PYBIND11_MODULE(_py4dgeo, m)
   kdtree.def(
     "nearest_neighbors",
     [](const KDTree& self, EigenPointCloudConstRef cloud, int k) {
-      KDTree::NearestNeighborsDistanceResult result;
+      NearestNeighborsDistanceResult result;
       self.nearest_neighbors_with_distances(cloud, result, k);
 
       py::array_t<long int> indices_array(result.size());
@@ -137,7 +231,7 @@ PYBIND11_MODULE(_py4dgeo, m)
       auto indices_array_ptr = indices_array.mutable_data();
       auto distances_array_ptr = distances_array.mutable_data();
 
-      for (size_t i = 0; i < result.size(); ++i) {
+      for (std::size_t i = 0; i < result.size(); ++i) {
         *indices_array_ptr++ = result[i].first[result[i].first.size() - 1];
         *distances_array_ptr++ = result[i].second[result[i].second.size() - 1];
       }
@@ -158,6 +252,179 @@ PYBIND11_MODULE(_py4dgeo, m)
     };
   });
 
+  // Expose the Octree class
+  py::class_<Octree> octree(m, "Octree", py::buffer_protocol());
+
+  // Map __init__ to constructor
+  octree.def(py::init<>(&Octree::create));
+
+  // Allow updating Octree from a given file
+  octree.def("load_index", [](Octree& self, std::string filename) {
+    std::ifstream stream(filename, std::ios::binary | std::ios::in);
+    self.loadIndex(stream);
+  });
+
+  // Allow dumping Octree to a file
+  octree.def("save_index", [](const Octree& self, std::string filename) {
+    std::ofstream stream(filename, std::ios::binary | std::ios::out);
+    self.saveIndex(stream);
+  });
+
+  // Allow building the Octree structure
+  octree.def("build_tree",
+             &Octree::build_tree,
+             py::arg("force_cubic") = false,
+             py::arg("min_corner") = std::nullopt,
+             py::arg("max_corner") = std::nullopt,
+             "Trigger building the search octree");
+
+  // Allow invalidating the Octree structure
+  octree.def("invalidate", &Octree::invalidate, "Invalidate the search octree");
+
+  // Allow extraction of number of points
+  octree.def("get_number_of_points",
+             &Octree::get_number_of_points,
+             "Return the number of points in the associated cloud");
+
+  // Allow extraction of bounding box size
+  octree.def("get_box_size",
+             &Octree::get_box_size,
+             "Return the side length of the bounding box");
+
+  // Allow extraction of min point
+  octree.def("get_min_point",
+             &Octree::get_min_point,
+             "Return the minimum point of the bounding box");
+
+  // Allow extraction of max point
+  octree.def(
+    "get_max_point", &Octree::get_max_point, "Return 8-bit dilated integer");
+
+  // Allow extraction of cell sizes
+  octree.def("get_cell_size",
+             &Octree::get_cell_size,
+             "Return the size of cells at a level of depth");
+
+  // Allow extraction of number of occupied cells per level
+  octree.def("get_occupied_cells_per_level",
+             &Octree::get_occupied_cells_per_level,
+             "Return the number of occupied cells per level of depth");
+
+  // Allow extraction of maximum amount of points
+  octree.def("get_max_cell_population_per_level",
+             &Octree::get_max_cell_population_per_level,
+             "Return the maximum number of points per cell per level of depth");
+
+  // Allow extraction of average amount of points
+  octree.def("get_average_cell_population_per_level",
+             &Octree::get_average_cell_population_per_level,
+             "Return the average number of points per cell per level of depth");
+
+  // Allow extraction of std of amount of points
+  octree.def("get_std_cell_population_per_level",
+             &Octree::get_std_cell_population_per_level,
+             "Return the standard deviation of number of points per cell per "
+             "level of depth");
+
+  // Allow extraction of spatial keys
+  octree.def("get_spatial_keys",
+             &Octree::get_spatial_keys,
+             "Return the computed spatial keys");
+
+  // Allow extraction of point indices
+  octree.def("get_point_indices",
+             &Octree::get_point_indices,
+             "Return the sorted point indices");
+
+  // Allow cell index computation
+  octree.def(
+    "get_cell_index_start",
+    &Octree::get_cell_index_start,
+    "Return first the index of a cell in the sorted array of point indices "
+    "and point spatial keys");
+
+  // Allow cell index computation
+  octree.def(
+    "get_cell_index_end",
+    &Octree::get_cell_index_end,
+    "Return the last index of a cell in the sorted array of point indices "
+    "and point spatial keys");
+
+  // Allow extraction from points in cell
+  octree.def(
+    "get_points_indices_from_cells",
+    [](const Octree& self,
+       const Octree::KeyContainer& keys,
+       unsigned int level) {
+      RadiusSearchResult result;
+      std::size_t num_points =
+        self.get_points_indices_from_cells(keys, level, result);
+
+      return as_pyarray(std::move(result));
+    },
+    "Retrieve point indices and spatial keys for a given cell",
+    py::arg("spatial_keys"),
+    py::arg("level"));
+
+  // Allow extraction from points in cell
+  octree.def(
+    "get_cells_intersected_by_sphere",
+    [](const Octree& self,
+       const Eigen::Vector3d& query_point,
+       double radius,
+       unsigned int level) {
+      Octree::KeyContainer cells_inside;
+      Octree::KeyContainer cells_intersecting;
+      self.get_cells_intersected_by_sphere(
+        query_point, radius, level, cells_inside, cells_intersecting);
+
+      return py::make_tuple(as_pyarray(std::move(cells_inside)),
+                            as_pyarray(std::move(cells_intersecting)));
+    },
+    "Retrieve the spatial keys of cells intersected by a sphere.",
+    py::arg("query_point"),
+    py::arg("radius"),
+    py::arg("level"));
+
+  // Allow computation of level of depth at which a radius search will be most
+  // efficient
+  octree.def("find_appropriate_level_for_radius_search",
+             &Octree::find_appropriate_level_for_radius_search,
+             "Return the level of depth at which a radius search will be most "
+             "efficient");
+
+  // Allow radius search with optional depth level specification
+  octree.def(
+    "radius_search",
+    [](const Octree& self,
+       Eigen::Ref<const Eigen::Vector3d> query_point,
+       double radius,
+       std::optional<unsigned int> level) {
+      unsigned int lvl =
+        level.value_or(self.find_appropriate_level_for_radius_search(radius));
+
+      RadiusSearchResult result;
+      self.radius_search(query_point, radius, lvl, result);
+
+      return as_pyarray(std::move(result));
+    },
+    "Search point in given radius!",
+    py::arg("query_point"),
+    py::arg("radius"),
+    py::arg("level") = std::nullopt);
+
+  // Pickling support for the Octree data structure
+  octree.def("__getstate__", [](const Octree&) {
+    // If a user pickles Octree itself, we end up redundantly storing
+    // the point cloud itself, because the Octree is only usable with the
+    // cloud (scipy does exactly the same). We solve the problem by asking
+    // users to pickle Epoch instead, which is the much cleaner solution.
+    throw std::runtime_error{
+      "Please pickle Epoch instead of Octree. Otherwise unpickled Octree does "
+      "not know the point cloud."
+    };
+  });
+
   // Segment point cloud into a supervoxels
   m.def("segment_pc_in_supervoxels",
         [](Epoch& epoch,
@@ -271,6 +538,10 @@ PYBIND11_MODULE(_py4dgeo, m)
       return std::make_tuple(std::move(result),
                              as_pyarray(std::move(used_radii)));
     },
+    py::arg("epoch"),
+    py::arg("corepoints"),
+    py::arg("normal_radii"),
+    py::arg("orientation"),
     "Compute M3C2 multiscale directions");
 
   // Corresponence distances computation

py4dgeo/segmentation.py

@@ -130,8 +130,8 @@ class SpatiotemporalAnalysis:
             # Ensure that we do have a timestamp on the epoch
             epoch = check_epoch_timestamp(epoch)
 
-            # Ensure that the KDTree is built - no-op if triggered by the user
-            epoch.build_kdtree()
+            # Ensure that the tearch tree is built - no-op if triggered by the user
+            epoch._validate_search_tree()
 
             # Write the reference epoch into the archive
             with tempfile.TemporaryDirectory() as tmp_dir:
@@ -173,9 +173,9 @@ class SpatiotemporalAnalysis:
                     "Corepoints cannot be changed - please start a new analysis"
                 )
 
-            # Ensure that the corepoints are stored as an epoch and build its KDTree
+            # Ensure that the corepoints are stored as an epoch and its search trees are built
             self._corepoints = as_epoch(_corepoints)
-            self._corepoints.build_kdtree()
+            self._corepoints._validate_search_tree()
 
             # Write the corepoints into the archive
             with tempfile.TemporaryDirectory() as tmp_dir:
@@ -678,6 +678,7 @@ class RegionGrowingAlgorithmBase:
         return self._analysis
 
     def run(self, analysis, force=False):
+        _py4dgeo.Epoch.set_default_radius_search_tree("octree")
         """Calculate the _segmentation
 
         :param analysis:
@@ -715,9 +716,9 @@ class RegionGrowingAlgorithmBase:
                 []
             )  # TODO: test initializing this in the analysis class, see if it crashes instantly
 
-        # Get corepoints from M3C2 class and build a KDTree on them
+        # Get corepoints from M3C2 class and build a search tree on them
         corepoints = as_epoch(analysis.corepoints)
-        corepoints.build_kdtree()
+        corepoints._validate_search_tree()
 
         # Calculate the list of seed points and sort them
         seeds = analysis.seeds
@@ -931,6 +932,12 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
         # window_jump = 1
         # window_penalty = 1.0
 
+        # Before starting the process, we check if the user has set a reasonable window width parameter
+        if self.window_width >= self.analysis.distances_for_compute.shape[1]:
+            raise Py4DGeoError(
+                "Window width cannot be larger than the length of the time series - please adapt parameter"
+            )
+
         # The list of generated seeds
         seeds = []
 
@@ -1044,7 +1051,8 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
         # The 4D-OBC algorithm sorts by similarity in the neighborhood
         # of the seed.
         def neighborhood_similarity(seed):
-            neighbors = self.analysis.corepoints.kdtree.radius_search(
+            self.analysis.corepoints._validate_search_tree()
+            neighbors = self.analysis.corepoints._radius_search(
                 self.analysis.corepoints.cloud[seed.index, :], self.neighborhood_radius
             )
             # if no neighbors are found make sure the algorithm continues its search but with a large dissimilarity

py4dgeo/util.py

@@ -3,9 +3,11 @@ 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
@@ -217,6 +219,16 @@ def set_num_threads(num_threads: int):
     "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:
@@ -254,6 +266,19 @@ def is_iterable(obj):
     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():
     # Define the target directory
     target = os.getcwd()

py4dgeo-0.8.0.data/platlib/.load-order-py4dgeo-0.8.0

@@ -0,0 +1,2 @@
+libomp-a12116ba72d1d6820407cf30be23da04.dll
+msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll

py4dgeo-0.8.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.11.1
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-x9rhbpfq\\cp39-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-v', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-x9rhbpfq\\cp39-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-x9rhbpfq\\cp39-win_amd64\\built_wheel\\py4dgeo-0.8.0-cp39-cp39-win_amd64.whl']

{py4dgeo-0.7.0.dist-info → py4dgeo-0.8.0.dist-info}/METADATA

@@ -1,13 +1,14 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: py4dgeo
-Version: 0.7.0
+Version: 0.8.0
 Summary: Library for change detection in 4D point cloud data
 Maintainer-Email: Dominic Kempf <ssc@iwr.uni-heidelberg.de>
 License: 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.
+         
+         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.
+         
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: C++
 Classifier: Operating System :: OS Independent
@@ -25,6 +26,7 @@ Requires-Dist: seaborn
 Requires-Dist: scikit-learn
 Requires-Dist: vedo
 Requires-Dist: xdg
+Requires-Dist: psutil
 Description-Content-Type: text/markdown
 
 # Welcome to py4dgeo
@@ -84,7 +86,6 @@ Using py4dgeo requires the following software installed:
 In order to build the package from source, the following tools are also needed.
 
 * A C++17-compliant compiler
-* CMake `>= 3.9`
 * Doxygen (optional, documentation building is skipped if missing)
 
 ### Installing py4dgeo
@@ -123,6 +124,13 @@ 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

py4dgeo-0.8.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+_py4dgeo.cp39-win_amd64.pyd,sha256=l6uYg_LZFIbmu6Ia7VHatOfO4SOq56G9jOfiZB-Y1Uw,857600
+py4dgeo/cloudcompare.py,sha256=hCe0YKZit8XVe98DsMKeUp-m-F2-avwicgS-IRjL4EQ,1111
+py4dgeo/epoch.py,sha256=y-DR19Lcyc9fpvw33i3WKy6U16DnIvrdcK05xpV3lFw,31587
+py4dgeo/fallback.py,sha256=5fL4OK8MIA7IMdgneRAVpmk8BWY_6ppYXIdtSvBMyDo,5240
+py4dgeo/logger.py,sha256=5J7DenNkvq5GMOF_Vd2kHLHGP7os1u4EFBMbyGCAJJY,2314
+py4dgeo/m3c2.py,sha256=TtrYiSWq7_U6uLBRQsEWplIgLRuRQoSmMffjn383zDQ,8451
+py4dgeo/m3c2ep.py,sha256=E0gjEk0a75YzO4KUE598L4ElnHIY9K9eiBkaKxxKpsg,29202
+py4dgeo/pbm3c2.py,sha256=Laa0v_9MUG1xEHlihsD-EV0BuPInR2L-9xQ0x5E2qDo,146237
+py4dgeo/py4dgeo_python.cpp,sha256=8TDJ28s8h0F8fjRPbiVykV60CaKJDaksBbm9MXK7xfc,28783
+py4dgeo/registration.py,sha256=aUdEas772buy31PVv-hA5Y3v-jGnnGeJB8Bo56eV4zg,17640
+py4dgeo/segmentation.py,sha256=MeBCc2Xh7tVHUYMKhAFqBKUJh4B4274OKvxohZMTkzA,54067
+py4dgeo/UpdateableZipFile.py,sha256=aZVdQgAc_M-EWFDIEVukgrYQUtEb5fRoRMCVxZqpggc,2770
+py4dgeo/util.py,sha256=_yowPxDyPcwuQGcBlRWRcpQ38_4Lw-BCt4oJIf6UHUU,9554
+py4dgeo/__init__.py,sha256=pEe0Zj9-YZtCMouP1IB95zvQSg9gA26erBg4H0jDUT4,2423
+py4dgeo-0.8.0.data/platlib/.load-order-py4dgeo-0.8.0,sha256=97iLj2m3vbU46AbFSKrbq4hxZ1pPNOZvy0aoCOmxtvs,90
+py4dgeo-0.8.0.data/platlib/libomp-a12116ba72d1d6820407cf30be23da04.dll,sha256=oSEWunLR1oIEB88wviPaBM551ruKcaXucXWcWh-qbxw,768000
+py4dgeo-0.8.0.data/platlib/msvcp140-a4c2229bdc2a2a630acdc095b4d86008.dll,sha256=pMIim9wqKmMKzcCVtNhgCOXD47x3cxdDVPPaT1vrnN4,575056
+py4dgeo-0.8.0.dist-info/DELVEWHEEL,sha256=RliAk1qCKddpFrnCE4-vuOzvBDfc4tkIpI2pU6VO3GA,401
+py4dgeo-0.8.0.dist-info/entry_points.txt,sha256=S8EHFVRD4deFJ_N6ZWst9v_ukH5lGnZY-f8NHjYoIfk,83
+py4dgeo-0.8.0.dist-info/METADATA,sha256=0r9xZELre0I1kpUVBdK7xBmkNYJbuzr9yt8cNVFCGrU,12697
+py4dgeo-0.8.0.dist-info/RECORD,,
+py4dgeo-0.8.0.dist-info/WHEEL,sha256=9tsL4JT94eZPTkcS3bNng2riasYJMxXndrO9CxUfJHs,104
+py4dgeo-0.8.0.dist-info/licenses/COPYING.md,sha256=ZetvO_BrdyO2DkROtlUcvpd6rl1M8Ak69vyDyePCZN0,1330
+py4dgeo-0.8.0.dist-info/licenses/LICENSE.md,sha256=Rza103klOvpFdEr8ed20dZErIT6Tm998uX2ai29wDl8,1028

{py4dgeo-0.7.0.dist-info → py4dgeo-0.8.0.dist-info}/WHEEL

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

py4dgeo-0.7.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-_py4dgeo.cp39-win_amd64.pyd,sha256=zaN5NSVv7ZV0_Qp1FqcH6Jp5ysJS93HfsC-Yf4Muyd0,526848
-py4dgeo/__init__.py,sha256=T_hK47cJOktmTxJrC03Ou-JGcdhs0IEKBcPXjUT4wJ8,767
-py4dgeo/cloudcompare.py,sha256=hCe0YKZit8XVe98DsMKeUp-m-F2-avwicgS-IRjL4EQ,1111
-py4dgeo/epoch.py,sha256=8Q9NTxb4OoiJx4IGESDXaDe4uwcgksofiMQLChsnndI,29914
-py4dgeo/fallback.py,sha256=dZltN-wUSMq5GYnUgCz157fh_H5gNf2MF2SdcntDQmI,5233
-py4dgeo/logger.py,sha256=5J7DenNkvq5GMOF_Vd2kHLHGP7os1u4EFBMbyGCAJJY,2314
-py4dgeo/m3c2.py,sha256=I-T2rnsHgZtjOcN0ONmB0UB3TlaW5je4-S0lgxhNvjo,8475
-py4dgeo/m3c2ep.py,sha256=vqudKR_QcV7z9bYMbGssVyJ2d4q5shgFhRue_WErJQ0,29150
-py4dgeo/pbm3c2.py,sha256=Ia7yWym0M72NNz1L-N5WhDA_ZGA_YmWmee80Dvdjgqo,146200
-py4dgeo/py4dgeo_python.cpp,sha256=J_csxFp1FF7nWHh8_z_BTJQRKbG4oPyRrrccJjoW4zw,18960
-py4dgeo/registration.py,sha256=aUdEas772buy31PVv-hA5Y3v-jGnnGeJB8Bo56eV4zg,17640
-py4dgeo/segmentation.py,sha256=pzSHuWyfHfiTDpmfy2onL3XTE_9dvLz7faVr0ddV0JI,53556
-py4dgeo/UpdateableZipFile.py,sha256=aZVdQgAc_M-EWFDIEVukgrYQUtEb5fRoRMCVxZqpggc,2770
-py4dgeo/util.py,sha256=dB27r6UAX1V4zy-bj-TbNxtjtwebvU7T1BCd3EIj59k,8553
-py4dgeo-0.7.0.dist-info/METADATA,sha256=jhvHo83amSpEvxj_2hXuIsBJWb1ef_ni04l70Xn9I9Q,12290
-py4dgeo-0.7.0.dist-info/WHEEL,sha256=s-IzttuPuPJp8zDv-jm-zGvTOCxdFCvjX9dIQ9zqnM8,104
-py4dgeo-0.7.0.dist-info/entry_points.txt,sha256=S8EHFVRD4deFJ_N6ZWst9v_ukH5lGnZY-f8NHjYoIfk,83
-py4dgeo-0.7.0.dist-info/licenses/COPYING.md,sha256=ZetvO_BrdyO2DkROtlUcvpd6rl1M8Ak69vyDyePCZN0,1330
-py4dgeo-0.7.0.dist-info/licenses/LICENSE.md,sha256=Rza103klOvpFdEr8ed20dZErIT6Tm998uX2ai29wDl8,1028
-py4dgeo-0.7.0.dist-info/RECORD,,