niiprep 0.1.0__tar.gz

niiprep-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: niiprep
+Version: 0.1.0
+Summary: A CLI wrapper for TorchIO and ANTsPyX for NIfTI image processing
+Author: Jinghang Li
+Author-email: jinghang.li@pitt.edu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=3.7
+Requires-Dist: torchio>=0.18.0
+Requires-Dist: antspyx>=0.3.0
+Requires-Dist: nibabel>=3.0.0
+Requires-Dist: numpy>=1.19.0

niiprep-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

niiprep-0.1.0/setup.py

@@ -0,0 +1,40 @@
+from setuptools import setup, find_packages
+
+
+setup(
+    name="niiprep",
+    version="0.1.0",
+    author="Jinghang Li",
+    author_email="jinghang.li@pitt.edu",
+    description="A CLI wrapper for TorchIO and ANTsPyX for NIfTI image processing",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    package_data={
+        'niiprep': [''],
+    },
+    include_package_data=True,
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "torchio>=0.18.0",
+        "antspyx>=0.3.0",
+        "nibabel>=3.0.0",
+        "numpy>=1.19.0",
+    ],
+    entry_points={
+        'console_scripts': [
+            'resample=niiprep.cli:resample_cli',
+            'registernii=niiprep.cli:register_cli',
+            'nii2mp4=niiprep.cli:nii_to_mp4_cli',
+            'roundnii=niiprep.cli:round_cli',
+            'denoiseMP2RAGE=niiprep.cli:denoise_mp2rage'
+        ],
+    },
+) 

niiprep-0.1.0/src/niiprep/__init__.py

@@ -0,0 +1,6 @@
+from .resample import resample
+from .registration import register
+from .nii2mp4 import nii_to_mp4
+
+__version__ = "0.1.0"
+__all__ = ["resample", "register", "nii_to_mp4"]

niiprep-0.1.0/src/niiprep/cli.py

@@ -0,0 +1,113 @@
+import argparse
+from .resample import resample
+from .registration import register
+from .nii2mp4 import nii_to_mp4
+from .round import round_nifti
+from .denoise_mp2rage import robust_combination
+
+def resample_cli():
+    parser = argparse.ArgumentParser(description='Resample NIfTI image to specified resolution')
+    parser.add_argument('-i', '--input', required=True,
+                      help='Path to input NIfTI file')
+    parser.add_argument('-o', '--output', required=True,
+                      help='Path to save resampled NIfTI file')
+    parser.add_argument('-s', '--spacing', nargs=3, type=float, default=[1.0, 1.0, 1.0],
+                      help='Target voxel spacing in mm (x y z), default: 1.0 1.0 1.0')
+    parser.add_argument('--interpolation', choices=['linear', 'nearest', 'bspline'], 
+                      default='linear',
+                      help='Interpolation method (default: linear)')
+    
+    args = parser.parse_args()
+    
+    resample(
+        input_path=args.input,
+        output_path=args.output,
+        target_spacing=tuple(args.spacing),
+        interpolation=args.interpolation
+    )
+
+def register_cli():
+    parser = argparse.ArgumentParser(description='Register moving image to fixed image')
+    parser.add_argument('-f', '--fixed', required=True,
+                      help='Path to fixed/reference NIfTI file')
+    parser.add_argument('-m', '--moving', required=True,
+                      help='Path to moving NIfTI file')
+    parser.add_argument('-o', '--output', required=True,
+                      help='Path to save registered NIfTI file')
+    parser.add_argument('-t', '--type', choices=['rigid', 'affine', 'syn'], 
+                      default='syn',
+                      help='Registration type (default: syn)')
+    parser.add_argument('--interpolation', default='linear',
+                      help='Interpolation type (default: linear)')
+    
+    args = parser.parse_args()
+    
+    register(
+        fixed_path=args.fixed,
+        moving_path=args.moving,
+        output_path=args.output,
+        reg_type=args.type,
+        interpolation=args.interpolation
+    ) 
+
+def nii_to_mp4_cli():
+    parser = argparse.ArgumentParser(description='Convert NIfTI file to MP4 video')
+    parser.add_argument('-i', '--input', required=True,
+                      help='Path to input NIfTI file')
+    parser.add_argument('-o', '--output', required=True,
+                      help='Path to save MP4 file')
+    parser.add_argument('-d', '--dimension', type=int, default=2, choices=[0, 1, 2],
+                      help='Dimension to slice along (0: sagittal, 1: coronal, 2: axial (default))')
+    parser.add_argument('--fps', type=int, default=10,
+                      help='Frames per second (default: 10)')
+    parser.add_argument('--no-normalize', action='store_false', dest='normalize',
+                      help='Disable intensity normalization')
+    
+    args = parser.parse_args()
+    
+    # Ensure output path has .mp4 extension
+    output_path = args.output
+    if not output_path.endswith('.mp4'):
+        output_path += '.mp4'
+    
+    nii_to_mp4(
+        input_path=args.input,
+        output_path=output_path,
+        dimension=args.dimension,
+        fps=args.fps,
+        normalize=args.normalize
+    ) 
+
+def round_cli():
+    parser = argparse.ArgumentParser(description='Round NIfTI image pixel values')
+    parser.add_argument('-i', '--input', required=True,
+                      help='Path to input NIfTI file (will be overwritten)')
+    
+    args = parser.parse_args()
+    
+    round_nifti(args.input) 
+
+def denoise_mp2rage():
+
+    parser = argparse.ArgumentParser(description='MP2RAGE robust combination processing')
+    
+    parser.add_argument('--uni', type=str, required=True,
+                        help='Path to UNI image (.nii or .nii.gz)')
+    parser.add_argument('--inv1', type=str, required=True,
+                        help='Path to INV1 image (.nii or .nii.gz)')
+    parser.add_argument('--inv2', type=str, required=True,
+                        help='Path to INV2 image (.nii or .nii.gz)')
+    parser.add_argument('--output', '-o', type=str, required=True,
+                        help='Output path for processed image')
+    parser.add_argument('--regularization', '-r', type=float, default=None,
+                        help='Noise regularization factor (default: None for interactive mode)')
+
+    args = parser.parse_args()
+
+    mp2rage_data = {
+        'filenameUNI': args.uni,
+        'filenameINV1': args.inv1,
+        'filenameINV2': args.inv2,
+        'filenameOUT': args.output
+    }
+    _, _ = robust_combination(mp2rage_data, regularization=args.regularization,)

niiprep-0.1.0/src/niiprep/denoise_mp2rage.py

@@ -0,0 +1,145 @@
+import os
+import numpy as np
+import nibabel as nib
+import json
+from matplotlib import pyplot as plt
+
+def robust_combination(mp2rage, regularization=None, figure=None):
+    """
+    Creates MP2RAGE T1w images without strong background noise in air regions.
+    This python file is translated from 
+    
+    https://github.com/JosePMarques/MP2RAGE-related-scripts/tree/master
+
+    Parameters:
+    -----------
+    mp2rage : dict
+        Dictionary containing filenames:
+        - filenameUNI: Path to UNI image
+        - filenameINV1: Path to INV1 image
+        - filenameINV2: Path to INV2 image
+        - filenameOUT: Optional output path
+    regularization : float, optional
+        Noise regularization factor
+    figure : matplotlib.figure, optional
+        Figure handle for visualization
+    
+    Returns:
+    --------
+    tuple: (mp2rage_robust, multiplying_factor)
+    """
+    
+    # Set defaults
+    multiplying_factor = 1 if regularization is None else regularization
+    final_choice = 'n'
+    
+    # Define helper functions
+    def mp2rage_robust_func(inv1, inv2, beta):
+        return (np.conj(inv1) * inv2 - beta) / (inv1**2 + inv2**2 + 2*beta)
+    
+    def roots_pos(a, b, c):
+        return (-b + np.sqrt(b**2 - 4*a*c)) / (2*a)
+    
+    def roots_neg(a, b, c):
+        return (-b - np.sqrt(b**2 - 4*a*c)) / (2*a)
+    
+    # Load data
+    print(f"Loading images from: {os.path.dirname(mp2rage['filenameUNI'])}")
+    uni_img = nib.load(mp2rage['filenameUNI'])
+    uni_data = uni_img.get_fdata().astype(np.float64)
+    inv1_data = nib.load(mp2rage['filenameINV1']).get_fdata().astype(np.float64)
+    inv2_data = nib.load(mp2rage['filenameINV2']).get_fdata().astype(np.float64)
+    
+    # Check if normalization is needed
+    if uni_data.min() >= 0 and uni_data.max() >= 0.51:
+        uni_data = (uni_data - uni_data.max()/2) / uni_data.max()
+        integer_format = True
+    else:
+        integer_format = False
+    
+    # Compute correct INV1 dataset
+    inv1_data = np.sign(uni_data) * inv1_data
+    
+    inv1_pos = roots_pos(-uni_data, inv2_data, -inv2_data**2 * uni_data)
+    inv1_neg = roots_neg(-uni_data, inv2_data, -inv2_data**2 * uni_data)
+    
+    inv1_final = inv1_data.copy()
+    mask_neg = np.abs(inv1_data - inv1_pos) > np.abs(inv1_data - inv1_neg)
+    inv1_final[mask_neg] = inv1_neg[mask_neg]
+    inv1_final[~mask_neg] = inv1_pos[~mask_neg]
+    
+    # Interactive regularization loop
+    while final_choice.lower() != 'y':
+        noise_level = multiplying_factor * np.mean(inv2_data[:, -10:, -10:])
+        mp2rage_robust = mp2rage_robust_func(inv1_final, inv2_data, noise_level**2)
+        
+        if figure is not None:
+            # Visualization code here (simplified)
+            plt.figure(figure.number)
+            plt.subplot(211)
+            plt.imshow(uni_data[:, :, uni_data.shape[2]//2], cmap='gray', vmin=-0.5, vmax=0.4)
+            plt.title('MP2RAGE UNI-Image')
+            
+            plt.subplot(212)
+            plt.imshow(mp2rage_robust[:, :, mp2rage_robust.shape[2]//2], cmap='gray', vmin=-0.5, vmax=0.4)
+            plt.title(f'MP2RAGE Robust (Noise level = {multiplying_factor})')
+            plt.show()
+            
+            if regularization is None:
+                final_choice = input('Is it a satisfactory noise level?? (y/n) [n]: ') or 'n'
+                if final_choice.lower() != 'y':
+                    multiplying_factor = float(input(f'New regularization noise level (current = {multiplying_factor}): '))
+            else:
+                final_choice = 'y'
+        else:
+            final_choice = 'y'
+    
+    # Save output if filename provided
+    if 'filenameOUT' in mp2rage and mp2rage['filenameOUT']:
+        print(f"Saving: {mp2rage['filenameOUT']}")
+        out_data = mp2rage_robust if not integer_format else np.round(4095 * (mp2rage_robust + 0.5))
+        out_img = nib.Nifti1Image(out_data, uni_img.affine)
+        nib.save(out_img, mp2rage['filenameOUT'])
+        
+        # Handle JSON sidecar
+        uni_json = os.path.splitext(mp2rage['filenameUNI'])[0] + '.json'
+        if os.path.exists(uni_json):
+            with open(uni_json, 'r') as f:
+                json_data = json.load(f)
+            
+            json_data.update({
+                'BasedOn': [mp2rage['filenameUNI'], mp2rage['filenameINV1'], mp2rage['filenameINV2']],
+                'SeriesDescription': f"{json_data['ProtocolName']}_MP2RAGE_denoised_background",
+                'NoiseRegularization': multiplying_factor
+            })
+            
+            out_json = os.path.splitext(mp2rage['filenameOUT'])[0] + '.json'
+            with open(out_json, 'w') as f:
+                json.dump(json_data, f)
+    
+    return mp2rage_robust, multiplying_factor
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description='MP2RAGE robust combination processing')
+    
+    parser.add_argument('--uni', type=str, required=True,
+                        help='Path to UNI image (.nii or .nii.gz)')
+    parser.add_argument('--inv1', type=str, required=True,
+                        help='Path to INV1 image (.nii or .nii.gz)')
+    parser.add_argument('--inv2', type=str, required=True,
+                        help='Path to INV2 image (.nii or .nii.gz)')
+    parser.add_argument('--output', '-o', type=str, required=True,
+                        help='Output path for processed image')
+    parser.add_argument('--regularization', '-r', type=float, default=None,
+                        help='Noise regularization factor (default: None for interactive mode)')
+
+    args = parser.parse_args()
+    mp2rage_data = {
+        'filenameUNI': args.uni,
+        'filenameINV1': args.inv1,
+        'filenameINV2': args.inv2,
+        'filenameOUT': args.output
+    }
+    robust_image, factor = robust_combination(mp2rage_data, regularization=args.regularization,)

niiprep-0.1.0/src/niiprep/nii2mp4.py

@@ -0,0 +1,56 @@
+import nibabel as nib
+import numpy as np
+import cv2
+from pathlib import Path
+
+def nii_to_mp4(
+    input_path: str,
+    output_path: str,
+    dimension: int = 2,
+    fps: int = 10,
+    normalize: bool = True
+) -> None:
+    """
+    Convert a NIfTI file to MP4 video along a specified dimension.
+    
+    Args:
+        input_path (str): Path to input NIfTI file
+        output_path (str): Path to save MP4 file
+        dimension (int): Dimension to slice along (0: sagittal, 1: coronal, 2: axial)
+        fps (int): Frames per second for the output video
+        normalize (bool): Whether to normalize slice intensities
+    """
+    # Load NIfTI file
+    img = nib.load(input_path)
+    data = img.get_fdata()
+    
+    # Get slices based on dimension
+    if dimension == 0:  # sagittal
+        n_slices = data.shape[0]
+        slices = [np.rot90(data[i, :, :]) for i in range(n_slices)]
+    elif dimension == 1:  # coronal
+        n_slices = data.shape[1]
+        slices = [np.rot90(data[:, i, :]) for i in range(n_slices)]
+    else:  # axial (dimension == 2)
+        n_slices = data.shape[2]
+        slices = [np.rot90(data[:, :, i]) for i in range(n_slices)]
+    
+    # Normalize and convert to uint8
+    if normalize:
+        slices = [(((s - s.min()) / (s.max() - s.min())) * 255).astype(np.uint8) for s in slices]
+    else:
+        slices = [s.astype(np.uint8) for s in slices]
+    
+    # Get dimensions for the video
+    height, width = slices[0].shape
+    
+    # Initialize video writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height), isColor=False)
+    
+    # Write slices to video
+    for slice_data in slices:
+        out.write(slice_data)
+    
+    # Release video writer
+    out.release()

niiprep-0.1.0/src/niiprep/registration.py

@@ -0,0 +1,51 @@
+import ants
+from pathlib import Path
+from typing import Literal, Optional, Union, Tuple
+
+def register(
+    fixed_path: str,
+    moving_path: str,
+    output_path: str,
+    reg_type: Literal['rigid', 'affine', 'syn'] = 'syn',
+    interpolation: str = 'linear'
+) -> Tuple[ants.core.ants_image.ANTsImage, dict]:
+    """
+    Register a moving image to a fixed image using ANTsPyX.
+    
+    Args:
+        fixed_path (str): Path to fixed/reference image
+        moving_path (str): Path to moving image to be registered
+        output_path (str): Path to save registered image
+        reg_type (str): Registration type ('rigid', 'affine', or 'syn')
+        interpolation (str): Interpolation type for resampling
+    
+    Returns:
+        tuple: (registered_image, transform_params)
+    """
+    # Load images
+    fixed_image = ants.image_read(fixed_path)
+    moving_image = ants.image_read(moving_path)
+    
+    # Set up registration parameters
+    if reg_type == 'rigid':
+        transform = 'Rigid'
+    elif reg_type == 'affine':
+        transform = 'Affine'
+    elif reg_type == 'syn':
+        transform = 'SyN'
+    else:
+        raise ValueError("reg_type must be 'rigid', 'affine', or 'syn'")
+    
+    # Perform registration
+    registration = ants.registration(
+        fixed=fixed_image,
+        moving=moving_image,
+        type_of_transform=transform,
+        interpolator=interpolation
+    )
+    
+    # Save registered image
+    registered_image = registration['warpedmovout']
+    ants.image_write(registered_image, output_path)
+    
+    return registered_image, registration

niiprep-0.1.0/src/niiprep/resample.py

@@ -0,0 +1,30 @@
+import torchio as tio
+import nibabel as nib
+import numpy as np
+
+def resample(
+    input_path: str,
+    output_path: str,
+    target_spacing: tuple = (1.0, 1.0, 1.0),
+    interpolation: str = 'linear'
+) -> None:
+    """
+    Resample a NIfTI image to specified voxel spacing.
+    
+    Args:
+        input_path (str): Path to input NIfTI file
+        output_path (str): Path to save resampled NIfTI file
+        target_spacing (tuple): Target voxel spacing in mm (x, y, z)
+        interpolation (str): Interpolation method ('linear', 'nearest', 'bspline')
+    """
+    # Load image
+    image = tio.ScalarImage(input_path)
+    
+    # Create resampling transform
+    resample = tio.Resample(target_spacing)
+    
+    # Apply transform
+    resampled_image = resample(image)
+    
+    # Save resampled image
+    resampled_image.save(output_path)

niiprep-0.1.0/src/niiprep/round.py

@@ -0,0 +1,22 @@
+import nibabel as nib
+import numpy as np
+
+def round_nifti(input_path: str) -> None:
+    """
+    Round pixel values in a NIfTI image and save with the same name.
+    
+    Args:
+        input_path: Path to input NIfTI file
+    """
+    # Load the image
+    img = nib.load(input_path)
+    data = img.get_fdata()
+    
+    # Round the data
+    rounded_data = np.round(data)
+    
+    # Create new NIfTI image with rounded data
+    rounded_img = nib.Nifti1Image(rounded_data, img.affine, img.header)
+    
+    # Save the rounded image (overwrites original)
+    nib.save(rounded_img, input_path) 

niiprep-0.1.0/src/niiprep.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: niiprep
+Version: 0.1.0
+Summary: A CLI wrapper for TorchIO and ANTsPyX for NIfTI image processing
+Author: Jinghang Li
+Author-email: jinghang.li@pitt.edu
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=3.7
+Requires-Dist: torchio>=0.18.0
+Requires-Dist: antspyx>=0.3.0
+Requires-Dist: nibabel>=3.0.0
+Requires-Dist: numpy>=1.19.0

niiprep-0.1.0/src/niiprep.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+setup.py
+src/niiprep/__init__.py
+src/niiprep/cli.py
+src/niiprep/denoise_mp2rage.py
+src/niiprep/nii2mp4.py
+src/niiprep/registration.py
+src/niiprep/resample.py
+src/niiprep/round.py
+src/niiprep.egg-info/PKG-INFO
+src/niiprep.egg-info/SOURCES.txt
+src/niiprep.egg-info/dependency_links.txt
+src/niiprep.egg-info/entry_points.txt
+src/niiprep.egg-info/requires.txt
+src/niiprep.egg-info/top_level.txt

niiprep-0.1.0/src/niiprep.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

niiprep-0.1.0/src/niiprep.egg-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+denoiseMP2RAGE = niiprep.cli:denoise_mp2rage
+nii2mp4 = niiprep.cli:nii_to_mp4_cli
+registernii = niiprep.cli:register_cli
+resample = niiprep.cli:resample_cli
+roundnii = niiprep.cli:round_cli

niiprep-0.1.0/src/niiprep.egg-info/requires.txt

@@ -0,0 +1,4 @@
+torchio>=0.18.0
+antspyx>=0.3.0
+nibabel>=3.0.0
+numpy>=1.19.0

niiprep-0.1.0/src/niiprep.egg-info/top_level.txt

@@ -0,0 +1 @@
+niiprep