ADD INFERENCE ENDPOINTS for images and video

.gitattributes

@@ -33,3 +33,5 @@ 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
+models/SV_FT_TSWC_kp filter=lfs diff=lfs merge=lfs -text
+models/SV_FT_TSWC_lines filter=lfs diff=lfs merge=lfs -text

api.py

@@ -1,15 +1,27 @@
 from fastapi import FastAPI, HTTPException, UploadFile, File, Form
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional
 import json
 import tempfile
 import os
 from PIL import Image
 import numpy as np
+import cv2
+import torch
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+import yaml
+from tqdm import tqdm
 
 from get_camera_params import get_camera_parameters
 
+# Imports pour l'inférence automatique
+from model.cls_hrnet import get_cls_net
+from model.cls_hrnet_l import get_cls_net as get_cls_net_l
+from utils.utils_calib import FramebyFrameCalib
+from utils.utils_heatmap import get_keypoints_from_heatmap_batch_maxpool, get_keypoints_from_heatmap_batch_maxpool_l, complete_keypoints, coords_to_dict
+
 app = FastAPI(
     title="Football Vision Calibration API",
     description="API pour la calibration de caméras à partir de lignes de terrain de football",
@@ -25,6 +37,80 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Paramètres par défaut pour l'inférence
+WEIGHTS_KP = "models/SV_FT_TSWC_kp"
+WEIGHTS_LINE = "models/SV_FT_TSWC_lines"
+DEVICE = "cuda:0"
+KP_THRESHOLD = 0.15
+LINE_THRESHOLD = 0.15
+PNL_REFINE = True
+FRAME_STEP = 5
+
+# Cache pour les modèles (éviter de les recharger à chaque requête)
+_models_cache = None
+
+def load_inference_models():
+    """Charge les modèles d'inférence (avec cache)"""
+    global _models_cache
+    
+    if _models_cache is not None:
+        return _models_cache
+    
+    device = torch.device(DEVICE if torch.cuda.is_available() else 'cpu')
+    
+    # Charger les configurations
+    cfg = yaml.safe_load(open("config/hrnetv2_w48.yaml", 'r'))
+    cfg_l = yaml.safe_load(open("config/hrnetv2_w48_l.yaml", 'r'))
+    
+    # Modèle keypoints
+    model = get_cls_net(cfg)
+    model.load_state_dict(torch.load(WEIGHTS_KP, map_location=device))
+    model.to(device)
+    model.eval()
+    
+    # Modèle lignes
+    model_l = get_cls_net_l(cfg_l)
+    model_l.load_state_dict(torch.load(WEIGHTS_LINE, map_location=device))
+    model_l.to(device)
+    model_l.eval()
+    
+    _models_cache = (model, model_l, device)
+    return _models_cache
+
+def process_frame_inference(frame, model, model_l, device, frame_width, frame_height):
+    """Traite une frame et retourne les paramètres de caméra"""
+    transform = T.Resize((540, 960))
+    
+    # Préparer la frame pour l'inférence
+    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    frame_pil = Image.fromarray(frame_rgb)
+    frame_tensor = f.to_tensor(frame_pil).float().unsqueeze(0)
+    
+    if frame_tensor.size()[-1] != 960:
+        frame_tensor = transform(frame_tensor)
+    
+    frame_tensor = frame_tensor.to(device)
+    b, c, h, w = frame_tensor.size()
+    
+    # Inférence
+    with torch.no_grad():
+        heatmaps = model(frame_tensor)
+        heatmaps_l = model_l(frame_tensor)
+    
+    # Extraire les keypoints et lignes
+    kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:,:-1,:,:])
+    line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:,:-1,:,:])
+    kp_dict = coords_to_dict(kp_coords, threshold=KP_THRESHOLD)
+    lines_dict = coords_to_dict(line_coords, threshold=LINE_THRESHOLD)
+    kp_dict, lines_dict = complete_keypoints(kp_dict[0], lines_dict[0], w=w, h=h, normalize=True)
+    
+    # Calibration
+    cam = FramebyFrameCalib(iwidth=frame_width, iheight=frame_height, denormalize=True)
+    cam.update(kp_dict, lines_dict)
+    final_params_dict = cam.heuristic_voting(refine_lines=PNL_REFINE)
+    
+    return final_params_dict
+
 # Modèles Pydantic pour la validation des données
 class Point(BaseModel):
     x: float
@@ -42,6 +128,19 @@ class CalibrationResponse(BaseModel):
     input_lines: Dict[str, List[Point]]
     message: str
 
+class InferenceImageResponse(BaseModel):
+    status: str
+    camera_parameters: Optional[Dict[str, Any]]
+    image_info: Dict[str, Any]
+    message: str
+
+class InferenceVideoResponse(BaseModel):
+    status: str
+    camera_parameters: List[Dict[str, Any]]
+    video_info: Dict[str, Any]
+    frames_processed: int
+    message: str
+
 @app.get("/")
 async def root():
     return {
@@ -49,6 +148,8 @@ async def root():
         "version": "1.0.0",
         "endpoints": {
             "/calibrate": "POST - Calibrer une caméra à partir d'une image et de lignes",
+            "/inference/image": "POST - Extraire les paramètres de caméra d'une image automatiquement",
+            "/inference/video": "POST - Extraire les paramètres de caméra d'une vidéo automatiquement",
             "/health": "GET - Vérifier l'état de l'API"
         }
     }
@@ -74,9 +175,20 @@ async def calibrate_camera(
         Paramètres de calibration de la caméra et lignes d'entrée
     """
     try:
-        # Validation du format d'image
-        if not image.content_type.startswith('image/'):
-            raise HTTPException(status_code=400, detail="Le fichier doit être une image")
+        # Validation du format d'image - version robuste
+        content_type = getattr(image, 'content_type', None) or ""
+        filename = getattr(image, 'filename', "") or ""
+        
+        # Vérifier le type MIME ou l'extension du fichier
+        image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif']
+        is_image_content = content_type.startswith('image/') if content_type else False
+        is_image_extension = any(filename.lower().endswith(ext) for ext in image_extensions)
+        
+        if not is_image_content and not is_image_extension:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Le fichier doit être une image. Type détecté: {content_type}, Fichier: {filename}"
+            )
         
         # Parse des données de lignes
         try:
@@ -114,7 +226,8 @@ async def calibrate_camera(
             validated_lines[line_name] = validated_points
         
         # Sauvegarde temporaire de l'image
-        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{image.filename.split('.')[-1]}") as temp_file:
+        file_extension = os.path.splitext(filename)[1] if filename else '.jpg'
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
             content = await image.read()
             temp_file.write(content)
             temp_image_path = temp_file.name
@@ -153,10 +266,219 @@ async def calibrate_camera(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erreur interne: {str(e)}")
 
-# if __name__ == "__main__":
-#     import uvicorn
-#     uvicorn.run(app, host="0.0.0.0", port=8000)
+@app.post("/inference/image", response_model=InferenceImageResponse)
+async def inference_image(
+    image: UploadFile = File(..., description="Image du terrain de football"),
+    kp_threshold: float = Form(KP_THRESHOLD, description="Seuil pour les keypoints"),
+    line_threshold: float = Form(LINE_THRESHOLD, description="Seuil pour les lignes")
+):
+    """
+    Extraire automatiquement les paramètres de caméra à partir d'une image.
+    
+    Args:
+        image: Image du terrain de football (formats: jpg, jpeg, png)
+        kp_threshold: Seuil pour la détection des keypoints (défaut: 0.15)
+        line_threshold: Seuil pour la détection des lignes (défaut: 0.15)
+    
+    Returns:
+        Paramètres de calibration de la caméra extraits automatiquement
+    """
+    try:
+        # Validation du format d'image - version robuste
+        content_type = getattr(image, 'content_type', None) or ""
+        filename = getattr(image, 'filename', "") or ""
+        
+        # Vérifier le type MIME ou l'extension du fichier
+        image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif']
+        is_image_content = content_type.startswith('image/') if content_type else False
+        is_image_extension = any(filename.lower().endswith(ext) for ext in image_extensions)
+        
+        if not is_image_content and not is_image_extension:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Le fichier doit être une image. Type détecté: {content_type}, Fichier: {filename}"
+            )
+        
+        # Sauvegarde temporaire de l'image
+        file_extension = os.path.splitext(filename)[1] if filename else '.jpg'
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            content = await image.read()
+            temp_file.write(content)
+            temp_image_path = temp_file.name
+        
+        try:
+            # Charger les modèles
+            model, model_l, device = load_inference_models()
+            
+            # Lire l'image
+            frame = cv2.imread(temp_image_path)
+            if frame is None:
+                raise HTTPException(status_code=400, detail="Impossible de lire l'image")
+            
+            frame_height, frame_width = frame.shape[:2]
+            
+            # Mettre à jour les seuils globaux
+            global KP_THRESHOLD, LINE_THRESHOLD
+            KP_THRESHOLD = kp_threshold
+            LINE_THRESHOLD = line_threshold
+            
+            # Traitement
+            params = process_frame_inference(frame, model, model_l, device, frame_width, frame_height)
+            # Formatage de la réponse
+            response = InferenceImageResponse(
+                status="success" if params is not None else "failed",
+                camera_parameters=params,
+                image_info={
+                    "filename": filename,
+                    "width": frame_width,
+                    "height": frame_height,
+                    "kp_threshold": kp_threshold,
+                    "line_threshold": line_threshold
+                },
+                message="Paramètres extraits avec succès" if params is not None else "Échec de l'extraction des paramètres"
+            )
+            
+            return response
+            
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Erreur lors de l'inférence: {str(e)} \n params:\n{params}"
+            )
+        
+        finally:
+            # Nettoyage du fichier temporaire
+            if os.path.exists(temp_image_path):
+                os.unlink(temp_image_path)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur interne: {str(e)}")
+
+@app.post("/inference/video", response_model=InferenceVideoResponse)
+async def inference_video(
+    video: UploadFile = File(..., description="Vidéo du terrain de football"),
+    kp_threshold: float = Form(KP_THRESHOLD, description="Seuil pour les keypoints"),
+    line_threshold: float = Form(LINE_THRESHOLD, description="Seuil pour les lignes"),
+    frame_step: int = Form(FRAME_STEP, description="Traiter 1 frame sur N")
+):
+    """
+    Extraire automatiquement les paramètres de caméra à partir d'une vidéo.
+    
+    Args:
+        video: Vidéo du terrain de football (formats: mp4, avi, mov, etc.)
+        kp_threshold: Seuil pour la détection des keypoints (défaut: 0.15)
+        line_threshold: Seuil pour la détection des lignes (défaut: 0.15)
+        frame_step: Traiter 1 frame sur N pour accélérer le traitement (défaut: 5)
+    
+    Returns:
+        Liste des paramètres de calibration de la caméra pour chaque frame traitée
+    """
+    try:
+        # Validation du format vidéo - version robuste
+        content_type = getattr(video, 'content_type', None) or ""
+        filename = getattr(video, 'filename', "") or ""
+        
+        video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv']
+        is_video_content = content_type.startswith('video/') if content_type else False
+        is_video_extension = any(filename.lower().endswith(ext) for ext in video_extensions)
+        
+        if not is_video_content and not is_video_extension:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Le fichier doit être une vidéo. Type détecté: {content_type}, Fichier: {filename}"
+            )
+        
+        # Sauvegarde temporaire de la vidéo
+        file_extension = os.path.splitext(filename)[1] if filename else '.mp4'
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            content = await video.read()
+            temp_file.write(content)
+            temp_video_path = temp_file.name
+        
+        try:
+            # Charger les modèles
+            model, model_l, device = load_inference_models()
+            
+            # Ouvrir la vidéo
+            cap = cv2.VideoCapture(temp_video_path)
+            if not cap.isOpened():
+                raise HTTPException(status_code=400, detail="Impossible d'ouvrir la vidéo")
+            
+            frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            
+            # Mettre à jour les seuils globaux
+            global KP_THRESHOLD, LINE_THRESHOLD
+            KP_THRESHOLD = kp_threshold
+            LINE_THRESHOLD = line_threshold
+            
+            all_params = []
+            frame_count = 0
+            processed_count = 0
+            
+            while cap.isOpened():
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                    
+                # Traiter seulement 1 frame sur frame_step
+                if frame_count % frame_step != 0:
+                    frame_count += 1
+                    continue
+                
+                # Traitement
+                params = process_frame_inference(frame, model, model_l, device, frame_width, frame_height)
+                
+                if params is not None:
+                    params['frame_number'] = frame_count
+                    params['timestamp_seconds'] = frame_count / fps
+                    all_params.append(params)
+                    processed_count += 1
+                
+                frame_count += 1
+            
+            cap.release()
+            
+            # Formatage de la réponse
+            response = InferenceVideoResponse(
+                status="success" if all_params else "failed",
+                camera_parameters=all_params,
+                video_info={
+                    "filename": filename,
+                    "width": frame_width,
+                    "height": frame_height,
+                    "total_frames": total_frames,
+                    "fps": fps,
+                    "duration_seconds": total_frames / fps,
+                    "kp_threshold": kp_threshold,
+                    "line_threshold": line_threshold,
+                    "frame_step": frame_step
+                },
+                frames_processed=processed_count,
+                message=f"Paramètres extraits de {processed_count} frames" if all_params else "Aucun paramètre extrait"
+            )
+            
+            return response
+            
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Erreur lors de l'inférence vidéo: {str(e)}"
+            )
+        
+        finally:
+            # Nettoyage du fichier temporaire
+            if os.path.exists(temp_video_path):
+                os.unlink(temp_video_path)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur interne: {str(e)}")
 
-# Ajoutez ceci à la place :
 # Point d'entrée pour Vercel
 app_instance = app

test-api.py

@@ -5,6 +5,8 @@ from pathlib import Path
 # Configuration
 API_URL = "http://localhost:8000"
 IMAGE_PATH = "examples/input/cam3.jpg"  # Adaptez selon votre structure
+# IMAGE_PATH = "examples/input/FootDrone.jpg"  # Adaptez selon votre structure
+VIDEO_PATH = "examples/input/FootDrone.mp4"  # Adaptez selon votre structure
 
 # Données d'exemple (votre cam3_line_dict)
 cam3_line_dict = {
@@ -19,38 +21,289 @@ cam3_line_dict = {
         {"x": 349.8767728435256, "y": 500.9610345717304},
         {"x": 32.736572890025556, "y": 397.21988189225624}
     ],
-    # ... ajoutez les autres lignes si nécessaire
+    "Big rect. right bottom": [
+        {"x": 32.736572890025556, "y": 397.21988189225624},
+        {"x": 0.3753980224568448, "y": 407.0286292126068}
+    ],
+    "Small rect. right top": [
+        {"x": 312.24913494809687, "y": 1075.6461846681693},
+        {"x": 426.66666666666663, "y": 999.9279904137233}
+    ],
+    "Small rect. right main": [
+        {"x": 426.66666666666663, "y": 999.9279904137233},
+        {"x": 0, "y": 769.079837198949}
+    ],
+    "Circle right": [
+        {"x": 828.6491513601493, "y": 668.8579000924583},
+        {"x": 821.7759602949911, "y": 612.2830792373484},
+        {"x": 782.8739995106773, "y": 564.5621490047902},
+        {"x": 722.6387053930304, "y": 529.3993583071158},
+        {"x": 623.5014504910696, "y": 503.02726528386006},
+        {"x": 494.24654853028534, "y": 492.980753655953},
+        {"x": 349.8767728435256, "y": 500.9610345717304}
+    ],
+    "Side line bottom": [
+        {"x": 2.0193824656299317, "y": 266.2605192109321},
+        {"x": 399.0443993689428, "y": 186.14824976426013},
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1001.1088573360372, "y": 53.39824942655338},
+        {"x": 1208.1676808654488, "y": 7.351737798646435}
+    ],
+    "Middle line": [
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1106.0585089650835, "y": 200.22939899146556},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1917.6527118636336, "y": 318.9857185061268}
+    ],
+    "Circle central": [
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1533.8366024891266, "y": 288.8643838246303},
+        {"x": 1441.810458698277, "y": 302.46903498742097},
+        {"x": 1316.3202626198458, "y": 304.5620582432349},
+        {"x": 1219.0653606590615, "y": 292.0039187083512},
+        {"x": 1135.4052299401073, "y": 274.2132210339326},
+        {"x": 1069.522876998931, "y": 237.5853140571884},
+        {"x": 1106.0585089650835, "y": 200.22939899146556},
+        {"x": 1139.5882364760548, "y": 189.4457791734675},
+        {"x": 1224.2941188289963, "y": 177.9341512664908},
+        {"x": 1314.2287593518718, "y": 174.79461638276985},
+        {"x": 1392.6601319008914, "y": 180.02717452230473},
+        {"x": 1465.8627462799764, "y": 190.49229080137454},
+        {"x": 1529.6535959531789, "y": 204.09694196416518},
+        {"x": 1581.9411776525253, "y": 230.2597326618396},
+        {"x": 1580.7388158704541, "y": 269.8451725000601}
+    ],
+    "Side line left": [
+        {"x": 1208.1676808654488, "y": 7.351737798646435},
+        {"x": 1401.9652021886754, "y": 20.565213248502545},
+        {"x": 1582.3573590514204, "y": 30.37625976013045},
+        {"x": 1679.416182580832, "y": 34.300678364781604},
+        {"x": 1824.5142217965183, "y": 41.23091697692868},
+        {"x": 1918.6318688553417, "y": 42.21202162809147}
+    ],
+    "Big rect. left bottom": [
+        {"x": 1401.9652021886754, "y": 20.565213248502545},
+        {"x": 1283.3377512082834, "y": 53.98527744204496}
+    ],
+    "Big rect. left main": [
+        {"x": 1283.3377512082834, "y": 53.98527744204496},
+        {"x": 1510.7887316004399, "y": 73.60737046530076},
+        {"x": 1808.8279472867146, "y": 94.21056813971936},
+        {"x": 1918.6318688553417, "y": 100.0971960466961}
+    ],
+    "Circle left": [
+        {"x": 1510.7887316004399, "y": 73.60737046530076},
+        {"x": 1548.0436335612244, "y": 86.36173093041702},
+        {"x": 1620.5926531690673, "y": 95.19167279088215},
+        {"x": 1681.3769668945574, "y": 97.15388209320773},
+        {"x": 1746.0828492474989, "y": 100.0971960466961},
+        {"x": 1808.8279472867146, "y": 94.21056813971936}
+    ],
+    "Small rect. left bottom": [
+        {"x": 1550.9848100318127, "y": 42.21202162809147},
+        {"x": 1582.3573590514204, "y": 30.37625976013045}
+    ],
+    "Small rect. left main": [
+        {"x": 1550.9848100318127, "y": 42.21202162809147},
+        {"x": 1918.418689198772, "y": 60.49417894940041}
+    ]
 }
 
-def test_api():
-    """Test de l'API de calibration"""
+def test_health():
+    """Test du health check"""
+    try:
+        response = requests.get(f"{API_URL}/health")
+        print(f"Health check: {response.status_code} - {response.json()}")
+        return response.status_code == 200
+    except requests.exceptions.ConnectionError:
+        print("❌ Impossible de se connecter à l'API. Vérifiez qu'elle est démarrée.")
+        return False
+    except Exception as e:
+        print(f"❌ Erreur health check: {e}")
+        return False
+
+def test_calibration():
+    """Test de l'API de calibration avec lignes manuelles"""
+    if not Path(IMAGE_PATH).exists():
+        print(f"❌ Image non trouvée: {IMAGE_PATH}")
+        print(f"   Chemin absolu: {Path(IMAGE_PATH).absolute()}")
+        return
     
-    # Test du health check
-    response = requests.get(f"{API_URL}/health")
-    print(f"Health check: {response.status_code} - {response.json()}")
+    print(f"📁 Test avec l'image: {IMAGE_PATH}")
+    print(f"   Taille du fichier: {Path(IMAGE_PATH).stat().st_size} bytes")
     
-    # Test de calibration
-    if Path(IMAGE_PATH).exists():
+    try:
         with open(IMAGE_PATH, 'rb') as image_file:
-            files = {'image': image_file}
+            files = {'image': (Path(IMAGE_PATH).name, image_file, 'image/jpeg')}
             data = {'lines_data': json.dumps(cam3_line_dict)}
             
+            print("🚀 Envoi de la requête de calibration...")
             response = requests.post(
                 f"{API_URL}/calibrate",
                 files=files,
                 data=data
             )
             
+            print(f"📡 Réponse reçue: {response.status_code}")
+            
             if response.status_code == 200:
                 result = response.json()
                 print("✅ Calibration réussie!")
                 print("Paramètres de la caméra:")
                 print(json.dumps(result['camera_parameters'], indent=2))
             else:
-                print(f"❌ Erreur: {response.status_code}")
-                print(response.json())
-    else:
+                print(f"❌ Erreur calibration: {response.status_code}")
+                try:
+                    error_detail = response.json()
+                    print(f"Détail de l'erreur: {error_detail}")
+                except:
+                    print(f"Réponse brute: {response.text}")
+                    
+    except Exception as e:
+        print(f"❌ Exception lors du test de calibration: {e}")
+
+def test_inference_image():
+    """Test de l'inférence automatique sur image"""
+    if not Path(IMAGE_PATH).exists():
         print(f"❌ Image non trouvée: {IMAGE_PATH}")
+        print(f"   Chemin absolu: {Path(IMAGE_PATH).absolute()}")
+        return
+        
+    print(f"📁 Test inférence avec l'image: {IMAGE_PATH}")
+    print(f"   Taille du fichier: {Path(IMAGE_PATH).stat().st_size} bytes")
+    
+    try:
+        with open(IMAGE_PATH, 'rb') as image_file:
+            files = {'image': (Path(IMAGE_PATH).name, image_file, 'image/jpeg')}
+            data = {
+                'kp_threshold': 0.15,
+                'line_threshold': 0.15
+            }
+            
+            print("🚀 Envoi de la requête d'inférence image...")
+            response = requests.post(
+                f"{API_URL}/inference/image",
+                files=files,
+                data=data
+            )
+            
+            print(f"📡 Réponse reçue: {response.status_code}")
+            print(f"📡 Réponse reçue: {response.json()}")
+            
+            if response.status_code == 200 and response.json()['status'] == 'success':
+                result = response.json()
+                print("✅ Inférence image réussie!")
+                print(f"Status: {result['status']}")
+                print(f"Image info: {result['image_info']}")
+                if result['camera_parameters']:
+                    print("Paramètres de la caméra:")
+                    cam_params = result['camera_parameters'].get('cam_params', {})
+                    print(f"  Position: {cam_params.get('position_meters', 'N/A')}")
+                    print(f"  Focale X: {cam_params.get('x_focal_length', 'N/A')}")
+                    print(f"  Focale Y: {cam_params.get('y_focal_length', 'N/A')}")
+            else:
+                print(f"❌ Erreur inférence image: {response.status_code}")
+                try:
+                    error_detail = response.json()
+                    print(f"Détail de l'erreur: {error_detail}")
+                except:
+                    print(f"Réponse brute: {response.text}")
+                    
+    except Exception as e:
+        print(f"❌ Exception lors du test d'inférence image: {e}")
+
+def test_inference_video():
+    """Test de l'inférence automatique sur vidéo"""
+    if not Path(VIDEO_PATH).exists():
+        print(f"❌ Vidéo non trouvée: {VIDEO_PATH}")
+        print(f"   Chemin absolu: {Path(VIDEO_PATH).absolute()}")
+        return
+        
+    print(f"📁 Test inférence avec la vidéo: {VIDEO_PATH}")
+    print(f"   Taille du fichier: {Path(VIDEO_PATH).stat().st_size} bytes")
+    print("🎬 Test inférence vidéo (peut prendre du temps...)") 
+    
+    try:
+        with open(VIDEO_PATH, 'rb') as video_file:
+            files = {'video': (Path(VIDEO_PATH).name, video_file, 'video/mp4')}
+            data = {
+                'kp_threshold': 0.15,
+                'line_threshold': 0.15,
+                'frame_step': 200  # Traiter 1 frame sur 10 pour le test
+            }
+            
+            print("🚀 Envoi de la requête d'inférence vidéo...")
+            response = requests.post(
+                f"{API_URL}/inference/video",
+                files=files,
+                data=data
+            )
+            
+            print(f"📡 Réponse reçue: {response.status_code}")
+            
+            if response.status_code == 200:
+                result = response.json()
+                print("✅ Inférence vidéo réussie!")
+                print(f"Status: {result['status']}")
+                print(f"Frames traitées: {result['frames_processed']}")
+                print(f"Vidéo info: {result['video_info']}")
+                
+                if result['camera_parameters']:
+                    print(f"\n=== Exemples de paramètres ===")
+                    for i, params in enumerate(result['camera_parameters'][:3]):
+                        frame_num = params.get('frame_number', i)
+                        timestamp = params.get('timestamp_seconds', 0)
+                        print(f"Frame {frame_num} (t={timestamp:.2f}s):")
+                        if 'cam_params' in params:
+                            cam_params = params['cam_params']
+                            print(f"  Position: {cam_params.get('position_meters', 'N/A')}")
+                            print(f"  Focales: X={cam_params.get('x_focal_length', 'N/A')}, Y={cam_params.get('y_focal_length', 'N/A')}")
+                    
+                    if len(result['camera_parameters']) > 3:
+                        print(f"... et {len(result['camera_parameters']) - 3} autres frames")
+            else:
+                print(f"❌ Erreur inférence vidéo: {response.status_code}")
+                try:
+                    error_detail = response.json()
+                    print(f"Détail de l'erreur: {error_detail}")
+                except:
+                    print(f"Réponse brute: {response.text}")
+                    
+    except Exception as e:
+        print(f"❌ Exception lors du test d'inférence vidéo: {e}")
+
+def test_all():
+    """Lance tous les tests"""
+    print("=== TEST DE L'API FOOTBALL VISION ===\n")
+    
+    # Test 1: Health check
+    # print("1. Test Health Check")
+    # if not test_health():
+    #     print("❌ API non accessible, arrêt des tests")
+    #     return
+    # print()
+    
+    # # Vérifier les chemins des fichiers
+    # print("2. Vérification des fichiers")
+    # print(f"   Image: {'✅' if Path(IMAGE_PATH).exists() else '❌'} {IMAGE_PATH}")
+    # print(f"   Vidéo: {'✅' if Path(VIDEO_PATH).exists() else '❌'} {VIDEO_PATH}")
+    # print()
+    
+    # # Test 2: Calibration avec lignes manuelles
+    # print("3. Test Calibration (lignes manuelles)")
+    # test_calibration()
+    # print()
+    
+    # Test 3: Inférence image
+    print("4. Test Inférence Image (automatique)")
+    test_inference_image()
+    print()
+    
+    # # Test 4: Inférence vidéo
+    # print("5. Test Inférence Vidéo (automatique)")
+    # test_inference_video()
+    # print()
 
 if __name__ == "__main__":
-    test_api()
+    test_all()