Tutorial Membuat Foto Kita Blur dengan Python

1opencv-python
2mediapipe
3numpy

1from enum import Enum
2
3
4class Gesture(str, Enum):
5    NONE = "none"
6    PEACE_SIGN = "peace_sign"

1from dataclasses import dataclass
2
3from src.domain.gesture import Gesture
4
5
6@dataclass(frozen=True)
7class HandDetection:
8    gesture: Gesture
9    landmarks: list[tuple[float, float]]
10
11    @property
12    def has_hand(self) -> bool:
13        return len(self.landmarks) > 0

1from abc import ABC, abstractmethod
2
3import numpy as np
4
5from src.domain.hand_detection import HandDetection
6
7
8class Camera(ABC):
9    @abstractmethod
10    def read(self) -> tuple[bool, np.ndarray | None]:
11        pass
12
13    @abstractmethod
14    def release(self) -> None:
15        pass
16
17
18class HandDetector(ABC):
19    @abstractmethod
20    def detect(self, frame: np.ndarray) -> HandDetection:
21        pass
22
23    @abstractmethod
24    def close(self) -> None:
25        pass

1import cv2
2import numpy as np
3
4from src.domain.interfaces import Camera
5
6
7class WebcamCamera(Camera):
8    def __init__(self, camera_index: int = 0) -> None:
9        self._capture = cv2.VideoCapture(camera_index)
10        self._capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
11        self._capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
12
13    def read(self) -> tuple[bool, np.ndarray | None]:
14        return self._capture.read()
15
16    def release(self) -> None:
17        self._capture.release()

1from pathlib import Path
2from urllib.error import URLError
3from urllib.request import urlretrieve
4
5import cv2
6import mediapipe as mp
7import numpy as np
8
9from src.domain.gesture import Gesture
10from src.domain.hand_detection import HandDetection
11from src.domain.interfaces import HandDetector
12
13
14class MediaPipeHandDetector(HandDetector):
15    MODEL_URL = (
16        "https://storage.googleapis.com/mediapipe-models/hand_landmarker/"
17        "hand_landmarker/float16/latest/hand_landmarker.task"
18    )
19    MODEL_PATH = Path("models") / "hand_landmarker.task"
20
21    def __init__(self) -> None:
22        model_path = self._ensure_model()
23
24        base_options = mp.tasks.BaseOptions(model_asset_path=str(model_path))
25        options = mp.tasks.vision.HandLandmarkerOptions(
26            base_options=base_options,
27            running_mode=mp.tasks.vision.RunningMode.VIDEO,
28            num_hands=1,
29            min_hand_detection_confidence=0.65,
30            min_hand_presence_confidence=0.55,
31            min_tracking_confidence=0.55,
32        )
33
34        self._landmarker = mp.tasks.vision.HandLandmarker.create_from_options(options)
35        self._timestamp_ms = 0
36
37    def detect(self, frame: np.ndarray) -> HandDetection:
38        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
39        rgb_frame = np.ascontiguousarray(rgb_frame)
40        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_frame)
41
42        self._timestamp_ms += 33
43        result = self._landmarker.detect_for_video(mp_image, self._timestamp_ms)
44
45        if not result.hand_landmarks:
46            return HandDetection(Gesture.NONE, [])
47
48        landmarks = result.hand_landmarks[0]
49        points = [(landmark.x, landmark.y) for landmark in landmarks]
50        gesture = Gesture.PEACE_SIGN if self._is_peace_sign(landmarks) else Gesture.NONE
51
52        return HandDetection(gesture, points)
53
54    def close(self) -> None:
55        self._landmarker.close()
56
57    def _is_peace_sign(self, landmarks: list[object]) -> bool:
58        index_open = landmarks[8].y < landmarks[6].y
59        middle_open = landmarks[12].y < landmarks[10].y
60        ring_closed = landmarks[16].y > landmarks[14].y
61        pinky_closed = landmarks[20].y > landmarks[18].y
62
63        index_middle_gap = abs(landmarks[8].x - landmarks[12].x)
64        middle_ring_gap = abs(landmarks[12].x - landmarks[16].x)
65
66        return (
67            index_open
68            and middle_open
69            and ring_closed
70            and pinky_closed
71            and index_middle_gap > 0.035
72            and middle_ring_gap > 0.025
73        )
74
75    def _ensure_model(self) -> Path:
76        if self.MODEL_PATH.exists():
77            return self.MODEL_PATH
78
79        self.MODEL_PATH.parent.mkdir(exist_ok=True)
80
81        try:
82            print("Downloading MediaPipe hand model...")
83            urlretrieve(self.MODEL_URL, self.MODEL_PATH)
84        except (OSError, URLError) as error:
85            raise RuntimeError(
86                "Model MediaPipe belum tersedia. Download hand_landmarker.task "
87                f"dari {self.MODEL_URL}, lalu simpan ke {self.MODEL_PATH}."
88            ) from error
89
90        return self.MODEL_PATH

1from dataclasses import dataclass
2
3import cv2
4import numpy as np
5
6from src.domain.gesture import Gesture
7
8
9@dataclass
10class CameraBlurState:
11    blur_strength: float = 0.0
12    is_blur_active: bool = False
13    manual_blur: bool = False
14
15
16class CameraBlurService:
17    def __init__(self) -> None:
18        self.state = CameraBlurState()
19
20    def toggle_manual_blur(self) -> bool:
21        self.state.manual_blur = not self.state.manual_blur
22        return self.state.manual_blur
23
24    def process_frame(self, frame: np.ndarray, gesture: Gesture) -> tuple[np.ndarray, CameraBlurState]:
25        target_active = gesture == Gesture.PEACE_SIGN or self.state.manual_blur
26        self.state.is_blur_active = target_active
27
28        target_blur = 1.0 if target_active else 0.0
29        easing = 0.12 if target_active else 0.16
30        self.state.blur_strength += (target_blur - self.state.blur_strength) * easing
31
32        if self.state.blur_strength < 0.01:
33            self.state.blur_strength = 0.0
34
35        return self._apply_blur(frame), self.state
36
37    def _apply_blur(self, frame: np.ndarray) -> np.ndarray:
38        if self.state.blur_strength <= 0.0:
39            return frame.copy()
40
41        blur_amount = int(1 + self.state.blur_strength * 70)
42        kernel_size = blur_amount if blur_amount % 2 == 1 else blur_amount + 1
43
44        blurred = cv2.GaussianBlur(frame, (kernel_size, kernel_size), 0)
45
46        alpha = min(1.0, self.state.blur_strength)
47        return cv2.addWeighted(frame, 1.0 - alpha, blurred, alpha, 0)

1from __future__ import annotations
2
3import time
4from datetime import datetime
5from pathlib import Path
6
7import cv2
8import numpy as np
9
10from src.application.camera_blur_service import CameraBlurService, CameraBlurState
11from src.domain.gesture import Gesture
12from src.domain.hand_detection import HandDetection
13from src.domain.interfaces import Camera, HandDetector
14
15
16class OpenCVWindow:
17    WINDOW_NAME = "Foto Kita Blur"
18
19    def __init__(
20        self,
21        camera: Camera,
22        hand_detector: HandDetector,
23        blur_service: CameraBlurService,
24    ) -> None:
25        self._camera = camera
26        self._hand_detector = hand_detector
27        self._blur_service = blur_service
28        self._show_helper = True
29        self._saved_message_until = 0.0
30        self._latest_frame: np.ndarray | None = None
31
32    def run(self) -> None:
33        cv2.namedWindow(self.WINDOW_NAME, cv2.WINDOW_NORMAL)
34
35        while True:
36            ok, frame = self._camera.read()
37            if not ok or frame is None:
38                break
39
40            frame = cv2.flip(frame, 1)
41
42            detection = self._hand_detector.detect(frame)
43            rendered_frame, state = self._blur_service.process_frame(frame, detection.gesture)
44            rendered_frame = self._render_overlay(rendered_frame, state, detection)
45
46            self._latest_frame = rendered_frame
47            cv2.imshow(self.WINDOW_NAME, rendered_frame)
48
49            key = cv2.waitKey(1) & 0xFF
50
51            if key == ord("q"):
52                break
53
54            if key == ord("s"):
55                self._save_current_frame()
56
57            if key == ord("b"):
58                self._blur_service.toggle_manual_blur()
59
60            if key == ord("h"):
61                self._show_helper = not self._show_helper
62
63        cv2.destroyAllWindows()
64
65    def _render_overlay(
66        self,
67        frame: np.ndarray,
68        state: CameraBlurState,
69        detection: HandDetection,
70    ) -> np.ndarray:
71        height, width = frame.shape[:2]
72        overlay = frame.copy()
73
74        if detection.has_hand:
75            self._draw_finger_indicators(overlay, detection.landmarks, detection.gesture)
76
77        if self._show_helper:
78            status = "blur aktif" if state.is_blur_active else "angkat dua jari"
79            hint = "s save   b blur   h helper   q quit"
80
81            self._draw_text(overlay, status, (24, height - 42), scale=0.5, thickness=1)
82            self._draw_text(overlay, hint, (24, height - 20), scale=0.38, thickness=1, alpha=0.74)
83
84        elif detection.gesture != Gesture.PEACE_SIGN and not state.is_blur_active:
85            self._draw_text(
86                overlay,
87                "show peace sign",
88                (28, height - 28),
89                scale=0.48,
90                thickness=1,
91                alpha=0.72,
92            )
93
94        if time.time() < self._saved_message_until:
95            text = "saved to captures/"
96            size, _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.48, 1)
97
98            self._draw_text(
99                overlay,
100                text,
101                (width - size[0] - 28, height - 26),
102                scale=0.48,
103                thickness=1,
104                alpha=0.9,
105            )
106
107        return overlay
108
109    def _draw_finger_indicators(
110        self,
111        frame: np.ndarray,
112        landmarks: list[tuple[float, float]],
113        gesture: Gesture,
114    ) -> None:
115        if len(landmarks) < 21:
116            return
117
118        height, width = frame.shape[:2]
119        points = [(int(x * width), int(y * height)) for x, y in landmarks]
120
121        finger_lines = [
122            (0, 1, 2, 3, 4),
123            (0, 5, 6, 7, 8),
124            (0, 9, 10, 11, 12),
125            (0, 13, 14, 15, 16),
126            (0, 17, 18, 19, 20),
127        ]
128
129        for line in finger_lines:
130            is_peace_finger = line[1] in (5, 9)
131
132            color = (
133                (80, 255, 120)
134                if gesture == Gesture.PEACE_SIGN and is_peace_finger
135                else (230, 230, 230)
136            )
137
138            thickness = 3 if gesture == Gesture.PEACE_SIGN and is_peace_finger else 1
139
140            for start_index, end_index in zip(line, line[1:]):
141                cv2.line(
142                    frame,
143                    points[start_index],
144                    points[end_index],
145                    color,
146                    thickness,
147                    cv2.LINE_AA,
148                )
149
150        for point in points:
151            cv2.circle(frame, point, 3, (240, 240, 240), -1, cv2.LINE_AA)
152
153        if gesture == Gesture.PEACE_SIGN:
154            cv2.circle(frame, points[8], 5, (80, 255, 120), -1, cv2.LINE_AA)
155            cv2.circle(frame, points[12], 5, (80, 255, 120), -1, cv2.LINE_AA)
156
157    def _draw_text(
158        self,
159        frame: np.ndarray,
160        text: str,
161        origin: tuple[int, int],
162        scale: float,
163        thickness: int,
164        alpha: float = 0.86,
165    ) -> None:
166        font = cv2.FONT_HERSHEY_SIMPLEX
167        shadow_color = (10, 10, 10)
168        text_color = (238, 238, 238)
169
170        shadow = frame.copy()
171        cv2.putText(
172            shadow,
173            text,
174            (origin[0] + 1, origin[1] + 1),
175            font,
176            scale,
177            shadow_color,
178            thickness + 2,
179            cv2.LINE_AA,
180        )
181        cv2.addWeighted(shadow, 0.46, frame, 0.54, 0, frame)
182
183        text_layer = frame.copy()
184        cv2.putText(
185            text_layer,
186            text,
187            origin,
188            font,
189            scale,
190            text_color,
191            thickness,
192            cv2.LINE_AA,
193        )
194        cv2.addWeighted(text_layer, alpha, frame, 1.0 - alpha, 0, frame)
195
196    def _save_current_frame(self) -> None:
197        if self._latest_frame is None:
198            return
199
200        captures_dir = Path("captures")
201        captures_dir.mkdir(exist_ok=True)
202
203        filename = datetime.now().strftime("capture_%Y%m%d_%H%M%S.jpg")
204        cv2.imwrite(str(captures_dir / filename), self._latest_frame)
205
206        self._saved_message_until = time.time() + 1.0

1from src.application.camera_blur_service import CameraBlurService
2from src.infrastructure.mediapipe_hand_detector import MediaPipeHandDetector
3from src.infrastructure.webcam_camera import WebcamCamera
4from src.presentation.opencv_window import OpenCVWindow
5
6
7def main() -> None:
8    camera = WebcamCamera(camera_index=0)
9    hand_detector = MediaPipeHandDetector()
10    blur_service = CameraBlurService()
11    window = OpenCVWindow(camera, hand_detector, blur_service)
12
13    try:
14        window.run()
15    finally:
16        hand_detector.close()
17        camera.release()
18
19
20if __name__ == "__main__":
21    main()

1py -m pip install -r requirements.txt
2py -m compileall .
3py main.py