Merge pull request #404 from jo-mueller/expand-supported-python-versions

expand tests to more python versions

Author: jo-mueller

.github/workflows/test_and_deploy.yml

@@ -21,11 +21,21 @@ jobs:
     strategy:
       matrix:
         platform: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.9"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Increase swapfile
+        if: runner.os == 'Linux'
+        run: |
+          sudo swapoff -a
+          sudo fallocate -l 15G /swapfile
+          sudo chmod 600 /swapfile
+          sudo mkswap /swapfile
+          sudo swapon /swapfile
+          sudo swapon --show
+
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v5
         with:

pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "mpmath",
     "napari",
     "napari-tools-menu>=0.1.15",
-    "numpy<1.24.0",
+    "numpy<2.0.0",
     "pandas",
     "scikit-image",
     "scipy>=1.9.0",

src/napari_stress/_reconstruction/patches.py

@@ -513,7 +513,7 @@ def iterative_curvature_adaptive_patch_fitting(
                 fitted_query_point, fitting_params
             )
 
-            mean_curvatures[idx] = mean_curv
+            mean_curvatures[idx] = mean_curv[0]
             principal_curvatures[idx] = principal_curv[0]
 
         # Update the search radii

src/napari_stress/_tests/test_approximation.py

@@ -3,230 +3,146 @@
 
 
 @pytest.fixture
-def ellipsoid_points():
+def generate_pointclouds():
     """
-    Generates points on the surface of an ellipsoid.
+    Generates synthetic point clouds for testing.
     """
-    a, b, c = 5, 3, 2  # Semi-axes of the ellipsoid
-    u = np.linspace(0, 2 * np.pi, 30)  # Longitude-like angles
-    v = np.linspace(0, np.pi, 30)  # Latitude-like angles
-    u, v = np.meshgrid(u, v)
-    x = a * np.cos(u) * np.sin(v)
-    y = b * np.sin(u) * np.sin(v)
-    z = c * np.cos(v)
-    return np.column_stack((x.ravel(), y.ravel(), z.ravel()))
-
-
-@pytest.fixture
-def droplet_points():
-    """
-    Create a droplet point cloud.
-    """
-    from napari_stress import sample_data
-
-    pointcloud = sample_data.get_droplet_point_cloud()[0][0][:, 1:]
-
-    return pointcloud
-
-
-def test_spherical_harmonics_fit(droplet_points):
+    def ellipsoid_points(a=5, b=3, c=2):
+        u = np.linspace(0, 2 * np.pi, 30)  # Longitude-like angles
+        v = np.linspace(0, np.pi, 30)  # Latitude-like angles
+        u, v = np.meshgrid(u, v)
+        x = a * np.cos(u) * np.sin(v)
+        y = b * np.sin(u) * np.sin(v)
+        z = c * np.cos(v)
+        return np.column_stack((x.ravel(), y.ravel(), z.ravel()))
+
+    def droplet_points():
+        from napari_stress import sample_data
+        return sample_data.get_droplet_point_cloud()[0][0][:, 1:]
+
+    def random_ellipsoid_points(a0=10, a1=20, a2=30, x0=(0, 0, 0)):
+        import vedo
+        ellipsoid = vedo.Ellipsoid(
+            pos=x0,
+            axis1=(a0, 0, 0),
+            axis2=(0, a1, 0),
+            axis3=(0, 0, a2),
+        )
+        points = ellipsoid.vertices
+        # Random rotations
+        angle_z = np.radians(np.random.randint(0, 360))
+        angle_x = np.radians(np.random.randint(0, 180))
+        R_z = np.array([[np.cos(angle_z), -np.sin(angle_z), 0],
+                        [np.sin(angle_z), np.cos(angle_z), 0],
+                        [0, 0, 1]])
+        R_x = np.array([[1, 0, 0],
+                        [0, np.cos(angle_x), -np.sin(angle_x)],
+                        [0, np.sin(angle_x), np.cos(angle_x)]])
+        return points @ R_z @ R_x
+
+    return ellipsoid_points, droplet_points, random_ellipsoid_points
+
+
+def test_spherical_harmonics(generate_pointclouds):
     """
-    Test fitting spherical harmonics to ellipsoid points.
+    Test spherical harmonics fitting and expansion.
     """
     from napari_stress import approximation
 
-    expander = approximation.SphericalHarmonicsExpander(
-        max_degree=5, expansion_type="cartesian"
-    )
-    expander.fit(droplet_points)
-
-    assert expander.coefficients_ is not None
-    assert expander.coefficients_.shape == (3, (5 + 1), (5 + 1))
-
-
-def test_spherical_harmonics_expand(droplet_points):
-    """
-    Test expanding points using spherical harmonics.
-    """
-    from napari_stress import approximation
+    _, droplet_points, _ = generate_pointclouds
+    points = droplet_points()
+    degree = 20
 
+    # Test fitting
     expander = approximation.SphericalHarmonicsExpander(
-        max_degree=10, expansion_type="cartesian"
+        max_degree=degree, expansion_type="cartesian"
     )
-    expander.fit(droplet_points)
-    expanded_points = expander.expand(droplet_points)
+    expander.fit(points)
+    assert expander.coefficients_ is not None
+    assert expander.coefficients_.shape == (3, (degree + 1), (degree + 1))
 
-    # Assert the expanded points are close to the original points
-    np.testing.assert_allclose(expanded_points, droplet_points, rtol=0.01)
+    # Test expansion
+    expanded_points = expander.expand(points)
+    np.testing.assert_allclose(expanded_points, points, rtol=0.01)
 
+    # Test radial expansion
     expander_radial = approximation.SphericalHarmonicsExpander(
         max_degree=10, expansion_type="radial"
     )
-    expander_radial.fit(droplet_points)
-    expanded_points_radial = expander_radial.expand(droplet_points)
-
-    # Assert the expanded points are close to the original points
-    np.testing.assert_allclose(
-        expanded_points_radial, droplet_points, rtol=0.01
-    )
-
-
-def generate_ellipsoidal_pointclouds(
-    a0: float = 10, a1: float = 20, a2: float = 30, x0: tuple = (0, 0, 0)
-):
-    import vedo
-
-    ellipsoid = vedo.Ellipsoid(
-        pos=x0,
-        axis1=(a0, 0, 0),
-        axis2=(0, a1, 0),
-        axis3=(0, 0, a2),
-    )
-
-    points = ellipsoid.vertices
+    expander_radial.fit(points)
+    expanded_points_radial = expander_radial.expand(points)
+    np.testing.assert_allclose(expanded_points_radial, points, rtol=0.01)
 
-    # rotate all points around the z-axis by random angle between
-    # 0 and 360 degrees using only numpy
-    angle = np.radians(np.random.randint(0, 360))
-    c, s = np.cos(angle), np.sin(angle)
-    R = np.array(((c, -s, 0), (s, c, 0), (0, 0, 1)))
-    points = points @ R
 
-    # rotate also around x-axis by random angle between
-    # 0 and 180 degrees using only numpy
-    angle = np.radians(np.random.randint(0, 180))
-    c, s = np.cos(angle), np.sin(angle)
-    R = np.array(((1, 0, 0), (0, c, -s), (0, s, c)))
-    points = points @ R
-
-    return points
-
-
-def test_lsq_ellipsoid0(n_tests=10):
+def test_ellipsoid_fitting(generate_pointclouds):
+    """
+    Test ellipsoid fitting and properties.
+    """
     from napari_stress import approximation
 
-    a0 = 10
-    a1 = 20
-    a2 = 30
+    _, _, random_ellipsoid_points = generate_pointclouds
+    a0, a1, a2 = 10, 20, 30
     x0 = np.asarray([0, 0, 0])
 
-    max_mean_curvatures = []
-    min_mean_curvatures = []
-    for i in range(n_tests):
-        points = generate_ellipsoidal_pointclouds(a0=a0, a1=a1, a2=a2, x0=x0)
-
-        expander = approximation.EllipsoidExpander()
-        expander.fit(points)
-
-        expanded_points = expander.expand(points)
-        center = expander.center_
-        axes_lengths = np.sort(expander.axes_)
-
-        max_mean_curvatures.append(
-            expander.properties["maximum_mean_curvature"]
-        )
-        min_mean_curvatures.append(
-            expander.properties["minimum_mean_curvature"]
-        )
-
-        # The mean curvature of an ellipsoid is given by the formula
-        # H = a / (2 * c^2) + a / (2 * b^2) for the maximum mean curvature
-        # and H = c / (2 * b^2) + c / (2 * a^2) for the minimum mean curvature
-        # where a, b, c are the semi-axes of the ellipsoid
-        axes_sorted = np.sort(expander.axes_)
-        a = axes_sorted[2]
-        b = axes_sorted[1]
-        c = axes_sorted[0]
-        h_max_theory = a / (2 * c**2) + a / (2 * b**2)
-        h_min_theory = c / (2 * b**2) + c / (2 * a**2)
-        assert expander.properties["maximum_mean_curvature"] == h_max_theory
-        assert expander.properties["minimum_mean_curvature"] == h_min_theory
-        assert (
-            expander.properties["maximum_mean_curvature"]
-            > expander.properties["minimum_mean_curvature"]
-        )
-
-        assert np.allclose(center, x0)
-        assert np.allclose(a2, axes_lengths[2])
-        assert np.allclose(a1, axes_lengths[1])
-        assert np.allclose(a0, axes_lengths[0])
-
-        assert np.allclose(
-            expander.properties["residuals"].mean(), 0, atol=0.01
-        )
-        assert len(expanded_points) == len(points)
-
-    # all elements in either list should be the same
-    assert np.allclose(max_mean_curvatures, max_mean_curvatures[0])
-    assert np.allclose(min_mean_curvatures, min_mean_curvatures[0])
-
-
-def test_lsq_ellipsoid1():
-    "Test whether pproperties in class are correctly set."
-    from napari_stress import approximation
+    points = random_ellipsoid_points(a0, a1, a2, x0)
 
+    # Test fitting
     expander = approximation.EllipsoidExpander()
+    expander.fit(points)
+    expanded_points = expander.expand(points)
+    center = expander.center_
+    axes_lengths = np.sort(expander.axes_)
+
+    # Validate properties
+    assert np.allclose(center, x0)
+    assert np.allclose(a2, axes_lengths[2])
+    assert np.allclose(a1, axes_lengths[1])
+    assert np.allclose(a0, axes_lengths[0])
+    assert np.allclose(expander.properties["residuals"].mean(), 0, atol=0.01)
+    assert len(expanded_points) == len(points)
+
+    # Validate mean curvature
+    max_curvature = expander.properties["maximum_mean_curvature"]
+    min_curvature = expander.properties["minimum_mean_curvature"]
+    axes_sorted = np.sort(expander.axes_)
+    a, b, c = axes_sorted[2], axes_sorted[1], axes_sorted[0]
+    h_max_theory = a / (2 * c**2) + a / (2 * b**2)
+    h_min_theory = c / (2 * b**2) + c / (2 * a**2)
+    assert np.allclose(max_curvature, h_max_theory)
+    assert np.allclose(min_curvature, h_min_theory)
+    assert max_curvature > min_curvature
+
+
+def test_curvature_and_normals(generate_pointclouds, make_napari_viewer):
+    """
+    Test curvature and normals on ellipsoid.
+    """
+    from napari_stress import approximation, measurements, types
 
-    random_coefficients = np.random.random((3, 2, 3))
-    expander.coefficients_ = random_coefficients
-
-    assert np.array_equal(expander.center_, random_coefficients[0, 0])
-    assert np.array_equal(
-        expander.axes_, np.linalg.norm(random_coefficients[:, 1], axis=1)
-    )
-
-
-def test_lsq_ellipsoid():
-    from napari_stress import approximation, get_droplet_point_cloud
-
-    pointcloud = get_droplet_point_cloud()[0][0][:, 1:]
-    ellipsoid = approximation.least_squares_ellipsoid(pointcloud)
-
-    fitted_points = approximation.expand_points_on_ellipse(
-        ellipsoid, pointcloud
-    )
-
-    assert fitted_points is not None
-
-
-def test_ellipse_normals():
-    from napari_stress import approximation, get_droplet_point_cloud
-
-    pointcloud = get_droplet_point_cloud()[0][0][:, 1:]
-
-    normals = approximation.normals_on_ellipsoid(pointcloud)
-
-    assert normals is not None
-
+    _, droplet_points, _ = generate_pointclouds
+    points = droplet_points()
 
-def test_curvature_on_ellipsoid(make_napari_viewer):
-    from napari_stress import (
-        approximation,
-        get_droplet_point_cloud,
-        measurements,
-        types,
-    )
+    # Fit ellipsoid
+    ellipsoid = approximation.least_squares_ellipsoid(points)
+    fitted_points = approximation.expand_points_on_ellipse(ellipsoid, points)
 
-    pointcloud = get_droplet_point_cloud()[0][0][:, 1:]
-    ellipsoid_stress = approximation.least_squares_ellipsoid(pointcloud)
-    fitted_points_stress = approximation.expand_points_on_ellipse(
-        ellipsoid_stress, pointcloud
-    )
+    # Test curvature
     data, features, metadata = measurements.curvature_on_ellipsoid(
-        ellipsoid_stress, fitted_points_stress
+        ellipsoid, fitted_points
     )
-
     assert data is not None
     assert features is not None
     assert metadata is not None
 
-    viewer = make_napari_viewer()
-    viewer.add_points(fitted_points_stress)
-    viewer.add_vectors(ellipsoid_stress)
-    results = measurements.curvature_on_ellipsoid(
-        ellipsoid_stress, fitted_points_stress
-    )
+    # Test normals
+    normals = approximation.normals_on_ellipsoid(points)
+    assert normals is not None
 
+    # Validate metadata keys
+    viewer = make_napari_viewer()
+    viewer.add_points(fitted_points)
+    viewer.add_vectors(ellipsoid)
+    results = measurements.curvature_on_ellipsoid(ellipsoid, fitted_points)
     assert types._METADATAKEY_H_E123_ELLIPSOID in results[1]["metadata"].keys()
     assert types._METADATAKEY_H0_ELLIPSOID in results[1]["metadata"].keys()
     assert types._METADATAKEY_MEAN_CURVATURE in results[1]["features"].keys()