deploy1

.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+#
+/mdodels/models--keizer77--samyolo2
+/models/*
+
+#files
+*.pth

Dockerfile

@@ -0,0 +1,21 @@
+# Étape 1 : Utiliser l'image officielle Python 3.12
+FROM python:3.12-slim
+
+# Étape 2 : Définir le répertoire de travail dans le conteneur
+WORKDIR /app
+
+# Étape 3 : Copier les fichiers nécessaires dans le conteneur
+COPY . /app
+
+# Étape 4 : Donner les permissions au fichier .sh
+RUN chmod +x ./startup.sh
+
+# Étape 5 : Installer les dépendances Python
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# Étape 6 : Exposer le port (par défaut pour Gunicorn)
+EXPOSE 8000
+
+# Étape 7 : Définir la commande d'entrée pour exécuter le script .sh
+CMD ["./startup.sh"]

app.py

@@ -0,0 +1,169 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory,url_for
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+# Générer une couleur unique pour chaque classe
+# Fonction pour générer une couleur unique pour chaque classe
+def get_color_for_class(class_name):
+    np.random.seed(hash(class_name) % (2**32))
+    return tuple(np.random.randint(0, 256, size=3).tolist())
+
+# Convertir un masque en bounding box au format YOLOv5
+def mask_to_yolo_bbox(mask):
+    y_indices, x_indices = np.where(mask > 0)
+    if len(x_indices) == 0 or len(y_indices) == 0:
+        return None
+    x_min, x_max = x_indices.min(), x_indices.max()
+    y_min, y_max = y_indices.min(), y_indices.max()
+    x_center = (x_min + x_max) / 2
+    y_center = (y_min + y_max) / 2
+    width = x_max - x_min
+    height = y_max - y_min
+    return x_center, y_center, width, height
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    """Page principale pour télécharger et afficher les images."""
+    if request.method == 'POST':
+        files = request.files.getlist('images')
+        if not files:
+            return "Aucun fichier sélectionné", 400
+
+        filenames = []
+        for file in files:
+            filename = secure_filename(file.filename)
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(filepath)
+            filenames.append(filename)
+
+        return render_template('index.html', uploaded_images=filenames)
+
+    uploaded_images = os.listdir(app.config['UPLOAD_FOLDER'])
+    return render_template('index.html', uploaded_images=uploaded_images)
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    """Servir les fichiers uploadés."""
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    """Endpoint pour effectuer la segmentation des images."""
+    try:
+        data = request.get_json()
+        print("Données reçues :", data)
+
+        if not isinstance(data, list):
+            return jsonify({'success': False, 'error': 'Format incorrect : liste attendue'}), 400
+
+        output = []
+
+        for item in data:
+            image_name = item.get('image_name')
+            points = item.get('points', [])
+
+            if not image_name or not points:
+                return jsonify({'success': False, 'error': f"Données manquantes pour l'image {image_name}"}), 400
+
+            image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+            if not os.path.exists(image_path):
+                return jsonify({'success': False, 'error': f"Image {image_name} non trouvée"}), 404
+
+            # Charger l'image
+            image = cv2.imread(image_path)
+            if image is None:
+                return jsonify({'success': False, 'error': f"Impossible de charger l'image {image_name}"}), 400
+
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            predictor.set_image(image_rgb)
+            annotated_image = image.copy()
+            yolo_annotations = []
+
+            for point in points:
+                x, y = point['x'], point['y']
+                class_name = point.get('class', 'Unknown')
+                color = get_color_for_class(class_name)
+
+                try:
+                    masks, _, _ = predictor.predict(
+                        point_coords=np.array([[x, y]]),
+                        point_labels=np.array([1]),
+                        multimask_output=False
+                    )
+                    mask = masks[0]
+                    annotated_image[mask > 0] = color
+
+                    # Convertir le masque en bounding box YOLOv5
+                    bbox = mask_to_yolo_bbox(mask)
+                    if bbox:
+                        x_center, y_center, width, height = bbox
+                        x_center /= image.shape[1]
+                        y_center /= image.shape[0]
+                        width /= image.shape[1]
+                        height /= image.shape[0]
+                        yolo_annotations.append(f"{class_name} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+                except Exception as e:
+                    print(f"Erreur de segmentation pour le point {point} : {e}")
+
+            # Sauvegarder les résultats
+            output_dir = os.path.join(app.config['UPLOAD_FOLDER'], os.path.splitext(image_name)[0])
+            os.makedirs(output_dir, exist_ok=True)
+            annotated_path = os.path.join(output_dir, f"annotated_{image_name}")
+            cv2.imwrite(annotated_path, annotated_image)
+
+            yolo_path = os.path.join(output_dir, f"{os.path.splitext(image_name)[0]}.txt")
+            with open(yolo_path, "w") as f:
+                f.write("\n".join(yolo_annotations))
+            
+            new_image_path = os.path.join(output_dir, image_name)
+            if not os.path.exists(new_image_path):
+                os.rename(image_path, new_image_path)
+
+            output.append({
+                'image_name': image_name,
+                'annotated_image': url_for('static', filename=f"uploads/{os.path.splitext(image_name)[0]}/annotated_{image_name}"),
+                'yolo_annotations': url_for('static', filename=f"uploads/{os.path.splitext(image_name)[0]}/{os.path.splitext(image_name)[0]}.txt")
+            })
+
+        return jsonify({'success': True, 'results': output})
+
+    except Exception as e:
+        print("Erreur dans /segment :", str(e))
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v1_app.py

@@ -0,0 +1,62 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        if 'image' not in request.files:
+            return "Aucun fichier sélectionné", 400
+        file = request.files['image']
+        if file.filename == '':
+            return "Nom de fichier vide", 400
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        # Passer le nom du fichier au template pour affichage
+        return render_template('index.html', uploaded_image=filename)
+    return render_template('index.html')
+
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v2_app.py

@@ -0,0 +1,111 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        if 'image' not in request.files:
+            return "Aucun fichier sélectionné", 400
+        file = request.files['image']
+        if file.filename == '':
+            return "Nom de fichier vide", 400
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        # Passer le nom du fichier au template pour affichage
+        return render_template('index.html', uploaded_image=filename)
+    return render_template('index.html')
+
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    """Endpoint pour segmenter une image et sauvegarder les annotations."""
+    data = request.json
+    image_name = data.get('image_name')
+    points = data.get('points')
+
+    if not image_name or not points:
+        return jsonify({'success': False, 'error': 'Données manquantes'}), 400
+
+    image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+    if not os.path.exists(image_path):
+        return jsonify({'success': False, 'error': 'Image non trouvée'}), 404
+
+    # Charger l'image
+    image = cv2.imread(image_path)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image_rgb)
+
+    # Annoter l'image avec les masques et les classes
+    annotated_image = image.copy()
+    for point in points:
+        x, y = point['x'], point['y']
+        class_name = point['class']
+        input_points = np.array([[x, y]])
+        input_labels = np.array([1])
+        masks, _, _ = predictor.predict(
+            point_coords=input_points,
+            point_labels=input_labels,
+            multimask_output=False
+        )
+        mask = masks[0]
+        mask_image = (mask * 255).astype(np.uint8)
+
+        # Superposer le masque à l'image
+        color = (0, 255, 0)  # Couleur verte pour les masques
+        annotated_image[mask > 0] = color
+
+        # Ajouter le texte de la classe
+        cv2.putText(annotated_image, class_name, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+
+    # Sauvegarder l'image annotée
+    annotated_path = os.path.join(app.config['UPLOAD_FOLDER'], f"annotated_{image_name}")
+    cv2.imwrite(annotated_path, annotated_image)
+
+    return jsonify({'success': True, 'annotated_image': f"annotated_{image_name}"})
+
+
+
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v3_app.py

@@ -0,0 +1,113 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        if 'image' not in request.files:
+            return "Aucun fichier sélectionné", 400
+        file = request.files['image']
+        if file.filename == '':
+            return "Nom de fichier vide", 400
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        # Passer le nom du fichier au template pour affichage
+        return render_template('index.html', uploaded_image=filename)
+    return render_template('index.html')
+
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    """Endpoint pour segmenter une image et sauvegarder les annotations."""
+    try:
+        data = request.get_json()
+        image_name = data.get('image_name')
+        points = data.get('points')
+
+        if not image_name or not points:
+            return jsonify({'success': False, 'error': 'Données manquantes'}), 400
+
+        image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+        if not os.path.exists(image_path):
+            return jsonify({'success': False, 'error': 'Image non trouvée'}), 404
+
+        # Charger l'image
+        image = cv2.imread(image_path)
+        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        predictor.set_image(image_rgb)
+
+        # Annoter l'image avec les masques et les classes
+        annotated_image = image.copy()
+        for point in points:
+            x, y = point['x'], point['y']
+            class_name = point.get('class', 'Unknown')
+            input_points = np.array([[x, y]])
+            input_labels = np.array([1])
+            masks, _, _ = predictor.predict(
+                point_coords=input_points,
+                point_labels=input_labels,
+                multimask_output=False
+            )
+            mask = masks[0]
+            mask_image = (mask * 255).astype(np.uint8)
+
+            # Superposer le masque à l'image
+            color = (0, 255, 0)  # Couleur verte pour les masques
+            annotated_image[mask > 0] = color
+
+            # Ajouter le texte de la classe
+            cv2.putText(annotated_image, class_name, (int(x), int(y)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)
+
+        # Sauvegarder l'image annotée
+        annotated_path = os.path.join(app.config['UPLOAD_FOLDER'], f"annotated_{image_name}")
+        cv2.imwrite(annotated_path, annotated_image)
+
+        return jsonify({'success': True, 'annotated_image': f"annotated_{image_name}"})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v4_app.py

@@ -0,0 +1,99 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+# Fonction pour générer une couleur unique pour chaque classe
+def get_color_for_class(class_name):
+    np.random.seed(hash(class_name) % (2**32))
+    return tuple(np.random.randint(0, 256, size=3).tolist())
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        file = request.files.get('image')
+        if not file or not file.filename:
+            return "Aucun fichier sélectionné", 400
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        return render_template('index.html', uploaded_image=filename)
+    return render_template('index.html')
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    data = request.get_json()
+    image_name = data.get('image_name')
+    points = data.get('points')
+
+    if not image_name or not points:
+        return jsonify({'success': False, 'error': 'Données manquantes'}), 400
+
+    image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+    if not os.path.exists(image_path):
+        return jsonify({'success': False, 'error': 'Image non trouvée'}), 404
+
+    # Charger l'image et effectuer la segmentation
+    image = cv2.imread(image_path)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image_rgb)
+    annotated_image = image.copy()
+
+    for point in points:
+        x, y = point['x'], point['y']
+        class_name = point.get('class', 'Unknown')
+        color = get_color_for_class(class_name)  # Couleur unique pour chaque classe
+        masks, _, _ = predictor.predict(
+            point_coords=np.array([[x, y]]),
+            point_labels=np.array([1]),
+            multimask_output=False
+        )
+        annotated_image[masks[0] > 0] = color  # Superposer le masque avec la couleur
+        cv2.putText(annotated_image, class_name, (int(x), int(y)),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)  # Texte blanc
+
+    # Sauvegarder et renvoyer l'image annotée
+    annotated_filename = f"annotated_{image_name}"
+    annotated_path = os.path.join(app.config['UPLOAD_FOLDER'], annotated_filename)
+    cv2.imwrite(annotated_path, annotated_image)
+    return jsonify({'success': True, 'annotated_image': f"uploads/{annotated_filename}"})
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v5_app.py

@@ -0,0 +1,154 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+# Fonction pour générer une couleur unique pour chaque classe
+def get_color_for_class(class_name):
+    np.random.seed(hash(class_name) % (2**32))
+    return tuple(np.random.randint(0, 256, size=3).tolist())
+
+# Convertir un masque en bounding box au format YOLOv5
+def mask_to_yolo_bbox(mask):
+    y_indices, x_indices = np.where(mask > 0)
+    if len(x_indices) == 0 or len(y_indices) == 0:
+        return None
+    x_min, x_max = x_indices.min(), x_indices.max()
+    y_min, y_max = y_indices.min(), y_indices.max()
+
+    # YOLOv5 format: x_center, y_center, width, height (normalized)
+    x_center = (x_min + x_max) / 2
+    y_center = (y_min + y_max) / 2
+    width = x_max - x_min
+    height = y_max - y_min
+
+    return x_center, y_center, width, height
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        file = request.files.get('image')
+        if not file or not file.filename:
+            return "Aucun fichier sélectionné", 400
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        return render_template('index.html', uploaded_image=filename)
+    return render_template('index.html')
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    data = request.get_json()
+    image_name = data.get('image_name')
+    points = data.get('points')
+
+    if not image_name or not points:
+        return jsonify({'success': False, 'error': 'Données manquantes'}), 400
+
+    image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+    if not os.path.exists(image_path):
+        return jsonify({'success': False, 'error': 'Image non trouvée'}), 404
+
+    # Créer un dossier pour sauvegarder les résultats
+    output_dir = os.path.join(app.config['UPLOAD_FOLDER'], os.path.splitext(image_name)[0])
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Charger l'image et effectuer la segmentation
+    image = cv2.imread(image_path)
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    predictor.set_image(image_rgb)
+    annotated_image = image.copy()
+
+    # YOLOv5 annotation
+    yolo_annotations = []
+
+    for point in points:
+        x, y = point['x'], point['y']
+        class_name = point.get('class', 'Unknown')
+        class_id = hash(class_name) % 1000  # Générer un ID unique basé sur le nom
+        color = get_color_for_class(class_name)  # Couleur unique pour chaque classe
+        masks, _, _ = predictor.predict(
+            point_coords=np.array([[x, y]]),
+            point_labels=np.array([1]),
+            multimask_output=False
+        )
+        mask = masks[0]
+        annotated_image[mask > 0] = color  # Superposer le masque avec la couleur
+
+        # Convertir le masque en bounding box YOLOv5
+        bbox = mask_to_yolo_bbox(mask)
+        if bbox:
+            x_center, y_center, width, height = bbox
+            # Normaliser les valeurs
+            x_center /= image.shape[1]
+            y_center /= image.shape[0]
+            width /= image.shape[1]
+            height /= image.shape[0]
+            yolo_annotations.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+        # Ajouter le texte de la classe
+        cv2.putText(annotated_image, class_name, (int(x), int(y)),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)  # Texte blanc
+
+    # Sauvegarder les résultats
+        annotated_filename = f"annotated_{image_name}"
+        annotated_path = os.path.join(output_dir, annotated_filename)
+        cv2.imwrite(annotated_path, annotated_image)
+
+        # Sauvegarder les annotations YOLOv5
+        yolo_path = os.path.join(output_dir, f"{os.path.splitext(image_name)[0]}.txt")
+        with open(yolo_path, "w") as f:
+            f.write("\n".join(yolo_annotations))
+
+        # Copier l'image originale dans le dossier
+        original_copy_path = os.path.join(output_dir, image_name)
+        if not os.path.exists(original_copy_path):
+            os.rename(image_path, original_copy_path)
+
+        # Renvoyer le chemin relatif pour affichage
+        relative_output_dir = output_dir.replace("static/", "")
+        return jsonify({
+            'success': True,
+            'output_dir': relative_output_dir,
+            'annotated_image': f"{relative_output_dir}/{annotated_filename}"
+        })
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v6_app.py

@@ -0,0 +1,169 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+import json
+
+# Initialisation de Flask
+app = Flask(
+    __name__,
+    template_folder='templates',
+    static_folder='static'
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+# Fonction pour générer une couleur unique pour chaque classe
+def get_color_for_class(class_name):
+    np.random.seed(hash(class_name) % (2**32))
+    return tuple(np.random.randint(0, 256, size=3).tolist())
+
+# Convertir un masque en bounding box au format YOLOv5
+def mask_to_yolo_bbox(mask):
+    y_indices, x_indices = np.where(mask > 0)
+    if len(x_indices) == 0 or len(y_indices) == 0:
+        return None
+    x_min, x_max = x_indices.min(), x_indices.max()
+    y_min, y_max = y_indices.min(), y_indices.max()
+
+    # YOLOv5 format: x_center, y_center, width, height (normalized)
+    x_center = (x_min + x_max) / 2
+    y_center = (y_min + y_max) / 2
+    width = x_max - x_min
+    height = y_max - y_min
+
+    return x_center, y_center, width, height
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    if request.method == 'POST':
+        files = request.files.getlist('images')  # Get multiple files
+        if not files:
+            return "Aucun fichier sélectionné", 400
+
+        filenames = []
+        for file in files:
+            filename = secure_filename(file.filename)
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(filepath)
+            filenames.append(filename)
+
+        return render_template('index.html', uploaded_images=filenames, all_annotated=False)
+
+    # Pour l'affichage des images déjà téléchargées
+    uploaded_images = os.listdir(app.config['UPLOAD_FOLDER'])
+    return render_template('index.html', uploaded_images=uploaded_images, all_annotated=False)
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    data = request.get_json()
+    print("Données reçues :", data)  # Log pour vérifier les données envoyées par le frontend
+
+    image_names = data.get('image_names')
+    points = data.get('points')
+
+    if not image_names or not points:
+        return jsonify({'success': False, 'error': 'Données manquantes'}), 400
+
+    output = []
+    for image_name in image_names:
+        image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+        if not os.path.exists(image_path):
+            return jsonify({'success': False, 'error': f'Image {image_name} non trouvée'}), 404
+
+        # Créer un dossier pour sauvegarder les résultats
+        output_dir = os.path.join(app.config['UPLOAD_FOLDER'], os.path.splitext(image_name)[0])
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Charger l'image et effectuer la segmentation
+        image = cv2.imread(image_path)
+        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        predictor.set_image(image_rgb)
+        annotated_image = image.copy()
+
+        # YOLOv5 annotation
+        yolo_annotations = []
+
+        for point in points:
+            x, y = point['x'], point['y']
+            class_name = point.get('class', 'Unknown')
+            class_id = hash(class_name) % 1000  # Générer un ID unique basé sur le nom
+            color = get_color_for_class(class_name)  # Couleur unique pour chaque classe
+            masks, _, _ = predictor.predict(
+                point_coords=np.array([[x, y]]),
+                point_labels=np.array([1]),
+                multimask_output=False
+            )
+            mask = masks[0]
+            annotated_image[mask > 0] = color  # Superposer le masque avec la couleur
+
+            # Convertir le masque en bounding box YOLOv5
+            bbox = mask_to_yolo_bbox(mask)
+            if bbox:
+                x_center, y_center, width, height = bbox
+                # Normaliser les valeurs
+                x_center /= image.shape[1]
+                y_center /= image.shape[0]
+                width /= image.shape[1]
+                height /= image.shape[0]
+                yolo_annotations.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+            # Ajouter le texte de la classe
+            cv2.putText(annotated_image, class_name, (int(x), int(y)),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)  # Texte blanc
+
+        # Sauvegarder les résultats
+        annotated_filename = f"annotated_{image_name}"
+        annotated_path = os.path.join(output_dir, annotated_filename)
+        cv2.imwrite(annotated_path, annotated_image)
+
+        # Sauvegarder les annotations YOLOv5
+        yolo_path = os.path.join(output_dir, f"{os.path.splitext(image_name)[0]}.txt")
+        with open(yolo_path, "w") as f:
+            f.write("\n".join(yolo_annotations))
+
+        # Copier l'image originale dans le dossier
+        original_copy_path = os.path.join(output_dir, image_name)
+        if not os.path.exists(original_copy_path):
+            os.rename(image_path, original_copy_path)
+
+        # Renvoyer le chemin relatif pour affichage
+        relative_output_dir = output_dir.replace("static/", "")
+        output.append({
+            'success': True,
+            'image': f"{relative_output_dir}/{annotated_filename}",
+            'yolo_annotations': f"{relative_output_dir}/{os.path.splitext(image_name)[0]}.txt"
+        })
+
+    return jsonify(output)
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

app_version/v7_multi_segmentaion.py

@@ -0,0 +1,169 @@
+from flask import Flask, request, render_template, jsonify, send_from_directory,url_for
+import os
+import torch
+import numpy as np
+import cv2
+from segment_anything import sam_model_registry, SamPredictor
+from werkzeug.utils import secure_filename
+import warnings
+
+app = Flask(
+    __name__,
+    template_folder='templates',  # Chemin des fichiers HTML
+    static_folder='static'       # Chemin des fichiers statiques
+)
+app.config['UPLOAD_FOLDER'] = os.path.join('static', 'uploads')
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+# Charger le modèle SAM
+MODEL_TYPE = "vit_b"
+MODEL_PATH = os.path.join('models', 'sam_vit_b_01ec64.pth')
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+print("Chargement du modèle SAM...")
+try:
+    state_dict = torch.load(MODEL_PATH, map_location="cpu", weights_only=True)
+except TypeError:
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=UserWarning)
+        state_dict = torch.load(MODEL_PATH, map_location="cpu")
+
+# Initialiser et charger le modèle
+sam = sam_model_registry[MODEL_TYPE]()
+sam.load_state_dict(state_dict, strict=False)
+sam.to(device=device)
+predictor = SamPredictor(sam)
+print("Modèle SAM chargé avec succès!")
+
+# Générer une couleur unique pour chaque classe
+# Fonction pour générer une couleur unique pour chaque classe
+def get_color_for_class(class_name):
+    np.random.seed(hash(class_name) % (2**32))
+    return tuple(np.random.randint(0, 256, size=3).tolist())
+
+# Convertir un masque en bounding box au format YOLOv5
+def mask_to_yolo_bbox(mask):
+    y_indices, x_indices = np.where(mask > 0)
+    if len(x_indices) == 0 or len(y_indices) == 0:
+        return None
+    x_min, x_max = x_indices.min(), x_indices.max()
+    y_min, y_max = y_indices.min(), y_indices.max()
+    x_center = (x_min + x_max) / 2
+    y_center = (y_min + y_max) / 2
+    width = x_max - x_min
+    height = y_max - y_min
+    return x_center, y_center, width, height
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    """Page principale pour télécharger et afficher les images."""
+    if request.method == 'POST':
+        files = request.files.getlist('images')
+        if not files:
+            return "Aucun fichier sélectionné", 400
+
+        filenames = []
+        for file in files:
+            filename = secure_filename(file.filename)
+            filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(filepath)
+            filenames.append(filename)
+
+        return render_template('index.html', uploaded_images=filenames)
+
+    uploaded_images = os.listdir(app.config['UPLOAD_FOLDER'])
+    return render_template('index.html', uploaded_images=uploaded_images)
+
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    """Servir les fichiers uploadés."""
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+
+@app.route('/segment', methods=['POST'])
+def segment():
+    """Endpoint pour effectuer la segmentation des images."""
+    try:
+        data = request.get_json()
+        print("Données reçues :", data)
+
+        if not isinstance(data, list):
+            return jsonify({'success': False, 'error': 'Format incorrect : liste attendue'}), 400
+
+        output = []
+
+        for item in data:
+            image_name = item.get('image_name')
+            points = item.get('points', [])
+
+            if not image_name or not points:
+                return jsonify({'success': False, 'error': f"Données manquantes pour l'image {image_name}"}), 400
+
+            image_path = os.path.join(app.config['UPLOAD_FOLDER'], image_name)
+            if not os.path.exists(image_path):
+                return jsonify({'success': False, 'error': f"Image {image_name} non trouvée"}), 404
+
+            # Charger l'image
+            image = cv2.imread(image_path)
+            if image is None:
+                return jsonify({'success': False, 'error': f"Impossible de charger l'image {image_name}"}), 400
+
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            predictor.set_image(image_rgb)
+            annotated_image = image.copy()
+            yolo_annotations = []
+
+            for point in points:
+                x, y = point['x'], point['y']
+                class_name = point.get('class', 'Unknown')
+                color = get_color_for_class(class_name)
+
+                try:
+                    masks, _, _ = predictor.predict(
+                        point_coords=np.array([[x, y]]),
+                        point_labels=np.array([1]),
+                        multimask_output=False
+                    )
+                    mask = masks[0]
+                    annotated_image[mask > 0] = color
+
+                    # Convertir le masque en bounding box YOLOv5
+                    bbox = mask_to_yolo_bbox(mask)
+                    if bbox:
+                        x_center, y_center, width, height = bbox
+                        x_center /= image.shape[1]
+                        y_center /= image.shape[0]
+                        width /= image.shape[1]
+                        height /= image.shape[0]
+                        yolo_annotations.append(f"{class_name} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
+
+                except Exception as e:
+                    print(f"Erreur de segmentation pour le point {point} : {e}")
+
+            # Sauvegarder les résultats
+            output_dir = os.path.join(app.config['UPLOAD_FOLDER'], os.path.splitext(image_name)[0])
+            os.makedirs(output_dir, exist_ok=True)
+            annotated_path = os.path.join(output_dir, f"annotated_{image_name}")
+            cv2.imwrite(annotated_path, annotated_image)
+
+            yolo_path = os.path.join(output_dir, f"{os.path.splitext(image_name)[0]}.txt")
+            with open(yolo_path, "w") as f:
+                f.write("\n".join(yolo_annotations))
+            
+            new_image_path = os.path.join(output_dir, image_name)
+            if not os.path.exists(new_image_path):
+                os.rename(image_path, new_image_path)
+
+            output.append({
+                'image_name': image_name,
+                'annotated_image': url_for('static', filename=f"uploads/{os.path.splitext(image_name)[0]}/annotated_{image_name}"),
+                'yolo_annotations': url_for('static', filename=f"uploads/{os.path.splitext(image_name)[0]}/{os.path.splitext(image_name)[0]}.txt")
+            })
+
+        return jsonify({'success': True, 'results': output})
+
+    except Exception as e:
+        print("Erreur dans /segment :", str(e))
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

convert_label.py

@@ -0,0 +1,75 @@
+import os
+
+def convert_labels_in_place(input_dir, class_mapping):
+    """
+    Convertit les fichiers de labels en format YOLOv5 directement dans les fichiers originaux.
+
+    Args:
+        input_dir (str): Répertoire contenant les fichiers de labels à convertir.
+        class_mapping (dict): Dictionnaire {nom_classe: index}.
+    """
+    for file_name in os.listdir(input_dir):
+        if not file_name.endswith(".txt"):
+            continue
+
+        input_path = os.path.join(input_dir, file_name)
+        temp_path = input_path + ".temp"  # Fichier temporaire pour éviter d'écraser immédiatement
+
+        with open(input_path, "r") as infile, open(temp_path, "w") as tempfile:
+            for line in infile:
+                parts = line.split()
+                # Vérifier que la ligne a au moins 10 éléments
+                if len(parts) < 10:
+                    print(f"Skipping invalid line in {file_name}: {line.strip()}")
+                    continue
+
+                try:
+                    # Extraire les sommets du polygone
+                    x1, y1 = float(parts[0]), float(parts[1])
+                    x2, y2 = float(parts[2]), float(parts[3])
+                    x3, y3 = float(parts[4]), float(parts[5])
+                    x4, y4 = float(parts[6]), float(parts[7])
+
+                    # Calculer les coordonnées de la bounding box
+                    x_min = min(x1, x2, x3, x4)
+                    y_min = min(y1, y2, y3, y4)
+                    x_max = max(x1, x2, x3, x4)
+                    y_max = max(y1, y2, y3, y4)
+
+                    # Calculer x_center, y_center, width, height normalisés
+                    img_width, img_height = 640, 640  # Assurez-vous que cette taille est correcte
+                    x_center = ((x_min + x_max) / 2) / img_width
+                    y_center = ((y_min + y_max) / 2) / img_height
+                    width = (x_max - x_min) / img_width
+                    height = (y_max - y_min) / img_height
+
+                    # Convertir le nom de classe en indice
+                    class_name = parts[8]
+                    if class_name not in class_mapping:
+                        print(f"Classe inconnue dans {file_name}: {class_name}")
+                        continue
+
+                    class_id = class_mapping[class_name]
+
+                    # Écrire la ligne convertie dans le fichier temporaire
+                    tempfile.write(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")
+                except ValueError as e:
+                    print(f"Erreur de conversion dans {file_name}: {line.strip()} | Erreur : {e}")
+                    continue
+
+        # Remplacer le fichier original par le fichier temporaire
+        os.replace(temp_path, input_path)
+        print(f"Converti : {input_path}")
+
+
+# Mapping des noms de classes aux indices
+class_mapping = {
+    "component": 0,
+    "void": 1
+}
+
+# Répertoire des fichiers de labels
+input_dir = "labelid_image/valid/labels"
+
+# Conversion des labels directement dans les fichiers originaux
+convert_labels_in_place(input_dir, class_mapping)

download_lodel_yolo.py

@@ -0,0 +1,21 @@
+from huggingface_hub import hf_hub_download
+import os
+
+def download_yolo_model(repo_id="keizer77/samyolo2", filename="best.pt", output_dir="models"):
+    """
+    Télécharge un modèle YOLOv5 depuis Hugging Face.
+    """
+    os.makedirs(output_dir, exist_ok=True)  # Créez le dossier si nécessaire
+
+    print(f"Téléchargement du modèle {filename} depuis le dépôt {repo_id}...")
+    model_path = hf_hub_download(repo_id=repo_id, filename=filename, cache_dir=output_dir)
+    print(f"Modèle téléchargé et sauvegardé dans : {model_path}")
+    return model_path
+
+if __name__ == "__main__":
+    # Exemple d'utilisation
+    try:
+        downloaded_model_path = download_yolo_model()
+        print(f"Modèle prêt à être utilisé : {downloaded_model_path}")
+    except Exception as e:
+        print(f"Erreur lors du téléchargement du modèle : {e}")

download_model_sam.py

@@ -0,0 +1,18 @@
+import os
+import requests
+
+# Créer le dossier cible s'il n'existe pas
+os.makedirs("models", exist_ok=True)
+
+# URL du modèle et chemin de destination
+url = "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth"
+output_path = "models/sam_vit_b_01ec64.pth"
+
+# Téléchargement
+print("Téléchargement du modèle...")
+response = requests.get(url, stream=True)
+with open(output_path, "wb") as f:
+    for chunk in response.iter_content(chunk_size=8192):
+        f.write(chunk)
+
+print("Téléchargement terminé ! Modèle sauvegardé dans :", output_path)

filestructure.txt

@@ -0,0 +1,517 @@
+|-- .env
+|-- app.py
+|-- app_version
+    |-- v1_app.py
+    |-- v2_app.py
+    |-- v3_app.py
+    |-- v4_app.py
+    |-- v5_app.py
+    |-- v6_app.py
+    |-- v7_multi_segmentaion.py
+|-- convert_label.py
+|-- download_lodel_yolo.py
+|-- download_model_sam.py
+|-- idea
+    |-- auto training.py
+|-- labelid_image
+    |-- data.yaml
+    |-- README.dataset.txt
+    |-- README.roboflow.txt
+    |-- test
+        |-- images
+            |-- 17_jpg.rf.bffd529c5bf4033da45bac4266570627.jpg
+            |-- 19_jpg.rf.d87571c6606039070d1f4d1ef6670a36.jpg
+            |-- 32_jpg.rf.17cfc81f24a609daff2ee0d7f9c403ea.jpg
+            |-- normal-reflow_jpg.rf.0bc1cd422852f197d37487cab35277de.jpg
+            |-- techtips_31_jpg.rf.cbc3a3c054285bbc91389e7b9944e0f1.jpg
+        |-- labels
+            |-- 17_jpg.rf.bffd529c5bf4033da45bac4266570627.txt
+            |-- 19_jpg.rf.d87571c6606039070d1f4d1ef6670a36.txt
+            |-- 32_jpg.rf.17cfc81f24a609daff2ee0d7f9c403ea.txt
+            |-- normal-reflow_jpg.rf.0bc1cd422852f197d37487cab35277de.txt
+            |-- techtips_31_jpg.rf.cbc3a3c054285bbc91389e7b9944e0f1.txt
+    |-- train
+        |-- images
+            |-- 02_JPG_jpg.rf.46475e2af0b81494f535407dca8a90df.jpg
+            |-- 02_JPG_jpg.rf.607f51fe5af261b2c6e1dcfdff8807dc.jpg
+            |-- 02_JPG_jpg.rf.ba454d33d656fe844e51c117639d3925.jpg
+            |-- 03_JPG_jpg.rf.3d664335f4575e8fa835d0e1b95ecd4a.jpg
+            |-- 03_JPG_jpg.rf.c1c14f4372dea6bb8c4812c6bc6b7748.jpg
+            |-- 03_JPG_jpg.rf.dce6c58b1c141a11eaa0ba797a39b8a0.jpg
+            |-- 04_JPG_jpg.rf.228ed8ab0bdabf748d31b6cf538e679a.jpg
+            |-- 04_JPG_jpg.rf.820d285cdb23efd232dcdcc2ddc19d0b.jpg
+            |-- 04_JPG_jpg.rf.8d252968125f0d1dcac7a227d9e81a14.jpg
+            |-- 05_jpg.rf.6f0497dc70803ad97f4fd7237ace269d.jpg
+            |-- 05_jpg.rf.a79bf109741928d7f0ec5c6ee1f60072.jpg
+            |-- 05_jpg.rf.b4b0f5581dc62bfd0eccf71f319a9426.jpg
+            |-- 08_JPG_jpg.rf.4af8990adfea52c23f0ee3b14626c289.jpg
+            |-- 08_JPG_jpg.rf.5ffca502a77dd15a24aeaa7cbf4bf419.jpg
+            |-- 08_JPG_jpg.rf.aa7636f8942d951b261a991e42c97abc.jpg
+            |-- 09_JPG_jpg.rf.1107a2106d3668730d997bc2f82e108c.jpg
+            |-- 09_JPG_jpg.rf.73bae9724ed4b99db8e4bd1416b5db79.jpg
+            |-- 09_JPG_jpg.rf.e3e36389aff5a943291dd5451fb13faf.jpg
+            |-- 10_JPG_jpg.rf.2692f3e373299579213dd91139305bf7.jpg
+            |-- 10_JPG_jpg.rf.79f0d2c21f3bdc9327961b56b6e63f0b.jpg
+            |-- 10_JPG_jpg.rf.ad9b4018e10df1f0f75945f983b447e3.jpg
+            |-- 11_JPG_jpg.rf.77790fe84eafc0d7f2af5c55620b236c.jpg
+            |-- 11_JPG_jpg.rf.9f16d7f9c3d7161a3e3cdd1cd31ff9dd.jpg
+            |-- 11_JPG_jpg.rf.c973e51ebd3c9138adf67aaa774cc3d1.jpg
+            |-- 12_jpg.rf.7327ab6b3de3aae49dca43ffa34b44eb.jpg
+            |-- 12_jpg.rf.cc6a06dd9d8d8c92b72b0200c8de9abd.jpg
+            |-- 12_jpg.rf.fdc79e50721cf51af7567ee329ef41b8.jpg
+            |-- 14_jpg.rf.34999d604ae615c91d3d902c6398b353.jpg
+            |-- 14_jpg.rf.4b37ab1bcc3adf9434a65cc6e8b1aa71.jpg
+            |-- 14_jpg.rf.c009a995ccc6605b6437fca4fef54b41.jpg
+            |-- 15r_jpg.rf.77fc1c57937c9f3671a76200321173c3.jpg
+            |-- 15r_jpg.rf.b7ad8e525ddc94abe50382d6d2001879.jpg
+            |-- 15r_jpg.rf.ebf6187721b3ccc403cd92708b213aad.jpg
+            |-- 15_jpg.rf.50a38ce8f7212ff40bc6462c54b4211d.jpg
+            |-- 15_jpg.rf.669e667f658e1652774eba6f02dfa5f2.jpg
+            |-- 15_jpg.rf.9553dee235f52bf9972979d2ecfa4b71.jpg
+            |-- 16_jpg.rf.448dc56101375a0f4f7dbbdfc6dfd6a8.jpg
+            |-- 16_jpg.rf.54131510d29bf7a96ac9a80096cc1709.jpg
+            |-- 16_jpg.rf.68e880a57b02225fb70f820fdd4e2e3f.jpg
+            |-- 18_jpg.rf.79ed74b38cded1cc737cc76593904f19.jpg
+            |-- 18_jpg.rf.a353c435e23b700c5762ab3c43a3b7b5.jpg
+            |-- 18_jpg.rf.d62c259c631f16821b9f18885bb6c3f2.jpg
+            |-- 20_jpg.rf.309c1e9931e0284a6eab07d703200db3.jpg
+            |-- 20_jpg.rf.be67670f261f896bcfa20a004664ea00.jpg
+            |-- 20_jpg.rf.e41773cdfef39afe830d48c80e7b9904.jpg
+            |-- 21_jpg.rf.027aced6583517fa7ab88f60cb721364.jpg
+            |-- 21_jpg.rf.6d6f283a384fd79667a128309a8504f7.jpg
+            |-- 21_jpg.rf.a9fdcbfb74638d7a07b66f21bd4346e7.jpg
+            |-- 22_jpg.rf.8636f2782cb04acd648403e779377f8e.jpg
+            |-- 22_jpg.rf.abe76c6faa4884e53e31a29197950769.jpg
+            |-- 22_jpg.rf.f0e7fef41d3d403c9c79875382262f74.jpg
+            |-- 25_jpg.rf.8484926dfad59e541b0ef2ae6784fcc8.jpg
+            |-- 25_jpg.rf.8fc6793b7c7195393a7a47447418f1ff.jpg
+            |-- 25_jpg.rf.cfdbc9ad0c5de9e42808c493e4dbea6f.jpg
+            |-- 26_jpg.rf.49f85c4d0d03d1d25be3c0e9ea0b251f.jpg
+            |-- 26_jpg.rf.8ce3aced6387343f0a9ab1d6250aecca.jpg
+            |-- 26_jpg.rf.df215b109ee20ef6618e41cc1f97d45a.jpg
+            |-- 29_jpg.rf.4898bea8a08db8612de89ab7d6b6c2fc.jpg
+            |-- 29_jpg.rf.5c441fbdbd06613382c8f780cde68cc8.jpg
+            |-- 29_jpg.rf.86abde10c2569ee60d13bf10a1f3752e.jpg
+            |-- 31_jpg.rf.52ca7660b43fc02e73d8687125d4fcde.jpg
+            |-- 31_jpg.rf.57070e9b0ffc517e0fff77f5b80c30ca.jpg
+            |-- 31_jpg.rf.792707571b6921b2141e8ab4fa84d736.jpg
+            |-- 7-Figure14-1_jpg.rf.63850a94a9f5642c721b088ed199d784.jpg
+            |-- 7-Figure14-1_jpg.rf.a1ac2d25ae90b3bad946773d77f8e216.jpg
+            |-- 7-Figure14-1_jpg.rf.d26136f007fc7c28647325a3cea8d763.jpg
+            |-- gc10_lake_voids_260-31_jpg.rf.35b70d42805f4eea091131a18e700121.jpg
+            |-- gc10_lake_voids_260-31_jpg.rf.55f5665abb89d3fae508e9d083d39c4a.jpg
+            |-- gc10_lake_voids_260-31_jpg.rf.73b30aed15e43196c52468d4b21f832f.jpg
+            |-- images_jpg.rf.059d5258ab915be973e1d87cdc0088d5.jpg
+            |-- images_jpg.rf.50f23ee8fafc1907c6400e5d9b897bc9.jpg
+            |-- images_jpg.rf.542b8e12e80348293e377385efb2766a.jpg
+            |-- LU-F_mod_jpg.rf.3c78583335c231eaf94d6381f2be6334.jpg
+            |-- LU-F_mod_jpg.rf.8e64fdb5f210effde8da288fa66f885c.jpg
+            |-- LU-F_mod_jpg.rf.beaff19f7c32f6ae36c17b66556eba6c.jpg
+            |-- qfn-voiding_0_jpg.rf.9feb6ba12734821030795e5a32bf0fe4.jpg
+            |-- qfn-voiding_0_jpg.rf.df9bf150f8a30becc2d7905db5a21ffb.jpg
+            |-- qfn-voiding_0_jpg.rf.fa13b031eddf08b3f80681a719d5d522.jpg
+            |-- Solder_Voids_jpg.rf.c7ff029524960bb21ad7c54c3699812d.jpg
+            |-- Solder_Voids_jpg.rf.d169656b8d049bb6257228e28afe7e45.jpg
+            |-- Solder_Voids_jpg.rf.f90508c3dcfae8bf2491a8eb1b15bb3a.jpg
+            |-- techtips_3_jpg.rf.5fa851d765dc5d0f7f599ba8d301a1bf.jpg
+            |-- techtips_3_jpg.rf.654255d42d56231a422190bbc0f5c5c1.jpg
+            |-- techtips_3_jpg.rf.875113b878fa23648c7a8c92ffe8c932.jpg
+        |-- labels
+            |-- 02_JPG_jpg.rf.46475e2af0b81494f535407dca8a90df.txt
+            |-- 02_JPG_jpg.rf.607f51fe5af261b2c6e1dcfdff8807dc.txt
+            |-- 02_JPG_jpg.rf.ba454d33d656fe844e51c117639d3925.txt
+            |-- 03_JPG_jpg.rf.3d664335f4575e8fa835d0e1b95ecd4a.txt
+            |-- 03_JPG_jpg.rf.c1c14f4372dea6bb8c4812c6bc6b7748.txt
+            |-- 03_JPG_jpg.rf.dce6c58b1c141a11eaa0ba797a39b8a0.txt
+            |-- 04_JPG_jpg.rf.228ed8ab0bdabf748d31b6cf538e679a.txt
+            |-- 04_JPG_jpg.rf.820d285cdb23efd232dcdcc2ddc19d0b.txt
+            |-- 04_JPG_jpg.rf.8d252968125f0d1dcac7a227d9e81a14.txt
+            |-- 05_jpg.rf.6f0497dc70803ad97f4fd7237ace269d.txt
+            |-- 05_jpg.rf.a79bf109741928d7f0ec5c6ee1f60072.txt
+            |-- 05_jpg.rf.b4b0f5581dc62bfd0eccf71f319a9426.txt
+            |-- 08_JPG_jpg.rf.4af8990adfea52c23f0ee3b14626c289.txt
+            |-- 08_JPG_jpg.rf.5ffca502a77dd15a24aeaa7cbf4bf419.txt
+            |-- 08_JPG_jpg.rf.aa7636f8942d951b261a991e42c97abc.txt
+            |-- 09_JPG_jpg.rf.1107a2106d3668730d997bc2f82e108c.txt
+            |-- 09_JPG_jpg.rf.73bae9724ed4b99db8e4bd1416b5db79.txt
+            |-- 09_JPG_jpg.rf.e3e36389aff5a943291dd5451fb13faf.txt
+            |-- 10_JPG_jpg.rf.2692f3e373299579213dd91139305bf7.txt
+            |-- 10_JPG_jpg.rf.79f0d2c21f3bdc9327961b56b6e63f0b.txt
+            |-- 10_JPG_jpg.rf.ad9b4018e10df1f0f75945f983b447e3.txt
+            |-- 11_JPG_jpg.rf.77790fe84eafc0d7f2af5c55620b236c.txt
+            |-- 11_JPG_jpg.rf.9f16d7f9c3d7161a3e3cdd1cd31ff9dd.txt
+            |-- 11_JPG_jpg.rf.c973e51ebd3c9138adf67aaa774cc3d1.txt
+            |-- 12_jpg.rf.7327ab6b3de3aae49dca43ffa34b44eb.txt
+            |-- 12_jpg.rf.cc6a06dd9d8d8c92b72b0200c8de9abd.txt
+            |-- 12_jpg.rf.fdc79e50721cf51af7567ee329ef41b8.txt
+            |-- 14_jpg.rf.34999d604ae615c91d3d902c6398b353.txt
+            |-- 14_jpg.rf.4b37ab1bcc3adf9434a65cc6e8b1aa71.txt
+            |-- 14_jpg.rf.c009a995ccc6605b6437fca4fef54b41.txt
+            |-- 15r_jpg.rf.77fc1c57937c9f3671a76200321173c3.txt
+            |-- 15r_jpg.rf.b7ad8e525ddc94abe50382d6d2001879.txt
+            |-- 15r_jpg.rf.ebf6187721b3ccc403cd92708b213aad.txt
+            |-- 15_jpg.rf.50a38ce8f7212ff40bc6462c54b4211d.txt
+            |-- 15_jpg.rf.669e667f658e1652774eba6f02dfa5f2.txt
+            |-- 15_jpg.rf.9553dee235f52bf9972979d2ecfa4b71.txt
+            |-- 16_jpg.rf.448dc56101375a0f4f7dbbdfc6dfd6a8.txt
+            |-- 16_jpg.rf.54131510d29bf7a96ac9a80096cc1709.txt
+            |-- 16_jpg.rf.68e880a57b02225fb70f820fdd4e2e3f.txt
+            |-- 18_jpg.rf.79ed74b38cded1cc737cc76593904f19.txt
+            |-- 18_jpg.rf.a353c435e23b700c5762ab3c43a3b7b5.txt
+            |-- 18_jpg.rf.d62c259c631f16821b9f18885bb6c3f2.txt
+            |-- 20_jpg.rf.309c1e9931e0284a6eab07d703200db3.txt
+            |-- 20_jpg.rf.be67670f261f896bcfa20a004664ea00.txt
+            |-- 20_jpg.rf.e41773cdfef39afe830d48c80e7b9904.txt
+            |-- 21_jpg.rf.027aced6583517fa7ab88f60cb721364.txt
+            |-- 21_jpg.rf.6d6f283a384fd79667a128309a8504f7.txt
+            |-- 21_jpg.rf.a9fdcbfb74638d7a07b66f21bd4346e7.txt
+            |-- 22_jpg.rf.8636f2782cb04acd648403e779377f8e.txt
+            |-- 22_jpg.rf.abe76c6faa4884e53e31a29197950769.txt
+            |-- 22_jpg.rf.f0e7fef41d3d403c9c79875382262f74.txt
+            |-- 25_jpg.rf.8484926dfad59e541b0ef2ae6784fcc8.txt
+            |-- 25_jpg.rf.8fc6793b7c7195393a7a47447418f1ff.txt
+            |-- 25_jpg.rf.cfdbc9ad0c5de9e42808c493e4dbea6f.txt
+            |-- 26_jpg.rf.49f85c4d0d03d1d25be3c0e9ea0b251f.txt
+            |-- 26_jpg.rf.8ce3aced6387343f0a9ab1d6250aecca.txt
+            |-- 26_jpg.rf.df215b109ee20ef6618e41cc1f97d45a.txt
+            |-- 29_jpg.rf.4898bea8a08db8612de89ab7d6b6c2fc.txt
+            |-- 29_jpg.rf.5c441fbdbd06613382c8f780cde68cc8.txt
+            |-- 29_jpg.rf.86abde10c2569ee60d13bf10a1f3752e.txt
+            |-- 31_jpg.rf.52ca7660b43fc02e73d8687125d4fcde.txt
+            |-- 31_jpg.rf.57070e9b0ffc517e0fff77f5b80c30ca.txt
+            |-- 31_jpg.rf.792707571b6921b2141e8ab4fa84d736.txt
+            |-- 7-Figure14-1_jpg.rf.63850a94a9f5642c721b088ed199d784.txt
+            |-- 7-Figure14-1_jpg.rf.a1ac2d25ae90b3bad946773d77f8e216.txt
+            |-- 7-Figure14-1_jpg.rf.d26136f007fc7c28647325a3cea8d763.txt
+            |-- gc10_lake_voids_260-31_jpg.rf.35b70d42805f4eea091131a18e700121.txt
+            |-- gc10_lake_voids_260-31_jpg.rf.55f5665abb89d3fae508e9d083d39c4a.txt
+            |-- gc10_lake_voids_260-31_jpg.rf.73b30aed15e43196c52468d4b21f832f.txt
+            |-- images_jpg.rf.059d5258ab915be973e1d87cdc0088d5.txt
+            |-- images_jpg.rf.50f23ee8fafc1907c6400e5d9b897bc9.txt
+            |-- images_jpg.rf.542b8e12e80348293e377385efb2766a.txt
+            |-- LU-F_mod_jpg.rf.3c78583335c231eaf94d6381f2be6334.txt
+            |-- LU-F_mod_jpg.rf.8e64fdb5f210effde8da288fa66f885c.txt
+            |-- LU-F_mod_jpg.rf.beaff19f7c32f6ae36c17b66556eba6c.txt
+            |-- qfn-voiding_0_jpg.rf.9feb6ba12734821030795e5a32bf0fe4.txt
+            |-- qfn-voiding_0_jpg.rf.df9bf150f8a30becc2d7905db5a21ffb.txt
+            |-- qfn-voiding_0_jpg.rf.fa13b031eddf08b3f80681a719d5d522.txt
+            |-- Solder_Voids_jpg.rf.c7ff029524960bb21ad7c54c3699812d.txt
+            |-- Solder_Voids_jpg.rf.d169656b8d049bb6257228e28afe7e45.txt
+            |-- Solder_Voids_jpg.rf.f90508c3dcfae8bf2491a8eb1b15bb3a.txt
+            |-- techtips_3_jpg.rf.5fa851d765dc5d0f7f599ba8d301a1bf.txt
+            |-- techtips_3_jpg.rf.654255d42d56231a422190bbc0f5c5c1.txt
+            |-- techtips_3_jpg.rf.875113b878fa23648c7a8c92ffe8c932.txt
+    |-- valid
+        |-- images
+            |-- 025_JPG_jpg.rf.d47dd8a24eec04a980085bb1fad81c1a.jpg
+            |-- 06_jpg.rf.ecf5de84954b61d29689eb0ce22c2044.jpg
+            |-- 07_JPG_jpg.rf.ccbbfdd3058e17eda2b2bcd0f0a46bc7.jpg
+            |-- 23_jpg.rf.1d1064aa64b455552f45fef20943bb89.jpg
+            |-- 24_jpg.rf.8aae72276db597edcc3464081d34670b.jpg
+            |-- 27_jpg.rf.999555b4b2a11b6c670968471381258f.jpg
+            |-- 28_jpg.rf.62e004c9a7670f016a0fb7f35a9c197a.jpg
+            |-- 30_jpg.rf.1f2e82377ba9f9219921b7a8d82f32cf.jpg
+        |-- labels
+            |-- 025_JPG_jpg.rf.d47dd8a24eec04a980085bb1fad81c1a.txt
+            |-- 06_jpg.rf.ecf5de84954b61d29689eb0ce22c2044.txt
+            |-- 07_JPG_jpg.rf.ccbbfdd3058e17eda2b2bcd0f0a46bc7.txt
+            |-- 23_jpg.rf.1d1064aa64b455552f45fef20943bb89.txt
+            |-- 24_jpg.rf.8aae72276db597edcc3464081d34670b.txt
+            |-- 27_jpg.rf.999555b4b2a11b6c670968471381258f.txt
+            |-- 28_jpg.rf.62e004c9a7670f016a0fb7f35a9c197a.txt
+            |-- 30_jpg.rf.1f2e82377ba9f9219921b7a8d82f32cf.txt
+|-- models
+    |-- .locks
+        |-- models--keizer77--samyolo2
+    |-- models--keizer77--samyolo2
+        |-- blobs
+        |-- refs
+            |-- main
+        |-- snapshots
+            |-- 74c8cb12ae448ff0b8bae9ef522b54ec09b47c20
+                |-- best.pt
+    |-- sam_vit_b_01ec64.pth
+|-- requirements.txt
+|-- static
+    |-- css
+        |-- styles.css
+    |-- uploads
+|-- templates
+    |-- index.html
+    |-- v1_index.html
+    |-- v3_index.html
+    |-- v4_index.html
+    |-- v5_index.html
+    |-- v6_index.py
+    |-- v7_multi_segmentation.html
+|-- weights
+    |-- custom_model
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model10
+        |-- hyp.yaml
+        |-- labels.jpg
+        |-- labels_correlogram.jpg
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model11
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model12
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model13
+        |-- hyp.yaml
+        |-- labels.jpg
+        |-- labels_correlogram.jpg
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model14
+        |-- hyp.yaml
+        |-- labels.jpg
+        |-- labels_correlogram.jpg
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model15
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model2
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model3
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model4
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model5
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model6
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model7
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model8
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+    |-- custom_model9
+        |-- hyp.yaml
+        |-- opt.yaml
+        |-- weights
+|-- yolov5
+    |-- .dockerignore
+    |-- .gitattributes
+    |-- .github
+        |-- dependabot.yml
+        |-- ISSUE_TEMPLATE
+            |-- bug-report.yml
+            |-- config.yml
+            |-- feature-request.yml
+            |-- question.yml
+        |-- workflows
+            |-- ci-testing.yml
+            |-- cla.yml
+            |-- codeql-analysis.yml
+            |-- docker.yml
+            |-- format.yml
+            |-- links.yml
+            |-- merge-main-into-prs.yml
+            |-- stale.yml
+    |-- .gitignore
+    |-- benchmarks.py
+    |-- CITATION.cff
+    |-- classify
+        |-- predict.py
+        |-- train.py
+        |-- tutorial.ipynb
+        |-- val.py
+    |-- CONTRIBUTING.md
+    |-- data
+        |-- Argoverse.yaml
+        |-- coco.yaml
+        |-- coco128-seg.yaml
+        |-- coco128.yaml
+        |-- GlobalWheat2020.yaml
+        |-- hyps
+            |-- hyp.no-augmentation.yaml
+            |-- hyp.Objects365.yaml
+            |-- hyp.scratch-high.yaml
+            |-- hyp.scratch-low.yaml
+            |-- hyp.scratch-med.yaml
+            |-- hyp.VOC.yaml
+        |-- ImageNet.yaml
+        |-- ImageNet10.yaml
+        |-- ImageNet100.yaml
+        |-- ImageNet1000.yaml
+        |-- images
+            |-- bus.jpg
+            |-- zidane.jpg
+        |-- Objects365.yaml
+        |-- scripts
+            |-- download_weights.sh
+            |-- get_coco.sh
+            |-- get_coco128.sh
+            |-- get_imagenet.sh
+            |-- get_imagenet10.sh
+            |-- get_imagenet100.sh
+            |-- get_imagenet1000.sh
+        |-- SKU-110K.yaml
+        |-- VisDrone.yaml
+        |-- VOC.yaml
+        |-- xView.yaml
+    |-- detect.py
+    |-- export.py
+    |-- hubconf.py
+    |-- LICENSE
+    |-- models
+        |-- common.py
+        |-- experimental.py
+        |-- hub
+            |-- anchors.yaml
+            |-- yolov3-spp.yaml
+            |-- yolov3-tiny.yaml
+            |-- yolov3.yaml
+            |-- yolov5-bifpn.yaml
+            |-- yolov5-fpn.yaml
+            |-- yolov5-p2.yaml
+            |-- yolov5-p34.yaml
+            |-- yolov5-p6.yaml
+            |-- yolov5-p7.yaml
+            |-- yolov5-panet.yaml
+            |-- yolov5l6.yaml
+            |-- yolov5m6.yaml
+            |-- yolov5n6.yaml
+            |-- yolov5s-ghost.yaml
+            |-- yolov5s-LeakyReLU.yaml
+            |-- yolov5s-transformer.yaml
+            |-- yolov5s6.yaml
+            |-- yolov5x6.yaml
+        |-- segment
+            |-- yolov5l-seg.yaml
+            |-- yolov5m-seg.yaml
+            |-- yolov5n-seg.yaml
+            |-- yolov5s-seg.yaml
+            |-- yolov5x-seg.yaml
+        |-- tf.py
+        |-- yolo.py
+        |-- yolov5l.yaml
+        |-- yolov5m.yaml
+        |-- yolov5n.yaml
+        |-- yolov5s.yaml
+        |-- yolov5x.yaml
+        |-- __init__.py
+        |-- __pycache__
+            |-- common.cpython-312.pyc
+            |-- experimental.cpython-312.pyc
+            |-- yolo.cpython-312.pyc
+            |-- __init__.cpython-312.pyc
+    |-- pyproject.toml
+    |-- README.md
+    |-- README.zh-CN.md
+    |-- requirements.txt
+    |-- segment
+        |-- predict.py
+        |-- train.py
+        |-- tutorial.ipynb
+        |-- val.py
+    |-- train.py
+    |-- tutorial.ipynb
+    |-- utils
+        |-- activations.py
+        |-- augmentations.py
+        |-- autoanchor.py
+        |-- autobatch.py
+        |-- aws
+            |-- mime.sh
+            |-- resume.py
+            |-- userdata.sh
+            |-- __init__.py
+        |-- callbacks.py
+        |-- dataloaders.py
+        |-- docker
+            |-- Dockerfile
+            |-- Dockerfile-arm64
+            |-- Dockerfile-cpu
+        |-- downloads.py
+        |-- flask_rest_api
+            |-- example_request.py
+            |-- README.md
+            |-- restapi.py
+        |-- general.py
+        |-- google_app_engine
+            |-- additional_requirements.txt
+            |-- app.yaml
+            |-- Dockerfile
+        |-- loggers
+            |-- clearml
+                |-- clearml_utils.py
+                |-- hpo.py
+                |-- README.md
+                |-- __init__.py
+                |-- __pycache__
+                    |-- clearml_utils.cpython-312.pyc
+                    |-- __init__.cpython-312.pyc
+            |-- comet
+                |-- comet_utils.py
+                |-- hpo.py
+                |-- optimizer_config.json
+                |-- README.md
+                |-- __init__.py
+                |-- __pycache__
+                    |-- comet_utils.cpython-312.pyc
+                    |-- __init__.cpython-312.pyc
+            |-- wandb
+                |-- wandb_utils.py
+                |-- __init__.py
+                |-- __pycache__
+                    |-- wandb_utils.cpython-312.pyc
+                    |-- __init__.cpython-312.pyc
+            |-- __init__.py
+            |-- __pycache__
+                |-- __init__.cpython-312.pyc
+        |-- loss.py
+        |-- metrics.py
+        |-- plots.py
+        |-- segment
+            |-- augmentations.py
+            |-- dataloaders.py
+            |-- general.py
+            |-- loss.py
+            |-- metrics.py
+            |-- plots.py
+            |-- __init__.py
+        |-- torch_utils.py
+        |-- triton.py
+        |-- __init__.py
+        |-- __pycache__
+            |-- augmentations.cpython-312.pyc
+            |-- autoanchor.cpython-312.pyc
+            |-- autobatch.cpython-312.pyc
+            |-- callbacks.cpython-312.pyc
+            |-- dataloaders.cpython-312.pyc
+            |-- downloads.cpython-312.pyc
+            |-- general.cpython-312.pyc
+            |-- loss.cpython-312.pyc
+            |-- metrics.cpython-312.pyc
+            |-- plots.cpython-312.pyc
+            |-- torch_utils.cpython-312.pyc
+            |-- __init__.cpython-312.pyc
+    |-- val.py
+    |-- __pycache__
+        |-- train.cpython-312.pyc
+        |-- val.cpython-312.pyc
+|-- yolo_training.py
+|-- yolo_training_v1.py

startup.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+echo "Starting the deployment process"
+
+# 1. Créer une virtual environment
+echo "Creating virtual environment..."
+python3 -m venv venv
+
+# 2. Activer la virtual environment
+echo "Activating virtual environment..."
+source venv/bin/activate
+
+# 3. Installer les dépendances
+echo "Installing dependencies..."
+pip install --upgrade pip
+pip install -r requirements.txt
+
+# 4. Exécuter les fichiers Python contenant 'download' dans leur nom
+echo "Running download scripts..."
+for file in $(ls | grep download.*\.py); do
+    echo "Executing $file..."
+    python $file
+done
+
+# 5. Démarrer l'application avec Gunicorn
+echo "Starting the Flask application with Gunicorn..."
+gunicorn --bind 0.0.0.0:8000 app:app

templates/index.html

@@ -0,0 +1,337 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <style>
+        /* General Styles */
+        body {
+            font-family: Arial, sans-serif;
+            margin: 0;
+            padding: 0;
+            background-color: #f4f4f4;
+        }
+
+        header {
+            background-color: #4CAF50;
+            padding: 15px 0;
+            text-align: center;
+            color: white;
+            font-size: 24px;
+            font-weight: bold;
+        }
+
+        section {
+            margin: 20px auto;
+            max-width: 1200px;
+            padding: 20px;
+            background: white;
+            box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 8px;
+        }
+
+        .upload-section {
+            text-align: center;
+        }
+
+        .upload-section input[type="file"] {
+            margin: 10px 0;
+        }
+
+        .image-container {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 20px;
+            justify-content: center;
+        }
+
+        .image-item {
+            width: 150px;
+            height: 150px;
+            overflow: hidden;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: transform 0.3s ease, border-color 0.3s ease;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background-color: #fff;
+        }
+
+        .image-item:hover {
+            border-color: #4CAF50;
+            transform: scale(1.05);
+        }
+
+        .image-item img {
+            max-width: 100%;
+            max-height: 100%;
+            object-fit: cover;
+        }
+
+        canvas {
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            margin: 20px auto;
+            display: block;
+        }
+
+        .class-management {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+
+        .class-management input[type="text"] {
+            padding: 8px;
+            font-size: 16px;
+            width: 300px;
+            margin-right: 10px;
+        }
+
+        .class-list {
+            display: flex;
+            justify-content: center;
+            flex-wrap: wrap;
+            gap: 10px;
+            list-style: none;
+            padding: 0;
+        }
+
+        .class-item {
+            padding: 5px 15px;
+            border-radius: 20px;
+            background-color: #f4f4f4;
+            border: 1px solid #ccc;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .class-item:hover {
+            background-color: #ddd;
+        }
+
+        .class-item.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #45a049;
+        }
+
+        .controls {
+            text-align: center;
+            margin-top: 20px;
+        }
+
+        button {
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            font-size: 16px;
+            cursor: pointer;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+            margin: 0 10px;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+
+        .result-section img {
+            max-width: 100%;
+            margin: 20px auto;
+            display: block;
+            border: 2px solid #4CAF50;
+            border-radius: 8px;
+        }
+    </style>
+</head>
+<body>
+    <header>Labélisation d'Images avec SAM</header>
+
+    <!-- Section 1: Téléchargement d'images -->
+    <section class="upload-section">
+        <h2>Télécharger vos images</h2>
+        <form method="post" enctype="multipart/form-data">
+            <input type="file" id="image" name="images" accept="image/*" multiple required>
+            <br>
+            <button type="submit">Télécharger</button>
+        </form>
+    </section>
+
+    {% if uploaded_images %}
+    <!-- Section 2: Galerie des images téléchargées -->
+    <section>
+        <h2>Images téléchargées</h2>
+        <div class="image-container">
+            {% for image in uploaded_images %}
+            <div class="image-item" onclick="loadImage('{{ image }}')">
+                <img src="{{ url_for('static', filename='uploads/' + image) }}" alt="{{ image }}">
+            </div>
+            {% endfor %}
+        </div>
+    </section>
+
+    <!-- Section 3: Zone de travail -->
+    <section>
+        <canvas id="image-canvas"></canvas>
+    </section>
+
+    <!-- Section 4: Gestion des classes -->
+    <section class="class-management">
+        <h3>Ajouter une classe</h3>
+        <input type="text" id="class-name" placeholder="Nom de la classe">
+        <button id="add-class">Ajouter</button>
+        <ul id="class-list" class="class-list"></ul>
+    </section>
+
+    <!-- Section 5: Contrôles -->
+    <section class="controls">
+        <button id="finish-button" disabled>Terminer l'annotation</button>
+        <button id="segment-button" disabled>Lancer la segmentation</button>
+    </section>
+    {% endif %}
+
+    <script>
+        let selectedImage = null; // Image actuellement sélectionnée
+        let annotations = {}; // Stocke les annotations de chaque image (clé : image, valeur : points)
+        let currentClass = null; // Classe actuellement sélectionnée
+        const finishButton = document.getElementById('finish-button');
+        const segmentButton = document.getElementById('segment-button');
+
+        function loadImage(imageName) {
+            if (!imageName) {
+                alert("Veuillez sélectionner une image !");
+                return;
+            }
+
+            selectedImage = imageName; // Stockez le nom de l'image sélectionnée
+            console.log("Image sélectionnée :", selectedImage);
+
+            // Initialiser les annotations pour cette image si elles n'existent pas
+            if (!annotations[selectedImage]) {
+                annotations[selectedImage] = [];
+            }
+
+            const img = new Image();
+            img.src = `/static/uploads/${imageName}`;
+            img.onload = () => {
+                const canvas = document.getElementById('image-canvas');
+                const ctx = canvas.getContext('2d');
+                canvas.width = img.width;
+                canvas.height = img.height;
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                ctx.drawImage(img, 0, 0);
+
+                // Dessiner les points existants pour cette image
+                annotations[selectedImage].forEach(point => {
+                    drawPoint(ctx, point.x, point.y, point.class);
+                });
+            };
+
+            finishButton.disabled = false;
+        }
+
+        function drawPoint(ctx, x, y, pointClass) {
+            ctx.fillStyle = pointClass === 'arbre' ? 'green' : 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+        }
+
+        document.getElementById('add-class').addEventListener('click', () => {
+            const className = document.getElementById('class-name').value.trim();
+            if (!className) {
+                alert("Veuillez entrer un nom de classe !");
+                return;
+            }
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.onclick = () => {
+                document.querySelectorAll('.class-item').forEach(item => item.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+                console.log("Classe sélectionnée :", currentClass);
+            };
+            document.getElementById('class-list').appendChild(li);
+            document.getElementById('class-name').value = '';
+        });
+
+        const canvas = document.getElementById('image-canvas');
+        const ctx = canvas.getContext('2d');
+
+        canvas.addEventListener('click', (event) => {
+            if (!currentClass) {
+                alert("Veuillez sélectionner une classe avant d'ajouter des points !");
+                return;
+            }
+
+            if (!selectedImage) {
+                alert("Veuillez sélectionner une image avant d'ajouter des points !");
+                return;
+            }
+
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+
+            const newPoint = { x, y, class: currentClass };
+            annotations[selectedImage].push(newPoint);
+            console.log(`Point ajouté pour ${selectedImage}:`, newPoint);
+
+            drawPoint(ctx, x, y, currentClass);
+        });
+
+        finishButton.addEventListener('click', () => {
+            if (!selectedImage) {
+                alert("Veuillez sélectionner une image !");
+                return;
+            }
+
+            console.log(`Annotation terminée pour ${selectedImage}.`);
+            alert(`Annotation pour ${selectedImage} terminée !`);
+
+            finishButton.disabled = true;
+
+            // Vérifiez si toutes les annotations sont terminées
+            if (Object.keys(annotations).length > 0) {
+                segmentButton.disabled = false;
+            }
+        });
+
+        segmentButton.addEventListener('click', () => {
+            const dataToSend = Object.keys(annotations).map(imageName => ({
+                image_name: imageName,
+                points: annotations[imageName]
+            }));
+
+            console.log("Données envoyées :", dataToSend);
+
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(dataToSend)
+            })
+            .then(response => response.json())
+            .then(data => {
+                console.log("Réponse du backend :", data);
+                if (data.success) {
+                    alert("Segmentation réussie !");
+                } else {
+                    alert("Erreur : " + data.error);
+                }
+            })
+            .catch(err => console.error('Erreur lors de la segmentation :', err));
+        });
+    </script>
+</body>
+</html>

templates/v1_index.html

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+</head>
+<body>
+    <h1>Labélisation d'Images avec SAM</h1>
+
+    <!-- Formulaire pour télécharger une image -->
+    <form method="post" enctype="multipart/form-data">
+        <label for="image">Télécharger une image :</label>
+        <input type="file" id="image" name="image" accept="image/*" required>
+        <button type="submit">Télécharger</button>
+    </form>
+
+    <!-- Prévisualisation de l'image sélectionnée -->
+    <h2>Prévisualisation :</h2>
+    <img id="preview" src="#" alt="Prévisualisation de l'image" style="max-width: 100%; display: none; border: 1px solid #ddd;">
+
+    <!-- JavaScript pour afficher la prévisualisation -->
+    <script>
+        // Récupérer l'élément <input> pour l'image et la balise <img> pour la prévisualisation
+        const imageInput = document.getElementById('image');
+        const preview = document.getElementById('preview');
+
+        // Écouteur pour détecter les changements dans l'input
+        imageInput.addEventListener('change', function(event) {
+            const file = event.target.files[0]; // Récupérer le fichier sélectionné
+            if (file) {
+                const reader = new FileReader(); // Créer un FileReader pour lire le fichier
+                reader.onload = function(e) {
+                    preview.src = e.target.result; // Mettre à jour la source de l'image
+                    preview.style.display = 'block'; // Afficher l'image
+                };
+                reader.readAsDataURL(file); // Lire le fichier comme une URL de données
+            } else {
+                preview.src = '#'; // Réinitialiser si aucun fichier n'est sélectionné
+                preview.style.display = 'none';
+            }
+        });
+    </script>
+</body>
+</html>

templates/v3_index.html

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+</head>
+<body>
+    <h1>Labélisation d'Images avec SAM</h1>
+    <div class="container">
+        <!-- Upload Section -->
+        <div class="upload-section">
+            <form method="post" enctype="multipart/form-data">
+                <label for="image">Télécharger une image :</label>
+                <input type="file" id="image" name="image" accept="image/*" required>
+                <button type="submit">Télécharger</button>
+            </form>
+        </div>
+
+        {% if uploaded_image %}
+        <!-- Display Uploaded Image -->
+        <canvas id="image-canvas"></canvas>
+
+        <!-- Class Management -->
+        <div class="class-management">
+            <h3>Ajouter une classe :</h3>
+            <input type="text" id="class-name" placeholder="Entrez une classe">
+            <button id="add-class">Ajouter</button>
+            <ul id="class-list"></ul>
+        </div>
+
+        <!-- Controls -->
+        <div class="controls">
+            <button id="segment-button" disabled>Lancer la Segmentation</button>
+        </div>
+        {% endif %}
+    </div>
+
+    <script>
+        let canvas = document.getElementById('image-canvas');
+        let ctx = canvas ? canvas.getContext('2d') : null;
+        let points = [];
+        let currentClass = null;
+        let img = null;
+    
+        {% if uploaded_image %}
+        img = new Image();
+        img.src = "{{ url_for('static', filename='uploads/' + uploaded_image) }}";
+        img.onload = () => {
+            canvas.width = img.width;
+            canvas.height = img.height;
+            ctx.drawImage(img, 0, 0);
+        };
+    
+        // Activer ou désactiver le bouton de segmentation
+        function updateSegmentButtonState() {
+            const segmentButton = document.getElementById('segment-button');
+            if (points.length > 0) {
+                segmentButton.disabled = false; // Activer le bouton
+            } else {
+                segmentButton.disabled = true; // Désactiver le bouton
+            }
+        }
+    
+        // Gestion des clics sur le canvas
+        canvas.addEventListener('click', event => {
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+    
+            if (!currentClass) {
+                alert('Veuillez sélectionner une classe avant d’ajouter des points.');
+                return;
+            }
+    
+            // Ajouter le point
+            points.push({ x, y, class: currentClass });
+    
+            // Dessiner le point sur le canvas
+            ctx.fillStyle = 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+    
+            // Mettre à jour l'état du bouton
+            updateSegmentButtonState();
+        });
+    
+        // Ajouter une classe et la sélectionner
+        document.getElementById('add-class').addEventListener('click', () => {
+            const classNameInput = document.getElementById('class-name');
+            const className = classNameInput.value.trim();
+    
+            if (!className) {
+                alert('Veuillez entrer une classe.');
+                return;
+            }
+    
+            const classList = document.getElementById('class-list');
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.addEventListener('click', () => {
+                document.querySelectorAll('.class-item').forEach(el => el.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+            });
+    
+            classList.appendChild(li);
+            classNameInput.value = '';
+        });
+    
+        // Lancer la segmentation
+        document.getElementById('segment-button').addEventListener('click', () => {
+            const imageName = "{{ uploaded_image }}";
+    
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    image_name: imageName,
+                    points: points
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    alert('Segmentation réussie !');
+                } else {
+                    alert('Erreur : ' + data.error);
+                }
+            })
+            .catch(error => {
+                console.error('Erreur lors de la segmentation :', error);
+            });
+        });
+    
+        // Désactiver le bouton au chargement
+        updateSegmentButtonState();
+        {% endif %}
+    </script>
+    
+</body>
+</html>

templates/v4_index.html

@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+            background-color: #f9f9f9;
+        }
+
+        h1 {
+            text-align: center;
+            color: #333;
+        }
+
+        section {
+            margin: 20px 0;
+            padding: 20px;
+            background: #fff;
+            box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 8px;
+        }
+
+        canvas {
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            display: block;
+            margin: 20px auto;
+        }
+
+        button {
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            font-size: 14px;
+            cursor: pointer;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+
+        .upload-section {
+            text-align: center;
+        }
+
+        .class-management {
+            text-align: center;
+        }
+
+        .class-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            justify-content: center;
+            list-style: none;
+            padding: 0;
+        }
+
+        .class-item {
+            padding: 5px 10px;
+            border-radius: 5px;
+            background-color: #f4f4f4;
+            border: 1px solid #ccc;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .class-item:hover {
+            background-color: #ddd;
+        }
+
+        .class-item.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #45a049;
+        }
+
+        #annotated-image {
+            display: block;
+            max-width: 100%;
+            margin: 20px auto;
+            border: 2px solid #4CAF50;
+            border-radius: 8px;
+        }
+
+        .status {
+            text-align: center;
+            margin-top: 10px;
+            font-weight: bold;
+        }
+
+        .status.success {
+            color: #4CAF50;
+        }
+
+        .status.error {
+            color: #f44336;
+        }
+    </style>
+</head>
+<body>
+    <h1>Labélisation d'Images avec SAM</h1>
+
+    <!-- Section 1: Upload Image -->
+    <section class="upload-section">
+        <form method="post" enctype="multipart/form-data">
+            <label for="image">Télécharger une image :</label><br>
+            <input type="file" id="image" name="image" accept="image/*" required>
+            <br>
+            <button type="submit">Télécharger</button>
+        </form>
+    </section>
+
+    {% if uploaded_image %}
+    <!-- Section 2: Canvas for Image -->
+    <section>
+        <canvas id="image-canvas"></canvas>
+    </section>
+
+    <!-- Section 3: Annotated Image -->
+    <section>
+        <h2>Image Annotée</h2>
+        <img id="annotated-image" style="display: none;" alt="Image Annotée">
+    </section>
+
+    <!-- Section 4: Manage Classes -->
+    <section class="class-management">
+        <h3>Ajouter une classe :</h3>
+        <input type="text" id="class-name" placeholder="Entrez une classe">
+        <button id="add-class">Ajouter</button>
+        <h4>Classes disponibles :</h4>
+        <ul id="class-list" class="class-list"></ul>
+    </section>
+
+    <!-- Section 5: Controls -->
+    <section>
+        <div class="controls">
+            <button id="segment-button" disabled>Lancer la Segmentation</button>
+        </div>
+    </section>
+    {% endif %}
+
+    <script>
+        let canvas = document.getElementById('image-canvas');
+        let ctx = canvas ? canvas.getContext('2d') : null;
+        let points = [];
+        let currentClass = null;
+
+        {% if uploaded_image %}
+        // Charger l'image téléchargée
+        const img = new Image();
+        img.src = "{{ url_for('static', filename='uploads/' + uploaded_image) }}";
+        img.onload = () => {
+            canvas.width = img.width;
+            canvas.height = img.height;
+            ctx.drawImage(img, 0, 0);
+        };
+
+        // Gestion des classes
+        document.getElementById('add-class').addEventListener('click', () => {
+            const className = document.getElementById('class-name').value.trim();
+            if (!className) return;
+
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.onclick = () => {
+                // Marquer la classe comme sélectionnée
+                document.querySelectorAll('.class-item').forEach(item => item.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+            };
+
+            document.getElementById('class-list').appendChild(li);
+            document.getElementById('class-name').value = '';
+        });
+
+        // Ajouter un point sur le canvas
+        canvas.addEventListener('click', event => {
+            if (!currentClass) {
+                alert('Veuillez sélectionner une classe.');
+                return;
+            }
+
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+            points.push({ x, y, class: currentClass });
+
+            // Dessiner le point sur le canvas
+            ctx.fillStyle = 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+
+            // Activer le bouton Segmentation
+            document.getElementById('segment-button').disabled = points.length === 0;
+        });
+
+        // Lancer la segmentation
+        document.getElementById('segment-button').addEventListener('click', () => {
+            const status = document.createElement('div');
+            status.className = 'status';
+            document.body.appendChild(status);
+
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    image_name: "{{ uploaded_image }}",
+                    points: points
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    status.textContent = 'Segmentation terminée !';
+                    status.classList.add('success');
+                    const annotatedImg = document.getElementById('annotated-image');
+                    annotatedImg.src = "{{ url_for('static', filename='') }}" + data.annotated_image;
+                    annotatedImg.style.display = 'block';
+                } else {
+                    status.textContent = 'Erreur : ' + data.error;
+                    status.classList.add('error');
+                }
+            })
+            .catch(err => {
+                status.textContent = 'Erreur de réseau.';
+                status.classList.add('error');
+                console.error('Erreur:', err);
+            });
+        });
+        {% endif %}
+    </script>
+</body>
+</html>

templates/v5_index.html

@@ -0,0 +1,249 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+            background-color: #f9f9f9;
+        }
+
+        h1 {
+            text-align: center;
+            color: #333;
+        }
+
+        section {
+            margin: 20px 0;
+            padding: 20px;
+            background: #fff;
+            box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 8px;
+        }
+
+        canvas {
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            display: block;
+            margin: 20px auto;
+        }
+
+        button {
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            font-size: 14px;
+            cursor: pointer;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+
+        .upload-section {
+            text-align: center;
+        }
+
+        .class-management {
+            text-align: center;
+        }
+
+        .class-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            justify-content: center;
+            list-style: none;
+            padding: 0;
+        }
+
+        .class-item {
+            padding: 5px 10px;
+            border-radius: 5px;
+            background-color: #f4f4f4;
+            border: 1px solid #ccc;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .class-item:hover {
+            background-color: #ddd;
+        }
+
+        .class-item.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #45a049;
+        }
+
+        #annotated-image {
+            display: block;
+            max-width: 100%;
+            margin: 20px auto;
+            border: 2px solid #4CAF50;
+            border-radius: 8px;
+        }
+
+        .status {
+            text-align: center;
+            margin-top: 10px;
+            font-weight: bold;
+        }
+
+        .status.success {
+            color: #4CAF50;
+        }
+
+        .status.error {
+            color: #f44336;
+        }
+    </style>
+</head>
+<body>
+    <h1>Labélisation d'Images avec SAM</h1>
+
+    <!-- Section 1: Upload Image -->
+    <section class="upload-section">
+        <form method="post" enctype="multipart/form-data">
+            <label for="image">Télécharger une image :</label><br>
+            <input type="file" id="image" name="image" accept="image/*" required>
+            <br>
+            <button type="submit">Télécharger</button>
+        </form>
+    </section>
+
+    {% if uploaded_image %}
+    <!-- Section 2: Canvas for Image -->
+    <section>
+        <canvas id="image-canvas"></canvas>
+    </section>
+
+    <!-- Section 3: Annotated Image -->
+    <section>
+        <h2>Image Annotée</h2>
+        <img id="annotated-image" style="display: none;" alt="Image Annotée">
+    </section>
+
+    <!-- Section 4: Manage Classes -->
+    <section class="class-management">
+        <h3>Ajouter une classe :</h3>
+        <input type="text" id="class-name" placeholder="Entrez une classe">
+        <button id="add-class">Ajouter</button>
+        <h4>Classes disponibles :</h4>
+        <ul id="class-list" class="class-list"></ul>
+    </section>
+
+    <!-- Section 5: Controls -->
+    <section>
+        <div class="controls">
+            <button id="segment-button" disabled>Lancer la Segmentation</button>
+        </div>
+    </section>
+    {% endif %}
+
+    <script>
+        let canvas = document.getElementById('image-canvas');
+        let ctx = canvas ? canvas.getContext('2d') : null;
+        let points = [];
+        let currentClass = null;
+
+        {% if uploaded_image %}
+        // Charger l'image téléchargée
+        const img = new Image();
+        img.src = "{{ url_for('static', filename='uploads/' + uploaded_image) }}";
+        img.onload = () => {
+            canvas.width = img.width;
+            canvas.height = img.height;
+            ctx.drawImage(img, 0, 0);
+        };
+
+        // Gestion des classes
+        document.getElementById('add-class').addEventListener('click', () => {
+            const className = document.getElementById('class-name').value.trim();
+            if (!className) return;
+
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.onclick = () => {
+                // Marquer la classe comme sélectionnée
+                document.querySelectorAll('.class-item').forEach(item => item.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+            };
+
+            document.getElementById('class-list').appendChild(li);
+            document.getElementById('class-name').value = '';
+        });
+
+        // Ajouter un point sur le canvas
+        canvas.addEventListener('click', event => {
+            if (!currentClass) {
+                alert('Veuillez sélectionner une classe.');
+                return;
+            }
+
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+            points.push({ x, y, class: currentClass });
+
+            // Dessiner le point sur le canvas
+            ctx.fillStyle = 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+
+            // Activer le bouton Segmentation
+            document.getElementById('segment-button').disabled = points.length === 0;
+        });
+
+        // Lancer la segmentation
+        document.getElementById('segment-button').addEventListener('click', () => {
+            const status = document.createElement('div');
+            status.className = 'status';
+            document.body.appendChild(status);
+
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    image_name: "{{ uploaded_image }}",
+                    points: points
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    status.textContent = 'Segmentation terminée !';
+                    status.classList.add('success');
+                    const annotatedImg = document.getElementById('annotated-image');
+                    annotatedImg.src = "{{ url_for('static', filename='') }}" + data.annotated_image;
+                    annotatedImg.style.display = 'block';
+                } else {
+                    status.textContent = 'Erreur : ' + data.error;
+                    status.classList.add('error');
+                }
+            })
+            .catch(err => {
+                status.textContent = 'Erreur de réseau.';
+                status.classList.add('error');
+                console.error('Erreur:', err);
+            });
+        });
+        {% endif %}
+    </script>
+</body>
+</html>

templates/v6_index.html

@@ -0,0 +1,318 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+            background-color: #f9f9f9;
+        }
+
+        h1 {
+            text-align: center;
+            color: #333;
+        }
+
+        section {
+            margin: 20px 0;
+            padding: 20px;
+            background: #fff;
+            box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 8px;
+        }
+
+        canvas {
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            display: block;
+            margin: 20px auto;
+        }
+
+        button {
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            font-size: 14px;
+            cursor: pointer;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+
+        .upload-section, .class-management, .controls {
+            text-align: center;
+        }
+
+        .class-list {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            justify-content: center;
+            list-style: none;
+            padding: 0;
+        }
+
+        .class-item {
+            padding: 5px 10px;
+            border-radius: 5px;
+            background-color: #f4f4f4;
+            border: 1px solid #ccc;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .class-item:hover {
+            background-color: #ddd;
+        }
+
+        .class-item.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #45a049;
+        }
+
+        #annotated-image {
+            display: block;
+            max-width: 100%;
+            margin: 20px auto;
+            border: 2px solid #4CAF50;
+            border-radius: 8px;
+        }
+
+        .status {
+            text-align: center;
+            margin-top: 10px;
+            font-weight: bold;
+        }
+
+        .status.success {
+            color: #4CAF50;
+        }
+
+        .status.error {
+            color: #f44336;
+        }
+
+        .image-container {
+            display: flex;
+            justify-content: center;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin: 20px 0;
+        }
+
+        .image-item {
+            width: 150px;
+            height: 150px;
+            object-fit: cover;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        /* Limite la taille des images téléchargées */
+        .image-item img {
+            max-width: 100%; /* S'adapte à la taille du conteneur */
+            max-height: 100%; /* Empêche de dépasser le conteneur */
+            border-radius: 8px;
+            object-fit: cover; /* Maintient le rapport d'aspect */
+        }
+
+        /* Taille fixe des conteneurs pour les images */
+        .image-item {
+            width: 150px;
+            height: 150px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            overflow: hidden; /* Coupe les parties excédentaires */
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .image-item:hover {
+            border-color: #4CAF50;
+        }
+
+        /* Ajout pour le conteneur général des images téléchargées */
+        .image-container {
+            display: flex;
+            justify-content: center;
+            flex-wrap: wrap;
+            gap: 10px;
+            margin: 20px 0;
+        }
+    </style>
+</head>
+<body>
+    <h1>Labélisation d'Images avec SAM</h1>
+
+    <!-- Section 1: Upload Images -->
+    <section class="upload-section">
+        <form method="post" enctype="multipart/form-data">
+            <label for="image">Télécharger des images :</label><br>
+            <input type="file" id="image" name="images" accept="image/*" multiple required>
+            <br>
+            <button type="submit">Télécharger les images</button>
+        </form>
+    </section>
+
+    {% if uploaded_images %}
+    <!-- Section 2: Images déjà téléchargées -->
+    <section>
+        <h2>Images téléchargées</h2>
+        <div class="image-container">
+            {% for image in uploaded_images %}
+                <div class="image-item" onclick="loadImage('{{ image }}')">
+                    <img src="{{ url_for('static', filename='uploads/' + image) }}" alt="{{ image }}">
+                </div>
+            {% endfor %}
+        </div>
+    </section>
+
+    <!-- Section 3: Canvas for Image Annotation -->
+    <section>
+        <canvas id="image-canvas"></canvas>
+    </section>
+
+    <!-- Section 4: Annotated Image -->
+    <section>
+        <h2>Image Annotée</h2>
+        <img id="annotated-image" style="display: none;" alt="Image Annotée">
+    </section>
+
+    <!-- Section 5: Manage Classes -->
+    <section class="class-management">
+        <h3>Ajouter une classe :</h3>
+        <input type="text" id="class-name" placeholder="Entrez une classe">
+        <button id="add-class">Ajouter</button>
+        <h4>Classes disponibles :</h4>
+        <ul id="class-list" class="class-list"></ul>
+    </section>
+
+    <!-- Section 6: Controls -->
+    <section>
+        <button id="finish-button" disabled>Terminer l'annotation</button>
+        <button id="segment-button" disabled>Lancer la Segmentation</button>
+    </section>
+    {% endif %}
+
+    <script>
+        let canvas = document.getElementById('image-canvas');
+        let ctx = canvas ? canvas.getContext('2d') : null;
+        let points = [];
+        let currentClass = null;
+        let img = null;
+        let imgWidth = 0;
+        let imgHeight = 0;
+
+        {% if uploaded_images %}
+        function loadImage(imageName) {
+            // Réinitialiser le tableau des points
+            points = [];
+            document.getElementById('finish-button').disabled = false;
+            document.getElementById('segment-button').disabled = true;
+
+            // Charger l'image sélectionnée
+            img = new Image();
+            img.src = "{{ url_for('static', filename='uploads/') }}" + imageName;
+
+            img.onload = () => {
+                imgWidth = img.width;
+                imgHeight = img.height;
+                canvas.width = imgWidth;
+                canvas.height = imgHeight;
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                ctx.drawImage(img, 0, 0);
+            };
+        }
+
+        // Gestion des classes
+        document.getElementById('add-class').addEventListener('click', () => {
+            const className = document.getElementById('class-name').value.trim();
+            if (!className) return;
+
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.onclick = () => {
+                document.querySelectorAll('.class-item').forEach(item => item.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+            };
+            document.getElementById('class-list').appendChild(li);
+
+            document.getElementById('class-name').value = '';
+        });
+
+        // Ajouter un point sur le canvas
+        canvas.addEventListener('click', event => {
+            if (!currentClass) {
+                alert('Veuillez sélectionner une classe.');
+                return;
+            }
+
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+
+            points.push({ x, y, class: currentClass });
+
+            ctx.fillStyle = 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+
+            // Activer le bouton Segmentation
+            document.getElementById('segment-button').disabled = points.length === 0;
+        });
+
+        // Terminer l'annotation
+        document.getElementById('finish-button').addEventListener('click', () => {
+            alert("Annotation terminée pour cette image.");
+            document.getElementById('finish-button').disabled = true;
+        });
+
+        // Lancer la segmentation
+        document.getElementById('segment-button').addEventListener('click', () => {
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    image_names: ["{{ uploaded_image }}"],  // Passer l'image actuelle
+                    points: points
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    document.getElementById('annotated-image').src = "{{ url_for('static', filename='') }}" + data.annotated_image;
+                    document.getElementById('annotated-image').style.display = 'block';
+                } else {
+                    alert("Erreur : " + data.error);
+                }
+            })
+            .catch(err => {
+                console.error('Erreur:', err);
+            });
+        });
+        {% endif %}
+    </script>
+</body>
+</html>

templates/v7_multi_segmentation.html

@@ -0,0 +1,337 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Labélisation d'Images avec SAM</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
+    <style>
+        /* General Styles */
+        body {
+            font-family: Arial, sans-serif;
+            margin: 0;
+            padding: 0;
+            background-color: #f4f4f4;
+        }
+
+        header {
+            background-color: #4CAF50;
+            padding: 15px 0;
+            text-align: center;
+            color: white;
+            font-size: 24px;
+            font-weight: bold;
+        }
+
+        section {
+            margin: 20px auto;
+            max-width: 1200px;
+            padding: 20px;
+            background: white;
+            box-shadow: 0px 4px 8px rgba(0, 0, 0, 0.1);
+            border-radius: 8px;
+        }
+
+        .upload-section {
+            text-align: center;
+        }
+
+        .upload-section input[type="file"] {
+            margin: 10px 0;
+        }
+
+        .image-container {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 20px;
+            justify-content: center;
+        }
+
+        .image-item {
+            width: 150px;
+            height: 150px;
+            overflow: hidden;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: transform 0.3s ease, border-color 0.3s ease;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            background-color: #fff;
+        }
+
+        .image-item:hover {
+            border-color: #4CAF50;
+            transform: scale(1.05);
+        }
+
+        .image-item img {
+            max-width: 100%;
+            max-height: 100%;
+            object-fit: cover;
+        }
+
+        canvas {
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            margin: 20px auto;
+            display: block;
+        }
+
+        .class-management {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+
+        .class-management input[type="text"] {
+            padding: 8px;
+            font-size: 16px;
+            width: 300px;
+            margin-right: 10px;
+        }
+
+        .class-list {
+            display: flex;
+            justify-content: center;
+            flex-wrap: wrap;
+            gap: 10px;
+            list-style: none;
+            padding: 0;
+        }
+
+        .class-item {
+            padding: 5px 15px;
+            border-radius: 20px;
+            background-color: #f4f4f4;
+            border: 1px solid #ccc;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .class-item:hover {
+            background-color: #ddd;
+        }
+
+        .class-item.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #45a049;
+        }
+
+        .controls {
+            text-align: center;
+            margin-top: 20px;
+        }
+
+        button {
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            padding: 10px 20px;
+            font-size: 16px;
+            cursor: pointer;
+            border-radius: 5px;
+            transition: background-color 0.3s ease;
+            margin: 0 10px;
+        }
+
+        button:hover {
+            background-color: #45a049;
+        }
+
+        button:disabled {
+            background-color: #ccc;
+            cursor: not-allowed;
+        }
+
+        .result-section img {
+            max-width: 100%;
+            margin: 20px auto;
+            display: block;
+            border: 2px solid #4CAF50;
+            border-radius: 8px;
+        }
+    </style>
+</head>
+<body>
+    <header>Labélisation d'Images avec SAM</header>
+
+    <!-- Section 1: Téléchargement d'images -->
+    <section class="upload-section">
+        <h2>Télécharger vos images</h2>
+        <form method="post" enctype="multipart/form-data">
+            <input type="file" id="image" name="images" accept="image/*" multiple required>
+            <br>
+            <button type="submit">Télécharger</button>
+        </form>
+    </section>
+
+    {% if uploaded_images %}
+    <!-- Section 2: Galerie des images téléchargées -->
+    <section>
+        <h2>Images téléchargées</h2>
+        <div class="image-container">
+            {% for image in uploaded_images %}
+            <div class="image-item" onclick="loadImage('{{ image }}')">
+                <img src="{{ url_for('static', filename='uploads/' + image) }}" alt="{{ image }}">
+            </div>
+            {% endfor %}
+        </div>
+    </section>
+
+    <!-- Section 3: Zone de travail -->
+    <section>
+        <canvas id="image-canvas"></canvas>
+    </section>
+
+    <!-- Section 4: Gestion des classes -->
+    <section class="class-management">
+        <h3>Ajouter une classe</h3>
+        <input type="text" id="class-name" placeholder="Nom de la classe">
+        <button id="add-class">Ajouter</button>
+        <ul id="class-list" class="class-list"></ul>
+    </section>
+
+    <!-- Section 5: Contrôles -->
+    <section class="controls">
+        <button id="finish-button" disabled>Terminer l'annotation</button>
+        <button id="segment-button" disabled>Lancer la segmentation</button>
+    </section>
+    {% endif %}
+
+    <script>
+        let selectedImage = null; // Image actuellement sélectionnée
+        let annotations = {}; // Stocke les annotations de chaque image (clé : image, valeur : points)
+        let currentClass = null; // Classe actuellement sélectionnée
+        const finishButton = document.getElementById('finish-button');
+        const segmentButton = document.getElementById('segment-button');
+
+        function loadImage(imageName) {
+            if (!imageName) {
+                alert("Veuillez sélectionner une image !");
+                return;
+            }
+
+            selectedImage = imageName; // Stockez le nom de l'image sélectionnée
+            console.log("Image sélectionnée :", selectedImage);
+
+            // Initialiser les annotations pour cette image si elles n'existent pas
+            if (!annotations[selectedImage]) {
+                annotations[selectedImage] = [];
+            }
+
+            const img = new Image();
+            img.src = `/static/uploads/${imageName}`;
+            img.onload = () => {
+                const canvas = document.getElementById('image-canvas');
+                const ctx = canvas.getContext('2d');
+                canvas.width = img.width;
+                canvas.height = img.height;
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                ctx.drawImage(img, 0, 0);
+
+                // Dessiner les points existants pour cette image
+                annotations[selectedImage].forEach(point => {
+                    drawPoint(ctx, point.x, point.y, point.class);
+                });
+            };
+
+            finishButton.disabled = false;
+        }
+
+        function drawPoint(ctx, x, y, pointClass) {
+            ctx.fillStyle = pointClass === 'arbre' ? 'green' : 'red';
+            ctx.beginPath();
+            ctx.arc(x, y, 5, 0, 2 * Math.PI);
+            ctx.fill();
+        }
+
+        document.getElementById('add-class').addEventListener('click', () => {
+            const className = document.getElementById('class-name').value.trim();
+            if (!className) {
+                alert("Veuillez entrer un nom de classe !");
+                return;
+            }
+            const li = document.createElement('li');
+            li.textContent = className;
+            li.classList.add('class-item');
+            li.onclick = () => {
+                document.querySelectorAll('.class-item').forEach(item => item.classList.remove('active'));
+                li.classList.add('active');
+                currentClass = className;
+                console.log("Classe sélectionnée :", currentClass);
+            };
+            document.getElementById('class-list').appendChild(li);
+            document.getElementById('class-name').value = '';
+        });
+
+        const canvas = document.getElementById('image-canvas');
+        const ctx = canvas.getContext('2d');
+
+        canvas.addEventListener('click', (event) => {
+            if (!currentClass) {
+                alert("Veuillez sélectionner une classe avant d'ajouter des points !");
+                return;
+            }
+
+            if (!selectedImage) {
+                alert("Veuillez sélectionner une image avant d'ajouter des points !");
+                return;
+            }
+
+            const rect = canvas.getBoundingClientRect();
+            const x = event.clientX - rect.left;
+            const y = event.clientY - rect.top;
+
+            const newPoint = { x, y, class: currentClass };
+            annotations[selectedImage].push(newPoint);
+            console.log(`Point ajouté pour ${selectedImage}:`, newPoint);
+
+            drawPoint(ctx, x, y, currentClass);
+        });
+
+        finishButton.addEventListener('click', () => {
+            if (!selectedImage) {
+                alert("Veuillez sélectionner une image !");
+                return;
+            }
+
+            console.log(`Annotation terminée pour ${selectedImage}.`);
+            alert(`Annotation pour ${selectedImage} terminée !`);
+
+            finishButton.disabled = true;
+
+            // Vérifiez si toutes les annotations sont terminées
+            if (Object.keys(annotations).length > 0) {
+                segmentButton.disabled = false;
+            }
+        });
+
+        segmentButton.addEventListener('click', () => {
+            const dataToSend = Object.keys(annotations).map(imageName => ({
+                image_name: imageName,
+                points: annotations[imageName]
+            }));
+
+            console.log("Données envoyées :", dataToSend);
+
+            fetch('/segment', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(dataToSend)
+            })
+            .then(response => response.json())
+            .then(data => {
+                console.log("Réponse du backend :", data);
+                if (data.success) {
+                    alert("Segmentation réussie !");
+                } else {
+                    alert("Erreur : " + data.error);
+                }
+            })
+            .catch(err => console.error('Erreur lors de la segmentation :', err));
+        });
+    </script>
+</body>
+</html>

yolo_training.py

@@ -0,0 +1,53 @@
+import pathlib
+from pathlib import Path
+pathlib.PosixPath = pathlib.WindowsPath
+import sys
+import os
+
+# Ajoutez le chemin du répertoire YOLOv5 au sys.path pour pouvoir importer train.py
+BASE_DIR = Path(__file__).resolve().parent
+YOLOV5_DIR = BASE_DIR / "yolov5"
+sys.path.append(str(YOLOV5_DIR))
+
+from yolov5.train import main, parse_opt  # Importation directe des fonctions nécessaires
+
+# Définir les chemins et options
+MODEL_PATH = BASE_DIR / "models/models--keizer77--samyolo2/snapshots/74c8cb12ae448ff0b8bae9ef522b54ec09b47c20/best.pt"
+DATA_YAML_PATH = BASE_DIR / "labelid_image/data.yaml"      #         
+OUTPUT_DIR = BASE_DIR / "weights"
+
+def clear_cache(data_path):
+    """
+    Supprime les fichiers de cache de labels pour s'assurer que YOLOv5
+    recrée les caches à partir des fichiers d'annotation actuels.
+    """
+    subfolders = ['train', 'valid', 'test']
+    for folder in subfolders:
+        cache_file = os.path.join(data_path, folder, 'labels.cache')
+        if os.path.exists(cache_file):
+            print(f"Suppression du cache : {cache_file}")
+            os.remove(cache_file)
+
+def train_yolo_direct():
+    # Nettoyer le cache avant l'entraînement
+    clear_cache("labelid_image")
+
+    # Préparer les options pour l'entraînement
+    opt = parse_opt()
+    opt.imgsz = 640
+    opt.batch_size = 8
+    opt.epochs = 10
+    opt.data = str(DATA_YAML_PATH)
+    opt.weights = str(MODEL_PATH)
+    opt.project = str(OUTPUT_DIR)
+    opt.name = "custom_model"
+    opt.device = "cpu"  # Spécifier le périphérique (CPU ou GPU)
+
+    print("Lancement de l'entraînement YOLOv5...")
+    main(opt)
+
+if __name__ == "__main__":
+    try:
+        train_yolo_direct()
+    except Exception as e:
+        print(f"Erreur lors de l'exécution de l'entraînement : {e}")

yolo_training_v1.py

@@ -0,0 +1,38 @@
+import pathlib
+from pathlib import Path
+pathlib.PosixPath = pathlib.WindowsPath
+import sys
+
+# Ajoutez le chemin du répertoire YOLOv5 au sys.path pour pouvoir importer train.py
+BASE_DIR = Path(__file__).resolve().parent
+YOLOV5_DIR = BASE_DIR / "yolov5"
+sys.path.append(str(YOLOV5_DIR))
+
+from yolov5.train import main, parse_opt  # Importation directe des fonctions nécessaires
+
+# Définir les chemins et options
+MODEL_PATH = BASE_DIR / "models/models--keizer77--samyolo2/snapshots/74c8cb12ae448ff0b8bae9ef522b54ec09b47c20/best.pt"
+DATA_YAML_PATH = BASE_DIR / "labelid_image/data.yaml"
+OUTPUT_DIR = BASE_DIR / "weights"
+
+def train_yolo_direct():
+    # Préparer les options pour l'entraînement
+    opt = parse_opt()
+    opt.imgsz = 640
+    opt.batch_size = 16
+    opt.epochs = 10
+    opt.data = str(DATA_YAML_PATH)
+    opt.weights = str(MODEL_PATH)
+    opt.project = str(OUTPUT_DIR)
+    opt.name = "custom_model"
+    opt.device = "cpu"  # Spécifier le périphérique (CPU ou GPU)
+    
+    # Appeler directement la fonction d'entraînement
+    print("Lancement de l'entraînement YOLOv5...")
+    main(opt)
+
+if __name__ == "__main__":
+    try:
+        train_yolo_direct()
+    except Exception as e:
+        print(f"Erreur lors de l'exécution de l'entraînement : {e}")