aind-registration-utils 0.0.1__py3-none-any.whl

aind_registration_utils/__init__.py

@@ -0,0 +1,2 @@
+"""Init package"""
+__version__ = "0.0.1"

aind_registration_utils/ants.py

@@ -0,0 +1,271 @@
+import ants
+import numpy as np
+
+# import SimpleITK as sitk
+import pandas as pd
+
+
+def apply_ants_transforms_to_point_dict(pts_dict, transformlist, **kwargs):
+    """
+    Apply ANTs spatial transforms to a dictionary of points.
+
+    This function takes a dictionary of labeled points, applies a series of
+    spatial transformations provided in `transformlist` using ANTs, and returns
+    the transformed points in a new dictionary with the same labels.
+
+    Parameters
+    ----------
+    pts_dict : dict
+        Dictionary where the keys are point labels and the values are 3D points
+        as (x, y, z) sequences. Example: {'pt1': [10, 20, 30], 'pt2': [40, 50,
+        60]}
+    transformlist : list
+        List of spatial transformation filenames to apply to the points. The
+        transformations are applied in the order they are provided.
+    **kwargs :
+        Additional keyword arguments passed to
+        `ants.apply_transforms_to_points`.
+
+    Returns
+    -------
+    dict
+        A dictionary containing the transformed points, maintaining the
+        original labels.
+
+    Examples
+    --------
+    >>> points = {'pt1': [10, 20, 30], 'pt2': [40, 50, 60]}
+    >>> transforms = ['path/to/transform1.nii.gz', 'path/to/transform2.nii.gz']
+    >>> transformed_points = apply_ants_transforms_to_point_dict(points,
+    ... transforms)
+    """
+    pt_arr = np.vstack(list(pts_dict.values()))
+    pt_df = pd.DataFrame(
+        {
+            "x": pt_arr[:, 0],
+            "y": pt_arr[:, 1],
+            "z": pt_arr[:, 2],
+        }
+    )
+    tx_pt_df = ants.apply_transforms_to_points(
+        3, pt_df, transformlist, **kwargs
+    )
+    tx_pts_dict = {
+        k: tx_pt_df.iloc[i, :].values for i, k in enumerate(pts_dict.keys())
+    }
+    return tx_pts_dict
+
+
+def ants_register_syn(
+    fixed_img,
+    moving_img,
+    rigid_kwargs=dict(),
+    affine_kwargs=dict(),
+    syn_kwargs=dict(
+        aff_metric="CC",
+        syn_metric="CC",
+        syn_sampling=2,
+        reg_iterations=(500, 200, 10),
+    ),
+    syn_save_prefix="",
+):
+    """
+    Perform SyN registration using ANTs with a two-stage initialization (rigid
+    followed by affine).
+
+    This function performs registration of the moving image to the fixed image
+    using the Symmetric Normalization (SyN) method implemented in ANTs
+    (Advanced Normalization Tools).  Before the SyN registration, it employs a
+    two-stage initialization approach: first, it computes a rigid
+    transformation, followed by an affine transformation. The final SyN
+    registration is initialized with the affine transformation.
+
+    Parameters
+    ----------
+    fixed_img : ants.ANTsImage
+        Target image for the registration.
+    moving_img : ants.ANTsImage
+        Source image that will be aligned to the `fixed_img`.
+    syn_save_prefix : str, optional
+        Prefix for the output files of the SyN registration. If not specified,
+        no prefix is added.
+
+    Returns
+    -------
+    dict
+        A dictionary containing the results of the SyN registration, including
+        forward and inverse transformations, warp fields, and other
+        registration details.
+
+    Examples
+    --------
+    >>> fixed = ants.image_read('path/to/fixed_image.nii.gz')
+    >>> moving = ants.image_read('path/to/moving_image.nii.gz')
+    >>> syn_results = ants_register_syn_cc(fixed, moving, 'output_prefix_')
+    """
+
+    tx_rigid = ants.registration(
+        fixed=fixed_img,
+        moving=moving_img,
+        type_of_transform="Rigid",
+        **rigid_kwargs,
+    )
+    tx_affine = ants.registration(
+        fixed=fixed_img,
+        moving=moving_img,
+        initial_transform=tx_rigid["fwdtransforms"][0],
+        type_of_transform="Affine",
+        **affine_kwargs,
+    )
+    tx_syn = ants.registration(
+        fixed=fixed_img,
+        moving=moving_img,
+        initial_transform=tx_affine["fwdtransforms"][0],
+        outprefix=str(syn_save_prefix),
+        type_of_transform="SyN",
+        **syn_kwargs,
+    )
+    return tx_syn
+
+
+def combine_syn_txs(
+    fixed_img,
+    moving_img,
+    tx_syn,
+    fwd_prefix,
+    rev_prefix,
+):
+    """
+    Combine transformations for mouse-to-in vivo registrations.
+
+    This function applies a series of spatial transformations to align the
+    masked mouse image to the in vivo image. The combined transformations are
+    returned for both alignments.
+
+    Parameters
+    ----------
+    invivo_img : ants.ANTsImage
+        The in vivo image used as a target or source for the registrations.
+    mouse_img_masked : ants.ANTsImage
+        The masked mouse image to be aligned.
+    mouse_invivo_tx_syn : dict
+        Dictionary containing the forward and inverse transformations between the
+        mouse image and the in vivo image.
+    mouse_invivo_prefix : str
+        Prefix for the output files of the mouse-to-in vivo combined
+        transformation.
+    invivo_mouse_prefix : str
+        Prefix for the output files of the in vivo-to-mouse combined
+        transformation.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the combined transformations for:
+        - mouse-to-in vivo
+        - in vivo-to-mouse
+
+    Examples
+    --------
+    >>> invivo = ants.image_read('path/to/invivo_image.nii.gz')
+    >>> mouse_masked = ants.image_read('path/to/mouse_masked_image.nii.gz')
+    >>> mouse_tx = {
+    ...     'fwdtransforms': ['path/to/fwd_transform.nii.gz'],
+    ...     'invtransforms': ['path/to/inv_transform.nii.gz']
+    ... }
+    >>> combined_txs = combine_mouse_invivo_txs(
+    ...     invivo, mouse_masked, mouse_tx, 'mouse_invivo_prefix_',
+    ...     'invivo_mouse_prefix_'
+    ... )
+    """
+    fwd_tx_cmb = ants.apply_transforms(
+        fixed=fixed_img,
+        moving=moving_img,
+        transformlist=tx_syn["fwdtransforms"],
+        compose=str(fwd_prefix),
+    )
+    rev_tx_cmb = ants.apply_transforms(
+        fixed=moving_img,
+        moving=fixed_img,
+        transformlist=tx_syn["invtransforms"],
+        whichtoinvert=[True, False],
+        compose=str(rev_prefix),
+    )
+    return fwd_tx_cmb, rev_tx_cmb
+
+
+def combine_syn_and_second_transform(
+    fixed_img,
+    moving_img,
+    fwd_tx_syn,
+    invivo_ccf_path,
+    other_fwd_path,
+    other_rev_path,
+    combined_prefix,
+):
+    """
+    Combine transformations for mouse-to-CCF (Common Coordinate Framework)
+    registrations.
+
+    This function applies a series of spatial transformations to align the
+    masked mouse image with the CCF image. These transformations encompass
+    mouse-to-in vivo and in vivo-to-CCF alignments. The combined
+    transformations for both alignments are returned.
+
+    Parameters
+    ----------
+    invivo_img : ants.ANTsImage
+        The in vivo image used as an intermediate reference for the
+        registrations.
+    mouse_img_masked : ants.ANTsImage
+        The masked mouse image to be aligned.
+    mouse_invivo_tx_syn : dict
+        Dictionary containing the forward and inverse transformations between
+        the mouse image and the in vivo image.
+    invivo_ccf_path : str or pathlib.Path
+        Path to the transformation from in vivo to CCF image.
+    ccf_invivo_path : str or pathlib.Path
+        Path to the transformation from CCF to in vivo image.
+    mouse_ccf_prefix : str or pathlib.Path
+        Prefix for the output files of the mouse-to-CCF combined
+        transformation.
+    ccf_mouse_prefix : str or pathlib.Path
+        Prefix for the output files of the CCF-to-mouse combined
+        transformation.
+
+    Returns
+    -------
+    tuple
+        A tuple containing the combined transformations for:
+        - mouse-to-CCF
+        - CCF-to-mouse
+
+    Examples
+    --------
+    >>> invivo = ants.image_read('path/to/invivo_image.nii.gz')
+    >>> mouse_masked = ants.image_read('path/to/mouse_masked_image.nii.gz')
+    >>> mouse_tx = {
+    ...     'fwdtransforms': ['path/to/fwd_transform.nii.gz'],
+    ...     'invtransforms': ['path/to/inv_transform.nii.gz']
+    ... }
+    >>> combined_txs = combine_mouse_invivo_and_invivo_ccf_txs(
+    ...     invivo, mouse_masked, mouse_tx,
+    ...     'path/to/invivo_ccf_tx.nii.gz', 'path/to/ccf_invivo_tx.nii.gz',
+    ...     'mouse_ccf_prefix_', 'ccf_mouse_prefix_'
+    ... )
+    """
+    fwd_tx_cmb = ants.apply_transforms(
+        fixed=fixed_img,
+        moving=moving_img,
+        transformlist=[str(invivo_ccf_path)] + fwd_tx_syn["fwdtransforms"],
+        compose=str(other_rev_path),
+    )
+    rev_tx_cmb = ants.apply_transforms(
+        fixed=moving_img,
+        moving=fixed_img,
+        transformlist=fwd_tx_syn["invtransforms"] + [str(other_fwd_path)],
+        whichtoinvert=[True, False, False],
+        compose=str(combined_prefix),
+    )
+
+    return fwd_tx_cmb, rev_tx_cmb

aind_registration_utils/vtk.py

@@ -0,0 +1,61 @@
+"""
+Code for handling manual keypoints transforms using vtk
+"""
+
+import numpy as np
+import vtk
+
+
+def define_transform(source_landmarks, target_landmarks):
+    """
+    Defines a non-linear warp between a set of source and target landmarks
+
+    Parameters
+    ==========
+    source_landmarks - np.ndarray (N x 3)
+    target_landmarks - np.ndarray (N x 3)
+
+    Returns
+    =======
+    transform - vtkThinPlateSplineTransform
+
+    """
+
+    transform = vtk.vtkThinPlateSplineTransform()
+    source_points = vtk.vtkPoints()
+    target_points = vtk.vtkPoints()
+
+    for i in range(source_landmarks.shape[0]):
+        source_points.InsertNextPoint(source_landmarks[i, :])
+
+    for i in range(target_landmarks.shape[0]):
+        target_points.InsertNextPoint(target_landmarks[i, :])
+
+    transform.SetBasisToR()  # for 3D transform
+    transform.SetSourceLandmarks(source_points)
+    transform.SetTargetLandmarks(target_points)
+    transform.Update()
+
+    return transform
+
+
+def apply_transform(transform, points):
+    """
+    Applies a non-linear warp to a set of points
+
+    Parameters
+    ==========
+    transform - vtkThinPlateSplineTransform
+    points - np.ndarray (N x 3)
+
+    Returns
+    =======
+    warped_points - np.ndarray (N x 3)
+
+    """
+
+    warped_points = np.zeros(points.shape)
+    for i in range(points.shape[0]):
+        warped_points[i, :] = transform.TransformPoint(points[i, :])
+
+    return warped_points

aind_registration_utils-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Allen Institute for Neural Dynamics
+
+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:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aind_registration_utils-0.0.1.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.1
+Name: aind-registration-utils
+Version: 0.0.1
+Summary: Generated from aind-library-template
+Author: Allen Institute for Neural Dynamics
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: antspyx >=0.5
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: SimpleITK
+Requires-Dist: vtk <10,>=9
+Provides-Extra: dev
+Requires-Dist: black ; extra == 'dev'
+Requires-Dist: coverage ; extra == 'dev'
+Requires-Dist: flake8 ; extra == 'dev'
+Requires-Dist: interrogate ; extra == 'dev'
+Requires-Dist: isort ; extra == 'dev'
+Requires-Dist: Sphinx ; extra == 'dev'
+Requires-Dist: furo ; extra == 'dev'
+
+# aind-registration-utils
+
+[![License](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
+![Code Style](https://img.shields.io/badge/code%20style-black-black)
+[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
+![Interrogate](https://img.shields.io/badge/interrogate-73.9%25-red)
+![Coverage](https://img.shields.io/badge/coverage-61%25-red?logo=codecov)
+![Python](https://img.shields.io/badge/python->=3.7-blue?logo=python)
+
+
+
+## Usage
+ - To use this template, click the green `Use this template` button and `Create new repository`.
+ - After github initially creates the new repository, please wait an extra minute for the initialization scripts to finish organizing the repo.
+ - To enable the automatic semantic version increments: in the repository go to `Settings` and `Collaborators and teams`. Click the green `Add people` button. Add `svc-aindscicomp` as an admin. Modify the file in `.github/workflows/tag_and_publish.yml` and remove the if statement in line 65. The semantic version will now be incremented every time a code is committed into the main branch.
+ - To publish to PyPI, enable semantic versioning and uncomment the publish block in `.github/workflows/tag_and_publish.yml`. The code will now be published to PyPI every time the code is committed into the main branch.
+ - The `.github/workflows/test_and_lint.yml` file will run automated tests and style checks every time a Pull Request is opened. If the checks are undesired, the `test_and_lint.yml` can be deleted. The strictness of the code coverage level, etc., can be modified by altering the configurations in the `pyproject.toml` file and the `.flake8` file.
+
+## Installation
+To use the software, in the root directory, run
+```bash
+pip install -e .
+```
+
+To develop the code, run
+```bash
+pip install -e .[dev]
+```
+
+## Contributing
+
+### Linters and testing
+
+There are several libraries used to run linters, check documentation, and run tests.
+
+- Please test your changes using the **coverage** library, which will run the tests and log a coverage report:
+
+```bash
+coverage run -m unittest discover && coverage report
+```
+
+- Use **interrogate** to check that modules, methods, etc. have been documented thoroughly:
+
+```bash
+interrogate .
+```
+
+- Use **flake8** to check that code is up to standards (no unused imports, etc.):
+```bash
+flake8 .
+```
+
+- Use **black** to automatically format the code into PEP standards:
+```bash
+black .
+```
+
+- Use **isort** to automatically sort import statements:
+```bash
+isort .
+```
+
+### Pull requests
+
+For internal members, please create a branch. For external members, please fork the repository and open a pull request from the fork. We'll primarily use [Angular](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit) style for commit messages. Roughly, they should follow the pattern:
+```text
+<type>(<scope>): <short summary>
+```
+
+where scope (optional) describes the packages affected by the code changes and type (mandatory) is one of:
+
+- **build**: Changes that affect build tools or external dependencies (example scopes: pyproject.toml, setup.py)
+- **ci**: Changes to our CI configuration files and scripts (examples: .github/workflows/ci.yml)
+- **docs**: Documentation only changes
+- **feat**: A new feature
+- **fix**: A bugfix
+- **perf**: A code change that improves performance
+- **refactor**: A code change that neither fixes a bug nor adds a feature
+- **test**: Adding missing tests or correcting existing tests
+
+### Semantic Release
+
+The table below, from [semantic release](https://github.com/semantic-release/semantic-release), shows which commit message gets you which release type when `semantic-release` runs (using the default configuration):
+
+| Commit message                                                                                                                                                                                   | Release type                                                                                                    |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `fix(pencil): stop graphite breaking when too much pressure applied`                                                                                                                             | ~~Patch~~ Fix Release, Default release                                                                          |
+| `feat(pencil): add 'graphiteWidth' option`                                                                                                                                                       | ~~Minor~~ Feature Release                                                                                       |
+| `perf(pencil): remove graphiteWidth option`<br><br>`BREAKING CHANGE: The graphiteWidth option has been removed.`<br>`The default graphite width of 10mm is always used for performance reasons.` | ~~Major~~ Breaking Release <br /> (Note that the `BREAKING CHANGE: ` token must be in the footer of the commit) |
+
+### Documentation
+To generate the rst files source files for documentation, run
+```bash
+sphinx-apidoc -o doc_template/source/ src 
+```
+Then to create the documentation HTML files, run
+```bash
+sphinx-build -b html doc_template/source/ doc_template/build/html
+```
+More info on sphinx installation can be found [here](https://www.sphinx-doc.org/en/master/usage/installation.html).

aind_registration_utils-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+aind_registration_utils/__init__.py,sha256=_b3QC6Y7NboP73RjV4irH9taFd2HaRADfzFUkRDgcbk,41
+aind_registration_utils/ants.py,sha256=grqRYBWfC_sFatnGanJCEkh77808Pc8KiRoz98OSXrk,8682
+aind_registration_utils/vtk.py,sha256=S5-NhZ9FIhRSmJ3kxLItwEUx8XNsTXFcfgWtiHA4CDM,1419
+aind_registration_utils-0.0.1.dist-info/LICENSE,sha256=U0Y7B3gZJHXpjJVLgTQjM8e_c8w4JJpLgGhIdsoFR1Y,1092
+aind_registration_utils-0.0.1.dist-info/METADATA,sha256=jI8edRk0Op-ROXBlkL177jyE8ZJ-XKDTfGK_eiiq0yM,6473
+aind_registration_utils-0.0.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+aind_registration_utils-0.0.1.dist-info/top_level.txt,sha256=6FpFq4IENJ0P5eRRC4yrQE2e-nmlQzldaKuil8jYbw0,24
+aind_registration_utils-0.0.1.dist-info/RECORD,,

aind_registration_utils-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aind_registration_utils-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+aind_registration_utils