app.py

import streamlit as st
import cv2
import numpy as np
from PIL import Image
from io import BytesIO
import barcode
from barcode.writer import ImageWriter
import qrcode
import tempfile

def image_to_bytes(img):
    pil_image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
    buffer = BytesIO()
    pil_image.save(buffer, format="PNG")
    return buffer.getvalue()

def generate_barcode(link):
    code128 = barcode.get_barcode_class('code128')
    barcode_image = code128(link, writer=ImageWriter())
    buffer = BytesIO()
    barcode_image.write(buffer)
    return Image.open(buffer)

def generate_qrcode(link):
    qr = qrcode.QRCode(
        version=2,  
        error_correction=qrcode.constants.ERROR_CORRECT_L,  
        box_size=4,  
        border=2,    
    )
    qr.add_data(link)
    qr.make(fit=True)
    qr_image = qr.make_image(fill_color="black", back_color="white")

    small_qr_image = qr_image.resize((60, 60), Image.Resampling.LANCZOS)

    buffer = BytesIO()
    small_qr_image.save(buffer, format="PNG")
    return Image.open(buffer)

def add_custom_css():
    css = """
    <style>
        body {
            background: linear-gradient(135deg, #a8dadc, #f1faee);
            color: #1d3557;
            font-family: 'Arial', sans-serif;
            animation: backgroundAnimation 10s infinite alternate;
        }

        @keyframes backgroundAnimation {
            0% {
                background: linear-gradient(135deg, #a8dadc, #f1faee);
            }
            100% {
                background: linear-gradient(135deg, #f1faee, #457b9d);
            }
        }

        .stButton>button {
            background-color: #457b9d;
            color: white;
            border-radius: 5px;
            transition: transform 0.3s, background-color 0.3s;
            box-shadow: 2px 2px 6px rgba(0,0,0,0.2);
        }

        .stButton>button:hover {
            transform: scale(1.1);
            background-color: #1d3557;
        }

        .stSidebar {
            background: linear-gradient(135deg, #457b9d, #a8dadc);
            color: white;
            font-size: 16px;
        }

        .stImage {
            animation: fadeIn 2s ease-in-out;
        }

        @keyframes fadeIn {
            0% {
                opacity: 0;
            }
            100% {
                opacity: 1;
            }
        }

        header, footer {
            background: #457b9d;
            color: white;
        }

        .stMarkdown {
            animation: slideIn 1s ease-out;
        }

        @keyframes slideIn {
            0% {
                transform: translateY(-20px);
                opacity: 0;
            }
            100% {
                transform: translateY(0);
                opacity: 1;
            }
        }
    </style>
    """
    st.markdown(css, unsafe_allow_html=True)

def add_custom_js():
    js = """
    <script>
        document.addEventListener('DOMContentLoaded', function() {
            const elements = document.querySelectorAll('.stButton>button');
            elements.forEach(button => {
                button.addEventListener('click', () => {
                    button.style.backgroundColor = '#a8dadc';
                    button.style.transform = 'rotate(360deg)';
                    setTimeout(() => button.style.transform = 'rotate(0deg)', 300);
                });
            });
        });
    </script>
    """
    st.markdown(js, unsafe_allow_html=True)

def main():
    st.set_page_config(page_title="ADS VISOR - Un autre regard", layout="wide")

    add_custom_css()
    add_custom_js()


    logo_path = "logo.jpg"  
    logo = Image.open(logo_path)
    st.image(logo, width=150, caption="ADS VISOR")

    st.title("ADS VISOR - Un autre regard")

    st.sidebar.header("Chargement de l'image")
    if "default_image" not in st.session_state:
        st.session_state["default_image"] = None

    uploaded_file = st.sidebar.file_uploader("Charge une image", type=["png", "jpg", "jpeg"])
    if uploaded_file is not None:
        image = Image.open(uploaded_file)
        st.session_state["default_image"] = np.array(image)
        st.sidebar.image(image, caption="Image par défaut", use_container_width=True)

    if st.session_state["default_image"] is None:
        st.sidebar.warning("Veuillez charger une image pour commencer.")
        return

    st.sidebar.header("Fonctionnalités")
    menu_option = st.sidebar.selectbox(
        "Choisissez une fonctionnalité",
        ["Accueil", "Transformations d'image", "Cropping", "Rotation", "Floutage", "Contours", "Génération de Code-barres et QR Code", "Détection Faciale"],
        format_func=lambda x: {
            "Accueil": "🏠 Accueil",
            "Transformations d'image": "🖼️ Transformations",
            "Cropping": "✂️ Cropping",
            "Rotation": "🔄 Rotation",
            "Floutage": "🌫️ Floutage",
            "Contours": "🔍 Contours",
            "Génération de Code-barres et QR Code": "📇 Codes",
            "Détection Faciale": "🙂 Détection Faciale"
        }.get(x, x)
    )

    image_np = st.session_state["default_image"]

    if menu_option == "Accueil":
        st.header("Bienvenue sur ADS VISOR")
        st.markdown(
            """
            <div class="stMarkdown">
                <h2>ADS VISOR est une application innovante pour analyser, transformer et explorer vos images. 🖼️✨</h2>
                <p>Elle a été concu par un groupe de trois étudiants dans le contexte du contrôle continu de Computer Vision.</p>
                <p>Que vous soyez un professionnel ou un passionné, découvrez un large éventail de fonctionnalités interactives !</p>
                <ul>
                    <li><b>Transformations d'image :</b> Couleurs, niveaux de gris, etc.</li>
                    <li><b>Découpage & Rotation :</b> Ajustez vos images à la perfection.</li>
                    <li><b>Détection Faciale :</b> Identifiez les visages automatiquement.</li>
                    <li><b>Codes-barres & QR Codes :</b> Génération rapide pour vos projets.</li>
                </ul>
            </div>
            """,
            unsafe_allow_html=True
        )

        st.write("### Équipe :")
        st.markdown(
            """
            | **Nom**                | **Niveau**                  |
            |------------------------|---------------------------|
            | **Ngoue David**        | Master 2 Intelligence Artificielle et Big Data      |
            | **Bidzanga Armel**     | Master 2 Intelligence Artificielle et Big Data       |
            | **Nziou Serena**       | Master 2 Administration de Systèmes d'Information     |
            """,
            unsafe_allow_html=True
        )

    elif menu_option == "Transformations d'image":
        st.subheader("Transformations d'image")

        tab1, tab2, tab3, tab4 = st.tabs([
            "Gris 🖤", "Rouge ❤️", "Vert 💚", "Jaune 💛"
        ])

        with tab1:
            st.image(cv2.cvtColor(image_np, cv2.COLOR_BGR2GRAY), caption="Image en Niveaux de Gris", use_container_width=True)
        with tab2:
            red = image_np.copy()
            red[:, :, 1:] = 0
            st.image(red, caption="Image Rouge", use_container_width=True)
        with tab3:
            green = image_np.copy()
            green[:, :, [0, 2]] = 0
            st.image(green, caption="Image Verte", use_container_width=True)
        with tab4:
            yellow = image_np.copy()
            yellow[:, :, 0] = 0
            st.image(yellow, caption="Image Jaune", use_container_width=True)

    elif menu_option == "Cropping":
        st.subheader("Cropping")

        x1 = st.number_input("x1", 0, image_np.shape[1] - 1, step=1)
        y1 = st.number_input("y1", 0, image_np.shape[0] - 1, step=1)
        x2 = st.number_input("x2", 1, image_np.shape[1], step=1)
        y2 = st.number_input("y2", 1, image_np.shape[0], step=1)

        cropped = image_np[int(y1):int(y2), int(x1):int(x2)]
        st.image(cropped, caption="Image Croppée", use_container_width=True)

    elif menu_option == "Rotation":
        st.subheader("Rotation")

        angle = st.selectbox("Angle de rotation", [45, 90, 180])

        rows, cols, _ = image_np.shape
        rotation_matrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1)
        rotated = cv2.warpAffine(image_np, rotation_matrix, (cols, rows))
        st.image(rotated, caption=f"Image Rotée de {angle} degrés", use_container_width=True)

    elif menu_option == "Floutage":
        st.subheader("Floutage")

        blur_level = st.slider("Niveau de flou (k)", min_value=1, max_value=51, step=2, value=15)
        blurred = cv2.GaussianBlur(image_np, (blur_level, blur_level), 0)
        st.image(blurred, caption=f"Image Floutée (k={blur_level})", use_container_width=True)

    elif menu_option == "Contours":
        st.subheader("Contours")

        gray = cv2.cvtColor(image_np, cv2.COLOR_BGR2GRAY)
        edges = cv2.Canny(gray, 100, 200)
        st.image(edges, caption="Contours de l'Image", use_container_width=True)

    elif menu_option == "Génération de Code-barres et QR Code":
        st.subheader("Génération de Code-barres et QR Code")
        link = st.text_input("Entre un lien ou un texte pour générer le code-barres et le QR code")
        if link:
            barcode_image = generate_barcode(link)
            st.image(barcode_image, caption="Code-barres généré", use_container_width=True)

            qrcode_image = generate_qrcode(link)
            st.image(qrcode_image, caption="QR Code généré", use_container_width=True)
        else:
            st.error("Veuillez entrer un lien valide pour générer les codes.")

    elif menu_option == "Détection Faciale":
        st.subheader("Détection Faciale")

        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")

        detection_option = st.radio(
            "Choisis la source pour la détection faciale",
            options=["Webcam", "Vidéo téléversée"]
        )

        if detection_option == "Webcam":
            if st.button("Lancer la détection via webcam"):
                cap = cv2.VideoCapture(0)

                if not cap.isOpened():
                    st.error("Impossible d'accéder à la webcam, Hugging Face et le navigateur bloquent l'accès.")
                else:
                    st.info("Appuyez sur Ctrl+C pour arrêter la détection.")
                    frame_placeholder = st.empty()

                    while True:
                        ret, frame = cap.read()
                        if not ret:
                            st.error("Erreur lors de la capture vidéo.")
                            break

                        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

                        for (x, y, w, h) in faces:
                            cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                        frame_placeholder.image(frame, channels="RGB", use_container_width=True)

                    cap.release()

        elif detection_option == "Vidéo téléversée":
            uploaded_video = st.file_uploader("Charge une vidéo", type=["mp4", "avi", "mov"])
            if uploaded_video is not None:
                video_bytes = uploaded_video.read()
                tfile = tempfile.NamedTemporaryFile(delete=False)
                tfile.write(video_bytes)
                tfile.close()

                cap = cv2.VideoCapture(tfile.name)
                frame_placeholder = st.empty()

                while cap.isOpened():
                    ret, frame = cap.read()
                    if not ret:
                        break

                    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

                    for (x, y, w, h) in faces:
                        cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    frame_placeholder.image(frame, channels="RGB", use_container_width=True)

                cap.release()

if __name__ == "__main__":
    main()