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

stouputils/data_science/data_processing/image/translation.py

@@ -1,71 +1,71 @@
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def translate_image(image: NDArray[Any], x: float, y: float, padding: int = 0, ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Translate an image
-
-	Args:
-		image         (NDArray[Any]):  Image to translate
-		x             (float):       Translation along the x axis (between -1 and 1)
-		y             (float):       Translation along the y axis (between -1 and 1)
-		padding       (int):         Padding that has been added to the image before calling this function
-		ignore_dtype  (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Translated image
-
-	>>> ## Basic tests
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.uint8)
-	>>> translate_image(image, 0.5, 0.5).tolist()
-	[[0, 0, 0], [0, 1, 2], [0, 4, 5]]
-
-	>>> translate_image(image, 0, -2/3).tolist()
-	[[7, 8, 9], [0, 0, 0], [0, 0, 0]]
-
-	>>> ## Test invalid inputs
-	>>> translate_image(image, 2, 0)
-	Traceback (most recent call last):
-		...
-	AssertionError: x must be between -1 and 1, got 2
-
-	>>> translate_image(image, 0, 2)
-	Traceback (most recent call last):
-		...
-	AssertionError: y must be between -1 and 1, got 2
-
-	>>> translate_image("not an image", 0, 0)
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-
-	>>> translate_image(image, 0, 0, padding=-1)
-	Traceback (most recent call last):
-		...
-	AssertionError: padding must be positive, got -1
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert isinstance(x, float | int), f"x must be a number, got {type(x)}"
-	assert isinstance(y, float | int), f"y must be a number, got {type(y)}"
-	assert -1 <= x <= 1, f"x must be between -1 and 1, got {x}"
-	assert -1 <= y <= 1, f"y must be between -1 and 1, got {y}"
-	assert isinstance(padding, int), f"padding must be an integer, got {type(padding)}"
-	assert padding >= 0, f"padding must be positive, got {padding}"
-
-	# Get image dimensions
-	height, width = image.shape[:2]
-	original_width: int = width - 2 * padding
-	original_height: int = height - 2 * padding
-
-	# Convert relative translations to absolute pixels
-	x_pixels: int = int(x * original_width)
-	y_pixels: int = int(y * original_height)
-
-	# Create translation matrix
-	translation_matrix: NDArray[Any] = np.array([[1, 0, x_pixels], [0, 1, y_pixels]], dtype=np.float32)
-
-	# Apply affine transformation
-	return cv2.warpAffine(image, translation_matrix, (width, height))
-
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def translate_image(image: NDArray[Any], x: float, y: float, padding: int = 0, ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Translate an image
+
+	Args:
+		image         (NDArray[Any]):  Image to translate
+		x             (float):       Translation along the x axis (between -1 and 1)
+		y             (float):       Translation along the y axis (between -1 and 1)
+		padding       (int):         Padding that has been added to the image before calling this function
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Translated image
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]).astype(np.uint8)
+	>>> translate_image(image, 0.5, 0.5).tolist()
+	[[0, 0, 0], [0, 1, 2], [0, 4, 5]]
+
+	>>> translate_image(image, 0, -2/3).tolist()
+	[[7, 8, 9], [0, 0, 0], [0, 0, 0]]
+
+	>>> ## Test invalid inputs
+	>>> translate_image(image, 2, 0)
+	Traceback (most recent call last):
+		...
+	AssertionError: x must be between -1 and 1, got 2
+
+	>>> translate_image(image, 0, 2)
+	Traceback (most recent call last):
+		...
+	AssertionError: y must be between -1 and 1, got 2
+
+	>>> translate_image("not an image", 0, 0)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> translate_image(image, 0, 0, padding=-1)
+	Traceback (most recent call last):
+		...
+	AssertionError: padding must be positive, got -1
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert isinstance(x, float | int), f"x must be a number, got {type(x)}"
+	assert isinstance(y, float | int), f"y must be a number, got {type(y)}"
+	assert -1 <= x <= 1, f"x must be between -1 and 1, got {x}"
+	assert -1 <= y <= 1, f"y must be between -1 and 1, got {y}"
+	assert isinstance(padding, int), f"padding must be an integer, got {type(padding)}"
+	assert padding >= 0, f"padding must be positive, got {padding}"
+
+	# Get image dimensions
+	height, width = image.shape[:2]
+	original_width: int = width - 2 * padding
+	original_height: int = height - 2 * padding
+
+	# Convert relative translations to absolute pixels
+	x_pixels: int = int(x * original_width)
+	y_pixels: int = int(y * original_height)
+
+	# Create translation matrix
+	translation_matrix: NDArray[Any] = np.array([[1, 0, x_pixels], [0, 1, y_pixels]], dtype=np.float32)
+
+	# Apply affine transformation
+	return cv2.warpAffine(image, translation_matrix, (width, height))
+

stouputils/data_science/data_processing/image/zoom.py

@@ -1,83 +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)
-
+
+# 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

@@ -1,118 +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
-
+
+# 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
+