py4dgeo 0.7.0__cp311-cp311-win_amd64.whl → 1.0.0__cp311-cp311-win_amd64.whl

py4dgeo/__init__.py

@@ -1,3 +1,14 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_12_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, '.'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
+# end delvewheel patch
+
 from py4dgeo.logger import set_py4dgeo_logfile
 from py4dgeo.cloudcompare import CloudCompareM3C2
 from py4dgeo.epoch import (
@@ -7,6 +18,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 +39,9 @@ from py4dgeo.util import (
     set_memory_policy,
     get_num_threads,
     set_num_threads,
+    initialize_openmp_defaults,
 )
 
-from py4dgeo.pbm3c2 import *
+initialize_openmp_defaults()
+
+from py4dgeo.pbm3c2 import PBM3C2

py4dgeo/cloudcompare.py

@@ -1,6 +1,5 @@
 from py4dgeo.m3c2 import M3C2
 
-
 _cloudcompare_param_mapping = {
     "normalscale": "normal_radii",
     "registrationerror": "reg_error",

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/logger.py

@@ -8,8 +8,13 @@ def create_default_logger(filename=None):
     # Create the logger instance
     logger = logging.getLogger("py4dgeo")
 
-    # Reset the handlers to avoid handler duplication
-    logger.handlers.clear()
+    # Close and remove existing handlers to avoid duplication and leaks
+    for handler in logger.handlers[:]:
+        try:
+            handler.close()
+        except Exception:
+            pass
+        logger.removeHandler(handler)
 
     # Apply default for logfile name
     if filename is None:

py4dgeo/m3c2.py

@@ -16,7 +16,6 @@ import laspy
 
 import _py4dgeo
 
-
 logger = logging.getLogger("py4dgeo")
 
 
@@ -72,7 +71,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 +81,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 +93,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 +175,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
@@ -802,12 +803,12 @@ def process_corepoint_list(
         normal = n[np.newaxis, :]
         M3C2_spread1[cp_idx] = np.sqrt(
             np.matmul(np.matmul(normal, p1_CoG_Cxx), normal.T)
-        )
+        ).squeeze()
         M3C2_spread2[cp_idx] = np.sqrt(
             np.matmul(np.matmul(normal, p2_CoG_Cxx), normal.T)
-        )
-        M3C2_cov1[cp_idx] = p1_CoG_Cxx
-        M3C2_cov2[cp_idx] = p2_CoG_Cxx
+        ).squeeze()
+        M3C2_cov1[cp_idx] = p1_CoG_Cxx.squeeze()
+        M3C2_cov2[cp_idx] = p2_CoG_Cxx.squeeze()
 
         pbarQueue.put((1, 0))  # point processed
 
@@ -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