app.py

import streamlit as st
import requests
from transformers import DetrImageProcessor, DetrForObjectDetection
import torch
from PIL import Image, ImageDraw

# Fonction pour générer du texte avec Gemini
def generate_text_with_gemini(api_key, prompt):
    url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent"
    headers = {
        "Content-Type": "application/json",
    }
    params = {
        "key": api_key
    }
    data = {
        "contents": [
            {
                "parts": [
                    {"text": prompt}
                ]
            }
        ]
    }
    response = requests.post(url, headers=headers, params=params, json=data)
    
    # Debug: Print the raw response
    print(f"Gemini response status code: {response.status_code}")
    print(f"Gemini response content: {response.text}")

    try:
        response_json = response.json()
    except ValueError:
        response_json = {}
        print("Failed to decode JSON response")
    
    return response.status_code, response_json

# Fonction de traitement de l'image et d'encadrement des personnes détectées
def process_image(image):
    processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50", revision="no_timm")
    model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", revision="no_timm")
    
    # Préparer l'image pour le modèle
    inputs = processor(images=image, return_tensors="pt")
    outputs = model(**inputs)
    
    # Post-traitement des résultats pour obtenir les boîtes englobantes et les labels
    target_sizes = torch.tensor([image.size[::-1]])
    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]

    # Convertir l'image pour dessiner
    draw_image = image.copy()
    draw = ImageDraw.Draw(draw_image)

    # Compter le nombre de personnes détectées
    persons = 0
    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
        if model.config.id2label[label.item()] == 'person':
            persons += 1
            box = [round(i, 2) for i in box.tolist()]
            # Dessiner le rectangle rouge autour de la personne détectée
            draw.rectangle(box, outline="red", width=3)
    
    expected_number_of_persons = 10  # Nombre attendu de personnes
    absents = expected_number_of_persons - persons

    # Assurez-vous que le nombre d'absents ne soit pas négatif
    if absents < 0:
        absents = 0

    # Générer le contenu de l'email avec Gemini
    prompt = f"Notifier de l'absence: Le nombre de personnes présentes est de {persons}. Le nombre d'absents est de {absents}."
    gemini_api_key = "AIzaSyCJVUr-76I4TL42X98d9U0THbRD3MKlB38"  # Votre clé API Gemini
    status_code, response_json = generate_text_with_gemini(gemini_api_key, prompt)
    email_content = response_json.get('candidates', [{}])[0].get('content', {}).get('parts', [{}])[0].get('text', 'Content generation failed.')

    return draw_image, email_content

# Interface Streamlit
st.title("Analyse d'Images pour Détection de Personnes")

uploaded_files = st.file_uploader("Choisissez jusqu'à 3 images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)

if uploaded_files:
    for uploaded_file in uploaded_files:
        # Lire l'image téléchargée
        image = Image.open(uploaded_file)
        st.image(image, caption=f'Image téléchargée : {uploaded_file.name}', use_column_width=True)
        
        # Traitement de l'image
        modified_image, email_content = process_image(image)
        
        # Afficher l'image modifiée
        st.image(modified_image, caption=f'Image avec personnes détectées : {uploaded_file.name}', use_column_width=True)
        
        # Afficher le contenu généré
        st.write(f"**Contenu généré pour {uploaded_file.name} :**")
        st.markdown(email_content)