larmor-dmri 1.0.0__tar.gz

larmor_dmri-1.0.0/.gitattributes

@@ -0,0 +1,17 @@
+# Text files are stored with LF and checked out with LF on every platform.
+* text=auto eol=lf
+
+# Binary data and images are never converted.
+*.nii binary
+*.nii.gz binary
+*.mif binary
+*.mif.gz binary
+*.mat binary
+*.npz binary
+*.npy binary
+*.tck binary
+*.trk binary
+*.tsf binary
+*.png binary
+*.webp binary
+*.gii binary

larmor_dmri-1.0.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Something in Larmor gives a wrong result, crashes, or behaves differently from its documentation
+title: ""
+labels: ["type:bug"]
+---
+
+<!--
+Describe the bug in full sentences, so someone who was not there can understand and reproduce it.
+The text inside these arrows is a hint and does not appear in the ticket.
+-->
+
+## What happens
+
+<!-- What you did and what Larmor did: the command or code you ran, and the output or error message (copied, not
+retyped). -->
+
+## What should happen
+
+<!-- What you expected instead, and why: for example what the documentation says, or what MRtrix3 or nibabel give
+for the same input. -->
+
+## How to reproduce
+
+<!-- The smallest set of steps or code that shows the problem. Say which data you used; if it is not shared, say
+what kind of data it is (format, size, number of volumes). -->
+
+1.
+2.
+3.
+
+## Environment
+
+<!-- The Larmor version is printed by `python -c "import larmor; print(larmor.__version__)"`. -->
+
+- Larmor version:
+- Python version:
+- Operating system:

larmor_dmri-1.0.0/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,2 @@
+# Allow an empty issue for anything that fits neither template.
+blank_issues_enabled: true

larmor_dmri-1.0.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,30 @@
+---
+name: Feature or task
+about: A new capability, an improvement, or a piece of work to plan
+title: ""
+labels: ["type:feature"]
+---
+
+<!--
+A ticket says what the work should achieve and why, not how to write the code. Write in full sentences.
+The text inside these arrows is a hint and does not appear in the ticket.
+If this is not a new feature (for example a refactor or documentation), change the type label after creating it.
+-->
+
+## Context
+
+<!-- The situation today and why it matters: what is missing or not working well, and who is affected. Link the
+relevant page of the documentation if there is one. -->
+
+## Goal
+
+<!-- What should be true when the work is done, described from the user's or the code's point of view. -->
+
+## Finished when
+
+<!-- Concrete checks that tell anyone whether the ticket is done. -->
+
+-
+-
+
+<!-- If this ticket depends on other tickets, say so here, for example "This ticket depends on #12." -->

larmor_dmri-1.0.0/.github/pull_request_template.md

@@ -0,0 +1,36 @@
+<!--
+See docs/contributing.md, "Pull requests". The title says what this pull request does, as a command
+(for example "Add the bug report template"), not the branch name.
+The text inside these arrows is a hint and does not appear in the pull request.
+-->
+
+## What
+
+<!-- What changed, so the reviewer knows what to expect before reading the code. -->
+
+## Why
+
+<!-- The reason for the change. A year from now, this is what explains why the code looks the way it does. -->
+
+## How I tested
+
+<!-- The proof that the change works: the tests added, and any check run by hand with its result.
+A speed-up shows the measured timings and that the results did not change. A viewer change includes a
+screenshot. -->
+
+## Before asking for a review
+
+<!-- Tick what applies; delete lines that do not apply to this change. -->
+
+- [ ] The checks pass locally (`uv run pytest`, `uv run ruff format .`, `uv run ruff check .`,
+  `uv run mypy`).
+- [ ] New or changed public functions and classes have docstrings with units, conventions and array shapes.
+- [ ] A method taken from another toolbox or paper (MRtrix3, dipy, MRIToolkit, ...) cites its original papers
+  and names the toolbox it follows, in its docstring and in the documentation.
+- [ ] A new user-facing feature has an example in `examples/`.
+- [ ] I read my own changes in the "Files changed" tab.
+
+<!-- Replace the number with the ticket this pull request finishes. "Closes" must stay in this description,
+not the title, so that merging closes the ticket. -->
+
+Closes #

larmor_dmri-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,218 @@
+# Runs the project's checks on every pull request and on every push to main, unless the change only touches
+# Markdown files. The same commands can be run locally; see docs/contributing.md, step 6.
+name: CI
+
+# The paths are read in order and a later pattern overrides an earlier one: every file counts, then Markdown files
+# are taken out, then the Markdown of the website in docs/ is put back, because a test builds the website from it
+# and another compares docs/cli.md with the CLI; the pages the website leaves out (exclude_patterns in
+# docs/conf.py) are taken out again. CI runs when any changed file is still in the list.
+on:
+  pull_request:
+    paths:
+      - "**"
+      - "!**/*.md"
+      - "docs/**/*.md"
+      - "!docs/README.md"
+      - "!docs/contributing.md"
+      - "!docs/releasing.md"
+      - "!docs/style.md"
+  push:
+    branches: [main]
+    paths:
+      - "**"
+      - "!**/*.md"
+      - "docs/**/*.md"
+      - "!docs/README.md"
+      - "!docs/contributing.md"
+      - "!docs/releasing.md"
+      - "!docs/style.md"
+  workflow_dispatch: # allows a manual run from the Actions tab, whatever changed
+
+permissions:
+  contents: read
+
+# A new push to a pull request cancels the run still going for the previous push.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Formatting, linting and type checking do not depend on the operating system, so they
+  # run once, on Linux (macOS and Windows minutes cost more on GitHub's plans). They need
+  # the tools but not the compiled module, which builds on macOS only for now: mypy reads
+  # its types from _core.pyi, and import-linter reads the package from src/.
+  checks:
+    name: ruff, mypy and import-linter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+          enable-cache: true
+      # The development tools without Larmor itself; --no-sync keeps uv run from installing it.
+      - name: Install the development tools
+        run: uv sync --locked --no-install-project
+      # Each check runs even if an earlier one failed, so a pull request shows every
+      # problem at once.
+      - name: ruff format
+        if: success() || failure()
+        run: uv run --no-sync ruff format --check .
+      - name: ruff check
+        if: success() || failure()
+        run: uv run --no-sync ruff check --output-format github .
+      - name: mypy
+        if: success() || failure()
+        run: uv run --no-sync mypy
+      - name: import-linter
+        if: success() || failure()
+        env:
+          PYTHONPATH: src
+        run: uv run --no-sync lint-imports
+
+  # The C++ backend's own checks on each operating system: a build in which every compiler warning
+  # is an error, and its unit tests; on Linux also the format and lint checks, which do not depend
+  # on the platform. The tools come from the uv environment. macOS links Accelerate for Eigen's
+  # matrix products; Linux (GCC) and Windows (MSVC) use Eigen's own. sccache keeps the compiled
+  # objects between runs, and link-time optimisation is off: these builds run once.
+  cpp:
+    name: C++ build and ctest (${{ matrix.name }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: Linux, os: ubuntu-latest, lint: true }
+          - { name: macOS, os: macos-latest, lint: false }
+          - { name: Windows, os: windows-latest, lint: false }
+    defaults:
+      run:
+        shell: bash
+        working-directory: cpp
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+    steps:
+      # Checked out as committed: Windows would otherwise turn line endings into CRLF.
+      - name: Keep line endings as committed
+        if: runner.os == 'Windows'
+        working-directory: .
+        run: git config --global core.autocrlf false
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+          enable-cache: true
+      - uses: mozilla-actions/sccache-action@v0.0.11
+      # Ninja needs the environment of the Visual Studio command prompt to find MSVC.
+      - uses: ilammy/msvc-dev-cmd@v1.13.0
+        if: runner.os == 'Windows'
+      - name: Use MSVC
+        if: runner.os == 'Windows'
+        working-directory: .
+        run: echo "CXX=cl" >> "$GITHUB_ENV"
+      # The development tools only: the dev preset builds the module itself, and --no-sync keeps
+      # uv run from installing Larmor.
+      - name: Install the development tools
+        run: uv sync --locked --no-install-project
+      - name: Configure
+        run: >-
+          uv run --no-sync cmake --preset dev -DLARMOR_WARNINGS_AS_ERRORS=ON -DLARMOR_LTO=OFF
+          -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+      - name: Build
+        run: uv run --no-sync cmake --build --preset dev
+      - name: ctest
+        run: uv run --no-sync ctest --preset dev
+      # Each check runs even if an earlier one failed, so a pull request shows every problem at once.
+      - name: clang-format
+        if: matrix.lint && (success() || failure())
+        run: find src tests -name '*.cpp' -o -name '*.hpp' | xargs uv run --no-sync clang-format --dry-run --Werror
+      # clang-tidy reads the compile commands of the build above, so it sees the same flags.
+      - name: clang-tidy
+        if: matrix.lint && (success() || failure())
+        run: uv run --no-sync run-clang-tidy.py -p build/dev -quiet 'cpp/(src|tests)/'
+
+  # The unit tests again, built by AppleClang with AddressSanitizer and UndefinedBehaviorSanitizer:
+  # an out-of-bounds read, a use after free, an overflow or a float converted to an integer it does
+  # not fit in stops the run.
+  cpp-sanitizers:
+    name: C++ tests under ASan and UBSan
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: cpp
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+          enable-cache: true
+      # The development tools only: the unit tests need neither the module nor Larmor installed,
+      # and --no-sync keeps uv run from installing them.
+      - name: Install the development tools
+        run: uv sync --locked --no-install-project
+      - name: Configure
+        run: uv run --no-sync cmake --preset sanitize
+      - name: Build
+        run: uv run --no-sync cmake --build --preset sanitize
+      - name: ctest
+        run: uv run --no-sync ctest --preset sanitize
+
+  # The whole test suite on macOS; on Linux and Windows, which have no GPU, all of it but the tests
+  # that build the viewer's Qt widgets (marked qt_widgets, see tests/conftest.py) and the gallery
+  # examples on a brain: with a software renderer each window takes seconds. Windows, the slowest
+  # runner, also leaves out tests/test_docs.py, which builds the website and runs the gallery and
+  # the task pages: none of it depends on the platform. The viewer's other
+  # tests draw there with Mesa's software Vulkan driver (lavapipe) on Linux and the software
+  # adapter of DirectX 12 (WARP) on Windows; Qt runs with its offscreen platform. A test that runs
+  # longer than two minutes fails, naming itself.
+  tests:
+    name: tests (${{ matrix.name }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 20
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: Linux, os: ubuntu-latest, select: "not qt_widgets", ignore: "" }
+          - { name: macOS, os: macos-latest, select: "", ignore: "" }
+          - { name: Windows, os: windows-latest, select: "not qt_widgets", ignore: "--ignore=tests/test_docs.py" }
+    defaults:
+      run:
+        shell: bash
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      # Read by CMake when the project is installed: compile through sccache, with Ninja, without
+      # link-time optimisation.
+      CMAKE_CXX_COMPILER_LAUNCHER: sccache
+      CMAKE_GENERATOR: Ninja
+      CMAKE_ARGS: -DLARMOR_LTO=OFF -DCMAKE_CXX_COMPILER_LAUNCHER=sccache
+    steps:
+      # Checked out as committed: Windows would otherwise turn line endings into CRLF.
+      - name: Keep line endings as committed
+        if: runner.os == 'Windows'
+        run: git config --global core.autocrlf false
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+          enable-cache: true
+      - uses: mozilla-actions/sccache-action@v0.0.11
+      # Ninja needs the environment of the Visual Studio command prompt to find MSVC.
+      - uses: ilammy/msvc-dev-cmd@v1.13.0
+        if: runner.os == 'Windows'
+      - name: Use MSVC
+        if: runner.os == 'Windows'
+        run: echo "CXX=cl" >> "$GITHUB_ENV"
+      # The libraries Qt's offscreen platform loads, and the software Vulkan driver.
+      - name: Install Qt's libraries and lavapipe
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            mesa-vulkan-drivers libegl1 libgl1 libxkbcommon0 libfontconfig1 libdbus-1-3
+      # Installing the project builds the C++ module (scikit-build-core, CMake).
+      - name: Install the project and its development tools
+        run: uv sync --locked
+      - name: pytest
+        run: uv run pytest -n auto -rfE --timeout 120 -m "${{ matrix.select }}" ${{ matrix.ignore }}

larmor_dmri-1.0.0/.github/workflows/docs.yml

@@ -0,0 +1,153 @@
+# Builds the documentation website. A pull request only builds it, so a broken build fails the check; a push to
+# main publishes it as the "dev" version and a version tag (v*) publishes it as the stable version, both to the
+# gh-pages branch, which GitHub Pages serves at https://larmor.org. See docs/releasing.md, section Website.
+name: Docs
+
+on:
+  pull_request:
+    paths:
+      - "docs/**"
+      - "examples/**"
+      - "src/**"
+      - ".github/workflows/docs.yml"
+  push:
+    branches: [main]
+    tags: ["v*"]
+  workflow_dispatch: # builds the site, without publishing it
+
+permissions:
+  contents: read
+
+# Publishes queue one after the other and are never cancelled half way; a new push to a pull request cancels the
+# build still going for the previous push.
+concurrency:
+  group: docs-${{ github.event_name == 'pull_request' && github.ref || 'publish' }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build:
+    name: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    env:
+      CMAKE_GENERATOR: Ninja
+      CMAKE_ARGS: -DLARMOR_LTO=OFF
+      # The name the version switcher marks as the current one: the version on a tag, dev otherwise.
+      LARMOR_DOCS_VERSION: ${{ startsWith(github.ref, 'refs/tags/v') && github.ref_name || 'dev' }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+          enable-cache: true
+      # The libraries Qt's offscreen platform loads, and the software Vulkan driver.
+      - name: Install Qt's libraries and lavapipe
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends \
+            mesa-vulkan-drivers libegl1 libgl1 libxkbcommon0 libfontconfig1 libdbus-1-3
+      # Installing the project builds the C++ module (scikit-build-core, CMake).
+      - name: Install the project and the documentation tools
+        run: uv sync --locked
+      # The example datasets the gallery downloads, kept between runs; the key, and so
+      # a new download, changes only when the table of files and checksums does.
+      - name: Restore the example datasets
+        uses: actions/cache@v6.1.0
+        with:
+          path: ${{ runner.temp }}/larmor-data
+          key: larmor-data-${{ hashFiles('src/larmor/data/files.py') }}
+      - name: Use the example datasets
+        run: echo "LARMOR_DATA_DIR=${{ runner.temp }}/larmor-data" >> "$GITHUB_ENV"
+      # The gallery runs its examples; -W makes any warning an error.
+      - name: Build the website
+        run: uv run sphinx-build -b dirhtml -W docs "${{ runner.temp }}/site"
+        env:
+          QT_QPA_PLATFORM: offscreen
+      - uses: actions/upload-artifact@v7.0.2
+        if: github.event_name != 'pull_request'
+        with:
+          name: site
+          path: ${{ runner.temp }}/site
+          if-no-files-found: error
+
+  publish:
+    name: publish
+    needs: build
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: write
+    env:
+      IS_TAG: ${{ startsWith(github.ref, 'refs/tags/v') }}
+    steps:
+      - uses: actions/download-artifact@v8.0.2
+        with:
+          name: site
+          path: site
+      # The site root has the CNAME file that keeps the custom domain, .nojekyll so that GitHub Pages serves
+      # folders starting with an underscore (_static), and versions.json for the version switcher: the
+      # published list with dev always there and the stable version replaced when a tag is published. Before the
+      # first tag the root also gets an index.html that redirects to /dev/; the stable site replaces it.
+      - name: Write the files of the site root
+        run: |
+          mkdir root
+          echo larmor.org > root/CNAME
+          touch root/.nojekyll
+          curl -fsS "https://raw.githubusercontent.com/${GITHUB_REPOSITORY}/gh-pages/versions.json" -o old.json || echo '[]' > old.json
+          python3 - <<'PY'
+          import json, os
+
+          old = json.load(open("old.json"))
+          versions = [{"name": "dev", "version": "dev", "url": "https://larmor.org/dev/"}]
+          if os.environ["IS_TAG"] == "true":
+              number = os.environ["GITHUB_REF_NAME"].removeprefix("v")
+              versions.append(
+                  {
+                      "name": f"{number} (stable)",
+                      "version": number,
+                      "url": "https://larmor.org/",
+                      "preferred": True,
+                  }
+              )
+          else:
+              stable = [entry for entry in old if entry.get("preferred")]
+              versions += stable
+              # Until the first release there is no stable site: the root sends visitors to dev.
+              if not stable:
+                  open("root/index.html", "w").write(
+                      "<!doctype html>\n"
+                      '<html lang="en">\n<head>\n<meta charset="utf-8">\n'
+                      "<title>Larmor</title>\n"
+                      '<link rel="canonical" href="https://larmor.org/dev/">\n'
+                      '<meta http-equiv="refresh" content="0; url=/dev/">\n'
+                      "</head>\n<body>\n"
+                      '<p><a href="/dev/">Larmor documentation</a></p>\n'
+                      "</body>\n</html>\n"
+                  )
+          json.dump(versions, open("root/versions.json", "w"), indent=2)
+          PY
+          cat root/versions.json
+      - name: Publish the dev version
+        if: env.IS_TAG != 'true'
+        uses: peaceiris/actions-gh-pages@v4.1.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: site
+          destination_dir: dev
+          keep_files: true
+      # The stable version is the site root; dev/ stays because the files already there are kept.
+      - name: Publish the stable version
+        if: env.IS_TAG == 'true'
+        uses: peaceiris/actions-gh-pages@v4.1.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: site
+          keep_files: true
+      - name: Publish the site root files
+        uses: peaceiris/actions-gh-pages@v4.1.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: root
+          keep_files: true
+          enable_jekyll: false

larmor_dmri-1.0.0/.github/workflows/wheels.yml

@@ -0,0 +1,102 @@
+# Builds the wheels users install, one per platform, with cibuildwheel, and checks each one in a fresh
+# environment: installed there, it passes the tests listed under [tool.cibuildwheel] in pyproject.toml.
+# Also builds the source distribution, which carries Eigen and pocketfft, and checks that it installs
+# with only a C++ compiler, downloading no C++ library. On a version tag, once every wheel and the
+# source distribution pass, publishes them to PyPI through trusted publishing: no token is stored.
+name: Wheels
+
+on:
+  pull_request:
+    paths:
+      - "pyproject.toml"
+      - "cpp/CMakeLists.txt"
+      - "cpp/CMakePresets.json"
+      - "cpp/cmake/**"
+      - "cpp/src/**/CMakeLists.txt"
+      - ".github/workflows/wheels.yml"
+  push:
+    tags: ["v*"]
+  workflow_dispatch: # allows a manual run from the Actions tab
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  wheel:
+    name: wheel (${{ matrix.name }})
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: linux-x86_64, runner: ubuntu-latest }
+          - { name: linux-aarch64, runner: ubuntu-24.04-arm }
+          - { name: macos-arm64, runner: macos-latest }
+          - { name: macos-x86_64, runner: macos-15-intel }
+          - { name: windows-x86_64, runner: windows-latest }
+    steps:
+      # Checked out as committed: Windows would otherwise turn line endings into CRLF.
+      - name: Keep line endings as committed
+        if: runner.os == 'Windows'
+        run: git config --global core.autocrlf false
+      - uses: actions/checkout@v7
+      # On Linux the wheel is built and tested inside a manylinux container, so it runs on any
+      # distribution with a recent enough glibc; elsewhere it is built on the runner itself.
+      - uses: pypa/cibuildwheel@v4.3.1
+        with:
+          output-dir: wheelhouse
+      - uses: actions/upload-artifact@v7.0.2
+        with:
+          name: wheel-${{ matrix.name }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    name: source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0  # setup-uv publishes exact versions only
+        with:
+          python-version: "3.14"
+      - name: Put Eigen and pocketfft into cpp/third_party
+        run: cmake -P cpp/cmake/vendor.cmake
+      # --no-config: the build in an isolated environment, as pip builds it, not in the uv
+      # environment as [tool.uv] in pyproject.toml asks for development.
+      - name: Build the source distribution
+        run: uv build --no-config --sdist --out-dir dist
+      # FETCHCONTENT_FULLY_DISCONNECTED stops CMake from downloading anything, so the build passes
+      # only with the C++ libraries the source distribution carries. The Python build tools still
+      # come from PyPI, as for any source build.
+      - name: Install from the source distribution in a fresh environment
+        run: |
+          uv venv --no-config --python 3.14 sdist-env
+          uv pip install --no-config --python sdist-env dist/*.tar.gz pytest pytest-xdist nibabel \
+            -C cmake.define.FETCHCONTENT_FULLY_DISCONNECTED=ON
+      - name: Test the installed package
+        run: sdist-env/bin/python -m pytest -p no:cacheprovider tests/test_core.py tests/dwi
+      - uses: actions/upload-artifact@v7.0.2
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [wheel, sdist]
+    runs-on: ubuntu-latest
+    # The PyPI project trusts this repository, this workflow and this environment only.
+    environment:
+      name: pypi
+      url: https://pypi.org/project/larmor-dmri/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8.0.2
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@v1.14.2

larmor_dmri-1.0.0/.gitignore

@@ -0,0 +1,67 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.env
+build/
+dist/
+
+# Tool caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.import_linter_cache/
+.coverage
+htmlcov/
+
+# The C++ build folder
+cpp/build/
+
+# The documentation website and the gallery it generates
+docs/_build/
+docs/gallery/
+docs/gen_modules/
+docs/sg_execution_times.rst
+examples/**/*.png
+examples/**/*.webp
+
+# Imaging data and tractograms: only the small files in tests/data are committed
+*.nii
+*.nii.gz
+*.mif
+*.mif.gz
+*.mih
+*.tck
+*.trk
+*.trk.gz
+*.tsf
+*.vtk
+*.vtp
+*.gii
+*.mgh
+*.mgz
+*.dcm
+!tests/data/**
+
+# MATLAB
+*.asv
+
+# Profiles
+*.prof
+*.lprof
+
+# Editors and operating systems
+.idea/
+.vscode/
+.claude/
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# The compiled C++ module, built in place
+*.so
+*.pyd
+
+# Eigen and pocketfft for the source distribution (cpp/cmake/vendor.cmake)
+cpp/third_party/