bm3dornl 0.3.1__tar.gz

bm3dornl-0.3.1/LICENSE

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

bm3dornl-0.3.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: bm3dornl
+Version: 0.3.1
+Summary: BM3D for streak artifact removal in neutron imaging
+License: MIT
+Project-URL: homepage, https://github.com/neutrons/python_project_template/
+Project-URL: repository, https://github.com/ornlneutronimaging/bm3dornl
+Project-URL: documentation, https://bm3dornl.readthedocs.io/en/latest/
+Project-URL: issues, https://github.com/ornlneutronimaging/bm3dornl/issues
+Keywords: BM3D,image processing,neutron imaging,denoising,CuPy,Numba
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy<1.13
+Requires-Dist: numba
+Requires-Dist: cupy-cuda12x
+Requires-Dist: scikit-image
+
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/ornlneutronimaging/bm3dornl/next.svg)](https://results.pre-commit.ci/latest/github/ornlneutronimaging/bm3dornl/next)
+[![Documentation Status](https://readthedocs.org/projects/bm3dornl/badge/?version=latest)](https://bm3dornl.readthedocs.io/en/latest/?badge=latest)
+
+BM3D ORNL
+=========
+
+This repository contains the BM3D ORNL code, which is a Python implementation of the BM3D denoising algorithm. The BM3D algorithm was originally proposed by K. Dabov, A. Foi, V. Katkovnik, and K. Egiazarian in the paper "Image Denoising by Sparse 3D Transform-Domain Collaborative Filtering" (2007).
+The BM3D algorithm is a state-of-the-art denoising algorithm that is widely used in the image processing community.
+The BM3D ORNL code is a Python implementation of the BM3D algorithm that has been optimized for performance using both `Numba` and `CuPy`.
+The BM3D ORNL code is designed to be easy to use and easy to integrate into existing Python workflows.
+The BM3D ORNL code is released under an open-source license, and is freely available for download and use.
+
+For more information, check out our [FAQ](docs/FAQ.md).

bm3dornl-0.3.1/README.md

@@ -0,0 +1,13 @@
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/ornlneutronimaging/bm3dornl/next.svg)](https://results.pre-commit.ci/latest/github/ornlneutronimaging/bm3dornl/next)
+[![Documentation Status](https://readthedocs.org/projects/bm3dornl/badge/?version=latest)](https://bm3dornl.readthedocs.io/en/latest/?badge=latest)
+
+BM3D ORNL
+=========
+
+This repository contains the BM3D ORNL code, which is a Python implementation of the BM3D denoising algorithm. The BM3D algorithm was originally proposed by K. Dabov, A. Foi, V. Katkovnik, and K. Egiazarian in the paper "Image Denoising by Sparse 3D Transform-Domain Collaborative Filtering" (2007).
+The BM3D algorithm is a state-of-the-art denoising algorithm that is widely used in the image processing community.
+The BM3D ORNL code is a Python implementation of the BM3D algorithm that has been optimized for performance using both `Numba` and `CuPy`.
+The BM3D ORNL code is designed to be easy to use and easy to integrate into existing Python workflows.
+The BM3D ORNL code is released under an open-source license, and is freely available for download and use.
+
+For more information, check out our [FAQ](docs/FAQ.md).

bm3dornl-0.3.1/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "bm3dornl"
+description = "BM3D for streak artifact removal in neutron imaging"
+dynamic = ["version"]
+requires-python = ">=3.10"
+dependencies = [
+  "numpy",
+  "scipy<1.13",  # avoid a bug
+  "numba",
+  "cupy-cuda12x",  # use pre-built wheels
+  "scikit-image",
+]
+license = { text = "MIT" }
+keywords = ["BM3D", "image processing", "neutron imaging", "denoising", "CuPy", "Numba"]
+readme = "README.md"
+
+[project.urls]
+homepage = "https://github.com/neutrons/python_project_template/"
+repository = "https://github.com/ornlneutronimaging/bm3dornl"
+documentation = "https://bm3dornl.readthedocs.io/en/latest/"
+issues = "https://github.com/ornlneutronimaging/bm3dornl/issues"
+
+
+[build-system]
+requires = [
+  "setuptools >= 40.6.0",
+  "wheel",
+  "toml",
+  "versioningit"
+]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 119
+
+[tool.versioningit.vcs]
+method = "git"
+default-tag = "0.0.1"
+
+[tool.versioningit.next-version]
+method = "minor"
+
+[tool.versioningit.format]
+distance = "{next_version}.dev{distance}"
+dirty = "{version}+d{build_date:%Y%m%d}"
+distance-dirty = "{next_version}.dev{distance}+d{build_date:%Y%m%d%H%M}"
+
+[tool.versioningit.write]
+file = "src/bm3dornl/_version.py"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["tests*", "scripts*", "docs*", "notebooks*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yml","*.yaml","*.ini"]
+
+[project.scripts]
+packagename-cli = "packagenamepy.packagename:main"
+
+[project.gui-scripts]
+packagenamepy = "packagenamepy.packagename:gui"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  ".", "src", "scripts"
+]
+testpaths = ["tests"]
+python_files = ["test*.py"]
+norecursedirs = [".git", "tmp*", "_tmp*", "__pycache__", "*dataset*", "*data_set*"]
+markers = [
+    "cuda_required: test requires cuda to run."
+]
+
+[tool.pylint]
+max-line-length = 120
+disable = ["too-many-locals",
+           "too-many-statements",
+           "too-many-instance-attributes",
+           "too-many-arguments",
+           "duplicate-code"
+]

bm3dornl-0.3.1/setup.cfg

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

bm3dornl-0.3.1/src/bm3dornl/__init__.py

@@ -0,0 +1,10 @@
+"""
+Contains the entry point for the application
+"""
+
+try:
+    from ._version import __version__  # noqa: F401
+except ImportError:
+    __version__ = "0.0.1"
+
+from .bm3d import bm3d_ring_artifact_removal  # noqa: F401

bm3dornl-0.3.1/src/bm3dornl/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

bm3dornl-0.3.1/src/bm3dornl/aggregation.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Functions for aggregating hyper patch block into a single image."""
+
+import numpy as np
+from typing import Tuple
+from numba import njit, prange
+
+
+@njit(parallel=True)
+def aggregate_block_to_image(
+    image_shape: Tuple[int, int],
+    hyper_blocks: np.ndarray,
+    hyper_block_indices: np.ndarray,
+    variance_blocks: np.ndarray,
+) -> np.ndarray:
+    """
+    Aggregate patches into the denoised image matrix and update the corresponding weights matrix using smart weighting.
+
+    Parameters
+    ----------
+    image_shape : tuple
+        The shape of the image to be denoised.
+    hyper_blocks : np.ndarray
+        A 4D numpy array of patches to be aggregated. Shape is (num_blocks, num_patches_per_block, patch_height, patch_width).
+    hyper_block_indices : np.ndarray
+        A 3D numpy array containing the top-left indices (row, column) for each patch in the `hyper_blocks`.
+        Shape is (num_blocks, num_patches_per_block, 2).
+    variance_blocks : np.ndarray
+        A 4D numpy array of the variances for each patch. Shape is the same as `hyper_blocks`.
+
+    Returns
+    -------
+    np.ndarray
+        The denoised image.
+    """
+    estimate_denoised_image = np.zeros(image_shape)
+    weights = np.zeros(image_shape)
+
+    num_blocks, num_patches, ph, pw = hyper_blocks.shape
+
+    for i in prange(num_blocks):
+        for p in range(num_patches):
+            patch = hyper_blocks[i, p]
+            variance = variance_blocks[i, p]
+            weight = 1 / (variance + 1e-8)  # Small epsilon to avoid division by zero
+            i_pos, j_pos = hyper_block_indices[i, p]
+            for ii in range(ph):
+                for jj in range(pw):
+                    estimate_denoised_image[i_pos + ii, j_pos + jj] += (
+                        patch[ii, jj] * weight[ii, jj]
+                    )
+                    weights[i_pos + ii, j_pos + jj] += weight[ii, jj]
+
+    # Normalize the denoised image by the sum of weights
+    estimate_denoised_image /= np.maximum(weights, 1)
+
+    return estimate_denoised_image
+
+
+@njit(parallel=True)
+def aggregate_denoised_block_to_image(
+    image_shape: Tuple[int, int],
+    denoised_patches: np.ndarray,
+    patch_positions: np.ndarray,
+) -> np.ndarray:
+    """
+    Aggregate denoised patches into the final denoised image.
+
+    Parameters
+    ----------
+    image_shape : tuple
+        The shape of the final denoised image (height, width).
+    denoised_patches : np.ndarray
+        A 4D numpy array of denoised patches. Shape is (num_blocks, num_patches_per_block, patch_height, patch_width).
+    patch_positions : np.ndarray
+        A 3D numpy array containing the top-left indices (row, column) for each patch in the `denoised_patches`.
+        Shape is (num_blocks, num_patches_per_block, 2).
+
+    Returns
+    -------
+    np.ndarray
+        The final denoised image.
+    """
+    denoised_image = np.zeros(image_shape, dtype=np.float32)
+    weights = np.zeros(image_shape, dtype=np.float32)
+
+    num_blocks, num_patches_per_block, patch_height, patch_width = (
+        denoised_patches.shape
+    )
+
+    for block_idx in prange(num_blocks):
+        for patch_idx in range(num_patches_per_block):
+            patch = denoised_patches[block_idx, patch_idx]
+            top_left_row, top_left_col = patch_positions[block_idx, patch_idx]
+            for i in range(patch_height):
+                for j in range(patch_width):
+                    denoised_image[top_left_row + i, top_left_col + j] += patch[i, j]
+                    weights[top_left_row + i, top_left_col + j] += 1
+
+    # Normalize the denoised image by the sum of weights
+    denoised_image /= np.maximum(weights, 1)
+
+    return denoised_image