Merge branch 'master' into add-clear-least-significant-set-bit

Author: deerred643-star

computer_vision/README.md

@@ -1,10 +1,11 @@
 # Computer Vision
 
-Computer vision is a field of computer science that works on enabling computers to see, identify and process images in the same way that human does, and provide appropriate output.
+Computer vision is an interdisciplinary field focused on enabling computers to gain high-level understanding from images and video—automatically extracting, analyzing, and interpreting visual information to produce outputs such as labels, measurements, 3D structure, or decisions.
 
-It is like imparting human intelligence and instincts to a computer.
-Image processing and computer vision are a little different from each other. Image processing means applying some algorithms for transforming image from one form to the other like smoothing, contrasting, stretching, etc.
+In practice, computer vision methods combine geometry, physics, statistics, and machine learning to connect pixel data to semantic concepts like objects, actions, and scenes.
 
-While computer vision comes from modelling image processing using the techniques of machine learning, computer vision applies machine learning to recognize patterns for interpretation of images (much like the process of visual reasoning of human vision).
+## Image processing vs. computer vision
 
-* <https://en.wikipedia.org/wiki/Computer_vision>
+Image processing primarily transforms images (e.g., denoising, contrast enhancement, geometric warping) where the output is another image.
+
+Computer vision uses images/video as input but often outputs information about the scene (e.g., detections, segmentation masks, pose estimates, tracking results, or a decision), which may then drive downstream behavior in a larger system.

computer_vision/cnn_classification.py

@@ -94,7 +94,6 @@
     test_image = np.expand_dims(test_image, axis=0)
     result = classifier.predict(test_image)
     # training_set.class_indices
-    if result[0][0] == 0:
-        prediction = "Normal"
-    if result[0][0] == 1:
-        prediction = "Abnormality detected"
+    # The sigmoid output is a probability in the range [0, 1].
+    # Use a threshold of 0.5 to convert the probability into a binary prediction.
+    prediction = "Normal" if result[0][0] < 0.5 else "Abnormality detected"

computer_vision/otsu_threshold.py

@@ -0,0 +1,77 @@
+import numpy as np
+from PIL import Image
+
+"""
+Otsu thresholding algorithm for image processing
+https://en.wikipedia.org/wiki/Otsu%27s_method
+"""
+
+
+def otsu_threshold(image: Image) -> Image:
+    """
+    Applies Otsu's thresholding method to a grayscale image.
+
+    Parameters:
+    image (PIL.Image.Image): A grayscale PIL image object.
+
+    Returns:
+    PIL.Image.Image: A binary image after applying Otsu's thresholding.
+
+    Example:
+    >>> from PIL import Image
+    >>> import numpy as np
+    >>> image_array = np.array(
+    ...     [[0, 0, 0, 0], [255, 255, 255, 255], [0, 0, 0, 0], [255, 255, 255, 255]],
+    ...     dtype=np.uint8
+    ... )
+    >>> image = Image.fromarray(image_array)
+    >>> binary_image = otsu_threshold(image)
+    >>> np.array(binary_image)
+    array([[  0,   0,   0,   0],
+           [255, 255, 255, 255],
+           [  0,   0,   0,   0],
+           [255, 255, 255, 255]], dtype=uint8)
+    """
+    # Convert the image to numpy array
+    pixel_array = np.array(image)
+
+    # Compute histogram
+    hist, _ = np.histogram(pixel_array, bins=256, range=(0, 256))
+
+    # Compute between class variance
+    total_pixels = pixel_array.size
+    current_max, threshold = 0.0, 0  # Ensure current_max is a float
+    sum_total, sum_foreground = 0.0, 0.0  # Ensure these are floats
+    weight_background, weight_foreground = 0.0, 0.0  # Ensure these are floats
+
+    for i in range(256):
+        sum_total += i * hist[i]
+
+    for i in range(256):
+        weight_background += hist[i]
+        if weight_background == 0:
+            continue
+        weight_foreground = total_pixels - weight_background
+        if weight_foreground == 0:
+            break
+        sum_foreground += i * hist[i]
+
+        mean_background = sum_foreground / weight_background
+        mean_foreground = (sum_total - sum_foreground) / weight_foreground
+
+        between_class_variance = (
+            weight_background
+            * weight_foreground
+            * (mean_background - mean_foreground) ** 2
+        )
+
+        if between_class_variance > current_max:
+            current_max = between_class_variance
+            threshold = i
+
+    # Apply threshold to the image
+    binary_image = pixel_array > threshold
+    binary_image = binary_image.astype(np.uint8) * 255
+
+    # Convert numpy array back to PIL image
+    return Image.fromarray(binary_image)

data_structures/binary_tree/segment_tree.py

@@ -11,7 +11,7 @@ def __init__(self, a) -> None:
         if self.N:
             self.build(1, 0, self.N - 1)
 
-    def left(self, idx):
+    def left(self, idx) -> int:
         """
         Returns the left child index for a given index in a binary tree.
 
@@ -23,7 +23,7 @@ def left(self, idx):
         """
         return idx * 2
 
-    def right(self, idx):
+    def right(self, idx) -> int:
         """
         Returns the right child index for a given index in a binary tree.
 
@@ -44,7 +44,7 @@ def build(self, idx, left, right) -> None:
             self.build(self.right(idx), mid + 1, right)
             self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
 
-    def update(self, a, b, val):
+    def update(self, a, b, val) -> bool:
         """
         Update the values in the segment tree in the range [a,b] with the given value.
 
@@ -71,7 +71,7 @@ def update_recursive(self, idx, left, right, a, b, val) -> bool:
         self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
         return True
 
-    def query(self, a, b):
+    def query(self, a, b) -> float:
         """
         Query the maximum value in the range [a,b].
 
@@ -83,7 +83,7 @@ def query(self, a, b):
         """
         return self.query_recursive(1, 0, self.N - 1, a - 1, b - 1)
 
-    def query_recursive(self, idx, left, right, a, b):
+    def query_recursive(self, idx, left, right, a, b) -> float:
         """
         query(1, 1, N, a, b) for query max of [a,b]
         """

data_structures/hashing/hash_table.py

@@ -22,7 +22,7 @@ def __init__(
         self.__aux_list: list = []
         self._keys: dict = {}
 
-    def keys(self):
+    def keys(self) -> dict:
         """
         The keys function returns a dictionary containing the key value pairs.
         key being the index number in hash table and value being the data value.
@@ -48,12 +48,12 @@ def keys(self):
         """
         return self._keys
 
-    def balanced_factor(self):
+    def balanced_factor(self) -> float:
         return sum(1 for slot in self.values if slot is not None) / (
             self.size_table * self.charge_factor
         )
 
-    def hash_function(self, key):
+    def hash_function(self, key) -> int:
         """
         Generates hash for the given key value
 

data_structures/hashing/hash_table_with_linked_list.py

@@ -12,7 +12,7 @@ def _set_value(self, key, data) -> None:
         self.values[key].appendleft(data)
         self._keys[key] = self.values[key]
 
-    def balanced_factor(self):
+    def balanced_factor(self) -> float:
         return (
             sum(self.charge_factor - len(slot) for slot in self.values)
             / self.size_table

data_structures/heap/binomial_heap.py

@@ -251,7 +251,7 @@ def peek(self):
         """
         return self.min_node.val
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return self.size == 0
 
     def delete_min(self):

data_structures/heap/max_heap.py

@@ -60,7 +60,7 @@ def pop(self) -> int:
         return max_value
 
     @property
-    def get_list(self):
+    def get_list(self) -> list:
         return self.__heap[1:]
 
     def __len__(self) -> int:

data_structures/heap/min_heap.py

@@ -39,19 +39,19 @@ def __init__(self, array) -> None:
     def __getitem__(self, key):
         return self.get_value(key)
 
-    def get_parent_idx(self, idx):
+    def get_parent_idx(self, idx) -> int:
         return (idx - 1) // 2
 
-    def get_left_child_idx(self, idx):
+    def get_left_child_idx(self, idx) -> int:
         return idx * 2 + 1
 
-    def get_right_child_idx(self, idx):
+    def get_right_child_idx(self, idx) -> int:
         return idx * 2 + 2
 
     def get_value(self, key):
         return self.heap_dict[key]
 
-    def build_heap(self, array):
+    def build_heap(self, array) -> list:
         last_idx = len(array) - 1
         start_from = self.get_parent_idx(last_idx)
 
@@ -120,7 +120,7 @@ def insert(self, node) -> None:
         self.heap_dict[node.name] = node.val
         self.sift_up(len(self.heap) - 1)
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         return len(self.heap) == 0
 
     def decrease_key(self, node, new_value) -> None:

data_structures/linked_list/doubly_linked_list.py

@@ -196,7 +196,7 @@ def delete(self, data) -> str:
             current.next.previous = current.previous  # 1 <--> 3
         return data
 
-    def is_empty(self):
+    def is_empty(self) -> bool:
         """
         >>> linked_list = DoublyLinkedList()
         >>> linked_list.is_empty()