feat: updated detector using Ela fft and meta

README.md

@@ -1,9 +0,0 @@
----
-title: Ai-Checker
-emoji: 🚀
-colorFrom: yellow
-colorTo: blue
-sdk: docker
-pinned: false
----
-

app.py

@@ -7,6 +7,8 @@ from fastapi.responses import JSONResponse
 from features.text_classifier.routes import router as text_classifier_router
 from features.nepali_text_classifier.routes import router as nepali_text_classifier_router
 from features.image_classifier.routes import router as image_classifier_router
+from features.image_edit_detector.routes import router as image_edit_detector_router
+
 from config import ACCESS_RATE
 
 import requests
@@ -30,6 +32,8 @@ app.add_middleware(SlowAPIMiddleware)
 app.include_router(text_classifier_router, prefix="/text")
 app.include_router(nepali_text_classifier_router,prefix="/NP")
 app.include_router(image_classifier_router,prefix="/AI-image")
+app.include_router(image_edit_detector_router,prefix="/detect")
+
 @app.get("/")
 @limiter.limit(ACCESS_RATE)
 async def root(request: Request):

docs/detector/ELA.md

@@ -0,0 +1,76 @@
+# Error Level Analysis (ELA) Detector
+
+This module provides a function to perform Error Level Analysis (ELA) on images to detect potential manipulations or edits.
+
+
+## Function: `run_ela`
+
+```python
+def run_ela(image: Image.Image, quality: int = 90, threshold: int = 15) -> bool:
+```
+
+
+### Description
+
+Error Level Analysis (ELA) works by recompressing an image at a specified JPEG quality level and comparing it to the original image. Differences between the two images reveal areas with inconsistent compression artifacts — often indicating image manipulation.
+
+The function computes the maximum pixel difference across all color channels and uses a threshold to determine if the image is likely edited.
+
+### Parameters
+
+| Parameter   | Type        | Default | Description                                                                                 |
+| ----------- | ----------- | ------- | ------------------------------------------------------------------------------------------- |
+| `image`     | `PIL.Image` | N/A     | Input image in RGB mode to analyze.                                                         |
+| `quality`   | `int`       | 90      | JPEG compression quality used for recompression during analysis (lower = more compression). |
+| `threshold` | `int`       | 15      | Pixel difference threshold to flag the image as edited.                                     |
+
+
+### Returns
+
+`bool`
+
+* `True` if the image is likely edited (max pixel difference > threshold).  
+* `False` if the image appears unedited.
+
+
+### Usage Example
+
+```python
+from PIL import Image
+from detectors.ela import run_ela
+
+# Open and convert image to RGB
+img = Image.open("example.jpg").convert("RGB")
+
+# Run ELA detection
+is_edited = run_ela(img, quality=90, threshold=15)
+
+print("Image edited:", is_edited)
+```
+
+
+### Notes
+
+* The input image **must** be in RGB mode for accurate analysis.  
+* ELA is a heuristic technique; combining it with other detection methods increases reliability.  
+* Visualizing the enhanced difference image can help identify edited regions (not returned by this function but possible to add).
+
+
+### Installation
+
+Make sure you have Pillow installed:
+
+```bash
+pip install pillow
+```
+
+
+### Running Locally
+
+Just put the function in a notebook or script file and run it with your image. It works well for basic images.
+
+
+### Developer
+
+Pujan Neupane
+

docs/detector/fft.md

@@ -0,0 +1,141 @@
+
+#  Fast Fourier Transform (FFT) Detector
+
+```python
+def run_fft(image: Image.Image, threshold: float = 0.92) -> bool:
+```
+
+## **Overview**
+
+The `run_fft` function performs a frequency domain analysis on an image using the **Fast Fourier Transform (FFT)** to detect possible **AI generation or digital manipulation**. It leverages the fact that artificially generated or heavily edited images often exhibit a distinct high-frequency pattern.
+
+---
+
+## **Parameters**
+
+| Parameter   | Type              | Description                                                                             |
+| ----------- | ----------------- | --------------------------------------------------------------------------------------- |
+| `image`     | `PIL.Image.Image` | Input image to analyze. It will be converted to grayscale and resized.                  |
+| `threshold` | `float`           | Proportion threshold of high-frequency components to flag the image. Default is `0.92`. |
+
+---
+
+## **Returns**
+
+| Type   | Description                                                            |
+| ------ | ---------------------------------------------------------------------- |
+| `bool` | `True` if image is likely AI-generated/manipulated; otherwise `False`. |
+
+---
+
+## **Step-by-Step Explanation**
+
+### 1. **Grayscale Conversion**
+
+All images are converted to grayscale:
+
+```python
+gray_image = image.convert("L")
+```
+
+### 2. **Resize**
+
+The image is resized to a fixed $512 \times 512$ for uniformity:
+
+```python
+resized_image = gray_image.resize((512, 512))
+```
+
+### 3. **FFT Calculation**
+
+Compute the 2D Discrete Fourier Transform:
+
+$$
+F(u, v) = \sum_{x=0}^{M-1} \sum_{y=0}^{N-1} f(x, y) \cdot e^{-2\pi i \left( \frac{ux}{M} + \frac{vy}{N} \right)}
+$$
+
+```python
+fft_result = fft2(image_array)
+```
+
+### 4. **Shift Zero Frequency to Center**
+
+Use `fftshift` to center the zero-frequency component:
+
+```python
+fft_shifted = fftshift(fft_result)
+```
+
+### 5. **Magnitude Spectrum**
+
+$$
+|F(u, v)| = \sqrt{\Re^2 + \Im^2}
+$$
+
+```python
+magnitude_spectrum = np.abs(fft_shifted)
+```
+
+### 6. **Normalization**
+
+Normalize the spectrum to avoid scale issues:
+
+$$
+\text{Normalized}(u,v) = \frac{|F(u,v)|}{\max(|F(u,v)|)}
+$$
+
+```python
+normalized_spectrum = magnitude_spectrum / max_magnitude
+```
+
+### 7. **High-Frequency Detection**
+
+High-frequency components are defined as:
+
+$$
+\text{Mask}(u,v) = 
+\begin{cases}
+1 & \text{if } \text{Normalized}(u,v) > 0.5 \\
+0 & \text{otherwise}
+\end{cases}
+$$
+
+```python
+high_freq_mask = normalized_spectrum > 0.5
+```
+
+### 8. **Proportion Calculation**
+
+$$
+\text{Ratio} = \frac{\sum \text{Mask}}{\text{Total pixels}}
+$$
+
+```python
+high_freq_ratio = np.sum(high_freq_mask) / normalized_spectrum.size
+```
+
+### 9. **Threshold Decision**
+
+If the ratio exceeds the threshold:
+
+$$
+\text{is\_fake} = (\text{Ratio} > \text{Threshold})
+$$
+
+```python
+is_fake = high_freq_ratio > threshold
+```
+
+it is implemented in the api
+
+### Running Locally
+
+Just put the function in a notebook or script file and run it with your image. It works well for basic images.
+
+
+### Worked By
+
+Pujan Neupane
+
+
+

docs/detector/note-for-backend.md

@@ -0,0 +1,92 @@
+
+# 📦API integration note
+
+## Overview
+
+This system integrates **three image forensics methods**—**ELA**, **FFT**, and **Metadata analysis**—into a single detection pipeline to determine whether an image is AI-generated, manipulated, or authentic.
+
+---
+
+## 🔍 Detection Modules
+
+### 1. **ELA (Error Level Analysis)**
+
+* **Purpose:** Detects tampering or editing by analyzing compression error levels.
+* **Accuracy:** ✅ *Most accurate method*
+* **Performance:** ❗ *Slowest method*
+* **Output:** `True` (edited) or `False` (authentic)
+
+### 2. **FFT (Fast Fourier Transform)**
+
+* **Purpose:** Identifies high-frequency patterns typical of AI-generated images.
+* **Accuracy:** ⚠️ *Moderately accurate*
+* **Performance:** ❗ *Moderate to slow*
+* **Output:** `True` (likely AI-generated) or `False` (authentic)
+
+### 3. **Metadata Analysis**
+
+* **Purpose:** Detects traces of AI tools or editors in image metadata or binary content.
+* **Accuracy:** ⚠️ *Fast but weaker signal*
+* **Performance:** 🚀 *Fastest method*
+* **Output:** One of:
+
+  * `"ai_generated"` – AI tool or generator identified
+  * `"edited"` – Edited using known software
+  * `"undetermined"` – No signature found
+
+---
+
+## 🧩 Integration Plan
+
+### ➕ Combine all three APIs into one unified endpoint:
+
+```bash
+POST /api/detect-image
+```
+
+### Input:
+
+* `image`: Image file (binary, any format supported by Pillow)
+
+### Output:
+
+```json
+{
+  "ela_result": true,
+  "fft_result": false,
+  "metadata_result": "ai_generated",
+  "final_decision": "ai_generated" 
+}
+```
+> NOTE:Optionally recommending a default logic (e.g., trust ELA > FFT > Metadata).
+
+## Result implementation
+| `ela_result` | `fft_result` | `metadata_result` | Suggested Final Decision | Notes                                                                   |
+| ------------ | ------------ | ----------------- | ------------------------ | ----------------------------------------------------------------------- |
+| `true`       | `true`       | `"ai_generated"`  | `ai_generated`           | Strong evidence from all three modules                                  |
+| `true`       | `false`      | `"edited"`        | `edited`                 | ELA confirms editing, no AI signals                                     |
+| `true`       | `false`      | `"undetermined"`  | `edited`                 | ELA indicates manipulation                                              |
+| `false`      | `true`       | `"ai_generated"`  | `ai_generated`           | No edits, but strong AI frequency & metadata signature                  |
+| `false`      | `true`       | `"undetermined"`  | `possibly_ai_generated`  | Weak metadata, but FFT indicates possible AI generation                 |
+| `false`      | `false`      | `"ai_generated"`  | `ai_generated`           | Metadata alone shows AI use                                             |
+| `false`      | `false`      | `"edited"`        | `possibly_edited`        | Weak signal—metadata shows editing but no structural or frequency signs |
+| `false`      | `false`      | `"undetermined"`  | `authentic`              | No detectable manipulation or AI indicators                             |
+
+
+### Decision Logic:
+
+* Use **ELA** as the **primary indicator** for manipulation.
+* Supplement with **FFT** and **Metadata** to improve reliability.
+* Combine using a simple rule-based or voting system.
+
+---
+
+## ⚙️ Performance Consideration
+
+| Method   | Speed       | Strength             |
+| -------- | ----------- | -------------------- |
+| ELA      | ❗ Slow      | ✅ Highly accurate    |
+| FFT      | ⚠️ Moderate | ⚠️ Somewhat reliable |
+| Metadata | 🚀 Fast     | ⚠️ Low confidence    |
+
+> For high-throughput systems, consider running Metadata first and conditionally applying ELA/FFT if suspicious.

features/image_edit_detector/controller.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import io
+from io import BytesIO
+from .detectors.fft import run_fft
+from .detectors.metadata import run_metadata
+from .detectors.ela import run_ela
+from .preprocess import preprocess_image
+from fastapi import HTTPException,status,Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+security=HTTPBearer()
+import os
+async def process_image_ela(image_bytes: bytes, quality: int=90):
+    image = Image.open(io.BytesIO(image_bytes))
+
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    compressed_image = preprocess_image(image, quality)
+    ela_result = run_ela(compressed_image, quality)
+
+    return {
+        "is_edited": ela_result,
+        "ela_score": ela_result
+    }
+
+async def process_fft_image(image_bytes: bytes,threshold:float=0.95) -> dict:
+    image = Image.open(BytesIO(image_bytes)).convert("RGB")
+    result = run_fft(image,threshold)
+    return {"edited": bool(result)}
+
+
+async def process_meta_image(image_bytes: bytes) -> dict:
+    try:
+        result = run_metadata(image_bytes)
+        return {"source": result}  # e.g. "edited", "phone_capture", "unknown"
+    except Exception as e:
+        # Handle errors gracefully, return useful message or raise HTTPException if preferred
+        return {"error": str(e)}
+
+
+async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    token = credentials.credentials
+    expected_token = os.getenv("MY_SECRET_TOKEN")
+    if token != expected_token:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid or expired token"
+        )
+    return token

features/image_edit_detector/detectors/ela.py

@@ -0,0 +1,32 @@
+from PIL import Image, ImageChops, ImageEnhance
+import io
+
+def run_ela(image: Image.Image, quality: int = 90, threshold: int = 15) -> bool:
+    """
+    Perform Error Level Analysis to detect image manipulation.
+
+    Parameters:
+        image (PIL.Image): Input image (should be RGB).
+        quality (int): JPEG compression quality for ELA.
+        threshold (int): Maximum pixel difference threshold to classify as edited.
+
+    Returns:
+        bool: True if image appears edited, False otherwise.
+    """
+
+    # Recompress the image into JPEG format in memory
+    buffer = io.BytesIO()
+    image.save(buffer, format='JPEG', quality=quality)
+    buffer.seek(0)
+    recompressed = Image.open(buffer)
+
+    # Compute the pixel-wise difference
+    diff = ImageChops.difference(image, recompressed)
+    extrema = diff.getextrema()
+    max_diff = max([ex[1] for ex in extrema])
+
+    # Enhance difference image for debug (not returned)
+    _ = ImageEnhance.Brightness(diff).enhance(10)
+
+    return max_diff > threshold
+

features/image_edit_detector/detectors/fft.py

@@ -0,0 +1,40 @@
+import numpy as np
+from PIL import Image
+from scipy.fft import fft2, fftshift
+
+
+def run_fft(image: Image.Image, threshold: float = 0.92) -> bool:
+    """
+    Detects potential image manipulation or generation using FFT-based high-frequency analysis.
+
+    Parameters:
+        image (PIL.Image.Image): The input image.
+        threshold (float): Proportion of high-frequency components above which the image is flagged.
+
+    Returns:
+        bool: True if the image is likely AI-generated or manipulated, False otherwise.
+    """
+    gray_image = image.convert("L")
+
+    resized_image = gray_image.resize((512, 512))
+
+
+    image_array = np.array(resized_image)
+
+    fft_result = fft2(image_array)
+
+    fft_shifted = fftshift(fft_result)
+
+    magnitude_spectrum = np.abs(fft_shifted)
+    max_magnitude = np.max(magnitude_spectrum)
+    if max_magnitude == 0:
+        return False  # Avoid division by zero if image is blank
+    normalized_spectrum = magnitude_spectrum / max_magnitude
+
+    high_freq_mask = normalized_spectrum > 0.5
+
+    high_freq_ratio = np.sum(high_freq_mask) / normalized_spectrum.size
+
+    is_fake = high_freq_ratio > threshold
+    return is_fake
+

features/image_edit_detector/detectors/metadata.py

@@ -0,0 +1,82 @@
+from PIL import Image, UnidentifiedImageError
+import io
+
+# Common AI metadata identifiers in image files.
+AI_INDICATORS = [
+    b'c2pa', b'claim_generator', b'claim_generator_info',
+    b'created_software_agent', b'actions.v2', b'assertions',
+    b'urn:c2pa', b'jumd', b'jumb', b'jumdcbor', b'jumdc2ma',
+    b'jumdc2as', b'jumdc2cl', b'cbor', b'convertedsfwareagent',b'c2pa.version', 
+    b'c2pa.assertions', b'c2pa.actions',
+    b'c2pa.thumbnail', b'c2pa.signature', b'c2pa.manifest',
+    b'c2pa.manifest_store', b'c2pa.ingredient', b'c2pa.parent',
+    b'c2pa.provenance', b'c2pa.claim', b'c2pa.hash', b'c2pa.authority',
+    b'jumdc2pn', b'jumdrefs', b'jumdver', b'jumdmeta',
+    
+    
+   'midjourney'.encode('utf-8'),
+   'stable-diffusion'.encode('utf-8'),
+   'stable diffusion'.encode('utf-8'),
+   'stable_diffusion'.encode('utf-8'),
+   'artbreeder'.encode('utf-8'),
+   'runwayml'.encode('utf-8'),
+   'remix.ai'.encode('utf-8'),
+   'firefly'.encode('utf-8'),
+   'adobe_firefly'.encode('utf-8'),
+
+    # OpenAI / DALL·E indicators (all encoded to bytes)
+    'openai'.encode('utf-8'),
+    'dalle'.encode('utf-8'),
+    'dalle2'.encode('utf-8'),
+    'DALL-E'.encode('utf-8'),
+    'DALL·E'.encode('utf-8'),
+    'created_by: openai'.encode('utf-8'),
+    'tool: dalle'.encode('utf-8'),
+    'tool: dalle2'.encode('utf-8'),
+    'creator: openai'.encode('utf-8'),
+    'creator: dalle'.encode('utf-8'),
+    'openai.com'.encode('utf-8'),
+    'api.openai.com'.encode('utf-8'),
+    'openai_model'.encode('utf-8'),
+    'openai_gpt'.encode('utf-8'),
+    
+    #Further possible AI-Generation Indicators
+    'generated_by'.encode('utf-8'),
+    'model_id'.encode('utf-8'),
+    'model_version'.encode('utf-8'),
+    'model_info'.encode('utf-8'),
+    'tool_name'.encode('utf-8'),
+    'tool_creator'.encode('utf-8'),
+    'tool_version'.encode('utf-8'),
+    'model_signature'.encode('utf-8'),
+    'ai_model'.encode('utf-8'),
+    'ai_tool'.encode('utf-8'),
+    'generator'.encode('utf-8'),
+    'generated_by_ai'.encode('utf-8'),
+    'ai_generated'.encode('utf-8'),
+    'ai_art'.encode('utf-8')
+    ]
+
+
+def run_metadata(image_bytes: bytes) -> str:
+    try:
+        img = Image.open(io.BytesIO(image_bytes))
+        img.load()
+
+        exif = img.getexif()
+        software = str(exif.get(305, "")).strip()
+
+        suspicious_editors = ["Photoshop", "GIMP", "Snapseed", "Pixlr", "VSCO", "Editor", "Adobe", "Luminar"]
+
+        if any(editor.lower() in software.lower() for editor in suspicious_editors):
+            return "edited"
+
+        if any(indicator in image_bytes for indicator in AI_INDICATORS):
+            return "ai_generated"
+
+        return "undetermined"
+
+    except UnidentifiedImageError:
+        return "error: invalid image format"
+    except Exception as e:
+        return f"error: {str(e)}"

features/image_edit_detector/preprocess.py

@@ -0,0 +1,9 @@
+from PIL import Image
+import io
+
+def preprocess_image(img: Image.Image, quality: int) -> Image.Image:
+    buffer = io.BytesIO()
+    img.save(buffer, format="JPEG", quality=quality)
+    buffer.seek(0)
+    return Image.open(buffer)
+

features/image_edit_detector/routes.py

@@ -0,0 +1,53 @@
+from slowapi import Limiter
+from config import ACCESS_RATE
+from fastapi import APIRouter, File, Request, Depends, HTTPException, UploadFile
+from fastapi.security import HTTPBearer
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+from io import BytesIO
+from .controller import process_image_ela , verify_token,process_fft_image, process_meta_image
+import requests
+router = APIRouter()
+limiter = Limiter(key_func=get_remote_address)
+security = HTTPBearer()
+
+
+
+@router.post("/ela")
+@limiter.limit(ACCESS_RATE)
+async def detect_ela(request:Request,file: UploadFile = File(...), quality: int = 90 ,token: str = Depends(verify_token)):
+    # Check file extension
+    allowed_types = ["image/jpeg", "image/png"]
+
+    if file.content_type not in allowed_types:
+        raise HTTPException(
+            status_code=400,
+            detail="Unsupported file type. Only JPEG and PNG images are allowed."
+        )
+    
+    content = await file.read()
+    result = await process_image_ela(content, quality)
+    return result
+
+@router.post("/fft")
+@limiter.limit(ACCESS_RATE)
+async def detect_fft(request:Request,file:UploadFile =File(...),threshold:float=0.95,token:str=Depends(verify_token)):
+    if file.content_type not in ["image/jpeg", "image/png"]:
+        raise HTTPException(status_code=400, detail="Unsupported image type.")
+    
+    content = await file.read()
+    result = await process_fft_image(content,threshold)
+    return result
+
+@router.post("/meta")
+@limiter.limit(ACCESS_RATE)
+async def detect_meta(request:Request,file:UploadFile=File(...),token:str=Depends(verify_token)):
+    if file.content_type not in ["image/jpeg", "image/png"]:
+        raise HTTPException(status_code=400, detail="Unsupported image type.")
+    content = await file.read()    
+    result = await process_meta_image(content)
+    return result
+@router.post("/health")
+@limiter.limit(ACCESS_RATE)
+def heath(request:Request):
+    return {"status":"ok"}

readme.md

@@ -1,35 +1,9 @@
-# 🚀 FastAPI AI Detector
-
-A production-ready FastAPI app for detecting AI vs. human-written text in English and Nepali. It uses GPT-2 and SentencePiece-based models, with Bearer token security.
-
-## 📂 Documentation
-
-- [Project Structure](docs/structure.md)
-- [API Endpoints](docs/api_endpoints.md)
-- [Setup & Installation](docs/setup.md)
-- [Deployment](docs/deployment.md)
-- [Security](docs/security.md)
-- [NestJS Integration](docs/nestjs_integration.md)
-- [Core Functions](docs/functions.md)
-
-## ⚡ Quick Start
-```bash
-uvicorn app:app --host 0.0.0.0 --port 8000
-```
-## 🚀 Deployment
-
-- **Local**: Use `uvicorn` as above.
-- **Railway/Heroku**: Use the provided `Procfile`.
-- **Hugging Face Spaces**: Use the `Dockerfile` for container deployment.
-
 ---
-
-## 💡 Tips
-
-- **Model files auto-download at first start** if not found.
-- **Keep `requirements.txt` up-to-date** after adding dependencies.
-- **All endpoints require the correct `Authorization` header**.
-- **For security**: Avoid committing `.env` to public repos.
-
+title: Ai-Checker
+emoji: 🚀
+colorFrom: yellow
+colorTo: blue
+sdk: docker
+pinned: false
 ---
 

test.md

@@ -0,0 +1,31 @@
+
+**Update: Edited & AI-Generated Content Detection – Project Plan**
+
+### 🔍 Phase 1: Rule-Based Image Detection (In Progress)
+
+We're implementing three core techniques to individually flag edited or AI-generated images:
+
+* **ELA (Error Level Analysis):** Highlights inconsistencies via JPEG recompression.
+* **FFT (Frequency Analysis):** Uses 2D Fourier Transform to detect unnatural image frequency patterns.
+* **Metadata Analysis:** Parses EXIF data to catch clues like editing software tags.
+
+ These give us visual + interpretable results for each image, and currently offer \~60–70% accuracy on typical AI-edited content.
+
+---
+
+###  Phase 2: AI vs Human Detection System (Coming Soon)
+
+**Goal:** Build an AI model that classifies whether content is AI- or human-made — initially focusing on **images**, and later expanding to **text**.
+
+**Data Strategy:**
+
+* Scraping large volumes of recent AI-gen images (e.g. SDXL, Gibbli, MidJourney).
+* Balancing with high-quality human images.
+
+**Model Plan:**
+
+* Use ELA, FFT, and metadata as feature extractors.
+* Feed these into a CNN or ensemble model.
+* Later, unify into a full web-based platform (upload → get AI/human probability).
+
+