predtiler 0.0.1__tar.gz

predtiler-0.0.1/.github/pull_request_template.md

@@ -0,0 +1,39 @@
+### Description
+
+Please provide a brief description of the changes in this PR. Include any relevant context or background information.
+
+- **What**: Clearly and concisely describe what changes you have made.
+- **Why**: Explain the reasoning behind these changes. 
+- **How**: Describe how you implemented these changes.
+
+### Changes Made
+
+- **Added**: List new features or files added.
+- **Modified**: Describe existing features or files modified.
+- **Removed**: Detail features or files that were removed.
+
+### Related Issues
+
+Link to any related issues or discussions. Use keywords like "Fixes", "Resolves", or "Closes" to link to issues automatically.
+
+- Fixes #
+- Resolves #
+- Closes #
+
+### Breaking changes
+
+Describe any breaking change.
+
+
+### Additional Notes and Examples
+
+Include any additional notes or context that reviewers should be aware of, including snippets of code illustrating your new feature.
+
+---
+
+**Please ensure your PR meets the following requirements:**
+
+- [ ] Code builds and passes tests locally, including doctests
+- [ ] New tests have been added (for bug fixes/features)
+- [ ] Pre-commit passes
+- [ ] PR to the documentation exists (for bug fixes / features)

predtiler-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,91 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  pull_request:
+  workflow_dispatch:
+  schedule:
+    # run every week (for --pre release tests)
+    - cron: "0 0 * * 0"
+
+jobs:
+  check-manifest:
+    # check-manifest is a tool that checks that all files in version control are
+    # included in the sdist (unless explicitly excluded)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - run: pipx run check-manifest
+
+  test:
+    name: ${{ matrix.platform }} (${{ matrix.python-version }})
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        # https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories
+        platform: [ubuntu-latest, macos-13, windows-latest]
+
+    steps:
+      - name: 🛑 Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@0.11.0
+        with:
+          access_token: ${{ github.token }}
+
+      - uses: actions/checkout@v3
+
+      - name: 🐍 Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache-dependency-path: "pyproject.toml"
+          cache: "pip"
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install -U pip
+          # if running a cron job, we add the --pre flag to test against pre-releases
+          python -m pip install ".[dev]" ${{ github.event_name == 'schedule' && '--pre' || ''  }}
+
+      - name: 🧪 Run Tests
+        run: pytest
+
+  deploy:
+    name: Release
+    needs: test
+    if: success() && startsWith(github.ref, 'refs/tags/') && github.event_name != 'schedule'
+    runs-on: ubuntu-latest
+
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+      # This permission allows writing releases
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
+      - name: Build
+        run: |
+          python -m pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true

predtiler-0.0.1/.github/workflows/coverage.yml

@@ -0,0 +1,48 @@
+name: Coverage
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  pull_request:
+
+jobs:
+
+  test:
+    name: ${{ matrix.platform }} (${{ matrix.python-version }})
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10"]
+        platform: [ubuntu-latest]
+
+    steps:
+      - name: 🛑 Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@0.11.0
+        with:
+          access_token: ${{ github.token }}
+
+      - uses: actions/checkout@v3
+
+      - name: 🐍 Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache-dependency-path: "pyproject.toml"
+          cache: "pip"
+
+      - name: Install Dependencies
+        run: |
+          python -m pip install -U pip
+          python -m pip install -e ".[dev]"
+
+      - name: 🧪 Run Tests
+        run: pytest --color=yes --cov --cov-config=pyproject.toml --cov-report=xml --cov-report=term-missing 
+
+      - name: Coverage
+        uses: codecov/codecov-action@v3
+        with:
+          version: v0.7.3

predtiler-0.0.1/.gitignore

@@ -0,0 +1,168 @@
+# VSCode
+.vscode
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff
+.ruff_cache

predtiler-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ashesh
+
+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.

predtiler-0.0.1/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.3
+Name: predtiler
+Version: 0.0.1
+Summary: Converting your dataset class into a class that can be used for tiled prediction and eventually obtain stiched prediction.
+Project-URL: homepage, https://github.com/ashesh-0/PredTiler
+Project-URL: repository, https://github.com/ashesh-0/PredTiler
+Author: Ashesh
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: sybil; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: jupyter; extra == 'examples'
+Requires-Dist: matplotlib; extra == 'examples'
+Description-Content-Type: text/markdown
+
+A lean wrapper around your dataset class to enable tiled prediction. 
+
+[![License](https://img.shields.io/badge/license-MIT-blue)](https://github.com/ashesh-0/PredTiler/blob/main/LICENSE)
+[![CI](https://github.com/ashesh-0/PredTiler/actions/workflows/ci.yml/badge.svg)](https://github.com/ashesh-0/PredTiler/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/ashesh-0/PredTiler/graph/badge.svg?token=M655MOS7EL)](https://codecov.io/gh/ashesh-0/PredTiler)
+
+## Objective
+This package subclasses the dataset class you use to train your network.
+With PredTiler, you can use your dataset class as is, and PredTiler will take care of the tiling logic for you. 
+It will automatically generate patches in such a way that they can be tiled with the overlap of `(patch_size - tile_size)//2`. 
+We also provide a function to stitch the tiles back together to get the final prediction. 
+
+In case you are facing issues, feel free to raise an issue and I will be happy to help you out ! 
+In future, I plan to add detailed instructions for:
+1. multi-channel data
+2. 3D data
+3. Data being a list of numpy arrays, each poissibly having different shapes.
+
+## Installation
+
+```bash
+pip install predtiler
+```
+
+## Usage
+To work with PredTiler, the only requirement is that your dataset class must have a **patch_location(self, index)** method that returns the location of the patch at the given index. 
+Your dataset class should only use the location information returned by this method to return the patch. 
+PredTiler will override this method to return the location of the patches needed for tiled prediction. 
+
+Note that your dataset class could be arbitrarily complex (augmentations, returning multiple patches, working with 3D data, etc.). The only requirement is that it should use the crop present at the location returned by **patch_location** method. Below is an example of a simple dataset class that can be used with PredTiler.
+
+```python
+class YourDataset:
+    def __init__(self, data_path, patch_size=64) -> None:
+        self.patch_size = patch_size
+        self.data = load_data(data_path) # shape: (N, H, W, C)
+
+    def patch_location(self, index:int)-> Tuple[int, int, int]:
+        # it just ignores the index and returns a random location
+        n_idx = np.random.randint(0,len(self.data))
+        h = np.random.randint(0, self.data.shape[1]-self.patch_size)
+        w = np.random.randint(0, self.data.shape[2]-self.patch_size)
+        return (n_idx, h, w)
+    
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        n_idx, h, w = self.patch_location(index)
+        # return the patch at the location (patch_size, patch_size)
+        return self.data[n_idx, h:h+self.patch_size, w:w+self.patch_size]
+```
+
+## Getting overlapping patches needed for tiled prediction
+To use PredTiler, we need to get a new class that wraps around your dataset class.
+For this we also need a tile manager that will manage the tiles.
+
+```python
+
+from predtiler.dataset import get_tiling_dataset, get_tile_manager
+patch_size = 256
+tile_size = 128
+data_shape = (10, 2048, 2048) # size of the data you are working with
+manager = get_tile_manager(data_shape=data_shape, tile_shape=(1,tile_size,tile_size), 
+                               patch_shape=(1,patch_size,patch_size))
+    
+dset_class = get_tiling_dataset(YourDataset, manager)
+```
+
+At this point, you can use the `dset_class` as you would use `YourDataset` class. 
+
+```python
+data_path = ... # path to your data
+dset = dset_class(data_path, patch_size=patch_size)
+```
+
+## Stitching the predictions
+The benefit of using PredTiler is that it will automatically generate the patches in such a way that they can be tiled with the overlap of `(patch_size - tile_size)//2`. This allows you to use your dataset class as is, without worrying about the tiling logic.
+
+```python
+model = ... # your model
+predictions = []
+for i in range(len(dset)):
+    inp = dset[i]
+    inp = torch.Tensor(inp)[None,None]
+    pred = model(inp)
+    predictions.append(pred[0].numpy())
+
+predictions = np.stack(predictions) # shape: (number_of_patches, C, patch_size, patch_size)
+stitched_pred = stitch_predictions(predictions, dset.tile_manager)
+```
+
+

predtiler-0.0.1/README.md

@@ -0,0 +1,93 @@
+A lean wrapper around your dataset class to enable tiled prediction. 
+
+[![License](https://img.shields.io/badge/license-MIT-blue)](https://github.com/ashesh-0/PredTiler/blob/main/LICENSE)
+[![CI](https://github.com/ashesh-0/PredTiler/actions/workflows/ci.yml/badge.svg)](https://github.com/ashesh-0/PredTiler/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/ashesh-0/PredTiler/graph/badge.svg?token=M655MOS7EL)](https://codecov.io/gh/ashesh-0/PredTiler)
+
+## Objective
+This package subclasses the dataset class you use to train your network.
+With PredTiler, you can use your dataset class as is, and PredTiler will take care of the tiling logic for you. 
+It will automatically generate patches in such a way that they can be tiled with the overlap of `(patch_size - tile_size)//2`. 
+We also provide a function to stitch the tiles back together to get the final prediction. 
+
+In case you are facing issues, feel free to raise an issue and I will be happy to help you out ! 
+In future, I plan to add detailed instructions for:
+1. multi-channel data
+2. 3D data
+3. Data being a list of numpy arrays, each poissibly having different shapes.
+
+## Installation
+
+```bash
+pip install predtiler
+```
+
+## Usage
+To work with PredTiler, the only requirement is that your dataset class must have a **patch_location(self, index)** method that returns the location of the patch at the given index. 
+Your dataset class should only use the location information returned by this method to return the patch. 
+PredTiler will override this method to return the location of the patches needed for tiled prediction. 
+
+Note that your dataset class could be arbitrarily complex (augmentations, returning multiple patches, working with 3D data, etc.). The only requirement is that it should use the crop present at the location returned by **patch_location** method. Below is an example of a simple dataset class that can be used with PredTiler.
+
+```python
+class YourDataset:
+    def __init__(self, data_path, patch_size=64) -> None:
+        self.patch_size = patch_size
+        self.data = load_data(data_path) # shape: (N, H, W, C)
+
+    def patch_location(self, index:int)-> Tuple[int, int, int]:
+        # it just ignores the index and returns a random location
+        n_idx = np.random.randint(0,len(self.data))
+        h = np.random.randint(0, self.data.shape[1]-self.patch_size)
+        w = np.random.randint(0, self.data.shape[2]-self.patch_size)
+        return (n_idx, h, w)
+    
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        n_idx, h, w = self.patch_location(index)
+        # return the patch at the location (patch_size, patch_size)
+        return self.data[n_idx, h:h+self.patch_size, w:w+self.patch_size]
+```
+
+## Getting overlapping patches needed for tiled prediction
+To use PredTiler, we need to get a new class that wraps around your dataset class.
+For this we also need a tile manager that will manage the tiles.
+
+```python
+
+from predtiler.dataset import get_tiling_dataset, get_tile_manager
+patch_size = 256
+tile_size = 128
+data_shape = (10, 2048, 2048) # size of the data you are working with
+manager = get_tile_manager(data_shape=data_shape, tile_shape=(1,tile_size,tile_size), 
+                               patch_shape=(1,patch_size,patch_size))
+    
+dset_class = get_tiling_dataset(YourDataset, manager)
+```
+
+At this point, you can use the `dset_class` as you would use `YourDataset` class. 
+
+```python
+data_path = ... # path to your data
+dset = dset_class(data_path, patch_size=patch_size)
+```
+
+## Stitching the predictions
+The benefit of using PredTiler is that it will automatically generate the patches in such a way that they can be tiled with the overlap of `(patch_size - tile_size)//2`. This allows you to use your dataset class as is, without worrying about the tiling logic.
+
+```python
+model = ... # your model
+predictions = []
+for i in range(len(dset)):
+    inp = dset[i]
+    inp = torch.Tensor(inp)[None,None]
+    pred = model(inp)
+    predictions.append(pred[0].numpy())
+
+predictions = np.stack(predictions) # shape: (number_of_patches, C, patch_size, patch_size)
+stitched_pred = stitch_predictions(predictions, dset.tile_manager)
+```
+
+

predtiler-0.0.1/pyproject.toml

@@ -0,0 +1,165 @@
+# https://peps.python.org/pep-0517/
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+# read more about configuring hatch at:
+# https://hatch.pypa.io/latest/config/build/
+
+# https://hatch.pypa.io/latest/config/metadata/
+[tool.hatch.version]
+source = "vcs" # use tags for versioning (e.g. tag v0.1.0, v0.2.0 etc.)
+
+[tool.hatch.build.targets.wheel]
+only-include = ["src"]
+sources = ["src"]
+
+# https://peps.python.org/pep-0621/
+[project]
+name = "predtiler"
+version = "0.0.1"
+description = "Converting your dataset class into a class that can be used for tiled prediction and eventually obtain stiched prediction."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = 'Ashesh' },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Typing :: Typed",
+]
+dependencies = [
+    "numpy",
+]
+
+[project.optional-dependencies]
+# development dependencies and tooling
+dev = [
+    "pre-commit",
+    "pytest",
+    "pytest-cov",
+    "sybil",      # doctesting
+]
+
+# examples
+examples = ["jupyter", "matplotlib"]
+
+[project.urls]
+homepage = "https://github.com/ashesh-0/PredTiler"
+repository = "https://github.com/ashesh-0/PredTiler"
+
+# https://beta.ruff.rs/docs
+[tool.ruff]
+line-length = 88
+target-version = "py39"
+src = ["src"]
+lint.select = [
+    "E",  # style errors
+    "W",  # style warnings
+    "F",  # flakes
+    "D",  # pydocstyle
+    "I",  # isort
+    "UP", # pyupgrade
+    # "S",    # bandit
+    "C4",   # flake8-comprehensions
+    "B",    # flake8-bugbear
+    "A001", # flake8-builtins
+    "RUF",  # ruff-specific rules
+]
+lint.ignore = [
+    "D100", # Missing docstring in public module
+    "D107", # Missing docstring in __init__
+    "D203", # 1 blank line required before class docstring
+    "D212", # Multi-line docstring summary should start at the first line
+    "D213", # Multi-line docstring summary should start at the second line
+    "D401", # First line should be in imperative mood
+    "D413", # Missing blank line after last section
+    "D416", # Section name should end with a colon
+
+    # incompatibility with mypy
+    "RUF005", # collection-literal-concatenation, in prediction_utils.py:30
+
+    # version specific
+    "UP007", # Replace Union by |, mandatory for py3.9
+]
+show-fixes = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*.py" = ["D", "S"]
+"setup.py" = ["D"]
+
+[tool.black]
+line-length = 88
+
+# https://mypy.readthedocs.io/en/stable/config_file.html
+[tool.mypy]
+files = "src/**/"
+strict = false
+# allow_untyped_defs = false
+# allow_untyped_calls = false
+# disallow_any_generics = false
+# ignore_missing_imports = false
+
+
+# https://docs.pytest.org/en/6.2.x/customize.html
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = ["tests"] # add src/careamics for doctest discovery
+filterwarnings = [
+    # "error",
+    # "ignore::UserWarning",
+]
+addopts = "-p no:doctest"
+
+
+# https://coverage.readthedocs.io/en/6.4/config.html
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "@overload",
+    "except ImportError",
+    "\\.\\.\\.",
+    "raise NotImplementedError()",
+]
+
+
+[tool.coverage.run]
+source = ["src/microssim"]
+
+# https://github.com/mgedmin/check-manifest#configuration
+# add files that you want check-manifest to explicitly ignore here
+# (files that are in the repo but shouldn't go in the package)
+[tool.check-manifest]
+ignore = [
+    ".github_changelog_generator",
+    ".pre-commit-config.yaml",
+    ".ruff_cache/**/*",
+    "setup.py",
+    "tests/**/*",
+]
+
+[tool.numpydoc_validation]
+checks = [
+    "all",  # report on all checks, except the below
+    "EX01", # Example section not found
+    "SA01", # See Also section not found
+    "ES01", # Extended Summar not found
+    "GL01", # Docstring text (summary) should start in the line immediately
+    # after the opening quotes
+    "GL02", # Closing quotes should be placed in the line after the last text 
+    # in the docstring
+    "GL03", # Double line break found
+]
+exclude = [ # don't report on objects that match any of these regex
+    "test_*",
+]

predtiler-0.0.1/src/predtiler/dataset.py

@@ -0,0 +1,53 @@
+
+from predtiler.tile_manager import TileIndexManager, TilingMode
+
+# class TilingDataset:
+#     def __init_subclass__(cls, parent_class=None, tile_manager=None, **kwargs):
+#         super().__init_subclass__(**kwargs)
+#         assert tile_manager is not None, 'tile_manager must be provided'
+#         cls.tile_manager = tile_manager
+#         if parent_class is not None:
+#             has_callable_method = callable(getattr(parent_class, 'patch_location', None))
+#             assert has_callable_method, f'{parent_class.__name__} must have a callable method with following signature: def patch_location(self, index)'
+#             cls.__bases__ = (parent_class,) + cls.__bases__
+
+#     def __len__(self):
+#         return self.tile_manager.total_grid_count()
+
+#     def patch_location(self, index):
+#         print('Calling patch_location')
+#         patch_loc_list = self.tile_manager.get_patch_location_from_dataset_idx(index)
+#         return patch_loc_list
+    
+
+# def get_tiling_dataset(dataset_class, tile_manager) -> type:
+#     class CorrespondingTilingDataset(TilingDataset, parent_class=dataset_class, tile_manager=tile_manager):
+#         pass
+    
+#     return CorrespondingTilingDataset
+
+def get_tiling_dataset(dataset_class, tile_manager) -> type:
+    has_callable_method = callable(getattr(dataset_class, 'patch_location', None))
+    assert has_callable_method, f'{dataset_class.__name__} must have a callable method with following signature: def patch_location(self, index)'
+
+    class TilingDataset(dataset_class):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.tile_manager = tile_manager
+
+        def __len__(self):
+            return self.tile_manager.total_grid_count()
+
+        def patch_location(self, index):
+            patch_loc_list = self.tile_manager.get_patch_location_from_dataset_idx(index)
+            return patch_loc_list
+    
+    return TilingDataset
+    
+
+
+
+def get_tile_manager(data_shape, tile_shape, patch_shape, tiling_mode=TilingMode.ShiftBoundary):
+    return TileIndexManager(data_shape, tile_shape, patch_shape, tiling_mode)
+
+

predtiler-0.0.1/src/predtiler/tile_manager.py

@@ -0,0 +1,210 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+
+class TilingMode:
+    """
+    Enum for the tiling mode.
+    """
+    TrimBoundary = 0
+    PadBoundary = 1
+    ShiftBoundary = 2
+
+@dataclass
+class TileIndexManager:
+    data_shape: tuple
+    grid_shape: tuple
+    patch_shape: tuple
+    tiling_mode: TilingMode
+
+    def __post_init__(self):
+        assert len(self.data_shape) == len(self.grid_shape), f"Data shape:{self.data_shape} and grid size:{self.grid_shape} must have the same dimension"
+        assert len(self.data_shape) == len(self.patch_shape), f"Data shape:{self.data_shape} and patch shape:{self.patch_shape} must have the same dimension"
+        innerpad = np.array(self.patch_shape) - np.array(self.grid_shape)
+        for dim, pad in enumerate(innerpad):
+            if pad < 0:
+                raise ValueError(f"Patch shape:{self.patch_shape} must be greater than or equal to grid shape:{self.grid_shape} in dimension {dim}")
+            if pad % 2 != 0:
+                raise ValueError(f"Patch shape:{self.patch_shape} must have even padding in dimension {dim}")
+
+    def patch_offset(self):
+        return (np.array(self.patch_shape) - np.array(self.grid_shape))//2
+    
+    def get_individual_dim_grid_count(self, dim:int):
+        """
+        Returns the number of the grid in the specified dimension, ignoring all other dimensions.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+
+        if self.grid_shape[dim]==1 and self.patch_shape[dim]==1:
+            return self.data_shape[dim]
+        elif self.tiling_mode == TilingMode.PadBoundary:
+            return int(np.ceil(self.data_shape[dim] / self.grid_shape[dim]))
+        elif self.tiling_mode == TilingMode.ShiftBoundary:
+            excess_size = self.patch_shape[dim] - self.grid_shape[dim]
+            return int(np.ceil((self.data_shape[dim] - excess_size) / self.grid_shape[dim]))
+        else:
+            excess_size = self.patch_shape[dim] - self.grid_shape[dim]
+            return int(np.floor((self.data_shape[dim] - excess_size) / self.grid_shape[dim]))
+    
+    def total_grid_count(self):
+        """
+        Returns the total number of grids in the dataset.
+        """
+        return self.grid_count(0) * self.get_individual_dim_grid_count(0)
+    
+    def grid_count(self, dim:int):
+        """
+        Returns the total number of grids for one value in the specified dimension.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        if dim == len(self.data_shape)-1:
+            return 1
+        
+        return self.get_individual_dim_grid_count(dim+1) * self.grid_count(dim+1)
+    
+    def get_grid_index(self, dim:int, coordinate:int):
+        """
+        Returns the index of the grid in the specified dimension.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        assert coordinate < self.data_shape[dim], f"Coordinate {coordinate} is out of bounds for data shape {self.data_shape}"
+
+        if self.grid_shape[dim]==1 and self.patch_shape[dim]==1:
+            return coordinate
+        elif self.tiling_mode == TilingMode.PadBoundary: #self.trim_boundary is False:
+            return np.floor(coordinate / self.grid_shape[dim])
+        elif self.tiling_mode == TilingMode.TrimBoundary:
+            excess_size = (self.patch_shape[dim] - self.grid_shape[dim])//2
+            # can be <0 if coordinate is in [0,grid_shape[dim]]
+            return max(0, np.floor((coordinate - excess_size) / self.grid_shape[dim]))
+        elif self.tiling_mode == TilingMode.ShiftBoundary:
+            excess_size = (self.patch_shape[dim] - self.grid_shape[dim])//2
+            if coordinate + self.grid_shape[dim] + excess_size == self.data_shape[dim]:
+                return self.get_individual_dim_grid_count(dim) - 1
+            else:
+                # can be <0 if coordinate is in [0,grid_shape[dim]]
+                return max(0, np.floor((coordinate - excess_size) / self.grid_shape[dim]))
+
+        else:
+            raise ValueError(f"Unsupported tiling mode {self.tiling_mode}")
+        
+    def dataset_idx_from_grid_idx(self, grid_idx:tuple):
+        """
+        Returns the index of the grid in the dataset.
+        """
+        assert len(grid_idx) == len(self.data_shape), f"Dimension indices {grid_idx} must have the same dimension as data shape {self.data_shape}"
+        index = 0
+        for dim in range(len(grid_idx)):
+            index += grid_idx[dim] * self.grid_count(dim)
+        return index
+    
+    def get_patch_location_from_dataset_idx(self, dataset_idx:int):
+        """
+        Returns the patch location of the grid in the dataset.
+        """
+        grid_location = self.get_location_from_dataset_idx(dataset_idx)
+        offset = self.patch_offset()
+        return tuple(np.array(grid_location) - np.array(offset))
+
+    
+    def get_dataset_idx_from_grid_location(self, location:tuple):
+        assert len(location) == len(self.data_shape), f"Location {location} must have the same dimension as data shape {self.data_shape}"
+        grid_idx = [self.get_grid_index(dim, location[dim]) for dim in range(len(location))]
+        return self.dataset_idx_from_grid_idx(tuple(grid_idx))
+    
+    def get_gridstart_location_from_dim_index(self, dim:int, dim_index:int):
+        """
+        Returns the grid-start coordinate of the grid in the specified dimension.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        assert dim_index < self.get_individual_dim_grid_count(dim), f"Dimension index {dim_index} is out of bounds for data shape {self.data_shape}"
+
+        if self.grid_shape[dim]==1 and self.patch_shape[dim]==1:
+            return dim_index
+        elif self.tiling_mode == TilingMode.PadBoundary:
+            return dim_index * self.grid_shape[dim]
+        elif self.tiling_mode == TilingMode.TrimBoundary:
+            excess_size = (self.patch_shape[dim] - self.grid_shape[dim])//2
+            return dim_index * self.grid_shape[dim] + excess_size
+        elif self.tiling_mode == TilingMode.ShiftBoundary:
+            excess_size = (self.patch_shape[dim] - self.grid_shape[dim])//2
+            if dim_index < self.get_individual_dim_grid_count(dim) - 1:
+                return dim_index * self.grid_shape[dim] + excess_size
+            else:
+                # on boundary. grid should be placed such that the patch covers the entire data.
+                return self.data_shape[dim] - self.grid_shape[dim] - excess_size
+        else:
+            raise ValueError(f"Unsupported tiling mode {self.tiling_mode}")
+ 
+    def get_location_from_dataset_idx(self, dataset_idx:int):
+        """
+        Returns the start location of the grid in the dataset.
+        """
+        grid_idx = []
+        for dim in range(len(self.data_shape)):
+            grid_idx.append(dataset_idx // self.grid_count(dim))
+            dataset_idx = dataset_idx % self.grid_count(dim)
+        location = [self.get_gridstart_location_from_dim_index(dim, grid_idx[dim]) for dim in range(len(self.data_shape))]
+        return tuple(location)
+    
+    def on_boundary(self, dataset_idx:int, dim:int, only_end:bool=False):
+        """
+        Returns True if the grid is on the boundary in the specified dimension.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        
+        if dim > 0:
+            dataset_idx = dataset_idx % self.grid_count(dim-1)
+
+        dim_index = dataset_idx // self.grid_count(dim)
+        if only_end:
+            return dim_index == self.get_individual_dim_grid_count(dim) - 1
+        
+        return dim_index == 0 or dim_index == self.get_individual_dim_grid_count(dim) - 1
+    
+    def next_grid_along_dim(self, dataset_idx:int, dim:int):
+        """
+        Returns the index of the grid in the specified dimension in the specified direction.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        new_idx = dataset_idx + self.grid_count(dim)
+        if new_idx >= self.total_grid_count():
+            return None
+        return new_idx
+    
+    def prev_grid_along_dim(self, dataset_idx:int, dim:int):
+        """
+        Returns the index of the grid in the specified dimension in the specified direction.
+        """
+        assert dim < len(self.data_shape), f"Dimension {dim} is out of bounds for data shape {self.data_shape}"
+        assert dim >= 0, "Dimension must be greater than or equal to 0"
+        new_idx = dataset_idx - self.grid_count(dim)
+        if new_idx < 0:
+            return None
+
+if __name__ == '__main__':
+    # data_shape =   (1, 5, 103, 103,2)
+    # grid_shape =   (1, 1, 16,16, 2)
+    # patch_shape =  (1, 3, 32, 32, 2)
+    data_shape = (5, 5, 64, 64, 2)
+    grid_shape = (1, 1, 8, 8, 2)
+    patch_shape = (1, 3, 16, 16, 2)
+    tiling_mode = TilingMode.ShiftBoundary
+    manager = TileIndexManager(data_shape, grid_shape, patch_shape, tiling_mode)
+    gc = manager.total_grid_count()
+    for i in range(gc):
+        loc = manager.get_location_from_dataset_idx(i)
+        print(i, loc)
+        inferred_i = manager.get_dataset_idx_from_grid_location(loc)
+        assert i == inferred_i, f"Index mismatch: {i} != {inferred_i}"
+    
+    for i in range(5):
+        print(manager.on_boundary(40, i))

predtiler-0.0.1/src/predtiler/tile_stitcher.py

@@ -0,0 +1,65 @@
+from typing import List
+
+import numpy as np
+
+from predtiler.tile_manager import TilingMode
+
+
+def stitch_predictions(predictions:np.ndarray, manager):
+    """
+    Args:
+        predictions: N*C*H*W or N*C*D*H*W numpy array where N is the number of datasets, C is the number of channels, H is the height, W is the width, D is the depth.
+        manager:
+    """
+    
+    mng = manager
+    shape = list(mng.data_shape)
+    shape.append(predictions.shape[1])
+    print(shape)
+
+    output = np.zeros(shape, dtype=predictions.dtype)
+    for dset_idx in range(predictions.shape[0]):
+        # grid start, grid end
+        gs = np.array(mng.get_location_from_dataset_idx(dset_idx), dtype=int)
+        ge = gs + mng.grid_shape
+
+        # patch start, patch end
+        ps = gs - mng.patch_offset()
+        pe = ps + mng.patch_shape
+
+        # valid grid start, valid grid end
+        vgs = np.array([max(0,x) for x in gs], dtype=int)
+        vge = np.array([min(x,y) for x,y in zip(ge, mng.data_shape)], dtype=int)
+        assert np.all(vgs ==gs)
+        assert np.all(vge ==ge)
+        
+        if mng.tiling_mode == TilingMode.ShiftBoundary:
+            for dim in range(len(vgs)):
+                if ps[dim] == 0:
+                    vgs[dim] = 0
+                if pe[dim] == mng.data_shape[dim]:
+                    vge[dim]= mng.data_shape[dim]
+
+        # relative start, relative end. This will be used on pred_tiled
+        rs = vgs - ps
+        re = rs + ( vge - vgs)
+        
+        for ch_idx in range(predictions.shape[1]):
+            if len(output.shape) == 4:
+                # channel dimension is the last one.
+                output[vgs[0]:vge[0],
+                    vgs[1]:vge[1],
+                    vgs[2]:vge[2],
+                    ch_idx] = predictions[dset_idx][ch_idx,rs[1]:re[1], rs[2]:re[2]]
+            elif len(output.shape) == 5:
+                # channel dimension is the last one.
+                assert vge[0] - vgs[0] == 1, 'Only one frame is supported'
+                output[vgs[0],
+                    vgs[1]:vge[1],
+                    vgs[2]:vge[2],
+                    vgs[3]:vge[3],
+                    ch_idx] = predictions[dset_idx][ch_idx, rs[1]:re[1], rs[2]:re[2], rs[3]:re[3]]
+            else:
+                raise ValueError(f'Unsupported shape {output.shape}')
+            
+    return output

predtiler-0.0.1/tests/test_full_tiling_setup.py

@@ -0,0 +1,92 @@
+from unittest.mock import Mock
+import numpy as np
+from predtiler.dataset import get_tiling_dataset, get_tile_manager
+from predtiler.tile_stitcher import stitch_predictions
+
+def get_data_3D(n=5,Z=9, H=512,W=512,C=2):
+    data = np.arange(n*Z*H*W*C).reshape(n,Z,H,W,C)
+    return data
+
+def get_data_2D(n=5,H=512,W=512,C=2):
+    data = np.arange(n*H*W*C).reshape(n,H,W,C)
+    return data
+
+class DummDataset:
+    def __init__(self, datatype ='2D', patch_size=64, z_patch_size=5) -> None:
+        assert datatype in ['2D', '3D'], 'datatype must be either 2D or 3D'
+        self.datatype = datatype
+        self.z_patch_size = z_patch_size
+        self.patch_size = patch_size
+        if datatype == '2D':
+            self.data = get_data_2D()
+        elif datatype == '3D':
+            self.data = get_data_3D()
+
+    def patch_location(self, index):
+        if self.datatype == '2D':
+            n_idx = np.random.randint(0,len(self.data))
+            h = np.random.randint(0, self.data.shape[1]-self.patch_size)
+            w = np.random.randint(0, self.data.shape[2]-self.patch_size)
+            return (n_idx, h, w)
+        elif self.datatype == '3D':
+            n_idx = np.random.randint(0,len(self.data))
+            z = np.random.randint(0, self.data.shape[1]-self.z_patch_size)
+            h = np.random.randint(0, self.data.shape[2]-self.patch_size)
+            w = np.random.randint(0, self.data.shape[3]-self.patch_size)
+            return (n_idx, z, h, w)
+    
+    def __len__(self):
+        return len(self.data) * (self.data.shape[-2]//self.patch_size) * (self.data.shape[-3]//self.patch_size)
+
+    def __getitem__(self, index):
+        if self.datatype == '2D':
+            n_idx, h, w = self.patch_location(index)
+            return self.data[n_idx, h:h+self.patch_size, w:w+self.patch_size].transpose(2,0,1)
+        elif self.datatype == '3D':
+            n_idx, z, h, w = self.patch_location(index)
+            return self.data[n_idx, z:z+self.z_patch_size, h:h+self.patch_size, w:w+self.patch_size].transpose(3,0,1,2)
+
+
+def test_stich_prediction_2D():
+    data_type = '2D'
+    data_fn = get_data_2D
+    patch_size = 256
+    tile_size = 128
+    data = data_fn()
+    manager = get_tile_manager(data_shape=data.shape[:-1], tile_shape=(1,tile_size,tile_size), 
+                               patch_shape=(1,patch_size,patch_size))
+    
+    dset_class = get_tiling_dataset(DummDataset, manager)
+    dset = dset_class(data_type, patch_size)
+    
+    predictions = []
+    for i in range(len(dset)):
+        predictions.append(dset[i])
+    
+    predictions = np.stack(predictions)
+    stitched_pred = stitch_predictions(predictions, dset.tile_manager)
+    assert (stitched_pred== data).all()
+
+
+
+def test_stich_prediction_3D():
+    data_type = '3D'
+    data_fn = get_data_3D
+    patch_size = 256
+    tile_size = 128
+    data = data_fn()
+    z_patch_size = 5
+    z_tile_size = 3
+    manager = get_tile_manager(data_shape=data.shape[:-1], tile_shape=(1,z_tile_size, tile_size,tile_size), 
+                               patch_shape=(1,z_patch_size, patch_size,patch_size))
+    
+    dset_class = get_tiling_dataset(DummDataset, manager)
+    dset = dset_class(data_type, patch_size)
+    
+    predictions = []
+    for i in range(len(dset)):
+        predictions.append(dset[i])
+    
+    predictions = np.stack(predictions)
+    stitched_pred = stitch_predictions(predictions, dset.tile_manager)
+    assert (stitched_pred== data).all()