trial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "from tkinter import ttk\n",
    "\n",
    "def create_pokemon_frame(container, name):\n",
    "    frame = ttk.Frame(container, padding=10)\n",
    "\n",
    "    ttk.Label(frame, text=name, font=(\"Arial\", 20)).grid(column=0, row=0, sticky=\"W\")\n",
    "    ttk.Label(frame, text=\"Fast Move: 3\").grid(column=0, row=1, sticky=\"W\")\n",
    "    ttk.Label(frame, text=\"Charge Move 1: 5\").grid(column=0, row=2, sticky=\"W\")\n",
    "    ttk.Label(frame, text=\"Charge Move 2: 4\").grid(column=0, row=3, sticky=\"W\")\n",
    "\n",
    "    return frame\n",
    "\n",
    "def main():\n",
    "    root = tk.Tk()\n",
    "    root.title(\"Pokemon Battle Assistant\")\n",
    "\n",
    "    mainframe = ttk.Frame(root, padding=\"30 30 30 30\")\n",
    "    mainframe.grid(column=0, row=0, sticky=(tk.W, tk.E, tk.N, tk.S))\n",
    "\n",
    "    opponent_frame = ttk.LabelFrame(mainframe, text=\"Opponent's Pokemon\", padding=20)\n",
    "    opponent_frame.grid(column=0, row=0, sticky=(tk.W, tk.E))\n",
    "\n",
    "    for i in range(3):\n",
    "        create_pokemon_frame(opponent_frame, f\"Pokemon {i + 1}\").grid(column=i, row=0)\n",
    "\n",
    "    info_frame = ttk.Frame(mainframe, padding=20)\n",
    "    info_frame.grid(column=0, row=1, sticky=(tk.W, tk.E))\n",
    "\n",
    "    ttk.Label(info_frame, text=\"Switch Timer: 00:00\").grid(column=0, row=0, sticky=\"W\")\n",
    "    ttk.Label(info_frame, text=\"Correct Alignment: Yes\").grid(column=1, row=0, sticky=\"W\")\n",
    "\n",
    "    ttk.Button(info_frame, text=\"Reset UI\").grid(column=2, row=0)\n",
    "    ttk.Button(info_frame, text=\"Start/Stop Recording\").grid(column=3, row=0)\n",
    "\n",
    "    your_frame = ttk.LabelFrame(mainframe, text=\"Your Pokemon\", padding=20)\n",
    "    your_frame.grid(column=0, row=2, sticky=(tk.W, tk.E))\n",
    "\n",
    "    for i in range(3):\n",
    "        create_pokemon_frame(your_frame, f\"Pokemon {i + 1}\").grid(column=i, row=0)\n",
    "\n",
    "    root.mainloop()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "import customtkinter as ctk\n",
    "import time\n",
    "\n",
    "class PokemonFrame(ctk.CTkFrame):\n",
    "    def __init__(self, master, name):\n",
    "        super().__init__(master)\n",
    "\n",
    "        self.pokemon_name_label = ctk.CTkLabel(self, text=name, font=(\"Arial\", 20))\n",
    "        self.pokemon_name_label.grid(column=0, row=0, sticky=\"W\", padx=10, pady=10)\n",
    "\n",
    "        self.fast_move_label = ctk.CTkLabel(self, text=\"Fast Move: \")\n",
    "        self.fast_move_label.grid(column=0, row=1, sticky=\"W\", padx=10, pady=10)\n",
    "\n",
    "        self.charge_move1_label = ctk.CTkLabel(self, text=\"Charge Move 1: \")\n",
    "        self.charge_move1_label.grid(column=0, row=2, sticky=\"W\", padx=10, pady=10)\n",
    "\n",
    "        self.charge_move2_label = ctk.CTkLabel(self, text=\"Charge Move 2: \")\n",
    "        self.charge_move2_label.grid(column=0, row=3, sticky=\"W\", padx=10, pady=10)\n",
    "\n",
    "\n",
    "class PokemonBattleAssistant(ctk.CTk):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.title(\"Pokemon Battle Assistant\")\n",
    "\n",
    "        mainframe = ctk.CTkFrame(self)\n",
    "        mainframe.grid(column=0, row=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=30, pady=30)\n",
    "\n",
    "        opponent_frame = ctk.CTkLabel(mainframe, text=\"Opponent's Pokemon\")\n",
    "        opponent_frame.grid(column=0, row=0, sticky=(tk.W, tk.E), padx=20, pady=20)\n",
    "        opponent_frame.grid_columnconfigure((0, 1, 2), weight=1) \n",
    "\n",
    "        self.opp_pokemon_frames = [PokemonFrame(opponent_frame, f\"Pokemon {i + 1}\") for i in range(3)]\n",
    "        for i, frame in enumerate(self.opp_pokemon_frames):\n",
    "            frame.grid(column=i, row=0, padx=10, pady=10)\n",
    "\n",
    "        info_frame = ctk.CTkFrame(mainframe)\n",
    "        info_frame.grid(column=0, row=1, sticky=(tk.W, tk.E), padx=20, pady=20)\n",
    "\n",
    "        self.switch_timer_label = ctk.CTkLabel(info_frame, text=\"Switch Timer: \")\n",
    "        self.switch_timer_label.grid(column=0, row=0, sticky=\"W\", padx=(10,70), pady=10)\n",
    "\n",
    "        self.correct_alignment_label = ctk.CTkLabel(info_frame, text=\"Correct Alignment: \")\n",
    "        self.correct_alignment_label.grid(column=1, row=0, sticky=\"W\", padx=(0,70), pady=10)\n",
    "\n",
    "        ctk.CTkButton(info_frame, text=\"Reset UI\", command=self.reset_ui).grid(column=2, row=0, padx=10, pady=10)\n",
    "        ctk.CTkButton(info_frame, text=\"Start/Stop Recording\").grid(column=3, row=0, padx=10, pady=10)\n",
    "\n",
    "\n",
    "        your_frame = ctk.CTkLabel(mainframe, text=\"Your Pokemon\")\n",
    "        your_frame.grid(column=0, row=2, sticky=(tk.W, tk.E), padx=20, pady=20)\n",
    "        your_frame.grid_columnconfigure((0, 1, 2), weight=1) \n",
    "\n",
    "        for i in range(3):\n",
    "            PokemonFrame(your_frame, f\"Pokemon {i + 1}\").grid(column=i, row=0, padx=10, pady=10)        \n",
    "    def reset_ui(self):\n",
    "        # Reset all labels here\n",
    "        pass\n",
    "\n",
    "    def update_ui(self):\n",
    "        # Here you put the logic for updating the UI\n",
    "        self.update_label(0, \"pokemon_name_label\", \"New Pokemon Name\")\n",
    "\n",
    "        self.after(2000, self.update_ui)\n",
    "\n",
    "\n",
    "    def update_opp_label(self, index, name_of_variable, new_value):\n",
    "        frame = self.opp_pokemon_frames[index]\n",
    "        label = getattr(frame, name_of_variable)\n",
    "        label.configure(text=new_value)\n",
    "\n",
    "\n",
    "    def update_my_label(self, index, name_of_variable, new_value):\n",
    "        frame = self.opp_pokemon_frames[index]\n",
    "        label = getattr(frame, name_of_variable)\n",
    "        label.configure(text=new_value)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app = PokemonBattleAssistant()\n",
    "    app.after(2000, app.update_ui)\n",
    "    app.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import utils\n",
    "# Load your data\n",
    "with open('json_files/pokemon.json', 'r') as f:\n",
    "    pokemon_details = json.load(f)\n",
    "\n",
    "moves = utils.load_moves_info()\n",
    "\n",
    "temp_corrected_opp_name = 'Giratina'\n",
    "temp_corrected_my_name = 'Trevenant'\n",
    "opp_move_data = [item for item in pokemon_details if temp_corrected_opp_name and item['speciesName'].startswith(temp_corrected_opp_name)]\n",
    "my_move_data = [item for item in pokemon_details if temp_corrected_my_name and item['speciesName'].startswith(temp_corrected_my_name)]\n",
    "\n",
    "league = 'Ultra League'\n",
    "for data in [opp_move_data,my_move_data]:\n",
    "    for entry in data:\n",
    "        print(f\"Species Name: {entry['speciesName']}\")\n",
    "        print(f\"Fast Moves: {', '.join(entry['fastMoves'])}\")\n",
    "        print(f\"Charged Moves: {', '.join(entry['chargedMoves'])}\")\n",
    "        print(\"\\n\")\n",
    "\n",
    "# Check if either Pokémon is Giratina and change form based on the league\n",
    "if temp_corrected_my_name == \"Giratina\":\n",
    "    if league in [\"great-league\", \"ultra-league\"]:\n",
    "        temp_corrected_my_name = \"Giratina (Altered)\"\n",
    "    else:\n",
    "        temp_corrected_my_name = \"Giratina (Origin)\"\n",
    "\n",
    "if temp_corrected_opp_name == \"Giratina\":\n",
    "    if league in [\"great-league\", \"ultra-league\"]:\n",
    "        temp_corrected_opp_name = \"Giratina (Altered)\"\n",
    "    else:\n",
    "        temp_corrected_opp_name = \"Giratina (Origin)\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[pok['speciesName'] for pok in opp_move_data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "league_pok = f\"json_files/rankings/{league}.json\"\n",
    "\n",
    "with open(league_pok, 'r') as file:\n",
    "    league_pok = json.load(file)\n",
    "    print(f\"Loaded {league} JSON data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_moveset_and_counts_2(pokemon_data, moves_data):\n",
    "    moveset = []\n",
    "    for pokemon in pokemon_data:\n",
    "        pokemon_moves = []\n",
    "        for fast_move in pokemon['fastMoves']:\n",
    "            for move in moves_data:\n",
    "                if fast_move.lower() == move['moveId'].lower():\n",
    "                    fast_move_data = move\n",
    "                    break\n",
    "            fast_count = round(fast_move_data['cooldown'] / 500)\n",
    "            fast_move_entry = {'fast_move': [fast_move, fast_count], 'charged_moves': []}\n",
    "            for charged_move in pokemon['chargedMoves']:\n",
    "                for move in moves_data:\n",
    "                    if charged_move.lower() == move['moveId'].lower():\n",
    "                        fast_move_entry['charged_moves'].append([charged_move, utils.calculate_move_counts(fast_move_data, move)])\n",
    "                        break\n",
    "            pokemon_moves.append(fast_move_entry)\n",
    "        moveset.append(pokemon_moves)\n",
    "\n",
    "    return moveset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "# Load the input data\n",
    "with open('json_files/pokemon.json') as f:\n",
    "    data = json.load(f)\n",
    "\n",
    "# Prepare output data structure\n",
    "output = {\n",
    "    \"images\": [],\n",
    "    \"annotations\": [],\n",
    "    \"categories\": []\n",
    "}\n",
    "\n",
    "# Assign a unique ID to each species\n",
    "species_id = 1\n",
    "\n",
    "# Loop through the input data\n",
    "for item in data:\n",
    "    # Extract species name\n",
    "    species_name = item.get('speciesName', '')\n",
    "\n",
    "    # Add species with states to categories\n",
    "    for state in ['Idle', 'Attacking']:\n",
    "        output[\"categories\"].append({\n",
    "            \"id\": species_id,\n",
    "            \"name\": f\"{species_name}_{state}\"\n",
    "        })\n",
    "        species_id += 1\n",
    "\n",
    "# Write output data to file\n",
    "# with open('classes.json', 'w') as f:\n",
    "#     json.dump(output, f, indent=4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "# Load the input data\n",
    "with open('json_files/pokemon.json') as f:\n",
    "    data = json.load(f)\n",
    "\n",
    "# Open the output file\n",
    "with open('species_states.txt', 'w') as f:\n",
    "    # Loop through the input data\n",
    "    for item in data:\n",
    "        # Extract species name\n",
    "        species_name = item.get('speciesName', '')\n",
    "\n",
    "        # Write species name with states to file\n",
    "        for state in ['Idle', 'Attacking']:\n",
    "            f.write(f\"{species_name}_{state}\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, QLabel, QDockWidget, QListWidget, QAction\n",
    "from PyQt5.QtGui import QPixmap\n",
    "from PyQt5.QtCore import Qt\n",
    "import sys\n",
    "\n",
    "class MainWindow(QMainWindow):\n",
    "    def __init__(self):\n",
    "        super(MainWindow, self).__init__()\n",
    "\n",
    "        # Create a label to hold the image\n",
    "        self.imageLabel = QLabel(self)\n",
    "        self.imageLabel.setScaledContents(True)\n",
    "        # self.imageLabel.setFixedSize(512, 512)  # Set a fixed size for the image label\n",
    "        self.imageLabel.setMinimumWidth(512)\n",
    "        self.imageLabel.ratio\n",
    "        # Create a list widget to hold the label classes\n",
    "        self.classList = QListWidget(self)\n",
    "\n",
    "        # Initialize the GUI\n",
    "        self.initUI()\n",
    "\n",
    "    def initUI(self):\n",
    "        # Set window parameters\n",
    "        self.setGeometry(100, 100, 800, 600)\n",
    "        self.setWindowTitle('Image Annotation Tool')\n",
    "\n",
    "        # Add menu options\n",
    "        mainMenu = self.menuBar()\n",
    "        fileMenu = mainMenu.addMenu('File')\n",
    "\n",
    "        # Add \"Open Image\" option\n",
    "        openButton = QAction('Open Image', self)\n",
    "        openButton.setShortcut('Ctrl+O')\n",
    "        openButton.triggered.connect(self.openImage)\n",
    "        fileMenu.addAction(openButton)\n",
    "\n",
    "        # Add \"Open Annotations\" option\n",
    "        openButton = QAction('Open Annotations', self)\n",
    "        openButton.setShortcut('Ctrl+A')\n",
    "        openButton.triggered.connect(self.openAnnotations)\n",
    "        fileMenu.addAction(openButton)\n",
    "\n",
    "        # Add \"Save Annotations\" option\n",
    "        saveButton = QAction('Save Annotations', self)\n",
    "        saveButton.setShortcut('Ctrl+S')\n",
    "        saveButton.triggered.connect(self.saveAnnotations)\n",
    "        fileMenu.addAction(saveButton)\n",
    "\n",
    "        # Create a dock widget to hold the class list\n",
    "        classDock = QDockWidget('Label Classes', self)\n",
    "        classDock.setWidget(self.classList)\n",
    "        self.addDockWidget(Qt.RightDockWidgetArea, classDock)\n",
    "\n",
    "        # Show the window\n",
    "        self.show()\n",
    "\n",
    "    def openImage(self):\n",
    "        fileName, _ = QFileDialog.getOpenFileName(self, \"Open Image\", \"\", \"Images (*.png *.xpm *.jpg)\")\n",
    "        if fileName:\n",
    "            # Load and display the image\n",
    "            pixmap = QPixmap(fileName)\n",
    "            # pixmap = pixmap.scaled(512, 512, Qt.KeepAspectRatio)  # Resize image\n",
    "            self.imageLabel.setPixmap(pixmap)\n",
    "            self.setCentralWidget(self.imageLabel)\n",
    "\n",
    "    def openAnnotations(self):\n",
    "        fileName, _ = QFileDialog.getOpenFileName(self, \"Open Annotations\", \"\", \"JSON Files (*.json)\")\n",
    "        if fileName:\n",
    "            pass  # TODO: Load the annotations\n",
    "\n",
    "    def saveAnnotations(self):\n",
    "        fileName, _ = QFileDialog.getSaveFileName(self, \"Save Annotations\", \"\", \"JSON Files (*.json)\")\n",
    "        if fileName:\n",
    "            pass  # TODO: Save the annotations\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    app = QApplication(sys.argv)\n",
    "    mainWindow = MainWindow()\n",
    "    sys.exit(app.exec_())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "\n",
    "video = cv2.VideoCapture('videos/2.mp4')\n",
    "if not video.isOpened():\n",
    "    print(\"Error opening video file\")\n",
    "\n",
    "frame_count = 0\n",
    "while video.isOpened():\n",
    "    ret, frame = video.read()\n",
    "    print(ret,frame)\n",
    "    if ret:\n",
    "        cv2.imwrite(f'videos/frames2/frame_{frame_count:06}.png', frame)\n",
    "        frame_count += 1\n",
    "    else:\n",
    "        break\n",
    "\n",
    "video.release()\n",
    "cv2.destroyAllWindows()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import customtkinter as ctk\n",
    "import tkinter as tk\n",
    "import time\n",
    "def calculation(progressbar, total):\n",
    "    for i in range(total):\n",
    "        \n",
    "        time.sleep(0.5) \n",
    "        # Perform your calculation here.\n",
    "        # In this example, we're just using a loop counter as a stand-in for a real calculation.\n",
    "\n",
    "        # Update the progress bar.\n",
    "        # The value must be in the range 0 to 1, so we divide i by total.\n",
    "        progressbar.set(i/total)\n",
    "\n",
    "        # Update the GUI, allowing the progress bar to visually update.\n",
    "        root.update()\n",
    "\n",
    "    # Make sure the progress bar is fully filled after the calculation.\n",
    "    progressbar.set(1)\n",
    "\n",
    "root = tk.Tk()\n",
    "\n",
    "progressbar = ctk.CTkProgressBar(root, width=200, height=20,orientation=\"horizontal\")\n",
    "progressbar.pack()\n",
    "\n",
    "# Perform a calculation with 100 steps.\n",
    "calculation(progressbar, 100)\n",
    "\n",
    "root.mainloop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "image = cv2.imread(\"templates/typing.png\")\n",
    "# image2 = cv2.imread(\"templates/opp-temp.png\")\n",
    "\n",
    "image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "lower_red = np.array([200, 200, 200])\n",
    "upper_red = np.array([255, 255, 255])\n",
    "# lower_red = np.array([30, 0, 0])\n",
    "# upper_red = np.array([255, 100, 100])\n",
    "\n",
    "# Threshold the image to get only red colors\n",
    "mask = cv2.inRange(image_rgb, lower_red, upper_red)\n",
    "kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))\n",
    "\n",
    "# mask = cv2.erode(mask, kernel, iterations=2)\n",
    "# mask = cv2.dilate(mask, kernel, iterations=2)\n",
    "\n",
    "contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "\n",
    "print(\"Number of objects found: \", len(contours))\n",
    "\n",
    "# Display the original image\n",
    "plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))\n",
    "plt.title('Input Image')\n",
    "plt.show()\n",
    "\n",
    "# Display the mask\n",
    "plt.imshow(mask, cmap='gray')\n",
    "plt.title('Mask Image')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "def hex_to_rgb(hex_color):\n",
    "    hex_color = hex_color.lstrip('#')\n",
    "    return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))\n",
    "\n",
    "def detect_emblems(image_path, color_range,print_out = False):\n",
    "    hex_colors = {\n",
    "        'Normal': '#a0a29f',\n",
    "        'Fire': '#fba64c',\n",
    "        'Water': '#539ddf',\n",
    "        'Electric': '#f2d94e',\n",
    "        'Grass': '#60bd58',\n",
    "        'Ice': '#76d1c1',\n",
    "        'Fighting': '#d3425f',\n",
    "        'Poison': '#b763cf',\n",
    "        'Ground': '#da7c4d',\n",
    "        'Flying': '#a1bbec',\n",
    "        'Psychic': '#fa8582',\n",
    "        'Bug': '#92bd2d',\n",
    "        'Rock': '#c9bc8a',\n",
    "        'Ghost': '#5f6dbc',\n",
    "        'Dragon': '#0c6ac8',\n",
    "        'Dark': '#595761',\n",
    "        'Steel': '#5795a3',\n",
    "        'Fairy': '#ef90e6',\n",
    "    }\n",
    "\n",
    "    color_ranges = {pokemon_type: (list(map(lambda x: max(0, x-color_range), hex_to_rgb(color))), list(map(lambda x: min(255, x+color_range), hex_to_rgb(color)))) for pokemon_type, color in hex_colors.items()}\n",
    "    image = cv2.imread(image_path)\n",
    "    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "    # Detect white emblems to estimate the number of emblems\n",
    "    white_mask = cv2.inRange(image_rgb, np.array([200, 200, 200]), np.array([255, 255, 255]))\n",
    "    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))\n",
    "    white_mask = cv2.erode(white_mask, kernel, iterations=2)\n",
    "    white_mask = cv2.dilate(white_mask, kernel, iterations=2)\n",
    "\n",
    "\n",
    "    contours, _ = cv2.findContours(white_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    number_of_emblems = len(contours)\n",
    "    print(f'number of emblems found:{number_of_emblems}')\n",
    "    # Detect each type of emblem\n",
    "    type_counts = {}\n",
    "    for pokemon_type, (lower, upper) in color_ranges.items():\n",
    "        mask = cv2.inRange(image_rgb, np.array(lower), np.array(upper))\n",
    "        # Count the number of pixels in the mask\n",
    "        pixel_count = np.count_nonzero(mask)\n",
    "        type_counts[pokemon_type] = pixel_count\n",
    "        result = cv2.bitwise_and(image, image, mask=mask)\n",
    "\n",
    "        if print_out:\n",
    "            cv2.imshow(f'{pokemon_type} detection', result)\n",
    "            cv2.waitKey(0)\n",
    "            cv2.destroyAllWindows()\n",
    "\n",
    "    sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)[:number_of_emblems]\n",
    "\n",
    "    for pokemon_type, pixel_count in sorted_types:\n",
    "        print(f'Number of pixels for {pokemon_type}: {pixel_count}')\n",
    "\n",
    "# detect_emblems(\"templates/typing.png\", 30)\n",
    "detect_emblems(\"templates/typing.png\", 10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "img = cv2.imread('templates/typing.png', cv2.IMREAD_COLOR)\n",
    "gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "gray = cv2.medianBlur(gray, 5)\n",
    "\n",
    "circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=10, param1=30, param2=13, minRadius=30, maxRadius=40)\n",
    "\n",
    "if circles is not None:\n",
    "    circles = np.uint16(np.around(circles))\n",
    "\n",
    "    for i in circles[0, :]:\n",
    "        # Draw the outer circle\n",
    "        cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2)\n",
    "        cv2.circle(img, (i[0], i[1]), 2, (0, 0, 255), 3)\n",
    "\n",
    "cv2.imshow('Detected Circles', img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "img = cv2.imread('templates/charge_mv_testing/charge_55.png', cv2.IMREAD_COLOR)\n",
    "gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "# gray = cv2.medianBlur(gray, 5)\n",
    "clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
    "gray = clahe.apply(gray)\n",
    "\n",
    "circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=math.inf, param1=30, param2=15, minRadius=80, maxRadius=150)\n",
    "\n",
    "if circles is not None:\n",
    "    circles = np.uint16(np.around(circles))\n",
    "\n",
    "    for i in circles[0, :]:\n",
    "        # Draw the outer circle\n",
    "        cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2)\n",
    "        cv2.circle(img, (i[0], i[1]), 2, (0, 0, 255), 3)\n",
    "\n",
    "cv2.imshow('Detected Circles', img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def detect_charge_circles(image):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
    "    gray = clahe.apply(gray)\n",
    "\n",
    "    circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=math.inf, param1=30, param2=15, minRadius=80, maxRadius=150)\n",
    "    img_with_circles = cv2.cvtColor(gray.copy(), cv2.COLOR_GRAY2BGR)\n",
    "    \n",
    "    energy_accumulation = [] \n",
    "\n",
    "    if circles is not None:\n",
    "        circles = np.uint16(np.around(circles))\n",
    "\n",
    "        for idx, i in enumerate(circles[0, :]):\n",
    "            # Draw the outer circle\n",
    "            cv2.circle(img_with_circles, (i[0], i[1]), i[2], (0, 255, 0), 2)\n",
    "            cv2.circle(img_with_circles, (i[0], i[1]), 2, (0, 0, 255), 3)\n",
    "\n",
    "\n",
    "            # Create a mask to select only the pixels within the circle\n",
    "            mask = np.zeros_like(gray)\n",
    "            cv2.circle(mask, (i[0], i[1]), i[2], (255), -1)\n",
    "\n",
    "            # Get the region of the circle\n",
    "            circle_region = cv2.bitwise_and(image, image, mask=mask)\n",
    "\n",
    "            # Circle region\n",
    "            cv2.imshow(f\"Circle Region {idx}\", circle_region)\n",
    "            cv2.waitKey(0)\n",
    "\n",
    "            # Convert the circle region to grayscale\n",
    "            circle_gray = cv2.cvtColor(circle_region, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "            # Perform Canny edge detection\n",
    "            edges = cv2.Canny(circle_gray, 50, 150)\n",
    "\n",
    "            # Edges\n",
    "            cv2.imshow(f\"Edges {idx}\", edges)\n",
    "            cv2.waitKey(0)\n",
    "\n",
    "            boundary_row = next((r for r in reversed(range(edges.shape[0])) if np.any(edges[r, :] == 255)), 0)\n",
    "            energy_percentage = (i[2] - boundary_row) / i[2]\n",
    "\n",
    "            energy_accumulation.append(energy_percentage)\n",
    "\n",
    "            img_with_edges = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)\n",
    "            img_with_edges = cv2.circle(img_with_edges, (i[0], i[1]), i[2], (0, 255, 0), 2)\n",
    "            img_with_edges = cv2.line(img_with_edges, (0, boundary_row), (img_with_edges.shape[1], boundary_row), (0, 0, 255), 2)\n",
    "            cv2.imshow(f\"Final Result {idx}\", img_with_edges)\n",
    "            cv2.waitKey(0)\n",
    "\n",
    "    cv2.destroyAllWindows()\n",
    "    return img_with_circles, energy_accumulation\n",
    "\n",
    "\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "img = cv2.imread('templates/charge_mv_testing/charge_2.png', cv2.IMREAD_COLOR)\n",
    "img_circ,energy= detect_charge_circles(img)\n",
    "print(energy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "def detect_energy_boundary_in_full_image(image, circle):\n",
    "    # Convert the image to grayscale\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    # Apply the Sobel operator in the y-direction\n",
    "    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)\n",
    "    # Compute the absolute value of the Sobel image\n",
    "    abs_sobel_y = np.abs(sobel_y)\n",
    "    # Create a mask to zero out values outside the circle\n",
    "    mask = np.zeros_like(gray)\n",
    "    center = (int(circle[0]), int(circle[1]))\n",
    "    radius = int(circle[2])\n",
    "    cv2.circle(mask, center, radius, (255), -1)\n",
    "    # Apply the mask to the sobel image\n",
    "    abs_sobel_y_masked = cv2.bitwise_and(abs_sobel_y, abs_sobel_y, mask=mask)\n",
    "    # Sum the gradient magnitudes along columns\n",
    "    vertical_profile = np.sum(abs_sobel_y_masked, axis=1)\n",
    "    # Find the row with the highest gradient magnitude\n",
    "    boundary_row = np.argmax(vertical_profile)\n",
    "    return boundary_row\n",
    "\n",
    "def detect_circle_and_boundary_return_circle(image):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
    "    gray = clahe.apply(gray)\n",
    "    circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=math.inf, param1=30, param2=15, minRadius=80, maxRadius=150)\n",
    "    if circles is not None:\n",
    "        circle = circles[0, 0]\n",
    "        boundary_row = detect_energy_boundary_in_full_image(image, circle)\n",
    "        return circle, boundary_row\n",
    "    return None, None\n",
    "\n",
    "def calculate_filled_proportion(circle, boundary_row):\n",
    "    boundary_from_bottom = (circle[1] + circle[2]) - boundary_row\n",
    "    filled_proportion = boundary_from_bottom / (2 * circle[2])\n",
    "    return filled_proportion\n",
    "\n",
    "img = cv2.imread('templates/charge_mv_testing/charge_1.png')\n",
    "detected_circle, detected_boundary_row = detect_circle_and_boundary_return_circle(img)\n",
    "filled_proportion = calculate_filled_proportion(detected_circle, detected_boundary_row)\n",
    "print(filled_proportion)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "def detect_circle_and_boundary_return_circle(image):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
    "    gray = clahe.apply(gray)\n",
    "    circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=math.inf, param1=30, param2=15, minRadius=80, maxRadius=150)\n",
    "    if circles is not None:\n",
    "        circle = circles[0, 0]\n",
    "        boundary_row = detect_energy_boundary_in_full_image(image, circle)\n",
    "        return circle, boundary_row\n",
    "    return None, None\n",
    "\n",
    "def calculate_filled_proportion(circle, boundary_row):\n",
    "    boundary_from_bottom = (circle[1] + circle[2]) - boundary_row\n",
    "    filled_proportion = boundary_from_bottom / (2 * circle[2])\n",
    "    return filled_proportion\n",
    "\n",
    "\n",
    "def detect_energy_boundary_in_full_image(image, circle):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    # Display the grayscale image\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(gray, cmap='gray')\n",
    "    plt.title(\"Grayscale Image\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    # Apply the Sobel operator in the y-direction\n",
    "    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)\n",
    "    # Compute the absolute value of the Sobel image\n",
    "    abs_sobel_y = np.abs(sobel_y)\n",
    "    \n",
    "    # Display the Sobel image\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(abs_sobel_y, cmap='gray')\n",
    "    plt.title(\"Sobel Y-direction Image\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    # Create a mask to zero out values outside the circle\n",
    "    mask = np.zeros_like(gray)\n",
    "    center = (int(circle[0]), int(circle[1]))\n",
    "    radius = int(circle[2])\n",
    "    cv2.circle(mask, center, radius, (255), -1)\n",
    "\n",
    "    mask = create_annular_mask(image.shape, circle, inner_radius_proportion=0.55)\n",
    "    # Apply the mask to the sobel image\n",
    "    abs_sobel_y_masked = cv2.bitwise_and(abs_sobel_y, abs_sobel_y, mask=mask)\n",
    "\n",
    "    # Display the masked Sobel image\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(abs_sobel_y_masked, cmap='gray')\n",
    "    plt.title(\"Masked Sobel Image\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    # Sum the gradient magnitudes along columns\n",
    "    vertical_profile = np.sum(abs_sobel_y_masked, axis=1)\n",
    "    # Find the row with the highest gradient magnitude\n",
    "    boundary_row = np.argmax(vertical_profile)\n",
    "    return boundary_row\n",
    "\n",
    "\n",
    "def create_annular_mask(image_shape, circle, inner_radius_proportion=0.3):\n",
    "    \n",
    "    mask = np.zeros(image_shape[:2], dtype=np.uint8)\n",
    "    center = (int(circle[0]), int(circle[1]))\n",
    "    outer_radius = int(circle[2])\n",
    "    inner_radius = int(inner_radius_proportion * circle[2])\n",
    "    \n",
    "    # Include the outer circle in the mask\n",
    "    cv2.circle(mask, center, outer_radius, (255), -1)\n",
    "    # Exclude the inner circle from the mask\n",
    "    cv2.circle(mask, center, inner_radius, (0), -1)\n",
    "    \n",
    "    return mask\n",
    "\n",
    "def adjust_detected_circle_radius(circle, adjustment_factor=0.9):\n",
    "    x, y, r = circle\n",
    "    adjusted_radius = r * adjustment_factor\n",
    "    return (x, y, adjusted_radius)\n",
    "\n",
    "def display_final_result(image, circle, boundary_row):\n",
    "    # Draw the detected boundary on the image for visualization\n",
    "    cv2.line(image, (0, boundary_row), (image.shape[1], boundary_row), (0, 0, 255), 2)\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))\n",
    "    plt.title(\"Final Result with Detected Boundary\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "img = cv2.imread('templates/charge_mv_testing/charge_55.png')\n",
    "detected_circle, detected_boundary_row = detect_circle_and_boundary_return_circle(img.copy())\n",
    "detected_circle = adjust_detected_circle_radius(detected_circle, 0.8)\n",
    "\n",
    "display_final_result(img.copy(), detected_circle, detected_boundary_row)\n",
    "filled_proportion = calculate_filled_proportion(detected_circle, detected_boundary_row)\n",
    "filled_proportion\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "import os\n",
    "\n",
    "def mask_white_pixels(image, min_white, max_white):\n",
    "    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n",
    "    lower_white = np.array(min_white, dtype=np.uint8)\n",
    "    upper_white = np.array(max_white, dtype=np.uint8)\n",
    "    mask = cv2.inRange(hsv, lower_white, upper_white)\n",
    "    inverted_mask = cv2.bitwise_not(mask)\n",
    "    result = cv2.bitwise_and(image, image, mask=inverted_mask)\n",
    "    return result\n",
    "\n",
    "def detect_circle(image):\n",
    "    min_white = [0, 0, 0]\n",
    "    max_white = [180, 50, 255]\n",
    "    image_without_white_circle = mask_white_pixels(image, min_white, max_white)\n",
    "    \n",
    "    # Convert to grayscale\n",
    "    gray = cv2.cvtColor(image_without_white_circle, cv2.COLOR_BGR2GRAY)\n",
    "    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))\n",
    "    gray = clahe.apply(gray)\n",
    "    \n",
    "    # Apply the Hough Transform to detect the inner circle\n",
    "    circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=math.inf, param1=30, param2=15, minRadius=80, maxRadius=150)\n",
    "    if circles is not None:\n",
    "        circle = circles[0, 0]\n",
    "\n",
    "        # Cast the coordinates to integers\n",
    "        center_x = int(circle[0])\n",
    "        center_y = int(circle[1])\n",
    "        radius = int(circle[2])\n",
    "\n",
    "        # Draw the detected circle on the image without white circle\n",
    "        cv2.circle(image_without_white_circle, (center_x, center_y), radius, (0, 255, 0), 2)\n",
    "\n",
    "        # Display the masked image with detected circle\n",
    "        plt.figure(figsize=(6, 6))\n",
    "        plt.imshow(cv2.cvtColor(image_without_white_circle, cv2.COLOR_BGR2RGB))\n",
    "        plt.title('Image with Detected Circle')\n",
    "        plt.axis('off')\n",
    "        plt.show()\n",
    "\n",
    "    return circle\n",
    "\n",
    "\n",
    "def calculate_filled_proportion(circle, boundary_row):\n",
    "    boundary_from_bottom = (circle[1] + circle[2]) - boundary_row\n",
    "    filled_proportion = boundary_from_bottom / (2 * circle[2])\n",
    "    return filled_proportion\n",
    "\n",
    "def detect_energy_boundary_in_full_image(image, circle):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)\n",
    "    abs_sobel_y = np.abs(sobel_y)\n",
    "    \n",
    "    # Display the Sobel image\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(abs_sobel_y, cmap='gray')\n",
    "    plt.title(\"Sobel Y-direction Image\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    mask = create_annular_mask(image.shape, circle, inner_radius_proportion=0.6)\n",
    "    \n",
    "    # Display the annular mask\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(mask, cmap='gray')\n",
    "    plt.title(\"Annular Mask\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    abs_sobel_y_masked = cv2.bitwise_and(abs_sobel_y, abs_sobel_y, mask=mask)\n",
    "    \n",
    "    # Display the masked Sobel image\n",
    "    plt.figure(figsize=(6, 6))\n",
    "    plt.imshow(abs_sobel_y_masked, cmap='gray')\n",
    "    plt.title(\"Masked Sobel Image\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "    vertical_profile = np.sum(abs_sobel_y_masked, axis=1)\n",
    "    boundary_row = np.argmax(vertical_profile)\n",
    "    return boundary_row\n",
    "\n",
    "\n",
    "def create_annular_mask(image_shape, circle, inner_radius_proportion=0.3):\n",
    "    mask = np.zeros(image_shape[:2], dtype=np.uint8)\n",
    "    center = (int(circle[0]), int(circle[1]))\n",
    "    outer_radius = int(circle[2])\n",
    "    inner_radius = int(inner_radius_proportion * circle[2])\n",
    "    cv2.circle(mask, center, outer_radius, (255), -1)\n",
    "    cv2.circle(mask, center, inner_radius, (0), -1)\n",
    "    return mask\n",
    "\n",
    "def adjust_detected_circle_radius(circle, adjustment_factor=0.9):\n",
    "    x, y, r = circle\n",
    "    adjusted_radius = r * adjustment_factor\n",
    "    return (x, y, adjusted_radius)\n",
    "\n",
    "def display_final_result(image, circle, boundary_row):\n",
    "    cv2.line(image, (0, boundary_row), (image.shape[1], boundary_row), (0, 0, 255), 2)\n",
    "    plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))\n",
    "    plt.title(\"Final Result with Detected Boundary\")\n",
    "    plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "def process_image(image_path):\n",
    "    img = cv2.imread(image_path)\n",
    "    detected_circle = detect_circle(img.copy())\n",
    "\n",
    "    if detected_circle is not None:\n",
    "        adjusted_circle = adjust_detected_circle_radius(detected_circle, 1)\n",
    "        detected_boundary_row = detect_energy_boundary_in_full_image(img.copy(), adjusted_circle)\n",
    "        display_final_result(img.copy(), adjusted_circle, detected_boundary_row)\n",
    "        filled_proportion = calculate_filled_proportion(adjusted_circle, detected_boundary_row)\n",
    "        print(f\"Image {image_path}: {filled_proportion}\")\n",
    "    else:\n",
    "        print(f\"Image {image_path}: No circle detected.\")\n",
    "\n",
    "folder_path = 'templates/charge_mv_testing'\n",
    "for image_file in os.listdir(folder_path):\n",
    "    image_path = os.path.join(folder_path, image_file)\n",
    "    if os.path.isfile(image_path) and image_file.endswith(('.png', '.jpg', '.jpeg')):\n",
    "        process_image(image_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def mask_white_pixels(image, min_white, max_white):\n",
    "    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n",
    "    lower_white = np.array(min_white, dtype=np.uint8)\n",
    "    upper_white = np.array(max_white, dtype=np.uint8)\n",
    "    mask = cv2.inRange(hsv, lower_white, upper_white)\n",
    "    inverted_mask = cv2.bitwise_not(mask)\n",
    "    result = cv2.bitwise_and(image, image, mask=inverted_mask)\n",
    "    return result\n",
    "\n",
    "def update(x):\n",
    "    min_white = [cv2.getTrackbarPos('Min H', 'Tuning'),\n",
    "                 cv2.getTrackbarPos('Min S', 'Tuning'),\n",
    "                 cv2.getTrackbarPos('Min V', 'Tuning')]\n",
    "    max_white = [cv2.getTrackbarPos('Max H', 'Tuning'),\n",
    "                 cv2.getTrackbarPos('Max S', 'Tuning'),\n",
    "                 cv2.getTrackbarPos('Max V', 'Tuning')]\n",
    "    masked_image = mask_white_pixels(image, min_white, max_white)\n",
    "    resized_image = cv2.resize(masked_image, (640, 480))\n",
    "    cv2.imshow('Tuning', resized_image)\n",
    "\n",
    "image_path = \"templates/typing-icons.png\"\n",
    "image = cv2.imread(image_path)\n",
    "\n",
    "cv2.namedWindow('Tuning')\n",
    "cv2.createTrackbar('Min H', 'Tuning', 0, 180, update)\n",
    "cv2.createTrackbar('Min S', 'Tuning', 0, 255, update)\n",
    "cv2.createTrackbar('Min V', 'Tuning', 0, 255, update)\n",
    "cv2.createTrackbar('Max H', 'Tuning', 180, 180, update)\n",
    "cv2.createTrackbar('Max S', 'Tuning', 40, 255, update)\n",
    "cv2.createTrackbar('Max V', 'Tuning', 255, 255, update)\n",
    "\n",
    "while True:\n",
    "    update(None)\n",
    "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "        break\n",
    "\n",
    "cv2.destroyAllWindows()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def merge_images(image1_path, image2_path, alpha=0.5):\n",
    "    # Read the images\n",
    "    image1 = cv2.imread(image1_path)\n",
    "    image2 = cv2.imread(image2_path)\n",
    "\n",
    "    # Check if the images have the same size\n",
    "    if image1.shape != image2.shape:\n",
    "        print(\"Images must have the same dimensions!\")\n",
    "        return None\n",
    "\n",
    "    # Merge the images using weighted sum\n",
    "    merged_image = cv2.addWeighted(image1, alpha, image2, 1 - alpha, 0)\n",
    "\n",
    "    return merged_image\n",
    "\n",
    "result = merge_images('templates/charge_mv_testing/1.jpg','templates/charge_mv_testing/2.jpg')\n",
    "\n",
    "# Display the result\n",
    "plt.imshow(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))\n",
    "plt.axis('off')\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "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.10.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}