Delete app.py

app.py

@@ -1,962 +0,0 @@
-# -*- coding: utf-8 -*-
-"""AdAnalyst_Mar30_logo
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1Xh3cPajDxLv2WzsW6te3eN2JO6inFYvg
-
-#0. Install Libraries (Restart runtime at the end of the download and start running from step1)
-"""
-
-"""#1. Import Libraries"""
-
-# Download the Dutch language corpus for textblob-nl
-import nltk
-nltk.download('alpino')
-import gradio as gr
-import torch
-import torchvision.transforms as transforms
-from PIL import Image, ImageDraw
-import timm
-import numpy as np
-import cv2
-import pandas as pd
-import re
-from textblob import TextBlob
-from textblob_nl import PatternTagger, PatternAnalyzer
-from sklearn.cluster import KMeans
-import math
-from ultralytics import YOLO
-import easyocr
-import sys
-import os
-import zipfile
-from deepface import DeepFace
-
-"""#2. Dictionaries"""
-
-# Define regex pattern for URLs
-url_pattern = re.compile(
-    r'(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|'
-    r'(?:%[0-9a-fA-F][0-9a-fA-F]))+|www\.(\w+\.)+\w+|(\w+\.)+(nl|com))'
-)
-
-# Define lists for price indications, promotions, calls to action, and car brands
-price_indications = [r'\u20AC', '€', 'EUR', 'euro', 'euros']
-
-
-promotion_words = ['korting', 'aanbieding', 'uitverkoop', 'prijsverlaging', 'afprijzing', 'voordeel',
-          'prijsbewust', 'goedkoop', 'besparing', 'tegen een lage prijs', 'speciale aanbieding',
-          'prijsvermindering', 'kortingbon', 'promotiecode', 'actie', 'actieprijs', 'tijdelijke aanbieding',
-          'nu met korting', 'extra voordelig', 'beste deal', 'flash sale', 'superaanbieding', 'seizoensuitverkoop',
-          'nu extra voordelig', 'nu met voordeel', 'exclusieve korting', 'laatste kans', 'tweede gratis', 'koopje',
-          'knalprijs', 'megakorting', 'laagste prijs']
-
-call_to_action_phrases = ['bezoek', 'ga naar', 'dealer', 'showroom', 'garage', 'proefrit', 'testrit',
-              'probeer', 'bestel nu', 'koop nu', 'reserveren', 'vraag een offerte aan', 'configureren',
-              'ontdek meer', 'bekijk de aanbieding', 'registreer voor updates', 'neem contact op voor meer informatie',
-              'kom langs', 'start hier', 'doe een aanbetaling', 'ontvang een brochure', 'financieringsmogelijkheden',
-              'vraag om een demo', 'bestel vandaag nog', 'nu kopen', 'nu reserveren', 'meld je aan', 'schrijf je in',
-              'maak een afspraak', 'bel ons', 'neem contact op', 'plan je testrit', 'configureer je auto', 'klik hier',
-              'vraag een proefrit aan', 'vraag een offerte', 'doe mee', 'check het aanbod', 'registreer nu', 'nu ontdekken',
-              'bekijk onze modellen', 'bezoek onze website', 'vraag informatie aan', 'aanbetaling', 'aanvraag', 'aanvragen', 'afspraak',
-              'bekijk', 'bel', 'bestel', 'contact', 'configureer', 'demo', 'doe', 'download', 'financieringsmogelijkheden', 'info',
-              'informatie', 'kom', 'koop', 'laat je gegevens achter', 'maak', 'meld', 'neem', 'nu', 'offerte', 'ontdek', 'ontvang',
-              'plan', 'probeer', 'registreer', 'reserveren', 'schrijf', 'start', 'vraag', 'website']
-
-# Expanded list of major car brands
-car_brands = [
-    'ARCFOX', 'Acura', 'Aion', 'Alfa Romeo', 'Apollo', 'Artega', 'Aston Martin', 'Audi',
-    'BAC', 'BAIC', 'BMW', 'BYD', 'Baojun', 'Beijing', 'Bentley', 'Bestune', 'Bugatti',
-    'Buick', 'Cadillac', 'Caterham', 'Changan', 'Chery', 'Chevrolet', 'Chrysler', 'Citroën',
-    'Cupra', 'Daewoo', 'Dacia', 'Dodge', 'Dongfeng', 'DS Automobiles', 'Ferrari', 'Fiat',
-    'Fisker', 'Ford', 'GAC', 'GAZ', 'GMC', 'Geely', 'Genesis', 'Great Wall', 'Gumpert',
-    'Haval', 'Holden', 'Honda', 'Hongqi', 'Hozon Auto', 'Hummer', 'Hyundai', 'Infiniti',
-    'Isuzu', 'JAC', 'Jaguar', 'Jeep', 'Kia', 'Koenigsegg', 'LEVC', 'LINCOLN', 'Lamborghini',
-    'Land Rover', 'Leapmotor', 'Lexus', 'Li Auto', 'Lincoln', 'Lucid', 'Luxgen', 'Lynk & Co',
-    'MG', 'MINI', 'Mahindra', 'Maserati', 'Mazda', 'McLaren', 'Mercedes', 'Mercury',
-    'Mini', 'Mitsubishi', 'Morgan', 'NIO', 'Nissan', 'Noble', 'Oldsmobile', 'Opel',
-    'ORA', 'Pagani', 'Peugeot', 'Perodua', 'Polestar', 'Pontiac', 'Porsche', 'Proton',
-    'Ram', 'Reno', 'Rezvani', 'Rimac', 'Rivian', 'Rolls-Royce', 'Roewe', 'Saab', 'Saturn',
-    'SAIC', 'SEAT', 'SSC North America', 'Skoda', 'Smart', 'Spyker', 'SsangYong',
-    'Subaru', 'Suzuki', 'Tank', 'Tata', 'Tesla', 'Toyota', 'Trumpchi', 'VinFast', 'Volkswagen',
-    'Volvo', 'WEY', 'W Motors', 'Wiesmann', 'Xpeng', 'Zeekr'
-]
-
-# COCO class names
-coco_classes = {
-    0: "person",
-    1: "bicycle",
-    2: "car",
-    3: "motorcycle",
-    4: "airplane",
-    5: "bus",
-    6: "train",
-    7: "truck",
-    8: "boat",
-    9: "traffic light",
-    10: "fire hydrant",
-    11: "stop sign",
-    12: "parking meter",
-    13: "bench",
-    14: "bird",
-    15: "cat",
-    16: "dog",
-    17: "horse",
-    18: "sheep",
-    19: "cow",
-    20: "elephant",
-    21: "bear",
-    22: "zebra",
-    23: "giraffe",
-    24: "backpack",
-    25: "umbrella",
-    26: "handbag",
-    27: "tie",
-    28: "suitcase",
-    29: "frisbee",
-    30: "skis",
-    31: "snowboard",
-    32: "sports ball",
-    33: "kite",
-    34: "baseball bat",
-    35: "baseball glove",
-    36: "skateboard",
-    37: "surfboard",
-    38: "tennis racket",
-    39: "bottle",
-    40: "wine glass",
-    41: "cup",
-    42: "fork",
-    43: "knife",
-    44: "spoon",
-    45: "bowl",
-    46: "banana",
-    47: "apple",
-    48: "sandwich",
-    49: "orange",
-    50: "broccoli",
-    51: "carrot",
-    52: "hot dog",
-    53: "pizza",
-    54: "donut",
-    55: "cake",
-    56: "chair",
-    57: "couch",
-    58: "potted plant",
-    59: "bed",
-    60: "dining table",
-    61: 'toilet',
-    62: 'tv',
-    63: 'laptop',
-    64: 'mouse',
-    65: 'remote',
-    66: 'keyboard',
-    67: 'cell phone',
-    68: 'microwave',
-    69: 'oven',
-    70: 'toaster',
-    71: 'sink',
-    72: 'refrigerator',
-    73: 'book',
-    74: 'clock',
-    75: 'vase',
-    76: 'scissors',
-    77: 'teddy bear',
-    78: 'hair drier',
-    79: 'toothbrush'
-}
-
-# Object categories as per your request
-animal_classes = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
-transportation_classes = [1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
-sports_classes = [29, 30, 31, 32, 33, 34, 35, 36, 37, 38]
-food_classes = [39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 60, 68, 69, 70, 71, 72]
-
-"""#3. Function Modules
-
-## Uniqueness and Consistency
-"""
-
-# 1. Compute image embedding
-# Load the pre-trained ViT model
-def load_vit_model():
-    model = timm.create_model('vit_base_patch16_224', pretrained=True, num_classes=0)
-    model.eval()
-    return model
-
-vit_model = load_vit_model()
-
-# Define image preprocessing steps
-def get_preprocess_transforms():
-    return transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(224),
-        transforms.ToTensor(),
-        transforms.Normalize(
-            mean=(0.5, 0.5, 0.5),
-            std=(0.5, 0.5, 0.5)
-        )
-    ])
-
-preprocess = get_preprocess_transforms()
-
-def compute_image_embedding(image, model, preprocess):
-    input_tensor = preprocess(image).unsqueeze(0)
-    with torch.no_grad():
-        embedding = model(input_tensor)
-    return embedding.squeeze()
-
-# 2. Get embeddings from files
-def get_embeddings_from_files(file_list, model, preprocess):
-    embeddings = []
-    for file_obj in file_list:
-        image = Image.open(file_obj.name).convert('RGB')
-        embedding = compute_image_embedding(image, model, preprocess)
-        embeddings.append(embedding)
-    return embeddings
-
-# 3. Calculate similarity scores
-def calculate_similarity_scores(focus_embedding, embeddings_list):
-    from torch.nn.functional import cosine_similarity
-    similarities = []
-    for emb in embeddings_list:
-        sim = cosine_similarity(focus_embedding.unsqueeze(0), emb.unsqueeze(0)).item()
-        similarities.append(sim)
-    average_score = sum(similarities) / len(similarities) if similarities else None
-    return round(average_score, 4) if average_score is not None else 'None'
-
-"""## OCR"""
-
-# Extract textual features
-
-# load EasyOCTR model
-reader = easyocr.Reader(['nl','en'], gpu=False)
-
-def extract_textual_features(image):
-
-    width, height = image.size
-    image_area = width * height
-
-    image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-
-    #reader = easyocr.Reader(['nl', 'en'], gpu=False)
-
-    results = reader.readtext(image_cv)
-
-    extracted_text_list = []
-    total_text_area = 0
-
-    mask = np.zeros((height, width), dtype=np.uint8)
-
-    for (bbox, text, prob) in results:
-        if text.strip():
-            extracted_text_list.append(text)
-
-            points = np.array(bbox, dtype=np.int32)
-            polygon = []
-            for point in points:
-                polygon.append((int(point[0]), int(point[1])))
-
-            temp_mask = Image.new('L', (width, height), 0)
-            ImageDraw.Draw(temp_mask).polygon(polygon, outline=1, fill=1)
-            temp_array = np.array(temp_mask)
-            mask = np.logical_or(mask, temp_array).astype(np.uint8) * 255
-
-    extracted_text = ' '.join(extracted_text_list).strip()
-
-    num_char = len(extracted_text.replace(" ", ""))
-
-    text_area = np.sum(mask > 0)
-    text_area_ratio = text_area / image_area if image_area > 0 else 0
-    text_area_ratio = round(text_area_ratio, 4)
-
-    return extracted_text, num_char, text_area_ratio
-
-# 5. Perform sentiment analysis
-def perform_sentiment_analysis(text):
-    if text.strip():
-        blob = TextBlob(text, pos_tagger=PatternTagger(), analyzer=PatternAnalyzer())
-        sentiment = blob.sentiment
-        sentiment_polarity = round(sentiment[0], 4)
-        sentiment_subjectivity = round(sentiment[1], 4)
-    else:
-        sentiment_polarity = 0.0
-        sentiment_subjectivity = 0.0
-    return sentiment_polarity, sentiment_subjectivity
-
-# 6. Analyze additional textual features
-def analyze_additional_text_features(text):
-    # URL Count
-    urls = re.findall(url_pattern, text)
-    url_count = len(urls)
-
-    # Price Indication Count
-    price_count = sum(text.lower().count(word.lower()) for word in price_indications)
-
-    # Promotion Indication Count
-    promotion_count = sum(text.lower().count(word.lower()) for word in promotion_words)
-
-    # Call to Action Count
-    call_to_action_count = sum(text.lower().count(phrase.lower()) for phrase in call_to_action_phrases)
-
-    # Brand Salience Count
-    brand_count = sum(text.lower().count(brand.lower()) for brand in car_brands)
-
-    return url_count, price_count, promotion_count, call_to_action_count, brand_count
-
-"""## Basci Visual Features"""
-
-# Function to convert RGB to Hex
-def rgb_to_hex(color):
-    return '#%02x%02x%02x' % tuple(color)
-
-#  Get dominant color
-def get_dominant_color(image, k=4):
-    # Resize image to reduce computation time
-    image = image.resize((150, 150))
-    # Convert image to numpy array
-    np_image = np.array(image)
-    np_image = np_image.reshape((np_image.shape[0]*np_image.shape[1], 3))
-    # Use KMeans clustering
-    kmeans = KMeans(n_clusters=k)
-    kmeans.fit(np_image)
-    # Get the cluster centers
-    colors = kmeans.cluster_centers_
-    # Get counts of pixels in each cluster
-    labels, counts = np.unique(kmeans.labels_, return_counts=True)
-    # Find the most frequent color
-    dominant_color = colors[np.argmax(counts)]
-    # Convert to int and to hex
-    dominant_color = dominant_color.astype(int)
-    dominant_color_hex = rgb_to_hex(dominant_color)
-    return dominant_color_hex, tuple(dominant_color)
-
-# Extract visual features
-def extract_visual_features(image):
-    # Image resolution
-    width, height = image.size
-
-    # Average RGB values
-    np_image = np.array(image)
-    avg_r = np.mean(np_image[:, :, 0])
-    avg_g = np.mean(np_image[:, :, 1])
-    avg_b = np.mean(np_image[:, :, 2])
-
-    # Dominant color
-    dominant_color_hex, dominant_color_rgb = get_dominant_color(image)
-
-    # Warm/cold hue
-    # Convert image to HSV
-    hsv_image = image.convert('HSV')
-    np_hsv = np.array(hsv_image)
-    avg_hue = np.mean(np_hsv[:, :, 0])
-    # Convert hue from 0-255 to degrees
-    avg_hue_deg = avg_hue * 360 / 255
-    # Determine warm or cold
-    # Warm colors are from 0-60 and 300-360 degrees
-    if (0 <= avg_hue_deg <= 60) or (300 <= avg_hue_deg <= 360):
-        hue_category = 'Warm'
-    else:
-        hue_category = 'Cool'
-
-    # Visual complexity (Shannon entropy)
-    # Convert image to grayscale
-    gray_image = image.convert('L')
-    histogram = gray_image.histogram()
-    histogram_length = sum(histogram)
-    samples_probability = [float(h) / histogram_length for h in histogram if h != 0]
-    entropy = -sum([p * math.log(p, 2) for p in samples_probability])
-
-    # Return the computed features
-    return {
-        'Resolution': f'{width}x{height}',
-        'Dominant Color': dominant_color_hex,
-        'Dominant Color RGB': dominant_color_rgb,
-        'Hue Category': hue_category,
-        'Average Red': round(avg_r, 2),
-        'Average Green': round(avg_g, 2),
-        'Average Blue': round(avg_b, 2),
-        'Visual Complexity': round(entropy, 4)
-    }
-
-"""## YOLO: Perform object detection"""
-
-# Load YOLO model
-def load_yolo_model():
-    model = YOLO('yolo11m.pt')  # Using YOLO medium model
-    return model
-
-yolo_model = load_yolo_model()
-
-# QR code
-detector = cv2.QRCodeDetector()
-
-def perform_object_detection(image_pil):
-    image_area = image.size[0] * image.size[1]
-
-    np_image = np.array(image_pil)
-    np_image_bgr = cv2.cvtColor(np_image, cv2.COLOR_RGB2BGR)
-
-    retval, decoded_info, points, _ = detector.detectAndDecodeMulti(np_image_bgr)
-    qr_code_count = len(decoded_info)
-
-    # Run YOLO model
-    results = yolo_model(np_image_bgr)
-
-    detections = results[0]
-    boxes = detections.boxes  # Bounding boxes
-    class_ids = boxes.cls.cpu().numpy().astype(int)
-    confidences = boxes.conf.cpu().numpy()
-    xyxy = boxes.xyxy.cpu().numpy()  # Bounding box coordinates
-
-    # Initialize counts and areas
-    car_count = 0
-    car_coverage_area = 0
-    car_positions = []
-
-    person_count = 0
-    animal_count = 0
-    transportation_count = 0
-    sports_item_count = 0
-    food_item_count = 0
-
-
-
-    for cls_id, conf, bbox in zip(class_ids, confidences, xyxy):
-        class_name = coco_classes.get(cls_id, 'Unknown')
-        bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
-
-        if cls_id == 2:  # Car class
-            car_count += 1
-            car_coverage_area += bbox_area
-            # Determine position
-            x_center = (bbox[0] + bbox[2]) / 2
-            y_center = (bbox[1] + bbox[3]) / 2
-            if x_center < image.size[0] / 2 and y_center < image.size[1] / 2:
-                position = 'Top-Left'
-            elif x_center >= image.size[0] / 2 and y_center < image.size[1] / 2:
-                position = 'Top-Right'
-            elif x_center < image.size[0] / 2 and y_center >= image.size[1] / 2:
-                position = 'Bottom-Left'
-            else:
-                position = 'Bottom-Right'
-            car_positions.append(position)
-        elif cls_id == 0:
-            person_count += 1
-        elif cls_id in animal_classes:
-            animal_count += 1
-        elif cls_id in transportation_classes:
-            transportation_count += 1
-        elif cls_id in sports_classes:
-            sports_item_count += 1
-        elif cls_id in food_classes:
-            food_item_count += 1
-
-    # Calculate coverage area ratio
-    car_coverage_ratio = car_coverage_area / image_area if image_area > 0 else 0
-    car_coverage_ratio = round(car_coverage_ratio, 4)
-
-    # Get unique positions
-    unique_positions = list(set(car_positions))
-
-    return {
-        'Car Count': car_count,
-        'Car Coverage Ratio': car_coverage_ratio,
-        'Car Positions': ', '.join(unique_positions) if unique_positions else 'None',
-        'Person Count': person_count,
-        'Animal Object Count': animal_count,
-        'Transportation Object Count': transportation_count,
-        'Sports Item Count': sports_item_count,
-        'Food Item Count': food_item_count,
-        'QR Code Count': qr_code_count
-    }
-
-"""## Logo"""
-
-# Commented out IPython magic to ensure Python compatibility.
-if not os.path.exists("yolov7"):
-    with zipfile.ZipFile("yolov7.zip", 'r') as zip_ref:
-        zip_ref.extractall(".")
-print("files", os.listdir("."))
-sys.path.append("./yolov7")
-logo_model = torch.hub.load('./yolov7', 'custom', './logo_detection.pt', source='local')
-logo_model.conf = 0.25
-
-def detect_logos(pil_image):
-
-    image_np = np.array(pil_image)
-    results = logo_model(image_np)
-
-    # results.xyxy[0]  [x1, y1, x2, y2, conf, cls]
-    detections = results.xyxy[0].cpu().numpy() if results.xyxy[0] is not None else np.empty((0, 6))
-
-    logo_count = detections.shape[0]
-    total_logo_area = 0
-    positions = []
-
-    img_height, img_width = image_np.shape[0], image_np.shape[1]
-    image_area = img_height * img_width
-
-    for det in detections:
-        x1, y1, x2, y2, conf, cls = det
-        box_area = (x2 - x1) * (y2 - y1)
-        total_logo_area += box_area
-
-        center_x = (x1 + x2) / 2
-        center_y = (y1 + y2) / 2
-
-        if center_x < img_width / 3:
-            horiz = 'Left'
-        elif center_x < 2 * img_width / 3:
-            horiz = 'Center'
-        else:
-            horiz = 'Right'
-
-        if center_y < img_height / 3:
-            vert = 'Top'
-        elif center_y < 2 * img_height / 3:
-            vert = 'Middle'
-        else:
-            vert = 'Bottom'
-
-        positions.append(f"{vert}-{horiz}")
-
-    logo_area_ratio = total_logo_area / image_area if image_area > 0 else 0
-    logo_area_ratio = round(logo_area_ratio,4)
-
-    unique_positions = list(dict.fromkeys(positions))
-    positions_str = ", ".join(unique_positions)
-
-    return {
-        'Logo Count': logo_count,
-        'Logo Coverage Ratio': logo_area_ratio,
-        'Logo Positions': positions_str}
-
-
-def analyze_face_features(image, confidence_threshold=0.3):
-    #GDPR -- exclude gender and race inference
-
-    # BGR format for deepface
-    image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-
-    results = DeepFace.analyze(
-        img_path=image_cv,
-        actions=['emotion'],
-        detector_backend='retinaface',
-        enforce_detection=False
-    )
-
-    # list format
-    if not isinstance(results, list):
-        results = [results]
-
-    # return none if no face detected
-    if not results:
-        return {
-            "angry": 0,
-            "disgust": 0,
-            "fear": 0,
-            "happy": 0,
-            "sad": 0,
-            "surprise": 0,
-            "neutral": 0}
-
-    # Filter out low confidence detections
-    filtered_results = []
-    for face in results:
-        # Check for face_confidence key specifically based on your output
-        if 'face_confidence' in face and face['face_confidence'] >= confidence_threshold:
-            filtered_results.append(face)
-
-    # If no faces meet confidence threshold, return zeros
-    if not filtered_results:
-        return {
-            "angry": 0,
-            "disgust": 0,
-            "fear": 0,
-            "happy": 0,
-            "sad": 0,
-            "surprise": 0,
-            "neutral": 0}
-
-    # initiation
-    emotions_sum = {
-        "angry": 0,
-        "disgust": 0,
-        "fear": 0,
-        "happy": 0,
-        "sad": 0,
-        "surprise": 0,
-        "neutral": 0
-    }
-
-    # process faces
-    for face in filtered_results:
-        for emotion, value in face['emotion'].items():
-            emotion_lower = emotion.lower()
-            if emotion_lower in emotions_sum:
-                emotions_sum[emotion_lower] += value
-
-    # average emtions
-    num_faces = len(filtered_results)
-    avg_emotions = {emotion: round(value / num_faces, 2) for emotion, value in emotions_sum.items()}
-
-    result = {
-        "angry": avg_emotions["angry"],
-        "disgust": avg_emotions["disgust"],
-        "fear": avg_emotions["fear"],
-        "happy": avg_emotions["happy"],
-        "sad": avg_emotions["sad"],
-        "surprise": avg_emotions["surprise"],
-        "neutral": avg_emotions["neutral"],
-    }
-
-    return result
-
-"""# 4. Run all analysis"""
-
-# Process image and compute all features
-def process_image(focal_image, same_brand_files, competitive_brand_files):
-    # Input validation
-    if focal_image is None:
-        return ["Please upload the focal ad."] + [""] * 23  # Adjusted for total outputs
-
-    # Compute embeddings
-    focus_embedding = compute_image_embedding(focal_image, vit_model, preprocess)
-
-    # Calculate scores
-    if same_brand_files:
-        same_brand_embeddings = get_embeddings_from_files(same_brand_files, vit_model, preprocess)
-        consistency_score = calculate_similarity_scores(focus_embedding, same_brand_embeddings)
-        consistency_score = round(consistency_score, 4)
-    else:
-        consistency_score = 'None'
-
-    if competitive_brand_files:
-        competitive_brand_embeddings = get_embeddings_from_files(competitive_brand_files, vit_model, preprocess)
-        uniqueness_score = 1- calculate_similarity_scores(focus_embedding, competitive_brand_embeddings)
-        uniqueness_score = round(uniqueness_score, 4)
-    else:
-        uniqueness_score = 'None'
-
-    # Calculate ad_elasticity
-    if consistency_score != 'None' and uniqueness_score != 'None':
-        ad_elasticity = round(0.021 + 0.097*consistency_score + 0.110*uniqueness_score, 4)
-    else:
-        ad_elasticity = 'None'  # Handle missing values gracefully    
-
-    # Extract textual features
-    extracted_text, num_char, text_area_ratio = extract_textual_features(focal_image)
-
-    # Sentiment analysis
-    sentiment_polarity, sentiment_subjectivity = perform_sentiment_analysis(extracted_text)
-
-    # Analyze additional textual features
-    url_count, price_count, promotion_count, call_to_action_count, brand_salience_count = analyze_additional_text_features(extracted_text)
-
-    # Extract visual features
-    visual_features = extract_visual_features(focal_image)
-    # Unpack visual features
-    resolution = visual_features['Resolution']
-    dominant_color = visual_features['Dominant Color']
-    dominant_color_rgb = visual_features['Dominant Color RGB']
-    hue_category = visual_features['Hue Category']
-    avg_r = visual_features['Average Red']
-    avg_g = visual_features['Average Green']
-    avg_b = visual_features['Average Blue']
-    visual_complexity = visual_features['Visual Complexity']
-
-    # Perform object detection
-    object_detection_results = perform_object_detection(focal_image)
-    # Unpack object detection results
-    car_count = object_detection_results['Car Count']
-    car_coverage_ratio = object_detection_results['Car Coverage Ratio']
-    car_positions = object_detection_results['Car Positions']
-    person_count = object_detection_results['Person Count']
-    animal_count = object_detection_results['Animal Object Count']
-    transportation_count = object_detection_results['Transportation Object Count']
-    sports_item_count = object_detection_results['Sports Item Count']
-    food_item_count = object_detection_results['Food Item Count']
-    qr_code_count = object_detection_results['QR Code Count']
-
-    # Perform logo detection
-    logo_detection_results = detect_logos(focal_image)
-    # Unpack logo detection results
-    logo_count = logo_detection_results['Logo Count']
-    logo_area_ratio = logo_detection_results['Logo Coverage Ratio']
-    logo_positions = logo_detection_results['Logo Positions']
-
-    #emtion
-    emotion_results = analyze_face_features(focal_image)
-    emo_angry = emotion_results["angry"]
-    emo_disgust = emotion_results["disgust"]
-    emo_fear =  emotion_results["fear"]
-    emo_happy = emotion_results["happy"]
-    emo_sad = emotion_results["sad"]
-    emo_surprise = emotion_results["surprise"]
-    emo_neutral = emotion_results["neutral"]
-    
-
-    # Return all outputs
-    return [
-        uniqueness_score,
-        consistency_score,
-        ad_elasticity,
-        resolution,
-        dominant_color,
-        hue_category,
-        avg_r,
-        avg_g,
-        avg_b,
-        visual_complexity,
-        car_count,
-        car_coverage_ratio,
-        car_positions,
-        logo_count,
-        logo_area_ratio,
-        logo_positions,
-        person_count,
-        animal_count,
-        transportation_count,
-        sports_item_count,
-        food_item_count,
-        qr_code_count,
-        num_char,
-        text_area_ratio,
-        sentiment_polarity,
-        sentiment_subjectivity,
-        url_count,
-        price_count,
-        promotion_count,
-        call_to_action_count,
-        brand_salience_count,
-        emo_angry,
-        emo_disgust,
-        emo_fear,
-        emo_happy,
-        emo_sad,
-        emo_surprise,
-        emo_neutral
-    ]
-
-import cv2, requests
-image = cv2.imdecode(np.frombuffer(requests.get("https://github.com/JaidedAI/EasyOCR/raw/master/examples/english.png").content, np.uint8), cv2.IMREAD_COLOR)
-
-image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-image = image.convert('RGB')
-image
-
-process_image(image, None, None)
-
-"""#5. Gradio Interface"""
-
-def get_score_card(value, title, thresholds, colors, labels):
-    try:
-        value = float(value)
-        position = 10  # default
-        for i, th in enumerate(thresholds):
-            if value < th:
-                position = 10 + i * 20
-                break
-        else:
-            position = 90
-    except (ValueError, TypeError):
-        return f"<div style='color:gray;'>{title}: N/A</div>"
-
-    color_bars = "".join([f"<div style='width:{100/len(colors)}%; background-color:{c};'></div>" for c in colors])
-    
-    return f"""
-    <div style='border-radius:15px; padding:20px; background:#F9F9F9; box-shadow:0 4px 10px rgba(0,0,0,0.1);'>
-        <div style='font-size:18px; font-weight:bold; margin-bottom:10px;'>{title}: {value:.2f}</div>
-        <div style='position:relative; height:40px;'>
-            <div style='display:flex; height:16px; border-radius:8px; overflow:hidden;'>
-                {color_bars}
-            </div>
-            <div style='position:absolute; top:18px; left:{position}%; transform:translateX(-50%);'>
-                <div style='width:0;height:0;border-left:8px solid transparent;border-right:8px solid transparent;border-top:12px solid black;'></div>
-            </div>
-        </div>
-        <div style='display:flex; justify-content:space-between; margin-top:8px; font-size:14px;'>
-            {"".join([f"<span>{l}</span>" for l in labels])}
-        </div>
-    </div>
-    """
-
-
-def get_consistency_card(value):
-    return get_score_card(
-        value=value,
-        title="Consistency Score (within brand ad similarity)",
-        thresholds=[0.1736, 0.3003, 0.5538, 0.6806],  # +- 1 or 2 SD
-        colors=["#FF4C4C", "#FFA500", "#FFD700", "#90EE90", "#008000"],
-        labels=["Poor", "Low", "Avg", "Good", "Exc"]
-    )
-
-
-def get_distinctiveness_card(value):
-    return get_score_card(
-        value=value,
-        title="Uniqueness Score (between brand ad dissimilarity)",
-        thresholds=[0.3937, 0.5000, 0.7125, 0.8187],
-        colors=["#FF4C4C", "#FFA500", "#FFD700", "#90EE90", "#008000"],
-        labels=["Poor", "Low", "Avg", "Good", "Exc"]
-    )
-
-
-def get_elasticity_card(value):
-    return get_score_card(
-        value=value,
-        title="Ad Elasticity",
-        thresholds=[0.08, 0.12, 0.16, 0.20],
-        colors=["#FF4C4C", "#FFA500", "#FFD700", "#90EE90", "#008000"],
-        labels=["Poor", "Low", "Avg", "Good", "Exc"],
-    )
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Ad Analyst")
-
-    # Input Components
-    with gr.Row():
-        focal_ad = gr.Image(type='pil', label='Focal Ad', height=200)
-        same_brand_ads = gr.File(file_types=['image'], label='Same Brand Ads', file_count='multiple')
-        competitive_brand_ads = gr.File(file_types=['image'], label='Competitive Brand Ads', file_count='multiple')
-    run_button = gr.Button('Run Analysis')
-
-    # Output Components
-    gr.Markdown("## Comprehensive Indexes")
-    with gr.Row():
-        distinctiveness_score = gr.HTML(label='Uniqueness Score (between brand ad dissimilarity)')
-        consistency_score = gr.HTML(label='Consistency Score (within brand ad similarity)')
-        ad_elasticity = gr.HTML(label='Ad Elasticity')
-
-    gr.Markdown("## Visual Features")
-    with gr.Row():
-        resolution_output = gr.Textbox(label='Resolution')
-        dominant_color_output = gr.Textbox(label='Dominant Color')
-        dominant_color_indicator = gr.ColorPicker(label='Color Indicator', value='#FFFFFF')
-        hue_category_output = gr.Textbox(label='Hue Category')
-    with gr.Row():
-        avg_r_output = gr.Textbox(label='Average Red')
-        avg_g_output = gr.Textbox(label='Average Green')
-        avg_b_output = gr.Textbox(label='Average Blue')
-        visual_complexity_output = gr.Textbox(label='Visual Complexity')
-    gr.Markdown("## Object Detection")
-    with gr.Row():
-        car_count_output = gr.Textbox(label='Car Count')
-        car_coverage_ratio_output = gr.Textbox(label='Car Coverage Ratio')
-        car_positions_output = gr.Textbox(label='Car Positions')
-    with gr.Row():
-        logo_count_output = gr.Textbox(label='Logo Count')
-        logo_coverage_ratio_output = gr.Textbox(label='Logo Coverage Ratio')
-        logo_positions_output = gr.Textbox(label='Logo Positions')
-    with gr.Row():
-        person_count_output = gr.Textbox(label='Person Count')
-        animal_count_output = gr.Textbox(label='Animal Object Count')
-        transportation_count_output = gr.Textbox(label='Transportation Object Count')
-    with gr.Row():
-        sports_item_count_output = gr.Textbox(label='Sports Item Count')
-        food_item_count_output = gr.Textbox(label='Food Item Count')
-        qr_code_count_output = gr.Textbox(label='QR Code Count')  # QR code count output
-        
-    gr.Markdown("## Textual Features")
-    with gr.Row():
-        num_char = gr.Textbox(label='Character Count')
-        text_area_ratio = gr.Textbox(label='Text Area Ratio')
-        sentiment_polarity_output = gr.Textbox(label='Sentiment Polarity')
-
-    with gr.Row():
-        subjectivity_output = gr.Textbox(label='Subjectivity')
-        url_count_output = gr.Textbox(label='URL Count')
-        price_indication_count_output = gr.Textbox(label='Price Indication Count')
-
-    with gr.Row():
-        promotion_indication_count_output = gr.Textbox(label='Promotion Indication Count')
-        call_to_action_count_output = gr.Textbox(label='Call to Action Count')
-        brand_salience_output = gr.Textbox(label='Brand Salience Count')
-
-    gr.Markdown("## Facial Emotions")
-    with gr.Row():
-        emo_angry_output = gr.Textbox(label='Angry')
-        emo_disgust_output = gr.Textbox(label='Disgust')
-        emo_fear_output = gr.Textbox(label='Fear')
-    with gr.Row():
-        emo_happy_output = gr.Textbox(label='Happy')
-        emo_sad_output = gr.Textbox(label='Sad')
-        emo_surprise_output = gr.Textbox(label='Surprise')
-        emo_neutral_output = gr.Textbox(label='Surprise')
-
-    
-    # Define the function to be called when the button is clicked
-    def process_and_display(focal_image, same_brand_files, competitive_brand_files):
-        # Call the process_image function and get the outputs
-        outputs = process_image(focal_image, same_brand_files, competitive_brand_files)
-        # Set the dominant color indicator
-        dominant_color_hex = outputs[4]
-        dominant_color_indicator = dominant_color_hex if dominant_color_hex else '#FFFFFF'
-        outputs.insert(5, dominant_color_indicator)  # Insert after dominant color output
-
-        ad_elasticity_value = outputs[2]  
-        ad_elasticity_card_html = get_elasticity_card(ad_elasticity_value)
-        outputs[2]=ad_elasticity_card_html
-
-        consistency_score_value = outputs[1]
-        consistency_score_card_html = get_consistency_card(consistency_score_value)
-        outputs[1]=consistency_score_card_html
-
-        distinctiveness_score_value = outputs[0]
-        distinctiveness_score_card_html = get_distinctiveness_card(distinctiveness_score_value)
-        outputs[0]=distinctiveness_score_card_html
-
-        return outputs
-
-    # Set up the event handler
-    run_button.click(
-        fn=process_and_display,
-        inputs=[focal_ad, same_brand_ads, competitive_brand_ads],
-        outputs=[
-            distinctiveness_score,
-            consistency_score,
-            ad_elasticity,
-            resolution_output,
-            dominant_color_output,
-            dominant_color_indicator,
-            hue_category_output,
-            avg_r_output,
-            avg_g_output,
-            avg_b_output,
-            visual_complexity_output,
-            car_count_output,
-            car_coverage_ratio_output,
-            car_positions_output,
-            logo_count_output,
-            logo_coverage_ratio_output,
-            logo_positions_output,
-            person_count_output,
-            animal_count_output,
-            transportation_count_output,
-            sports_item_count_output,
-            food_item_count_output,
-            qr_code_count_output,
-            num_char,
-            text_area_ratio,
-            sentiment_polarity_output,
-            subjectivity_output,
-            url_count_output,
-            price_indication_count_output,
-            promotion_indication_count_output,
-            call_to_action_count_output,
-            brand_salience_output,
-            emo_angry_output,
-            emo_disgust_output,
-            emo_fear_output,
-            emo_happy_output,
-            emo_sad_output,
-            emo_surprise_output,
-            emo_neutral_output
-        ]
-    )
-
-# Launch the app
-demo.launch()