rescale4dl 0.1.1__tar.gz

rescale4dl-0.1.1/LICENSE.txt

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2025 rescale4dl
+
+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.

rescale4dl-0.1.1/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: rescale4dl
+Version: 0.1.1
+Summary: My python package package
+Author-email: Mariana G Ferreira <mariana.g.ferreira@itqb.unl.pt>, Bruno Saraiva <bruno.msaraiva2@gmail.com>, Ricardo Henriques <ricardo.jv.henriques@gmail.com>, Estibaliz Gómez-de-Mariscal <esgodema@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: <=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: imageio>=2.33.1
+Requires-Dist: jupyter>=1.1.1
+Requires-Dist: matplotlib>=3.9.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pillow>=11.0.0
+Requires-Dist: pypdf>=4.2.0
+Requires-Dist: scikit-image>=0.22.0
+Requires-Dist: scikit-learn>=1.5.2
+Requires-Dist: scipy>=1.14.1
+Requires-Dist: seaborn>=0.13.2
+Requires-Dist: setuptools>=68.2.2
+Requires-Dist: tifffile>=2024.12.12
+Requires-Dist: nanopyx>=1.0.0
+Provides-Extra: all
+Requires-Dist: rescale4dl[dev,test]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.7.0; extra == "dev"
+Requires-Dist: ipykernel>=6.29.4; extra == "dev"
+Requires-Dist: ruff>=0.4.3; extra == "dev"
+Requires-Dist: gptrepo>=1.0.3; extra == "dev"
+Requires-Dist: pdoc>=12.3.1; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: gptrepo; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=8.2.0; extra == "test"
+Requires-Dist: pytest-xdist>=3.6.1; extra == "test"
+Requires-Dist: pytest-cov>=5.0.0; extra == "test"
+Requires-Dist: nbmake>=1.5.3; extra == "test"
+Requires-Dist: mypy>=1.10.0; extra == "test"
+Dynamic: license-file
+
+# ReScale4DL: Balancing Pixel and Contextual Information for Enhanced Bioimage Segmentation
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+<img src="https://raw.githubusercontent.com/HenriquesLab/ReScale4DL/refs/heads/main/.github/logo.png?token=GHSAT0AAAAAAC5PYSXBX34C76FL7KUWDO62Z7VHF5A" align="right" width="150"/>
+
+A systematic approach for determining optimal image resolution in deep learning-based microscopy segmentation, balancing accuracy with acquisition/storage costs.
+
+## Key Features
+- **Resolution simulation**: Rescale images and their respective annotations (upsample and downsample)
+- **Segmentation evaluation**: Compare performance across resolutions using:
+  - Mean Intersection-over-Union (IoU)
+  - Morphological features
+  - Potential throughput
+  - Personalised metrics
+- **Visualization tools**: Generate comparative plots and sample outputs
+
+## Installation
+
+ReScale4DL is available as a Python package through pip. 
+Activate your conda environment or create one and install it with `pip`:
+
+```terminal
+pip install rescale4dl
+```
+
+### Manual installation
+Manual installation from using GitHub repository
+```terminal
+git clone https://github.com/HenriquesLab/ReScale4DL.git
+cd rescale4dl
+conda create -n rescale4dl "python<=3.12"
+conda activate rescale4dl
+python -m pip install .
+```
+
+
+## Usage
+
+### 1. Image Rescaling
+Notebook: `Rescale_Images.ipynb`
+
+### 2. Segmentation Analysis 
+Notebook: `Evaluate_Segmentation.ipynb`
+
+### 3. Rescale and crop 
+Notebook: `Rescale_Foundation_Models.ipynb`
+
+
+## Contributing
+We welcome contributions through:
+- [Issue reporting](https://github.com/HenriquesLab/ReScale4D/issues)
+- [Pull requests](https://github.com/HenriquesLab/ReScale4D/pulls)
+
+## License
+MIT License - See [LICENSE](LICENSE) for details
+
+## Citation
+If using this work in research, please cite:
+```
+@article{gferreira2025rescale4dl,
+  title={ReScale4DL: Balancing Pixel and Contextual Information for Enhanced Bioimage Segmentation},
+  author={Ferreira, Mariana G. and Saraiva, Bruno M. and Brito, Antonio D. and Pinho, Mariana G. and Henriques, Ricardo and G{\'o}mez-de-Mariscal, Estibaliz },
+  journal={bioRxiv},
+  year={2025},
+  publisher = {Cold Spring Harbor Laboratory},
+  URL = ,
+  eprint = ,
+}
+```
+
+
+
+

rescale4dl-0.1.1/README.md

@@ -0,0 +1,75 @@
+# ReScale4DL: Balancing Pixel and Contextual Information for Enhanced Bioimage Segmentation
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+<img src="https://raw.githubusercontent.com/HenriquesLab/ReScale4DL/refs/heads/main/.github/logo.png?token=GHSAT0AAAAAAC5PYSXBX34C76FL7KUWDO62Z7VHF5A" align="right" width="150"/>
+
+A systematic approach for determining optimal image resolution in deep learning-based microscopy segmentation, balancing accuracy with acquisition/storage costs.
+
+## Key Features
+- **Resolution simulation**: Rescale images and their respective annotations (upsample and downsample)
+- **Segmentation evaluation**: Compare performance across resolutions using:
+  - Mean Intersection-over-Union (IoU)
+  - Morphological features
+  - Potential throughput
+  - Personalised metrics
+- **Visualization tools**: Generate comparative plots and sample outputs
+
+## Installation
+
+ReScale4DL is available as a Python package through pip. 
+Activate your conda environment or create one and install it with `pip`:
+
+```terminal
+pip install rescale4dl
+```
+
+### Manual installation
+Manual installation from using GitHub repository
+```terminal
+git clone https://github.com/HenriquesLab/ReScale4DL.git
+cd rescale4dl
+conda create -n rescale4dl "python<=3.12"
+conda activate rescale4dl
+python -m pip install .
+```
+
+
+## Usage
+
+### 1. Image Rescaling
+Notebook: `Rescale_Images.ipynb`
+
+### 2. Segmentation Analysis 
+Notebook: `Evaluate_Segmentation.ipynb`
+
+### 3. Rescale and crop 
+Notebook: `Rescale_Foundation_Models.ipynb`
+
+
+## Contributing
+We welcome contributions through:
+- [Issue reporting](https://github.com/HenriquesLab/ReScale4D/issues)
+- [Pull requests](https://github.com/HenriquesLab/ReScale4D/pulls)
+
+## License
+MIT License - See [LICENSE](LICENSE) for details
+
+## Citation
+If using this work in research, please cite:
+```
+@article{gferreira2025rescale4dl,
+  title={ReScale4DL: Balancing Pixel and Contextual Information for Enhanced Bioimage Segmentation},
+  author={Ferreira, Mariana G. and Saraiva, Bruno M. and Brito, Antonio D. and Pinho, Mariana G. and Henriques, Ricardo and G{\'o}mez-de-Mariscal, Estibaliz },
+  journal={bioRxiv},
+  year={2025},
+  publisher = {Cold Spring Harbor Laboratory},
+  URL = ,
+  eprint = ,
+}
+```
+
+
+
+

rescale4dl-0.1.1/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rescale4dl"
+version = "0.1.1"
+description = "My python package package"
+authors = [
+    { name = "Mariana G Ferreira", email = "mariana.g.ferreira@itqb.unl.pt" },
+    { name = "Bruno Saraiva", email = "bruno.msaraiva2@gmail.com" },
+    { name = "Ricardo Henriques", email = "ricardo.jv.henriques@gmail.com" },
+    { name = "Estibaliz Gómez-de-Mariscal", email = "esgodema@gmail.com" }
+]
+readme = { file = "README.md", content-type = "text/markdown" }
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent"
+]
+requires-python = "<= 3.12"
+dependencies = [
+  "imageio>=2.33.1",
+  "jupyter>=1.1.1",
+  "matplotlib>=3.9.2",
+  "pandas>=2.2.3",
+  "pillow>=11.0.0",
+  "pypdf>=4.2.0",
+  "scikit-image>=0.22.0",
+  "scikit-learn>=1.5.2",
+  "scipy>=1.14.1",
+  "seaborn>=0.13.2",
+  "setuptools>=68.2.2",
+  "tifffile>=2024.12.12",
+  "nanopyx>=1.0.0",
+]
+
+[project.optional-dependencies]
+all = ["rescale4dl[dev, test]"]
+dev = [
+    "pre-commit>=3.7.0",
+    "ipykernel>=6.29.4",
+    "ruff>=0.4.3",
+    "gptrepo>=1.0.3",
+    "pdoc>=12.3.1",
+    "build",
+    "gptrepo"
+]
+test = [
+    "pytest>=8.2.0",
+    "pytest-xdist>=3.6.1",
+    "pytest-cov>=5.0.0",
+    "nbmake>=1.5.3",
+    "mypy>=1.10.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

rescale4dl-0.1.1/setup.cfg

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

rescale4dl-0.1.1/src/rescale4dl/batch.py

@@ -0,0 +1,209 @@
+import os
+import numpy as np
+
+from typing import List
+from tkinter import filedialog as fd
+from tifffile import imread, imwrite
+
+from .utils import check_crop_img, crop_with_padding
+from .blurring import gaussian_blur
+from .downscaling import binning_img, binning_label
+from .upscaling import upsample_img, upsample_labels
+from tqdm import tqdm
+
+
+
+def downsample_batch(input_folder_path: str, input_folder_name: str, downsampling_factor: int, keep_dims: bool = False, mode: str = "sum"):
+    """Downsamples a batch of images by a given factor. The last two dimensions of the array are binned.
+    Creates new folders outside input_folder to store the results.
+    :param input_folder_path: path to folder containing an "images" folder and a "labels" folder. Images inside both folders should have the same name.
+    :param downsampling_factor: factor used to bin dimensions
+    :para keep_dims: whether to keep the original dimensions or just blur the image (defaults to False)
+    :param mode: can be either sum, max or mean, defaults to sum if not specified or not valid mode
+    """
+
+    if keep_dims:
+        new_dataset_path = os.path.join(os.path.dirname(os.path.dirname(input_folder_path)), "Processed", f"{input_folder_name}_downsampled_{downsampling_factor}_mode_{mode}_same_dims")
+    else:
+        new_dataset_path = os.path.join(os.path.dirname(os.path.dirname(input_folder_path)), "Processed", f"{input_folder_name}_downsampled_{downsampling_factor}_mode_{mode}_diff_dims")
+
+    new_images_path = os.path.join(new_dataset_path, "Images")
+    new_labels_path = os.path.join(new_dataset_path, "Labels")
+
+    if not os.path.exists(new_dataset_path):
+        os.mkdir(new_dataset_path)
+        os.mkdir(new_images_path)
+        os.mkdir(new_labels_path)
+
+    for img_name in os.listdir(os.path.join(input_folder_path, "Images")):
+        img = imread(os.path.join(input_folder_path, "Images", img_name)).astype(np.float32)
+        img = check_crop_img(img, downsampling_factor)
+        lbl = imread(os.path.join(input_folder_path, "Labels", img_name)).astype(np.float32)
+        lbl = check_crop_img(lbl, downsampling_factor)
+        imwrite(os.path.join(new_images_path, img_name), binning_img(img, downsampling_factor, keep_dims=keep_dims, mode=mode))
+        if keep_dims:
+            imwrite(os.path.join(new_labels_path, img_name), lbl.astype(np.uint16))
+        else:
+            imwrite(os.path.join(new_labels_path, img_name), binning_label(lbl, downsampling_factor).astype(np.uint16))
+
+
+def upsample_batch(input_folder_path: str, input_folder_name: str, magnification: int, keep_dims: bool = False):
+    """Upsamples a batch of images by the magnification param using Catmull-rom interpolation and labels using Nearest-neighbor.
+    Creates new folders outside input_folder to store the results.
+    :param input_folder_path: path to folder containing an "images" folder and a "labels" folder. Images inside both folders should have the same name.
+    :param magnification: upscaling factor
+    :para keep_dims: whether to keep the original dimensions or just blur the image (defaults to False)
+    """
+
+    if keep_dims:
+        new_dataset_path = os.path.join(os.path.dirname(os.path.dirname(input_folder_path)), "Processed", f"{input_folder_name}_upsampled_{magnification}_same_dims")
+    else:
+        new_dataset_path = os.path.join(os.path.dirname(os.path.dirname(input_folder_path)), "Processed", f"{input_folder_name}_upsampled_{magnification}_diff_dims")
+
+    new_images_path = os.path.join(new_dataset_path, "Images")
+    new_labels_path = os.path.join(new_dataset_path, "Labels")
+
+    if not os.path.exists(new_dataset_path):
+        os.mkdir(new_dataset_path)
+        os.mkdir(new_images_path)
+        os.mkdir(new_labels_path)
+
+    for img_name in os.listdir(os.path.join(input_folder_path, "Images")):
+        img = imread(os.path.join(input_folder_path, "Images", img_name)).astype(np.float32)
+        lbl = imread(os.path.join(input_folder_path, "Labels", img_name)).astype(np.float32)
+        imwrite(os.path.join(new_images_path, img_name), upsample_img(img, magnification, keep_dims=keep_dims))
+        imwrite(os.path.join(new_labels_path, img_name), upsample_labels(lbl, magnification, keep_dims=keep_dims).astype(np.uint16))
+
+
+def blur_batch(input_folder_path: str, input_folder_name: str, gaussian_sigma: float):
+    """Applies Gaussian blur to a batch of images.
+    Creates new folders outside input_folder to store the results.
+    :param input_folder_path: path to folder containing an "images" folder and a "labels" folder. Images inside both folders should have the same name.
+    :param gaussians: list of standard deviations
+    """
+
+    new_dataset_path = os.path.join(os.path.dirname(os.path.dirname(input_folder_path)), "Processed", f"{input_folder_name}_blurred_{gaussian_sigma}")
+    new_images_path = os.path.join(new_dataset_path, "Images")
+    new_labels_path = os.path.join(new_dataset_path, "Labels")
+
+    if not os.path.exists(new_dataset_path):
+        os.mkdir(new_dataset_path)
+        os.mkdir(new_images_path)
+        os.mkdir(new_labels_path)
+
+    for img_name in os.listdir(os.path.join(input_folder_path, "Images")):
+        img = imread(os.path.join(input_folder_path, "Images", img_name)).astype(np.float32)
+        lbl = imread(os.path.join(input_folder_path, "Labels", img_name)).astype(np.float32)
+        imwrite(os.path.join(new_images_path, img_name), gaussian_blur(img, gaussian_sigma))
+        imwrite(os.path.join(new_labels_path, img_name), lbl.astype(np.uint16))
+
+
+def process_batch(input_folder_path: str, input_folder_name: str, downsampling_factors: List[int], magnifications: List[int], gaussians: List[float], modes: List[str] = ["sum", "mean"]):
+    """Performs all downstream preprocessing on a single dataset"""
+
+    for mag in magnifications:
+        upsample_batch(
+            input_folder_path,
+            input_folder_name,
+            mag
+            )
+        upsample_batch(
+            input_folder_path,
+            input_folder_name,
+            mag,
+            keep_dims=True
+            )
+
+    for mode in modes:
+        for dsf in downsampling_factors:
+            downsample_batch(
+                input_folder_path,
+                input_folder_name,
+                dsf,
+                keep_dims=True,
+                mode=mode
+                )
+            downsample_batch(
+                input_folder_path,
+                input_folder_name,
+                dsf,
+                keep_dims=False,
+                mode=mode
+                )
+
+    for gau in gaussians:
+        blur_batch(
+            input_folder_path,
+            input_folder_name,
+            gau
+        )
+
+
+def process_all_datasets(datasets_path: str, downsampling_factor: List[int], magnification: List[int], gaussians: List[float], modes: List[str] = ["sum", "mean"]):
+    """Performs all downstream preprocessing on all datasets in a folder"""
+
+    if datasets_path is None:
+        datasets_path = fd.askdirectory()
+
+    if not os.path.exists(os.path.join(os.path.dirname(datasets_path), "Processed")):
+        os.mkdir(os.path.join(os.path.dirname(datasets_path), "Processed"))
+
+    for fld in os.listdir(datasets_path):
+        if os.path.isdir(os.path.join(datasets_path, fld)):
+            process_batch(
+                os.path.join(datasets_path, fld),
+                fld,
+                downsampling_factor,
+                magnification,
+                gaussians,
+                modes
+                )
+
+# Core Processing Functions
+def rescale_image(image: np.ndarray, factor: int, mode: str) -> np.ndarray:
+    """Rescale image using specified method"""
+    if mode == "down":
+        return binning_img(image, factor, keep_dims=False, mode="mean")
+    elif mode == "up":
+        return upsample_img(image, factor, keep_dims=False)
+    else:
+        raise ValueError(f"Invalid scale mode: {mode}. Use 'up' or 'down'")
+
+
+#  Processing Pipeline
+def rescale_and_crop_image(INPUT_DIR, OUTPUT_DIR, SCALE_FACTOR, SCALE_MODE, TARGET_SHAPE, SAVE_SCALED):
+    # Create output directories
+    os.makedirs(os.path.join(OUTPUT_DIR, "scaled"), exist_ok=True)
+    os.makedirs(os.path.join(OUTPUT_DIR, "final"), exist_ok=True)
+    # Get image list
+    images = [f for f in os.listdir(INPUT_DIR) if f.lower().endswith('.tif')]
+
+    for filename in images:
+        # Load image
+        img_path = os.path.join(INPUT_DIR, filename)
+        image = np.squeeze(imread(img_path))
+
+        # Rescale
+        scaled = rescale_image(image, SCALE_FACTOR, SCALE_MODE)
+
+        # Save intermediate
+        if SAVE_SCALED:
+            imwrite(os.path.join(OUTPUT_DIR, "scaled", f"scaled_{SCALE_MODE}_{SCALE_FACTOR}_{filename}"), scaled)
+
+        # Crop/Pad
+        final_image = crop_with_padding(scaled, TARGET_SHAPE)
+
+        # Save result
+        imwrite(os.path.join(OUTPUT_DIR, "final", f"processed_{SCALE_MODE}_{SCALE_FACTOR}_{filename}"), final_image)
+
+
+def rescale_and_crop(INPUT_DIR, OUTPUT_DIR, SCALE_FACTOR, TARGET_SHAPE, SAVE_SCALED):
+    for s in tqdm(SCALE_FACTOR, desc="Rescaling and cropping"):
+        SCALE_MODE = "down" if s<1 else "up"
+        if s < 1:
+            SCALE_MODE = "down"
+            s = np.floor(1/s)
+        else:
+            SCALE_MODE = "up"
+        print(s)
+        rescale_and_crop_image(INPUT_DIR, OUTPUT_DIR, np.int8(s), SCALE_MODE, TARGET_SHAPE, SAVE_SCALED)

rescale4dl-0.1.1/src/rescale4dl/blurring.py

@@ -0,0 +1,14 @@
+import numpy as np
+from skimage.filters import gaussian
+
+
+def gaussian_blur(img: np.array, sigma: float):
+    """
+    Apply Gaussian blur to an image.
+    Parameters:
+        img (ndarray): The input image.
+        sigma (float): The standard deviation for Gaussian kernel.
+    Returns:
+        ndarray: The blurred image.
+    """
+    return gaussian(img, sigma=sigma)

rescale4dl-0.1.1/src/rescale4dl/downscaling.py

@@ -0,0 +1,67 @@
+import numpy as np
+
+from skimage.transform import rescale
+from nanopyx.core.transform.binning import rebin_2d
+from nanopyx.core.transform._le_convolution import Convolution
+
+
+
+def binning_downsize(img: np.array, downsampling_factor: int, mode: str = "sum"):
+    """Bins a 2D array by a given factor. The last two dimensions of the array are binned.
+    :param arr: numpy array with any shape as long as last two dimensions are y, x (example: time, channel, z, y, x)
+    :param bin_factor: factor used to bin dimensions
+    :param mode: can be either sum or mean, defaults to sum if not specified or not valid mode
+    :return: binned array
+    """
+    return rebin_2d(img, downsampling_factor, mode=mode)
+
+
+def binning_blur(img: np.array, downsampling_factor: int, mode: str = "sum"):
+    """Blurs a 2D array by a given factor using binning. The last two dimensions of the array are binned.
+    :param arr: numpy array with any shape as long as last two dimensions are y, x (example: time, channel, z, y, x)
+    :param bin_factor: factor used to bin dimensions
+    :param mode: can be either sum or mean, defaults to sum if not specified or not valid mode
+    :return: binned array
+    """
+    conv = Convolution()
+
+    if mode not in ["sum", "mean"]:
+        mode = "sum"
+
+    if mode == "sum":
+        kernel = np.ones((downsampling_factor, downsampling_factor), dtype=np.float32)
+        return np.asarray(
+            conv.run(img.astype(np.float32), kernel),
+            dtype=np.float32
+            )
+
+    elif mode == "mean":
+        kernel = np.ones((
+                downsampling_factor, downsampling_factor),
+                dtype=np.float32) / (
+                downsampling_factor**2
+                )
+        return np.asarray(
+            conv.run(img.astype(np.float32), kernel),
+            dtype=np.float32
+            )
+
+
+def binning_img(img: np.array, downsampling_factor: int, keep_dims: bool = False, mode: str = "sum"):
+    """Bins a 2D array by a given factor. The last two dimensions of the array are binned.
+    :param arr: numpy array with any shape as long as last two dimensions are y, x (example: time, channel, z, y, x)
+    :param bin_factor: factor used to bin dimensions
+    :param keep_dims: whether to keep the original dimensions or just blur the image (defaults to False)
+    :param mode: can be either sum or mean, defaults to sum if not specified or not valid mode
+    :return: binned array
+    """
+    if keep_dims:
+        return binning_blur(img, downsampling_factor, mode=mode)
+    else:
+        return binning_downsize(img, downsampling_factor, mode=mode)
+
+def binning_label(img: np.array, downsampling_factor: int):
+    """Bins a 2D array by a given factor using Nearest-neighbor.
+    :params img: Input image, should be a 2-d np array.
+    :params downsampling_factor: factor used to bin dimensions"""
+    return rescale(img, 1/downsampling_factor, anti_aliasing=False, order=0).astype(np.uint16)