stouputils 1.14.0__py3-none-any.whl → 1.14.2__py3-none-any.whl

stouputils/data_science/config/get.py

@@ -1,51 +1,51 @@
-""" Load configuration from the set.py file and handle some special cases.
-
-Proper way to get the configuration is by importing this module, not the set.py file directly.
-"""
-
-# pyright: reportUnknownMemberType=false
-# pyright: reportUnknownVariableType=false
-# pyright: reportMissingTypeStubs=false
-
-# Imports
-import os
-from typing import Any
-
-from .set import DataScienceConfig
-
-# Special cases
-# Hide GPU when using CPU
-if DataScienceConfig.TENSORFLOW_DEVICE.lower().startswith("/cpu"):
-	os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-
-# Precise which GPU we use
-elif DataScienceConfig.TENSORFLOW_DEVICE.lower().startswith("/gpu"):
-	os.environ["CUDA_VISIBLE_DEVICES"] = DataScienceConfig.TENSORFLOW_DEVICE.split(":")[-1]
-
-	# Configure TensorFlow (if available)
-	try:
-		from tensorflow import config as tf_config
-
-		# Get the physical devices
-		physical_devices: list[Any] = tf_config.list_physical_devices("GPU")
-
-		# Configure TensorFlow GPU memory management to allocate memory dynamically
-		# This prevents TensorFlow from allocating all GPU memory upfront
-		# Instead, memory will grow as needed, allowing better resource sharing
-		for device in physical_devices:
-			tf_config.experimental.set_memory_growth(device, True)
-
-		# Disable eager execution mode in TensorFlow
-		# This improves performance by allowing TensorFlow to create an optimized graph
-		# of operations instead of executing operations one by one (at the cost of debugging difficulty)
-		tf_config.run_functions_eagerly(False)
-	except ImportError:
-		pass
-
-	# Enable mixed precision training (if available)
-	try:
-		from keras import mixed_precision
-		mixed_precision.set_global_policy(DataScienceConfig.MIXED_PRECISION_POLICY)
-	except ImportError:
-		pass
-
+""" Load configuration from the set.py file and handle some special cases.
+
+Proper way to get the configuration is by importing this module, not the set.py file directly.
+"""
+
+# pyright: reportUnknownMemberType=false
+# pyright: reportUnknownVariableType=false
+# pyright: reportMissingTypeStubs=false
+
+# Imports
+import os
+from typing import Any
+
+from .set import DataScienceConfig
+
+# Special cases
+# Hide GPU when using CPU
+if DataScienceConfig.TENSORFLOW_DEVICE.lower().startswith("/cpu"):
+	os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+
+# Precise which GPU we use
+elif DataScienceConfig.TENSORFLOW_DEVICE.lower().startswith("/gpu"):
+	os.environ["CUDA_VISIBLE_DEVICES"] = DataScienceConfig.TENSORFLOW_DEVICE.split(":")[-1]
+
+	# Configure TensorFlow (if available)
+	try:
+		from tensorflow import config as tf_config
+
+		# Get the physical devices
+		physical_devices: list[Any] = tf_config.list_physical_devices("GPU")
+
+		# Configure TensorFlow GPU memory management to allocate memory dynamically
+		# This prevents TensorFlow from allocating all GPU memory upfront
+		# Instead, memory will grow as needed, allowing better resource sharing
+		for device in physical_devices:
+			tf_config.experimental.set_memory_growth(device, True)
+
+		# Disable eager execution mode in TensorFlow
+		# This improves performance by allowing TensorFlow to create an optimized graph
+		# of operations instead of executing operations one by one (at the cost of debugging difficulty)
+		tf_config.run_functions_eagerly(False)
+	except ImportError:
+		pass
+
+	# Enable mixed precision training (if available)
+	try:
+		from keras import mixed_precision
+		mixed_precision.set_global_policy(DataScienceConfig.MIXED_PRECISION_POLICY)
+	except ImportError:
+		pass
+

stouputils/data_science/data_processing/image/__init__.py

@@ -1,66 +1,66 @@
-
-# Imports
-from .auto_contrast import auto_contrast_image
-from .axis_flip import flip_image
-from .bias_field_correction import bias_field_correction_image
-from .binary_threshold import binary_threshold_image
-from .blur import blur_image
-from .brightness import brightness_image
-from .canny import canny_image
-from .clahe import clahe_image
-from .contrast import contrast_image
-from .curvature_flow_filter import curvature_flow_filter_image
-from .denoise import (
-    adaptive_denoise_image,
-    bilateral_denoise_image,
-    nlm_denoise_image,
-    tv_denoise_image,
-    wavelet_denoise_image,
-)
-from .invert import invert_image
-from .laplacian import laplacian_image
-from .median_blur import median_blur_image
-from .noise import noise_image
-from .normalize import normalize_image
-from .random_erase import random_erase_image
-from .resize import resize_image
-from .rotation import rotate_image
-from .salt_pepper import salt_pepper_image
-from .sharpening import sharpen_image
-from .shearing import shear_image
-from .threshold import threshold_image
-from .translation import translate_image
-from .zoom import zoom_image
-
-__all__ = [
-    "adaptive_denoise_image",
-    "auto_contrast_image",
-    "bias_field_correction_image",
-    "bilateral_denoise_image",
-    "binary_threshold_image",
-    "blur_image",
-    "brightness_image",
-    "canny_image",
-    "clahe_image",
-    "contrast_image",
-    "curvature_flow_filter_image",
-    "flip_image",
-    "invert_image",
-    "laplacian_image",
-    "median_blur_image",
-    "nlm_denoise_image",
-    "noise_image",
-    "normalize_image",
-    "random_erase_image",
-    "resize_image",
-    "rotate_image",
-    "salt_pepper_image",
-    "sharpen_image",
-    "shear_image",
-    "threshold_image",
-    "translate_image",
-    "tv_denoise_image",
-    "wavelet_denoise_image",
-    "zoom_image",
-]
-
+
+# Imports
+from .auto_contrast import auto_contrast_image
+from .axis_flip import flip_image
+from .bias_field_correction import bias_field_correction_image
+from .binary_threshold import binary_threshold_image
+from .blur import blur_image
+from .brightness import brightness_image
+from .canny import canny_image
+from .clahe import clahe_image
+from .contrast import contrast_image
+from .curvature_flow_filter import curvature_flow_filter_image
+from .denoise import (
+    adaptive_denoise_image,
+    bilateral_denoise_image,
+    nlm_denoise_image,
+    tv_denoise_image,
+    wavelet_denoise_image,
+)
+from .invert import invert_image
+from .laplacian import laplacian_image
+from .median_blur import median_blur_image
+from .noise import noise_image
+from .normalize import normalize_image
+from .random_erase import random_erase_image
+from .resize import resize_image
+from .rotation import rotate_image
+from .salt_pepper import salt_pepper_image
+from .sharpening import sharpen_image
+from .shearing import shear_image
+from .threshold import threshold_image
+from .translation import translate_image
+from .zoom import zoom_image
+
+__all__ = [
+    "adaptive_denoise_image",
+    "auto_contrast_image",
+    "bias_field_correction_image",
+    "bilateral_denoise_image",
+    "binary_threshold_image",
+    "blur_image",
+    "brightness_image",
+    "canny_image",
+    "clahe_image",
+    "contrast_image",
+    "curvature_flow_filter_image",
+    "flip_image",
+    "invert_image",
+    "laplacian_image",
+    "median_blur_image",
+    "nlm_denoise_image",
+    "noise_image",
+    "normalize_image",
+    "random_erase_image",
+    "resize_image",
+    "rotate_image",
+    "salt_pepper_image",
+    "sharpen_image",
+    "shear_image",
+    "threshold_image",
+    "translate_image",
+    "tv_denoise_image",
+    "wavelet_denoise_image",
+    "zoom_image",
+]
+

stouputils/data_science/data_processing/image/auto_contrast.py

@@ -1,79 +1,79 @@
-
-# pyright: reportUnusedImport=false
-# ruff: noqa: F401
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def auto_contrast_image(image: NDArray[Any], ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Adjust the contrast of an image.
-
-	Args:
-		image         (NDArray[Any]):  Image to adjust contrast
-		ignore_dtype  (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Image with adjusted contrast
-
-	>>> ## Basic tests
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.uint8)
-	>>> adjusted = auto_contrast_image(image)
-	>>> adjusted.tolist()
-	[[0, 36, 73], [109, 146, 182], [219, 255, 255]]
-	>>> adjusted.shape == image.shape
-	True
-	>>> adjusted.dtype == image.dtype
-	True
-
-	>>> ## Test invalid inputs
-	>>> auto_contrast_image("not an image")
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-
-	# Perform histogram clipping
-	clip_hist_percent: float = 1.0
-
-	# Calculate the histogram of the image
-	hist: NDArray[Any] = cv2.calcHist([image], [0], None, [256], [0, 256])
-
-	# Create an accumulator list to store the cumulative histogram
-	accumulator: list[float] = []
-	accumulator.append(hist[0])
-	for i in range(1, 256):
-		accumulator.append(accumulator[i - 1] + hist[i])
-
-	# Find the maximum value in the accumulator
-	max_value: float = accumulator[-1]
-
-	# Calculate the clipping threshold
-	clip_hist_percent = clip_hist_percent * (max_value / 100.0)
-	clip_hist_percent = clip_hist_percent / 2.0
-
-	# Find the minimum and maximum gray levels after clipping
-	min_gray: int = 0
-	while accumulator[min_gray] < clip_hist_percent:
-		min_gray = min_gray + 1
-	max_gray: int = 256 - 1
-	while (max_gray >= 0 and accumulator[max_gray] >= (max_value - clip_hist_percent)):
-		max_gray = max_gray - 1
-
-	# Calculate the input range after clipping
-	input_range: int = max_gray - min_gray
-
-	# If the input range is 0, return the original image
-	if input_range == 0:
-		return image
-
-	# Calculate the scaling factors for contrast adjustment
-	alpha: float = (256 - 1) / input_range
-	beta: float = -min_gray * alpha
-
-	# Apply the contrast adjustment
-	adjusted: NDArray[Any] = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
-	return adjusted
-
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def auto_contrast_image(image: NDArray[Any], ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Adjust the contrast of an image.
+
+	Args:
+		image         (NDArray[Any]):  Image to adjust contrast
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Image with adjusted contrast
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.uint8)
+	>>> adjusted = auto_contrast_image(image)
+	>>> adjusted.tolist()
+	[[0, 36, 73], [109, 146, 182], [219, 255, 255]]
+	>>> adjusted.shape == image.shape
+	True
+	>>> adjusted.dtype == image.dtype
+	True
+
+	>>> ## Test invalid inputs
+	>>> auto_contrast_image("not an image")
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+
+	# Perform histogram clipping
+	clip_hist_percent: float = 1.0
+
+	# Calculate the histogram of the image
+	hist: NDArray[Any] = cv2.calcHist([image], [0], None, [256], [0, 256])
+
+	# Create an accumulator list to store the cumulative histogram
+	accumulator: list[float] = []
+	accumulator.append(hist[0])
+	for i in range(1, 256):
+		accumulator.append(accumulator[i - 1] + hist[i])
+
+	# Find the maximum value in the accumulator
+	max_value: float = accumulator[-1]
+
+	# Calculate the clipping threshold
+	clip_hist_percent = clip_hist_percent * (max_value / 100.0)
+	clip_hist_percent = clip_hist_percent / 2.0
+
+	# Find the minimum and maximum gray levels after clipping
+	min_gray: int = 0
+	while accumulator[min_gray] < clip_hist_percent:
+		min_gray = min_gray + 1
+	max_gray: int = 256 - 1
+	while (max_gray >= 0 and accumulator[max_gray] >= (max_value - clip_hist_percent)):
+		max_gray = max_gray - 1
+
+	# Calculate the input range after clipping
+	input_range: int = max_gray - min_gray
+
+	# If the input range is 0, return the original image
+	if input_range == 0:
+		return image
+
+	# Calculate the scaling factors for contrast adjustment
+	alpha: float = (256 - 1) / input_range
+	beta: float = -min_gray * alpha
+
+	# Apply the contrast adjustment
+	adjusted: NDArray[Any] = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
+	return adjusted
+

stouputils/data_science/data_processing/image/axis_flip.py

@@ -1,58 +1,58 @@
-
-# pyright: reportUnusedImport=false
-# ruff: noqa: F401
-
-# Imports
-from typing import Literal
-
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def flip_image(
-	image: NDArray[Any], axis: Literal["horizontal", "vertical", "both"], ignore_dtype: bool = True
-) -> NDArray[Any]:
-	""" Flip an image along specified axis
-
-	Args:
-		image         (NDArray[Any]):     Image to flip
-		axis          (str):            Axis along which to flip ("horizontal" or "vertical" or "both")
-		ignore_dtype  (bool):           Ignore the dtype check
-	Returns:
-		NDArray[Any]: Flipped image
-
-	>>> ## Basic tests
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-	>>> flip_image(image, "horizontal").tolist()
-	[[3, 2, 1], [6, 5, 4], [9, 8, 7]]
-
-	>>> flip_image(image, "vertical").tolist()
-	[[7, 8, 9], [4, 5, 6], [1, 2, 3]]
-
-	>>> flip_image(image, "both").tolist()
-	[[9, 8, 7], [6, 5, 4], [3, 2, 1]]
-
-	>>> ## Test invalid inputs
-	>>> flip_image(image, "diagonal")
-	Traceback (most recent call last):
-	AssertionError: axis must be either 'horizontal' or 'vertical' or 'both', got 'diagonal'
-
-	>>> flip_image("not an image", "horizontal")
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert axis in ("horizontal", "vertical", "both"), (
-		f"axis must be either 'horizontal' or 'vertical' or 'both', got '{axis}'"
-	)
-
-	# Apply the flip
-	if axis == "horizontal":
-		return cv2.flip(image, 1)	# 1 for horizontal flip
-	elif axis == "vertical":
-		return cv2.flip(image, 0)	# 0 for vertical flip
-	else:
-		return cv2.flip(image, -1)	# -1 for both flips
-
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from typing import Literal
+
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def flip_image(
+	image: NDArray[Any], axis: Literal["horizontal", "vertical", "both"], ignore_dtype: bool = True
+) -> NDArray[Any]:
+	""" Flip an image along specified axis
+
+	Args:
+		image         (NDArray[Any]):     Image to flip
+		axis          (str):            Axis along which to flip ("horizontal" or "vertical" or "both")
+		ignore_dtype  (bool):           Ignore the dtype check
+	Returns:
+		NDArray[Any]: Flipped image
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+	>>> flip_image(image, "horizontal").tolist()
+	[[3, 2, 1], [6, 5, 4], [9, 8, 7]]
+
+	>>> flip_image(image, "vertical").tolist()
+	[[7, 8, 9], [4, 5, 6], [1, 2, 3]]
+
+	>>> flip_image(image, "both").tolist()
+	[[9, 8, 7], [6, 5, 4], [3, 2, 1]]
+
+	>>> ## Test invalid inputs
+	>>> flip_image(image, "diagonal")
+	Traceback (most recent call last):
+	AssertionError: axis must be either 'horizontal' or 'vertical' or 'both', got 'diagonal'
+
+	>>> flip_image("not an image", "horizontal")
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert axis in ("horizontal", "vertical", "both"), (
+		f"axis must be either 'horizontal' or 'vertical' or 'both', got '{axis}'"
+	)
+
+	# Apply the flip
+	if axis == "horizontal":
+		return cv2.flip(image, 1)	# 1 for horizontal flip
+	elif axis == "vertical":
+		return cv2.flip(image, 0)	# 0 for vertical flip
+	else:
+		return cv2.flip(image, -1)	# -1 for both flips
+

stouputils/data_science/data_processing/image/bias_field_correction.py

@@ -1,74 +1,74 @@
-
-# pyright: reportUnknownMemberType=false
-# pyright: reportUnknownArgumentType=false
-# pyright: reportUnknownVariableType=false
-
-# Imports
-import SimpleITK as Sitk
-
-from .common import Any, NDArray, check_image, np
-
-
-# Functions
-def bias_field_correction_image(image: NDArray[Any], ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Apply a bias field correction to an image. (N4 Filter)
-
-	Args:
-		image         (NDArray[Any]):  Image to apply the bias field correction (can't be 8-bit unsigned integer)
-		ignore_dtype  (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Image with the curvature flow filter applied
-
-	>>> ## Basic tests
-	>>> image = np.random.randint(0, 255, size=(10,10), dtype=np.uint8) / 255
-	>>> corrected = bias_field_correction_image(image)
-	>>> corrected.shape == image.shape
-	True
-	>>> corrected.dtype == np.float64
-	True
-
-	>>> ## Test invalid inputs
-	>>> bias_field_correction_image("not an image")
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-
-	# If the image is 3D, convert to grayscale first
-	if image.ndim == 3:
-		image = np.mean(image, axis=-1)
-
-	# Convert numpy array to SimpleITK image
-	image_sitk: Sitk.Image = Sitk.GetImageFromArray(image)
-
-	# Create binary mask of the head region
-	transformed: Sitk.Image = Sitk.RescaleIntensity(image_sitk)  # Normalize intensities
-	transformed = Sitk.LiThreshold(transformed, 0, 1)  # Apply Li thresholding
-	head_mask: Sitk.Image = transformed
-
-	# Downsample images to speed up bias field estimation
-	shrink_factor: int = 4  # Reduce image size by factor of 4
-	input_image: Sitk.Image = Sitk.Shrink(
-		image_sitk,
-		[shrink_factor] * image_sitk.GetDimension()  # Apply shrink factor to all dimensions
-	)
-	mask_image: Sitk.Image = Sitk.Shrink(
-		head_mask,
-		[shrink_factor] * image_sitk.GetDimension()
-	)
-
-	# Apply N4 bias field correction
-	corrector = Sitk.N4BiasFieldCorrectionImageFilter()
-	corrector.Execute(input_image, mask_image)
-
-	# Get estimated bias field and apply correction
-	log_bias_field: Sitk.Image = Sitk.Cast(
-		corrector.GetLogBiasFieldAsImage(image_sitk), Sitk.sitkFloat64
-	)
-	corrected_image_full_resolution: Sitk.Image = image_sitk / Sitk.Exp(log_bias_field)
-
-	# Convert back to numpy array and return
-	return Sitk.GetArrayFromImage(corrected_image_full_resolution)
-
+
+# pyright: reportUnknownMemberType=false
+# pyright: reportUnknownArgumentType=false
+# pyright: reportUnknownVariableType=false
+
+# Imports
+import SimpleITK as Sitk
+
+from .common import Any, NDArray, check_image, np
+
+
+# Functions
+def bias_field_correction_image(image: NDArray[Any], ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Apply a bias field correction to an image. (N4 Filter)
+
+	Args:
+		image         (NDArray[Any]):  Image to apply the bias field correction (can't be 8-bit unsigned integer)
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Image with the curvature flow filter applied
+
+	>>> ## Basic tests
+	>>> image = np.random.randint(0, 255, size=(10,10), dtype=np.uint8) / 255
+	>>> corrected = bias_field_correction_image(image)
+	>>> corrected.shape == image.shape
+	True
+	>>> corrected.dtype == np.float64
+	True
+
+	>>> ## Test invalid inputs
+	>>> bias_field_correction_image("not an image")
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+
+	# If the image is 3D, convert to grayscale first
+	if image.ndim == 3:
+		image = np.mean(image, axis=-1)
+
+	# Convert numpy array to SimpleITK image
+	image_sitk: Sitk.Image = Sitk.GetImageFromArray(image)
+
+	# Create binary mask of the head region
+	transformed: Sitk.Image = Sitk.RescaleIntensity(image_sitk)  # Normalize intensities
+	transformed = Sitk.LiThreshold(transformed, 0, 1)  # Apply Li thresholding
+	head_mask: Sitk.Image = transformed
+
+	# Downsample images to speed up bias field estimation
+	shrink_factor: int = 4  # Reduce image size by factor of 4
+	input_image: Sitk.Image = Sitk.Shrink(
+		image_sitk,
+		[shrink_factor] * image_sitk.GetDimension()  # Apply shrink factor to all dimensions
+	)
+	mask_image: Sitk.Image = Sitk.Shrink(
+		head_mask,
+		[shrink_factor] * image_sitk.GetDimension()
+	)
+
+	# Apply N4 bias field correction
+	corrector = Sitk.N4BiasFieldCorrectionImageFilter()
+	corrector.Execute(input_image, mask_image)
+
+	# Get estimated bias field and apply correction
+	log_bias_field: Sitk.Image = Sitk.Cast(
+		corrector.GetLogBiasFieldAsImage(image_sitk), Sitk.sitkFloat64
+	)
+	corrected_image_full_resolution: Sitk.Image = image_sitk / Sitk.Exp(log_bias_field)
+
+	# Convert back to numpy array and return
+	return Sitk.GetArrayFromImage(corrected_image_full_resolution)
+