app.py

import gradio as gr
import joblib
import numpy as np
import pandas as pd
import cv2
from skimage.color import rgb2hsv
from skimage.measure import shannon_entropy
from scipy.ndimage import generic_filter

# Extract features from the image (same as your previous code)
def extract_features(image_path):
    image = cv2.imread(image_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # Extract RGB means
    meanr = np.mean(image[:, :, 0])  # Red channel
    meang = np.mean(image[:, :, 1])  # Green channel
    meanb = np.mean(image[:, :, 2])  # Blue channel
    
    # Convert to HSI and compute HHR
    hsv_image = rgb2hsv(image)
    hue = hsv_image[:, :, 0]
    high_hue_pixels = np.sum(hue > 0.95)
    total_pixels = hue.size
    HHR = high_hue_pixels / total_pixels
    
    # Convert to Grayscale
    gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
    
    # Compute Entropy
    Ent = shannon_entropy(gray_image)
    
    # Compute Brightness
    B = np.mean(gray_image)
    
    # Sliding window for gray-level features
    def g1_filter(window):
        return window[4] - np.min(window)

    def g2_filter(window):
        return np.max(window) - window[4]

    def g3_filter(window):
        return window[4] - np.mean(window)

    def g4_filter(window):
        return np.std(window)

    def g5_filter(window):
        return window[4]

    # Apply filters with 3x3 window
    g1 = generic_filter(gray_image, g1_filter, size=3).mean()
    g2 = generic_filter(gray_image, g2_filter, size=3).mean()
    g3 = generic_filter(gray_image, g3_filter, size=3).mean()
    g4 = generic_filter(gray_image, g4_filter, size=3).mean()
    g5 = generic_filter(gray_image, g5_filter, size=3).mean()

    # Return features
    return {
        "meanr": meanr,
        "meang": meang,
        "meanb": meanb,
        "HHR": HHR,
        "Ent": Ent,
        "B": B,
        "g1": g1,
        "g2": g2,
        "g3": g3,
        "g4": g4,
        "g5": g5,
    }

# Function to make predictions
def predict_hemoglobin(age, gender, image):
    # Extract features from the image
    features = extract_features(image)  # Use the file path directly
    
    # Add age and gender to the features
    features['age'] = age
    features['gender'] = 1 if gender.lower() == 'male' else 0
    
    # Convert features to DataFrame
    features_df = pd.DataFrame([features])
    
    # Load the pre-trained models
    svr_model = joblib.load('svr_model.pkl')  # SVR model
    scaler = joblib.load('scaler.pkl')        # MinMaxScaler
    label_encoder = joblib.load('label_encoder.pkl')  # LabelEncoder

    # Apply MinMaxScaler transformation
    features_df_scaled = scaler.transform(features_df)
    
    # Make the prediction
    hemoglobin = svr_model.predict(features_df_scaled)[0]
    
    return f"Predicted Hemoglobin Value: {hemoglobin:.2f}"

# Gradio Interface
def gradio_interface():
    with gr.Blocks() as demo:
        gr.Markdown("## Hemoglobin Prediction from Image Features")
        
        with gr.Row():
            age = gr.Number(label="Age", value=25)
            gender = gr.Dropdown(choices=["Male", "Female"], label="Gender", value="Male")
        
        image_input = gr.Image(type="filepath", label="Upload Image (Path to Image)", interactive=True)
        
        output = gr.Textbox(label="Predicted Hemoglobin Value")
        
        # Prediction button
        predict_btn = gr.Button("Predict Hemoglobin")
        
        predict_btn.click(fn=predict_hemoglobin, inputs=[age, gender, image_input], outputs=output)
    
    return demo

# Launch the app
if __name__ == "__main__":
    gradio_interface().launch(share=True)  # Set `share=True` to create a public link