Create app_gradio.py

app_gradio.py

@@ -1,91 +0,0 @@
-import pickle
-import cv2
-import mediapipe as mp
-import numpy as np
-import matplotlib.pyplot as plt
-import gradio as gr
-import time
-from PIL import Image
-import random
-
-# Load model once globally
-model_dict = pickle.load(open('./model.p', 'rb'))
-model = model_dict['model']
-
-mp_hands = mp.solutions.hands
-mp_drawing = mp.solutions.drawing_utils
-mp_drawing_styles = mp.solutions.drawing_styles
-
-# Function to process a single frame
-def predict(input):
-    hands = mp_hands.Hands(static_image_mode=True, min_detection_confidence=0.3)
-    labels_dict =  {0: 'L', 1: 'A', 2: 'B', 3: 'C', 4: 'V', 5: 'W', 6: 'Y'}
-    data_aux = []
-    frame_rgb = cv2.cvtColor(input, cv2.COLOR_BGR2RGB)
-    results = hands.process(frame_rgb)
-    
-    if results.multi_hand_landmarks:
-        for hand_landmarks in results.multi_hand_landmarks:
-            mp_drawing.draw_landmarks(
-                input,
-                hand_landmarks,
-                mp_hands.HAND_CONNECTIONS,
-                mp_drawing_styles.get_default_hand_landmarks_style(),
-                mp_drawing_styles.get_default_hand_connections_style())
-
-            for i in range(len(hand_landmarks.landmark)):
-                x = hand_landmarks.landmark[i].x
-                y = hand_landmarks.landmark[i].y
-                data_aux.append(x)
-                data_aux.append(y)
-    
-    if data_aux:
-        prediction = model.predict([np.asarray(data_aux)])
-        predicted_character = labels_dict[int(prediction[0])]
-        output = cv2.putText(input, f'Sign: {predicted_character}', (5, 30), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 255, 255), 3, cv2.LINE_AA)
-        output_image = Image.fromarray(cv2.cvtColor(output, cv2.COLOR_BGR2RGB))
-        return output_image, predicted_character
-    else:
-        return Image.fromarray(cv2.cvtColor(input, cv2.COLOR_BGR2RGB)), "No hand landmarks detected in the current frame."
-
-# Function to process video
-def vid_inf(vid, progress=gr.Progress()):
-    cap = cv2.VideoCapture(vid)
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    processed_frames = 0
-    writer = None
-    character_output = []
-    tmpname = f"output_{random.randint(111111111, 999999999)}.mp4"
-    
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            break
-        
-        if writer is None:
-            height, width, _ = frame.shape
-            writer = cv2.VideoWriter(tmpname, cv2.VideoWriter_fourcc(*'mp4v'), cap.get(cv2.CAP_PROP_FPS), (width, height))
-        
-        processed_frames += 1
-        progress(processed_frames / total_frames, desc=f"Processing frame {processed_frames}/{total_frames}")
-        out, character = predict(frame)
-        writer.write(cv2.cvtColor(np.array(out), cv2.COLOR_RGB2BGR))
-        character_output.append(character)
-    
-    cap.release()
-    writer.release()
-    return tmpname, character_output
-
-input_video = gr.Video(sources=["webcam", "upload"], label="Input Video")
-output_video = gr.Video(label="Processed Video")
-output_character = gr.Textbox(label="Sign Sequence")
-
-# Create Gradio Interface for Video Inference
-interface_video = gr.Interface(
-    fn=vid_inf,
-    inputs=[input_video],
-    outputs=[output_video, output_character],
-    title="Video Inference"
-)
-
-interface_video.launch(share=True)