cornucopia 0.0.0__tar.gz

cornucopia-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Yaël Balbastre
+
+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.

cornucopia-0.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: cornucopia
+Version: 0.0.0
+Summary: An abundance of augmentation layers
+Author-email: Yael Balbastre <yael.balbastre@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/balbasty/cornucopia
+Project-URL: Issues, https://github.com/balbasty/cornucopia/issues
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.8
+Requires-Dist: torch-interpol>=0.3
+Requires-Dist: torch-distmap>=0.3
+Requires-Dist: typing_extensions>=4.7
+Requires-Dist: nibabel
+Provides-Extra: io
+Requires-Dist: nibabel; extra == "io"
+Requires-Dist: pillow; extra == "io"
+Requires-Dist: tifffile; extra == "io"
+Requires-Dist: numpy; extra == "io"
+Provides-Extra: typing
+Requires-Dist: numpy>=1.20; extra == "typing"
+Dynamic: license-file
+
+<picture align="center">
+  <source media="(prefers-color-scheme: dark)" srcset="docs/icons/cornucopia_lightorange.svg">
+  <source media="(prefers-color-scheme: light)"  srcset="docs/icons/cornucopia_orange.svg">
+  <img alt="Cornucopia logo" src="https://github.com/balbasty/cornucopia/raw/main/docs/icons/cornucopia_orange.svg">
+</picture>
+
+The `cornucopia` package provides a generic framework for preprocessing,
+augmentation, and domain randomization; along with an abundance of specific layers,
+mostly targeted at (medical) imaging. `cornucopia` is written using a PyTorch
+backend, and therefore runs **on the CPU or GPU**.
+
+Cornucopia is *intended* to be used on the GPU for on-line augmentation.
+A quick [benchmark](docs/examples/benchmark.ipynb) of affine and elastic augmentation
+shows that while cornucopia is slower than [TorchIO](https://github.com/fepegar/torchio)
+on the CPU (~ 3s vs 1s), it is greatly accelerated on the GPU (~ 50ms).
+
+Since gradients are not expected to backpropagate through its layers, it can
+theoretically be used within any dataloader pipeline,
+independent of the downstream learning framework (pytorch, tensorflow, jax, ...).
+
+## Installation
+
+### Dependencies
+
+- `pytorch >= 1.8`
+- `numpy`
+- `nibabel`
+- `torch-interpol`
+- `torch-distmap`
+
+### Pip (release)
+
+```sh
+pip install cornucopia
+```
+
+### Pip (dev)
+
+```sh
+pip install cornucopia@git+https://github.com/balbasty/cornucopia
+```
+
+## Documentation
+
+Read the [documentation](https://balbasty.github.io/cornucopia) and in particular:
+- [installation](https://balbasty.github.io/cornucopia/install/)
+- [get started](https://balbasty.github.io/cornucopia/start/)
+- [examples](https://balbasty.github.io/cornucopia/examples/)
+- [API](https://balbasty.github.io/cornucopia/api/)
+
+## Other augmentation packages
+
+There are other great, and much more mature, augmentation packages
+out-there (although few run on the GPU). Here's a non-exhaustive list:
+- [MONAI](https://github.com/Project-MONAI/MONAI)
+- [TorchIO](https://github.com/fepegar/torchio)
+- [Albumentations](https://github.com/albumentations-team/albumentations) (2D only)
+- [Volumentations](https://github.com/ZFTurbo/volumentations) (3D extension of Albumentations)
+
+## Contributions
+
+If you find this project useful and wish to contribute, please reach out!

cornucopia-0.0.0/README.md

@@ -0,0 +1,62 @@
+<picture align="center">
+  <source media="(prefers-color-scheme: dark)" srcset="docs/icons/cornucopia_lightorange.svg">
+  <source media="(prefers-color-scheme: light)"  srcset="docs/icons/cornucopia_orange.svg">
+  <img alt="Cornucopia logo" src="https://github.com/balbasty/cornucopia/raw/main/docs/icons/cornucopia_orange.svg">
+</picture>
+
+The `cornucopia` package provides a generic framework for preprocessing,
+augmentation, and domain randomization; along with an abundance of specific layers,
+mostly targeted at (medical) imaging. `cornucopia` is written using a PyTorch
+backend, and therefore runs **on the CPU or GPU**.
+
+Cornucopia is *intended* to be used on the GPU for on-line augmentation.
+A quick [benchmark](docs/examples/benchmark.ipynb) of affine and elastic augmentation
+shows that while cornucopia is slower than [TorchIO](https://github.com/fepegar/torchio)
+on the CPU (~ 3s vs 1s), it is greatly accelerated on the GPU (~ 50ms).
+
+Since gradients are not expected to backpropagate through its layers, it can
+theoretically be used within any dataloader pipeline,
+independent of the downstream learning framework (pytorch, tensorflow, jax, ...).
+
+## Installation
+
+### Dependencies
+
+- `pytorch >= 1.8`
+- `numpy`
+- `nibabel`
+- `torch-interpol`
+- `torch-distmap`
+
+### Pip (release)
+
+```sh
+pip install cornucopia
+```
+
+### Pip (dev)
+
+```sh
+pip install cornucopia@git+https://github.com/balbasty/cornucopia
+```
+
+## Documentation
+
+Read the [documentation](https://balbasty.github.io/cornucopia) and in particular:
+- [installation](https://balbasty.github.io/cornucopia/install/)
+- [get started](https://balbasty.github.io/cornucopia/start/)
+- [examples](https://balbasty.github.io/cornucopia/examples/)
+- [API](https://balbasty.github.io/cornucopia/api/)
+
+## Other augmentation packages
+
+There are other great, and much more mature, augmentation packages
+out-there (although few run on the GPU). Here's a non-exhaustive list:
+- [MONAI](https://github.com/Project-MONAI/MONAI)
+- [TorchIO](https://github.com/fepegar/torchio)
+- [Albumentations](https://github.com/albumentations-team/albumentations) (2D only)
+- [Volumentations](https://github.com/ZFTurbo/volumentations) (3D extension of Albumentations)
+
+## Contributions
+
+If you find this project useful and wish to contribute, please reach out!

cornucopia-0.0.0/cornucopia/__init__.py

@@ -0,0 +1,73 @@
+"""
+Flexible transforms for pre-processing and augmentation
+
+Example on how to use this machinery to generate within-subject
+image pairs with a random affine deformation between them::
+
+    # It's easy to randomize deterministic parameters of a transform
+    rand_chi = trf.RandomizedTransform(
+    trf.ChiNoiseTransform, dict(sigma=trf.Uniform(0.01, 0.3)))
+
+    # SequentialTransform is equivalent to monai's Compose
+    # MappedTransform make sit possible to process only some inputs (the
+    # others are kept untouched)
+    demo_transformer = trf.SequentialTransform([
+        trf.MappedTransform(img=trf.ToTensorTransform(3, dtype=torch.float32),
+                            seg=trf.ToTensorTransform(3, dtype=torch.int64)),
+        trf.MappedTransform(seg=trf.OneHotTransform([1])),
+        trf.MappedTransform(img=trf.QuantileTransform()),
+        trf.MakeAffinePair(trf.RandomAffineTransform()),
+        trf.MappedTransform(img=trf.MultFieldTransform()),
+        trf.MappedTransform(img=rand_chi),
+    ])
+
+    # Apply the workflow
+    img_and_seg, flow_and_mat = demo_transformer(dict(img=dat, seg=lab))
+
+    # Unpile everything
+    img1, img2 = img_and_seg['img']
+    seg1, seg2 = img_and_seg['seg']
+    flow = flow_and_mat['flow']
+
+"""
+
+from . import random                        # noqa: F401
+from . import ctx                           # noqa: F401
+from . import base                          # noqa: F401
+from . import baseutils                     # noqa: F401
+from . import special                       # noqa: F401
+from . import contrast                      # noqa: F401
+from . import geometric                     # noqa: F401
+from . import intensity                     # noqa: F401
+from . import io                            # noqa: F401
+from . import fov                           # noqa: F401
+from . import kspace                        # noqa: F401
+from . import labels                        # noqa: F401
+from . import noise                         # noqa: F401
+from . import psf                           # noqa: F401
+from . import qmri                          # noqa: F401
+from . import synth                         # noqa: F401
+from . import typing                        # noqa: F401
+from . import utils                         # noqa: F401
+
+from .random import *                       # noqa: F401,F403
+from .ctx import *                          # noqa: F401,F403
+from .base import *                         # noqa: F401,F403
+from .special import *                      # noqa: F401,F403
+from .contrast import *                     # noqa: F401,F403
+from .geometric import *                    # noqa: F401,F403
+from .intensity import *                    # noqa: F401,F403
+from .io import *                           # noqa: F401,F403
+from .fov import *                          # noqa: F401,F403
+from .kspace import *                       # noqa: F401,F403
+from .labels import *                       # noqa: F401,F403
+from .noise import *                        # noqa: F401,F403
+from .psf import *                          # noqa: F401,F403
+from .qmri import *                         # noqa: F401,F403
+from .synth import *                        # noqa: F401,F403
+from .utils.patch import patch_apply        # noqa: F401,F403
+
+try:
+    from ._version import __version__
+except ImportError:
+    __version__ = None