warpkit 1.2.0__tar.gz → 1.2.2__tar.gz

{warpkit-1.2.0 → warpkit-1.2.2}/.github/workflows/build.yml

@@ -41,7 +41,8 @@ jobs:
           {version: '3.11', glob: cp311*},
           {version: '3.12', glob: cp312*},
           {version: '3.13', glob: cp313*},
-          {version: '3.14', glob: cp314*}
+          {version: '3.14', glob: cp314-*},
+          {version: '3.14t', glob: cp314t*}
           ]
     name: Python ${{ matrix.python-versions.version }} wheel on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}

{warpkit-1.2.0 → warpkit-1.2.2}/CLAUDE.md

@@ -10,7 +10,7 @@ DIstortion Correction). Phase unwrapping uses a self-contained C++17 port of
 **no Julia runtime is involved**; do not reintroduce one (no `julia.py`, no
 conda recipe, no `FindJulia.cmake`).
 
-Pre-print: <https://www.biorxiv.org/content/10.1101/2023.11.28.568744v1>.
+Paper (Imaging Neuroscience): <https://doi.org/10.1162/IMAG.a.1262>.
 
 ## Layout
 
@@ -131,12 +131,15 @@ and call out anything CI-relevant (wheel matrix, pybind11 ABI, ITK).
 
 ## CI specifics
 
-GitHub Actions builds wheels for Python 3.11–3.14 on `ubuntu-latest`,
+GitHub Actions builds wheels for Python 3.11–3.14 (both standard and free-threaded) on `ubuntu-latest`,
 `ubuntu-24.04-arm`, and `macos-latest` via cibuildwheel.
-`pyproject.toml`'s `[tool.cibuildwheel]` skips `*musllinux*` and the
-`cp314t-*` free-threaded build; re-enabling free-threaded support requires
-auditing the pybind11 + ITK code paths for the no-GIL ABI. The sdist job
-also runs `uv run coverage run` then `coverage report -m` — keep coverage
-healthy when adding code (the `[tool.coverage.report]` config in
+`pyproject.toml`'s `[tool.cibuildwheel]` skips only `*musllinux*` builds.
+Free-threaded support is enabled via `py::mod_gil_not_used()` in
+`src/warpkit.cpp`. `PyErr_CheckSignals()` calls in `include/warps.h` are
+wrapped in a `WARPKIT_CHECK_SIGNALS()` macro that compiles to a no-op under
+`Py_GIL_DISABLED`, so GIL builds keep Ctrl+C interruptibility during long ITK
+operations and the free-threaded build skips the GIL-requiring check. The
+sdist job also runs `uv run coverage run` then `coverage report -m` — keep
+coverage healthy when adding code (the `[tool.coverage.report]` config in
 `pyproject.toml` omits the test files). PyPI publish and the GHCR Docker
 image only run on a published GitHub release.

{warpkit-1.2.0 → warpkit-1.2.2}/LICENSE

@@ -1,7 +1,10 @@
 Copyright (c) 2022 Washington University.
 Authored by: Andrew Van							
 
-Please cite https://www.biorxiv.org/content/10.1101/2023.11.28.568744v1	
+Please cite:
+Van AN, Montez DF, Laumann TO, Cho PN, Suljic V, Madison T, et al.
+Frame-wise multi-echo distortion correction for superior functional MRI.
+Imaging Neuroscience 2026; 4 IMAG.a.1262. doi: https://doi.org/10.1162/IMAG.a.1262
 
 warpkit is free for non-commercial use by academic, government,
 and non-profit/not-for-profit institutions. A commercial version of the software is

{warpkit-1.2.0 → warpkit-1.2.2}/PKG-INFO

@@ -1,11 +1,14 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: warpkit
-Version: 1.2.0
+Version: 1.2.2
 Summary: A python library for neuroimaging transformations
 Keywords: neuroimaging
 Author-Email: Andrew Van <vanandrew77@gmail.com>
+License-File: LICENSE
+License-File: include/romeo/LICENSE
 Classifier: Programming Language :: Python :: 3
 Project-URL: github, https://github.com/vanandrew/warpkit
+Project-URL: paper, https://doi.org/10.1162/IMAG.a.1262
 Requires-Python: >=3.11
 Requires-Dist: nibabel>=4.0.2
 Requires-Dist: numpy>=1.23.3
@@ -19,10 +22,9 @@ Description-Content-Type: text/markdown
 
 [![Build](https://github.com/vanandrew/warpkit/actions/workflows/build.yml/badge.svg)](https://github.com/vanandrew/warpkit/actions)
 [![PyPI](https://img.shields.io/pypi/v/warpkit)](https://pypi.org/project/warpkit/)
-[![docker](https://ghcr-badge.egpl.dev/vanandrew/warpkit/latest_tag?trim=major&label=ghcr&nbsp;latest)](https://github.com/vanandrew/warpkit/pkgs/container/warpkit)
 [![codecov](https://codecov.io/gh/vanandrew/warpkit/graph/badge.svg?token=S6ZZKOAF8V)](https://codecov.io/gh/vanandrew/warpkit)
 
-A Python library for neuroimaging transforms, focused on the Multi-Echo DIstortion Correction (MEDIC) algorithm. The pre-print is available at <https://www.biorxiv.org/content/10.1101/2023.11.28.568744v1>.
+A Python library for neuroimaging transforms, focused on the Multi-Echo DIstortion Correction (MEDIC) algorithm. The paper is published in *Imaging Neuroscience* at <https://doi.org/10.1162/IMAG.a.1262>.
 
 The phase-unwrapping core is a self-contained C++17 port of [ROMEO](https://github.com/korbinian90/ROMEO) — there is no Julia runtime to install, and binary wheels ship with the ITK pieces statically linked. If you used an older release of warpkit that required `julia` on `PATH`, that step is gone.
 
@@ -211,6 +213,15 @@ wk-convert-fieldmap \
   --output sub-01_run-01_fieldmap.nii
 ```
 
+## Citation
+
+If you use warpkit, please cite:
+
+> Van AN, Montez DF, Laumann TO, Cho PN, Suljic V, Madison T, et al.
+> Frame-wise multi-echo distortion correction for superior functional MRI.
+> *Imaging Neuroscience* 2026; 4 IMAG.a.1262.
+> doi: <https://doi.org/10.1162/IMAG.a.1262>
+
 ## Authors
 
 Vahdeta Suljic &lt;suljic@wustl.edu&gt;, Andrew Van &lt;vanandrew77@gmail.com&gt;

{warpkit-1.2.0 → warpkit-1.2.2}/README.md

@@ -2,10 +2,9 @@
 
 [![Build](https://github.com/vanandrew/warpkit/actions/workflows/build.yml/badge.svg)](https://github.com/vanandrew/warpkit/actions)
 [![PyPI](https://img.shields.io/pypi/v/warpkit)](https://pypi.org/project/warpkit/)
-[![docker](https://ghcr-badge.egpl.dev/vanandrew/warpkit/latest_tag?trim=major&label=ghcr latest)](https://github.com/vanandrew/warpkit/pkgs/container/warpkit)
 [![codecov](https://codecov.io/gh/vanandrew/warpkit/graph/badge.svg?token=S6ZZKOAF8V)](https://codecov.io/gh/vanandrew/warpkit)
 
-A Python library for neuroimaging transforms, focused on the Multi-Echo DIstortion Correction (MEDIC) algorithm. The pre-print is available at <https://www.biorxiv.org/content/10.1101/2023.11.28.568744v1>.
+A Python library for neuroimaging transforms, focused on the Multi-Echo DIstortion Correction (MEDIC) algorithm. The paper is published in *Imaging Neuroscience* at <https://doi.org/10.1162/IMAG.a.1262>.
 
 The phase-unwrapping core is a self-contained C++17 port of [ROMEO](https://github.com/korbinian90/ROMEO) — there is no Julia runtime to install, and binary wheels ship with the ITK pieces statically linked. If you used an older release of warpkit that required `julia` on `PATH`, that step is gone.
 
@@ -194,6 +193,15 @@ wk-convert-fieldmap \
   --output sub-01_run-01_fieldmap.nii
 ```
 
+## Citation
+
+If you use warpkit, please cite:
+
+> Van AN, Montez DF, Laumann TO, Cho PN, Suljic V, Madison T, et al.
+> Frame-wise multi-echo distortion correction for superior functional MRI.
+> *Imaging Neuroscience* 2026; 4 IMAG.a.1262.
+> doi: <https://doi.org/10.1162/IMAG.a.1262>
+
 ## Authors
 
 Vahdeta Suljic &lt;suljic@wustl.edu&gt;, Andrew Van &lt;vanandrew77@gmail.com&gt;

warpkit-1.2.2/codecov.yml

@@ -0,0 +1,10 @@
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 1%
+    patch:
+      default:
+        target: 90%
+        threshold: 1%

{warpkit-1.2.0 → warpkit-1.2.2}/include/romeo/voxel_quality.h

@@ -48,50 +48,23 @@ inline std::vector<T> voxel_quality(const T* phase4d, std::size_t nx, std::size_
 
     std::vector<T> qmap(vol, T(0));
 
-    // Forward-edge sum: qmap[v] = Σ_d w[d, v] for the 3 dims.
-    for (std::size_t idx = 0; idx < vol; ++idx) {
-        qmap[idx] = w[0u + 3u * idx] + w[1u + 3u * idx] + w[2u + 3u * idx];
-    }
-
-    // Backward-edge contributions. Julia:
-    //   qmap[2:end,:,:] .+= weights[1, 1:end-1, :, :]
-    //   qmap[:,2:end,:] .+= weights[2, :, 1:end-1, :]
-    //   qmap[:,:,2:end] .+= weights[3, :, :, 1:end-1]
-    // In 0-based: each interior voxel adds the forward-edge weight of its
-    // previous neighbor along that dim.
-    const std::ptrdiff_t sx = 1;
-    const std::ptrdiff_t sy = static_cast<std::ptrdiff_t>(nx);
-    const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(nx * ny);
-
+    // Single fused pass: each voxel sums its three forward edges plus the
+    // forward-edge weight of its previous neighbor along each axis (= the
+    // backward-edge contribution from Julia's three .+= expressions).
+    // Associativity matches the original four-pass form: forward triplet
+    // first, then back-x, then back-y, then back-z.
     for (std::size_t k = 0; k < nz; ++k) {
         for (std::size_t j = 0; j < ny; ++j) {
-            for (std::size_t i = 1; i < nx; ++i) {
-                const std::size_t idx = i + nx * (j + ny * k);
-                const std::size_t prev = idx - static_cast<std::size_t>(sx);
-                qmap[idx] += w[0u + 3u * prev];
-            }
-        }
-    }
-    for (std::size_t k = 0; k < nz; ++k) {
-        for (std::size_t j = 1; j < ny; ++j) {
             for (std::size_t i = 0; i < nx; ++i) {
                 const std::size_t idx = i + nx * (j + ny * k);
-                const std::size_t prev = idx - static_cast<std::size_t>(sy);
-                qmap[idx] += w[1u + 3u * prev];
+                T q = w[0u + 3u * idx] + w[1u + 3u * idx] + w[2u + 3u * idx];
+                if (i > 0) q += w[0u + 3u * (idx - 1)];
+                if (j > 0) q += w[1u + 3u * (idx - nx)];
+                if (k > 0) q += w[2u + 3u * (idx - nx * ny)];
+                qmap[idx] = q / T(6);
             }
         }
     }
-    for (std::size_t k = 1; k < nz; ++k) {
-        for (std::size_t j = 0; j < ny; ++j) {
-            for (std::size_t i = 0; i < nx; ++i) {
-                const std::size_t idx = i + nx * (j + ny * k);
-                const std::size_t prev = idx - static_cast<std::size_t>(sz);
-                qmap[idx] += w[2u + 3u * prev];
-            }
-        }
-    }
-
-    for (std::size_t i = 0; i < vol; ++i) qmap[i] /= T(6);
     return qmap;
 }
 

{warpkit-1.2.0 → warpkit-1.2.2}/include/romeo/weights.h

@@ -119,91 +119,65 @@ inline std::vector<OutT> calculate_weights_romeo_impl(const T* phase, std::size_
     if (phase2 == nullptr || TEs == nullptr) flags.phase_gradient_coherence = false;
 
     const std::size_t n = nx * ny * nz;
-    const std::ptrdiff_t stride[3] = {1, static_cast<std::ptrdiff_t>(nx), static_cast<std::ptrdiff_t>(nx * ny)};
     const std::ptrdiff_t signed_n = static_cast<std::ptrdiff_t>(n);
-
-    // ROMEO's `parsekwargs` multiplies mag by mask when both are present. We
-    // do the same pre-pass so `maxmag` is computed over the masked region.
-    std::vector<T> masked_mag;
-    const T* mag_in_use = mag;
-    if (mag != nullptr && mask != nullptr) {
-        masked_mag.assign(mag, mag + n);
-        for (std::size_t i = 0; i < n; ++i) {
-            if (!mask[i]) masked_mag[i] = T(0);
-        }
-        mag_in_use = masked_mag.data();
-    }
-
-    // maxmag: `maximum(mag[isfinite.(mag)])` — infinities and NaNs excluded.
-    T maxmag = T(0);
-    bool has_finite_mag = false;
-    if (mag_in_use != nullptr) {
-        for (std::size_t i = 0; i < n; ++i) {
-            T v = mag_in_use[i];
-            if (std::isfinite(v) && (!has_finite_mag || v > maxmag)) {
-                maxmag = v;
-                has_finite_mag = true;
-            }
-        }
-    }
-    (void)maxmag;  // only needed once magweight/magweight2 (flags 5-6) are ported.
-    (void)has_finite_mag;
+    const std::ptrdiff_t sx = 1;
+    const std::ptrdiff_t sy = static_cast<std::ptrdiff_t>(nx);
+    const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(nx * ny);
 
     std::vector<OutT> weights(3 * n, zero_value);
 
-    for (int dim = 0; dim < 3; ++dim) {
-        const std::ptrdiff_t step = stride[dim];
-        for (std::ptrdiff_t idx = 0; idx < signed_n; ++idx) {
-            const std::ptrdiff_t jdx = idx + step;
-            if (jdx >= signed_n) continue;
-            if (mask != nullptr && !mask[idx]) continue;
+    // Mirrors ROMEO's `mag .* mask` pre-pass without materializing a copy: any
+    // masked-out voxel reads as 0 magnitude.
+    auto mag_at = [&](std::ptrdiff_t i) -> T {
+        if (mask != nullptr && !mask[i]) return T(0);
+        return mag[i];
+    };
 
-            T w = T(1);
-            if (flags.phase_coherence) {
-                w *= T(0.1) + T(0.9) * detail::phase_coherence(phase[idx], phase[jdx]);
-            }
-            if (flags.phase_gradient_coherence) {
-                w *= T(0.1) +
-                     T(0.9) * detail::phase_gradient_coherence(phase[idx], phase[jdx], phase2[idx], phase2[jdx],
-                                                                TEs[0], TEs[1]);
-            }
-            if (flags.phase_linearity) {
-                w *= T(0.1) + T(0.9) * detail::phase_linearity(phase, idx, jdx, step, signed_n);
-            }
-            if (mag_in_use != nullptr) {
-                T mi = mag_in_use[idx];
-                T mj = mag_in_use[jdx];
-                T small = std::min(mi, mj);
-                T big = std::max(mi, mj);
-                if (flags.mag_coherence) {
-                    w *= T(0.1) + T(0.9) * detail::mag_coherence(small, big);
-                }
-                // flags 5-6 (magweight, magweight2) not ported — warpkit uses :romeo, not :romeo6.
+    auto edge_weight = [&](std::ptrdiff_t idx, std::ptrdiff_t jdx, std::ptrdiff_t stride) -> T {
+        T w = T(1);
+        if (flags.phase_coherence) {
+            w *= T(0.1) + T(0.9) * detail::phase_coherence(phase[idx], phase[jdx]);
+        }
+        if (flags.phase_gradient_coherence) {
+            w *= T(0.1) + T(0.9) * detail::phase_gradient_coherence(phase[idx], phase[jdx], phase2[idx], phase2[jdx],
+                                                                    TEs[0], TEs[1]);
+        }
+        if (flags.phase_linearity) {
+            w *= T(0.1) + T(0.9) * detail::phase_linearity(phase, idx, jdx, stride, signed_n);
+        }
+        if (mag != nullptr) {
+            T mi = mag_at(idx);
+            T mj = mag_at(jdx);
+            T small = std::min(mi, mj);
+            T big = std::max(mi, mj);
+            if (flags.mag_coherence) {
+                w *= T(0.1) + T(0.9) * detail::mag_coherence(small, big);
             }
-
-            // Column-major (3, nx, ny, nz): index = dim + 3*idx
-            weights[static_cast<std::size_t>(dim) + 3u * static_cast<std::size_t>(idx)] = rescale_fn(w);
+            // flags 5-6 (magweight, magweight2) not ported — warpkit uses :romeo, not :romeo6.
         }
-    }
+        return w;
+    };
 
-    // Zero out the boundary edges that don't actually exist (Julia:
-    //   weights[1,end,:,:] .= 0 / [2,:,end,:] .= 0 / [3,:,:,end] .= 0).
+    // One pass over voxels in (k, j, i) order. Boundary edges are skipped by
+    // construction via the `+1 < n*` guards, so the trailing zero-fill pass
+    // from the Julia source is unnecessary — the value-init of `weights`
+    // already leaves those slots at `zero_value`.
     for (std::size_t k = 0; k < nz; ++k) {
         for (std::size_t j = 0; j < ny; ++j) {
-            std::size_t idx = (nx - 1) + nx * (j + ny * k);
-            weights[0u + 3u * idx] = zero_value;
-        }
-    }
-    for (std::size_t k = 0; k < nz; ++k) {
-        for (std::size_t i = 0; i < nx; ++i) {
-            std::size_t idx = i + nx * ((ny - 1) + ny * k);
-            weights[1u + 3u * idx] = zero_value;
-        }
-    }
-    for (std::size_t j = 0; j < ny; ++j) {
-        for (std::size_t i = 0; i < nx; ++i) {
-            std::size_t idx = i + nx * (j + ny * (nz - 1));
-            weights[2u + 3u * idx] = zero_value;
+            for (std::size_t i = 0; i < nx; ++i) {
+                const std::size_t idx = i + nx * (j + ny * k);
+                if (mask != nullptr && !mask[idx]) continue;
+                const std::ptrdiff_t sidx = static_cast<std::ptrdiff_t>(idx);
+                if (i + 1 < nx) {
+                    weights[0u + 3u * idx] = rescale_fn(edge_weight(sidx, sidx + sx, sx));
+                }
+                if (j + 1 < ny) {
+                    weights[1u + 3u * idx] = rescale_fn(edge_weight(sidx, sidx + sy, sy));
+                }
+                if (k + 1 < nz) {
+                    weights[2u + 3u * idx] = rescale_fn(edge_weight(sidx, sidx + sz, sz));
+                }
+            }
         }
     }
 

{warpkit-1.2.0 → warpkit-1.2.2}/include/warps.h

@@ -19,6 +19,18 @@
 
 namespace py = pybind11;
 
+// PyErr_CheckSignals() needs the GIL; free-threaded builds (Py_GIL_DISABLED)
+// declare `py::mod_gil_not_used()` and skip the check, trading Ctrl+C
+// interruptibility during long ITK operations for no-GIL execution.
+#ifdef Py_GIL_DISABLED
+#define WARPKIT_CHECK_SIGNALS() ((void)0)
+#else
+#define WARPKIT_CHECK_SIGNALS()                                  \
+    do {                                                         \
+        if (PyErr_CheckSignals() != 0) throw py::error_already_set(); \
+    } while (0)
+#endif
+
 /**
  * @brief Invert a displacement map
  *
@@ -139,9 +151,9 @@ py::array_t<T, py::array::f_style> invert_displacement_map(py::array_t<T, py::ar
 
     // Get output
     typename DisplacementMapType::Pointer inv_map = identity_filter->GetOutput();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     inv_map->Update();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     itk::ImageRegionConstIteratorWithIndex<DisplacementMapType> inv_map_it(inv_map,
                                                                            inv_map->GetLargestPossibleRegion());
     py::array_t<T, py::array::f_style> inverted_displacement_map(displacement_map);
@@ -170,7 +182,7 @@ py::array_t<T, py::array::f_style> invert_displacement_field(py::array_t<T, py::
                                                              py::array_t<T, py::array::f_style> direction,
                                                              py::array_t<T, py::array::f_style> spacing,
                                                              ssize_t iterations, bool verbose) {
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
 
     // Get the displacement field shape
     const ssize_t* shape = displacement_field.shape();
@@ -227,9 +239,9 @@ py::array_t<T, py::array::f_style> invert_displacement_field(py::array_t<T, py::
 
     // Get output
     typename DisplacementFieldType::Pointer inv_field = invert_displacement_filter->GetOutput();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     inv_field->Update();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     itk::ImageRegionConstIteratorWithIndex<DisplacementFieldType> inv_field_it(inv_field,
                                                                                inv_field->GetLargestPossibleRegion());
     py::array_t<T, py::array::f_style> inverted_displacement_field(displacement_field);
@@ -261,7 +273,7 @@ py::array_t<T, py::array::f_style> compute_jacobian_determinant(py::array_t<T, p
                                                                 py::array_t<T, py::array::f_style> origin,
                                                                 py::array_t<T, py::array::f_style> direction,
                                                                 py::array_t<T, py::array::f_style> spacing) {
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
 
     // Get the displacement field shape
     const ssize_t* shape = displacement_field.shape();
@@ -315,9 +327,9 @@ py::array_t<T, py::array::f_style> compute_jacobian_determinant(py::array_t<T, p
     // Get the jacobian determinant fields
     typename DisplacementFieldJacobianDeterminantFilterType::OutputImagePointer jacobian_determinant =
         jacobian_filter->GetOutput();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     jacobian_determinant->Update();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
 
     // Convert to numpy array
     py::array_t<T, py::array::f_style> jacobian_determinant_array({shape[0], shape[1], shape[2]});
@@ -461,9 +473,9 @@ py::array_t<T, py::array::f_style> resample(
 
     // Get the output
     typename OutputImageType::Pointer output_image = warp_filter->GetOutput();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     output_image->Update();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
     itk::ImageRegionConstIteratorWithIndex<OutputImageType> output_iterator(output_image,
                                                                             output_image->GetLargestPossibleRegion());
     py::array_t<T, py::array::f_style> output_array({output_shape.at(0), output_shape.at(1), output_shape.at(2)});
@@ -481,7 +493,7 @@ T compute_hausdorff_distance(
     py::array_t<T, py::array::f_style> image1_direction, py::array_t<T, py::array::f_style> image1_spacing,
     py::array_t<T, py::array::f_style> image2, py::array_t<T, py::array::f_style> image2_origin,
     py::array_t<T, py::array::f_style> image2_direction, py::array_t<T, py::array::f_style> image2_spacing) {
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
 
     // Setup types
     using ImageType = typename itk::Image<T, 3>;
@@ -545,7 +557,7 @@ T compute_hausdorff_distance(
     // Get the hausdorff distance
     hausdorff_filter->Update();
     T hausdorff_distance = hausdorff_filter->GetAverageHausdorffDistance();
-    if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+    WARPKIT_CHECK_SIGNALS();
 
     // Return the hausdorff distance
     return hausdorff_distance;

{warpkit-1.2.0 → warpkit-1.2.2}/packaging/pyinstaller/build_bundle.py

@@ -102,6 +102,20 @@ def write_readme(bundle: Path, version: str, target: str) -> None:
     (bundle / "README.md").write_text(body, encoding="utf-8")
 
 
+def write_licenses(bundle: Path) -> None:
+    # Bundle warpkit's own LICENSE plus the upstream ROMEO MIT notice. The
+    # ROMEO notice is required: the wk-* binaries link in compiled code derived
+    # from include/romeo/, which the MIT terms require we ship the notice with.
+    repo_root = Path(__file__).resolve().parents[2]
+    licenses_dir = bundle / "LICENSES"
+    licenses_dir.mkdir(exist_ok=True)
+    shutil.copy2(repo_root / "LICENSE", licenses_dir / "warpkit.LICENSE")
+    shutil.copy2(
+        repo_root / "include" / "romeo" / "LICENSE",
+        licenses_dir / "ROMEO.LICENSE",
+    )
+
+
 def make_zip(bundle: Path, out_zip: Path) -> None:
     # shutil.make_archive's base_dir keeps a tidy top-level folder inside the zip.
     base_name = str(out_zip.with_suffix(""))
@@ -144,6 +158,7 @@ def main() -> int:
 
     adhoc_sign_macos(versioned)
     write_readme(versioned, version, target)
+    write_licenses(versioned)
 
     out_zip = dist / f"warpkit-{version}-{target}.zip"
     make_zip(versioned, out_zip)

{warpkit-1.2.0 → warpkit-1.2.2}/packaging/pyinstaller/bundle_README.md

@@ -47,3 +47,9 @@ xattr -r -d com.apple.quarantine /opt/warpkit-@VERSION@
 - `wk-compute-jacobian` — compute the Jacobian determinant of a warp
 
 Run any of them with `--help` for usage.
+
+## Licenses
+
+`LICENSES/warpkit.LICENSE` is the warpkit license. `LICENSES/ROMEO.LICENSE` is
+the upstream MIT notice for the ROMEO phase-unwrapping algorithms compiled
+into these binaries.

{warpkit-1.2.0 → warpkit-1.2.2}/pyproject.toml

@@ -6,7 +6,11 @@ requires-python = ">=3.11"
 authors = [{ name = "Andrew Van", email = "vanandrew77@gmail.com" }]
 keywords = ["neuroimaging"]
 classifiers = ["Programming Language :: Python :: 3"]
-urls = { github = "https://github.com/vanandrew/warpkit" }
+urls = { github = "https://github.com/vanandrew/warpkit", paper = "https://doi.org/10.1162/IMAG.a.1262" }
+# include/romeo/LICENSE is the upstream MIT notice for the ROMEO C++ port; it
+# travels with the headers in source distributions and (via PEP 639
+# license-files) gets bundled into wheels under *.dist-info/licenses/.
+license-files = ["LICENSE", "include/romeo/LICENSE"]
 dynamic = ["version"]
 dependencies = [
   "nibabel >= 4.0.2",
@@ -118,9 +122,10 @@ command_line = "-m pytest"
 omit = ["tests/*"]
 
 [tool.cibuildwheel]
-# Skip musllinux (we ship manylinux only) and free-threaded CPython builds
-# (cp31Xt-*) — our pybind11 bindings + ITK haven't been audited for the no-GIL ABI.
-skip = "*musllinux* cp314t-*"
+# Skip musllinux (we ship manylinux only). Free-threaded (cp31Xt-*) builds
+# are kept: warps.h guards PyErr_CheckSignals() behind WARPKIT_CHECK_SIGNALS,
+# which is a no-op under Py_GIL_DISABLED.
+skip = "*musllinux*"
 build-frontend = "build"
 build-verbosity = 3
 

{warpkit-1.2.0 → warpkit-1.2.2}/src/warpkit.cpp

@@ -5,7 +5,7 @@
 
 namespace py = pybind11;
 
-PYBIND11_MODULE(warpkit_cpp, m) {
+PYBIND11_MODULE(warpkit_cpp, m, py::mod_gil_not_used()) {
     m.def("calculate_weights", &romeo::calculate_weights<float>,
           "ROMEO edge-weight map (3, nx, ny, nz) uint8. Exposed for port validation; not used by warpkit.",
           py::arg("phase"),

{warpkit-1.2.0 → warpkit-1.2.2}/tests/test_scripts.py

@@ -600,6 +600,91 @@ def test_unwrap_phase_noiseframes_consumes_all_frames(argv, capsys, tmp_path):
     assert "0 frames" in err
 
 
+def test_unwrap_phase_metadata_accepts_echotime_only(argv, capsys, tmp_path):
+    """``wk-unwrap-phase`` only needs EchoTime; sidecars without
+    TotalReadoutTime / PhaseEncodingDirection must work. A mismatched phase
+    count forces a clean parser.error *after* the metadata loader resolves —
+    if the loader still required TRT/PED we'd see a KeyError instead."""
+    sidecar = tmp_path / "m1.json"
+    sidecar.write_text(json.dumps({"EchoTime": 0.014}))
+    argv(
+        [
+            "wk-unwrap-phase",
+            "--magnitude",
+            "m.nii",
+            "--phase",
+            "p1.nii",
+            "p2.nii",
+            "--metadata",
+            str(sidecar),
+            "--out-prefix",
+            str(tmp_path / "out"),
+        ]
+    )
+    with pytest.raises(SystemExit) as exc:
+        unwrap_phase_main()
+    assert exc.value.code == 2
+    err = capsys.readouterr().err
+    assert "must match" in err
+
+
+def test_unwrap_phase_metadata_missing_echotime(argv, capsys, tmp_path):
+    """A sidecar without EchoTime must surface as a clean parser error, not a
+    KeyError from the metadata loader."""
+    sidecar = tmp_path / "m1.json"
+    sidecar.write_text(json.dumps({}))
+    argv(
+        [
+            "wk-unwrap-phase",
+            "--magnitude",
+            "m.nii",
+            "--phase",
+            "p.nii",
+            "--metadata",
+            str(sidecar),
+            "--out-prefix",
+            str(tmp_path / "out"),
+        ]
+    )
+    with pytest.raises(SystemExit) as exc:
+        unwrap_phase_main()
+    assert exc.value.code == 2
+    err = capsys.readouterr().err
+    assert "EchoTime" in err
+
+
+def test_medic_noiseframes_consumes_all_frames(argv, capsys, tmp_path):
+    """``-f`` >= n_frames now raises a clean parser error in medic too: the
+    check moved into ``trim_noise_frames`` so every caller is protected from
+    silently producing an empty 4D series."""
+    mag = _write_nifti(tmp_path / "m.nii", (4, 4, 4, 5))
+    phase = _write_nifti(tmp_path / "p.nii", (4, 4, 4, 5))
+    argv(
+        [
+            "wk-medic",
+            "--magnitude",
+            mag,
+            "--phase",
+            phase,
+            "--TEs",
+            "14.0",
+            "--total-readout-time",
+            "0.05",
+            "--phase-encoding-direction",
+            "j",
+            "--out-prefix",
+            str(tmp_path / "out"),
+            "-f",
+            "5",
+        ]
+    )
+    with pytest.raises(SystemExit) as exc:
+        medic_main()
+    assert exc.value.code == 2
+    err = capsys.readouterr().err
+    assert "0 frames" in err
+
+
 # ---------------------------------------------------------------------------
 # compute_fieldmap --help / argument validation
 # ---------------------------------------------------------------------------
@@ -1693,14 +1778,12 @@ def test_bundle_frames_to_3d_series_clears_vector_intent():
 
 def test_write_output_per_frame_map_clears_vector_intent(tmp_path):
     """Per-frame map outputs must round-trip without a stale vector intent."""
-    import argparse
-
     from warpkit.scripts._warp_io import write_output
 
     frames = [_vector_intent_frame() for _ in range(2)]
     out_paths = [str(tmp_path / "f1.nii"), str(tmp_path / "f2.nii")]
 
-    write_output(frames, out_paths, "map", argparse.ArgumentParser())
+    write_output(frames, out_paths, "map")
 
     for p in out_paths:
         loaded = _load(p)