stouputils 1.14.0__py3-none-any.whl

stouputils/data_science/data_processing/image/zoom.py

@@ -0,0 +1,83 @@
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def zoom_image(image: NDArray[Any], zoom_factor: float, ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Zoom into an image.
+
+	Args:
+		image         (NDArray[Any]):  Image to zoom
+		zoom_factor   (float):       Zoom factor (greater than 1 for zoom in, less than 1 for zoom out)
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Zoomed image
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+	>>> zoomed = zoom_image(image.astype(np.uint8), 1.5)
+	>>> zoomed.shape == image.shape
+	True
+
+	>>> img = np.eye(4, dtype=np.uint8) * 255
+	>>> zoomed_in = zoom_image(img, 2.0)
+	>>> zoomed_in.shape == img.shape  # Should preserve size
+	True
+
+	>>> zoomed_out = zoom_image(img, 0.5)
+	>>> zoomed_out.shape == img.shape  # Should preserve size
+	True
+
+	>>> rgb = np.full((4,4,3), 128, dtype=np.uint8)
+	>>> zoomed_rgb = zoom_image(rgb, 1.5)
+	>>> zoomed_rgb.shape == (4,4,3)
+	True
+
+	>>> ## Test invalid inputs
+	>>> zoom_image("not an image", 1.5)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> zoom_image(image.astype(np.uint8), "1.5")
+	Traceback (most recent call last):
+		...
+	AssertionError: zoom_factor must be a number, got <class 'str'>
+
+	>>> zoom_image(image.astype(np.uint8), -1)
+	Traceback (most recent call last):
+		...
+	AssertionError: zoom_factor must be greater than 0, got -1
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert isinstance(zoom_factor, float | int), f"zoom_factor must be a number, got {type(zoom_factor)}"
+	assert zoom_factor > 0, f"zoom_factor must be greater than 0, got {zoom_factor}"
+
+	# Get image dimensions
+	height, width = image.shape[:2]
+
+	# Calculate new dimensions
+	new_height, new_width = int(height * zoom_factor), int(width * zoom_factor)
+
+	# Resize image
+	zoomed_image: NDArray[Any] = cv2.resize(image, (new_width, new_height))
+
+	# Crop or pad to original size
+	if zoom_factor > 1:
+		# Crop
+		start_x: int = (new_width - width) // 2
+		start_y: int = (new_height - height) // 2
+		return zoomed_image[start_y:start_y + height, start_x:start_x + width] # pyright: ignore [reportUnknownVariableType]
+	else:
+		# Pad
+		pad_x: int = (width - new_width) // 2
+		pad_y: int = (height - new_height) // 2
+		# Ensure value list matches number of channels (max 4 for OpenCV)
+		value: list[int] = [0] * min(image.shape[-1], 4)
+		return cv2.copyMakeBorder(zoomed_image, pad_y, pad_y, pad_x, pad_x, cv2.BORDER_CONSTANT, value=value)
+

stouputils/data_science/data_processing/image_augmentation.py

@@ -0,0 +1,118 @@
+
+# Imports
+import os
+import random
+
+from ...decorators import handle_error
+from ..config.get import DataScienceConfig
+from .image_preprocess import ImageDatasetPreprocess
+from .technique import ProcessingTechnique
+
+
+# Image dataset augmentation class
+class ImageDatasetAugmentation(ImageDatasetPreprocess):
+	""" Image dataset augmentation class. Check the class constructor for more information. """
+
+	# Class constructor (configuration)
+	def __init__(self, final_dataset_size: int, techniques: list[ProcessingTechnique] | None = None) -> None:
+		""" Initialize the image dataset augmentation class with the given parameters.
+
+		Args:
+			final_dataset_size	(int):							Size of the final dataset
+			techniques			(list[ProcessingTechnique]):	List of processing techniques to apply.
+		"""
+		if techniques is None:
+			techniques = []
+		super().__init__(techniques=techniques)
+		self.final_dataset_size: int = final_dataset_size
+
+	# Class methods
+	def _add_suffix(self, path: str, used_destinations: set[str]) -> str:
+		""" Add a count suffix to the path in order to avoid overwriting the same file
+
+		Args:
+			path	(str):	Path to the file (example: "path/to/file.jpg")
+		Returns:
+			str:	Path with the suffix (example: "path/to/file_1.jpg")
+		"""
+		# Split the path into base path and extension (e.g. "path/to/file.jpg" -> "path/to/file", ".jpg")
+		path_no_ext, ext = os.path.splitext(path)
+
+		# Convert count to augmented path
+		def get_path_from_count(count: int) -> str:
+			return path_no_ext + DataScienceConfig.AUGMENTED_FILE_SUFFIX + str(count) + ext
+
+		# Function to check if the path is not available
+		def is_not_available(path_aug: str) -> bool:
+			return path_aug in used_destinations or os.path.isfile(path_aug)
+
+		# Keep incrementing counter until we find a filename that doesn't exist
+		count: int = 1
+		while is_not_available(get_path_from_count(count)):
+			count += 1
+		return get_path_from_count(count)
+
+	@handle_error(message="Error while getting queue of files to process")
+	def get_queue(
+		self,
+		dataset_path: str,
+		destination_path: str,
+		images_per_class_dict: dict[str, int] | None = None
+	) -> list[tuple[str, str, list[ProcessingTechnique]]]:
+		""" Get the queue of images to process with their techniques.
+
+		Args:
+			dataset_path          (str):             Path to the dataset
+			destination_path      (str):             Path to the destination dataset
+			images_per_class_dict (dict[str, int]):  Dictionary mapping class names to desired number of images
+				(optional, defaults to empty dictionary)
+		Returns:
+			list[tuple[str, str, list[ProcessingTechnique]]]: Queue of (source_path, dest_path, techniques) tuples
+		"""
+		# Initializations
+		if images_per_class_dict is None:
+			images_per_class_dict = {}
+		queue: list[tuple[str, str, list[ProcessingTechnique]]] = []
+		used_destinations: set[str] = set()
+
+		# Get all folders (classes) and compute the number of images per class
+		classes: tuple[str, ...] = tuple(f for f in os.listdir(dataset_path) if os.path.isdir(f"{dataset_path}/{f}"))
+		default_images_per_class: int = self.final_dataset_size // len(classes)
+
+		# For each class, for each image, apply the processing techniques
+		for class_name in classes:
+			class_path: str = f"{dataset_path}/{class_name}"
+			images: list[str] = os.listdir(class_path)
+
+			# Determine target number of images for this class
+			target_images: int = images_per_class_dict.get(class_name, default_images_per_class)
+			remaining_images: int = target_images - len(images)
+
+			# Add images to the queue without applying the processing techniques
+			for img in images:
+				files: dict[str, str] = self.get_files_recursively(f"{class_path}/{img}", f"{destination_path}/{class_name}/{img}")
+				for path, dest in files.items():
+					queue.append((path, dest, []))
+
+			# While there is less images than the desired number, apply the processing techniques
+			while remaining_images > 0:
+				chosen_images: list[str] = random.sample(images, k=min(remaining_images, len(images)))
+
+				# Apply the processing techniques
+				for img in chosen_images:
+					img_destination: str = self._add_suffix(f"{destination_path}/{class_name}/{img}", used_destinations)
+					used_destinations.add(img_destination)
+					img_path: str = f"{class_path}/{img}"
+
+					# Get the technique and their fixed values
+					techniques: list[ProcessingTechnique] = [x.deterministic(use_default=False) for x in self.techniques]
+
+					# For each image found, add it to the queue
+					for path, dest in self.get_files_recursively(img_path, img_destination).items():
+						queue.append((path, dest, techniques))
+
+				# Update the remaining images
+				remaining_images -= len(chosen_images)
+
+		return queue
+

stouputils/data_science/data_processing/image_preprocess.py

@@ -0,0 +1,183 @@
+
+# Imports
+import os
+import shutil
+from typing import Any
+
+import cv2
+import numpy as np
+from numpy.typing import NDArray
+
+from ...decorators import handle_error
+from ...parallel import multiprocessing, CPU_COUNT
+from ...print import warning, error
+from ...io import clean_path, super_copy
+from .technique import ProcessingTechnique
+
+
+# Image dataset augmentation class
+class ImageDatasetPreprocess:
+	""" Image dataset preprocessing class. Check the class constructor for more information. """
+
+	# Class constructor (configuration)
+	def __init__(self, techniques: list[ProcessingTechnique] | None = None) -> None:
+		""" Initialize the image dataset augmentation class with the given parameters.
+
+		Args:
+			techniques			(list[ProcessingTechnique]):	List of processing techniques to apply.
+		"""
+		if techniques is None:
+			techniques = []
+		assert all(isinstance(x, ProcessingTechnique) for x in techniques), (
+			"All techniques must be ProcessingTechnique objects"
+		)
+		self.techniques: list[ProcessingTechnique] = [x.deterministic(use_default=True) for x in techniques]
+
+	@handle_error(message="Error while getting files recursively")
+	def get_files_recursively(
+		self,
+		source: str,
+		destination: str,
+		extensions: tuple[str,...] = (".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif")
+	) -> dict[str, str]:
+		""" Recursively get all files in a directory and their destinations.
+
+		Args:
+			source		(str):				Path to the source directory
+			destination	(str):				Path to the destination directory
+			extensions	(tuple[str,...]):	Tuple of extensions to consider (e.g. (".jpg", ".png"))
+		Returns:
+			dict[str, str]:	Dictionary mapping source paths to destination paths
+		"""
+		files: dict[str, str] = {}
+
+		if os.path.isfile(source) and source.endswith(extensions):
+			files[source] = destination
+		elif os.path.isdir(source):
+			for item in os.listdir(source):
+				item_path: str = f"{source}/{item}"
+				item_dest: str = f"{destination}/{item}"
+				files.update(self.get_files_recursively(item_path, item_dest, extensions))
+		return files
+
+
+	@handle_error(message="Error while getting queue of files to process")
+	def get_queue(self, dataset_path: str, destination_path: str) -> list[tuple[str, str, list[ProcessingTechnique]]]:
+		""" Get the queue of images to process with their techniques.
+
+		This method converts the processing techniques ranges to fixed values and builds a queue
+		of files to process by recursively finding all images in the dataset path.
+
+		Args:
+			dataset_path		(str):		Path to the dataset directory
+			destination_path	(str):		Path to the destination directory where processed images will be saved
+		Returns:
+			list[tuple[str, str, list[ProcessingTechnique]]]: Queue of (source_path, dest_path, techniques) tuples
+		"""
+		# Convert technique ranges to fixed values
+		self.techniques = [x.deterministic(use_default=True) for x in self.techniques]
+
+		# Build queue by recursively finding all images and their destinations
+		return [
+			(path, dest, self.techniques)
+			for path, dest in
+			self.get_files_recursively(dataset_path, destination_path).items()
+		]
+
+
+	@handle_error(message="Error while processing the dataset")
+	def process_dataset(
+		self,
+		dataset_path: str,
+		destination_path: str,
+		max_workers: int = CPU_COUNT,
+		ignore_confirmation: bool = False
+	) -> None:
+		""" Preprocess the dataset by applying the given processing techniques to the images.
+
+		Args:
+			dataset_path		(str):		Path to the dataset
+			destination_path	(str):		Path to the destination dataset
+			max_workers			(int):		Number of workers to use (Defaults to CPU_COUNT)
+			ignore_confirmation	(bool):		If True, don't ask for confirmation
+		"""
+		# Clean paths
+		dataset_path = clean_path(dataset_path)
+		destination_path = clean_path(destination_path)
+
+		# If destination folder exists, ask user if they want to delete it
+		if os.path.isdir(destination_path):
+			if not ignore_confirmation:
+				warning(f"Destination folder '{destination_path}' already exists.\nDo you want to delete it? (y/N)")
+				if input().lower() == "y":
+					shutil.rmtree(destination_path)
+				else:
+					error("Aborting...", exit=False)
+					return
+			else:
+				warning(f"Destination folder '{destination_path}' already exists.\nDeleting it...")
+				shutil.rmtree(destination_path)
+
+		# Prepare the multiprocessing arguments (image path, destination path, techniques)
+		queue: list[tuple[str, str, list[ProcessingTechnique]]] = self.get_queue(dataset_path, destination_path)
+
+		# Apply the processing techniques in parallel
+		splitted: list[str] = dataset_path.split('/')
+		short_path: str = f".../{splitted[-1]}" if len(splitted) > 2 else dataset_path
+		multiprocessing(
+			self.apply_techniques,
+			queue,
+			use_starmap=True,
+			desc=f"Processing dataset '{short_path}'",
+			max_workers=max_workers
+		)
+
+
+	@staticmethod
+	def apply_techniques(path: str, dest: str, techniques: list[ProcessingTechnique], use_padding: bool = True) -> None:
+		""" Apply the processing techniques to the image.
+
+		Args:
+			path		(str):							Path to the image
+			dest		(str):							Path to the destination image
+			techniques	(list[ProcessingTechnique]):	List of processing techniques to apply
+			use_padding	(bool):							If True, add padding to the image before applying techniques
+		"""
+		if not techniques:
+			super_copy(path, dest)
+			return
+
+		# Read the image
+		img: NDArray[Any] = cv2.imread(path, cv2.IMREAD_UNCHANGED)
+
+		if not use_padding:
+			# Add a padding (to avoid cutting the image)
+			previous_shape: tuple[int, ...] = img.shape[:2]
+			padding: int = max(previous_shape[0], previous_shape[1]) // 2
+			img = np.pad( # pyright: ignore [reportUnknownMemberType]
+				img,
+				pad_width=((padding, padding), (padding, padding), (0, 0)),
+				mode="constant",
+				constant_values=0
+			)
+
+			# Compute the dividers that will be used to adjust techniques parameters
+			dividers: tuple[float, float] = (
+				img.shape[0] / previous_shape[0],
+				img.shape[1] / previous_shape[1]
+			)
+		else:
+			dividers = (1.0, 1.0)
+			padding = 0
+
+		# Apply the processing techniques
+		for technique in techniques:
+			img = technique.apply(img, dividers)
+
+		# Remove the padding
+		if not use_padding:
+			img = img[padding:-padding, padding:-padding, :]
+
+		# Save the image
+		os.makedirs(os.path.dirname(dest), exist_ok=True)
+		cv2.imwrite(dest, img)