Upload 23 files

.dockerignore

@@ -0,0 +1,27 @@
+# Git
+.git
+.gitignore
+
+# Python/Environment
+venv/
+env/
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Large Data & Models (Download at runtime or mount as volumes)
+dataset/
+model/
+weights/
+
+# IDE
+.vscode/
+.idea/
+
+# Local Dev/Debug
+debug_*.py
+test_*.py
+tests/
+*.log

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test_image.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+env/
+venv/
+.DS_Store
+
+# Large Files
+dataset/
+model/
+

Dockerfile

@@ -0,0 +1,29 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /code
+
+# Install system dependencies (required for OpenCV)
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt /code/requirements.txt
+
+# Install PyTorch CPU-only (Detailed command significantly reduces size/memory usage)
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+# Install other python dependencies
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the rest of the application
+COPY . /code
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app

README.md

@@ -1,11 +1,74 @@
----
-title: Ai
-emoji: 🏢
-colorFrom: gray
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Coin Toss Detector
+emoji: 🪙
+colorFrom: blue
+colorTo: yellow
+sdk: docker
+app_port: 7860
+---
+
+# COIN-TOSS: AI & Identity Risk Detection
+
+## Overview
+
+COIN-TOSS is an advanced web application designed to accurately detect AI-generated images and assess potential identity theft risks. By combining multiple state-of-the-art deep learning models with custom analysis logic ("Gap Trap V3"), it provides a reliable "Real" vs "AI" verdict without ambiguous percentages, while also identifying potential misuse of authentic images.
+
+## Features
+
+-   **High-Accuracy AI Detection**:
+    -   Utilizes a hybrid ensemble of models (`dima806/ai_vs_real_image_detection` and `prithivMLmods/Deep-Fake-Detector-v2-Model`).
+    -   **Gap Trap V3 Logic**: A specialized algorithm to catch "uncanny valley" images and properly classify filtered real photos vs. high-quality deepfakes.
+    -   **Frequency Analysis**: Visualizes invisible noise patterns (FFT) to detect checkerboard artifacts common in diffusion models.
+-   **Identity Theft Risk Analysis**:
+    -   Analyzes "Real" images for biometric metrics (Face Visibility, Quality, etc.).
+    -   Provides a risk assessment (Low/High) for using the image in sensitive contexts (KYC, Profiles).
+-   **User-Friendly Interface**:
+    -   Simple drag-and-drop upload.
+    -   Instant "Real" or "AI" verdict.
+    -   Detailed analysis points explaining the decision.
+
+## Workflow
+
+### Prerequisites
+
+-   Python 3.8+
+-   Git
+
+### Installation
+
+1.  **Clone the Repository**
+    ```bash
+    git clone https://github.com/madhavmullick2025/COIN-TOSS.git
+    cd COIN-TOSS
+    ```
+
+2.  **Install Dependencies**
+    It is recommended to use a virtual environment.
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+### Usage
+
+1.  **Start the Application**
+    ```bash
+    python app.py
+    ```
+    *Note: The first run may take a few moments to download the necessary model weights from HuggingFace.*
+
+2.  **Access the Interface**
+    Open your web browser and navigate to:
+    ```
+    http://localhost:5002
+    ```
+
+3.  **Analyze Images**
+    -   Upload an image (JPG, PNG, WEBP).
+    -   Click "Analyze" to see if it's Real or AI.
+    -   If "Real", switch to the "Identity Risk" tab to see safety metrics.
+
+## Tech Stack
+
+-   **Backend**: Python, Flask, PyTorch, Transformers (HuggingFace).
+-   **Frontend**: HTML5, CSS3, JavaScript.
+-   **AI Models**: ViT (Vision Transformer) based image classifiers.

app.py

@@ -0,0 +1,223 @@
+import os
+import torch
+from flask import Flask, request, jsonify, render_template
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import io
+import torch.nn.functional as F
+from identity_risk import IdentityRiskAnalyzer  # [NEW]
+try:
+    from frequency_analysis import FrequencyAnalyzer # [NEW]
+except ImportError:
+    FrequencyAnalyzer = None
+    print("WARNING: FrequencyAnalyzer could not be imported. Feature disabled.")
+
+app = Flask(__name__)
+
+# --- Configuration ---
+# Loading multiple models for an ensemble approach
+# User requested "Academy/Winston AI" accuracy.
+# Switching to NYUAD-ComNets/NYUAD_AI_Generated_Image_Detection
+# This model is likely trained on a massive academic dataset for rigor.
+# User requested "Winston AI" style accuracy.
+# We combine a "Liberal" Model (umm-maybe - good with filters) 
+# and a "Conservative" Model (dima806 - strict on artifacts).
+# User requested "Accuracy" for both AI and Real.
+# Implementing "Gap Trap V2" Logic.
+# This logic specifically targets the "Uncanny Valley" of AI Hyper-Realism.
+MODEL_GENERAL = "dima806/ai_vs_real_image_detection"
+MODEL_FACE = "prithivMLmods/Deep-Fake-Detector-v2-Model"
+
+models = {}
+processors = {}
+risk_analyzer = None # [NEW]
+freq_analyzer = None # [NEW]
+
+# --- Load Models & Processors ---
+def load_models():
+    global risk_analyzer
+    try:
+        print(f"Loading General Model: {MODEL_GENERAL}...")
+        models['general'] = AutoModelForImageClassification.from_pretrained(MODEL_GENERAL)
+        processors['general'] = AutoImageProcessor.from_pretrained(MODEL_GENERAL)
+        
+        print(f"Loading Face Model: {MODEL_FACE}...")
+        models['face'] = AutoModelForImageClassification.from_pretrained(MODEL_FACE)
+        processors['face'] = AutoImageProcessor.from_pretrained(MODEL_FACE)
+        
+        print("Loading Identity Risk Analyzer...")
+        risk_analyzer = IdentityRiskAnalyzer() # [NEW]
+        
+        if FrequencyAnalyzer:
+            print("Loading Frequency Analyzer...")
+            global freq_analyzer
+            freq_analyzer = FrequencyAnalyzer() # [NEW]
+        else:
+             print("Skipping Frequency Analyzer...")
+
+        print("All models loaded successfully.")
+    except Exception as e:
+        print(f"Error loading models: {e}")
+
+load_models()
+
+# --- Routes ---
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    if not models or not processors:
+        return jsonify({"error": "Models not loaded service unavailable"}), 503
+
+    if 'image' not in request.files:
+        return jsonify({"error": "No image uploaded"}), 400
+    
+    file = request.files['image']
+    if file.filename == '':
+        return jsonify({"error": "No file selected"}), 400
+
+    try:
+        # Read image
+        image_bytes = file.read()
+        image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+        
+        # --- Inference Helper ---
+        def get_prob(model_key, img):
+            processor = processors[model_key]
+            model = models[model_key]
+            inputs = processor(images=img, return_tensors="pt")
+            with torch.no_grad():
+                outputs = model(**inputs)
+            return F.softmax(outputs.logits, dim=-1)
+
+        # 1. Get General Scores (dima806)
+        probs_gen = get_prob('general', image)
+        labels_gen = models['general'].config.id2label
+        idx_real_gen = 0 # Default assumption
+        if 'real' in str(labels_gen.get(0, '')).lower(): idx_real_gen = 0
+        elif 'real' in str(labels_gen.get(1, '')).lower(): idx_real_gen = 1
+        
+        real_score_gen = probs_gen[0][idx_real_gen].item()
+        fake_score_gen = probs_gen[0][1-idx_real_gen].item()
+
+        # 2. Get Face Scores (Deepfake)
+        probs_face = get_prob('face', image)
+        # Deepfake labels: 0=Realism, 1=Deepfake
+        real_score_face = probs_face[0][0].item()
+        fake_score_face = probs_face[0][1].item()
+        
+        # --- GAP TRAP V3 (v19.0) ---
+        # Refined Thresholds to trap "Noise" on non-face images.
+        # Digital Art often scores ~0.46 on Face Model.
+        # We raise the "High Quality" bar to 0.65.
+        
+        print(f"DEBUG: General_Fake={fake_score_gen:.4f}, Face_Real={real_score_face:.4f}")
+        
+        # --- Logic & Explanation Tracking ---
+        analysis_points = []
+        
+        # Step 1: Default to General Model
+        if fake_score_gen > 0.5:
+            final_label = "AI"
+            final_prob = fake_score_gen
+            analysis_points.append("General analysis detected synthetic patterns/artifacts.")
+        else:
+            final_label = "Real"
+            final_prob = real_score_gen
+            analysis_points.append("No significant deepfake artifacts detected.")
+            analysis_points.append("Image noise patterns consistent with optical cameras.")
+            
+        # Step 2: The Widened Gap Trap
+        if final_label == "AI":
+            # Zone A: Filtered Real (0.00 - 0.25) -> OVERRIDE REAL
+            # Zone B: Uncanny Valley / Noise (0.25 - 0.65) -> TRAP (STAY AI)
+            # Zone C: High Quality Real (0.65 - 1.00) -> OVERRIDE REAL
+            
+            if real_score_face < 0.25:
+                print("DEBUG: Override -> Real (Filter Zone)")
+                final_label = "Real"
+                final_prob = 0.85 
+                analysis_points = [] # Reset for override
+                analysis_points.append("Heavy smoothing detected, consistent with beauty filters.")
+                analysis_points.append("Underlying facial structure remains authentic.")
+            elif real_score_face > 0.65:
+                print("DEBUG: Override -> Real (High Quality Zone)")
+                final_label = "Real"
+                final_prob = real_score_face
+                analysis_points = [] # Reset for override
+                analysis_points.append("High-fidelity skin micro-textures confirm human subject.")
+                analysis_points.append("Lighting interaction with features appears natural.")
+            else:
+                print("DEBUG: Trap Triggered -> Confirmed AI (Uncanny Valley / Noise)")
+                analysis_points.append("Deep analysis confirms lack of authentic biological details.")
+                analysis_points.append("Texture inconsistencies found in detailed regions.")
+
+        # --- [NEW] Smart Tagging (UI Badge) ---
+        classification_tag = ""
+        if final_label == "AI":
+             if final_prob > 0.98:
+                 classification_tag = "Completely generated by AI"
+             else:
+                 classification_tag = "High-level Digital Manipulation"
+        else: # Real
+             if final_prob > 0.99:
+                 classification_tag = "Raw Image / Authentic Source"
+             elif final_prob > 0.90:
+                 classification_tag = "Likely Authentic (Filters)"
+             else:
+                 classification_tag = "Heavily Processed / Filtered"
+        
+        print(f"DEBUG: Generated Tag: {classification_tag}")
+
+        # --- [NEW] Identity Risk Check ---
+        risk_data = {}
+        if final_label == "Real" and risk_analyzer:
+             try:
+                 print("Running Identity Risk Analysis...")
+                 risk_data = risk_analyzer.analyze(image)
+             except Exception as risk_e:
+                 print(f"Risk Analysis Error: {risk_e}")
+                 risk_data = {"error": "Analysis failed"}
+
+        # --- [NEW] Frequency Analysis ---
+        frequency_map_b64 = ""
+        pattern_map_b64 = "" # [NEW]
+        if freq_analyzer:
+            try:
+                # We analyze the raw image for frequency artifacts
+                frequency_map_b64 = freq_analyzer.generate_spectrum(image)
+                pattern_map_b64 = freq_analyzer.generate_pattern_map(image) # [NEW]
+            except Exception as freq_e:
+                print(f"Frequency Analysis Error: {freq_e}")
+
+        return jsonify({
+            "prediction": final_label,
+            "confidence": float(f"{final_prob:.4f}"),
+            "classification_tag": classification_tag, # [NEW]
+            "analysis_points": analysis_points, # [NEW]
+            "risk_analysis": risk_data,
+            "frequency_analysis": frequency_map_b64, # [NEW]
+            "pattern_analysis": pattern_map_b64, # [NEW]
+            "all_scores": {
+                "Real": float(f"{1-final_prob if final_label=='AI' else final_prob:.4f}"),
+                "AI": float(f"{final_prob if final_label=='AI' else 1-final_prob:.4f}"),
+                "Debug_General_Fake": fake_score_gen,
+                "Debug_Face_Real": real_score_face,
+                "Debug_Mode": "Gap Trap V3 [0.25-0.65]"
+            }
+        })
+
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    print("--- STARTING SERVER VERSION 19.2 (GAP TRAP V3 + ID RISK) ---")
+    try:
+        port = int(os.environ.get("PORT", 5002))
+        app.run(debug=False, host='0.0.0.0', port=port)
+    except Exception as e:
+        print(f"Startup Error: {e}")

check_labels.py

@@ -0,0 +1,4 @@
+
+from transformers import AutoModelForImageClassification
+model = AutoModelForImageClassification.from_pretrained("prithivMLmods/Deep-Fake-Detector-v2-Model")
+print("LABELS:", model.config.id2label)

debug_load.py

@@ -0,0 +1,9 @@
+
+from transformers import AutoModelForImageClassification, AutoImageProcessor
+try:
+    print("Loading EfficientNet...")
+    m = AutoModelForImageClassification.from_pretrained("Dafilab/ai-image-detector")
+    p = AutoImageProcessor.from_pretrained("Dafilab/ai-image-detector")
+    print("Success")
+except Exception as e:
+    print(f"FAILED: {e}")

debug_predict.py

@@ -0,0 +1,18 @@
+import requests
+
+url = 'http://127.0.0.1:5002/predict'
+file_path = r'C:/Users/Madhav/.gemini/antigravity/brain/67c74e6e-1b77-4d5b-894d-787254bc31a0/uploaded_image_1767961715511.jpg'
+
+try:
+    with open(file_path, 'rb') as f:
+        files = {'image': f}
+        response = requests.post(url, files=files)
+        data = response.json()
+        print("FULL RESPONSE:", data)
+        scores = data.get('all_scores', {})
+        print(f"DEBUG - Face Real: {scores.get('Debug_Face_Real')}")
+        print(f"DEBUG - Gen Fake: {scores.get('Debug_General_Fake')}")
+        print(f"DEBUG - Analysis: {data.get('analysis_points')}")
+        print(f"Prediction: {data.get('prediction')}")
+except Exception as e:
+    print(f"Error: {e}")

debug_single_image.py

@@ -0,0 +1,29 @@
+from identity_risk import IdentityRiskAnalyzer
+from PIL import Image
+import os
+
+# Path to the uploaded image
+image_path = r"C:/Users/Madhav/.gemini/antigravity/brain/9cc8325c-cd76-426f-85e1-e3096464cb09/uploaded_image_1767977759111.png"
+
+try:
+    print(f"Loading image from: {image_path}")
+    image = Image.open(image_path).convert("RGB")
+    
+    analyzer = IdentityRiskAnalyzer()
+    print("Running analysis...")
+    results = analyzer.analyze(image)
+    
+    print("\n--- ANALYSIS RESULTS ---")
+    print(f"High Risk: {results['is_high_risk']}")
+    print(f"Risk Score: {results['risk_score']}")
+    
+    print("\n[Passed Criteria (Risk Factors)]:")
+    for item in results['passed_criteria']:
+        print(f" - {item}")
+        
+    print("\n[Failed Criteria / Details (Safety Factors)]:")
+    for item in results['details']:
+        print(f" - {item}")
+
+except Exception as e:
+    print(f"Error: {e}")

frequency_analysis.py

@@ -0,0 +1,97 @@
+import numpy as np
+import numpy as np
+from PIL import Image, ImageFilter, ImageOps
+import io
+import base64
+
+class FrequencyAnalyzer:
+    def __init__(self):
+        pass
+
+    def generate_spectrum(self, image: Image.Image) -> str:
+        """
+        Generates a 2D Frequency Spectrum (Magnitude Plot) from a PIL Image.
+        Returns a base64 encoded PNG string of the spectrum.
+        """
+        try:
+            # 1. Convert to Grayscale
+            img_gray = image.convert('L')
+            
+            # 2. Convert to Numpy Array
+            img_array = np.array(img_gray)
+            
+            # 3. Compute FFT (Fast Fourier Transform)
+            # f = np.fft.fft2(img_array)
+            # fshift = np.fft.fftshift(f)
+            # magnitude_spectrum = 20 * np.log(np.abs(fshift))
+             
+            # Use a slightly more robust method for visualization
+            f = np.fft.fft2(img_array)
+            fshift = np.fft.fftshift(f)
+            # Add epsilon to avoid log(0)
+            magnitude_spectrum = 20 * np.log(np.abs(fshift) + 1e-9)
+
+            # 4. Normalize to 0-255 for standard image display
+            mag_min = magnitude_spectrum.min()
+            mag_max = magnitude_spectrum.max()
+            
+            # Avoid division by zero if image is blank
+            if mag_max == mag_min:
+                normalized = np.zeros_like(magnitude_spectrum, dtype=np.uint8)
+            else:
+                normalized = 255 * (magnitude_spectrum - mag_min) / (mag_max - mag_min)
+                normalized = np.uint8(normalized)
+
+            # 5. Convert back to PIL Image
+            spectrum_img = Image.fromarray(normalized)
+
+            # 6. Encode to Base64
+            buffered = io.BytesIO()
+            spectrum_img.save(buffered, format="PNG")
+            img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+            
+            return img_str
+            
+        except Exception as e:
+            print(f"Error generating frequency spectrum: {e}")
+            return ""
+
+    def generate_pattern_map(self, image: Image.Image) -> str:
+        """
+        Generates a Noise Pattern Map (High-Pass/Laplacian) to visualize
+        checkerboard artifacts.
+        """
+        try:
+            # 1. Convert to Grayscale
+            img_gray = image.convert('L')
+            
+            # 2. Apply Laplacian Filter (High-Pass)
+            # This removes smooth areas and keeps edges/noise
+            noise_map = img_gray.filter(ImageFilter.FIND_EDGES) 
+            # Note: FIND_EDGES is a simple approximation. For better grid visualization,
+            # we can use a Kernel, but this is usually sufficient for "seeing" the grid.
+            
+            # 3. Invert to make lines black on white (easier to see)
+            # noise_map = ImageOps.invert(noise_map)
+            # Actually, white on black (default) effectively shows the "glowing" grid lines.
+            
+            # 4. Enhance Contrast/Brightness to make faint artifacts visible
+            # We convert to numpy to scale
+            arr = np.array(noise_map).astype(float)
+            
+            # Amplify
+            arr = arr * 5.0 # Boost signal
+            arr = np.clip(arr, 0, 255).astype(np.uint8)
+            
+            enhanced_map = Image.fromarray(arr)
+            
+            # 5. Encode
+            buffered = io.BytesIO()
+            enhanced_map.save(buffered, format="PNG")
+            img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+            
+            return img_str
+            
+        except Exception as e:
+            print(f"Error generating pattern map: {e}")
+            return ""

identity_risk.py

@@ -0,0 +1,128 @@
+import cv2
+import numpy as np
+import os
+
+class IdentityRiskAnalyzer:
+    def __init__(self):
+        # Load Haar Cascades
+        cascade_path = cv2.data.haarcascades
+        self.face_cascade = cv2.CascadeClassifier(os.path.join(cascade_path, 'haarcascade_frontalface_default.xml'))
+        self.eye_cascade = cv2.CascadeClassifier(os.path.join(cascade_path, 'haarcascade_eye.xml'))
+        # Smile cascade is often less reliable, but we can try if available, or skip expression strictness.
+        # self.smile_cascade = cv2.CascadeClassifier(os.path.join(cascade_path, 'haarcascade_smile.xml'))
+
+    def analyze(self, pil_image):
+        """
+        Analyzes a PIL Image for identity theft risk using OpenCV.
+        """
+        # Convert PIL to CV2 (BGR)
+        img_np = np.array(pil_image)
+        if img_np.shape[2] == 4: # RGBA to RGB
+            img_np = cv2.cvtColor(img_np, cv2.COLOR_RGBA2RGB)
+        
+        # OpenCV expects BGR
+        img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+        h, w = gray.shape
+
+        results = {
+            "is_high_risk": False,
+            "risk_score": 0.0,
+            "details": [],
+            "passed_criteria": []
+        }
+
+        # 1. Face Visibility & Count
+        faces = self.face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+        
+        if len(faces) == 0:
+            results["details"].append("No face detected.")
+            return results
+        
+        if len(faces) > 1:
+            results["details"].append("Multiple faces detected.")
+            return results
+        
+        results["passed_criteria"].append("Single face visible")
+        
+        # Get Face ROI
+        (x, y, fw, fh) = faces[0]
+        face_roi_gray = gray[y:y+fh, x:x+fw]
+        
+        face_ratio = (fw * fh) / (w * h)
+        if face_ratio < 0.05:
+             results["details"].append("Face too small relative to image.")
+        
+        # 2. Alignment (Eyes)
+        eyes = self.eye_cascade.detectMultiScale(face_roi_gray)
+        
+        if len(eyes) >= 2:
+            # Sort by x position to get left and right eye
+            eyes = sorted(eyes, key=lambda e: e[0])
+            (ex1, ey1, ew1, eh1) = eyes[0]
+            (ex2, ey2, ew2, eh2) = eyes[-1] # Farthest right
+            
+            # Check Angle (Roll)
+            dy = (ey2 + eh2/2) - (ey1 + eh1/2)
+            dx = (ex2 + ew2/2) - (ex1 + ew1/2)
+            angle = np.degrees(np.arctan2(dy, dx))
+            
+            if abs(angle) > 10:
+                results["details"].append(f"Face tilted (Angle: {angle:.1f}°).")
+            else:
+                results["passed_criteria"].append("Face vertically aligned")
+                
+            # Check Centering (Yaw/Translation)
+            face_center_x = x + fw/2
+            img_center_x = w/2
+            deviation = abs(face_center_x - img_center_x)
+            
+            if deviation > w * 0.15:
+                results["details"].append("Face not centered.")
+            else:
+                results["passed_criteria"].append("Face centered")
+        else:
+             # Can't see both eyes -> Maybe side profile or hair?
+             # For High Risk ID, we NEED eyes visible.
+             results["details"].append("Eyes not clearly visible or aligned.")
+
+        # 3. Image Quality (Blur)
+        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+        if laplacian_var < 50:
+             results["details"].append("Image too blurry.")
+        else:
+             results["passed_criteria"].append("High resolution/sharp")
+
+        # 4. Lighting & Background
+        margin = int(min(w, h) * 0.1)
+        if margin < 1: margin = 1
+        
+        # Check top corners for background uniformity
+        top_strip = gray[0:margin, :]
+        bg_var = np.var(top_strip)
+        bg_mean = np.mean(top_strip)
+        
+        if bg_var > 2500: # Relaxed threshold for "real world" plain walls
+             results["details"].append("Background not plain/uniform.")
+        elif bg_mean < 80: # Too dark
+             results["details"].append("Background too dark.")
+        else:
+             results["passed_criteria"].append("Plain light-colored background")
+
+        # 5. Expression (Heuristic)
+        # Without landmarks, checking "neutral" is hard. 
+        # But we can skip strict Smile check as user requested leniency.
+        # We assume if it passes eye alignment and is frontal, it's risky enough.
+        results["passed_criteria"].append("Expression check skipped (Lenient)")
+
+        # Final Scoring
+        # High Risk if NO details (failures).
+        
+        if len(results["details"]) == 0:
+            results["is_high_risk"] = True
+            results["risk_score"] = 0.95
+        else:
+             # Special Case: If only Background failed? No, ID photo needs plain BG.
+             results["is_high_risk"] = False
+
+        return results

inspect_dire.py

@@ -0,0 +1,22 @@
+
+from transformers import AutoModelForImageClassification
+import sys
+
+model_name = 'yevvonlim/DistilDIRE'
+try:
+    print(f"Attempting to load {model_name}...")
+    model = AutoModelForImageClassification.from_pretrained(model_name)
+    print("Success!")
+    print("Labels:", model.config.id2label)
+except Exception as e:
+    print(f"Error loading {model_name}: {e}")
+
+# Check Organika as backup
+model_name_2 = 'Organika/SDXL-Detector'
+try:
+    print(f"Attempting to load {model_name_2}...")
+    model2 = AutoModelForImageClassification.from_pretrained(model_name_2)
+    print("Success Organika!")
+    print("Labels:", model2.config.id2label)
+except Exception as e:
+    print(f"Error loading {model_name_2}: {e}")

render.yaml

@@ -0,0 +1,9 @@
+services:
+  - type: web
+    name: coin-toss
+    env: python
+    buildCommand: pip install -r requirements.txt
+    startCommand: gunicorn app:app
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.10.0

requirements.txt

@@ -0,0 +1,13 @@
+flask
+transformers
+pillow
+pandas
+
+scikit-learn
+accelerate
+datasets
+evaluate
+
+opencv-python-headless
+numpy
+gunicorn

static/bg-animation.js

@@ -0,0 +1,113 @@
+/**
+ * Background Particle Animation
+ * Creates a "living" grid of particles that reacts to mouse movement.
+ */
+
+const canvas = document.getElementById('bg-canvas');
+const ctx = canvas.getContext('2d');
+
+let particlesArray;
+
+// Mouse Interactions
+let mouse = {
+    x: null,
+    y: null,
+    radius: 150 // Interaction radius
+}
+
+window.addEventListener('mousemove', function (event) {
+    mouse.x = event.x;
+    mouse.y = event.y;
+});
+
+// Particle Class
+class Particle {
+    constructor(x, y, loadingSpeed, size, color) {
+        this.x = x;
+        this.y = y;
+        this.baseX = x; // Remember original position
+        this.baseY = y;
+        this.size = size;
+        this.color = color;
+        this.density = (Math.random() * 30) + 1; // How heavy/slow it moves
+    }
+
+    draw() {
+        ctx.beginPath();
+        ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2, false);
+        ctx.fillStyle = this.color;
+        ctx.fill();
+    }
+
+    update() {
+        // Mouse Interaction Physics
+        let dx = mouse.x - this.x;
+        let dy = mouse.y - this.y;
+        let distance = Math.sqrt(dx * dx + dy * dy);
+        let forceDirectionX = dx / distance;
+        let forceDirectionY = dy / distance;
+        let maxDistance = mouse.radius;
+        let force = (maxDistance - distance) / maxDistance;
+        let directionX = forceDirectionX * force * this.density;
+        let directionY = forceDirectionY * force * this.density;
+
+        if (distance < mouse.radius) {
+            // Move away from mouse (Repulsion) - feels "magnetic"
+            this.x -= directionX;
+            this.y -= directionY;
+            // Option: To make it attract instead, change -= to +=
+        } else {
+            // Return to original position (Elasticity)
+            if (this.x !== this.baseX) {
+                let dx = this.x - this.baseX;
+                this.x -= dx / 10; // Speed of return
+            }
+            if (this.y !== this.baseY) {
+                let dy = this.y - this.baseY;
+                this.y -= dy / 10;
+            }
+        }
+    }
+}
+
+function init() {
+    particlesArray = [];
+    // Create a grid of particles
+    const numberOfParticles = (canvas.width * canvas.height) / 9000; // Density control
+
+    // Random distribution (Starfield style)
+    for (let i = 0; i < numberOfParticles * 2; i++) {
+        let size = (Math.random() * 2) + 0.5; // Random size
+        let x = Math.random() * innerWidth;
+        let y = Math.random() * innerHeight;
+        let color = '#00DC82'; // Brand Green
+
+        particlesArray.push(new Particle(x, y, 1, size, color));
+    }
+}
+
+function animate() {
+    requestAnimationFrame(animate);
+    ctx.clearRect(0, 0, innerWidth, innerHeight);
+
+    for (let i = 0; i < particlesArray.length; i++) {
+        particlesArray[i].draw();
+        particlesArray[i].update();
+    }
+    // Connect particles with lines (Constellation effect) - Optional, can be heavy
+    // connect(); 
+}
+
+// Handle Resize
+window.addEventListener('resize', function () {
+    canvas.width = innerWidth;
+    canvas.height = innerHeight;
+    mouse.radius = ((canvas.height / 80) * (canvas.height / 80));
+    init();
+});
+
+// Start
+canvas.width = innerWidth;
+canvas.height = innerHeight;
+init();
+animate();

static/script.js

@@ -0,0 +1,405 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const dropZone = document.getElementById('drop-zone');
+    const fileInput = document.getElementById('file-input');
+    const previewContainer = document.getElementById('preview-container');
+    const imagePreview = document.getElementById('image-preview');
+    const removeBtn = document.getElementById('remove-btn');
+    const analyzeBtn = document.getElementById('analyze-btn');
+    const resultContainer = document.getElementById('result-container');
+    const resultBadge = document.getElementById('result-badge');
+
+    const tabDetector = document.getElementById('tab-detector');
+    const tabRisk = document.getElementById('tab-risk');
+    let currentMode = 'detector'; // 'detector' or 'risk'
+
+    const modelLabel = document.getElementById('model-label');
+    const btnText = analyzeBtn.querySelector('.btn-text');
+    const loader = analyzeBtn.querySelector('.loader');
+
+    let currentFile = null;
+
+    // --- Tab Switching ---
+    function switchTab(mode) {
+        currentMode = mode;
+        resultContainer.classList.add('hidden'); // Hide previous results
+
+        if (mode === 'detector') {
+            tabDetector.className = 'px-6 py-2 rounded-full font-medium transition-all duration-300 bg-white text-black shadow-[0_0_20px_-5px_rgba(255,255,255,0.5)]';
+            tabRisk.className = 'px-6 py-2 rounded-full font-medium transition-all duration-300 bg-white/5 text-brand-gray hover:bg-white/10 hover:text-white border border-white/10';
+            btnText.textContent = 'Analyze Authenticity';
+        } else {
+            tabRisk.className = 'px-6 py-2 rounded-full font-medium transition-all duration-300 bg-brand-green text-black shadow-[0_0_20px_-5px_rgba(0,220,130,0.5)]';
+            tabDetector.className = 'px-6 py-2 rounded-full font-medium transition-all duration-300 bg-white/5 text-brand-gray hover:bg-white/10 hover:text-white border border-white/10';
+            btnText.textContent = 'Check Identity Risk';
+        }
+    }
+
+    tabDetector.addEventListener('click', () => switchTab('detector'));
+    tabRisk.addEventListener('click', () => switchTab('risk'));
+
+
+    // --- Drag & Drop ---
+    dropZone.addEventListener('click', () => fileInput.click());
+
+    dropZone.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        dropZone.classList.add('dragover');
+    });
+
+    dropZone.addEventListener('dragleave', () => {
+        dropZone.classList.remove('dragover');
+    });
+
+    dropZone.addEventListener('drop', (e) => {
+        e.preventDefault();
+        dropZone.classList.remove('dragover');
+        if (e.dataTransfer.files.length) {
+            handleFile(e.dataTransfer.files[0]);
+        }
+    });
+
+    fileInput.addEventListener('change', (e) => {
+        if (e.target.files.length) {
+            handleFile(e.target.files[0]);
+        }
+    });
+
+    // --- File Handling ---
+    function handleFile(file) {
+        if (!file.type.startsWith('image/')) {
+            alert('Please upload an image file (JPG, PNG).');
+            return;
+        }
+
+        currentFile = file;
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            imagePreview.src = e.target.result;
+            dropZone.classList.add('hidden');
+            previewContainer.classList.remove('hidden');
+            analyzeBtn.disabled = false;
+            resultContainer.classList.add('hidden');
+        };
+        reader.readAsDataURL(file);
+    }
+
+    // --- Reset ---
+    removeBtn.addEventListener('click', () => {
+        currentFile = null;
+        fileInput.value = '';
+        dropZone.classList.remove('hidden');
+        previewContainer.classList.add('hidden');
+        analyzeBtn.disabled = true;
+        resultContainer.classList.add('hidden');
+    });
+
+    // --- Prediction ---
+    analyzeBtn.addEventListener('click', async () => {
+        if (!currentFile) return;
+
+        // UI Loading State
+        analyzeBtn.disabled = true;
+        btnText.textContent = currentMode === 'detector' ? 'Analysing...' : 'Checking Risk...';
+        loader.classList.remove('hidden');
+        resultContainer.classList.add('hidden');
+
+        const formData = new FormData();
+        formData.append('image', currentFile);
+
+        try {
+            const response = await fetch('/predict', {
+                method: 'POST',
+                body: formData
+            });
+
+            if (!response.ok) throw new Error('API Error');
+
+            const data = await response.json();
+            displayResult(data);
+
+        } catch (error) {
+            console.error(error);
+            alert('Error processing image. Please try again.');
+        } finally {
+            // UI Reset State
+            analyzeBtn.disabled = false;
+            btnText.textContent = currentMode === 'detector' ? 'Analyze Authenticity' : 'Check Identity Risk';
+            loader.classList.add('hidden');
+        }
+    });
+
+    function displayResult(data) {
+        resultContainer.classList.remove('hidden');
+        const badgeContainer = document.getElementById('result-badge-container');
+
+        // Remove existing detailed warnings/lists
+        const existingWarning = document.getElementById('risk-warning');
+        if (existingWarning) existingWarning.remove();
+        const existingList = document.getElementById('risk-details');
+        if (existingList) existingList.remove();
+
+
+        const confidenceWrapper = document.getElementById('confidence-wrapper');
+        const explanationsSection = document.getElementById('explanations-section');
+        const qualificationTag = document.getElementById('qualification-tag'); // [NEW]
+
+        if (currentMode === 'detector') {
+            // --- AI Detector Mode ---
+            if (confidenceWrapper) confidenceWrapper.classList.remove('hidden'); // Show in Detector Mode
+
+            modelLabel.textContent = 'AI Detection Result';
+            const label = data.prediction.toLowerCase();
+            resultBadge.textContent = label.toUpperCase();
+
+            // [NEW] Qualification Tag Logic
+            if (qualificationTag) {
+                if (data.classification_tag) {
+                    qualificationTag.classList.remove('hidden');
+                    qualificationTag.textContent = data.classification_tag;
+
+                    // Dynamic Styling based on content
+                    qualificationTag.className = "px-3 py-1 rounded-full text-[10px] font-bold uppercase tracking-wider border transition-colors duration-300";
+
+                    if (data.classification_tag.includes("AI") || data.classification_tag.includes("Manipulation")) {
+                        qualificationTag.classList.add("bg-red-500/10", "border-red-500/20", "text-red-200");
+                    } else if (data.classification_tag.includes("Raw")) {
+                        qualificationTag.classList.add("bg-brand-green/10", "border-brand-green/20", "text-brand-green");
+                    } else {
+                        qualificationTag.classList.add("bg-yellow-500/10", "border-yellow-500/20", "text-yellow-200");
+                    }
+                } else {
+                    qualificationTag.classList.add('hidden');
+                }
+            }
+
+            // Confidence Update
+            const confidenceBar = document.getElementById('confidence-bar');
+            const confidenceValue = document.getElementById('confidence-value');
+            const percent = Math.round(data.confidence * 100);
+
+            // Animate Bar
+            setTimeout(() => {
+                confidenceBar.style.width = `${percent}%`;
+            }, 100);
+            confidenceValue.textContent = `${percent}%`;
+
+            resultBadge.className = 'text-3xl font-bold tracking-tight transition-colors duration-300';
+            confidenceBar.className = 'h-full w-0 rounded-full transition-all duration-1000 ease-out'; // Reset base
+
+            if (label.includes('real')) {
+                resultBadge.classList.add('text-brand-green', 'drop-shadow-[0_0_15px_rgba(0,220,130,0.5)]');
+                confidenceBar.classList.add('bg-brand-green', 'shadow-[0_0_10px_rgba(0,220,130,0.5)]');
+            } else if (label.includes('fake') || label.includes('ai')) {
+                resultBadge.classList.add('text-red-500', 'drop-shadow-[0_0_15px_rgba(255,50,50,0.5)]');
+                confidenceBar.classList.add('bg-red-500', 'shadow-[0_0_10px_rgba(255,50,50,0.5)]');
+            } else {
+                resultBadge.classList.add('text-brand-gray');
+                confidenceBar.classList.add('bg-gray-500');
+            }
+
+            // [NEW] Analysis Points Logic
+            const explanationsSection = document.getElementById('explanations-section');
+            const reasonsList = document.getElementById('reasons-list');
+
+            reasonsList.innerHTML = ''; // Clear previous
+
+            if (data.analysis_points && data.analysis_points.length > 0) {
+                explanationsSection.classList.remove('hidden');
+                data.analysis_points.forEach(point => {
+                    const li = document.createElement('li');
+                    li.className = 'text-gray-300 text-sm flex items-start gap-2.5 leading-relaxed';
+                    li.innerHTML = `
+                        <i class="fa-solid fa-circle-check text-brand-green text-[10px] mt-1.5 opacity-80"></i>
+                        <span class="opacity-90">${point}</span>
+                    `;
+                    // Change icon for AI points
+                    if (label.includes('ai')) {
+                        li.innerHTML = `
+                            <i class="fa-solid fa-circle-exclamation text-red-500 text-[10px] mt-1.5 opacity-80"></i>
+                            <span class="opacity-90">${point}</span>
+                        `;
+                    }
+                    reasonsList.appendChild(li);
+                });
+            } else {
+                explanationsSection.classList.add('hidden');
+            }
+
+            // Old Warning for "Real" images in Detection Mode (optional, keeping minimal as per request)
+            if (data.risk_analysis && data.risk_analysis.is_high_risk && label.includes('real')) {
+                const warningDiv = document.createElement('div');
+                warningDiv.id = 'risk-warning';
+                warningDiv.className = 'mt-4 p-3 rounded-xl bg-orange-500/10 border border-orange-500/20 backdrop-blur-sm animate-fade-in-up';
+                warningDiv.innerHTML = `
+                    <div class="flex items-center gap-3">
+                        <i class="fa-solid fa-triangle-exclamation text-orange-500"></i>
+                         <p class="text-orange-200/80 text-xs">
+                            Identity Risk Detected. Switch to the <b>Identity Risk</b> tab for details.
+                        </p>
+                    </div>
+                `;
+                const resultCard = resultContainer.querySelector('div');
+                resultCard.appendChild(warningDiv);
+            }
+
+        } else {
+            // --- Identity Risk Mode ---
+            modelLabel.textContent = 'Identity Theft Risk Analysis';
+
+            // Hide Detector-specific elements
+            if (confidenceWrapper) confidenceWrapper.classList.add('hidden');
+            if (explanationsSection) explanationsSection.classList.add('hidden');
+
+            // Check if analysis actually ran
+            if (data.prediction !== "Real") {
+                // It's AI, so no risk analysis
+                resultBadge.textContent = "N/A (AI Detected)";
+                resultBadge.className = 'text-xl font-semibold text-brand-gray';
+
+                const infoDiv = document.createElement('div');
+                infoDiv.id = 'risk-details';
+                infoDiv.className = 'mt-4 text-brand-gray/60 text-sm text-center';
+                infoDiv.textContent = "Identity risk analysis is only performed on real images.";
+
+                const resultCard = resultContainer.querySelector('div');
+                resultCard.appendChild(infoDiv);
+                return;
+            }
+
+            if (!data.risk_analysis || data.risk_analysis.error) {
+                resultBadge.textContent = "Error";
+                return;
+            }
+
+            const isHighRisk = data.risk_analysis.is_high_risk;
+            resultBadge.textContent = isHighRisk ? "HIGH RISK" : "LOW RISK";
+
+            resultBadge.className = 'text-3xl font-bold tracking-tight transition-colors duration-300';
+            if (isHighRisk) {
+                resultBadge.classList.add('text-red-500', 'drop-shadow-[0_0_15px_rgba(255,50,50,0.5)]');
+            } else {
+                resultBadge.classList.add('text-brand-green', 'drop-shadow-[0_0_15px_rgba(0,220,130,0.5)]');
+            }
+
+            // Create Detailed List
+            const detailsDiv = document.createElement('div');
+            detailsDiv.id = 'risk-details';
+            detailsDiv.className = 'mt-6 pt-4 border-t border-white/10 animate-fade-in-up';
+
+            let html = '<div class="space-y-3">';
+
+            // Passed Criteria (Green Check) - Logic: "Passed" means it matched the ID criteria (so it IS risky)
+            // Wait, my passed_criteria list means "Matches ID standard". 
+            // So if it's in passed_criteria, it contributes to High Risk.
+
+            const passed = data.risk_analysis.passed_criteria || [];
+            const failed = data.risk_analysis.details || []; // Reasons why it FAILED to be an ID photo (so good for safety)
+
+            // Show "Risk Factors" (The things that make it ID-like)
+            if (passed.length > 0) {
+                html += '<h5 class="text-xs font-semibold text-brand-gray uppercase mb-2">Risk Factors (ID Compliant)</h5>';
+                passed.forEach(item => {
+                    html += `
+                        <div class="flex items-center gap-2 text-sm text-red-200/80">
+                            <i class="fa-solid fa-check text-red-500"></i>
+                            <span>${item}</span>
+                        </div>`;
+                });
+            }
+
+            // Show "Safety Factors" (The things that make it SAFE / Not ID-like)
+            if (failed.length > 0) {
+                html += '<h5 class="text-xs font-semibold text-brand-gray uppercase mt-4 mb-2">Safety Factors (Non-ID)</h5>';
+                failed.forEach(item => {
+                    html += `
+                        <div class="flex items-center gap-2 text-sm text-brand-green/80">
+                            <i class="fa-solid fa-shield text-brand-green"></i>
+                            <span>${item}</span>
+                        </div>`;
+                });
+            }
+
+            html += '</div>';
+            detailsDiv.innerHTML = html;
+
+
+
+            const resultCard = resultContainer.querySelector('div');
+            resultCard.appendChild(detailsDiv);
+        }
+
+        // --- Frequency Map Logic (Shared) ---
+        // This runs after the mode-specific logic
+
+        // --- Advanced Analysis Logic (Tabs + Maps) ---
+        const advancedToggleContainer = document.getElementById('advanced-toggle-container');
+        const advancedSection = document.getElementById('advanced-analysis-section');
+        const advancedBtn = document.getElementById('advanced-btn');
+
+        const frequencyMapImg = document.getElementById('frequency-map-img');
+        const patternMapImg = document.getElementById('pattern-map-img');
+
+        const tabFreq = document.getElementById('tab-freq');
+        const tabPattern = document.getElementById('tab-pattern');
+        const panelFreq = document.getElementById('panel-freq');
+        const panelPattern = document.getElementById('panel-pattern');
+
+        if (advancedToggleContainer && advancedSection) {
+            // 1. Reset State
+            advancedToggleContainer.classList.add('hidden');
+            advancedSection.classList.add('hidden');
+            advancedBtn.innerHTML = '<i class="fa-solid fa-chart-simple mr-2"></i>View Advanced Frequency Analysis';
+
+            // 2. Check if we have data to show
+            if (currentMode === 'detector' && (data.frequency_analysis || data.pattern_analysis)) {
+                advancedToggleContainer.classList.remove('hidden');
+
+                // Populate Images
+                if (data.frequency_analysis && frequencyMapImg) frequencyMapImg.src = 'data:image/png;base64,' + data.frequency_analysis;
+                if (data.pattern_analysis && patternMapImg) patternMapImg.src = 'data:image/png;base64,' + data.pattern_analysis;
+
+                // 3. Toggle Section Visibility
+                const newBtn = advancedBtn.cloneNode(true);
+                advancedBtn.parentNode.replaceChild(newBtn, advancedBtn);
+
+                newBtn.addEventListener('click', () => {
+                    const isHidden = advancedSection.classList.contains('hidden');
+                    if (isHidden) {
+                        advancedSection.classList.remove('hidden');
+                        newBtn.innerHTML = '<i class="fa-solid fa-chevron-up mr-2"></i>Hide Advanced Analysis';
+                    } else {
+                        advancedSection.classList.add('hidden');
+                        newBtn.innerHTML = '<i class="fa-solid fa-chart-simple mr-2"></i>View Advanced Frequency Analysis';
+                    }
+                });
+
+                // 4. Tab Switching Logic
+                // Update References & remove old listeners
+                const newTabFreq = tabFreq.cloneNode(true);
+                if (tabFreq) tabFreq.parentNode.replaceChild(newTabFreq, tabFreq);
+
+                const newTabPattern = tabPattern.cloneNode(true);
+                if (tabPattern) tabPattern.parentNode.replaceChild(newTabPattern, tabPattern);
+
+                const setActive = (activeTab, activePanel) => {
+                    // Reset all
+                    [newTabFreq, newTabPattern].forEach(t => {
+                        if (t) t.className = "relative px-4 py-2 text-xs font-medium text-brand-gray bg-black/40 rounded-t-lg transition-colors border-t border-x border-white/5 hover:bg-white/5 hover:text-white cursor-pointer";
+                    });
+                    if (panelFreq) panelFreq.classList.add('hidden');
+                    if (panelPattern) panelPattern.classList.add('hidden');
+
+                    // Set Active
+                    if (activeTab) activeTab.className = "relative px-4 py-2 text-xs font-medium text-white bg-white/10 rounded-t-lg transition-colors border-t border-x border-white/10 hover:bg-white/20 z-10 cursor-default";
+                    if (activePanel) activePanel.classList.remove('hidden');
+                };
+
+                if (newTabFreq) newTabFreq.addEventListener('click', () => setActive(newTabFreq, panelFreq));
+                if (newTabPattern) newTabPattern.addEventListener('click', () => setActive(newTabPattern, panelPattern));
+
+                // Default to Freq
+                setActive(newTabFreq, panelFreq);
+            }
+        }
+    }
+});

static/style.css

@@ -0,0 +1,2 @@
+/* All styles are now handled by Tailwind CSS in index.html */
+/* This file is kept to prevent 404s if referenced, but is intentionally empty. */

templates/index.html

@@ -0,0 +1,358 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>V-VORTEX | AI Detection</title>
+
+    <!-- Google Fonts -->
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+
+    <!-- FontAwesome -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+
+    <!-- Tailwind CSS -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = {
+            theme: {
+                extend: {
+                    fontFamily: {
+                        sans: ['Outfit', 'sans-serif'],
+                    },
+                    colors: {
+                        brand: {
+                            dark: '#02040a',
+                            green: '#00DC82',
+                            gray: '#8899ac'
+                        }
+                    },
+                    backgroundImage: {
+                        'gradient-radial': 'radial-gradient(var(--tw-gradient-stops))',
+                    }
+                }
+            }
+        }
+    </script>
+
+    <!-- Custom CSS (Only for what Tailwind can't easily do) -->
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+
+<body
+    class="bg-brand-dark text-white min-h-screen flex flex-col font-sans overflow-x-hidden selection:bg-brand-green selection:text-brand-dark relative">
+
+    <!-- Ambient Background Glows -->
+    <div class="fixed top-0 left-0 w-full h-full overflow-hidden pointer-events-none z-0">
+        <canvas id="bg-canvas" class="absolute top-0 left-0 w-full h-full opacity-40"></canvas>
+        <div class="absolute top-[-20%] left-[-10%] w-[800px] h-[800px] bg-brand-green/5 rounded-full blur-[120px]">
+        </div>
+        <div class="absolute bottom-[-10%] right-[-5%] w-[600px] h-[600px] bg-blue-600/5 rounded-full blur-[100px]">
+        </div>
+    </div>
+
+    <!-- Header -->
+    <header class="relative z-10 w-full max-w-7xl mx-auto px-6 py-8 flex justify-between items-center">
+        <div class="flex items-center gap-2">
+            <div class="w-8 h-8 rounded bg-brand-green flex items-center justify-center text-brand-dark font-bold">
+                <i class="fa-solid fa-coins"></i>
+            </div>
+            <span class="font-bold text-lg tracking-wide">COIN TOSS</span>
+        </div>
+
+        <a href="https://github.com/madhavmullick2025/COIN-TOSS" target="_blank"
+            class="text-brand-gray hover:text-white transition-colors">
+            <i class="fa-brands fa-github text-xl"></i>
+        </a>
+    </header>
+
+    <main class="relative z-10 flex-1 flex flex-col items-center justify-center px-4 mb-20">
+
+        <!-- Hero Section -->
+        <div class="text-center mb-12 animate-fade-in-up">
+            <div
+                class="inline-flex items-center gap-2 px-4 py-1.5 rounded-full bg-white/5 border border-white/10 mb-8 backdrop-blur-sm">
+                <i class="fa-solid fa-bolt text-brand-green text-xs"></i>
+                <span class="text-xs font-semibold text-brand-green tracking-wider uppercase">Powered by
+                    UniversalFakeDetect & DIRET</span>
+            </div>
+
+            <div class="relative">
+                <h1 class="text-5xl md:text-7xl font-bold mb-4 leading-tight tracking-tight">
+                    See beyond <br>
+                    <span class="bg-gradient-to-r from-brand-green to-emerald-600 bg-clip-text text-transparent">the
+                        pixels.</span>
+                </h1>
+            </div>
+
+            <p class="text-brand-gray max-w-xl mx-auto text-lg leading-relaxed">
+                Detect AI-generated images with precision. Visualize the artifacts that give them away through advanced
+                attention mapping and forensic analysis.
+            </p>
+        </div>
+
+        <!-- Tabs -->
+        <div class="flex items-center gap-4 mb-8">
+            <button id="tab-detector"
+                class="px-6 py-2 rounded-full font-medium transition-all duration-300 bg-white text-black shadow-[0_0_20px_-5px_rgba(255,255,255,0.5)]">
+                AI Detector
+            </button>
+            <button id="tab-risk"
+                class="px-6 py-2 rounded-full font-medium transition-all duration-300 bg-white/5 text-brand-gray hover:bg-white/10 hover:text-white border border-white/10">
+                Identity Risk
+            </button>
+        </div>
+
+        <!-- Upload Card -->
+        <div class="w-full max-w-[580px] perspective-1000">
+            <div
+                class="relative group bg-white/[0.03] hover:bg-white/[0.05] border border-white/10 rounded-3xl p-2 transition-all duration-300 backdrop-blur-xl shadow-2xl shadow-black/50">
+
+
+                <div id="drop-zone"
+                    class="relative rounded-2xl border border-dashed border-white/20 bg-black/20 h-[300px] flex flex-col items-center justify-center transition-all duration-300 group-hover:border-brand-green/30 cursor-pointer overflow-hidden">
+
+                    <input type="file" id="file-input" accept="image/*" class="hidden">
+
+                    <div
+                        class="upload-content text-center p-8 transition-transform duration-300 group-hover:-translate-y-2">
+                        <div
+                            class="w-16 h-16 rounded-full bg-white/5 flex items-center justify-center mx-auto mb-6 border border-white/10 group-hover:scale-110 group-hover:border-brand-green/50 transition-all duration-300">
+                            <i class="fa-solid fa-arrow-up-from-bracket text-brand-green text-xl"></i>
+                        </div>
+                        <h3 class="text-white font-semibold text-xl mb-2">Drag & Drop or <span
+                                class="text-brand-green">Browse</span></h3>
+                        <p class="text-brand-gray text-sm">Supported formats: JPG, PNG, WEBP</p>
+
+                        <button
+                            class="mt-6 px-6 py-2.5 rounded-full bg-white/10 hover:bg-white/20 text-sm font-medium transition-all text-white border border-white/5">
+                            Choose File
+                        </button>
+                    </div>
+
+                    <!-- Overlay for drag hover -->
+                    <div
+                        class="absolute inset-0 bg-brand-green/10 opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none flex items-center justify-center">
+                    </div>
+                </div>
+
+                <!-- Preview Container (Initially Hidden) -->
+                <div id="preview-container"
+                    class="hidden relative h-[300px] w-full rounded-2xl overflow-hidden bg-black/40">
+                    <img id="image-preview" src="" alt="Preview" class="w-full h-full object-contain p-4" />
+                    <button id="remove-btn"
+                        class="absolute top-4 right-4 w-8 h-8 rounded-full bg-black/50 hover:bg-red-500/80 text-white flex items-center justify-center backdrop-blur-md transition-colors border border-white/10">
+                        <i class="fa-solid fa-xmark text-sm"></i>
+                    </button>
+                </div>
+            </div>
+
+            <!-- Analyze Button -->
+            <div class="mt-8 flex justify-center">
+                <button id="analyze-btn" disabled
+                    class="group relative px-8 py-4 rounded-full bg-white text-black font-semibold text-lg flex items-center gap-3 transition-all hover:scale-105 disabled:opacity-50 disabled:hover:scale-100 disabled:cursor-not-allowed shadow-[0_0_40px_-10px_rgba(255,255,255,0.3)]">
+                    <span class="btn-text">Analyze Image</span>
+                    <i
+                        class="fa-solid fa-wand-magic-sparkles text-brand-dark group-hover:rotate-12 transition-transform"></i>
+
+                    <!-- Loader -->
+                    <span
+                        class="loader hidden w-5 h-5 border-2 border-brand-dark/30 border-t-brand-dark rounded-full animate-spin ml-2"></span>
+                </button>
+            </div>
+        </div>
+
+        <!-- Result Section -->
+        <div id="result-container" class="hidden mt-12 w-full max-w-[580px] animate-fade-in-up">
+            <div class="relative bg-white/[0.03] border border-white/10 rounded-2xl p-6 backdrop-blur-md">
+                <div class="flex items-center justify-between mb-2">
+                    <span class="text-brand-gray text-sm font-medium uppercase tracking-wider">Detection Result</span>
+                    <span id="model-label" class="text-xs text-brand-gray/50">--</span>
+                </div>
+
+                <div class="flex items-center gap-4">
+                    <div id="result-badge-container" class="flex-1 flex flex-row items-center justify-between gap-2">
+                        <h2 id="result-badge" class="text-3xl font-bold text-white tracking-tight">--</h2>
+                        <div id="qualification-tag"
+                            class="hidden px-3 py-1 rounded-full text-[10px] font-bold uppercase tracking-wider border border-white/10 bg-white/5 text-brand-gray/80">
+                            --
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Confidence Meter -->
+                <div id="confidence-wrapper" class="mt-6 mb-2">
+                    <div class="flex justify-between items-center mb-2">
+                        <span class="text-xs font-medium text-brand-gray uppercase tracking-wider">Confidence
+                            Level</span>
+                        <span id="confidence-value" class="text-sm font-bold text-white">0%</span>
+                    </div>
+                    <div class="w-full h-2 bg-white/10 rounded-full overflow-hidden">
+                        <div id="confidence-bar"
+                            class="h-full w-0 rounded-full transition-all duration-1000 ease-out bg-brand-green"></div>
+                    </div>
+                </div>
+
+            </div>
+
+            <!-- Analysis Insights -->
+            <div id="explanations-section" class="hidden mt-6 pt-6 border-t border-white/10">
+                <h3 class="text-sm font-semibold text-brand-gray mb-4 uppercase tracking-wider flex items-center gap-2">
+                    <i class="fa-solid fa-microscope text-brand-green"></i> Analysis Insights
+                </h3>
+                <ul id="reasons-list" class="space-y-3">
+                    <!-- Points injected via JS -->
+                </ul>
+            </div>
+
+            <!-- Advanced Analysis -->
+            <div id="advanced-toggle-container" class="mt-8 text-center hidden mb-6 relative z-10">
+                <button id="advanced-btn"
+                    class="text-brand-gray/60 hover:text-white text-xs font-medium tracking-wide transition-colors duration-300 border border-white/10 px-4 py-2 rounded-lg hover:bg-white/5 backdrop-blur-sm">
+                    <i class="fa-solid fa-chart-simple mr-2"></i>View Advanced Frequency Analysis
+                </button>
+            </div>
+
+            <div id="advanced-analysis-section"
+                class="hidden animate-fade-in-up mb-8 relative z-10 w-full max-w-[580px]">
+
+                <!-- Chrome-style Tabs -->
+                <div class="flex items-end px-2 space-x-1 overflow-x-auto">
+                    <!-- Frequency Tab (Active) -->
+                    <button id="tab-freq"
+                        class="relative px-4 py-2 text-xs font-medium text-white bg-white/10 rounded-t-lg transition-colors border-t border-x border-white/10 hover:bg-white/20 z-10">
+                        <div class="flex items-center gap-2">
+                            <i class="fa-solid fa-wave-square text-purple-400"></i>
+                            Frequency Map
+                        </div>
+                    </button>
+                    <!-- Pattern Tab (Inactive) -->
+                    <button id="tab-pattern"
+                        class="relative px-4 py-2 text-xs font-medium text-brand-gray bg-black/40 rounded-t-lg transition-colors border-t border-x border-white/5 hover:bg-white/5 hover:text-white">
+                        <div class="flex items-center gap-2">
+                            <i class="fa-solid fa-border-all text-blue-400"></i>
+                            Noise Pattern
+                        </div>
+                    </button>
+                    <!-- Spacer line -->
+                    <div class="flex-1 border-b border-white/10 h-full"></div>
+                </div>
+
+                <!-- Content Container -->
+                <div
+                    class="bg-black/40 rounded-b-xl rounded-tr-xl border border-white/10 p-5 backdrop-blur-md relative -top-[1px] z-0">
+
+                    <!-- TAB 1: Frequency map -->
+                    <div id="panel-freq" class="block">
+                        <div class="flex items-center justify-between mb-4">
+                            <h3 class="text-white text-xs font-semibold">Frequency Spectrum (FFT)</h3>
+                            <span
+                                class="text-[10px] text-brand-gray bg-white/5 px-2 py-1 rounded border border-white/5">Mathematical
+                                Structure</span>
+                        </div>
+
+                        <div class="grid grid-cols-1 gap-6">
+                            <div
+                                class="relative group flex justify-center bg-black/50 rounded-lg p-4 border border-white/5">
+                                <img id="frequency-map-img" src="" alt="Frequency Spectrum"
+                                    class="w-64 h-64 object-contain rounded-lg shadow-2xl">
+                            </div>
+                            <!-- FFT Legend -->
+                            <div class="grid grid-cols-2 gap-3">
+                                <div
+                                    class="p-3 rounded-lg bg-white/5 border border-white/5 flex flex-col items-center text-center">
+                                    <div class="w-2 h-2 bg-white rounded-full shadow-[0_0_5px_white] mb-2"></div>
+                                    <p class="text-[10px] font-bold text-white mb-1">Authentic</p>
+                                    <p class="text-[10px] text-brand-gray/60 leading-tight">Single center starburst.</p>
+                                </div>
+                                <div
+                                    class="p-3 rounded-lg bg-white/5 border border-white/5 flex flex-col items-center text-center">
+                                    <div class="grid grid-cols-3 gap-0.5 mb-2 opacity-80 scale-75">
+                                        <div class="w-0.5 h-0.5 bg-red-400"></div>
+                                        <div class="w-0.5 h-0.5"></div>
+                                        <div class="w-0.5 h-0.5 bg-red-400"></div>
+                                        <div class="w-0.5 h-0.5"></div>
+                                        <div class="w-0.5 h-0.5"></div>
+                                        <div class="w-0.5 h-0.5"></div>
+                                        <div class="w-0.5 h-0.5 bg-red-400"></div>
+                                        <div class="w-0.5 h-0.5"></div>
+                                        <div class="w-0.5 h-0.5 bg-red-400"></div>
+                                    </div>
+                                    <p class="text-[10px] font-bold text-red-300 mb-1">Artificial</p>
+                                    <p class="text-[10px] text-brand-gray/60 leading-tight">Grid pattern / bright dots.
+                                    </p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- TAB 2: Noise Pattern -->
+                    <div id="panel-pattern" class="hidden">
+                        <div class="flex items-center justify-between mb-4">
+                            <h3 class="text-white text-xs font-semibold">High-Frequency Noise Filter</h3>
+                            <span
+                                class="text-[10px] text-brand-gray bg-white/5 px-2 py-1 rounded border border-white/5">Surface
+                                Artifacts</span>
+                        </div>
+
+                        <div class="grid grid-cols-1 gap-6">
+                            <div
+                                class="relative group flex justify-center bg-black/50 rounded-lg p-4 border border-white/5">
+                                <img id="pattern-map-img" src="" alt="Noise Pattern"
+                                    class="w-64 h-64 object-contain rounded-lg shadow-2xl filter contrast-125 brightness-110">
+                            </div>
+                            <!-- Pattern Legend -->
+                            <div class="p-3 rounded-lg bg-white/5 border border-white/5">
+                                <h4 class="text-[10px] text-brand-gray uppercase font-bold mb-2">What to look for</h4>
+                                <ul class="space-y-2">
+                                    <li class="flex items-start gap-2 text-[10px] text-gray-300">
+                                        <i class="fa-solid fa-check text-brand-green mt-0.5"></i>
+                                        <span><b>Real:</b> Random "Tv Static" or organic grain. No straight
+                                            lines.</span>
+                                    </li>
+                                    <li class="flex items-start gap-2 text-[10px] text-gray-300">
+                                        <i class="fa-solid fa-xmark text-red-500 mt-0.5"></i>
+                                        <span><b>AI:</b> Visible "Checkerboard" grid lines or squares tiles.</span>
+                                    </li>
+                                </ul>
+                            </div>
+                        </div>
+                    </div>
+
+                </div>
+            </div>
+
+            <!-- Decorative line -->
+            <div
+                class="absolute bottom-0 left-0 w-full h-[2px] bg-gradient-to-r from-transparent via-brand-green/50 to-transparent">
+            </div>
+        </div>
+        </div>
+
+    </main>
+
+    <script src="{{ url_for('static', filename='bg-animation.js') }}"></script>
+    <script src="{{ url_for('static', filename='script.js') }}?v=5"></script>
+    <style>
+        .animate-fade-in-up {
+            animation: fadeInUp 0.8s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+        }
+
+        @keyframes fadeInUp {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+    </style>
+</body>
+
+</html>

test_app_load.py

@@ -0,0 +1,8 @@
+try:
+    print("Importing app...")
+    import app
+    print("Import success!")
+except Exception as e:
+    print(f"Import failed: {e}")
+except SystemExit as se:
+    print(f"SystemExit: {se}")

test_freq.py

@@ -0,0 +1,17 @@
+try:
+    from frequency_analysis import FrequencyAnalyzer
+    print("Import Successful")
+    
+    fa = FrequencyAnalyzer()
+    print("Initialization Successful")
+    
+    from PIL import Image
+    import numpy as np
+    
+    # Create dummy image
+    img = Image.new('RGB', (100, 100), color = 'red')
+    res = fa.generate_spectrum(img)
+    print(f"Generation Successful. Len: {len(res)}")
+    
+except Exception as e:
+    print(f"Error: {e}")

train.py

@@ -0,0 +1,151 @@
+import os
+import torch
+from datasets import load_dataset, ClassLabel, Image
+from transformers import (
+    ViTImageProcessor,
+    ViTForImageClassification,
+    TrainingArguments,
+    Trainer,
+    DefaultDataCollator,
+)
+import evaluate
+from torchvision.transforms import (
+    CenterCrop,
+    Compose,
+    Normalize,
+    RandomRotation,
+    RandomResizedCrop,
+    RandomHorizontalFlip,
+    RandomAdjustSharpness,
+    Resize,
+    ToTensor,
+)
+import numpy as np
+
+# --- Configuration ---
+MODEL_NAME = "google/vit-base-patch16-224"
+DATASET_DIR = "./dataset"
+OUTPUT_DIR = "./model"
+BATCH_SIZE = 16
+NUM_EPOCHS = 3
+LEARNING_RATE = 2e-5
+
+def main():
+    # 1. Load Dataset
+    print("Loading dataset...")
+    # Expects dataset structure: dataset/train/LABEL and dataset/test/LABEL
+    data_files = {}
+    if os.path.exists(os.path.join(DATASET_DIR, "train")):
+        data_files["train"] = os.path.join(DATASET_DIR, "train")
+    if os.path.exists(os.path.join(DATASET_DIR, "test")):
+        data_files["test"] = os.path.join(DATASET_DIR, "test")
+    
+    if not data_files:
+        print(f"Error: No data found in {DATASET_DIR}. Please organize data in 'train' and 'test' folders.")
+        print("Expected structure: ./dataset/train/REAL, ./dataset/train/FAKE, etc.")
+        return
+
+    # Use evaluate load logic or simplified imagefolder loading
+    # Ideally use Hugging Face datasets ImageFolder builder which is automatic if we point to directory
+    dataset = load_dataset("imagefolder", data_dir=DATASET_DIR)
+    
+    # 2. Labels
+    labels = dataset["train"].features["label"].names
+    id2label = {str(i): c for i, c in enumerate(labels)}
+    label2id = {c: str(i) for i, c in enumerate(labels)}
+    print(f"Labels found: {labels}")
+
+    # 3. Preprocessing
+    processor = ViTImageProcessor.from_pretrained(MODEL_NAME)
+    image_mean = processor.image_mean
+    image_std = processor.image_std
+    size = processor.size["height"]
+
+    normalize = Normalize(mean=image_mean, std=image_std)
+
+    _train_transforms = Compose([
+        RandomResizedCrop(size),
+        RandomHorizontalFlip(),
+        RandomAdjustSharpness(2),
+        ToTensor(),
+        normalize,
+    ])
+
+    _val_transforms = Compose([
+        Resize(size),
+        CenterCrop(size),
+        ToTensor(),
+        normalize,
+    ])
+
+    def train_transforms(examples):
+        examples["pixel_values"] = [_train_transforms(image.convert("RGB")) for image in examples["image"]]
+        return examples
+
+    def val_transforms(examples):
+        examples["pixel_values"] = [_val_transforms(image.convert("RGB")) for image in examples["image"]]
+        return examples
+
+    # Apply transforms
+    print("Applying transforms...")
+    dataset["train"].set_transform(train_transforms)
+    if "test" in dataset:
+        dataset["test"].set_transform(val_transforms)
+    
+    # 4. Model
+    print(f"Loading model {MODEL_NAME}...")
+    model = ViTForImageClassification.from_pretrained(
+        MODEL_NAME,
+        num_labels=len(labels),
+        id2label=id2label,
+        label2id=label2id,
+        ignore_mismatched_sizes=True 
+    )
+
+    # 5. Metrics
+    metric = evaluate.load("accuracy")
+    def compute_metrics(eval_pred):
+        predictions = np.argmax(eval_pred.predictions, axis=1)
+        return metric.compute(predictions=predictions, references=eval_pred.label_ids)
+
+    # 6. Training Arguments
+    args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        remove_unused_columns=False,
+        evaluation_strategy="epoch",
+        save_strategy="epoch",
+        learning_rate=LEARNING_RATE,
+        per_device_train_batch_size=BATCH_SIZE,
+        per_device_eval_batch_size=BATCH_SIZE,
+        num_train_epochs=NUM_EPOCHS,
+        warmup_ratio=0.1,
+        logging_steps=10,
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        push_to_hub=False,
+    )
+
+    collator = DefaultDataCollator()
+
+    trainer = Trainer(
+        model=model,
+        args=args,
+        train_dataset=dataset["train"],
+        eval_dataset=dataset["test"] if "test" in dataset else None,
+        tokenizer=processor,
+        data_collator=collator,
+        compute_metrics=compute_metrics,
+    )
+
+    # 7. Train
+    print("Starting training...")
+    trainer.train()
+
+    # 8. Save
+    print(f"Saving model to {OUTPUT_DIR}...")
+    trainer.save_model(OUTPUT_DIR)
+    processor.save_pretrained(OUTPUT_DIR)
+    print("Done!")
+
+if __name__ == "__main__":
+    main()