intensity-normalization

Name	intensity-normalization JSON
Version	3.0.0 JSON
	download
home_page	None
Summary	Normalize intensities of MR image modalities
upload_time	2025-07-11 01:54:24
maintainer	None
docs_url	None
author	Jacob Reinhold
requires_python	>=3.11
license	MIT License Copyright (c) 2025 Jacob Reinhold 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.
keywords
VCS
bugtrack_url
requirements	No requirements were recorded.
Travis-CI	No Travis.
coveralls test coverage	No coveralls.

            # Intensity Normalization

A modern Python package for normalizing MR image intensities.

## Features

- **🔧 Multiple Image Format Support**: Works with numpy arrays and nibabel images (.nii, .nii.gz, .mgz, .mnc, etc.)
- **📊 6 Normalization Methods**: FCM, KDE, WhiteStripe, Z-score, Nyúl, LSQ
- **⚡ High Performance**: Optimized implementations

## Installation

```bash
pip install intensity-normalization
```

## Quick Start

### High-Level API

```python
import numpy as np
import nibabel as nib
from intensity_normalization import normalize_image

# Load MRI image and brain mask
img = nib.load("brain_t1.nii.gz")
mask = nib.load("brain_mask.nii.gz")

# Normalize using FCM (default, recommended for T1)
normalized = normalize_image(img, method="fcm", mask=mask)

# Different methods for different modalities
t2_normalized = normalize_image(img, method="kde", modality="t2")
zscore_normalized = normalize_image(img, method="zscore")
```

### Object-Oriented API

```python
from intensity_normalization import FCMNormalizer, ZScoreNormalizer
import numpy as np

# Create synthetic brain data
brain_data = np.random.normal(1000, 200, (64, 64, 32))  # WM ~1000
brain_data[20:40, 20:40, 10:20] = np.random.normal(600, 100, (20, 20, 10))  # GM ~600

# FCM normalization (tissue-based)
fcm = FCMNormalizer(tissue_type="wm")  # white matter reference
normalized = fcm.fit_transform(brain_data)

# Z-score normalization
zscore = ZScoreNormalizer()
standardized = zscore.fit_transform(brain_data)

print(f"Original mean: {brain_data[brain_data > 0].mean():.1f}")
print(f"FCM normalized WM mean: {normalized[40:60, 40:60, 10:20].mean():.2f}")
print(f"Z-score mean: {standardized[brain_data > 0].mean():.2f}")
```

### Population-Based Methods

```python
from intensity_normalization import NyulNormalizer, LSQNormalizer
from intensity_normalization.adapters import create_image

# Load multiple subjects
image_paths = ["subject1_t1.nii.gz", "subject2_t1.nii.gz", "subject3_t1.nii.gz"]
images = [create_image(path) for path in image_paths]

# Nyúl histogram matching
nyul = NyulNormalizer(output_min_value=0, output_max_value=100)
nyul.fit_population(images)

# Normalize all images to the same scale
normalized_images = [nyul.transform(img) for img in images]

# LSQ tissue mean harmonization
lsq = LSQNormalizer()
lsq.fit_population(images)
harmonized_images = [lsq.transform(img) for img in images]
```

## Command Line Interface

### Single Image Normalization

```bash
# Basic usage
intensity-normalize fcm brain_t1.nii.gz

# With brain mask
intensity-normalize fcm brain_t1.nii.gz -m brain_mask.nii.gz

# Specify output location
intensity-normalize zscore brain_t1.nii.gz -o normalized_brain.nii.gz

# Different modalities and tissue types
intensity-normalize kde brain_t2.nii.gz --modality t2 --tissue-type gm
intensity-normalize whitestripe brain_flair.nii.gz --modality flair --width 0.1
```

### Method-Specific Parameters

```bash
# FCM with different tissue types and clusters
intensity-normalize fcm brain.nii.gz --tissue-type wm --n-clusters 3

# WhiteStripe with custom width
intensity-normalize whitestripe brain.nii.gz --width 0.05

# Get help for specific methods
intensity-normalize fcm --help
```

## Supported File Formats

Works with all neuroimaging formats supported by nibabel:

| Format | Extensions | Description |
|--------|------------|-------------|
| **NIfTI** | `.nii`, `.nii.gz` | Most common neuroimaging format |
| **FreeSurfer** | `.mgz`, `.mgh` | FreeSurfer volume format |
| **ANALYZE** | `.hdr/.img` | Legacy format pair |
| **MINC** | `.mnc` | Medical Imaging NetCDF |
| **PAR/REC** | `.par/.rec` | Philips scanner format |
| **Numpy** | `.npy` | Raw numpy arrays |

## Normalization Methods

### Individual Methods (Single Image)

| Method | Best For | Description |
|--------|----------|-------------|
| **FCM** | T1-weighted | Fuzzy C-means tissue segmentation (recommended) |
| **Z-Score** | Any modality | Standard score normalization |
| **KDE** | T1/T2/FLAIR | Kernel density estimation of tissue modes |
| **WhiteStripe** | T1-weighted | Normal-appearing white matter standardization |

### Population Methods (Multiple Images)

| Method | Best For | Description |
|--------|----------|-------------|
| **Nyúl** | Cross-scanner | Piecewise linear histogram matching |
| **LSQ** | Multi-site studies | Least squares tissue mean harmonization |

### Method Selection Guide

```python
# T1-weighted images (structural)
normalize_image(t1_image, method="fcm", tissue_type="wm")

# T2-weighted or FLAIR
normalize_image(t2_image, method="kde", modality="t2")

# Quick standardization
normalize_image(image, method="zscore")

# Multi-site harmonization (requires multiple subjects)
from intensity_normalization.services.normalization import NormalizationService
config = NormalizationConfig(method="nyul")
harmonized = NormalizationService.normalize_images(all_images, config)
```

## Architecture Overview

The package is structured as follows:

```
intensity_normalization/
├── domain/          # Core logic
│   ├── protocols.py # Image and normalizer interfaces
│   ├── models.py    # Configuration and value objects
│   └── exceptions.py# Domain-specific exceptions
├── adapters/        # External interfaces
│   ├── images.py    # Universal image adapter (numpy/nibabel)
│   └── io.py        # File I/O operations
├── normalizers/     # Normalization implementations
│   ├── individual/  # Single-image methods (FCM, Z-score, etc.)
│   └── population/  # Multi-image methods (Nyúl, LSQ)
├── services/        # Application services
│   ├── normalization.py # Orchestration logic
│   └── validation.py    # Input validation
└── cli.py          # Command-line interface
```

## Advanced Usage

### Custom Normalizers

```python
from intensity_normalization.domain.protocols import BaseNormalizer
from intensity_normalization.domain.protocols import ImageProtocol

class CustomNormalizer(BaseNormalizer):
    def fit(self, image: ImageProtocol, mask=None) -> 'CustomNormalizer':
        # Implement fitting logic
        self.is_fitted = True
        return self

    def transform(self, image: ImageProtocol, mask=None) -> ImageProtocol:
        # Implement normalization logic
        data = image.get_data()
        normalized_data = your_normalization_function(data)
        return image.with_data(normalized_data)
```

### Configuration-Based Workflow

```python
from intensity_normalization.domain.models import NormalizationConfig, Modality, TissueType
from intensity_normalization.services.normalization import NormalizationService

# Create configuration
config = NormalizationConfig(
    method="fcm",
    modality=Modality.T1,
    tissue_type=TissueType.WM
)

# Validate configuration
from intensity_normalization.services import ValidationService
ValidationService.validate_normalization_config(config)

# Apply normalization
result = NormalizationService.normalize_image(image, config, mask)
```

### Batch Processing

```python
from pathlib import Path
from intensity_normalization.adapters.images import create_image, save_image
from intensity_normalization.services.normalization import NormalizationService

def process_directory(input_dir: Path, output_dir: Path, method: str = "fcm"):
    """Process all NIfTI files in a directory."""
    output_dir.mkdir(exist_ok=True)

    for img_file in input_dir.glob("*.nii.gz"):
        # Load image
        image = create_image(img_file)

        # Create configuration
        config = NormalizationConfig(method=method)

        # Normalize
        normalized = NormalizationService.normalize_image(image, config)

        # Save result
        output_file = output_dir / f"{img_file.stem}_normalized.nii.gz"
        save_image(normalized, output_file)
        print(f"Processed: {img_file.name}")

# Usage
process_directory(Path("raw_images/"), Path("normalized/"))
```

## Development

### Setup Development Environment

```bash
# Clone and setup
git clone https://github.com/jcreinhold/intensity-normalization.git
cd intensity-normalization

# Install uv (modern Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create virtual environment and install dependencies
uv sync --dev
```

### Code Quality

```bash
# Format code
uv run ruff format intensity_normalization/

# Lint code
uv run ruff check intensity_normalization/

# Type checking
uv run mypy intensity_normalization/

# Run tests
uv run pytest

# Run tests with coverage
uv run pytest --cov=intensity_normalization --cov-report=html
```

### Contributing

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make changes and add tests
4. Ensure code quality (`uv run ruff format && uv run ruff check --fix && uv run mypy`)
5. Run tests (`uv run pytest`)
6. Commit changes (`git commit -m 'Add amazing feature'`)
7. Push to branch (`git push origin feature/amazing-feature`)
8. Open a Pull Request

## Citation

If you use this package in your research, please cite:

```bibtex
@inproceedings{reinhold2019evaluating,
  title={Evaluating the impact of intensity normalization on {MR} image synthesis},
  author={Reinhold, Jacob C and Dewey, Blake E and Carass, Aaron and Prince, Jerry L},
  booktitle={Medical Imaging 2019: Image Processing},
  volume={10949},
  pages={109493H},
  year={2019},
  organization={International Society for Optics and Photonics}}
```

## Related Papers

- **FCM**: Udupa, J.K., et al. "A framework for evaluating image segmentation algorithms." Computerized medical imaging and graphics 30.2 (2006): 75-87.
- **Nyúl**: Nyúl, L.G., Udupa, J.K. "On standardizing the MR image intensity scale." Magnetic Resonance in Medicine 42.6 (1999): 1072-1081.
- **WhiteStripe**: Shinohara, R.T., et al. "Statistical normalization techniques for magnetic resonance imaging." NeuroImage 132 (2016): 174-184.

## Support

- **Issues**: [GitHub Issues](https://github.com/jcreinhold/intensity-normalization/issues)
- **Discussions**: [GitHub Discussions](https://github.com/jcreinhold/intensity-normalization/discussions)

            

Raw data

            {
    "_id": null,
    "home_page": null,
    "name": "intensity-normalization",
    "maintainer": null,
    "docs_url": null,
    "requires_python": ">=3.11",
    "maintainer_email": null,
    "keywords": null,
    "author": "Jacob Reinhold",
    "author_email": null,
    "download_url": "https://files.pythonhosted.org/packages/3d/30/afa3d457699ac935a3f3dffcf06d13e91e71f0621b95e4e9e5daff835636/intensity_normalization-3.0.0.tar.gz",
    "platform": null,
    "description": "# Intensity Normalization\n\nA modern Python package for normalizing MR image intensities.\n\n## Features\n\n- **\ud83d\udd27 Multiple Image Format Support**: Works with numpy arrays and nibabel images (.nii, .nii.gz, .mgz, .mnc, etc.)\n- **\ud83d\udcca 6 Normalization Methods**: FCM, KDE, WhiteStripe, Z-score, Ny\u00fal, LSQ\n- **\u26a1 High Performance**: Optimized implementations\n\n## Installation\n\n```bash\npip install intensity-normalization\n```\n\n## Quick Start\n\n### High-Level API\n\n```python\nimport numpy as np\nimport nibabel as nib\nfrom intensity_normalization import normalize_image\n\n# Load MRI image and brain mask\nimg = nib.load(\"brain_t1.nii.gz\")\nmask = nib.load(\"brain_mask.nii.gz\")\n\n# Normalize using FCM (default, recommended for T1)\nnormalized = normalize_image(img, method=\"fcm\", mask=mask)\n\n# Different methods for different modalities\nt2_normalized = normalize_image(img, method=\"kde\", modality=\"t2\")\nzscore_normalized = normalize_image(img, method=\"zscore\")\n```\n\n### Object-Oriented API\n\n```python\nfrom intensity_normalization import FCMNormalizer, ZScoreNormalizer\nimport numpy as np\n\n# Create synthetic brain data\nbrain_data = np.random.normal(1000, 200, (64, 64, 32))  # WM ~1000\nbrain_data[20:40, 20:40, 10:20] = np.random.normal(600, 100, (20, 20, 10))  # GM ~600\n\n# FCM normalization (tissue-based)\nfcm = FCMNormalizer(tissue_type=\"wm\")  # white matter reference\nnormalized = fcm.fit_transform(brain_data)\n\n# Z-score normalization\nzscore = ZScoreNormalizer()\nstandardized = zscore.fit_transform(brain_data)\n\nprint(f\"Original mean: {brain_data[brain_data > 0].mean():.1f}\")\nprint(f\"FCM normalized WM mean: {normalized[40:60, 40:60, 10:20].mean():.2f}\")\nprint(f\"Z-score mean: {standardized[brain_data > 0].mean():.2f}\")\n```\n\n### Population-Based Methods\n\n```python\nfrom intensity_normalization import NyulNormalizer, LSQNormalizer\nfrom intensity_normalization.adapters import create_image\n\n# Load multiple subjects\nimage_paths = [\"subject1_t1.nii.gz\", \"subject2_t1.nii.gz\", \"subject3_t1.nii.gz\"]\nimages = [create_image(path) for path in image_paths]\n\n# Ny\u00fal histogram matching\nnyul = NyulNormalizer(output_min_value=0, output_max_value=100)\nnyul.fit_population(images)\n\n# Normalize all images to the same scale\nnormalized_images = [nyul.transform(img) for img in images]\n\n# LSQ tissue mean harmonization\nlsq = LSQNormalizer()\nlsq.fit_population(images)\nharmonized_images = [lsq.transform(img) for img in images]\n```\n\n## Command Line Interface\n\n### Single Image Normalization\n\n```bash\n# Basic usage\nintensity-normalize fcm brain_t1.nii.gz\n\n# With brain mask\nintensity-normalize fcm brain_t1.nii.gz -m brain_mask.nii.gz\n\n# Specify output location\nintensity-normalize zscore brain_t1.nii.gz -o normalized_brain.nii.gz\n\n# Different modalities and tissue types\nintensity-normalize kde brain_t2.nii.gz --modality t2 --tissue-type gm\nintensity-normalize whitestripe brain_flair.nii.gz --modality flair --width 0.1\n```\n\n### Method-Specific Parameters\n\n```bash\n# FCM with different tissue types and clusters\nintensity-normalize fcm brain.nii.gz --tissue-type wm --n-clusters 3\n\n# WhiteStripe with custom width\nintensity-normalize whitestripe brain.nii.gz --width 0.05\n\n# Get help for specific methods\nintensity-normalize fcm --help\n```\n\n## Supported File Formats\n\nWorks with all neuroimaging formats supported by nibabel:\n\n| Format | Extensions | Description |\n|--------|------------|-------------|\n| **NIfTI** | `.nii`, `.nii.gz` | Most common neuroimaging format |\n| **FreeSurfer** | `.mgz`, `.mgh` | FreeSurfer volume format |\n| **ANALYZE** | `.hdr/.img` | Legacy format pair |\n| **MINC** | `.mnc` | Medical Imaging NetCDF |\n| **PAR/REC** | `.par/.rec` | Philips scanner format |\n| **Numpy** | `.npy` | Raw numpy arrays |\n\n## Normalization Methods\n\n### Individual Methods (Single Image)\n\n| Method | Best For | Description |\n|--------|----------|-------------|\n| **FCM** | T1-weighted | Fuzzy C-means tissue segmentation (recommended) |\n| **Z-Score** | Any modality | Standard score normalization |\n| **KDE** | T1/T2/FLAIR | Kernel density estimation of tissue modes |\n| **WhiteStripe** | T1-weighted | Normal-appearing white matter standardization |\n\n### Population Methods (Multiple Images)\n\n| Method | Best For | Description |\n|--------|----------|-------------|\n| **Ny\u00fal** | Cross-scanner | Piecewise linear histogram matching |\n| **LSQ** | Multi-site studies | Least squares tissue mean harmonization |\n\n### Method Selection Guide\n\n```python\n# T1-weighted images (structural)\nnormalize_image(t1_image, method=\"fcm\", tissue_type=\"wm\")\n\n# T2-weighted or FLAIR\nnormalize_image(t2_image, method=\"kde\", modality=\"t2\")\n\n# Quick standardization\nnormalize_image(image, method=\"zscore\")\n\n# Multi-site harmonization (requires multiple subjects)\nfrom intensity_normalization.services.normalization import NormalizationService\nconfig = NormalizationConfig(method=\"nyul\")\nharmonized = NormalizationService.normalize_images(all_images, config)\n```\n\n## Architecture Overview\n\nThe package is structured as follows:\n\n```\nintensity_normalization/\n\u251c\u2500\u2500 domain/          # Core logic\n\u2502   \u251c\u2500\u2500 protocols.py # Image and normalizer interfaces\n\u2502   \u251c\u2500\u2500 models.py    # Configuration and value objects\n\u2502   \u2514\u2500\u2500 exceptions.py# Domain-specific exceptions\n\u251c\u2500\u2500 adapters/        # External interfaces\n\u2502   \u251c\u2500\u2500 images.py    # Universal image adapter (numpy/nibabel)\n\u2502   \u2514\u2500\u2500 io.py        # File I/O operations\n\u251c\u2500\u2500 normalizers/     # Normalization implementations\n\u2502   \u251c\u2500\u2500 individual/  # Single-image methods (FCM, Z-score, etc.)\n\u2502   \u2514\u2500\u2500 population/  # Multi-image methods (Ny\u00fal, LSQ)\n\u251c\u2500\u2500 services/        # Application services\n\u2502   \u251c\u2500\u2500 normalization.py # Orchestration logic\n\u2502   \u2514\u2500\u2500 validation.py    # Input validation\n\u2514\u2500\u2500 cli.py          # Command-line interface\n```\n\n## Advanced Usage\n\n### Custom Normalizers\n\n```python\nfrom intensity_normalization.domain.protocols import BaseNormalizer\nfrom intensity_normalization.domain.protocols import ImageProtocol\n\nclass CustomNormalizer(BaseNormalizer):\n    def fit(self, image: ImageProtocol, mask=None) -> 'CustomNormalizer':\n        # Implement fitting logic\n        self.is_fitted = True\n        return self\n\n    def transform(self, image: ImageProtocol, mask=None) -> ImageProtocol:\n        # Implement normalization logic\n        data = image.get_data()\n        normalized_data = your_normalization_function(data)\n        return image.with_data(normalized_data)\n```\n\n### Configuration-Based Workflow\n\n```python\nfrom intensity_normalization.domain.models import NormalizationConfig, Modality, TissueType\nfrom intensity_normalization.services.normalization import NormalizationService\n\n# Create configuration\nconfig = NormalizationConfig(\n    method=\"fcm\",\n    modality=Modality.T1,\n    tissue_type=TissueType.WM\n)\n\n# Validate configuration\nfrom intensity_normalization.services import ValidationService\nValidationService.validate_normalization_config(config)\n\n# Apply normalization\nresult = NormalizationService.normalize_image(image, config, mask)\n```\n\n### Batch Processing\n\n```python\nfrom pathlib import Path\nfrom intensity_normalization.adapters.images import create_image, save_image\nfrom intensity_normalization.services.normalization import NormalizationService\n\ndef process_directory(input_dir: Path, output_dir: Path, method: str = \"fcm\"):\n    \"\"\"Process all NIfTI files in a directory.\"\"\"\n    output_dir.mkdir(exist_ok=True)\n\n    for img_file in input_dir.glob(\"*.nii.gz\"):\n        # Load image\n        image = create_image(img_file)\n\n        # Create configuration\n        config = NormalizationConfig(method=method)\n\n        # Normalize\n        normalized = NormalizationService.normalize_image(image, config)\n\n        # Save result\n        output_file = output_dir / f\"{img_file.stem}_normalized.nii.gz\"\n        save_image(normalized, output_file)\n        print(f\"Processed: {img_file.name}\")\n\n# Usage\nprocess_directory(Path(\"raw_images/\"), Path(\"normalized/\"))\n```\n\n## Development\n\n### Setup Development Environment\n\n```bash\n# Clone and setup\ngit clone https://github.com/jcreinhold/intensity-normalization.git\ncd intensity-normalization\n\n# Install uv (modern Python package manager)\ncurl -LsSf https://astral.sh/uv/install.sh | sh\n\n# Create virtual environment and install dependencies\nuv sync --dev\n```\n\n### Code Quality\n\n```bash\n# Format code\nuv run ruff format intensity_normalization/\n\n# Lint code\nuv run ruff check intensity_normalization/\n\n# Type checking\nuv run mypy intensity_normalization/\n\n# Run tests\nuv run pytest\n\n# Run tests with coverage\nuv run pytest --cov=intensity_normalization --cov-report=html\n```\n\n### Contributing\n\n1. Fork the repository\n2. Create a feature branch (`git checkout -b feature/amazing-feature`)\n3. Make changes and add tests\n4. Ensure code quality (`uv run ruff format && uv run ruff check --fix && uv run mypy`)\n5. Run tests (`uv run pytest`)\n6. Commit changes (`git commit -m 'Add amazing feature'`)\n7. Push to branch (`git push origin feature/amazing-feature`)\n8. Open a Pull Request\n\n## Citation\n\nIf you use this package in your research, please cite:\n\n```bibtex\n@inproceedings{reinhold2019evaluating,\n  title={Evaluating the impact of intensity normalization on {MR} image synthesis},\n  author={Reinhold, Jacob C and Dewey, Blake E and Carass, Aaron and Prince, Jerry L},\n  booktitle={Medical Imaging 2019: Image Processing},\n  volume={10949},\n  pages={109493H},\n  year={2019},\n  organization={International Society for Optics and Photonics}}\n```\n\n## Related Papers\n\n- **FCM**: Udupa, J.K., et al. \"A framework for evaluating image segmentation algorithms.\" Computerized medical imaging and graphics 30.2 (2006): 75-87.\n- **Ny\u00fal**: Ny\u00fal, L.G., Udupa, J.K. \"On standardizing the MR image intensity scale.\" Magnetic Resonance in Medicine 42.6 (1999): 1072-1081.\n- **WhiteStripe**: Shinohara, R.T., et al. \"Statistical normalization techniques for magnetic resonance imaging.\" NeuroImage 132 (2016): 174-184.\n\n## Support\n\n- **Issues**: [GitHub Issues](https://github.com/jcreinhold/intensity-normalization/issues)\n- **Discussions**: [GitHub Discussions](https://github.com/jcreinhold/intensity-normalization/discussions)\n",
    "bugtrack_url": null,
    "license": "MIT License\n        \n        Copyright (c) 2025 Jacob Reinhold\n        \n        Permission is hereby granted, free of charge, to any person obtaining a copy\n        of this software and associated documentation files (the \"Software\"), to deal\n        in the Software without restriction, including without limitation the rights\n        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n        copies of the Software, and to permit persons to whom the Software is\n        furnished to do so, subject to the following conditions:\n        \n        The above copyright notice and this permission notice shall be included in all\n        copies or substantial portions of the Software.\n        \n        THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n        SOFTWARE.",
    "summary": "Normalize intensities of MR image modalities",
    "version": "3.0.0",
    "project_urls": {
        "Documentation": "https://intensity-normalization.readthedocs.io/",
        "Homepage": "https://github.com/jcreinhold/intensity-normalization",
        "Issues": "https://github.com/jcreinhold/intensity-normalization/issues",
        "Repository": "https://github.com/jcreinhold/intensity-normalization"
    },
    "split_keywords": [],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "b10518479b583884af2843625c152bb590d2e6a84c5963d083f6420205ae594b",
                "md5": "0c1b6fbc3a601dca74686111ac1bd857",
                "sha256": "b194f599c6221c42034e063cb62da44c3df07de0672448115530bd0fbeabd356"
            },
            "downloads": -1,
            "filename": "intensity_normalization-3.0.0-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "0c1b6fbc3a601dca74686111ac1bd857",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.11",
            "size": 27985,
            "upload_time": "2025-07-11T01:54:23",
            "upload_time_iso_8601": "2025-07-11T01:54:23.102231Z",
            "url": "https://files.pythonhosted.org/packages/b1/05/18479b583884af2843625c152bb590d2e6a84c5963d083f6420205ae594b/intensity_normalization-3.0.0-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "3d30afa3d457699ac935a3f3dffcf06d13e91e71f0621b95e4e9e5daff835636",
                "md5": "9a03bb111046eac7f7a6d1faead9d971",
                "sha256": "efe71a01c7943990eb48ba08276e929af006a8ccd5214e4df83b8896473c9459"
            },
            "downloads": -1,
            "filename": "intensity_normalization-3.0.0.tar.gz",
            "has_sig": false,
            "md5_digest": "9a03bb111046eac7f7a6d1faead9d971",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.11",
            "size": 50748,
            "upload_time": "2025-07-11T01:54:24",
            "upload_time_iso_8601": "2025-07-11T01:54:24.535699Z",
            "url": "https://files.pythonhosted.org/packages/3d/30/afa3d457699ac935a3f3dffcf06d13e91e71f0621b95e4e9e5daff835636/intensity_normalization-3.0.0.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-07-11 01:54:24",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "jcreinhold",
    "github_project": "intensity-normalization",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": true,
    "lcname": "intensity-normalization"
}