15_3_contours.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3a71339c-7eb0-4845-845e-d93ecd7587f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Posicione sua mão fora da câmera e pressione 's' para capturar o fundo.\n",
      "Pressione 'q' para sair do jogo.\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import time\n",
    "import random\n",
    "\n",
    "# ============================================\n",
    "# 1. Configurações e Inicializações\n",
    "# ============================================\n",
    "\n",
    "# Definir a área mínima aceitável para o convex hull\n",
    "MIN_HULL_AREA = 1000  # Ajuste esse valor conforme necessário\n",
    "\n",
    "# Caminho para o sprite\n",
    "FOLDER = 'pokemon_dataset/images/'\n",
    "POKEMON = 'abra'\n",
    "\n",
    "def setup_webcam(index=1):\n",
    "    \"\"\"Inicializa a captura de vídeo da webcam.\"\"\"\n",
    "    cap = cv2.VideoCapture(index)\n",
    "    if not cap.isOpened():\n",
    "        print(\"Erro ao abrir a webcam\")\n",
    "        exit()\n",
    "    return cap\n",
    "\n",
    "def create_trackbars():\n",
    "    \"\"\"Cria uma janela com trackbars para ajuste de HSV.\"\"\"\n",
    "    def nothing(x):\n",
    "        pass\n",
    "    \n",
    "    cv2.namedWindow('Trackbars')\n",
    "    cv2.createTrackbar('H Min', 'Trackbars', 0, 179, nothing)\n",
    "    cv2.createTrackbar('H Max', 'Trackbars', 179, 179, nothing)\n",
    "    cv2.createTrackbar('S Min', 'Trackbars', 0, 255, nothing)\n",
    "    cv2.createTrackbar('S Max', 'Trackbars', 255, 255, nothing)\n",
    "    cv2.createTrackbar('V Min', 'Trackbars', 0, 255, nothing)\n",
    "    cv2.createTrackbar('V Max', 'Trackbars', 255, 255, nothing)\n",
    "\n",
    "def load_sprite(folder, pokemon):\n",
    "    \"\"\"Carrega a imagem do sprite com canal alfa.\"\"\"\n",
    "    sprite = cv2.imread(f\"{folder}{pokemon}.png\", cv2.IMREAD_UNCHANGED)\n",
    "    if sprite is None:\n",
    "        print(f\"Erro ao carregar o sprite: {folder}{pokemon}.png\")\n",
    "        exit()\n",
    "    return sprite\n",
    "\n",
    "# ============================================\n",
    "# 2. Captura de Fundo\n",
    "# ============================================\n",
    "\n",
    "def capture_background(cap):\n",
    "    \"\"\"Captura uma imagem de fundo quando o usuário pressiona 's'.\"\"\"\n",
    "    print(\"Posicione sua mão fora da câmera e pressione 's' para capturar o fundo.\")\n",
    "    print(\"Pressione 'q' para sair do jogo.\")\n",
    "    while True:\n",
    "        success, background = cap.read()\n",
    "        if not success:\n",
    "            print(\"Falha ao capturar o frame de fundo.\")\n",
    "            continue\n",
    "        cv2.imshow('Captura de Fundo', background)\n",
    "        key = cv2.waitKey(1) & 0xFF\n",
    "        if key == ord('s'):\n",
    "            break\n",
    "        elif key == ord('q'):\n",
    "            cap.release()\n",
    "            cv2.destroyAllWindows()\n",
    "            exit()\n",
    "    cv2.destroyWindow('Captura de Fundo')\n",
    "    return background\n",
    "\n",
    "# ============================================\n",
    "# 3. Processamento de Frames\n",
    "# ============================================\n",
    "\n",
    "def get_hsv_values():\n",
    "    \"\"\"Obtém os valores atuais das trackbars para HSV.\"\"\"\n",
    "    h_min = cv2.getTrackbarPos('H Min', 'Trackbars')\n",
    "    h_max = cv2.getTrackbarPos('H Max', 'Trackbars')\n",
    "    s_min = cv2.getTrackbarPos('S Min', 'Trackbars')\n",
    "    s_max = cv2.getTrackbarPos('S Max', 'Trackbars')\n",
    "    v_min = cv2.getTrackbarPos('V Min', 'Trackbars')\n",
    "    v_max = cv2.getTrackbarPos('V Max', 'Trackbars')\n",
    "    return h_min, h_max, s_min, s_max, v_min, v_max\n",
    "\n",
    "def create_skin_mask(frame, background, hsv_limits):\n",
    "    \"\"\"Cria uma máscara para a cor da pele baseada nos limites de HSV.\"\"\"\n",
    "    # Subtrair o fundo do frame atual\n",
    "    fg_mask = cv2.absdiff(background, frame)\n",
    "    \n",
    "    # Converter a foreground mask para Grayscale para melhor visualização\n",
    "    fg_mask_gray = cv2.cvtColor(fg_mask, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    # Exibir a subtração de fundo em grayscale para fins de explicação\n",
    "    cv2.imshow('Foreground Mask', fg_mask_gray)  # Janela atualizada\n",
    "    \n",
    "    # Converter o frame para o espaço de cor HSV\n",
    "    hsv = cv2.cvtColor(fg_mask, cv2.COLOR_BGR2HSV)\n",
    "    \n",
    "    # Definir os limites para a cor da pele em HSV\n",
    "    lower_skin = np.array([hsv_limits[0], hsv_limits[2], hsv_limits[4]], dtype=np.uint8)\n",
    "    upper_skin = np.array([hsv_limits[1], hsv_limits[3], hsv_limits[5]], dtype=np.uint8)\n",
    "    \n",
    "    # Criar uma máscara para a cor da pele\n",
    "    skin_mask = cv2.inRange(hsv, lower_skin, upper_skin)\n",
    "    \n",
    "    # Aplicar operações morfológicas para limpar a máscara\n",
    "    kernel = np.ones((3, 3), np.uint8)\n",
    "    skin_mask = cv2.erode(skin_mask, kernel, iterations=2)\n",
    "    skin_mask = cv2.dilate(skin_mask, kernel, iterations=2)\n",
    "    \n",
    "    return skin_mask\n",
    "\n",
    "# ============================================\n",
    "# 4. Detecção de Contornos e Convex Hull\n",
    "# ============================================\n",
    "\n",
    "def find_largest_convex_hull(skin_mask):\n",
    "    \"\"\"Encontra o maior contorno e calcula seu convex hull.\"\"\"\n",
    "    contours, _ = cv2.findContours(skin_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    if not contours:\n",
    "        return None, 0, False\n",
    "    largest_contour = max(contours, key=cv2.contourArea)\n",
    "    hull = cv2.convexHull(largest_contour)\n",
    "    hull_area = cv2.contourArea(hull)\n",
    "    hull_valid = hull_area >= MIN_HULL_AREA\n",
    "    return hull, hull_area, hull_valid\n",
    "\n",
    "# ============================================\n",
    "# 5. Atualização do Sprite\n",
    "# ============================================\n",
    "\n",
    "def update_sprite_position(sprite_pos, sprite_speed, frame_dimensions, sprite_width, sprite_height):\n",
    "    \"\"\"Atualiza a posição do sprite e verifica colisões com as bordas.\"\"\"\n",
    "    sprite_x, sprite_y = sprite_pos\n",
    "    speed_x, speed_y = sprite_speed\n",
    "    sprite_x += speed_x\n",
    "    sprite_y += speed_y\n",
    "\n",
    "    frame_width, frame_height = frame_dimensions\n",
    "\n",
    "    # Verificar colisão com as bordas\n",
    "    if sprite_x < 0 or sprite_x + sprite_width > frame_width:\n",
    "        speed_x *= -1\n",
    "    if sprite_y < 0 or sprite_y + sprite_height > frame_height:\n",
    "        speed_y *= -1\n",
    "\n",
    "    sprite_x = max(0, min(sprite_x, frame_width - sprite_width))\n",
    "    sprite_y = max(0, min(sprite_y, frame_height - sprite_height))\n",
    "\n",
    "    return (sprite_x, sprite_y), (speed_x, speed_y)\n",
    "\n",
    "# ============================================\n",
    "# 6. Renderização\n",
    "# ============================================\n",
    "\n",
    "def render_sprite(frame, sprite, position):\n",
    "    \"\"\"Desenha o sprite na posição especificada com transparência.\"\"\"\n",
    "    sprite_x, sprite_y = position\n",
    "    sprite_overlay = sprite[:, :, :3]\n",
    "    alpha_mask = sprite[:, :, 3] / 255.0\n",
    "    for c in range(3):\n",
    "        frame[sprite_y:sprite_y + sprite.shape[0],\n",
    "              sprite_x:sprite_x + sprite.shape[1], c] = \\\n",
    "            sprite_overlay[:, :, c] * alpha_mask + \\\n",
    "            frame[sprite_y:sprite_y + sprite.shape[0],\n",
    "                  sprite_x:sprite_x + sprite.shape[1], c] * (1 - alpha_mask)\n",
    "    return frame\n",
    "\n",
    "# ============================================\n",
    "# 7. Função Principal\n",
    "# ============================================\n",
    "\n",
    "def main():\n",
    "    # Inicializações\n",
    "    cap = setup_webcam()\n",
    "    create_trackbars()\n",
    "    sprite = load_sprite(FOLDER, POKEMON)\n",
    "    frame_width, frame_height = 640, 480  # Ajuste conforme necessário\n",
    "    sprite_width, sprite_height = sprite.shape[1], sprite.shape[0]\n",
    "    \n",
    "    # Inicializar a posição e velocidade do sprite\n",
    "    sprite_x = random.randint(0, frame_width - sprite_width)\n",
    "    sprite_y = random.randint(0, frame_height - sprite_height)\n",
    "    sprite_speed_x = random.choice([-5, 5])\n",
    "    sprite_speed_y = random.choice([-5, 5])\n",
    "\n",
    "    score = 0\n",
    "    game_started = False\n",
    "    prev_time = time.time()\n",
    "\n",
    "    # Capturar a imagem de fundo\n",
    "    background = capture_background(cap)\n",
    "\n",
    "    while True:\n",
    "        ret, frame = cap.read()\n",
    "        if not ret:\n",
    "            print(\"Falha ao capturar o frame\")\n",
    "            break\n",
    "\n",
    "        # Redimensionar frame se necessário\n",
    "        frame = cv2.resize(frame, (frame_width, frame_height))\n",
    "\n",
    "        # Processamento de frame\n",
    "        hsv_limits = get_hsv_values()\n",
    "        skin_mask = create_skin_mask(frame, background, hsv_limits)\n",
    "\n",
    "        # Detecção de convex hull\n",
    "        hull, hull_area, hull_valid = find_largest_convex_hull(skin_mask)\n",
    "        if hull_valid:\n",
    "            cv2.drawContours(frame, [hull], -1, (0, 255, 0), 2)\n",
    "\n",
    "        # Estado do jogo\n",
    "        if not game_started:\n",
    "            cv2.putText(frame, \"Aperte 'n' para iniciar o jogo\", (50, 240),\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)\n",
    "            cv2.imshow('Webcam - Convex Hull', frame)\n",
    "            cv2.imshow('Webcam - Threshold', skin_mask)\n",
    "            key = cv2.waitKey(1) & 0xFF\n",
    "            if key == ord('n'):\n",
    "                game_started = True\n",
    "            elif key == ord('q'):\n",
    "                break\n",
    "            continue\n",
    "\n",
    "        # Atualizar posição do sprite\n",
    "        (sprite_x, sprite_y), (sprite_speed_x, sprite_speed_y) = update_sprite_position(\n",
    "            (sprite_x, sprite_y),\n",
    "            (sprite_speed_x, sprite_speed_y),\n",
    "            (frame_width, frame_height),\n",
    "            sprite_width,\n",
    "            sprite_height\n",
    "        )\n",
    "\n",
    "        # Verificar colisão com o convex hull\n",
    "        if hull_valid:\n",
    "            for point in hull:\n",
    "                px, py = point[0]\n",
    "                if sprite_x < px < sprite_x + sprite_width and sprite_y < py < sprite_y + sprite_height:\n",
    "                    score += 1\n",
    "                    # Resetar a posição e velocidade do sprite\n",
    "                    sprite_x = random.randint(0, frame_width - sprite_width)\n",
    "                    sprite_y = random.randint(0, frame_height - sprite_height)\n",
    "                    sprite_speed_x = random.choice([-5, 5])\n",
    "                    sprite_speed_y = random.choice([-5, 5])\n",
    "                    break\n",
    "\n",
    "        # Renderizar sprite\n",
    "        frame = render_sprite(frame, sprite, (sprite_x, sprite_y))\n",
    "\n",
    "        # Calcular FPS\n",
    "        curr_time = time.time()\n",
    "        fps = 1 / (curr_time - prev_time) if (curr_time - prev_time) > 0 else 0\n",
    "        prev_time = curr_time\n",
    "\n",
    "        # Adicionar informações na tela\n",
    "        cv2.putText(frame, f'FPS: {int(fps)}', (10, 30),\n",
    "                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2, cv2.LINE_AA)\n",
    "        if hull_valid:\n",
    "            cv2.putText(frame, f'Area: {int(hull_area)}', (10, 50),\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2, cv2.LINE_AA)\n",
    "        else:\n",
    "            cv2.putText(frame, 'Mao nao detectada ou muito pequena', (10, 50),\n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2, cv2.LINE_AA)\n",
    "        cv2.putText(frame, f'Score: {int(score)}', (10, 70),\n",
    "                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2, cv2.LINE_AA)\n",
    "\n",
    "        # Exibir frames\n",
    "        cv2.imshow('Webcam - Convex Hull', frame)\n",
    "        cv2.imshow('Webcam - Threshold', skin_mask)\n",
    "\n",
    "        # Controle de saída\n",
    "        key = cv2.waitKey(1) & 0xFF\n",
    "        if key == ord('q'):\n",
    "            break\n",
    "\n",
    "    # Encerramento\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ep_15",
   "language": "python",
   "name": "ep_15"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}