Update app.py

app.py

@@ -1,71 +1,41 @@
-
+import gradio as gr
 import os
-import hashlib
 import random
-import json
-import base64
-from flask import Flask, render_template, request, jsonify, url_for, redirect, session, send_file
-from werkzeug.utils import secure_filename
-import numpy as np
+import hashlib
 from datetime import datetime
-from io import BytesIO
 
-app = Flask(__name__, static_folder="static", template_folder="templates")
-app.secret_key = "fake_logo_detector_secret_key"
-app.config['UPLOAD_FOLDER'] = 'static/uploads'
-app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max upload
+UPLOAD_FOLDER = "uploads"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 
-# Ensure uploads directory exists
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-
-# Store scan history in memory (would use a database in production)
-SCAN_HISTORY = []
-
-# Popular brand logos for more accurate detection
 POPULAR_BRANDS = [
-    "nike", "adidas", "puma", "reebok", "apple", "samsung", 
-    "microsoft", "google", "amazon", "coca-cola", "pepsi",
-    "starbucks", "mcdonald", "gucci", "chanel", "louis vuitton", 
-    "rolex", "ferrari", "lamborghini", "bmw", "mercedes"
+    "nike", "adidas", "puma", "reebok", "apple", "samsung", "microsoft",
+    "google", "amazon", "coca-cola", "pepsi", "starbucks", "mcdonald",
+    "gucci", "chanel", "louis vuitton", "rolex", "ferrari", "lamborghini",
+    "bmw", "mercedes"
 ]
 
+SCAN_HISTORY = []
+
 def allowed_file(filename):
-    """Check if the file extension is allowed"""
-    return '.' in filename and filename.rsplit('.', 1)[1].lower() in {'png', 'jpg', 'jpeg', 'gif'}
+    return filename.split('.')[-1].lower() in {'png', 'jpg', 'jpeg', 'gif'}
+
+def analyze_logo(file):
+    filename = file.name
+    file_path = os.path.join(UPLOAD_FOLDER, filename)
+    with open(file_path, "wb") as f:
+        f.write(file.read())
 
-def analyze_logo(file_path):
-    """
-    Enhanced logo analysis with more sophisticated detection
-    """
-    # Generate a hash of the file for consistent results
     with open(file_path, 'rb') as f:
         file_hash = hashlib.md5(f.read()).hexdigest()
-    
-    # Use the hash to seed the random number generator for consistent results
+
     random.seed(file_hash)
-    
-    # Extract filename without path and extension for brand detection
-    filename = os.path.basename(file_path).lower()
-    brand_detected = False
-    
-    # Check if any popular brand name is in the filename
-    for brand in POPULAR_BRANDS:
-        if brand in filename:
-            brand_detected = True
-            break
-    
-    # Use hash digits to determine outcome with a more balanced approach
-    hash_sum = sum(int(digit, 16) for digit in file_hash[:8])
-    
-    # Logic to determine if the logo is real or fake
-    # Popular brands: 50% real, Other images: 30% real
+
+    brand_detected = any(brand in filename.lower() for brand in POPULAR_BRANDS)
+    hash_sum = sum(int(d, 16) for d in file_hash[:8])
     threshold = 50 if brand_detected else 30
     is_real = hash_sum % 100 < threshold
-    
-    # Generate a realistic confidence score
     confidence = random.randint(92, 99) if is_real else random.randint(85, 97)
-    
-    # Create detailed reasons for counterfeits
+
     reasons = []
     if not is_real:
         possible_reasons = [
@@ -80,119 +50,36 @@ def analyze_logo(file_path):
             "Unauthorized modification of trademark elements",
             "Irregular outline thickness around key elements"
         ]
-        # Select 2-4 reasons randomly for more detailed analysis
-        num_reasons = random.randint(2, 4)
-        reasons = random.sample(possible_reasons, num_reasons)
-    
+        reasons = random.sample(possible_reasons, random.randint(2, 4))
+
     result = {
         "is_real": is_real,
         "confidence": confidence,
-        "reasons": reasons if reasons else None
+        "reasons": reasons
     }
-    
-    return result
 
-def generate_report(scan_id=None):
-    """Generate a PDF report of scan history or a specific scan"""
-    try:
-        # In a real implementation, this would generate an actual PDF
-        # For now, we'll just return success message
-        return {"success": True, "message": "Report generated successfully"}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
+    SCAN_HISTORY.append({
+        "filename": filename,
+        "datetime": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        **result
+    })
 
-@app.route('/')
-def index():
-    return render_template('index.html')
-
-@app.route('/analyze', methods=['POST'])
-def analyze():
-    if 'file' not in request.files:
-        return jsonify({"error": "No file part"}), 400
-    
-    file = request.files['file']
-    
-    if file.filename == '':
-        return jsonify({"error": "No selected file"}), 400
-    
-    if file and allowed_file(file.filename):
-        filename = secure_filename(file.filename)
-        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(file_path)
-        
-        result = analyze_logo(file_path)
-        
-        # Save to history
-        scan_record = {
-            "id": len(SCAN_HISTORY) + 1,
-            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "is_real": result["is_real"],
-            "confidence": result["confidence"],
-            "image_path": file_path.replace('static/', ''),
-            "filename": filename,
-            "reasons": result["reasons"]
-        }
-        SCAN_HISTORY.append(scan_record)
-        
-        return jsonify({
-            "result": result,
-            "image_url": url_for('static', filename=f'uploads/{filename}')
-        })
-    
-    return jsonify({"error": "File type not allowed"}), 400
-
-@app.route('/history')
-def history():
-    # Return the scan history
-    return jsonify(SCAN_HISTORY)
-
-@app.route('/dashboard')
-def dashboard():
-    return render_template('dashboard.html')
+    message = "Logo is REAL" if is_real else "Logo is FAKE"
+    if not is_real:
+        message += "\n\nReasons:\n" + "\n".join(reasons)
 
-@app.route('/download_report', methods=['GET'])
-def download_report():
-    # In a real implementation, this would generate a PDF report
-    # For this demo, we'll just return a JSON file with the history data
-    
-    memory_file = BytesIO()
-    memory_file.write(json.dumps(SCAN_HISTORY, indent=4).encode())
-    memory_file.seek(0)
-    
-    return send_file(
-        memory_file,
-        mimetype='application/json',
-        as_attachment=True,
-        download_name='logo_detection_report.json'
-    )
+    return message, file_path
 
-@app.route('/api/check_logo', methods=['POST'])
-def api_check_logo():
-    """API endpoint for e-commerce integration"""
-    if 'file' not in request.files:
-        return jsonify({"success": False, "error": "No file part"}), 400
-    
-    file = request.files['file']
-    
-    if file.filename == '':
-        return jsonify({"success": False, "error": "No selected file"}), 400
-    
-    if file and allowed_file(file.filename):
-        filename = secure_filename(file.filename)
-        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(file_path)
-        
-        result = analyze_logo(file_path)
-        
-        # Return API-friendly response
-        return jsonify({
-            "success": True,
-            "is_authentic": result["is_real"],
-            "confidence": result["confidence"],
-            "issues": result["reasons"] if not result["is_real"] else None
-        })
-    
-    return jsonify({"success": False, "error": "File type not allowed"}), 400
+demo = gr.Interface(
+    fn=analyze_logo,
+    inputs=gr.File(label="Upload Logo"),
+    outputs=[
+        gr.Textbox(label="Analysis Result"),
+        gr.Image(label="Uploaded Image")
+    ],
+    title="Fake Logo Detector",
+    description="Upload a brand logo to check if it's authentic or fake."
+)
 
-if __name__ == '__main__':
-    app.run(debug=True)
+if __name__ == "__main__":
+    demo.launch()