First commit

.gitattributes

@@ -33,3 +33,15 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/watch_test1.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test10.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test107.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test109.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test110.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test111.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test112.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test113.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test114.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test115.jpg filter=lfs diff=lfs merge=lfs -text
+examples/watch_test116.jpg filter=lfs diff=lfs merge=lfs -text
+img/2.png filter=lfs diff=lfs merge=lfs -text

gradio_app.py

@@ -0,0 +1,211 @@
+"""Gradio interface for the Analogic Watch Detector model.
+
+This module exposes a lightweight Gradio demo that can be used on
+Hugging Face Spaces. It loads the YOLO model once, runs inference on the
+uploaded image and renders the predicted time alongside the annotated
+image.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Optional, Tuple
+
+import cv2
+import gradio as gr
+import numpy as np
+from ultralytics import YOLO
+
+from utils.clock_utils import process_clock_time
+from utils.detections_utils import get_latest_train_dir, run_detection
+
+
+_MODEL: Optional[YOLO] = None
+
+
+def _resolve_model_path() -> str:
+    """Return the best available model path."""
+    env_path = os.environ.get("MODEL_PATH")
+    if env_path and os.path.exists(env_path):
+        return env_path
+    
+    # Priority 1: Specific tuned model for HF deployment
+    tune4_model = "tune4_best.pt"
+    if os.path.exists(tune4_model):
+        return tune4_model
+
+    default_weight = "yolov8s.pt"
+    if os.path.exists(default_weight):
+        return default_weight
+
+    try:
+        return os.path.join(get_latest_train_dir(), "weights", "best.pt")
+    except FileNotFoundError as exc:  # pragma: no cover - defensive path
+        raise RuntimeError(
+            "Model weights were not found. Provide them via the MODEL_PATH "
+            "environment variable or include 'yolov8s.pt' in the repository."
+        ) from exc
+
+
+def _load_model() -> YOLO:
+    """Lazy-load the YOLO model to keep the interface responsive."""
+    global _MODEL
+    if _MODEL is None:
+        model_path = _resolve_model_path()
+        _MODEL = YOLO(model_path)
+    return _MODEL
+
+
+def _format_time(prediction: Optional[dict]) -> str:
+    """Generate a human readable string for the detected time."""
+    if not prediction:
+        return "Unable to determine the time from the detected clock."
+
+    hours = prediction.get("hours")
+    minutes = prediction.get("minutes")
+    seconds = prediction.get("seconds")
+
+    if hours is None:
+        return "Unable to determine the time from the detected clock."
+
+    if minutes is None:
+        return f"Detected hour hand at {hours:02d}."
+
+    if seconds is None:
+        return f"Detected time: {hours:02d}:{minutes:02d}."
+
+    return f"Detected time: {hours:02d}:{minutes:02d}:{seconds:02d}."
+
+
+def predict(image: np.ndarray, confidence: float) -> Tuple[np.ndarray, str]:
+    """Run detection on the uploaded image and return the annotated preview."""
+    if image is None:
+        raise gr.Error("Please upload an image of an analog clock.")
+
+    # Basic guard against oversized inputs to reduce DoS risk
+    try:
+        if hasattr(image, "nbytes") and (image.nbytes > 40 * 1024 * 1024):
+            raise gr.Error("Image is too large. Please upload a smaller file.")
+        if image.size and image.size > 20_000_000:
+            raise gr.Error("Image resolution is too high. Please downscale and retry.")
+    except Exception:
+        pass
+
+    image_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+
+    detections, results = run_detection(
+        image=image_bgr,
+        image_path=None,
+        confidence=confidence,
+        save_path=None,
+        save_visualization=False,
+        return_prediction_results=True,
+        model=_load_model(),
+    )
+
+    if not detections or not detections[0]:
+        return image, "No clock components detected in the provided image."
+
+    prediction = process_clock_time(detections, "uploaded_image")
+    annotated = image
+    if results:
+        annotated_bgr = results[0].plot()
+        annotated = cv2.cvtColor(annotated_bgr, cv2.COLOR_BGR2RGB)
+
+    return annotated, _format_time(prediction)
+
+
+def build_interface() -> gr.Blocks:
+    """Create the Gradio Blocks interface."""
+    with gr.Blocks(title="Analog Clock Time Detector") as demo:
+        gr.Markdown(
+            """
+            # Analog Clock Time Detector
+            Upload a picture of an analog clock to detect the time displayed on it.
+            The model is based on YOLOv8 and predicts the hour, minute and second
+            hands when available.
+            """
+        )
+
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    type="numpy",
+                    label="Clock image",
+                    image_mode="RGB",
+                )
+                confidence_slider = gr.Slider(
+                    minimum=0.01,
+                    maximum=0.5,
+                    step=0.01,
+                    value=0.1,
+                    label="Detection confidence threshold",
+                )
+                submit_btn = gr.Button("Detect time")
+
+            with gr.Column():
+                annotated_image = gr.Image(
+                    type="numpy",
+                    label="Detections",
+                )
+                time_output = gr.Textbox(
+                    label="Predicted time",
+                    placeholder="The predicted time will appear here.",
+                )
+
+        submit_btn.click(
+            fn=predict,
+            inputs=[image_input, confidence_slider],
+            outputs=[annotated_image, time_output],
+        )
+
+        # Load examples from the examples directory
+        example_images = []
+        if os.path.exists("examples"):
+            example_images = [
+                os.path.join("examples", f)
+                for f in os.listdir("examples")
+                if f.lower().endswith(('.png', '.jpg', '.jpeg'))
+            ]
+        # Sort for consistent order, though not strictly required
+        example_images.sort()
+        
+        # Fallback to img directory if no examples found (local dev fallback/legacy)
+        if not example_images and os.path.exists("img"):
+             example_images = [
+                os.path.join("img", "1.png"),
+                os.path.join("img", "2.png"),
+            ]
+
+        if example_images:
+            gr.Examples(
+                examples=example_images,
+                inputs=image_input,
+            )
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = build_interface()
+    # Detect Hugging Face Spaces environment
+    on_hf = bool(os.environ.get("SPACE_ID"))
+
+    # Configure queue conservatively; keep broad compatibility
+    try:
+        demo.queue(concurrency_count=1, max_size=8)
+    except TypeError:
+        try:
+            demo.queue(max_size=8)
+        except TypeError:
+            demo.queue()
+
+    if on_hf:
+        # Let Spaces manage networking/binding
+        demo.launch()
+    else:
+        # Local dev: bind only to localhost and avoid public share
+        try:
+            demo.launch(server_name="127.0.0.1", share=False, allowed_paths=["img"]) 
+        except TypeError:
+            demo.launch(server_name="127.0.0.1", share=False)

img/annotations_utils/add_rotated_gt.ipynb

@@ -0,0 +1,349 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 562 entries, 0 to 561\n",
+      "Data columns (total 2 columns):\n",
+      " #   Column  Non-Null Count  Dtype \n",
+      "---  ------  --------------  ----- \n",
+      " 0   Watch   562 non-null    object\n",
+      " 1   Time    562 non-null    object\n",
+      "dtypes: object(2)\n",
+      "memory usage: 8.9+ KB\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(    Watch      Time\n",
+       " 0  watch1  10:10:30\n",
+       " 1  watch2  11:15:12\n",
+       " 2  watch3  10:10:25\n",
+       " 3  watch4  10:11:48\n",
+       " 4  watch5  10:08:31,\n",
+       " None)"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "# Caminho do arquivo enviado\n",
+    "file_path = r'C:\\Users\\anoca\\Documents\\GitHub\\analogic-watch-detector\\ground_truths/watch_times.csv'\n",
+    "\n",
+    "# Ler o arquivo CSV\n",
+    "original_df = pd.read_csv(file_path)\n",
+    "\n",
+    "# Visualizar as primeiras linhas para entender a estrutura\n",
+    "original_df.head(), original_df.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Watch</th>\n",
+       "      <th>Time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>watch1</td>\n",
+       "      <td>10:10:30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>watch2</td>\n",
+       "      <td>11:15:12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>watch3</td>\n",
+       "      <td>10:10:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>watch4</td>\n",
+       "      <td>10:11:48</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>watch5</td>\n",
+       "      <td>10:08:31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>557</th>\n",
+       "      <td>watch558</td>\n",
+       "      <td>10:10:31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>558</th>\n",
+       "      <td>watch559</td>\n",
+       "      <td>04:40:01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>559</th>\n",
+       "      <td>watch560</td>\n",
+       "      <td>10:01:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>560</th>\n",
+       "      <td>watch561</td>\n",
+       "      <td>10:13:22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>561</th>\n",
+       "      <td>watch562</td>\n",
+       "      <td>10:08:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>562 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Watch      Time\n",
+       "0      watch1  10:10:30\n",
+       "1      watch2  11:15:12\n",
+       "2      watch3  10:10:25\n",
+       "3      watch4  10:11:48\n",
+       "4      watch5  10:08:31\n",
+       "..        ...       ...\n",
+       "557  watch558  10:10:31\n",
+       "558  watch559  04:40:01\n",
+       "559  watch560  10:01:00\n",
+       "560  watch561  10:13:22\n",
+       "561  watch562  10:08:00\n",
+       "\n",
+       "[562 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "original_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Gerar os novos nomes de relógios com rotações\n",
+    "rotations = [-90, 180, -270]\n",
+    "new_watches = [\n",
+    "    f\"{row['Watch']}_rotated_{rotation}\"\n",
+    "    for _, row in original_df.iterrows()\n",
+    "    for rotation in rotations\n",
+    "]\n",
+    "\n",
+    "# Criar o novo DataFrame para relógios rotacionados\n",
+    "new_data = []\n",
+    "\n",
+    "for new_watch in new_watches:\n",
+    "    original_watch = new_watch.split(\"_rotated_\")[0]  # Extrai o nome base, e.g., \"watch1\"\n",
+    "    original_time = original_df.loc[original_df[\"Watch\"] == original_watch, \"Time\"].values\n",
+    "    if len(original_time) > 0:\n",
+    "        new_data.append({\"Watch\": new_watch, \"Time\": original_time[0]})\n",
+    "\n",
+    "# Criar DataFrame com os novos dados\n",
+    "rotated_df = pd.DataFrame(new_data)\n",
+    "\n",
+    "# Concatenar os dados originais com os novos\n",
+    "final_df = pd.concat([original_df, rotated_df], ignore_index=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Watch</th>\n",
+       "      <th>Time</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>watch1</td>\n",
+       "      <td>10:10:30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>watch2</td>\n",
+       "      <td>11:15:12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>watch3</td>\n",
+       "      <td>10:10:25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>watch4</td>\n",
+       "      <td>10:11:48</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>watch5</td>\n",
+       "      <td>10:08:31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2243</th>\n",
+       "      <td>watch561_rotated_180</td>\n",
+       "      <td>10:13:22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2244</th>\n",
+       "      <td>watch561_rotated_-270</td>\n",
+       "      <td>10:13:22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2245</th>\n",
+       "      <td>watch562_rotated_-90</td>\n",
+       "      <td>10:08:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2246</th>\n",
+       "      <td>watch562_rotated_180</td>\n",
+       "      <td>10:08:00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2247</th>\n",
+       "      <td>watch562_rotated_-270</td>\n",
+       "      <td>10:08:00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>2248 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Watch      Time\n",
+       "0                    watch1  10:10:30\n",
+       "1                    watch2  11:15:12\n",
+       "2                    watch3  10:10:25\n",
+       "3                    watch4  10:11:48\n",
+       "4                    watch5  10:08:31\n",
+       "...                     ...       ...\n",
+       "2243   watch561_rotated_180  10:13:22\n",
+       "2244  watch561_rotated_-270  10:13:22\n",
+       "2245   watch562_rotated_-90  10:08:00\n",
+       "2246   watch562_rotated_180  10:08:00\n",
+       "2247  watch562_rotated_-270  10:08:00\n",
+       "\n",
+       "[2248 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "final_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_path = r'C:\\Users\\anoca\\Documents\\GitHub\\analogic-watch-detector\\ground_truths/ground_truths.csv'\n",
+    "final_df.to_csv(output_path, index=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "vc",
+   "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.8.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

img/annotations_utils/desfocar.py

@@ -0,0 +1,68 @@
+import os
+import cv2
+import albumentations as A
+
+# Função para ler anotações de um arquivo
+def read_annotations(file_path):
+    annotations = []
+    with open(file_path, "r") as f:
+        for line in f:
+            annotations.append(line.strip())
+    return annotations
+
+# Caminhos das pastas
+images_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\rr"
+labels_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector"
+output_images_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\rr"
+output_labels_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector"
+
+# Certificar-se de que as pastas de saída existem
+os.makedirs(output_images_folder, exist_ok=True)
+os.makedirs(output_labels_folder, exist_ok=True)
+
+# Configuração de transformação de desfoque
+transform = A.Compose([
+    A.Blur(blur_limit=43, p=1.0)  # Intensão do desfoque
+])
+
+# Processar todas as imagens na pasta
+for image_filename in os.listdir(images_folder):
+    # Ignorar arquivos com "rotated" ou "zoom_out" no nome
+    if "rotated" in image_filename or "zoom_out" in image_filename:
+        print(f"Ignorado: {image_filename} (contém 'rotated' ou 'zoom_out')")
+        continue
+
+    # Verificar se o arquivo é uma imagem
+    if image_filename.endswith((".jpg", ".png", ".jpeg")):
+        image_path = os.path.join(images_folder, image_filename)
+        label_path = os.path.join(labels_folder, image_filename.replace(".jpg", ".txt").replace(".png", ".txt").replace(".jpeg", ".txt"))
+
+        # Verificar se o arquivo de anotações correspondente existe
+        if not os.path.exists(label_path):
+            print(f"Anotação não encontrada para {image_filename}, pulando.")
+            continue
+
+        # Carregar a imagem
+        imagem = cv2.imread(image_path)
+
+        # Aplicar o desfoque
+        imagem_desfocada = transform(image=imagem)['image']
+
+        # Criar novo nome para a imagem e o label
+        base_name, ext = os.path.splitext(image_filename)  # Separar nome e extensão
+        new_image_name = f"{base_name}_blurred{ext}"
+        new_label_name = f"{base_name}_blurred.txt"
+
+        # Salvar a imagem desfocada
+        output_image_path = os.path.join(output_images_folder, new_image_name)
+        cv2.imwrite(output_image_path, imagem_desfocada)
+
+        # Copiar o conteúdo das anotações para um novo arquivo
+        new_label_path = os.path.join(output_labels_folder, new_label_name)
+        annotations = read_annotations(label_path)
+        with open(new_label_path, "w") as f:
+            for line in annotations:
+                f.write(line + "\n")
+
+        print(f"Imagem processada e salva como: {new_image_name}")
+        print(f"Anotações copiadas e salvas como: {new_label_name}")

img/annotations_utils/name_changer.py

@@ -0,0 +1,22 @@
+import os
+
+# Folder containing the images
+folder_path = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\test_set\novos"
+
+# Starting number for the renaming
+start_number = 110
+
+# Get all .jpg files in the folder
+files = [f for f in os.listdir(folder_path) if f.lower().endswith('.jpg')]
+
+# Sort files to ensure consistent renaming
+files.sort()
+
+# Rename the files
+for i, file in enumerate(files):
+    new_name = f"watch_test{start_number + i}.jpg"
+    old_file = os.path.join(folder_path, file)
+    new_file = os.path.join(folder_path, new_name)
+    os.rename(old_file, new_file)
+
+print("Renaming completed!")

img/annotations_utils/remove_center.py

@@ -0,0 +1,25 @@
+import os
+
+# Caminho da pasta onde estão os arquivos
+caminho_pasta = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\labels\val"
+
+# Iterar por todos os arquivos na pasta
+for nome_arquivo in os.listdir(caminho_pasta):
+    # Verificar se o arquivo tem extensão .txt
+    if nome_arquivo.endswith(".txt"):
+        caminho_arquivo = os.path.join(caminho_pasta, nome_arquivo)
+        
+        # Ler o conteúdo do arquivo
+        with open(caminho_arquivo, "r") as arquivo:
+            linhas = arquivo.readlines()
+        
+        # Filtrar as linhas que não começam com "4"
+        linhas_filtradas = [linha for linha in linhas if not linha.startswith("4")]
+        
+        # Sobrescrever o arquivo original com as linhas filtradas
+        with open(caminho_arquivo, "w") as arquivo:
+            arquivo.writelines(linhas_filtradas)
+        
+        print(f"Processado: {nome_arquivo}")
+
+print("Todos os arquivos foram processados.")

img/annotations_utils/resized_annotations.py

@@ -0,0 +1,115 @@
+import os
+import cv2
+import albumentations as A
+
+# Função para ajustar as anotações após transformação
+def adjust_annotations(annotations, original_size, resized_size, padded_size):
+    orig_h, orig_w = original_size
+    resized_h, resized_w = resized_size
+    padded_h, padded_w = padded_size
+
+    scale_x = resized_w / orig_w  # Escala para largura
+    scale_y = resized_h / orig_h  # Escala para altura
+
+    pad_x = (padded_w - resized_w) / 2  # Padding horizontal
+    pad_y = (padded_h - resized_h) / 2  # Padding vertical
+
+    adjusted_annotations = []
+    for ann in annotations:
+        cls, x_c, y_c, w, h = ann
+
+        # Ajustar coordenadas normalizadas para o redimensionamento
+        x_c = x_c * orig_w * scale_x
+        y_c = y_c * orig_h * scale_y
+        w = w * orig_w * scale_x
+        h = h * orig_h * scale_y
+
+        # Ajustar para o padding e normalizar para o novo tamanho
+        x_c = (x_c + pad_x) / padded_w
+        y_c = (y_c + pad_y) / padded_h
+        w = w / padded_w
+        h = h / padded_h
+
+        # Adicionar anotação ajustada
+        adjusted_annotations.append((cls, x_c, y_c, w, h))
+    
+    return adjusted_annotations
+
+# Função para ler as anotações de um arquivo
+def read_annotations(file_path):
+    annotations = []
+    with open(file_path, "r") as f:
+        for line in f:
+            parts = line.strip().split()
+            cls = int(parts[0])  # Classe
+            x_c, y_c, w, h = map(float, parts[1:])
+            annotations.append((cls, x_c, y_c, w, h))
+    return annotations
+
+# Configuração de transformações
+resize_height, resize_width = 128, 128
+padded_height, padded_width = 256, 256
+augmentation = A.Compose([
+    A.Resize(height=resize_height, width=resize_width),
+    A.PadIfNeeded(min_height=padded_height, min_width=padded_width, border_mode=cv2.BORDER_CONSTANT, value=(0, 0, 0)),
+])
+
+# Caminhos das pastas
+images_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\images\train"
+labels_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\labels\train"
+output_images_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\images\train"
+output_labels_folder = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\labels\train"
+
+# Certificar-se de que as pastas de saída existem
+os.makedirs(output_images_folder, exist_ok=True)
+os.makedirs(output_labels_folder, exist_ok=True)
+
+# Processar todos os arquivos na pasta
+for image_filename in os.listdir(images_folder):
+    # Pular arquivos com "rotated" no nome
+    if "rotated" in image_filename:
+        print(f"Pulado: {image_filename} (contém 'rotated').")
+        continue
+
+    if image_filename.endswith((".jpg", ".png", ".jpeg")):  # Verifica formatos de imagem
+        image_path = os.path.join(images_folder, image_filename)
+        label_path = os.path.join(labels_folder, image_filename.replace(".jpg", ".txt").replace(".png", ".txt").replace(".jpeg", ".txt"))
+
+        # Verificar se o arquivo de anotações correspondente existe
+        if not os.path.exists(label_path):
+            print(f"Anotação não encontrada para {image_filename}, pulando.")
+            continue
+
+        # Carregar a imagem e as anotações
+        image = cv2.imread(image_path)
+        original_size = image.shape[:2]  # (altura, largura)
+        annotations = read_annotations(label_path)
+
+        # Aplicar transformações
+        augmented = augmentation(image=image)
+        augmented_image = augmented["image"]
+
+        # Ajustar as anotações
+        new_annotations = adjust_annotations(
+            annotations,
+            original_size=(original_size[0], original_size[1]),
+            resized_size=(resize_height, resize_width),
+            padded_size=(padded_height, padded_width)
+        )
+
+        # Criar novo nome para a imagem e as anotações
+        base_name, ext = os.path.splitext(image_filename)
+        new_image_name = f"{base_name}_zoom_out{ext}"
+        new_label_name = f"{base_name}_zoom_out.txt"
+
+        # Salvar imagem transformada
+        output_image_path = os.path.join(output_images_folder, new_image_name)
+        cv2.imwrite(output_image_path, augmented_image)
+
+        # Salvar anotações transformadas
+        output_label_path = os.path.join(output_labels_folder, new_label_name)
+        with open(output_label_path, "w") as f:
+            for ann in new_annotations:
+                f.write(f"{ann[0]} {ann[1]:.6f} {ann[2]:.6f} {ann[3]:.6f} {ann[4]:.6f}\n")
+
+        print(f"Processado e salvo como: {new_image_name}")

img/annotations_utils/rotate_img.py

@@ -0,0 +1,56 @@
+import os
+import random
+from PIL import Image
+
+def rotate_images(input_dir, output_dir):
+    """
+    Roda apenas uma imagem do diretório para um ângulo aleatório, salva a nova e remove a antiga.
+
+    Args:
+        input_dir (str): Diretório onde estão as imagens originais.
+        output_dir (str): Diretório onde será salva a imagem rotacionada.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    # Lista todos os arquivos no diretório de entrada
+    for filename in os.listdir(input_dir):
+        input_path = os.path.join(input_dir, filename)
+        
+        # Verifica se o arquivo é uma imagem
+        if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
+            continue
+        
+        try:
+            # Escolhe um ângulo aleatório
+            ang = [90, 270, 45, 135, 180, 225, 315]
+            random_angle = random.choice(ang)
+            
+            # Abrir a imagem
+            with Image.open(input_path) as img:
+                # Rotacionar a imagem
+                rotated_img = img.rotate(random_angle, expand=True)
+                
+                # Gerar nome para a imagem rotacionada
+                name, ext = os.path.splitext(filename)
+                rotated_filename = f"{name}_rotated_{random_angle}{ext}"
+                output_path = os.path.join(output_dir, rotated_filename)
+                
+                # Salvar imagem rotacionada
+                rotated_img.save(output_path)
+                print(f"Imagem salva: {output_path}")
+            
+            # Remover a imagem original após gerar a versão rotacionada
+            os.remove(input_path)
+            print(f"Imagem original removida: {input_path}")
+            
+        except Exception as e:
+            print(f"Erro ao processar {filename}: {e}")
+
+# Configurações
+input_directory = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\images\train\novos\rodados"  # Substitua pelo diretório das imagens originais
+output_directory = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\images\train\novos\rodados"  # Substitua pelo diretório de saída
+
+# Executar o script
+rotate_images(input_directory, output_directory)
+

img/annotations_utils/rotate_img_ann.py

@@ -0,0 +1,148 @@
+import os
+import random
+import math
+from PIL import Image, ImageDraw
+
+def rotate_point(point, center, angle_deg):
+    """
+    Rotaciona um ponto ao redor de um centro em um determinado ângulo.
+    """
+    angle_rad = math.radians(angle_deg)
+    x, y = point[0] - center[0], point[1] - center[1]
+    x_rotated = x * math.cos(angle_rad) - y * math.sin(angle_rad)
+    y_rotated = x * math.sin(angle_rad) + y * math.cos(angle_rad)
+    return (x_rotated + center[0], y_rotated + center[1])
+
+def draw_bounding_boxes(image_path, annotations_path, output_path):
+    """
+    Desenha caixas delimitadoras em uma imagem com base nas anotações YOLO.
+    """
+    with Image.open(image_path) as img:
+        draw = ImageDraw.Draw(img)
+        img_width, img_height = img.size
+        
+        with open(annotations_path, 'r') as f:
+            lines = f.readlines()
+        
+        for line in lines:
+            parts = line.strip().split()
+            class_id = parts[0]
+            x_center = float(parts[1]) * img_width
+            y_center = float(parts[2]) * img_height
+            width = float(parts[3]) * img_width
+            height = float(parts[4]) * img_height
+            
+            x_min = x_center - width / 2
+            y_min = y_center - height / 2
+            x_max = x_center + width / 2
+            y_max = y_center + height / 2
+            
+            # Desenha o retângulo
+            draw.rectangle([x_min, y_min, x_max, y_max], outline="red", width=2)
+            draw.text((x_min, y_min - 10), f"Class {class_id}", fill="red")
+        
+        img.save(output_path)
+        print(f"Imagem com bounding boxes salva: {output_path}")
+
+def rotate_yolo_annotations(input_txt, output_txt, angle, original_width, original_height, rotated_width, rotated_height):
+    """
+    Rotaciona as anotações YOLO para um ângulo específico, considerando o tamanho da imagem rotacionada.
+    """
+    with open(input_txt, 'r') as f:
+        lines = f.readlines()
+    
+    new_annotations = []
+    
+    for line in lines:
+        parts = line.strip().split()
+        class_id = parts[0]
+        x_center = float(parts[1]) * original_width
+        y_center = float(parts[2]) * original_height
+        width = float(parts[3]) * original_width
+        height = float(parts[4]) * original_height
+        
+        if angle == -90:
+            new_x_center = original_height - y_center
+            new_y_center = x_center
+            new_width = height
+            new_height = width
+        elif angle == 180:
+            new_x_center = original_width - x_center
+            new_y_center = original_height - y_center
+            new_width = width
+            new_height = height
+        elif angle == -270:
+            new_x_center = y_center
+            new_y_center = original_width - x_center
+            new_width = height
+            new_height = width
+        
+        # Normaliza os valores para a escala [0, 1]
+        norm_x_center = new_x_center / rotated_width
+        norm_y_center = new_y_center / rotated_height
+        norm_width = new_width / rotated_width
+        norm_height = new_height / rotated_height
+        
+        # Gera a nova anotação YOLO
+        new_annotation = f"{class_id} {norm_x_center:.6f} {norm_y_center:.6f} {norm_width:.6f} {norm_height:.6f}\n"
+        new_annotations.append(new_annotation)
+    
+    # Salva as novas anotações no arquivo de saída
+    with open(output_txt, 'w') as f:
+        f.writelines(new_annotations)
+
+def rotate_images_and_annotations(input_dir, output_dir):
+    """
+    Rotaciona imagens e suas anotações correspondentes em todos os ângulos especificados.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    angles = [-90, 180, -270]
+    
+    for filename in os.listdir(input_dir):
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
+            try:
+                input_img_path = os.path.join(input_dir, filename)
+                input_txt_path = os.path.splitext(input_img_path)[0] + '.txt'
+                
+                with Image.open(input_img_path) as img:
+                    original_width, original_height = img.size
+                    
+                    for angle in angles:
+                        rotated_img = img.rotate(angle, expand=True)
+                        rotated_width, rotated_height = rotated_img.size
+                        name, ext = os.path.splitext(filename)
+                        rotated_filename = f"{name}_rotated_{angle}{ext}"
+                        output_img_path = os.path.join(output_dir, rotated_filename)
+                        rotated_img.save(output_img_path)
+                        print(f"Imagem salva: {output_img_path}")
+                        
+                        if os.path.exists(input_txt_path):
+                            rotated_txt_filename = f"{name}_rotated_{angle}.txt"
+                            output_txt_path = os.path.join(output_dir, rotated_txt_filename)
+                            rotate_yolo_annotations(
+                                input_txt_path, 
+                                output_txt_path, 
+                                angle, 
+                                original_width, 
+                                original_height, 
+                                rotated_width, 
+                                rotated_height
+                            )
+                            print(f"Anotação salva: {output_txt_path}")
+                # Desenha bounding boxes antes e depois
+                #annotated_image_path = os.path.join(output_dir, f"{name}_original_with_boxes{ext}")
+                #draw_bounding_boxes(input_img_path, input_txt_path, annotated_image_path)
+                
+                #annotated_rotated_path = os.path.join(output_dir, f"{name}_rotated_with_boxes{ext}")
+                #draw_bounding_boxes(output_img_path, output_txt_path, annotated_rotated_path)
+                                
+            except Exception as e:
+                print(f"Erro ao processar {filename}: {e}")
+
+
+# Configurações
+input_directory = r"C:\Users\anoca\Downloads\Nova pasta"
+output_directory = r"C:\Users\anoca\Downloads\Nova pasta\rotated"
+rotate_images_and_annotations(input_directory, output_directory)

img/annotations_utils/train_val_split.py

@@ -0,0 +1,47 @@
+import os
+import shutil
+from sklearn.model_selection import train_test_split
+
+def split_dataset(images_dir, labels_dir, val_images_dir, val_labels_dir, val_ratio=0.2):
+    """
+    Divide o conjunto de dados em treino e validação, excluindo imagens "_rotated".
+    
+    :param images_dir: Diretório das imagens originais.
+    :param labels_dir: Diretório das labels originais.
+    :param val_images_dir: Diretório para salvar imagens de validação.
+    :param val_labels_dir: Diretório para salvar labels de validação.
+    :param val_ratio: Proporção de imagens a serem usadas na validação.
+    """
+    # Cria pastas de validação, se não existirem
+    os.makedirs(val_images_dir, exist_ok=True)
+    os.makedirs(val_labels_dir, exist_ok=True)
+
+    # Lista de imagens normais (sem _rotated)
+    normal_images = [f for f in os.listdir(images_dir) if f.endswith(".jpg") and "_rotated" not in f]
+    
+    # Associa labels existentes
+    normal_images = [f for f in normal_images if os.path.exists(os.path.join(labels_dir, f.replace(".jpg", ".txt")))]
+    
+    # Divide em treino e validação
+    train_images, val_images = train_test_split(normal_images, test_size=val_ratio, random_state=42)
+    
+    # Move as imagens e labels para o diretório de validação
+    for image in val_images:
+        label = image.replace(".jpg", ".txt")
+        
+        # Move a imagem
+        shutil.move(os.path.join(images_dir, image), os.path.join(val_images_dir, image))
+        
+        # Move a label
+        shutil.move(os.path.join(labels_dir, label), os.path.join(val_labels_dir, label))
+
+    print(f"Divisão concluída! {len(val_images)} imagens movidas para validação.")
+
+# Exemplos de uso
+split_dataset(
+    images_dir="dataset/images/train",
+    labels_dir="dataset/labels/train",
+    val_images_dir="dataset/images/val",
+    val_labels_dir="dataset/labels/val",
+    val_ratio=0.2
+)

img/annotations_utils/xml_to_txt.py

@@ -0,0 +1,59 @@
+import os
+import xml.etree.ElementTree as ET
+
+# Mapeamento das classes
+class_mapping = {
+    "circle": 0,
+    "hours": 1,
+    "minutes": 2,
+    "seconds": 3,
+    "12": 4
+}
+
+# Diretório contendo os arquivos XML
+input_dir = r"C:\Users\anoca\Documents\GitHub\analogic-watch-detector\dataset\images\train"
+
+def convert_xml_to_yolo(xml_file, output_file):
+    tree = ET.parse(xml_file)
+    root = tree.getroot()
+
+    image_width = int(root.find('size/width').text)
+    image_height = int(root.find('size/height').text)
+    
+    yolo_annotations = []
+
+    for obj in root.findall('object'):
+        class_name = obj.find('name').text
+        class_id = class_mapping[class_name]
+
+        xmin = int(obj.find('bndbox/xmin').text)
+        ymin = int(obj.find('bndbox/ymin').text)
+        xmax = int(obj.find('bndbox/xmax').text)
+        ymax = int(obj.find('bndbox/ymax').text)
+
+        x_center = ((xmin + xmax) / 2) / image_width
+        y_center = ((ymin + ymax) / 2) / image_height
+        width = (xmax - xmin) / image_width
+        height = (ymax - ymin) / image_height
+
+        yolo_annotations.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+    with open(output_file, 'w') as f:
+        f.write("\n".join(yolo_annotations))
+
+# Processar todos os arquivos XML no diretório
+for filename in os.listdir(input_dir):
+    if filename.endswith(".xml"):
+        xml_path = os.path.join(input_dir, filename)
+        txt_filename = os.path.splitext(filename)[0] + ".txt"
+        txt_path = os.path.join(input_dir, txt_filename)
+        
+        try:
+            convert_xml_to_yolo(xml_path, txt_path)
+            print(f"Convertido: {xml_path} -> {txt_path}")
+            
+            # Apagar o arquivo XML após a conversão
+            os.remove(xml_path)
+            print(f"Arquivo XML apagado: {xml_path}")
+        except Exception as e:
+            print(f"Erro ao processar {xml_path}: {e}")

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.0
+ultralytics==8.3.40
+opencv-python-headless
+numpy==1.24.4
+torch==2.2.2
+torchvision==0.17.2
+pillow

tune4_best.pt

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

utils/clock_utils.py

@@ -0,0 +1,242 @@
+import cv2
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+from utils.detections_utils import run_detection
+import os
+
+
+def get_box_center(box):
+    """Calculate the center point of a bounding box"""
+    x = (box[0] + box[2]) / 2
+    y = (box[1] + box[3]) / 2
+    return (x, y)
+
+def calculate_angle(center, point, reference_point):
+    """Calculate angle between two points relative to 12 o'clock position"""
+    # Calculate vectors
+    ref_vector = (reference_point[0] - center[0], reference_point[1] - center[1])
+    point_vector = (point[0] - center[0], point[1] - center[1])
+    
+    # Calculate angles from vectors
+    ref_angle = math.atan2(ref_vector[1], ref_vector[0])
+    point_angle = math.atan2(point_vector[1], point_vector[0])
+    
+    # Calculate relative angle in degrees
+    angle = math.degrees(point_angle - ref_angle)
+    
+    # Normalize angle to 0-360 range
+    angle = (angle + 360) % 360
+    
+    return angle
+
+def process_clock_time(detections_data, image_path):
+    """Process clock time from detections"""
+    # Organize detections by class_name and select the one with highest confidence for each class
+    detections_by_class = {}
+    for detection in detections_data[0]:
+        class_name = detection['class_name']
+        if class_name not in detections_by_class or detection['confidence'] > detections_by_class[class_name]['confidence']:
+            detections_by_class[class_name] = detection
+
+    # Validate required keys
+    required_keys = ['hours', 'minutes', '12', 'circle']
+    for key in required_keys:
+        if key not in detections_by_class:
+            print(f"Error: Missing required key '{key}' in detection data.")
+            return None
+
+    # Calculate circle center
+    circle_box_point = get_box_center(detections_by_class['circle']['box'])
+    
+    # Determine center point: use 'center' if exists, otherwise use circle center
+    if 'center' in detections_by_class:
+        center_point = get_box_center(detections_by_class['center']['box'])
+    else:
+        center_point = circle_box_point
+
+    hours_point = get_box_center(detections_by_class['hours']['box'])
+    number_12_point = get_box_center(detections_by_class['12']['box'])
+
+    # Try to get seconds point with highest confidence
+    seconds_point = None
+    seconds_angle = None
+    calculated_seconds = 0
+    
+    if 'minutes' in detections_by_class:
+        minutes_point = get_box_center(detections_by_class['minutes']['box'])
+
+    if 'seconds' in detections_by_class:
+        seconds_point = get_box_center(detections_by_class['seconds']['box'])
+
+    # Calculate raw angles relative to 12 o'clock position
+    hour_angle = calculate_angle(center_point, hours_point, number_12_point)
+    
+    # Calculate minute angle
+    if minutes_point:
+        minute_angle = calculate_angle(center_point, minutes_point, number_12_point)
+
+    # Calculate seconds angle if seconds point exists
+    if seconds_point:
+        seconds_angle = calculate_angle(center_point, seconds_point, number_12_point)
+
+    # Convert angles to time
+    hours = (hour_angle / 30)  # Each hour is 30 degrees
+
+    # Round to nearest hour and minute
+    hours = math.floor(hours) % 12
+    if hours == 0:
+        hours = 12
+    
+    if minute_angle is not None:
+        minutes = (minute_angle / 6)
+        minutes = round(minutes) % 60
+        calculated_minutes = minutes
+    
+    # Calculate seconds if angle exists
+    if seconds_angle is not None:
+        seconds = (seconds_angle / 6)  # Each second is 6 degrees
+        seconds = round(seconds) % 60
+        calculated_seconds = seconds
+
+    return {
+        'hours': hours,
+        'minutes': calculated_minutes if minute_angle is not None else None,
+        'seconds': calculated_seconds if seconds_angle is not None else None
+    }
+
+def draw_clock(image_path, center_point, hours_point, minutes_point, seconds_point, number_12_point, hour_angle, minute_angle, seconds_angle, calculated_hours, calculated_minutes, calculated_seconds, image_name):
+    """Draw clock and reference points on the image"""
+
+    img = cv2.imread(image_path)
+    
+    # To int
+    center = (int(center_point[0]), int(center_point[1]))
+    hours = (int(hours_point[0]), int(hours_point[1]))
+    minutes = (int(minutes_point[0]), int(minutes_point[1])) if minutes_point else None
+    seconds = (int(seconds_point[0]), int(seconds_point[1])) if seconds_point else None
+    twelve = (int(number_12_point[0]), int(number_12_point[1]))
+    
+    # Draw the reference points
+    cv2.circle(img, center, 3, (0, 0, 255), -1)  # Centro em vermelho
+    cv2.circle(img, twelve, 3, (255, 0, 0), -1)  # Ponto 12 em azul
+    
+    # Draw the lines with thicker strokes
+    cv2.line(img, center, hours, (0, 0, 255), 5)     # Ponteiro das horas em vermelho 
+    if minutes:
+        cv2.line(img, center, minutes, (255, 0, 0), 4) # Ponteiro dos minutos em azul 
+    if seconds:
+        cv2.line(img, center, seconds, (255, 165, 0), 2)   # Ponteiro dos segundos em laranja 
+    
+    cv2.line(img, center, twelve, (0, 255, 0), 1)    # Linha de referência (12h) em verde
+    
+    # Draw the text
+    cv2.putText(img, f"Hour angle: {hour_angle:.1f}", 
+                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+    if minute_angle is not None:
+        cv2.putText(img, f"Minute angle: {minute_angle:.1f}", 
+                    (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+        time_text = f"Time: {int(calculated_hours):02d}:{int(calculated_minutes):02d}"
+    else:
+        time_text = f"Time: {int(calculated_hours):02d}"
+    
+    if seconds_angle is not None:
+        cv2.putText(img, f"Seconds angle: {seconds_angle:.1f}", 
+                    (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+        time_text = f"Time: {int(calculated_hours):02d}:{int(calculated_minutes):02d}:{int(calculated_seconds):02d}"
+    else:
+        time_text = f"Time: {int(calculated_hours):02d}:{int(calculated_minutes):02d}"
+    
+    cv2.putText(img, time_text, 
+                (10, 120 if seconds else 90), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+    
+
+    output_path = f'results/images/{image_name}'
+    cv2.imwrite(output_path, img)
+    print(f"Annotated image saved to {output_path}")
+    
+def zoom_into_clock_circle(image_path, confidence=0.01):
+    """
+    Attempt to find the clock circle and zoom into it for more precise detection.
+    
+    Args:
+        image_path (str): Path to the input image
+        confidence (float): Confidence threshold for detection
+    
+    Returns:
+        str: Path to the zoomed-in image, or None if no suitable circle found
+    """
+    # Read the image
+    image = cv2.imread(image_path)
+    
+    # Run detection to find clock circle
+    detections = run_detection(image_path, confidence=confidence)
+    
+    # Find the circle detection with highest confidence
+    circle_detection = None
+    for detection in detections[0]:
+        if detection['class_name'] == 'circle' and detection['confidence'] >= confidence:
+            if not circle_detection or detection['confidence'] > circle_detection['confidence']:
+                circle_detection = detection
+    
+    if not circle_detection:
+        return None
+    
+    # Extract bounding box
+    x1, y1, x2, y2 = circle_detection['box']
+    
+    # Add some padding (20% on each side)
+    height, width = image.shape[:2]
+    pad_x = int((x2 - x1) * 0.2)
+    pad_y = int((y2 - y1) * 0.2)
+    
+    # Calculate padded coordinates with boundary checks
+    x1_pad = max(0, x1 - pad_x)
+    y1_pad = max(0, y1 - pad_y)
+    x2_pad = min(width, x2 + pad_x)
+    y2_pad = min(height, y2 + pad_y)
+    
+    # Crop the image
+    zoomed_image = image[int(y1_pad):int(y2_pad), int(x1_pad):int(x2_pad)]
+    
+    # Save the zoomed image
+    zoomed_image_path = f'results/zoomed_images/{os.path.splitext(os.path.basename(image_path))[0]}_zoomed.jpg'
+    os.makedirs('results/zoomed_images', exist_ok=True)
+    cv2.imwrite(zoomed_image_path, zoomed_image)
+    
+    return zoomed_image_path
+
+def process_clock_with_fallback(image_path, confidence=0.01):
+    """
+    Attempt to process clock time with fallback to zoomed detection.
+    
+    Args:
+        image_path (str): Path to the input image
+        confidence (float): Confidence threshold for detection
+    
+    Returns:
+        dict or None: Processed clock time result
+    """
+    # First attempt with original image
+    #original_result = process_clock_time(run_detection(image_path, confidence=confidence), image_path)
+    
+    # If original detection succeeds, return the result
+    #if original_result:
+    #    return original_result
+    
+    # Try zooming into clock circle
+    zoomed_image_path = zoom_into_clock_circle(image_path, confidence)
+    
+    # If no zoom possible, return None
+    if not zoomed_image_path:
+        return None
+    
+    detections = run_detection(zoomed_image_path, confidence=confidence, zoom = True)
+    # Attempt detection on zoomed image
+    zoomed_result = process_clock_time(detections, zoomed_image_path)
+    
+    return detections, zoomed_result
+
+
+
+    

utils/detections_utils.py

@@ -0,0 +1,158 @@
+import os
+import re
+import json
+from ultralytics import YOLO
+import cv2
+import numpy as np
+import torch
+
+def get_latest_train_dir(base_path="runs/detect"):
+    """Find the most recent training directory (train, train1, train2, etc.)"""
+    if not os.path.exists(base_path):
+        raise FileNotFoundError(f"Directory {base_path} does not exist")
+    
+    train_dirs = [d for d in os.listdir(base_path) 
+                  if os.path.isdir(os.path.join(base_path, d)) and d.startswith('train')]
+    
+    if not train_dirs:
+        raise FileNotFoundError("No 'train' directory found")
+    
+    def get_train_number(dirname):
+        match = re.search(r'train(\d+)?$', dirname)
+        if not match or not match.group(1):
+            return -1
+        return int(match.group(1))
+    
+    latest_train = max(train_dirs, key=get_train_number)
+    return os.path.join(base_path, latest_train)
+
+def run_detection(
+    image_path=None,
+    model_path=None,
+    confidence=0.01,
+    save_path=None,
+    zoom=False,
+    model=None,
+    image=None,
+    save_visualization=True,
+    return_prediction_results=False,
+):
+    """
+    Run object detection on an image without Non-Maximum Suppression
+
+    Args:
+        image_path (str): Path to the input image
+        model_path (str, optional): Path to the YOLO model weights
+        confidence (float, optional): Initial confidence threshold
+        save_path (str, optional): Path to save detection results JSON
+
+    Returns:
+        list: Detections from the image
+    """
+    # Find model path if not provided
+    if image_path is None and image is None:
+        raise ValueError("Either 'image_path' or 'image' must be provided for detection.")
+
+    if model is None:
+        if not model_path:
+            model_path = os.path.join(get_latest_train_dir(), "weights/best.pt")
+        model = YOLO(model_path)
+
+    # Default save path if not specified
+    image_identifier = (
+        os.path.splitext(os.path.basename(image_path))[0]
+        if image_path
+        else "uploaded_image"
+    )
+    if not save_path and image_path:
+        save_path = os.path.join('results/detections', f'{image_identifier}_detection.json')
+
+    # Ensure detections directory exists
+    if save_path:
+        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    if save_visualization and image_path:
+        os.makedirs('results/image_detections', exist_ok=True)
+
+    # Determine prediction source
+    source = image if image is not None else image_path
+
+    # Run detection
+    results = model.predict(
+        source=source,
+        save=save_visualization,
+        save_txt=False,
+        conf=confidence,
+        max_det=50,
+        verbose=False,
+    )
+
+    # Convert detections to list format
+    detections = []
+    for result in results:
+        # Extract raw detections
+        boxes = result.boxes.xyxy.cpu().numpy()
+        confidences = result.boxes.conf.cpu().numpy()
+        classes = result.boxes.cls.cpu().numpy()
+
+        # Get class names
+        if hasattr(result.names, 'items'):
+            class_names = {int(k): v for k, v in result.names.items()}
+        else:
+            class_names = {int(cls_id): str(cls_id) for cls_id in np.unique(classes)}
+
+        # Create list of detections for this image
+        image_detections = []
+        for box, score, cls_id in zip(boxes, confidences, classes):
+            cls_name = class_names.get(int(cls_id), "unknown")
+            detection = {
+                'box': box.tolist(),  # [x_min, y_min, x_max, y_max]
+                'confidence': float(score),
+                'class_id': int(cls_id),
+                'class_name': cls_name
+            }
+            image_detections.append(detection)
+
+        detections.append(image_detections)
+
+    # Create a visualization only for detections with confidence > 0.1
+    if save_visualization and results:
+        filtered_results = results.copy()
+
+        # Filtred results with confidence > 0.1
+        filtered_results[0].boxes = filtered_results[0].boxes[filtered_results[0].boxes.conf > 0.1]
+
+        # Plot the detections
+        res_plotted = filtered_results[0].plot()
+
+        output_path = f"results/image_detections/{image_identifier}_detection.jpg"
+        cv2.imwrite(output_path, res_plotted)
+        print(f"Imagem salva com as detecções em: results/image_detections/{image_identifier}")
+
+    # Save to JSON file
+    if save_path:
+        with open(save_path, 'w') as f:
+            json.dump(detections, f, indent=4)
+
+        print(f"Detections saved to: {save_path}")
+
+    if return_prediction_results:
+        return detections, results
+
+    return detections
+
+
+
+def load_detections(input_file):
+    """
+    Load detections from a JSON file
+    
+    Args:
+        input_file (str): Path to the JSON detection file
+        
+    Returns:
+        list: Loaded detections
+    """
+    with open(input_file, 'r') as f:
+        detections = json.load(f)
+    return detections
+

utils/train_hiper.py

@@ -0,0 +1,11 @@
+from ultralytics import YOLO
+model = YOLO('yolov8s.pt')
+
+results = model.tune(data='dataset.yaml', epochs=25,           
+    iterations=10,           
+    device=0,
+    optimizer='adamw',
+    plots=True,
+    save=True,
+    conf=0.25,
+    iou=0.45)

utils/train_model.py

@@ -0,0 +1,31 @@
+import yaml
+from ultralytics import YOLO
+
+def main():
+    
+    file_path = "runs/detect/tune4/best_hyperparameters.yaml"
+
+    
+    with open(file_path, 'r') as file:
+        hyperparameters = yaml.safe_load(file)
+
+    print(hyperparameters)
+
+    model = YOLO('yolov8s.pt')
+    model.train(
+        data='dataset.yaml',
+        **hyperparameters,
+        imgsz=768,
+        batch=16,
+        device=0,
+        optimizer='adamw',
+        plots=True,
+        save=True,
+        conf=0.25,
+        iou=0.45,
+        epochs=200,
+        patience=20
+    )
+
+if __name__ == "__main__":
+    main()