Add initial project structure with OpenCV and Mediapipe integration

- Created .gitignore to exclude environment and configuration files.
- Added requirements.txt for project dependencies including OpenCV, Mediapipe, and Streamlit.
- Implemented run.py to launch GUI applications using Tkinter or Streamlit.
- Added face and hand landmark detection models in the res directory.
- Developed face_mesh_tracker.py and hand_tracker.py for face and hand tracking functionalities.
- Introduced opencv_utils.py for various image processing utilities.
- Created streamlit_app.py for a web-based interface to explore OpenCV filters.
- Developed tkinter_app.py for a desktop application interface with real-time image processing capabilities.

.gitignore

@@ -0,0 +1,6 @@
+.vscode
+.env
+.venv
+.streamlit
+.streamlit/secrets.toml
+.streamlit/secrets.toml

requirements.txt

@@ -0,0 +1,7 @@
+opencv-python-headless==4.8.0.74
+mediapipe==0.10.8
+numpy==1.24.4
+streamlit==1.41.1
+streamlit-webrtc==0.62.4
+av==12.3.0
+Pillow==11.2.1

res/face_landmarker.task

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff
+size 3758596

res/hand_landmarker.task

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1
+size 7819105

run.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def main():
+    """
+    Main function to run the appropriate GUI application based on command-line arguments.
+    """
+    parser = argparse.ArgumentParser(description="OpenCV GUI Application Launcher")
+    parser.add_argument(
+        "-i",
+        "--interface",
+        choices=["tkinter", "streamlit"],
+        default="tkinter",
+        help="Choose the interface to run (tkinter or streamlit)",
+    )
+
+    args = parser.parse_args()
+
+    # Get the absolute path to the src directory
+    current_dir = Path(__file__).parent
+    src_dir = current_dir / "src"
+
+    if args.interface == "tkinter":
+        print("Starting Tkinter interface...")
+        # Run the tkinter application directly using Python
+        tkinter_path = src_dir / "tkinter_app.py"
+        subprocess.run([sys.executable, str(tkinter_path)])
+
+    elif args.interface == "streamlit":
+        print("Starting Streamlit interface...")
+        # Run the streamlit application using the streamlit CLI
+        streamlit_path = src_dir / "streamlit_app.py"
+        subprocess.run(["streamlit", "run", str(streamlit_path)])
+
+
+if __name__ == "__main__":
+    main()

src/face_mesh_tracker.py

@@ -0,0 +1,432 @@
+import os
+import urllib.request
+import sys
+
+import cv2
+
+import mediapipe as mp
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from mediapipe.framework.formats import landmark_pb2
+
+import time
+import numpy as np
+
+# import autopy
+
+
+class FaceMeshTracker:
+    # face bounder indices
+    FACE_OVAL = [
+        10,
+        338,
+        297,
+        332,
+        284,
+        251,
+        389,
+        356,
+        454,
+        323,
+        361,
+        288,
+        397,
+        365,
+        379,
+        378,
+        400,
+        377,
+        152,
+        148,
+        176,
+        149,
+        150,
+        136,
+        172,
+        58,
+        132,
+        93,
+        234,
+        127,
+        162,
+        21,
+        54,
+        103,
+        67,
+        109,
+    ]
+
+    # lips indices for Landmarks
+    LIPS = [
+        61,
+        146,
+        91,
+        181,
+        84,
+        17,
+        314,
+        405,
+        321,
+        375,
+        291,
+        308,
+        324,
+        318,
+        402,
+        317,
+        14,
+        87,
+        178,
+        88,
+        95,
+        185,
+        40,
+        39,
+        37,
+        0,
+        267,
+        269,
+        270,
+        409,
+        415,
+        310,
+        311,
+        312,
+        13,
+        82,
+        81,
+        42,
+        183,
+        78,
+    ]
+    LOWER_LIPS = [
+        61,
+        146,
+        91,
+        181,
+        84,
+        17,
+        314,
+        405,
+        321,
+        375,
+        291,
+        308,
+        324,
+        318,
+        402,
+        317,
+        14,
+        87,
+        178,
+        88,
+        95,
+    ]
+    UPPER_LIPS = [
+        185,
+        40,
+        39,
+        37,
+        0,
+        267,
+        269,
+        270,
+        409,
+        415,
+        310,
+        311,
+        312,
+        13,
+        82,
+        81,
+        42,
+        183,
+        78,
+    ]
+    # Left eyes indices
+    LEFT_EYE = [
+        362,
+        382,
+        381,
+        380,
+        374,
+        373,
+        390,
+        249,
+        263,
+        466,
+        388,
+        387,
+        386,
+        385,
+        384,
+        398,
+    ]
+    LEFT_EYEBROW = [336, 296, 334, 293, 300, 276, 283, 282, 295, 285]
+    LEFT_CENTER_EYE = [473]
+
+    # right eyes indices
+    RIGHT_EYE = [
+        33,
+        7,
+        163,
+        144,
+        145,
+        153,
+        154,
+        155,
+        133,
+        173,
+        157,
+        158,
+        159,
+        160,
+        161,
+        246,
+    ]
+    RIGHT_EYEBROW = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46]
+    RIGHT_CENTER_EYE = [468]
+
+    def __init__(
+        self,
+        model: str = None,
+        num_faces: int = 1,
+        min_face_detection_confidence: float = 0.5,
+        min_face_presence_confidence: float = 0.5,
+        min_tracking_confidence: float = 0.5,
+    ):
+        """
+        Initialize a FaceTracker instance.
+
+        Args:
+            model (str): The path to the model for face tracking.
+            num_faces (int): Maximum number of faces to detect.
+            min_face_detection_confidence (float): Minimum confidence value ([0.0, 1.0]) for successful face detection.
+            min_face_presence_confidence (float): Minimum confidence value ([0.0, 1.0]) for presence of a face to be tracked.
+            min_tracking_confidence (float): Minimum confidence value ([0.0, 1.0]) for successful face landmark tracking.
+        """
+        self.model = model
+
+        if self.model == None:
+            self.model = self.download_model()
+
+        if self.model == None:
+            self.model = self.download_model()
+
+        self.detector = self.initialize_detector(
+            num_faces,
+            min_face_detection_confidence,
+            min_face_presence_confidence,
+            min_tracking_confidence,
+        )
+
+        self.mp_face_mesh = mp.solutions.face_mesh
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+
+        self.DETECTION_RESULT = None
+
+    def save_result(
+        self,
+        result: vision.FaceLandmarkerResult,
+        unused_output_image,
+        timestamp_ms: int,
+        fps: bool = False,
+    ):
+        """
+        Saves the result of the face detection.
+
+        Args:
+            result (vision.FaceLandmarkerResult): Result of the face detection.
+            unused_output_image (mp.Image): Unused.
+            timestamp_ms (int): Timestamp of the detection.
+
+        Returns:
+            None
+        """
+        self.DETECTION_RESULT = result
+
+    def initialize_detector(
+        self,
+        num_faces: int,
+        min_face_detection_confidence: float,
+        min_face_presence_confidence: float,
+        min_tracking_confidence: float,
+    ):
+        """
+        Initializes the FaceLandmarker instance.
+
+        Args:
+            num_faces (int): Maximum number of faces to detect.
+            min_face_detection_confidence (float): Minimum confidence value ([0.0, 1.0]) for face detection to be considered successful.
+            min_face_presence_confidence (float): Minimum confidence value ([0.0, 1.0]) for the presence of a face for the face landmarks to be considered tracked successfully.
+            min_tracking_confidence (float): Minimum confidence value ([0.0, 1.0]) for the face landmarks to be considered tracked successfully.
+
+        Returns:
+            vision.FaceLandmarker: FaceLandmarker instance.
+        """
+        base_options = python.BaseOptions(model_asset_path=self.model)
+        options = vision.FaceLandmarkerOptions(
+            base_options=base_options,
+            running_mode=vision.RunningMode.LIVE_STREAM,
+            num_faces=num_faces,
+            min_face_detection_confidence=min_face_detection_confidence,
+            min_face_presence_confidence=min_face_presence_confidence,
+            min_tracking_confidence=min_tracking_confidence,
+            output_face_blendshapes=True,
+            result_callback=self.save_result,
+        )
+        return vision.FaceLandmarker.create_from_options(options)
+
+    def draw_landmarks(
+        self,
+        image: np.ndarray,
+        text_color: tuple = (0, 0, 0),
+        font_size: int = 1,
+        font_thickness: int = 1,
+    ) -> np.ndarray:
+        """
+        Draws the face landmarks on the image.
+
+        Args:
+            image (numpy.ndarray): Image on which to draw the landmarks.
+            text_color (tuple, optional): Color of the text. Defaults to (0, 0, 0).
+            font_size (int, optional): Size of the font. Defaults to 1.
+            font_thickness (int, optional): Thickness of the font. Defaults to 1.
+
+        Returns:
+            numpy.ndarray: Image with the landmarks drawn.
+        """
+
+        if self.DETECTION_RESULT:
+            # Draw landmarks.
+            for face_landmarks in self.DETECTION_RESULT.face_landmarks:
+                face_landmarks_proto = landmark_pb2.NormalizedLandmarkList()
+                face_landmarks_proto.landmark.extend(
+                    [
+                        landmark_pb2.NormalizedLandmark(
+                            x=landmark.x, y=landmark.y, z=landmark.z
+                        )
+                        for landmark in face_landmarks
+                    ]
+                )
+                self.mp_drawing.draw_landmarks(
+                    image=image,
+                    landmark_list=face_landmarks_proto,
+                    connections=self.mp_face_mesh.FACEMESH_TESSELATION,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=self.mp_drawing_styles.get_default_face_mesh_tesselation_style(),
+                )
+                self.mp_drawing.draw_landmarks(
+                    image=image,
+                    landmark_list=face_landmarks_proto,
+                    connections=self.mp_face_mesh.FACEMESH_CONTOURS,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=self.mp_drawing_styles.get_default_face_mesh_contours_style(),
+                )
+                self.mp_drawing.draw_landmarks(
+                    image=image,
+                    landmark_list=face_landmarks_proto,
+                    connections=self.mp_face_mesh.FACEMESH_IRISES,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=self.mp_drawing_styles.get_default_face_mesh_iris_connections_style(),
+                )
+
+        return image
+
+    def draw_landmark_circles(
+        self,
+        image: np.ndarray,
+        landmark_indices: list,
+        circle_radius: int = 1,
+        circle_color: tuple = (0, 255, 0),
+        circle_thickness: int = 1,
+    ) -> np.ndarray:
+        """
+        Draws circles on the specified face landmarks on the image.
+
+        Args:
+            image (numpy.ndarray): Image on which to draw the landmarks.
+            landmark_indices (list of int): Indices of the landmarks to draw.
+            circle_radius (int, optional): Radius of the circles. Defaults to 1.
+            circle_color (tuple, optional): Color of the circles. Defaults to (0, 255, 0).
+            circle_thickness (int, optional): Thickness of the circles. Defaults to 1.
+
+        Returns:
+            numpy.ndarray: Image with the landmarks drawn.
+        """
+        if self.DETECTION_RESULT:
+            # Draw landmarks.
+            for face_landmarks in self.DETECTION_RESULT.face_landmarks:
+                for i, landmark in enumerate(face_landmarks):
+                    if i in landmark_indices:
+                        # Convert the landmark position to image coordinates.
+                        x = int(landmark.x * image.shape[1])
+                        y = int(landmark.y * image.shape[0])
+                        cv2.circle(
+                            image,
+                            (x, y),
+                            circle_radius,
+                            circle_color,
+                            circle_thickness,
+                        )
+
+        return image
+
+    def detect(self, frame: np.ndarray, draw: bool = False) -> np.ndarray:
+        """
+        Detects the face landmarks in the frame.
+
+        Args:
+            frame (numpy.ndarray): Frame in which to detect the landmarks.
+            draw (bool, optional): Whether to draw the landmarks on the frame. Defaults to False.
+
+        Returns:
+            numpy.ndarray: Frame with the landmarks drawn.
+        """
+        rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)
+        self.detector.detect_async(mp_image, time.time_ns() // 1_000_000)
+        return self.draw_landmarks(frame) if draw else frame
+
+    def get_face_landmarks(self, face_idx: int = 0, idxs: list = None) -> list:
+        """
+        Returns the face landmarks.
+
+        Args:
+            face_idx (int, optional): Index of the face for which to return the landmarks. Defaults to 0.
+            idxs (list, optional): List of indices of the landmarks to return. Defaults to None.
+
+        Returns:
+            list: List of face world landmarks.
+        """
+        if self.DETECTION_RESULT is not None:
+            if idxs is None:
+                return self.DETECTION_RESULT.face_landmarks[face_idx]
+            else:
+                return [
+                    self.DETECTION_RESULT.face_landmarks[face_idx][idx] for idx in idxs
+                ]
+        else:
+            return []
+
+    @staticmethod
+    def download_model() -> str:
+        """
+        Download the face_landmarker task model from the mediapipe repository.
+            https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/latest/face_landmarker.task
+
+        Returns:
+            str: Path to the downloaded model.
+        """
+        root = os.path.dirname(os.path.realpath(__file__))
+        # Unino to res folder
+        root = os.path.join(root, "..", "res")
+        filename = os.path.join(root, "face_landmarker.task")
+        if os.path.exists(filename):
+            print(f"O arquivo {filename} já existe, pulando o download.")
+        else:
+            base = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/latest/face_landmarker.task"
+            urllib.request.urlretrieve(base, filename)
+
+        return filename

src/hand_tracker.py

@@ -0,0 +1,381 @@
+import math
+
+import os
+import urllib.request
+
+import cv2
+import numpy as np
+import mediapipe as mp
+
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
+from mediapipe.framework.formats import landmark_pb2
+
+
+class HandTracker:
+    def __init__(
+        self,
+        model: str = None,
+        num_hands: int = 2,
+        min_hand_detection_confidence: float = 0.5,
+        min_hand_presence_confidence: float = 0.5,
+        min_tracking_confidence: float = 0.5,
+    ):
+        """
+        Initialize a HandTracker instance.
+
+        Args:
+            model (str): The path to the model for hand tracking.
+            num_hands (int): Maximum number of hands to detect.
+            min_hand_detection_confidence (float): Minimum confidence value ([0.0, 1.0]) for successful hand detection.
+            min_hand_presence_confidence (float): Minimum confidence value ([0.0, 1.0]) for presence of a hand to be tracked.
+            min_tracking_confidence (float): Minimum confidence value ([0.0, 1.0]) for successful hand landmark tracking.
+        """
+        self.model = model
+
+        if self.model is None:
+            self.model = self.download_model()
+
+        self.detector = self.initialize_detector(
+            num_hands,
+            min_hand_detection_confidence,
+            min_hand_presence_confidence,
+            min_tracking_confidence,
+        )
+
+        self.mp_hands = mp.solutions.hands
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+        self.DETECTION_RESULT = None
+
+        self.tipIds = [4, 8, 12, 16, 20]
+
+        self.MARGIN = 10  # pixels
+        self.FONT_SIZE = 1
+        self.FONT_THICKNESS = 1
+        self.HANDEDNESS_TEXT_COLOR = (88, 205, 54)  # vibrant green
+
+        # x is the raw distance, y is the value in cm
+        # This values are used to calculate the approximate depth of the hand
+        x = (
+            np.array(
+                [
+                    300,
+                    245,
+                    200,
+                    170,
+                    145,
+                    130,
+                    112,
+                    103,
+                    93,
+                    87,
+                    80,
+                    75,
+                    70,
+                    67,
+                    62,
+                    59,
+                    57,
+                ]
+            )
+            / 1.5
+        )
+        y = [20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
+        self.coff = np.polyfit(x, y, 2)  # y = Ax^2 + Bx + C
+
+    def save_result(
+        self,
+        result: landmark_pb2.NormalizedLandmarkList,
+        unused_output_image,
+        timestamp_ms: int,
+    ):
+        """
+        Saves the result of the detection.
+
+        Args:
+            result (mediapipe.framework.formats.landmark_pb2.NormalizedLandmarkList): Result of the detection.
+            unused_output_image (mediapipe.framework.formats.image_frame.ImageFrame): Unused.
+            timestamp_ms (int): Timestamp of the detection.
+
+        Returns:
+            None
+        """
+        self.DETECTION_RESULT = result
+
+    def initialize_detector(
+        self,
+        num_hands: int,
+        min_hand_detection_confidence: float,
+        min_hand_presence_confidence: float,
+        min_tracking_confidence: float,
+    ):
+        """
+        Initializes the HandLandmarker instance.
+
+        Args:
+            num_hands (int): Maximum number of hands to detect.
+            min_hand_detection_confidence (float): Minimum confidence value ([0.0, 1.0]) for hand detection to be considered successful.
+            min_hand_presence_confidence (float): Minimum confidence value ([0.0, 1.0]) for the presence of a hand for the hand landmarks to be considered tracked successfully.
+            min_tracking_confidence (float): Minimum confidence value ([0.0, 1.0]) for the hand landmarks to be considered tracked successfully.
+
+        Returns:
+            mediapipe.HandLandmarker: HandLandmarker instance.
+        """
+        base_options = python.BaseOptions(model_asset_path=self.model)
+        options = vision.HandLandmarkerOptions(
+            base_options=base_options,
+            # running_mode=vision.RunningMode.LIVE_STREAM,
+            num_hands=num_hands,
+            min_hand_detection_confidence=min_hand_detection_confidence,
+            min_hand_presence_confidence=min_hand_presence_confidence,
+            min_tracking_confidence=min_tracking_confidence,
+            # result_callback=self.save_result,
+        )
+        return vision.HandLandmarker.create_from_options(options)
+
+    def draw_landmarks(
+        self,
+        image: np.ndarray,
+        text_color: tuple = (0, 0, 0),
+        font_size: int = 1,
+        font_thickness: int = 1,
+    ) -> np.ndarray:
+        """
+        Draws the landmarks and handedness on the image.
+
+        Args:
+            image (numpy.ndarray): Image on which to draw the landmarks.
+            text_color (tuple, optional): Color of the text. Defaults to (0, 0, 0).
+            font_size (int, optional): Size of the font. Defaults to 1.
+            font_thickness (int, optional): Thickness of the font. Defaults to 1.
+
+        Returns:
+            numpy.ndarray: Image with the landmarks drawn.
+        """
+
+        if self.DETECTION_RESULT:
+            # Landmark visualization parameters.
+
+            # Draw landmarks and indicate handedness.
+            for idx in range(len(self.DETECTION_RESULT.hand_landmarks)):
+                hand_landmarks = self.DETECTION_RESULT.hand_landmarks[idx]
+                handedness = self.DETECTION_RESULT.handedness[idx]
+
+                # Draw the hand landmarks.
+                hand_landmarks_proto = landmark_pb2.NormalizedLandmarkList()
+                hand_landmarks_proto.landmark.extend(
+                    [
+                        landmark_pb2.NormalizedLandmark(
+                            x=landmark.x, y=landmark.y, z=landmark.z
+                        )
+                        for landmark in hand_landmarks
+                    ]
+                )
+                self.mp_drawing.draw_landmarks(
+                    image,
+                    hand_landmarks_proto,
+                    self.mp_hands.HAND_CONNECTIONS,
+                    self.mp_drawing_styles.get_default_hand_landmarks_style(),
+                    self.mp_drawing_styles.get_default_hand_connections_style(),
+                )
+
+                # Get the top left corner of the detected hand's bounding box.
+                height, width, _ = image.shape
+                x_coordinates = [landmark.x for landmark in hand_landmarks]
+                y_coordinates = [landmark.y for landmark in hand_landmarks]
+                text_x = int(min(x_coordinates) * width)
+                text_y = int(min(y_coordinates) * height) - self.MARGIN
+
+                # Draw handedness (left or right hand) on the image.
+                cv2.putText(
+                    image,
+                    f"{handedness[0].category_name}",
+                    (text_x, text_y),
+                    cv2.FONT_HERSHEY_DUPLEX,
+                    self.FONT_SIZE,
+                    self.HANDEDNESS_TEXT_COLOR,
+                    self.FONT_THICKNESS,
+                    cv2.LINE_AA,
+                )
+
+        return image
+
+    def detect(self, frame: np.ndarray, draw: bool = True) -> np.ndarray:
+        """
+        Detects hands in the image.
+
+        Args:
+            frame (numpy.ndarray): Image in which to detect the hands.
+            draw (bool, optional): Whether to draw the landmarks on the image. Defaults to False.
+
+        Returns:
+            numpy.ndarray: Image with the landmarks drawn if draw is True, else the original image.
+        """
+
+        rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image)
+        self.DETECTION_RESULT = self.detector.detect(mp_image)
+
+        return self.draw_landmarks(frame) if draw else frame
+
+    def raised_fingers(self):
+        """
+        Counts the number of raised fingers.
+
+        Returns:
+            list: List of 1s and 0s, where 1 indicates a raised finger and 0 indicates a lowered finger.
+        """
+        fingers = []
+        if self.DETECTION_RESULT:
+            for idx, hand_landmarks in enumerate(
+                self.DETECTION_RESULT.hand_world_landmarks
+            ):
+                if self.DETECTION_RESULT.handedness[idx][0].category_name == "Right":
+                    if (
+                        hand_landmarks[self.tipIds[0]].x
+                        > hand_landmarks[self.tipIds[0] - 1].x
+                    ):
+                        fingers.append(1)
+                    else:
+                        fingers.append(0)
+                else:
+                    if (
+                        hand_landmarks[self.tipIds[0]].x
+                        < hand_landmarks[self.tipIds[0] - 1].x
+                    ):
+                        fingers.append(1)
+                    else:
+                        fingers.append(0)
+
+                for id in range(1, 5):
+                    if (
+                        hand_landmarks[self.tipIds[id]].y
+                        < hand_landmarks[self.tipIds[id] - 2].y
+                    ):
+                        fingers.append(1)
+                    else:
+                        fingers.append(0)
+        return fingers
+
+    def get_approximate_depth(
+        self, hand_idx: int = 0, width: int = 640, height: int = 480
+    ) -> float:
+        """
+        Calculates the depth of each finger landmark.
+
+        Returns:
+            numpy.ndarray: Mean of the depth of each finger landmark.
+        """
+        if self.DETECTION_RESULT is not None:
+            x1, y1 = (
+                self.DETECTION_RESULT.hand_landmarks[hand_idx][5].x * width,
+                self.DETECTION_RESULT.hand_landmarks[hand_idx][5].y * height,
+            )
+            x2, y2 = (
+                self.DETECTION_RESULT.hand_landmarks[hand_idx][17].x * width,
+                self.DETECTION_RESULT.hand_landmarks[hand_idx][17].y * height,
+            )
+
+            distance = math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
+            A, B, C = self.coff
+
+            return A * distance**2 + B * distance + C
+        else:
+            0
+
+    def get_hand_world_landmarks(self, hand_idx: int = 0):
+        """
+        Returns the hand world landmarks.
+
+        Args:
+            hand_idx (int, optional): Index of the hand for which to return the landmarks. Defaults to 0.
+            0 = Right hand
+            1 = Left hand
+
+        Returns:
+            list: List of hand world landmarks.
+        """
+        return (
+            self.DETECTION_RESULT.hand_world_landmarks[hand_idx]
+            if self.DETECTION_RESULT is not None
+            else []
+        )
+
+    def get_hand_landmarks(self, hand_idx: int = 0, idxs: list = None) -> list:
+        """
+        Returns the hand landmarks.
+
+        Args:
+            hand_idx (int, optional): Index of the hand for which to return the landmarks. Defaults to 0.
+            0 = Right hand
+            1 = Left hand
+            idxs (list, optional): List of indices of the landmarks to return. Defaults to None.
+
+        Returns:
+            list: List of hand world landmarks.
+        """
+        if self.DETECTION_RESULT is not None:
+            if idxs is None:
+                return self.DETECTION_RESULT.hand_landmarks[hand_idx]
+            else:
+                return [
+                    self.DETECTION_RESULT.hand_landmarks[hand_idx][idx] for idx in idxs
+                ]
+
+        else:
+            return []
+
+    def find_distance(self, l1, l2, img, draw=True):
+        """
+        Finds the distance between two landmarks.
+
+        Args:
+            l1 (int): Index of the first landmark.
+            l2 (int): Index of the second landmark.
+            img (numpy.ndarray): Image on which to draw the landmarks.
+            draw (bool, optional): Whether to draw the landmarks on the image. Defaults to True.
+
+        Returns:
+            float: Distance between the two landmarks.
+            numpy.ndarray: Image with the landmarks drawn if draw is True, else the original image.
+            list: List of the coordinates of the two landmarks and the center of the line joining them.
+        """
+        ladnmarks = self.get_hand_landmarks(idxs=[l1, l2])
+        x1, y1 = ladnmarks[0].x * img.shape[1], ladnmarks[0].y * img.shape[0]
+        x2, y2 = ladnmarks[1].x * img.shape[1], ladnmarks[1].y * img.shape[0]
+        cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
+        length = math.hypot(x2 - x1, y2 - y1)
+
+        # Cast points to int
+        x1, y1, x2, y2, cx, cy = map(int, [x1, y1, x2, y2, cx, cy])
+
+        if draw:
+            cv2.circle(img, (x1, y1), 10, (255, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x2, y2), 10, (255, 0, 255), cv2.FILLED)
+            cv2.line(img, (x1, y1), (x2, y2), (255, 0, 255), 3)
+            cv2.circle(img, (cx, cy), 10, (255, 0, 255), cv2.FILLED)
+
+        return length, img, [x1, y1, x2, y2, cx, cy]
+
+    @staticmethod
+    def download_model() -> str:
+        """
+        Downloads the hand landmark model in float16 format from the mediapipe website.
+            https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/latest/hand_landmarker.task
+
+        Returns:
+            str: Path to the downloaded model.
+        """
+        root = os.path.dirname(os.path.realpath(__file__))
+        # Unino to res folder
+        root = os.path.join(root, "..", "res")
+        filename = os.path.join(root, "hand_landmarker.task")
+        if os.path.exists(filename):
+            print(f"O arquivo {filename} já existe, pulando o download.")
+        else:
+            print(f"Baixando o arquivo {filename}...")
+            base = "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/latest/hand_landmarker.task"
+            urllib.request.urlretrieve(base, filename)
+
+        return filename

src/opencv_utils.py

@@ -0,0 +1,246 @@
+import cv2
+import numpy as np
+
+from hand_tracker import HandTracker
+from face_mesh_tracker import FaceMeshTracker
+
+
+class OpenCVUtils:
+
+    def __init__(self) -> None:
+        self.hand_tracker = HandTracker(
+            num_hands=2,
+            min_hand_detection_confidence=0.7,
+            min_hand_presence_confidence=0.7,
+            min_tracking_confidence=0.7,
+        )
+        self.face_mesh_tracker = FaceMeshTracker(
+            num_faces=1,
+            min_face_detection_confidence=0.7,
+            min_face_presence_confidence=0.7,
+            min_tracking_confidence=0.7,
+        )
+
+    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
+
+        :param frame: The frame to detect the face
+        :param draw: If the output should be drawn
+        """
+        return self.face_mesh_tracker.detect(frame, draw=draw)
+
+    def detect_hands(self, frame: np.ndarray, draw: bool = True) -> np.ndarray:
+        """
+        Detect a hand in the frame with the hand tracker of mediapipe
+
+        :param frame: The frame to detect the hand
+        :param draw: If the output should be drawn
+        """
+        result = self.hand_tracker.detect(frame, draw=draw)
+        return result
+
+    def apply_color_filter(
+        self, frame: np.ndarray, lower_bound: list, upper_bound: list
+    ) -> np.ndarray:
+        """
+        Apply a color filter to the frame
+
+        :param frame: The frame to apply the filter
+        :param lower_bound: The lower bound of the color filter in HSV
+        :param upper_bound: The upper bound of the color filter in HSV
+        """
+        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+        lower_bound = np.array([lower_bound[0], lower_bound[1], lower_bound[2]])
+        upper_bound = np.array([upper_bound[0], upper_bound[1], upper_bound[2]])
+        mask = cv2.inRange(hsv, lower_bound, upper_bound)
+        return cv2.bitwise_and(frame, frame, mask=mask)
+
+    def apply_edge_detection(
+        self, frame: np.ndarray, lower_canny: int = 100, upper_canny: int = 200
+    ) -> np.ndarray:
+        """
+        Apply a edge detection to the frame
+
+        :param frame: The frame to apply the filter
+        :param lower_canny: The lower bound of the canny edge detection
+        :param upper_canny: The upper bound of the canny edge detection
+        """
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        edges = cv2.Canny(gray, lower_canny, upper_canny)
+        return cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+
+    def apply_contour_detection(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Apply a contour detection to the frame
+
+        :param frame: The frame to apply the filter
+        """
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        ret, thresh = cv2.threshold(gray, 127, 255, 0)
+        contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(frame, contours, -1, (0, 255, 0), 3)
+        return frame
+
+    def blur_image(self, image: np.ndarray, kernel_size: int = 5) -> np.ndarray:
+        """
+        Apply a blur to the image
+
+        :param image: The image to apply the blur
+        :param kernel_size: The kernel size of the blur
+        """
+        if kernel_size % 2 == 0:
+            kernel_size += 1
+        return cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
+
+    def rotate_image(self, image: np.ndarray, angle: int = 0) -> np.ndarray:
+        """
+        Rotate the image
+
+        :param image: The image to rotate
+        :param angle: The angle to rotate the image
+        """
+        (h, w) = image.shape[:2]
+        center = (w / 2, h / 2)
+
+        M = cv2.getRotationMatrix2D(center, angle, 1.0)
+        return cv2.warpAffine(image, M, (w, h))
+
+    def resize_image(
+        self, image: np.ndarray, width: int = None, height: int = None
+    ) -> np.ndarray:
+        """
+        Resize the image
+
+        :param image: The image to resize
+        :param width: The width of the new image
+        :param height: The height of the new image
+        """
+        dim = None
+        (h, w) = image.shape[:2]
+
+        if width is None and height is None:
+            return image
+
+        if width is None:
+            r = height / float(h)
+            dim = (int(w * r), height)
+        else:
+            r = width / float(w)
+            dim = (width, int(h * r))
+
+        return cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
+
+    def pencil_sketch(
+        self,
+        image: np.ndarray,
+        sigma_s: int = 60,
+        sigma_r: float = 0.07,
+        shade_factor: float = 0.05,
+    ) -> np.ndarray:
+        # Converte para sketch preto e branco
+        gray, sketch = cv2.pencilSketch(
+            image, sigma_s=sigma_s, sigma_r=sigma_r, shade_factor=shade_factor
+        )
+        return sketch
+
+    def stylization(
+        self, image: np.ndarray, sigma_s: int = 60, sigma_r: float = 0.45
+    ) -> np.ndarray:
+        # Efeito de pintura estilizada
+        return cv2.stylization(image, sigma_s=sigma_s, sigma_r=sigma_r)
+
+    def cartoonify(self, image: np.ndarray) -> np.ndarray:
+        # Cartoon: detecta bordas e aplica quantização de cores
+        # 1) Detecção de bordas
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        blur = cv2.medianBlur(gray, 7)
+        edges = cv2.adaptiveThreshold(
+            blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 2
+        )
+        # 2) Redução de cores
+        data = np.float32(image).reshape((-1, 3))
+        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
+        _, label, center = cv2.kmeans(
+            data, 8, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS
+        )
+        center = np.uint8(center)
+        quant = center[label.flatten()].reshape(image.shape)
+        # Combina bordas e quantização
+        cartoon = cv2.bitwise_and(quant, quant, mask=edges)
+        return cartoon
+
+    def color_quantization(self, image: np.ndarray, k: int = 8) -> np.ndarray:
+        # Reduz o número de cores via k-means
+        data = np.float32(image).reshape((-1, 3))
+        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
+        _, label, center = cv2.kmeans(
+            data, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS
+        )
+        center = np.uint8(center)
+        quant = center[label.flatten()].reshape(image.shape)
+        return quant
+
+    def equalize_histogram(self, image: np.ndarray) -> np.ndarray:
+        ycrcb = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb)
+        channels = cv2.split(ycrcb)
+        cv2.equalizeHist(channels[0], channels[0])
+        merged = cv2.merge(channels)
+        return cv2.cvtColor(merged, cv2.COLOR_YCrCb2BGR)
+
+    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)
+
+    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
+        }
+        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]])
+        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)
+        if lines is not None:
+            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)
+        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])
+        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)

src/streamlit_app.py

@@ -0,0 +1,127 @@
+import av
+import cv2
+import numpy as np
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer
+from opencv_utils import OpenCVUtils
+
+st.set_page_config(page_title="OpenCV Explorer", page_icon="🎨", layout="wide")
+
+
+@st.cache_resource
+def get_app():
+    return OpenCVUtils()
+
+
+app = get_app()
+
+# --- HIDE STREAMLIT STYLE ---
+hide_st_style = """
+            <style>
+            #MainMenu {visibility: hidden;}
+            footer {visibility: hidden;}
+            header {visibility: hidden;}
+            </style>
+            """
+st.markdown(hide_st_style, unsafe_allow_html=True)
+# ---------------------------
+
+st.markdown("# 🎨 OpenCV Explorer")
+st.markdown("Explore filters and transformations in real-time using your webcam.")
+
+# Sidebar Controls
+FUNCTIONS = [
+    "Color Filter",
+    "Canny",
+    "Blur",
+    "Rotation",
+    "Resize",
+    "Contour",
+    "Histogram Equalization",
+    "Adaptive Threshold",
+    "Morphology",
+    "Sharpen",
+    "Hough Lines",
+    "Optical Flow",
+    "Pencil Sketch",
+    "Color Quantization",
+    "Hand Tracker",
+    "Face Tracker",
+]
+selected_functions = st.sidebar.multiselect(
+    "Select and order functions:", FUNCTIONS, default=[]
+)
+# Parameters
+with st.sidebar.expander("Color Filter"):
+    lh = st.slider("Lower Hue", 0, 180, 0)
+    uh = st.slider("Upper Hue", 0, 180, 180)
+    ls = st.slider("Lower Sat", 0, 255, 0)
+    us = st.slider("Upper Sat", 0, 255, 255)
+    lv = st.slider("Lower Val", 0, 255, 0)
+    uv = st.slider("Upper Val", 0, 255, 255)
+with st.sidebar.expander("Canny Edge"):
+    lc = st.slider("Lower Canny", 0, 255, 100)
+    uc = st.slider("Upper Canny", 0, 255, 200)
+with st.sidebar.expander("Blur"):
+    bk = st.slider("Kernel Size (odd)", 1, 15, 5, step=2)
+with st.sidebar.expander("Rotation"):
+    ang = st.slider("Angle", 0, 360, 0)
+with st.sidebar.expander("Resize"):
+    w = st.slider("Width", 100, 1920, 640)
+    h = st.slider("Height", 100, 1080, 480)
+with st.sidebar.expander("Morphology"):
+    morph_op = st.selectbox("Operation", ["erode", "dilate", "open", "close"])
+    morph_ks = st.slider("Kernel Size", 1, 31, 5, step=2)
+
+prev_gray = None
+
+
+def video_frame_callback(frame: av.VideoFrame) -> av.VideoFrame:
+    global prev_gray
+    img = frame.to_ndarray(format="bgr24")
+    curr_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+    for fn in selected_functions:
+        if fn == "Color Filter":
+            img = app.apply_color_filter(img, (lh, ls, lv), (uh, us, uv))
+        elif fn == "Canny":
+            img = app.apply_edge_detection(img, lc, uc)
+        elif fn == "Blur":
+            img = app.blur_image(img, bk)
+        elif fn == "Rotation":
+            img = app.rotate_image(img, ang)
+        elif fn == "Resize":
+            img = app.resize_image(img, w, h)
+        elif fn == "Contour":
+            img = app.apply_contour_detection(img)
+        elif fn == "Histogram Equalization":
+            img = app.equalize_histogram(img)
+        elif fn == "Adaptive Threshold":
+            img = app.adaptive_threshold(img)
+        elif fn == "Morphology":
+            img = app.morphology(img, morph_op, morph_ks)
+        elif fn == "Sharpen":
+            img = app.sharpen(img)
+        elif fn == "Hough Lines":
+            img = app.hough_lines(img)
+        elif fn == "Optical Flow" and prev_gray is not None:
+            img = app.optical_flow(prev_gray, curr_gray, img)
+        elif fn == "Pencil Sketch":
+            img = app.pencil_sketch(img)
+        elif fn == "Color Quantization":
+            img = app.color_quantization(img)
+        elif fn == "Hand Tracker":
+            img = app.detect_hands(img)
+        elif fn == "Face Tracker":
+            img = app.detect_faces(img)
+
+    prev_gray = curr_gray
+    return av.VideoFrame.from_ndarray(img, format="bgr24")
+
+
+webrtc_streamer(
+    key="opencv-explorer",
+    video_frame_callback=video_frame_callback,
+    media_stream_constraints={"video": True, "audio": False},
+    async_processing=True,
+)

src/tkinter_app.py

@@ -0,0 +1,713 @@
+import cv2
+import numpy as np
+import time
+
+from tkinter import *
+from tkinter import ttk
+
+from PIL import Image, ImageTk
+
+from opencv_utils import OpenCVUtils
+
+
+class MainWindow:
+    def __init__(self, root: Tk) -> None:
+        self.root = root
+
+        self.font = ("Arial", 12, "bold")
+        self.font_small = ("Arial", 10, "bold")
+
+        self.colors = {
+            "yellow": "#FDCE01",
+            "black": "#1E1E1E",
+            "white": "#FEFEFE",
+        }
+
+        self.congig_interface()
+
+        self.root.bind("<q>", self.close_application)
+
+        self.functions = []
+        self.aplication = OpenCVUtils()
+        self.fps_avg_frame_count = 30
+
+        self.COUNTER, self.FPS = 0, 0
+        self.START_TIME = time.time()
+
+        # For optical flow
+        self.prev_gray = None
+
+    def close_application(self, event) -> None:
+        """
+        Close the application
+
+        :param event: The event that triggered the function
+        """
+        # Libera a webcam e destrói todas as janelas do OpenCV
+        self.cap.release()
+        cv2.destroyAllWindows()
+        self.root.destroy()
+
+    def congig_interface(self) -> None:
+        self.root.geometry("1500x1000")
+        self.root.title("OpenCV + Tkinter")
+        self.root.config(bg=self.colors["black"])
+
+        self.paned_window = PanedWindow(self.root, orient=HORIZONTAL)
+        self.paned_window.pack(fill=BOTH, expand=1)
+
+        # Cria a barra lateral com os sliders
+        self.sidebar = Frame(
+            self.paned_window,
+            width=700,
+            bg=self.colors["black"],
+            background=self.colors["black"],
+            padx=10,
+            pady=10,
+        )
+        self.paned_window.add(self.sidebar)
+
+        # Create a scrollbar for the sidebar
+        canvas = Canvas(self.sidebar, bg=self.colors["black"], highlightthickness=0)
+        scrollbar = Scrollbar(self.sidebar, orient="vertical", command=canvas.yview)
+        scrollable_frame = Frame(
+            canvas,
+            bg=self.colors["black"],
+        )
+
+        scrollable_frame.bind(
+            "<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
+        )
+
+        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
+        canvas.configure(yscrollcommand=scrollbar.set)
+
+        canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+
+        # Cria as trackbars
+        self.color_filter_var = IntVar()
+        self.color_filter_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.apply_color_filter, self.color_filter_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Color Filter",
+            variable=self.color_filter_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        self.lower_hue = Scale(
+            scrollable_frame,
+            from_=0,
+            to=180,
+            orient=HORIZONTAL,
+            label="Lower Hue",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.lower_hue.pack(anchor="center")
+        self.upper_hue = Scale(
+            scrollable_frame,
+            from_=0,
+            to=180,
+            orient=HORIZONTAL,
+            label="Upper Hue",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.upper_hue.pack(anchor="center")
+
+        self.lower_saturation = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Lower Sat",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.lower_saturation.pack(anchor="center")
+        self.upper_saturation = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Upper Sat",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.upper_saturation.pack(anchor="center")
+
+        self.lower_value = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Lower Value",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.lower_value.pack(anchor="center")
+        self.upper_value = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Upper Value",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.upper_value.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.canny_var = IntVar()
+        self.canny_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.apply_edge_detection, self.canny_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Canny",
+            variable=self.canny_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        self.lower_canny = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Lower Canny",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.lower_canny.pack(anchor="center")
+        self.upper_canny = Scale(
+            scrollable_frame,
+            from_=0,
+            to=255,
+            orient=HORIZONTAL,
+            label="Upper Canny",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.upper_canny.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.blur_var = IntVar()
+        self.blur_var.trace_add(
+            "write",
+            lambda *args: self.add_function(self.aplication.blur_image, self.blur_var),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Blur",
+            variable=self.blur_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack(anchor="center")
+
+        self.blur = Scale(
+            scrollable_frame,
+            from_=1,
+            to=15,
+            orient=HORIZONTAL,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.blur.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.rotation_var = IntVar()
+        self.rotation_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.rotate_image, self.rotation_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Rotation",
+            variable=self.rotation_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack(anchor="center")
+
+        self.rotation_angle = Scale(
+            scrollable_frame,
+            from_=0,
+            to=360,
+            orient=HORIZONTAL,
+            label="Rotation Angle",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.rotation_angle.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.resize_var = IntVar()
+        self.resize_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.resize_image, self.resize_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Resize",
+            variable=self.resize_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        Label(
+            scrollable_frame,
+            text="Height",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+        ).pack()
+        self.height = Scale(
+            scrollable_frame,
+            from_=100,
+            to=1080,
+            orient=HORIZONTAL,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.height.pack(anchor="center")
+        self.width = Scale(
+            scrollable_frame,
+            from_=100,
+            to=1920,
+            orient=HORIZONTAL,
+            label="Width",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.width.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.contour_var = IntVar()
+        self.contour_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.apply_contour_detection, self.contour_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Contour",
+            variable=self.contour_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        # Add new OpenCV functions
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.hist_equal_var = IntVar()
+        self.hist_equal_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.equalize_histogram, self.hist_equal_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Histogram Equalization",
+            variable=self.hist_equal_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.adaptive_threshold_var = IntVar()
+        self.adaptive_threshold_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.adaptive_threshold, self.adaptive_threshold_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Adaptive Threshold",
+            variable=self.adaptive_threshold_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.morphology_var = IntVar()
+        self.morphology_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.morphology, self.morphology_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Morphology",
+            variable=self.morphology_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        # Morphology operation options
+        self.morph_op_var = StringVar(value="erode")
+        Label(
+            scrollable_frame,
+            text="Operation",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+        ).pack()
+
+        for op in ["erode", "dilate", "open", "close"]:
+            Radiobutton(
+                scrollable_frame,
+                text=op.capitalize(),
+                variable=self.morph_op_var,
+                value=op,
+                bg=self.colors["black"],
+                fg=self.colors["white"],
+                selectcolor=self.colors["black"],
+                highlightbackground=self.colors["black"],
+            ).pack(anchor="w")
+
+        self.morph_kernel_size = Scale(
+            scrollable_frame,
+            from_=1,
+            to=31,
+            orient=HORIZONTAL,
+            label="Kernel Size",
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+        )
+        self.morph_kernel_size.set(5)
+        self.morph_kernel_size.pack(anchor="center")
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.sharpen_var = IntVar()
+        self.sharpen_var.trace_add(
+            "write",
+            lambda *args: self.add_function(self.aplication.sharpen, self.sharpen_var),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Sharpen",
+            variable=self.sharpen_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.hough_lines_var = IntVar()
+        self.hough_lines_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.hough_lines, self.hough_lines_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Hough Lines",
+            variable=self.hough_lines_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.optical_flow_var = IntVar()
+        self.optical_flow_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.process_optical_flow, self.optical_flow_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Optical Flow",
+            variable=self.optical_flow_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.pencil_sketch_var = IntVar()
+        self.pencil_sketch_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.pencil_sketch, self.pencil_sketch_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Pencil Sketch",
+            variable=self.pencil_sketch_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.color_quantization_var = IntVar()
+        self.color_quantization_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.color_quantization, self.color_quantization_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Color Quantization",
+            variable=self.color_quantization_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.hand_tracker_var = IntVar()
+        self.hand_tracker_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.detect_hands, self.hand_tracker_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Hand Tracker",
+            variable=self.hand_tracker_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        ttk.Separator(scrollable_frame, orient=HORIZONTAL).pack(fill=X, padx=3, pady=3)
+
+        self.face_tracker_var = IntVar()
+        self.face_tracker_var.trace_add(
+            "write",
+            lambda *args: self.add_function(
+                self.aplication.detect_faces, self.face_tracker_var
+            ),
+        )
+        Checkbutton(
+            scrollable_frame,
+            text="Face Tracker",
+            variable=self.face_tracker_var,
+            font=self.font,
+            bg=self.colors["black"],
+            fg=self.colors["white"],
+            highlightbackground=self.colors["black"],
+            selectcolor=self.colors["black"],
+        ).pack()
+
+        # 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)
+
+    def add_function(self, function: callable, var: IntVar) -> None:
+        """
+        Add or remove a function from the list of functions to be applied to the image
+
+        :param function: The function to be added or removed
+        :param var: The variable that controls the function
+        """
+        if var.get() == 1:
+            self.functions.append(function)
+        else:
+            self.functions.remove(function)
+
+    def process_optical_flow(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Special handler for optical flow which needs to track previous frames
+
+        :param frame: The current frame
+        :return: The processed frame with optical flow
+        """
+        curr_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        if self.prev_gray is not None:
+            frame = self.aplication.optical_flow(self.prev_gray, curr_gray, frame)
+
+        self.prev_gray = curr_gray
+        return frame
+
+    def process_image(self, frame: np.ndarray) -> np.ndarray:
+        """
+        Process the image with the functions selected by the user
+
+        :param frame: The image to be processed
+        :return: The processed image
+        """
+        function_dict = {
+            self.aplication.apply_color_filter: [
+                (
+                    self.lower_hue.get(),
+                    self.lower_saturation.get(),
+                    self.lower_value.get(),
+                ),
+                (
+                    self.upper_hue.get(),
+                    self.upper_saturation.get(),
+                    self.upper_value.get(),
+                ),
+            ],
+            self.aplication.apply_edge_detection: [
+                self.lower_canny.get(),
+                self.upper_canny.get(),
+            ],
+            self.aplication.blur_image: [self.blur.get()],
+            self.aplication.rotate_image: [self.rotation_angle.get()],
+            self.aplication.resize_image: [self.width.get(), self.height.get()],
+            self.aplication.morphology: [
+                self.morph_op_var.get(),
+                self.morph_kernel_size.get(),
+            ],
+        }
+
+        for function in self.functions:
+            args = function_dict.get(function, [])
+            frame = function(frame, *args)
+
+        return frame
+
+    def run(self) -> None:
+        """
+        Run the main loop of the tkinter application
+        """
+        # Abre a webcam
+        self.cap = cv2.VideoCapture(0)
+        self.START_TIME = time.time()
+        while True:
+            # Lê um frame da webcam
+            ret, frame = self.cap.read()
+            if not ret:
+                break
+
+            # Aplica as funções do OpenCV
+            frame = self.process_image(frame)
+
+            output = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+            if self.COUNTER % self.fps_avg_frame_count == 0:
+                self.FPS = self.fps_avg_frame_count / (time.time() - self.START_TIME)
+                self.START_TIME = time.time()
+            self.COUNTER += 1
+
+            # Show the FPS
+            fps_text = "FPS = {:.1f}".format(self.FPS)
+
+            cv2.putText(
+                output,
+                fps_text,
+                (24, 30),
+                cv2.FONT_HERSHEY_DUPLEX,
+                1,
+                (0, 0, 0),
+                1,
+                cv2.LINE_AA,
+            )
+
+            # Converte a imagem NumPy para uma imagem PIL
+            pil_image = Image.fromarray(output)
+
+            # Converte a imagem PIL para uma imagem Tkinter
+            tk_image = ImageTk.PhotoImage(pil_image)
+
+            # Exibe a imagem no label
+            self.image_label.config(image=tk_image)
+            self.image_label.image = tk_image
+
+            # Atualiza a janela tkinter
+            self.root.update()
+
+            cv2.waitKey(1)
+
+
+def main():
+    # Cria a janela principal
+    root = Tk()
+    main_window = MainWindow(root)
+    main_window.run()
+
+
+if __name__ == "__main__":
+    main()