PartSegCore-compiled-backend 0.15.11__tar.gz → 0.15.13__tar.gz

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/.pre-commit-config.yaml

@@ -1,10 +1,7 @@
-default_language_version:
-    python: python3.9
-
 repos:
 -   repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.9.2
+    rev: v0.12.0
     hooks:
       # Run the linter.
       - id: ruff
@@ -30,13 +27,13 @@ repos:
     hooks:
     - id: markdownlint
 -   repo: https://github.com/codespell-project/codespell
-    rev: v2.3.0
+    rev: v2.4.1
     hooks:
     - id: codespell
       additional_dependencies:
       - tomli
 -   repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v19.1.7  # Use the sha / tag you want to point at
+    rev: v20.1.6  # Use the sha / tag you want to point at
     hooks:
     - id: clang-format
       args: ["-style=Google"]

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: PartSegCore_compiled_backend
-Version: 0.15.11
+Version: 0.15.13
 Summary: PartSegCore compiled backend,
 Keywords: bioimaging
 Author-Email: Grzegorz Bokota <g.bokota@cent.uw.edu.pl>
@@ -18,13 +18,13 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Project-URL: Homepage, https://4dnucleome.cent.uw.edu.pl/PartSeg/
 Project-URL: Documentation, https://partsegcore-compiled-backend.readthedocs.io/en/stable/
-Project-URL: Source code, https://github.com/4DNucleome/PartSegCore-compiled-backend
+Project-URL: Source Code, https://github.com/4DNucleome/PartSegCore-compiled-backend
 Requires-Python: >=3.9
 Requires-Dist: numpy>=1.23.5
-Requires-Dist: pytest>=7.0.0; extra == "test"
-Requires-Dist: sphinx>=5.0.0; extra == "docs"
 Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
 Provides-Extra: docs
+Requires-Dist: sphinx>=5.0.0; extra == "docs"
 Description-Content-Type: text/markdown
 
 # PartSegCore_compiled_backend
@@ -61,6 +61,31 @@ pip install .
 As currently there is no wheel for macOS ARM64
 it is required to build package from source.
 
+## Development in Clion
+
+To install Python build dependencies, run:
+
+```bash
+pip install scikit-build-core cython cython-cmake numpy setuptools-scm
+```
+
+Then, install the package in development mode:
+
+```bash
+pip install --no-build-isolation --config-settings=editable.rebuild=true\
+ -Cbuild-dir=build -ve .
+```
+
+vendor `FindCython.cmake` from cython-cmake to `cmake` directory.
+
+```bash
+mkdir cmake && cython-cmake vendor cmake
+```
+
+Set `CUSTOM_MODULE_PATH` environment variable to full path to cmake directory.
+
+Set it in Settings → Build, Execution, Deployment → CMake → Environment
+
 ## Cite as
 
 Bokota, G., Sroka, J., Basu, S. et al. PartSeg: a tool for quantitative feature extraction

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/Readme.md

@@ -32,6 +32,31 @@ pip install .
 As currently there is no wheel for macOS ARM64
 it is required to build package from source.
 
+## Development in Clion
+
+To install Python build dependencies, run:
+
+```bash
+pip install scikit-build-core cython cython-cmake numpy setuptools-scm
+```
+
+Then, install the package in development mode:
+
+```bash
+pip install --no-build-isolation --config-settings=editable.rebuild=true\
+ -Cbuild-dir=build -ve .
+```
+
+vendor `FindCython.cmake` from cython-cmake to `cmake` directory.
+
+```bash
+mkdir cmake && cython-cmake vendor cmake
+```
+
+Set `CUSTOM_MODULE_PATH` environment variable to full path to cmake directory.
+
+Set it in Settings → Build, Execution, Deployment → CMake → Environment
+
 ## Cite as
 
 Bokota, G., Sroka, J., Basu, S. et al. PartSeg: a tool for quantitative feature extraction

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/pyproject.toml

@@ -1,6 +1,12 @@
 [build-system]
 # Minimum requirements for the build system to execute.
-requires = ["scikit-build-core", "Cython", "cython-cmake", "numpy>=2", "setuptools_scm[toml]>=8.1"]  # PEP 508 specifications.
+requires = [
+    "scikit-build-core",
+    "Cython",
+    "cython-cmake",
+    "numpy>=2",
+    "setuptools_scm[toml]>=8.1"
+]  # PEP 508 specifications.
 build-backend = "scikit_build_core.build"
 
 [tool.scikit-build]

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/_fast_unique.pyx

@@ -27,7 +27,7 @@ ctypedef fused numpy_int_types:
 def unique1d(np.ndarray[numpy_int_types, ndim=1] array):
     cdef unordered_set[numpy_int_types] unique_values
     cdef vector[unordered_set[numpy_int_types]] unique_values_vector
-    cdef Py_ssize_t i, j, n_rows, n_cols, id_num
+    cdef Py_ssize_t i, j, n_rows, n_cols, id_num, n_items
     cdef numpy_int_types prev_val, v
     n_items = array.shape[0]
     unique_values_vector.resize(50) # openmp.omp_get_num_threads())

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/multiscale_opening/mso.h

@@ -580,7 +580,7 @@ class MSO {
       queue_copy = queue;
       // std::cerr << "# Queue1 " << queue.get_size() << " Queue2 " <<
       // queue_copy.get_size() << std::endl;
-      // Calculate area which can be reached by monoticall path (firs part of
+      // Calculate area which can be reached by monoticall path (first part of
       // Morphological neighborhood)
       while (!queue.empty()) {
         coord = queue.front();

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/sprawl_utils/find_split.py

@@ -4,7 +4,6 @@ This module contains function to perform multiple component sprawl (watershed li
 
 from __future__ import annotations
 
-import logging
 import os
 import typing
 from concurrent.futures import ThreadPoolExecutor, as_completed
@@ -385,7 +384,6 @@ def reverse_permutation(perm: list[int]) -> list[int]:
 
 
 def relabel_with_perm(labeling: list, perm: list) -> list:
-    logging.debug('%(labeling), %(perm)', extra={'labeling': labeling, 'perm': perm})
     perm = reverse_permutation(perm)
     return [perm[x] for x in labeling]
 

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/triangulation/intersection.hpp

@@ -112,6 +112,12 @@ inline int64_t double_as_hex(double d) {
   return result;
 }
 
+enum Orientation {
+  COLLINEAR = 0,
+  CLOCKWISE = 1,
+  COUNTERCLOCKWISE = 2,
+};
+
 /**
  * Determines the orientation of the triplet (p, q, r).
  *
@@ -119,12 +125,14 @@ inline int64_t double_as_hex(double d) {
  * @param q The second point.
  * @param r The third point.
  *
- * @return 0 if p, q and r are collinear.
- *         1 if the triplet (p, q, r) is in a clockwise orientation.
- *         2 if the triplet (p, q, r) is in a counterclockwise orientation.
+ * @return Orientation::COLLINEAR if p, q and r are collinear.
+ *         Orientation::CLOCKWISE if the triplet (p, q, r) is in a clockwise
+ *         orientation.
+ *         Orientation::COUNTERCLOCKWISE if the triplet (p, q, r) is in a
+ *         counterclockwise orientation.
  */
-inline int _orientation(const point::Point &p, const point::Point &q,
-                        const point::Point &r) {
+inline Orientation _orientation(const point::Point &p, const point::Point &q,
+                                const point::Point &r) {
   double val1 = ((q.y - p.y) * (r.x - q.x));
   double val2 = ((r.y - q.y) * (q.x - p.x));
   // This commented code if for debugging purposes of differences between macOS
@@ -142,8 +150,8 @@ inline int _orientation(const point::Point &p, const point::Point &q,
   // }
   // Instead of using classical equation, we need to use two variables
   // to handle problem with strange behavior on macOS.
-  if (val1 == val2) return 0;
-  return (val1 > val2) ? 1 : 2;
+  if (val1 == val2) return Orientation::COLLINEAR;
+  return (val1 > val2) ? Orientation::CLOCKWISE : Orientation::COUNTERCLOCKWISE;
 }
 
 /**
@@ -163,17 +171,17 @@ inline bool _do_intersect(const point::Segment &s1, const point::Segment &s2) {
   const point::Point &p2 = s2.bottom;
   const point::Point &q2 = s2.top;
 
-  int o1 = _orientation(p1, q1, p2);
-  int o2 = _orientation(p1, q1, q2);
-  int o3 = _orientation(p2, q2, p1);
-  int o4 = _orientation(p2, q2, q1);
+  Orientation o1 = _orientation(p1, q1, p2);
+  Orientation o2 = _orientation(p1, q1, q2);
+  Orientation o3 = _orientation(p2, q2, p1);
+  Orientation o4 = _orientation(p2, q2, q1);
 
   if (o1 != o2 && o3 != o4) return true;
 
-  if (o1 == 0 && _on_segment(p1, p2, q1)) return true;
-  if (o2 == 0 && _on_segment(p1, q2, q1)) return true;
-  if (o3 == 0 && _on_segment(p2, p1, q2)) return true;
-  if (o4 == 0 && _on_segment(p2, q1, q2)) return true;
+  if (o1 == Orientation::COLLINEAR && _on_segment(p1, p2, q1)) return true;
+  if (o2 == Orientation::COLLINEAR && _on_segment(p1, q2, q1)) return true;
+  if (o3 == Orientation::COLLINEAR && _on_segment(p2, p1, q2)) return true;
+  if (o4 == Orientation::COLLINEAR && _on_segment(p2, q1, q2)) return true;
 
   return false;
 }

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/triangulation/point.hpp

@@ -208,6 +208,19 @@ struct Segment {
     }
   };
 };
+Point centroid(const std::vector<Point> &point_list) {
+  if (point_list.empty()) {
+    return {0, 0};
+  }
+  Point res(0, 0);
+  for (auto &point : point_list) {
+    res.x += point.x;
+    res.y += point.y;
+  }
+  res.x /= float(point_list.size());
+  res.y /= float(point_list.size());
+  return res;
+}
 }  // namespace partsegcore::point
 
 // overload of hash function for

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/triangulation/triangulate.hpp

@@ -2,6 +2,7 @@
 #define PARTSEGCORE_TRIANGULATE_H
 
 #include <algorithm>
+#include <cmath>
 #include <map>
 #include <memory>  // memory header is required on linux, and not on macos
 #include <set>
@@ -602,6 +603,36 @@ struct MonotonePolygonBuilder {
   };
 };
 
+/*
+ * Check if the polygon, that all angles have the same orientation
+ * do not have self-intersections
+ *
+ * @param begin Iterator to the first point of the polygon
+ * @param end Iterator to the end of the polygon
+ * @param centroid Centroid of the polygon
+ *
+ * @return True if the polygon is simple, false otherwise
+ */
+template <typename Iterator>
+bool is_simple_polygon(Iterator begin, Iterator end, point::Point centroid) {
+  double start_angle = std::atan2(begin->y - centroid.y, begin->x - centroid.x);
+  double prev_angle = 0;
+  begin++;
+  for (; begin != end; begin++) {
+    double angle =
+        std::atan2(begin->y - centroid.y, begin->x - centroid.x) - start_angle;
+    if (angle < 0) {
+      angle += 2 * M_PI;
+    }
+    if (angle < prev_angle) {
+      return false;
+    } else {
+      prev_angle = angle;
+    }
+  }
+  return true;
+}
+
 /**
  * Checks if a given polygon is convex.
  *
@@ -615,26 +646,47 @@ struct MonotonePolygonBuilder {
  * @return True if the polygon is convex, false otherwise.
  */
 inline bool _is_convex(const std::vector<point::Point> &polygon) {
-  int orientation = 0;
-  int triangle_orientation;
-  for (std::size_t i = 0; i < polygon.size() - 2; i++) {
-    triangle_orientation =
-        intersection::_orientation(polygon[i], polygon[i + 1], polygon[i + 2]);
-    if (triangle_orientation == 0) continue;
-    if (orientation == 0)
+  if (polygon.size() < 3) return false;
+  if (polygon.size() == 3) return true;
+  intersection::Orientation orientation = intersection::Orientation::COLLINEAR;
+  intersection::Orientation triangle_orientation;
+  size_t idx = 0;
+  for (; idx < polygon.size() - 2; idx++) {
+    triangle_orientation = intersection::_orientation(
+        polygon[idx], polygon[(idx + 1)], polygon[(idx + 2)]);
+    if (triangle_orientation != intersection::Orientation::COLLINEAR) {
       orientation = triangle_orientation;
-    else if (orientation != triangle_orientation)
+      break;
+    }
+  }
+  if (orientation == intersection::Orientation::COLLINEAR) {
+    return false;
+  }
+  for (; idx < polygon.size() - 2; idx++) {
+    triangle_orientation = intersection::_orientation(
+        polygon[idx], polygon[(idx + 1)], polygon[(idx + 2)]);
+    if (triangle_orientation != 0 && triangle_orientation != orientation) {
       return false;
+    }
   }
   triangle_orientation = intersection::_orientation(
       polygon[polygon.size() - 2], polygon[polygon.size() - 1], polygon[0]);
-  if (triangle_orientation != 0 && triangle_orientation != orientation)
+  if (triangle_orientation != 0 && triangle_orientation != orientation) {
     return false;
+  }
   triangle_orientation = intersection::_orientation(polygon[polygon.size() - 1],
                                                     polygon[0], polygon[1]);
-  if (triangle_orientation != 0 && triangle_orientation != orientation)
+  if (triangle_orientation != 0 && triangle_orientation != orientation) {
     return false;
-  return true;
+  }
+
+  point::Point centroid = point::centroid(polygon);
+
+  if (orientation == intersection::Orientation::COUNTERCLOCKWISE) {
+    return is_simple_polygon(polygon.begin(), polygon.end(), centroid);
+  } else {
+    return is_simple_polygon(polygon.rbegin(), polygon.rend(), centroid);
+  }
 }
 
 /**

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/PartSegCore_compiled_backend/version.py

@@ -1,8 +1,13 @@
-# file generated by setuptools_scm
+# file generated by setuptools-scm
 # don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
 TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from typing import Tuple, Union
+    from typing import Tuple
+    from typing import Union
+
     VERSION_TUPLE = Tuple[Union[int, str], ...]
 else:
     VERSION_TUPLE = object
@@ -12,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.15.11'
-__version_tuple__ = version_tuple = (0, 15, 11)
+__version__ = version = '0.15.13'
+__version_tuple__ = version_tuple = (0, 15, 13)

{partsegcore_compiled_backend-0.15.11 → partsegcore_compiled_backend-0.15.13}/src/tests/test_triangulate.py

@@ -208,6 +208,7 @@ def test_triangle_convex_polygon():
     ],
 )
 def test_triangulate_polygon_py_convex(polygon, expected):
+    assert is_convex(polygon)
     assert triangulate_polygon_py(polygon)[0] == expected
 
 
@@ -691,3 +692,55 @@ def test_splitting_edges(split_edges, triangles):
     )
     triangles_ = triangulate_polygon_with_edge_numpy_li([polygon], split_edges=split_edges)[1][2]
     assert len(triangles_) == triangles
+
+
+def generate_regular_polygon(n: int, reverse: bool, radius: int = 1) -> np.ndarray:
+    angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+    if reverse:
+        angles = angles[::-1]
+    return np.column_stack((radius * np.cos(angles), radius * np.sin(angles)))
+
+
+def generate_self_intersecting_polygon(n: int, reverse: bool, radius: int = 1) -> np.ndarray:
+    """Generate self-intersecting polygon with n vertices
+
+    The polygon is generated by doubling the angle range of a regular polygon
+    """
+    assert n % 2 == 1, 'an odd number is required to generate a self-intersecting polygon'
+    angles = np.linspace(0, 4 * np.pi, n, endpoint=False)
+    if reverse:
+        angles = angles[::-1]
+    return np.column_stack((radius * np.cos(angles), radius * np.sin(angles)))
+
+
+def rotation_matrix(angle: float) -> np.ndarray:
+    """Create a 2D rotation matrix for the given angle in degrees."""
+    return np.array(
+        [
+            [np.cos(np.radians(angle)), -np.sin(np.radians(angle))],
+            [np.sin(np.radians(angle)), np.cos(np.radians(angle))],
+        ]
+    )
+
+
+ANGLES = [0, 5, 75, 95, 355]
+
+
+@pytest.mark.parametrize('angle', ANGLES, ids=str)
+@pytest.mark.parametrize('n_vertex', [5, 7, 19])
+@pytest.mark.parametrize('reverse', [False, True])
+def test_is_convex_self_intersection(angle, n_vertex, reverse):
+    p = generate_self_intersecting_polygon(n_vertex, reverse)
+    rot = rotation_matrix(angle)
+    data = np.dot(p, rot)
+    assert not is_convex(data)
+
+
+@pytest.mark.parametrize('angle', ANGLES, ids=str)
+@pytest.mark.parametrize('n_vertex', [3, 4, 7, 12, 15, 20])
+@pytest.mark.parametrize('reverse', [False, True])
+def test_is_convex_regular_polygon(angle, n_vertex, reverse):
+    poly = generate_regular_polygon(n_vertex, reverse=reverse)
+    rot = rotation_matrix(angle)
+    rotated_poly = np.dot(poly, rot)
+    assert is_convex(rotated_poly)