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

py4dgeo/__init__.py

@@ -9,7 +9,11 @@ from py4dgeo.epoch import (
 )
 from py4dgeo.m3c2 import M3C2, write_m3c2_results_to_las
 from py4dgeo.m3c2ep import M3C2EP
-from py4dgeo.registration import iterative_closest_point
+from py4dgeo.registration import (
+    iterative_closest_point,
+    point_to_plane_icp,
+    icp_with_stable_areas,
+)
 from py4dgeo.segmentation import (
     RegionGrowingAlgorithm,
     SpatiotemporalAnalysis,

py4dgeo/cloudcompare.py

@@ -5,7 +5,7 @@ _cloudcompare_param_mapping = {
     "normalscale": "normal_radii",
     "registrationerror": "reg_error",
     "searchdepth": "max_distance",
-    "searchscale": "cyl_radii",
+    "searchscale": "cyl_radius",
     "usemedian": "robust_aggr",
 }
 
@@ -21,10 +21,8 @@ class CloudCompareM3C2(M3C2):
         # Apply changes that are not a mere renaming
 
         # Scale parameters are diameters in CloudCompare and radii in py4dgeo
-        if "cyl_radii" in py4dgeo_params:
-            py4dgeo_params["cyl_radii"] = tuple(
-                0.5 * r for r in py4dgeo_params["cyl_radii"]
-            )
+        if "cyl_radius" in py4dgeo_params:
+            py4dgeo_params["cyl_radius"] = py4dgeo_params["cyl_radius"] * 0.5
         if "normal_radii" in py4dgeo_params:
             py4dgeo_params["normal_radii"] = tuple(
                 0.5 * r for r in py4dgeo_params["normal_radii"]

py4dgeo/epoch.py

@@ -95,6 +95,26 @@ class Epoch(_py4dgeo.Epoch):
         # Call base class constructor
         super().__init__(cloud)
 
+    @property
+    def cloud(self):
+        return self._cloud
+
+    @cloud.setter
+    def cloud(self, cloud):
+        raise Py4DGeoError(
+            "The Epoch point cloud cannot be changed after initialization. Please construct a new Epoch, e.g. by slicing an existing one."
+        )
+
+    @property
+    def kdtree(self):
+        return self._kdtree
+
+    @kdtree.setter
+    def kdtree(self, kdtree):
+        raise Py4DGeoError(
+            "The KDTree of an Epoch cannot be changed after initialization."
+        )
+
     @property
     def normals(self):
         # Maybe calculate normals
@@ -121,22 +141,67 @@ class Epoch(_py4dgeo.Epoch):
         if self.kdtree.leaf_parameter() == 0:
             self.build_kdtree()
 
-        # Allocate memory for the normals
-        self._normals = np.empty(self.cloud.shape, dtype=np.float64)
-
         # Reuse the multiscale code with a single radius in order to
         # avoid code duplication.
         with logger_context("Calculating point cloud normals:"):
-            _py4dgeo.compute_multiscale_directions(
+            self._normals, _ = _py4dgeo.compute_multiscale_directions(
                 self,
                 self.cloud,
                 [radius],
                 orientation_vector,
-                self._normals,
             )
 
         return self.normals
 
+    def normals_attachment(self, normals_array):
+        """Attach normals to the epoch object
+
+        :param normals:
+            The point cloud normals of shape (n, 3) where n is the
+            same as the number of points in the point cloud.
+        """
+
+        if normals_array.shape == self.cloud.shape:
+            self._normals = normals_array
+        else:
+            raise ValueError("Normals cannot be added. Shape does not match.")
+
+    def copy(self):
+        """Copy the epoch object"""
+
+        new_epoch = Epoch(
+            self.cloud.copy(),
+            normals=self.normals.copy() if self.normals is not None else None,
+            additional_dimensions=(
+                self.additional_dimensions.copy()
+                if self.additional_dimensions is not None
+                else None
+            ),
+            timestamp=self.timestamp,
+            scanpos_info=(
+                self.scanpos_info.copy() if self.scanpos_info is not None else None
+            ),
+        )
+
+        return new_epoch
+
+    def __getitem__(self, ind):
+        """Slice the epoch in order to e.g. downsample it.
+
+        Creates a copy of the epoch.
+        """
+
+        return Epoch(
+            self.cloud[ind],
+            normals=self.normals[ind] if self.normals is not None else None,
+            additional_dimensions=(
+                self.additional_dimensions[ind]
+                if self.additional_dimensions is not None
+                else None
+            ),
+            **self.metadata,
+        )
+
     @property
     def timestamp(self):
         return self._timestamp
@@ -278,8 +343,12 @@ class Epoch(_py4dgeo.Epoch):
         # Invalidate the KDTree
         self.kdtree.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++
-        _py4dgeo.transform_pointcloud_inplace(self.cloud, trafo, reduction_point)
+        _py4dgeo.transform_pointcloud_inplace(
+            self.cloud, trafo, reduction_point, self._normals
+        )
 
         # Store the transformation
         self._transformations.append(

py4dgeo/fallback.py

@@ -1,4 +1,4 @@
-"""Fallback implementations for C++ components of the M3C2 algorithms """
+"""Fallback implementations for C++ components of the M3C2 algorithms"""
 
 from py4dgeo.m3c2 import M3C2
 
@@ -7,8 +7,8 @@ import _py4dgeo
 
 
 def radius_workingset_finder(params: _py4dgeo.WorkingSetFinderParameters) -> np.ndarray:
-    indices = params.epoch.kdtree.radius_search(params.corepoint, params.radius)
-    return params.epoch.cloud[indices, :]
+    indices = params.epoch._kdtree.radius_search(params.corepoint, params.radius)
+    return params.epoch._cloud[indices, :]
 
 
 def cylinder_workingset_finder(
@@ -35,10 +35,10 @@ 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._kdtree.radius_search(qp, r_cyl)
 
         # Gather the points from the point cloud
-        superset = params.epoch.cloud[indices, :]
+        superset = params.epoch._cloud[indices, :]
 
         # Calculate distance from the axis and the plane perpendicular to the axis
         to_corepoint = superset - qp

py4dgeo/m3c2.py

@@ -1,3 +1,4 @@
+from ast import List
 from py4dgeo.epoch import Epoch, as_epoch
 from py4dgeo.util import (
     as_double_precision,
@@ -22,9 +23,10 @@ logger = logging.getLogger("py4dgeo")
 class M3C2LikeAlgorithm(abc.ABC):
     def __init__(
         self,
-        epochs: typing.Tuple[Epoch, ...] = None,
-        corepoints: np.ndarray = None,
-        cyl_radii: typing.List[float] = None,
+        epochs: typing.Optional[typing.Tuple[Epoch, ...]] = None,
+        corepoints: typing.Optional[np.ndarray] = None,
+        cyl_radii: typing.Optional[List] = None,
+        cyl_radius: typing.Optional[float] = None,
         max_distance: float = 0.0,
         registration_error: float = 0.0,
         robust_aggr: bool = False,
@@ -32,6 +34,7 @@ class M3C2LikeAlgorithm(abc.ABC):
         self.epochs = epochs
         self.corepoints = corepoints
         self.cyl_radii = cyl_radii
+        self.cyl_radius = cyl_radius
         self.max_distance = max_distance
         self.registration_error = registration_error
         self.robust_aggr = robust_aggr
@@ -72,9 +75,19 @@ class M3C2LikeAlgorithm(abc.ABC):
     def calculate_distances(self, epoch1, epoch2):
         """Calculate the distances between two epochs"""
 
-        if self.cyl_radii is None or len(self.cyl_radii) != 1:
+        if isinstance(self.cyl_radii, typing.Iterable):
+            logger.warning(
+                "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!")
+            elif self.cyl_radius is None:
+                self.cyl_radius = self.cyl_radii[0]
+            self.cyl_radii = None
+
+        if self.cyl_radius is None:
             raise Py4DGeoError(
-                f"{self.name} requires exactly one cylinder radius to be given"
+                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
@@ -85,7 +98,7 @@ class M3C2LikeAlgorithm(abc.ABC):
 
         distances, uncertainties = _py4dgeo.compute_distances(
             self.corepoints,
-            self.cyl_radii[0],
+            self.cyl_radius,
             epoch1,
             epoch2,
             self.directions(),
@@ -128,6 +141,7 @@ class M3C2(M3C2LikeAlgorithm):
         )
         self.cloud_for_normals = cloud_for_normals
         self.corepoint_normals = corepoint_normals
+        self._directions_radii = None
         super().__init__(**kwargs)
 
     def directions(self):
@@ -155,9 +169,6 @@ class M3C2(M3C2LikeAlgorithm):
                 "M3C2 requires at least the MINIMUM memory policy level to compute multiscale normals"
             )
 
-        # Allocate the storage for the computed normals
-        self.corepoint_normals = np.empty(self.corepoints.shape, dtype=np.float64)
-
         # Find the correct epoch to use for normal calculation
         normals_epoch = self.cloud_for_normals
         if normals_epoch is None:
@@ -167,16 +178,25 @@ class M3C2(M3C2LikeAlgorithm):
         normals_epoch.build_kdtree()
 
         # Trigger the precomputation
-        _py4dgeo.compute_multiscale_directions(
-            normals_epoch,
-            self.corepoints,
-            self.normal_radii,
-            self.orientation_vector,
-            self.corepoint_normals,
+        self.corepoint_normals, self._directions_radii = (
+            _py4dgeo.compute_multiscale_directions(
+                normals_epoch,
+                self.corepoints,
+                self.normal_radii,
+                self.orientation_vector,
+            )
         )
 
         return self.corepoint_normals
 
+    def directions_radii(self):
+        if self._directions_radii is None:
+            raise ValueError(
+                "Radii are only available after calculating directions with py4dgeo."
+            )
+
+        return self._directions_radii
+
     @property
     def name(self):
         return "M3C2"

py4dgeo/m3c2ep.py

@@ -56,7 +56,7 @@ class M3C2EP(M3C2):
         print(self.name + " running")
         """Calculate the distances between two epochs"""
 
-        if self.cyl_radii is None or len(self.cyl_radii) != 1:
+        if not isinstance(self.cyl_radius, float):
             raise Py4DGeoError(
                 f"{self.name} requires exactly one cylinder radius to be given"
             )
@@ -71,7 +71,7 @@ class M3C2EP(M3C2):
 
         # set default M3C2Meta
         M3C2Meta = {"searchrad": 0.5, "maxdist": 3, "minneigh": 5, "maxneigh": 100000}
-        M3C2Meta["searchrad"] = self.cyl_radii[0]
+        M3C2Meta["searchrad"] = self.cyl_radius
         M3C2Meta["maxdist"] = self.max_distance
 
         M3C2Meta["spInfos"] = [epoch1.scanpos_info, epoch2.scanpos_info]
@@ -194,9 +194,11 @@ class M3C2EP(M3C2):
         p2_coords_shm.unlink()
 
         out_attrs = {
-            key: np.empty((query_coords.shape[0], 3, 3), dtype=val.dtype)
-            if key == "m3c2_cov1" or key == "m3c2_cov2"
-            else np.empty(query_coords.shape[0], dtype=val.dtype)
+            key: (
+                np.empty((query_coords.shape[0], 3, 3), dtype=val.dtype)
+                if key == "m3c2_cov1" or key == "m3c2_cov2"
+                else np.empty(query_coords.shape[0], dtype=val.dtype)
+            )
             for key, val in return_dict[0].items()
         }
         for key in out_attrs:

py4dgeo/pbm3c2.py

@@ -1286,9 +1286,9 @@ class Segmentation(BaseTransformer):
                         >= self.roughness_threshold
                     ):
                         mask_seg_id = X[:, self.columns.SEGMENT_ID_COLUMN] == seg_id
-                        X[
-                            mask_seg_id, self.columns.SEGMENT_ID_COLUMN
-                        ] = DEFAULT_NO_SEGMENT
+                        X[mask_seg_id, self.columns.SEGMENT_ID_COLUMN] = (
+                            DEFAULT_NO_SEGMENT
+                        )
                         # since we don't have a new segment
                         seg_id -= 1
                     else:
@@ -2027,6 +2027,11 @@ class PBM3C2:
         extract_segments=ExtractSegments(),
         classifier=ClassifierWrapper(),
     ):
+
+        logger.warning(
+            f"This method is in experimental stage and undergoing active development."
+        )
+
         """
         :param per_point_computation:
             lowest local surface variation and PCA computation. (computes the normal vector as well)

py4dgeo/py4dgeo_python.cpp

@@ -65,8 +65,8 @@ PYBIND11_MODULE(_py4dgeo, m)
   epoch.def(py::init<EigenPointCloudRef>(), py::keep_alive<1, 2>());
 
   // We can directly access the point cloud and the kdtree
-  epoch.def_readwrite("cloud", &Epoch::cloud);
-  epoch.def_readwrite("kdtree", &Epoch::kdtree);
+  epoch.def_readwrite("_cloud", &Epoch::cloud);
+  epoch.def_readwrite("_kdtree", &Epoch::kdtree);
 
   // Pickling support for the Epoch class
   epoch.def(py::pickle(
@@ -127,12 +127,22 @@ PYBIND11_MODULE(_py4dgeo, m)
 
   kdtree.def(
     "nearest_neighbors",
-    [](const KDTree& self, EigenPointCloudConstRef cloud) {
+    [](const KDTree& self, EigenPointCloudConstRef cloud, int k) {
       KDTree::NearestNeighborsDistanceResult result;
-      self.nearest_neighbors_with_distances(cloud, result);
+      self.nearest_neighbors_with_distances(cloud, result, k);
 
-      return std::make_tuple(as_pyarray(std::move(result.first)),
-                             as_pyarray(std::move(result.second)));
+      py::array_t<long int> indices_array(result.size());
+      py::array_t<double> distances_array(result.size());
+
+      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) {
+        *indices_array_ptr++ = result[i].first[result[i].first.size() - 1];
+        *distances_array_ptr++ = result[i].second[result[i].second.size() - 1];
+      }
+
+      return std::make_pair(indices_array, distances_array);
     },
     "Find nearest neighbors for all points in a cloud!");
 
@@ -148,6 +158,63 @@ PYBIND11_MODULE(_py4dgeo, m)
     };
   });
 
+  // Segment point cloud into a supervoxels
+  m.def("segment_pc_in_supervoxels",
+        [](Epoch& epoch,
+           const KDTree& kdtree,
+           EigenNormalSetConstRef normals,
+           double resolution,
+           int k,
+           int minSVPvalue) {
+          std::vector<Supervoxel> supervoxels =
+            segment_pc(epoch, kdtree, normals, resolution, k, minSVPvalue);
+
+          py::list np_arrays_cloud;
+          py::list np_arrays_centroid;
+          py::list np_arrays_boundary_points;
+          py::list np_arrays_normals;
+
+          for (const auto& sv : supervoxels) {
+            // Convert Eigen::MatrixXd to a NumPy array
+            auto np_array_cloud = py::array_t<double>(
+              sv.cloud.rows() * sv.cloud.cols(), sv.cloud.data());
+            auto np_array_normals = py::array_t<double>(
+              sv.normals.rows() * sv.normals.cols(), sv.normals.data());
+            auto np_array_centroid =
+              py::array_t<double>(sv.centroid.size(), sv.centroid.data());
+            auto np_array_boundary_points = py::array_t<double>(
+              sv.boundary_points.rows() * sv.boundary_points.cols(),
+              sv.boundary_points.data());
+
+            // Reshape the arrays to their original shape
+            np_array_cloud.resize({ sv.cloud.rows(), sv.cloud.cols() });
+            np_array_normals.resize({ sv.normals.rows(), sv.normals.cols() });
+            np_array_centroid.resize({ sv.centroid.size() });
+            np_array_boundary_points.resize(
+              { sv.boundary_points.rows(), sv.boundary_points.cols() });
+
+            np_arrays_cloud.append(np_array_cloud);
+            np_arrays_normals.append(np_array_normals);
+            np_arrays_centroid.append(np_array_centroid);
+            np_arrays_boundary_points.append(np_array_boundary_points);
+          }
+
+          return std::make_tuple(np_arrays_cloud,
+                                 np_arrays_normals,
+                                 np_arrays_centroid,
+                                 np_arrays_boundary_points);
+        });
+
+  // Perform a transformation of a point cloud using Gauss-Newton method
+  m.def("fit_transform_GN",
+        [](EigenPointCloudConstRef cloud1,
+           EigenPointCloudConstRef cloud2,
+           EigenNormalSetConstRef normals) {
+          Eigen::Matrix4d transformation =
+            fit_transform_GN(cloud1, cloud2, normals);
+          return transformation;
+        });
+
   // The main distance computation function that is the main entry point of M3C2
   m.def(
     "compute_distances",
@@ -189,9 +256,27 @@ PYBIND11_MODULE(_py4dgeo, m)
     "The main M3C2 distance calculation algorithm");
 
   // Multiscale direction computation
-  m.def("compute_multiscale_directions",
-        &compute_multiscale_directions,
-        "Compute M3C2 multiscale directions");
+  m.def(
+    "compute_multiscale_directions",
+    [](const Epoch& epoch,
+       EigenPointCloudConstRef corepoints,
+       const std::vector<double>& normal_radii,
+       EigenNormalSetConstRef orientation) {
+      EigenNormalSet result(corepoints.rows(), 3);
+      std::vector<double> used_radii;
+
+      compute_multiscale_directions(
+        epoch, corepoints, normal_radii, orientation, result, used_radii);
+
+      return std::make_tuple(std::move(result),
+                             as_pyarray(std::move(used_radii)));
+    },
+    "Compute M3C2 multiscale directions");
+
+  // Corresponence distances computation
+  m.def("compute_correspondence_distances",
+        &compute_correspondence_distances,
+        "Compute correspondence distances");
 
   // Callback parameter structs
   py::class_<WorkingSetFinderParameters> ws_params(
@@ -362,7 +447,8 @@ PYBIND11_MODULE(_py4dgeo, m)
   m.def("transform_pointcloud_inplace",
         [](EigenPointCloudRef cloud,
            const py::array_t<double>& t,
-           EigenPointCloudConstRef rp) {
+           EigenPointCloudConstRef rp,
+           EigenNormalSetRef normals) {
           Transformation trafo;
 
           auto r = t.unchecked<2>();
@@ -370,7 +456,7 @@ PYBIND11_MODULE(_py4dgeo, m)
             for (IndexType j = 0; j < 4; ++j)
               trafo(i, j) = r(i, j);
 
-          transform_pointcloud_inplace(cloud, trafo, rp);
+          transform_pointcloud_inplace(cloud, trafo, rp, normals);
         });
 
   // The main algorithms for the spatiotemporal segmentations

py4dgeo/registration.py

@@ -1,3 +1,6 @@
+from py4dgeo.util import Py4DGeoError
+
+from copy import deepcopy
 import dataclasses
 import numpy as np
 
@@ -80,20 +83,26 @@ def iterative_closest_point(
 
     # Make a copy of the cloud to be transformed.
     cloud = epoch.cloud.copy()
-
     prev_error = 0
 
     for _ in range(max_iterations):
-        indices, distances = reference_epoch.kdtree.nearest_neighbors(cloud)
-        # Calculate a transform and apply it
+        neighbor_arrays = np.asarray(reference_epoch.kdtree.nearest_neighbors(cloud, 1))
+        indices, distances = np.split(neighbor_arrays, 2, axis=0)
 
+        indices = np.squeeze(indices.astype(int))
+        distances = np.squeeze(distances)
+
+        # Calculate a transform and apply it
         T = _fit_transform(
             cloud, reference_epoch.cloud[indices, :], reduction_point=reduction_point
         )
-        _py4dgeo.transform_pointcloud_inplace(cloud, T, reduction_point)
+        _py4dgeo.transform_pointcloud_inplace(
+            cloud, T, reduction_point, np.empty((1, 3))
+        )
 
         # Determine convergence
         mean_error = np.mean(np.sqrt(distances))
+
         if np.abs(prev_error - mean_error) < tolerance:
             break
         prev_error = mean_error
@@ -102,3 +111,364 @@ def iterative_closest_point(
         affine_transformation=_fit_transform(epoch.cloud, cloud),
         reduction_point=reduction_point,
     )
+
+
+def point_to_plane_icp(
+    reference_epoch, epoch, max_iterations=50, tolerance=0.00001, reduction_point=None
+):
+    """Perform a point to plane Iterative Closest Point algorithm (ICP), based on Gauss-Newton method for computing the least squares solution
+
+    :param reference_epoch:
+        The reference epoch to match with. This epoch has to have calculated normals.
+    :type reference_epoch: py4dgeo.Epoch
+    :param epoch:
+        The epoch to be transformed to the reference epoch
+    :type epoch: py4dgeo.Epoch
+    :param max_iterations:
+        The maximum number of iterations to be performed in the ICP algorithm
+    :type max_iterations: int
+    :param tolerance:
+        The tolerance criterium used to terminate ICP iteration.
+    :type tolerance: float
+    :param reduction_point:
+        A translation vector to apply before applying rotation and scaling.
+        This is used to increase the numerical accuracy of transformation.
+    :type reduction_point: np.ndarray
+    """
+
+    from py4dgeo.epoch import Epoch
+
+    # Ensure that Epoch has calculated normals
+    if reference_epoch.normals is None:
+        raise Py4DGeoError(
+            "Normals for this Reference Epoch have not been calculated! Please use Epoch.calculate_normals or load externally calculated normals."
+        )
+
+    # Ensure that reference_epoch has its KDTree built
+    if reference_epoch.kdtree.leaf_parameter() == 0:
+        reference_epoch.build_kdtree()
+
+    # Apply the default for the registration point
+    if reduction_point is None:
+        reduction_point = np.array([0, 0, 0])
+
+    # Make a copy of the cloud to be transformed.
+    trans_epoch = epoch.copy()
+
+    prev_error = 0
+    for _ in range(max_iterations):
+        neighbor_arrays = np.asarray(
+            reference_epoch.kdtree.nearest_neighbors(trans_epoch.cloud, 1)
+        )
+        indices, distances = np.split(neighbor_arrays, 2, axis=0)
+
+        indices = np.squeeze(indices.astype(int))
+        distances = np.squeeze(distances)
+
+        # Calculate a transform and apply it
+        T = _py4dgeo.fit_transform_GN(
+            trans_epoch.cloud,
+            reference_epoch.cloud[indices, :],
+            reference_epoch.normals[indices, :],
+        )
+        trans_epoch.transform(
+            Transformation(affine_transformation=T, reduction_point=reduction_point)
+        )
+
+        # Determine convergence
+        mean_error = np.mean(np.sqrt(distances))
+        if np.abs(prev_error - mean_error) < tolerance:
+            break
+        prev_error = mean_error
+
+    return Transformation(
+        affine_transformation=_py4dgeo.fit_transform_GN(
+            epoch.cloud,
+            trans_epoch.cloud,
+            trans_epoch.normals,
+        ),
+        reduction_point=reduction_point,
+    )
+
+
+def calculate_bounding_box(point_cloud):
+    """
+    Calculate the bounding box of a point cloud.
+
+    Parameters:
+    - point_cloud: NumPy array with shape (N, 3), where N is the number of points.
+
+    Returns:
+    - min_bound: 1D array representing the minimum coordinates of the bounding box.
+    - max_bound: 1D array representing the maximum coordinates of the bounding box.
+    """
+    min_bound = np.min(point_cloud, axis=0)
+    max_bound = np.max(point_cloud, axis=0)
+
+    return min_bound, max_bound
+
+
+def calculate_bounding_box_change(
+    bounding_box_min, bounding_box_max, transformation_matrix
+):
+    """Calculate the change in kdtree bounding box corners after applying a transformation matrix.
+    Parameters:
+    - bounding_box_min: 1D array representing the minimum coordinates of the bounding box.
+    - bounding_box_max: 1D array representing the maximum coordinates of the bounding box.
+    - transformation_matrix: 2D array representing the transformation matrix.
+    Returns:
+    - max_change: The maximum change in the bounding box corners.
+    """
+
+    # Convert bounding box to homogeneous coordinates
+    bounding_box_min_homogeneous = np.concatenate((bounding_box_min, [1]))
+    bounding_box_max_homogeneous = np.concatenate((bounding_box_max, [1]))
+    bounding_box_min_homogeneous = np.reshape(bounding_box_min_homogeneous, (4, 1))
+    bounding_box_max_homogeneous = np.reshape(bounding_box_max_homogeneous, (4, 1))
+
+    # Calculate the change in bounding box corners
+    bb_c2p1 = np.dot(transformation_matrix, bounding_box_min_homogeneous)
+    bb_c2p2 = np.dot(transformation_matrix, bounding_box_max_homogeneous)
+
+    dif_bb_pmin = np.sum(np.abs(bb_c2p1[:3] - bounding_box_min_homogeneous[:3]))
+    dif_bb_pmax = np.sum(np.abs(bb_c2p2[:3] - bounding_box_max_homogeneous[:3]))
+
+    return max(dif_bb_pmin, dif_bb_pmax)
+
+
+def calculate_dis_threshold(epoch1, epoch2):
+    """Calculate the distance threshold for the next iteration of the registration method
+    Parameters:
+    - epoch1: The reference epoch.
+    - epoch2: Stable points of epoch.
+    Returns:
+    - dis_threshold: The distance threshold.
+    """
+    neighbor_arrays = np.asarray(epoch1.kdtree.nearest_neighbors(epoch2.cloud, 1))
+    indices, distances = np.split(neighbor_arrays, 2, axis=0)
+    distances = np.squeeze(distances)
+
+    if indices.size > 0:
+        # Calculate mean distance
+        mean_dis = np.mean(np.sqrt(distances))
+
+        # Calculate standard deviation
+        std_dis = np.sqrt(np.mean((mean_dis - distances) ** 2))
+
+        dis_threshold = mean_dis + 1.0 * std_dis
+
+    return dis_threshold
+
+
+def icp_with_stable_areas(
+    reference_epoch,
+    epoch,
+    initial_distance_threshold,
+    level_of_detection,
+    reference_supervoxel_resolution,
+    supervoxel_resolution,
+    min_svp_num=10,
+    reduction_point=None,
+):
+    """Perform a registration method
+
+    :param reference_epoch:
+        The reference epoch to match with. This epoch has to have calculated normals.
+    :type reference_epoch: py4dgeo.Epoch
+    :param epoch:
+        The epoch to be transformed to the reference epoch
+    :type epoch: py4dgeo.Epoch
+    :param initial_distance_threshold:
+        The upper boundary of the distance threshold in the iteration. It can be (1) an empirical value manually set by the user according to the approximate accuracy of coarse registration,
+        or (2) calculated by the mean and standard of the nearest neighbor distances of all points.
+    :type initial_distance_threshold: float
+    :param level_of_detection:
+        The lower boundary (minimum) of the distance threshold in the iteration.
+        It can be  (1) an empirical value manually set by the user according to the approximate uncertainty of laser scanning measurements in different scanning configurations and scenarios
+        (e.g., 1 cm for TLS point clouds in short distance and 4 cm in long distance, 8 cm for ALS point clouds, etc.),
+        or (2) calculated by estimating the standard deviation from local modeling (e.g., using the level of detection in M3C2 or M3C2-EP calculations).
+    :type level_of_detection: float
+    :param reference_supervoxel_resolution:
+       The approximate size of generated supervoxels for the reference epoch.
+       It can be (1) an empirical value manually set by the user according to different surface geometries and scanning distance (e.g., 2-10 cm for indoor scenes, 1-3 m for landslide surface),
+         or (2) calculated by 10-20 times the average point spacing (original resolution of point clouds). In both cases, the number of points in each supervoxel should be at least 10 (i.e., minSVPnum = 10).
+    :type reference_supervoxel_resolution: float
+    :param supervoxel_resolution:
+         The same as `reference_supervoxel_resolution`, but for a different epoch.
+    :type supervoxel_resolution: float
+    :param min_svp_num:
+         Minimum number of points for supervoxels to be taken into account in further calculations.
+    :type min_svp_num: int
+    :param reduction_point:
+        A translation vector to apply before applying rotation and scaling.
+        This is used to increase the numerical accuracy of transformation.
+    :type reduction_point: np.ndarray
+
+    """
+
+    from py4dgeo.epoch import as_epoch
+
+    # Ensure that reference_epoch has its KDTree build
+    if reference_epoch.kdtree.leaf_parameter() == 0:
+        reference_epoch.build_kdtree()
+
+    # Ensure that epoch has its KDTree build
+    if epoch.kdtree.leaf_parameter() == 0:
+        epoch.build_kdtree()
+
+    # Ensure that Epoch has calculated normals
+    # Ensure that Epoch has calculated normals
+    if reference_epoch.normals is None:
+        raise Py4DGeoError(
+            "Normals for this Reference Epoch have not been calculated! Please use Epoch.calculate_normals or load externally calculated normals."
+        )
+
+    # Ensure that Epoch has calculated normals
+
+    # Ensure that Epoch has calculated normals
+    if epoch.normals is None:
+        raise Py4DGeoError(
+            "Normals for this Epoch have not been calculated! Please use Epoch.calculate_normals or load externally calculated normals."
+        )
+
+    # Apply the default for the registration point
+    if reduction_point is None:
+        reduction_point = np.array([0, 0, 0])
+
+    if initial_distance_threshold <= level_of_detection:
+        initial_distance_threshold = level_of_detection
+
+    transMatFinal = np.identity(4)  # Identity matrix for initial transMatFinal
+    stage3 = stage4 = 0
+    epoch_copy = epoch.copy()  # Create copy of epoch for applying transformation
+
+    k = 50  # Number of nearest neighbors to consider in supervoxel segmentation
+
+    clouds_pc1, _, centroids_pc1, _ = _py4dgeo.segment_pc_in_supervoxels(
+        reference_epoch,
+        reference_epoch.kdtree,
+        reference_epoch.normals,
+        reference_supervoxel_resolution,
+        k,
+        min_svp_num,
+    )
+    (
+        clouds_pc2,
+        normals2,
+        centroids_pc2,
+        boundary_points_pc2,
+    ) = _py4dgeo.segment_pc_in_supervoxels(
+        epoch, epoch.kdtree, epoch.normals, supervoxel_resolution, k, min_svp_num
+    )
+
+    centroids_pc1 = as_epoch(np.array(centroids_pc1))
+    centroids_pc1.build_kdtree()
+    centroids_pc2 = np.array(centroids_pc2)
+    boundary_points_pc2 = np.concatenate(boundary_points_pc2, axis=0)
+
+    _, reference_distances = np.split(
+        np.asarray(reference_epoch.kdtree.nearest_neighbors(reference_epoch.cloud, 2)),
+        2,
+        axis=0,
+    )
+    basicRes = np.mean(np.squeeze(reference_distances))
+    dis_threshold = initial_distance_threshold
+
+    while stage4 == 0:
+        cor_dist_ct = _py4dgeo.compute_correspondence_distances(
+            centroids_pc1, centroids_pc2, clouds_pc1, len(reference_epoch.cloud)
+        )
+        # Calculation BP2-CT1
+        cor_dist_bp = _py4dgeo.compute_correspondence_distances(
+            centroids_pc1,
+            boundary_points_pc2,
+            clouds_pc1,
+            len(reference_epoch.cloud),
+        )
+        # calculation BP2- CP1
+        cor_dist_pc = _py4dgeo.compute_correspondence_distances(
+            reference_epoch,
+            boundary_points_pc2,
+            clouds_pc1,
+            len(reference_epoch.cloud),
+        )
+
+        stablePC2 = []  # Stable supervoxels
+        normPC2 = []  # Stable supervoxel's normals
+
+        dt_point = dis_threshold + 2 * basicRes
+
+        for i in range(len(centroids_pc2)):
+            if cor_dist_ct[i] < dis_threshold and all(
+                cor_dist_bp[j + 6 * i] < dis_threshold
+                and cor_dist_pc[j + 6 * i] < dt_point
+                for j in range(6)
+            ):
+                stablePC2.append(clouds_pc2[i])
+                normPC2.append(normals2[i])
+
+        # Handle empty stablePC2
+        if len(stablePC2) == 0:
+            raise Py4DGeoError(
+                "No stable supervoxels found! Please adjust the parameters."
+            )
+
+        stablePC2 = np.vstack(stablePC2)
+        stablePC2 = as_epoch(stablePC2)
+        normPC2 = np.vstack(normPC2)
+        stablePC2.normals_attachment(normPC2)
+        trans_mat_cur_obj = point_to_plane_icp(
+            reference_epoch,
+            stablePC2,
+            max_iterations=50,
+            tolerance=0.00001,
+            reduction_point=reduction_point,
+        )
+
+        trans_mat_cur = trans_mat_cur_obj.affine_transformation
+
+        # BB
+        initial_min_bound, initial_max_bound = calculate_bounding_box(epoch_copy.cloud)
+        max_bb_change = calculate_bounding_box_change(
+            initial_min_bound, initial_max_bound, trans_mat_cur
+        )
+        # update DT
+        if stage3 == 0 and max_bb_change < 2 * level_of_detection:
+            stage3 = 1
+        elif dis_threshold == level_of_detection:
+            stage4 = 1
+
+        if stage3 == 0:
+            dis_threshold = calculate_dis_threshold(reference_epoch, stablePC2)
+            if dis_threshold <= level_of_detection:
+                dis_threshold = level_of_detection
+
+        if stage3 == 1 and stage4 == 0:
+            dis_threshold = 0.8 * dis_threshold
+            if dis_threshold <= level_of_detection:
+                dis_threshold = level_of_detection
+
+        # update values and apply changes
+        # Apply the transformation to the epoch
+        epoch_copy.transform(
+            Transformation(
+                affine_transformation=trans_mat_cur, reduction_point=reduction_point
+            )
+        )
+        _py4dgeo.transform_pointcloud_inplace(
+            centroids_pc2, trans_mat_cur, reduction_point, np.empty((1, 3))
+        )
+        _py4dgeo.transform_pointcloud_inplace(
+            boundary_points_pc2, trans_mat_cur, reduction_point, np.empty((1, 3))
+        )
+        for i in range(len(clouds_pc2)):
+            _py4dgeo.transform_pointcloud_inplace(
+                clouds_pc2[i], trans_mat_cur, reduction_point, np.empty((1, 3))
+            )
+
+        transMatFinal = trans_mat_cur @ transMatFinal
+
+    return Transformation(
+        affine_transformation=transMatFinal,
+        reduction_point=reduction_point,
+    )

py4dgeo/segmentation.py

@@ -14,7 +14,6 @@ import pickle
 import seaborn
 import tempfile
 import zipfile
-
 import _py4dgeo
 
 
@@ -557,7 +556,7 @@ class SpatiotemporalAnalysis:
 
                 zf.write(objectsfile, arcname="objects.pickle")
 
-    def invalidate_results(self, seeds=True, objects=True, smoothed_distances=True):
+    def invalidate_results(self, seeds=True, objects=True, smoothed_distances=False):
         """Invalidate (and remove) calculated results
 
         This is automatically called when new epochs are added or when
@@ -697,10 +696,24 @@ class RegionGrowingAlgorithmBase:
             analysis.invalidate_results()
 
         # Return pre-calculated objects if they are available
-        precalculated = analysis.objects
+        # precalculated = analysis.objects
+        # if precalculated is not None:
+        #     logger.info("Reusing objects by change stored in analysis object")
+        #     return precalculated
+
+        # Check if there are pre-calculated objects.
+        # If so, create objects list from these and continue growing objects, taking into consideration objects that are already grown.
+        # if not initiate new empty objects list
+        precalculated = analysis.objects  # TODO: do not assign to new object
         if precalculated is not None:
             logger.info("Reusing objects by change stored in analysis object")
-            return precalculated
+            objects = (
+                precalculated.copy()
+            )  # test if .copy() solves memory problem, or deepcopy?
+        else:
+            objects = (
+                []
+            )  # TODO: test initializing this in the analysis class, see if it crashes instantly
 
         # Get corepoints from M3C2 class and build a KDTree on them
         corepoints = as_epoch(analysis.corepoints)
@@ -720,11 +733,34 @@ class RegionGrowingAlgorithmBase:
             analysis.seeds = seeds
         else:
             logger.info("Reusing seed candidates stored in analysis object")
-
-        objects = []
+        # write the number of seeds to a separate text file if self.write_nr_seeds is True
+        if self.write_nr_seeds:
+            with open("number_of_seeds.txt", "w") as f:
+                f.write(str(len(seeds)))
 
         # Iterate over the seeds to maybe turn them into objects
-        for i, seed in enumerate(seeds):
+        for i, seed in enumerate(
+            seeds
+        ):  # [self.resume_from_seed-1:]): # starting seed ranked at the `resume_from_seed` variable (representing 1 for index 0)
+            # or to keep within the same index range when resuming from seed:
+            if i < (
+                self.resume_from_seed - 1
+            ):  # resume from index 0 when `resume_from_seed` == 1
+                continue
+            if i >= (self.stop_at_seed - 1):  # stop at index 0 when `stop_at_seed` == 1
+                break
+
+            # save objects to analysis object when at index `intermediate_saving`
+            if (
+                (self.intermediate_saving)
+                and ((i % self.intermediate_saving) == 0)
+                and (i != 0)
+            ):
+                with logger_context(
+                    f"Intermediate saving of first {len(objects)} objects, grown from first {i+1}/{len(seeds)} seeds"
+                ):
+                    analysis.objects = objects  # This assigns itself to itself
+
             # Check all already calculated objects whether they overlap with this seed.
             found = False
             for obj in objects:
@@ -762,7 +798,9 @@ class RegionGrowingAlgorithmBase:
 
                 # If the returned object has 0 indices, the min_segments threshold was violated
                 if objdata.indices_distances:
-                    obj = ObjectByChange(objdata, seed, analysis)
+                    obj = ObjectByChange(
+                        objdata, seed, analysis
+                    )  # TODO: check, does it copy the whole analysis object when initializing
                     if self.filter_objects(obj):
                         objects.append(obj)
 
@@ -775,7 +813,7 @@ class RegionGrowingAlgorithmBase:
         # Store the results in the analysis object
         analysis.objects = objects
 
-        # Potentially remove objects from memory # TODO Why do we remove these?
+        # Potentially remove objects from memory
         del analysis.smoothed_distances
         del analysis.distances
 
@@ -793,6 +831,11 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
         window_penalty=1.0,
         minperiod=24,
         height_threshold=0.0,
+        use_unfinished=True,
+        intermediate_saving=0,
+        resume_from_seed=0,
+        stop_at_seed=np.inf,
+        write_nr_seeds=False,
         **kwargs,
     ):
         """Construct the 4D-OBC algorithm.
@@ -836,7 +879,27 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
             as unsigned difference between magnitude (i.e. distance) at start epoch and peak magnitude.
             The default is 0.0, in which case all detected changes are used as seed candidates.
         :type height_threshold: float
-
+        :param use_unfinished:
+            If False, seed candidates that are not finished by the end of the time series are not considered in further
+            analysis. The default is True, in which case unfinished seed_candidates are regarded as seeds region growing.
+        :type use_unfinished: bool
+        :param intermediate_saving:
+            Parameter that determines after how many considered seeds, the resulting list of 4D-OBCs is saved to the SpatiotemporalAnalysis object.
+            This is to ensure that if the algorithm is terminated unexpectedly not all results are lost. If set to 0 no intermediate saving is done.
+        :type intermediate_saving: int
+        :param resume_from_seed:
+            Parameter specifying from which seed index the region growing algorithm must resume. If zero all seeds are considered, starting from the highest ranked seed.
+            Default is 0.
+        :type resume_from_seed: int
+        :param stop_at_seed:
+            Parameter specifying at which seed to stop region growing and terminate the run function.
+            Default is np.inf, meaning all seeds are considered.
+        :type stop_at_seed: int
+        :param write_nr_seeds:
+            If True, after seed detection, a text file is written in the working directory containing the total number of detected seeds.
+            This can be used to split up the consecutive 4D-OBC segmentation into different subsets.
+            Default is False, meaning no txt file is written.
+        :type write_nr_seeds: bool
         """
 
         # Initialize base class
@@ -851,6 +914,11 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
         self.window_penalty = window_penalty
         self.minperiod = minperiod
         self.height_threshold = height_threshold
+        self.use_unfinished = use_unfinished
+        self.intermediate_saving = intermediate_saving
+        self.resume_from_seed = resume_from_seed
+        self.stop_at_seed = stop_at_seed
+        self.write_nr_seeds = write_nr_seeds
 
     def find_seedpoints(self):
         """Calculate seedpoints for the region growing algorithm"""
@@ -941,8 +1009,14 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
 
                     # Check whether the volume started decreasing
                     if previous_volume > volume:
-                        # Only add seed if larger than the minimum period
-                        if target_idx - start_idx >= self.minperiod:
+                        # Only add seed if larger than the minimum period and height of the change form larger than threshold
+                        if (target_idx - start_idx >= self.minperiod) and (
+                            np.abs(
+                                np.max(used_timeseries[start_idx : target_idx + 1])
+                                - np.min(used_timeseries[start_idx : target_idx + 1])
+                            )
+                            >= self.height_threshold
+                        ):
                             corepoint_seeds.append(
                                 RegionGrowingSeed(i, start_idx, target_idx)
                             )
@@ -953,7 +1027,7 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
                     # This causes a seed to always be detected if the volume doesn't decrease before present
                     #  Useful when used in an online setting, can be filtered before region growing
                     # Only if the last epoch is reached we use the segment as seed
-                    if target_idx == timeseries.shape[0] - 1:
+                    if (target_idx == timeseries.shape[0] - 1) and self.use_unfinished:
                         # We reached the present and add a seed based on it
                         corepoint_seeds.append(
                             RegionGrowingSeed(i, start_idx, timeseries.shape[0] - 1)
@@ -973,6 +1047,10 @@ class RegionGrowingAlgorithm(RegionGrowingAlgorithmBase):
             neighbors = self.analysis.corepoints.kdtree.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
+            if len(neighbors) < 2:
+                return 9999999.0  # return very large number? or delete the seed point, but then also delete from the seeds list
+
             similarities = []
             for n in neighbors:
                 data = _py4dgeo.TimeseriesDistanceFunctionData(

py4dgeo/util.py

@@ -14,8 +14,8 @@ import _py4dgeo
 
 
 # The current data archive URL
-TEST_DATA_ARCHIVE = "https://github.com/3dgeo-heidelberg/py4dgeo-test-data/releases/download/2023-09-08/data.tar.gz"
-TEST_DATA_CHECKSUM = "88bd0663c6b4d7edad4561e5a7cca929ef70d6c2a67bfffd3a863c6105ba452c"
+TEST_DATA_ARCHIVE = "https://github.com/3dgeo-heidelberg/py4dgeo-test-data/releases/download/2024-06-28/data.tar.gz"
+TEST_DATA_CHECKSUM = "5ee51a43b008181b829113d8b967cdf519eae4ac37a3301f1eaf53d15d3016cc"
 
 # Read the version from package metadata
 __version__ = metadata.version(__package__)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py4dgeo
-Version: 0.6.0
+Version: 0.7.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:
@@ -26,8 +26,6 @@ Requires-Dist: scikit-learn
 Requires-Dist: vedo
 Requires-Dist: xdg
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
-License-File: COPYING.md
 
 # Welcome to py4dgeo
 
@@ -53,28 +51,27 @@ 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. The concept and algorithm is explained [in this tutorial by James Dietrich](https://youtu.be/xJql7h8M2_o), including usage in the graphical software [CloudCompare](www.cloudcompare.org).
+* **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. The concept and method are explained in full detail in the related paper.
+* **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 *[under active development]*. The concept and method are explained in this scientific talk:
-<a href="https://youtu.be/JxX3veMbMAI" target="_blank"><img src="https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/doc/img/thumb_youtube_anders_isprs2021.png?raw=true" alt="" width="400" /></a>
+* **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. The concept and method are explained in this scientific talk:
-<a href="https://youtu.be/5pjkpajsRNU" target="_blank"><img src="https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/doc/img/thumb_youtube_zahs_isprs2022.png?raw=true" alt="" width="400" /></a>
+* **Correspondence-driven plane-based M3C2** ([Zahs et al., 2022](#-literature)) for lower uncertainty in 3D topographic change quantification  *[under active development]*.
 
-* **Point cloud registration**: Py4dgeo supports to calculate and apply affine transformations to point clouds using a standard ICP implementations. More ICP methods are currently being implemented - stay tuned!
+* **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://github.com/3dgeo-heidelberg/py4dgeo/blob/main/demo/m3c2-change_analysis.ipynb)  | [![Example 2](img/m3c2ep_change_analysis_thumbnail.png)](https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/demo/m3c2ep-change_analysis.ipynb)  |
-| [![Example 3](img/4dobc_extraction_thumbnail.png)](https://github.com/3dgeo-heidelberg/py4dgeo/blob/main/demo/4dobc-change_analysis.ipynb)  | [![Example 4](img/kmeans_clustering_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/kmeans_clustering_of_time_series.ipynb)  |
-| [![Example 5](img/pca_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/registration_standard_ICP.ipynb)  | [![Example 6](img/standard_icp_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/registration_standard_ICP.ipynb) |
-| [![Example 7](img/cd-pb-m3c2_change_analysis_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/jupyter/pbm3c2.ipynb)
+|                                                                                                                                                              |                                                                                                                                                                 |
+|--------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [![Example 1](img/m3c2_change_analysis_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/m3c2-change_analysis.ipynb)       | [![Example 2](img/m3c2ep_change_analysis_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/m3c2ep_change_analysis.ipynb)      |
+| [![Example 3](img/4dobc_extraction_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/4dobc-change_analysis.ipynb)          | [![Example 4](img/kmeans_clustering_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/kmeans_clustering_of_time_series.ipynb) |
+| [![Example 5](img/pca_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/principal_component_analysis_of_time_series.ipynb) | [![Example 6](img/pbm3c2_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/jupyter/pbm3c2.ipynb)                                   |
+ [![Example 7](img/standard_icp_thumbnail.png)](https://nbviewer.org/github/3dgeo-heidelberg/py4dgeo/blob/main/demo/registration_standard_ICP.ipynb)          |
 
 ## 💻 Installation
 
@@ -82,7 +79,7 @@ Below, you find a list of [provided methods](#methods-provided-by-py4dgeo).
 
 Using py4dgeo requires the following software installed:
 
-* 64-bit Python `>= 3.8` (32-bit installations might cause trouble during installation of dependencies)
+* 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.
 

py4dgeo-0.7.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+_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,,

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

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

py4dgeo-0.6.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-_py4dgeo.cp39-win_amd64.pyd,sha256=wnuHtpyKWkLDhKxEeSvSNj9hf0Js-v8-eLsQxguMQQE,437760
-py4dgeo/__init__.py,sha256=SUIe73kbzU1eLUJXUAxNvFMroy-K6PoMR-Ox_RyDC7U,703
-py4dgeo/cloudcompare.py,sha256=R4IDWBu13RilIjgXVClE7sFsGhs0TXiJj-5IPAr9AMk,1157
-py4dgeo/epoch.py,sha256=h9XqOwRgVFbebn12bXYTSnrkp3M25NNPV32Jq8Wm2Jg,27772
-py4dgeo/fallback.py,sha256=jD5OFPrFAbTMJpXTx-gRgfcwCBK0F6cLXcxraQ7WL1I,5230
-py4dgeo/logger.py,sha256=5J7DenNkvq5GMOF_Vd2kHLHGP7os1u4EFBMbyGCAJJY,2314
-py4dgeo/m3c2.py,sha256=zgueVFPDGhnoUuAvtEwmBXgHOzTsDhkjde1SZBnllww,7658
-py4dgeo/m3c2ep.py,sha256=_A7vH2tEQ-Xnx88clhywKkraSrJAYL_aVNw44oFgn20,29122
-py4dgeo/pbm3c2.py,sha256=nrdqYvxUnENgJj9wR1D9C4uqsyzCNJ_2GVrP-CjNgEM,146070
-py4dgeo/py4dgeo_python.cpp,sha256=5XRjetjQsVrz7Xj8DpbwyIH7P7XTf73PfoQHWEfSxac,15371
-py4dgeo/registration.py,sha256=SLYtg8ag6mtMpdmosiOpdvpZC5ykJnLrgU6-kVAixHU,3128
-py4dgeo/segmentation.py,sha256=MS3jETT34QVs0e87ncU5ZkitImsrZV080PJE0kTfKsk,48878
-py4dgeo/UpdateableZipFile.py,sha256=aZVdQgAc_M-EWFDIEVukgrYQUtEb5fRoRMCVxZqpggc,2770
-py4dgeo/util.py,sha256=BzyY5TxnQ4uDEtHJlgR6mzXpcy4CRdm_2Ywj0BquwCs,8553
-py4dgeo-0.6.0.dist-info/METADATA,sha256=17eGeRumqHKC35ug_w5seIkm2E4bAX4UnpZpOEQBbGQ,12586
-py4dgeo-0.6.0.dist-info/WHEEL,sha256=8M3tCeSbuIPqzNDALzP1Gqz5ajcvQ7Kh5mc0IA65Zn4,103
-py4dgeo-0.6.0.dist-info/entry_points.txt,sha256=S8EHFVRD4deFJ_N6ZWst9v_ukH5lGnZY-f8NHjYoIfk,83
-py4dgeo-0.6.0.dist-info/licenses/LICENSE.md,sha256=Rza103klOvpFdEr8ed20dZErIT6Tm998uX2ai29wDl8,1028
-py4dgeo-0.6.0.dist-info/licenses/COPYING.md,sha256=ZetvO_BrdyO2DkROtlUcvpd6rl1M8Ak69vyDyePCZN0,1330
-py4dgeo-0.6.0.dist-info/RECORD,,