feat: Add ArUco Marker Detector functionality and UI integration

- Introduced ArUco Marker Detector to the application, allowing users to detect ArUco markers in the video feed.
- Added a selection interface for various ArUco dictionaries, enhancing flexibility in marker detection.
- Updated the documentation to include detailed descriptions and usage examples for the ArUco Marker Detector.
- Implemented the detection logic in the OpenCVUtils class, ensuring efficient processing of detected markers.

app.py

@@ -201,6 +201,7 @@ with main_tabs[0]:  # Camera Feed Tab
             "Optical Flow",
             "Hand Tracker",
             "Face Tracker",
+            "ArUco Marker Detector",
         ]
 
         # Use multiselect to both select and order filters
@@ -273,6 +274,35 @@ with main_tabs[0]:  # Camera Feed Tab
         else:
             morph_op, morph_ks = "erode", 5
 
+        if "ArUco Marker Detector" in selected_functions:
+            with st.expander("🔍 ArUco Marker Parameters", expanded=True):
+                aruco_dict = st.selectbox(
+                    "ArUco Dictionary",
+                    options=[
+                        "DICT_4X4_50",
+                        "DICT_4X4_100",
+                        "DICT_4X4_250",
+                        "DICT_4X4_1000",
+                        "DICT_5X5_50",
+                        "DICT_5X5_100",
+                        "DICT_5X5_250",
+                        "DICT_5X5_1000",
+                        "DICT_6X6_50",
+                        "DICT_6X6_100",
+                        "DICT_6X6_250",
+                        "DICT_6X6_1000",
+                        "DICT_7X7_50",
+                        "DICT_7X7_100",
+                        "DICT_7X7_250",
+                        "DICT_7X7_1000",
+                        "DICT_ARUCO_ORIGINAL",
+                    ],
+                    index=10,  # Default to DICT_6X6_250
+                    help="Select the ArUco marker dictionary. Different dictionaries support different marker patterns and IDs.",
+                )
+        else:
+            aruco_dict = "DICT_6X6_250"
+
     with video_col:
         st.markdown("## 📹 Live Camera Feed")
         # WebRTC settings for real-time video
@@ -317,6 +347,8 @@ with main_tabs[0]:  # Camera Feed Tab
                     img = app.detect_hands(img)
                 elif fn == "Face Tracker":
                     img = app.detect_faces(img)
+                elif fn == "ArUco Marker Detector":
+                    img = app.detect_aruco_markers(img, dict_type=aruco_dict)
 
             prev_gray = curr_gray
             return av.VideoFrame.from_ndarray(img, format="bgr24")
@@ -600,6 +632,29 @@ with main_tabs[2]:  # Documentation Tab
             **Docs**: [MediaPipe Face Detector](https://developers.google.com/mediapipe/solutions/vision/face_detector)
             """
             )
+        elif filter_name == "ArUco Marker Detector":
+            st.markdown(
+                """
+            Detects ArUco markers in the video feed. ArUco markers are square fiducial markers that can be used for camera pose estimation, calibration, and object tracking.
+
+            **Parameters:**
+            - **ArUco Dictionary**: Select the dictionary type for the markers you want to detect. Different dictionaries support different marker patterns and ID ranges.
+
+            **Usage**: 
+            - Augmented reality
+            - Camera calibration
+            - Object tracking 
+            - Robotics navigation
+            - Positional reference
+
+            **How it works**:
+            1. Converts the image to grayscale
+            2. Detects markers using the selected dictionary
+            3. Draws detected markers with their IDs
+            
+            **Docs**: [OpenCV ArUco Marker Detection](https://docs.opencv.org/4.x/d5/dae/tutorial_aruco_detection.html)
+            """
+            )
         else:
             # Fallback for any filters missed
             st.markdown(

src/opencv_utils.py

@@ -21,6 +21,27 @@ class OpenCVUtils:
             min_tracking_confidence=0.7,
         )
 
+        # Initialize ArUco dictionaries
+        self.aruco_dicts = {
+            "DICT_4X4_50": cv2.aruco.DICT_4X4_50,
+            "DICT_4X4_100": cv2.aruco.DICT_4X4_100,
+            "DICT_4X4_250": cv2.aruco.DICT_4X4_250,
+            "DICT_4X4_1000": cv2.aruco.DICT_4X4_1000,
+            "DICT_5X5_50": cv2.aruco.DICT_5X5_50,
+            "DICT_5X5_100": cv2.aruco.DICT_5X5_100,
+            "DICT_5X5_250": cv2.aruco.DICT_5X5_250,
+            "DICT_5X5_1000": cv2.aruco.DICT_5X5_1000,
+            "DICT_6X6_50": cv2.aruco.DICT_6X6_50,
+            "DICT_6X6_100": cv2.aruco.DICT_6X6_100,
+            "DICT_6X6_250": cv2.aruco.DICT_6X6_250,
+            "DICT_6X6_1000": cv2.aruco.DICT_6X6_1000,
+            "DICT_7X7_50": cv2.aruco.DICT_7X7_50,
+            "DICT_7X7_100": cv2.aruco.DICT_7X7_100,
+            "DICT_7X7_250": cv2.aruco.DICT_7X7_250,
+            "DICT_7X7_1000": cv2.aruco.DICT_7X7_1000,
+            "DICT_ARUCO_ORIGINAL": cv2.aruco.DICT_ARUCO_ORIGINAL,
+        }
+
     def detect_faces(self, frame: np.ndarray, draw: bool = True) -> np.ndarray:
         """
         Detect a face in the frame with the face mesh tracker of mediapipe
@@ -40,6 +61,59 @@ class OpenCVUtils:
         result = self.hand_tracker.detect(frame, draw=draw)
         return result
 
+    def detect_aruco_markers(
+        self, frame: np.ndarray, dict_type: str = "DICT_6X6_250", draw: bool = True
+    ) -> np.ndarray:
+        """
+        Detect ArUco markers in the frame
+
+        :param frame: The frame to detect ArUco markers
+        :param dict_type: The ArUco dictionary type to use for detection
+        :param draw: If the detected markers should be drawn on the frame
+        :return: The frame with detected ArUco markers drawn (if draw=True)
+        """
+        # Create a copy of the frame to avoid modifying the original
+        output = frame.copy()
+
+        # Convert the image to grayscale
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        # Get the ArUco dictionary
+
+        aruco_dict = cv2.aruco.getPredefinedDictionary(getattr(cv2.aruco, dict_type))
+
+        # Set the detection parameters (using default values)
+        parameters = cv2.aruco.DetectorParameters()
+
+        # Detect ArUco markers
+        corners, ids, rejected = cv2.aruco.detectMarkers(
+            gray, aruco_dict, parameters=parameters
+        )
+
+        # If markers are detected and draw is True
+        if draw and ids is not None:
+            # Draw the detected markers
+            cv2.aruco.drawDetectedMarkers(output, corners, ids)
+
+            # For each marker, draw additional information
+            for i, corner in enumerate(corners):
+                # Get the center of the marker
+                c = corner[0]
+                center = (int(c[:, 0].mean()), int(c[:, 1].mean()))
+
+                # Draw the marker ID
+                cv2.putText(
+                    output,
+                    f"ID: {ids[i][0]}",
+                    (center[0], center[1] - 15),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (0, 255, 0),
+                    2,
+                )
+
+        return output
+
     def apply_color_filter(
         self, frame: np.ndarray, lower_bound: list, upper_bound: list
     ) -> np.ndarray:
@@ -191,56 +265,69 @@ class OpenCVUtils:
     def adaptive_threshold(self, image: np.ndarray) -> np.ndarray:
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         return cv2.cvtColor(
-            cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                  cv2.THRESH_BINARY, 11, 2),
-            cv2.COLOR_GRAY2BGR)
+            cv2.adaptiveThreshold(
+                gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+            ),
+            cv2.COLOR_GRAY2BGR,
+        )
 
-    def morphology(self, image: np.ndarray, op: str = 'erode', ksize: int = 5) -> np.ndarray:
+    def morphology(
+        self, image: np.ndarray, op: str = "erode", ksize: int = 5
+    ) -> np.ndarray:
         kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (ksize, ksize))
         ops = {
-            'erode': cv2.erode,
-            'dilate': cv2.dilate,
-            'open': cv2.morphologyEx,
-            'close': cv2.morphologyEx
+            "erode": cv2.erode,
+            "dilate": cv2.dilate,
+            "open": cv2.morphologyEx,
+            "close": cv2.morphologyEx,
         }
-        if op in ['open', 'close']:
-            flag = cv2.MORPH_OPEN if op == 'open' else cv2.MORPH_CLOSE
+        if op in ["open", "close"]:
+            flag = cv2.MORPH_OPEN if op == "open" else cv2.MORPH_CLOSE
             return ops[op](image, flag, kernel)
         return ops[op](image, kernel)
 
     def sharpen(self, image: np.ndarray) -> np.ndarray:
-        kernel = np.array([[0, -1, 0],
-                           [-1, 5, -1],
-                           [0, -1, 0]])
+        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
         return cv2.filter2D(image, -1, kernel)
 
     def hough_lines(self, image: np.ndarray) -> np.ndarray:
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         edges = cv2.Canny(gray, 50, 150)
-        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50,
-                                minLineLength=50, maxLineGap=10)
+        lines = cv2.HoughLinesP(
+            edges, 1, np.pi / 180, threshold=50, minLineLength=50, maxLineGap=10
+        )
         if lines is not None:
-            for x1, y1, x2, y2 in lines[:,0]:
+            for x1, y1, x2, y2 in lines[:, 0]:
                 cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
         return image
 
     def hough_circles(self, image: np.ndarray) -> np.ndarray:
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1.2,
-                                   minDist=50, param1=50, param2=30,
-                                   minRadius=5, maxRadius=100)
+        circles = cv2.HoughCircles(
+            gray,
+            cv2.HOUGH_GRADIENT,
+            dp=1.2,
+            minDist=50,
+            param1=50,
+            param2=30,
+            minRadius=5,
+            maxRadius=100,
+        )
         if circles is not None:
             circles = np.uint16(np.around(circles))
             for x, y, r in circles[0, :]:
                 cv2.circle(image, (x, y), r, (0, 255, 0), 2)
         return image
 
-    def optical_flow(self, prev_gray: np.ndarray, curr_gray: np.ndarray, image: np.ndarray) -> np.ndarray:
-        flow = cv2.calcOpticalFlowFarneback(prev_gray, curr_gray, None,
-                                            0.5, 3, 15, 3, 5, 1.2, 0)
-        mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
+    def optical_flow(
+        self, prev_gray: np.ndarray, curr_gray: np.ndarray, image: np.ndarray
+    ) -> np.ndarray:
+        flow = cv2.calcOpticalFlowFarneback(
+            prev_gray, curr_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0
+        )
+        mag, ang = cv2.cartToPolar(flow[..., 0], flow[..., 1])
         hsv = np.zeros_like(image)
-        hsv[...,1] = 255
-        hsv[...,0] = ang * 180 / np.pi / 2
-        hsv[...,2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
-        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+        hsv[..., 1] = 255
+        hsv[..., 0] = ang * 180 / np.pi / 2
+        hsv[..., 2] = cv2.normalize(mag, None, 0, 255, cv2.NORM_MINMAX)
+        return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)

src/tkinter_app.py

@@ -579,6 +579,67 @@ class MainWindow:
             selectcolor=self.colors["black"],
         ).pack()
 
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        # Add ArUco Marker Detector
+        self.aruco_marker_var = IntVar()
+        self.aruco_marker_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.detect_aruco_markers, self.aruco_marker_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="ArUco Marker Detector",
+            variable=self.aruco_marker_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        # ArUco dictionary selector
+        Label(
+            scrollable_frame,
+            text="ArUco Dictionary",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+        ).pack()
+
+        self.aruco_dict_var = StringVar(value="DICT_6X6_250")
+        aruco_dicts = [
+            "DICT_4X4_50",
+            "DICT_4X4_100",
+            "DICT_4X4_250",
+            "DICT_4X4_1000",
+            "DICT_5X5_50",
+            "DICT_5X5_100",
+            "DICT_5X5_250",
+            "DICT_5X5_1000",
+            "DICT_6X6_50",
+            "DICT_6X6_100",
+            "DICT_6X6_250",
+            "DICT_6X6_1000",
+            "DICT_7X7_50",
+            "DICT_7X7_100",
+            "DICT_7X7_250",
+            "DICT_7X7_1000",
+            "DICT_ARUCO_ORIGINAL",
+        ]
+
+        # Create a combobox for selecting dictionary
+        aruco_dict_combo = ttk.Combobox(
+            scrollable_frame,
+            textvariable=self.aruco_dict_var,
+            values=aruco_dicts,
+            state="readonly",
+            width=20,
+        )
+        aruco_dict_combo.pack(pady=5)
+        aruco_dict_combo.current(10)  # Default to DICT_6X6_250
+
         # Cria o label para exibir a imagem
         self.image_label = Label(self.paned_window, bg=self.colors["black"])
         self.paned_window.add(self.image_label)
@@ -595,6 +656,17 @@ class MainWindow:
         else:
             self.functions.remove(function)
 
+    def detect_aruco_markers(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Wrapper for ArUco marker detection to pass the dictionary type parameter
+
+        :param frame: The frame to detect ArUco markers
+        :return: The frame with detected ArUco markers
+        """
+        return self.aplication.detect_aruco_markers(
+            frame, dict_type=self.aruco_dict_var.get()
+        )
+
     def process_optical_flow(self, frame: np.ndarray) -> np.ndarray:
         """
         Special handler for optical flow which needs to track previous frames