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

stouputils/data_science/data_processing/image/binary_threshold.py

@@ -1,73 +1,73 @@
-
-# pyright: reportUnusedImport=false
-# ruff: noqa: F401
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def binary_threshold_image(image: NDArray[Any], threshold: float, ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Apply binary threshold to an image.
-
-	Args:
-		image         (NDArray[Any]):  Image to threshold
-		threshold     (float):       Threshold value (between 0 and 1)
-		ignore_dtype  (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Thresholded binary image
-
-	>>> ## Basic tests
-	>>> image = np.array([[100, 150, 200], [50, 125, 175], [25, 75, 225]])
-	>>> binary_threshold_image(image.astype(np.uint8), 0.5).tolist()
-	[[0, 255, 255], [0, 0, 255], [0, 0, 255]]
-
-	>>> np.random.seed(42)
-	>>> img = np.random.randint(0, 256, (4,4), dtype=np.uint8)
-	>>> thresholded = binary_threshold_image(img, 0.7)
-	>>> set(np.unique(thresholded).tolist()) <= {0, 255}  # Should only contain 0 and 255
-	True
-
-	>>> rgb = np.random.randint(0, 256, (3,3,3), dtype=np.uint8)
-	>>> thresh_rgb = binary_threshold_image(rgb, 0.5)
-	>>> thresh_rgb.shape == rgb.shape
-	True
-	>>> set(np.unique(thresh_rgb).tolist()) <= {0, 255}
-	True
-
-	>>> ## Test invalid inputs
-	>>> binary_threshold_image("not an image", 0.5)
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-
-	>>> binary_threshold_image(image.astype(np.uint8), "0.5")
-	Traceback (most recent call last):
-		...
-	AssertionError: threshold must be a number, got <class 'str'>
-
-	>>> binary_threshold_image(image.astype(np.uint8), 1.5)
-	Traceback (most recent call last):
-		...
-	AssertionError: threshold must be between 0 and 1, got 1.5
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert isinstance(threshold, float | int), f"threshold must be a number, got {type(threshold)}"
-	assert 0 <= threshold <= 1, f"threshold must be between 0 and 1, got {threshold}"
-
-	# Convert threshold from 0-1 range to 0-255 range
-	threshold_value: int = int(threshold * 255)
-
-	# Apply threshold
-	if len(image.shape) == 2:
-		# Grayscale image
-		binary: NDArray[Any] = cv2.threshold(image, threshold_value, 255, cv2.THRESH_BINARY)[1]
-	else:
-		# Color image - convert to grayscale first, then back to color
-		gray: NDArray[Any] = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-		binary: NDArray[Any] = cv2.threshold(gray, threshold_value, 255, cv2.THRESH_BINARY)[1]
-		binary = cv2.cvtColor(binary, cv2.COLOR_GRAY2BGR)
-
-	return binary
-
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def binary_threshold_image(image: NDArray[Any], threshold: float, ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Apply binary threshold to an image.
+
+	Args:
+		image         (NDArray[Any]):  Image to threshold
+		threshold     (float):       Threshold value (between 0 and 1)
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Thresholded binary image
+
+	>>> ## Basic tests
+	>>> image = np.array([[100, 150, 200], [50, 125, 175], [25, 75, 225]])
+	>>> binary_threshold_image(image.astype(np.uint8), 0.5).tolist()
+	[[0, 255, 255], [0, 0, 255], [0, 0, 255]]
+
+	>>> np.random.seed(42)
+	>>> img = np.random.randint(0, 256, (4,4), dtype=np.uint8)
+	>>> thresholded = binary_threshold_image(img, 0.7)
+	>>> set(np.unique(thresholded).tolist()) <= {0, 255}  # Should only contain 0 and 255
+	True
+
+	>>> rgb = np.random.randint(0, 256, (3,3,3), dtype=np.uint8)
+	>>> thresh_rgb = binary_threshold_image(rgb, 0.5)
+	>>> thresh_rgb.shape == rgb.shape
+	True
+	>>> set(np.unique(thresh_rgb).tolist()) <= {0, 255}
+	True
+
+	>>> ## Test invalid inputs
+	>>> binary_threshold_image("not an image", 0.5)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> binary_threshold_image(image.astype(np.uint8), "0.5")
+	Traceback (most recent call last):
+		...
+	AssertionError: threshold must be a number, got <class 'str'>
+
+	>>> binary_threshold_image(image.astype(np.uint8), 1.5)
+	Traceback (most recent call last):
+		...
+	AssertionError: threshold must be between 0 and 1, got 1.5
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert isinstance(threshold, float | int), f"threshold must be a number, got {type(threshold)}"
+	assert 0 <= threshold <= 1, f"threshold must be between 0 and 1, got {threshold}"
+
+	# Convert threshold from 0-1 range to 0-255 range
+	threshold_value: int = int(threshold * 255)
+
+	# Apply threshold
+	if len(image.shape) == 2:
+		# Grayscale image
+		binary: NDArray[Any] = cv2.threshold(image, threshold_value, 255, cv2.THRESH_BINARY)[1]
+	else:
+		# Color image - convert to grayscale first, then back to color
+		gray: NDArray[Any] = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+		binary: NDArray[Any] = cv2.threshold(gray, threshold_value, 255, cv2.THRESH_BINARY)[1]
+		binary = cv2.cvtColor(binary, cv2.COLOR_GRAY2BGR)
+
+	return binary
+

stouputils/data_science/data_processing/image/blur.py

@@ -1,59 +1,59 @@
-
-# pyright: reportUnusedImport=false
-# ruff: noqa: F401
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def blur_image(image: NDArray[Any], blur_strength: float, ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Apply Gaussian blur to an image.
-
-	Args:
-		image         (NDArray[Any]):  Image to blur
-		blur_strength (float):       Strength of the blur
-		ignore_dtype  (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Blurred image
-
-	>>> ## Basic tests
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-	>>> blurred = blur_image(image.astype(np.uint8), 1.5)
-	>>> blurred.shape == image.shape
-	True
-
-	>>> img = np.zeros((5,5), dtype=np.uint8)
-	>>> img[2,2] = 255  # Single bright pixel
-	>>> blurred = blur_image(img, 1.0)
-	>>> bool(blurred[2,2] < 255)  # Center should be blurred
-	True
-
-	>>> rgb = np.full((3,3,3), 128, dtype=np.uint8)
-	>>> blurred_rgb = blur_image(rgb, 1.0)
-	>>> blurred_rgb.shape == (3,3,3)
-	True
-
-	>>> ## Test invalid inputs
-	>>> blur_image("not an image", 1.5)
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-
-	>>> blur_image(image.astype(np.uint8), "1.5")
-	Traceback (most recent call last):
-		...
-	AssertionError: blur_strength must be a number, got <class 'str'>
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert isinstance(blur_strength, float | int), f"blur_strength must be a number, got {type(blur_strength)}"
-
-	# Apply Gaussian blur
-	kernel_size: int = max(3, int(blur_strength * 2) + 1)
-	if kernel_size % 2 == 0:
-		kernel_size += 1
-	blurred_image: NDArray[Any] = cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
-
-	return blurred_image
-
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def blur_image(image: NDArray[Any], blur_strength: float, ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Apply Gaussian blur to an image.
+
+	Args:
+		image         (NDArray[Any]):  Image to blur
+		blur_strength (float):       Strength of the blur
+		ignore_dtype  (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Blurred image
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+	>>> blurred = blur_image(image.astype(np.uint8), 1.5)
+	>>> blurred.shape == image.shape
+	True
+
+	>>> img = np.zeros((5,5), dtype=np.uint8)
+	>>> img[2,2] = 255  # Single bright pixel
+	>>> blurred = blur_image(img, 1.0)
+	>>> bool(blurred[2,2] < 255)  # Center should be blurred
+	True
+
+	>>> rgb = np.full((3,3,3), 128, dtype=np.uint8)
+	>>> blurred_rgb = blur_image(rgb, 1.0)
+	>>> blurred_rgb.shape == (3,3,3)
+	True
+
+	>>> ## Test invalid inputs
+	>>> blur_image("not an image", 1.5)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> blur_image(image.astype(np.uint8), "1.5")
+	Traceback (most recent call last):
+		...
+	AssertionError: blur_strength must be a number, got <class 'str'>
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert isinstance(blur_strength, float | int), f"blur_strength must be a number, got {type(blur_strength)}"
+
+	# Apply Gaussian blur
+	kernel_size: int = max(3, int(blur_strength * 2) + 1)
+	if kernel_size % 2 == 0:
+		kernel_size += 1
+	blurred_image: NDArray[Any] = cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
+
+	return blurred_image
+

stouputils/data_science/data_processing/image/brightness.py

@@ -1,54 +1,54 @@
-
-# pyright: reportUnusedImport=false
-# ruff: noqa: F401
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def brightness_image(image: NDArray[Any], brightness_factor: float, ignore_dtype: bool = False) -> NDArray[Any]:
-	""" Adjust the brightness of an image.
-
-	Args:
-		image             (NDArray[Any]):  Image to adjust brightness
-		brightness_factor (float):       Brightness adjustment factor
-		ignore_dtype      (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Image with adjusted brightness
-
-	>>> ## Basic tests
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-	>>> brightened = brightness_image(image.astype(np.uint8), 1.5)
-	>>> brightened.shape == image.shape
-	True
-
-	>>> img = np.full((3,3), 100, dtype=np.uint8)
-	>>> bright = brightness_image(img, 2.0)
-	>>> dark = brightness_image(img, 0.5)
-	>>> bool(np.mean(bright) > np.mean(img) > np.mean(dark))
-	True
-
-	>>> rgb = np.full((3,3,3), 128, dtype=np.uint8)
-	>>> bright_rgb = brightness_image(rgb, 1.5)
-	>>> bright_rgb.shape == (3,3,3)
-	True
-
-	>>> ## Test invalid inputs
-	>>> brightness_image("not an image", 1.5)
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-
-	>>> brightness_image(image.astype(np.uint8), "1.5")
-	Traceback (most recent call last):
-		...
-	AssertionError: brightness_factor must be a number, got <class 'str'>
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert isinstance(brightness_factor, float | int), f"brightness_factor must be a number, got {type(brightness_factor)}"
-
-	# Apply brightness adjustment
-	return cv2.convertScaleAbs(image, alpha=brightness_factor, beta=0)
-
+
+# pyright: reportUnusedImport=false
+# ruff: noqa: F401
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def brightness_image(image: NDArray[Any], brightness_factor: float, ignore_dtype: bool = False) -> NDArray[Any]:
+	""" Adjust the brightness of an image.
+
+	Args:
+		image             (NDArray[Any]):  Image to adjust brightness
+		brightness_factor (float):       Brightness adjustment factor
+		ignore_dtype      (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Image with adjusted brightness
+
+	>>> ## Basic tests
+	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+	>>> brightened = brightness_image(image.astype(np.uint8), 1.5)
+	>>> brightened.shape == image.shape
+	True
+
+	>>> img = np.full((3,3), 100, dtype=np.uint8)
+	>>> bright = brightness_image(img, 2.0)
+	>>> dark = brightness_image(img, 0.5)
+	>>> bool(np.mean(bright) > np.mean(img) > np.mean(dark))
+	True
+
+	>>> rgb = np.full((3,3,3), 128, dtype=np.uint8)
+	>>> bright_rgb = brightness_image(rgb, 1.5)
+	>>> bright_rgb.shape == (3,3,3)
+	True
+
+	>>> ## Test invalid inputs
+	>>> brightness_image("not an image", 1.5)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> brightness_image(image.astype(np.uint8), "1.5")
+	Traceback (most recent call last):
+		...
+	AssertionError: brightness_factor must be a number, got <class 'str'>
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert isinstance(brightness_factor, float | int), f"brightness_factor must be a number, got {type(brightness_factor)}"
+
+	# Apply brightness adjustment
+	return cv2.convertScaleAbs(image, alpha=brightness_factor, beta=0)
+

stouputils/data_science/data_processing/image/canny.py

@@ -1,110 +1,110 @@
-
-# Imports
-from .common import Any, NDArray, check_image, cv2, np
-
-
-# Functions
-def canny_image(
-	image: NDArray[Any],
-	threshold1: float,
-	threshold2: float,
-	aperture_size: int = 3,
-	sigma: float = 3,
-	stop_at_nms: bool = False,
-	ignore_dtype: bool = False,
-) -> NDArray[Any]:
-	""" Apply Canny edge detection to an image.
-
-	Args:
-		image           (NDArray[Any]):  Image to apply Canny edge detection
-		threshold1      (float):       First threshold for hysteresis (between 0 and 1)
-		threshold2      (float):       Second threshold for hysteresis (between 0 and 1)
-		aperture_size   (int):         Aperture size for Sobel operator (3, 5, or 7)
-		sigma           (float):       Standard deviation for Gaussian blur
-		stop_at_nms     (bool):        Stop at non-maximum suppression step (don't apply thresholding)
-		ignore_dtype    (bool):        Ignore the dtype check
-	Returns:
-		NDArray[Any]: Image with Canny edge detection applied
-
-	>>> ## Basic tests
-	>>> image = np.array([[100, 150, 200], [50, 125, 175], [25, 75, 225]])
-	>>> edges = canny_image(image.astype(np.uint8), 0.1, 0.2)
-	>>> edges.shape == image.shape[:2]  # Canny returns single channel
-	True
-	>>> set(np.unique(edges).tolist()) <= {0, 255}  # Only contains 0 and 255
-	True
-
-	>>> rgb = np.random.randint(0, 256, (3,3,3), dtype=np.uint8)
-	>>> edges_rgb = canny_image(rgb, 0.1, 0.2)
-	>>> edges_rgb.shape == rgb.shape[:2]  # Canny returns single channel
-	True
-
-	>>> ## Test invalid inputs
-	>>> canny_image("not an image", 0.1, 0.2)
-	Traceback (most recent call last):
-		...
-	AssertionError: Image must be a numpy array
-
-	>>> canny_image(image.astype(np.uint8), 1.5, 0.2)
-	Traceback (most recent call last):
-		...
-	AssertionError: threshold1 must be between 0 and 1, got 1.5
-	"""
-	# Check input data
-	check_image(image, ignore_dtype=ignore_dtype)
-	assert 0 <= threshold1 <= 1, f"threshold1 must be between 0 and 1, got {threshold1}"
-	assert 0 <= threshold2 <= 1, f"threshold2 must be between 0 and 1, got {threshold2}"
-	assert aperture_size in (3, 5, 7), f"aperture_size must be 3, 5 or 7, got {aperture_size}"
-
-	# Convert to grayscale if needed
-	if len(image.shape) > 2:
-		image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-
-	# Convert thresholds to 0-255 range
-	t1: int = int(threshold1 * 255)
-	t2: int = int(threshold2 * 255)
-
-	if not stop_at_nms:
-		# Apply full Canny edge detection
-		return cv2.Canny(image, t1, t2, apertureSize=aperture_size)
-	else:
-		# Manual implementation up to non-maximum suppression
-		# 1. Apply Gaussian blur to reduce noise
-		blurred: NDArray[Any] = cv2.GaussianBlur(image, (5, 5), sigma)
-
-		# 2. Calculate gradients using Sobel
-		# Use constant value 6 for 64-bit float depth (CV_64F)
-		gx: NDArray[Any] = cv2.Sobel(blurred, 6, 1, 0, ksize=aperture_size)
-		gy: NDArray[Any] = cv2.Sobel(blurred, 6, 0, 1, ksize=aperture_size)
-
-		# Calculate gradient magnitude and direction
-		magnitude: NDArray[Any] = np.sqrt(gx**2 + gy**2)
-		direction: NDArray[Any] = np.arctan2(gy, gx) * 180 / np.pi
-
-		# 3. Non-maximum suppression
-		nms: NDArray[Any] = np.zeros_like(magnitude, dtype=np.uint8)
-		height, width = magnitude.shape
-
-		for i in range(1, height - 1):
-			for j in range(1, width - 1):
-				# Get gradient direction
-				angle: float = direction[i, j]
-				if angle < 0:
-					angle += 180
-
-				# Round to 0, 45, 90, or 135 degrees
-				if (0 <= angle < 22.5) or (157.5 <= angle <= 180):
-					neighbors = [magnitude[i, j-1], magnitude[i, j+1]]
-				elif 22.5 <= angle < 67.5:
-					neighbors = [magnitude[i-1, j-1], magnitude[i+1, j+1]]
-				elif 67.5 <= angle < 112.5:
-					neighbors = [magnitude[i-1, j], magnitude[i+1, j]]
-				else:  # 112.5 <= angle < 157.5
-					neighbors = [magnitude[i-1, j+1], magnitude[i+1, j-1]]
-
-				# Check if current pixel is local maximum
-				if magnitude[i, j] >= max(neighbors):
-					nms[i, j] = np.uint8(min(magnitude[i, j], 255))
-
-		return nms
-
+
+# Imports
+from .common import Any, NDArray, check_image, cv2, np
+
+
+# Functions
+def canny_image(
+	image: NDArray[Any],
+	threshold1: float,
+	threshold2: float,
+	aperture_size: int = 3,
+	sigma: float = 3,
+	stop_at_nms: bool = False,
+	ignore_dtype: bool = False,
+) -> NDArray[Any]:
+	""" Apply Canny edge detection to an image.
+
+	Args:
+		image           (NDArray[Any]):  Image to apply Canny edge detection
+		threshold1      (float):       First threshold for hysteresis (between 0 and 1)
+		threshold2      (float):       Second threshold for hysteresis (between 0 and 1)
+		aperture_size   (int):         Aperture size for Sobel operator (3, 5, or 7)
+		sigma           (float):       Standard deviation for Gaussian blur
+		stop_at_nms     (bool):        Stop at non-maximum suppression step (don't apply thresholding)
+		ignore_dtype    (bool):        Ignore the dtype check
+	Returns:
+		NDArray[Any]: Image with Canny edge detection applied
+
+	>>> ## Basic tests
+	>>> image = np.array([[100, 150, 200], [50, 125, 175], [25, 75, 225]])
+	>>> edges = canny_image(image.astype(np.uint8), 0.1, 0.2)
+	>>> edges.shape == image.shape[:2]  # Canny returns single channel
+	True
+	>>> set(np.unique(edges).tolist()) <= {0, 255}  # Only contains 0 and 255
+	True
+
+	>>> rgb = np.random.randint(0, 256, (3,3,3), dtype=np.uint8)
+	>>> edges_rgb = canny_image(rgb, 0.1, 0.2)
+	>>> edges_rgb.shape == rgb.shape[:2]  # Canny returns single channel
+	True
+
+	>>> ## Test invalid inputs
+	>>> canny_image("not an image", 0.1, 0.2)
+	Traceback (most recent call last):
+		...
+	AssertionError: Image must be a numpy array
+
+	>>> canny_image(image.astype(np.uint8), 1.5, 0.2)
+	Traceback (most recent call last):
+		...
+	AssertionError: threshold1 must be between 0 and 1, got 1.5
+	"""
+	# Check input data
+	check_image(image, ignore_dtype=ignore_dtype)
+	assert 0 <= threshold1 <= 1, f"threshold1 must be between 0 and 1, got {threshold1}"
+	assert 0 <= threshold2 <= 1, f"threshold2 must be between 0 and 1, got {threshold2}"
+	assert aperture_size in (3, 5, 7), f"aperture_size must be 3, 5 or 7, got {aperture_size}"
+
+	# Convert to grayscale if needed
+	if len(image.shape) > 2:
+		image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+	# Convert thresholds to 0-255 range
+	t1: int = int(threshold1 * 255)
+	t2: int = int(threshold2 * 255)
+
+	if not stop_at_nms:
+		# Apply full Canny edge detection
+		return cv2.Canny(image, t1, t2, apertureSize=aperture_size)
+	else:
+		# Manual implementation up to non-maximum suppression
+		# 1. Apply Gaussian blur to reduce noise
+		blurred: NDArray[Any] = cv2.GaussianBlur(image, (5, 5), sigma)
+
+		# 2. Calculate gradients using Sobel
+		# Use constant value 6 for 64-bit float depth (CV_64F)
+		gx: NDArray[Any] = cv2.Sobel(blurred, 6, 1, 0, ksize=aperture_size)
+		gy: NDArray[Any] = cv2.Sobel(blurred, 6, 0, 1, ksize=aperture_size)
+
+		# Calculate gradient magnitude and direction
+		magnitude: NDArray[Any] = np.sqrt(gx**2 + gy**2)
+		direction: NDArray[Any] = np.arctan2(gy, gx) * 180 / np.pi
+
+		# 3. Non-maximum suppression
+		nms: NDArray[Any] = np.zeros_like(magnitude, dtype=np.uint8)
+		height, width = magnitude.shape
+
+		for i in range(1, height - 1):
+			for j in range(1, width - 1):
+				# Get gradient direction
+				angle: float = direction[i, j]
+				if angle < 0:
+					angle += 180
+
+				# Round to 0, 45, 90, or 135 degrees
+				if (0 <= angle < 22.5) or (157.5 <= angle <= 180):
+					neighbors = [magnitude[i, j-1], magnitude[i, j+1]]
+				elif 22.5 <= angle < 67.5:
+					neighbors = [magnitude[i-1, j-1], magnitude[i+1, j+1]]
+				elif 67.5 <= angle < 112.5:
+					neighbors = [magnitude[i-1, j], magnitude[i+1, j]]
+				else:  # 112.5 <= angle < 157.5
+					neighbors = [magnitude[i-1, j+1], magnitude[i+1, j-1]]
+
+				# Check if current pixel is local maximum
+				if magnitude[i, j] >= max(neighbors):
+					nms[i, j] = np.uint8(min(magnitude[i, j], 255))
+
+		return nms
+