import os
import time
from typing import Literal
import spaces
import gradio as gr
import modelscope_studio.components.antd as antd
import modelscope_studio.components.antdx as antdx
import modelscope_studio.components.base as ms
from transformers import pipeline, AutoImageProcessor, SwinForImageClassification, Swinv2ForImageClassification, AutoFeatureExtractor, AutoModelForImageClassification
from torchvision import transforms
import torch
from PIL import Image
import numpy as np
import io
import logging
from utils.utils import softmax, augment_image, convert_pil_to_bytes
from utils.gradient import gradient_processing
from utils.minmax import preprocess as minmax_preprocess
from utils.ela import genELA as ELA
from utils.wavelet import wavelet_blocking_noise_estimation
from utils.bitplane import bit_plane_extractor
from utils.hf_logger import log_inference_data
from utils.text_content import QUICK_INTRO, IMPLEMENTATION
from agents.monitoring_agents import EnsembleMonitorAgent, WeightOptimizationAgent, SystemHealthAgent
from agents.smart_agents import ContextualIntelligenceAgent, ForensicAnomalyDetectionAgent
from forensics.registry import register_model, MODEL_REGISTRY, ModelEntry
from agents.weight_management import ModelWeightManager
from dotenv import load_dotenv
import json
from huggingface_hub import CommitScheduler
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
os.environ['HF_HUB_CACHE'] = './models'
LOCAL_LOG_DIR = "./hf_inference_logs"
HF_DATASET_NAME="degentic_rd0"
load_dotenv()
# print(os.getenv("HF_HUB_CACHE"))
# Custom JSON Encoder to handle numpy types
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.float32):
return float(obj)
return json.JSONEncoder.default(self, obj)
# Ensure using GPU if available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
header_style = {
"textAlign": 'center',
"color": '#fff',
"height": 64,
"paddingInline": 48,
"lineHeight": '64px',
"backgroundColor": '#4096ff',
}
content_style = {
"textAlign": 'center',
"minHeight": 120,
"lineHeight": '120px',
"color": '#fff',
"backgroundColor": '#0958d9',
}
sider_style = {
"textAlign": 'center',
"lineHeight": '120px',
"color": '#fff',
"backgroundColor": '#1677ff',
}
footer_style = {
"textAlign": 'center',
"color": '#fff',
"backgroundColor": '#4096ff',
}
layout_style = {
"borderRadius": 8,
"overflow": 'hidden',
"width": 'calc(100% - 8px)',
"maxWidth": 'calc(100% - 8px)',
}
# Model paths and class names
MODEL_PATHS = {
"model_1": "haywoodsloan/ai-image-detector-deploy",
"model_2": "Heem2/AI-vs-Real-Image-Detection",
"model_3": "Organika/sdxl-detector",
"model_4": "cmckinle/sdxl-flux-detector_v1.1",
"model_5": "prithivMLmods/Deep-Fake-Detector-v2-Model",
"model_5b": "prithivMLmods/Deepfake-Detection-Exp-02-22",
"model_6": "ideepankarsharma2003/AI_ImageClassification_MidjourneyV6_SDXL",
"model_7": "date3k2/vit-real-fake-classification-v4"
}
CLASS_NAMES = {
"model_1": ['artificial', 'real'],
"model_2": ['AI Image', 'Real Image'],
"model_3": ['AI', 'Real'],
"model_4": ['AI', 'Real'],
"model_5": ['Realism', 'Deepfake'],
"model_5b": ['Real', 'Deepfake'],
"model_6": ['ai_gen', 'human'],
"model_7": ['Fake', 'Real'],
}
def preprocess_resize_256(image):
if image.mode != 'RGB':
image = image.convert('RGB')
return transforms.Resize((256, 256))(image)
def preprocess_resize_224(image):
if image.mode != 'RGB':
image = image.convert('RGB')
return transforms.Resize((224, 224))(image)
def postprocess_pipeline(prediction, class_names):
# Assumes HuggingFace pipeline output
return {pred['label']: pred['score'] for pred in prediction}
def postprocess_logits(outputs, class_names):
# Assumes model output with logits
logits = outputs.logits.cpu().numpy()[0]
probabilities = softmax(logits)
return {class_names[i]: probabilities[i] for i in range(len(class_names))}
# Expand ModelEntry to include metadata
# (Assume ModelEntry is updated in registry.py to accept display_name, contributor, model_path)
# If not, we will update registry.py accordingly after this.
def register_model_with_metadata(model_id, model, preprocess, postprocess, class_names, display_name, contributor, model_path):
entry = ModelEntry(model, preprocess, postprocess, class_names)
entry.display_name = display_name
entry.contributor = contributor
entry.model_path = model_path
MODEL_REGISTRY[model_id] = entry
# Load and register models (example for two models)
image_processor_1 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_1"], use_fast=True)
model_1 = Swinv2ForImageClassification.from_pretrained(MODEL_PATHS["model_1"]).to(device)
clf_1 = pipeline(model=model_1, task="image-classification", image_processor=image_processor_1, device=device)
register_model_with_metadata(
"model_1", clf_1, preprocess_resize_256, postprocess_pipeline, CLASS_NAMES["model_1"],
display_name="SwinV2 Based", contributor="haywoodsloan", model_path=MODEL_PATHS["model_1"]
)
clf_2 = pipeline("image-classification", model=MODEL_PATHS["model_2"], device=device)
register_model_with_metadata(
"model_2", clf_2, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_2"],
display_name="ViT Based", contributor="Heem2", model_path=MODEL_PATHS["model_2"]
)
# Register remaining models
feature_extractor_3 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_3"], device=device)
model_3 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_3"]).to(device)
def preprocess_256(image):
if image.mode != 'RGB':
image = image.convert('RGB')
return transforms.Resize((256, 256))(image)
def postprocess_logits_model3(outputs, class_names):
logits = outputs.logits.cpu().numpy()[0]
probabilities = softmax(logits)
return {class_names[i]: probabilities[i] for i in range(len(class_names))}
def model3_infer(image):
inputs = feature_extractor_3(image, return_tensors="pt").to(device)
with torch.no_grad():
outputs = model_3(**inputs)
return outputs
register_model_with_metadata(
"model_3", model3_infer, preprocess_256, postprocess_logits_model3, CLASS_NAMES["model_3"],
display_name="SDXL Dataset", contributor="Organika", model_path=MODEL_PATHS["model_3"]
)
feature_extractor_4 = AutoFeatureExtractor.from_pretrained(MODEL_PATHS["model_4"], device=device)
model_4 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_4"]).to(device)
def model4_infer(image):
inputs = feature_extractor_4(image, return_tensors="pt").to(device)
with torch.no_grad():
outputs = model_4(**inputs)
return outputs
def postprocess_logits_model4(outputs, class_names):
logits = outputs.logits.cpu().numpy()[0]
probabilities = softmax(logits)
return {class_names[i]: probabilities[i] for i in range(len(class_names))}
register_model_with_metadata(
"model_4", model4_infer, preprocess_256, postprocess_logits_model4, CLASS_NAMES["model_4"],
display_name="SDXL + FLUX", contributor="cmckinle", model_path=MODEL_PATHS["model_4"]
)
clf_5 = pipeline("image-classification", model=MODEL_PATHS["model_5"], device=device)
register_model_with_metadata(
"model_5", clf_5, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_5"],
display_name="Vit Based", contributor="prithivMLmods", model_path=MODEL_PATHS["model_5"]
)
clf_5b = pipeline("image-classification", model=MODEL_PATHS["model_5b"], device=device)
register_model_with_metadata(
"model_5b", clf_5b, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_5b"],
display_name="Vit Based, Newer Dataset", contributor="prithivMLmods", model_path=MODEL_PATHS["model_5b"]
)
image_processor_6 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_6"], use_fast=True)
model_6 = SwinForImageClassification.from_pretrained(MODEL_PATHS["model_6"]).to(device)
clf_6 = pipeline(model=model_6, task="image-classification", image_processor=image_processor_6, device=device)
register_model_with_metadata(
"model_6", clf_6, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_6"],
display_name="Swin, Midj + SDXL", contributor="ideepankarsharma2003", model_path=MODEL_PATHS["model_6"]
)
image_processor_7 = AutoImageProcessor.from_pretrained(MODEL_PATHS["model_7"], use_fast=True)
model_7 = AutoModelForImageClassification.from_pretrained(MODEL_PATHS["model_7"]).to(device)
clf_7 = pipeline(model=model_7, task="image-classification", image_processor=image_processor_7, device=device)
register_model_with_metadata(
"model_7", clf_7, preprocess_resize_224, postprocess_pipeline, CLASS_NAMES["model_7"],
display_name="ViT", contributor="temp", model_path=MODEL_PATHS["model_7"]
)
# Generic inference function
def infer(image: Image.Image, model_id: str, confidence_threshold: float = 0.75) -> dict:
entry = MODEL_REGISTRY[model_id]
img = entry.preprocess(image)
try:
result = entry.model(img)
scores = entry.postprocess(result, entry.class_names)
# Flatten output for Dataframe: include metadata and both class scores
ai_score = float(scores.get(entry.class_names[0], 0.0))
real_score = float(scores.get(entry.class_names[1], 0.0))
label = "AI" if ai_score >= confidence_threshold else ("REAL" if real_score >= confidence_threshold else "UNCERTAIN")
return {
"Model": entry.display_name,
"Contributor": entry.contributor,
"HF Model Path": entry.model_path,
"AI Score": ai_score,
"Real Score": real_score,
"Label": label
}
except Exception as e:
return {
"Model": entry.display_name,
"Contributor": entry.contributor,
"HF Model Path": entry.model_path,
"AI Score": 0.0, # Ensure it's a float even on error
"Real Score": 0.0, # Ensure it's a float even on error
"Label": f"Error: {str(e)}"
}
# Update predict_image to use all registered models in order
def predict_image(img, confidence_threshold):
model_ids = [
"model_1", "model_2", "model_3", "model_4", "model_5", "model_5b", "model_6", "model_7"
]
results = [infer(img, model_id, confidence_threshold) for model_id in model_ids]
return img, results
def get_consensus_label(results):
labels = [r[4] for r in results if len(r) > 4]
if not labels:
return "No results"
consensus = max(set(labels), key=labels.count)
color = {"AI": "red", "REAL": "green", "UNCERTAIN": "orange"}.get(consensus, "gray")
return f"{consensus}"
# Update predict_image_with_json to return consensus label
def predict_image_with_json(img, confidence_threshold, augment_methods, rotate_degrees, noise_level, sharpen_strength):
# Ensure img is a PIL Image (if it's not already)
if not isinstance(img, Image.Image):
try:
# If it's a numpy array, convert it
img = Image.fromarray(img)
except Exception as e:
logger.error(f"Error converting input image to PIL: {e}")
# If conversion fails, it's a critical error for the whole process
raise ValueError("Input image could not be converted to PIL Image.")
# Initialize agents
monitor_agent = EnsembleMonitorAgent()
weight_manager = ModelWeightManager()
optimization_agent = WeightOptimizationAgent(weight_manager)
health_agent = SystemHealthAgent()
# New smart agents
context_agent = ContextualIntelligenceAgent()
anomaly_agent = ForensicAnomalyDetectionAgent()
# Monitor system health
health_agent.monitor_system_health()
if augment_methods:
img_pil, _ = augment_image(img, augment_methods, rotate_degrees, noise_level, sharpen_strength)
else:
img_pil = img
img_np_og = np.array(img) # Convert PIL Image to NumPy array
# 1. Get initial predictions from all models
model_predictions_raw = {}
confidence_scores = {}
results = [] # To store the results for the DataFrame
for model_id in MODEL_REGISTRY:
model_start = time.time()
result = infer(img_pil, model_id, confidence_threshold)
model_end = time.time()
# Monitor individual model performance
monitor_agent.monitor_prediction(
model_id,
result["Label"],
max(result.get("AI Score", 0.0), result.get("Real Score", 0.0)),
model_end - model_start
)
model_predictions_raw[model_id] = result # Store the full result dictionary
confidence_scores[model_id] = max(result.get("AI Score", 0.0), result.get("Real Score", 0.0))
results.append(result) # Add individual model result to the list
# 2. Infer context tags using ContextualIntelligenceAgent
image_data_for_context = {
"width": img.width,
"height": img.height,
"mode": img.mode,
# Add more features like EXIF data if exif_full_dump is used
}
detected_context_tags = context_agent.infer_context_tags(image_data_for_context, model_predictions_raw)
logger.info(f"Detected context tags: {detected_context_tags}")
# 3. Get adjusted weights, passing context tags
adjusted_weights = weight_manager.adjust_weights(model_predictions_raw, confidence_scores, context_tags=detected_context_tags)
# 4. Optimize weights if needed
# `final_prediction_label` is determined AFTER weighted consensus, so analyze_performance will be called later
# 5. Calculate weighted consensus
weighted_predictions = {
"AI": 0.0,
"REAL": 0.0,
"UNCERTAIN": 0.0
}
for model_id, prediction in model_predictions_raw.items(): # Use raw predictions for weighting
# Ensure the prediction label is valid for weighted_predictions
prediction_label = prediction.get("Label") # Extract the label
if prediction_label in weighted_predictions:
weighted_predictions[prediction_label] += adjusted_weights[model_id]
else:
# Handle cases where prediction might be an error or unexpected label
logger.warning(f"Unexpected prediction label '{prediction_label}' from model '{model_id}'. Skipping its weight in consensus.")
final_prediction_label = "UNCERTAIN"
if weighted_predictions["AI"] > weighted_predictions["REAL"] and weighted_predictions["AI"] > weighted_predictions["UNCERTAIN"]:
final_prediction_label = "AI"
elif weighted_predictions["REAL"] > weighted_predictions["AI"] and weighted_predictions["REAL"] > weighted_predictions["UNCERTAIN"]:
final_prediction_label = "REAL"
# Call analyze_performance after final_prediction_label is known
optimization_agent.analyze_performance(final_prediction_label, None)
# 6. Perform forensic processing
gradient_image = gradient_processing(img_np_og) # Added gradient processing
minmax_image = minmax_preprocess(img_np_og) # Added MinMax processing
# First pass - standard analysis
ela1 = ELA(img_np_og, quality=75, scale=50, contrast=20, linear=False, grayscale=True)
# Second pass - enhanced visibility
ela2 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=True)
ela3 = ELA(img_np_og, quality=75, scale=75, contrast=25, linear=False, grayscale=False)
forensics_images = [img_pil, ela1, ela2, ela3, gradient_image, minmax_image]
# 7. Generate boilerplate descriptions for forensic outputs for anomaly agent
forensic_output_descriptions = [
f"Original augmented image (PIL): {img_pil.width}x{img_pil.height}",
"ELA analysis (Pass 1): Grayscale error map, quality 75.",
"ELA analysis (Pass 2): Grayscale error map, quality 75, enhanced contrast.",
"ELA analysis (Pass 3): Color error map, quality 75, enhanced contrast.",
"Gradient processing: Highlights edges and transitions.",
"MinMax processing: Deviations in local pixel values."
]
# You could also add descriptions for Wavelet and Bit Plane if they were dynamic outputs
# For instance, if wavelet_blocking_noise_estimation had parameters that changed and you wanted to describe them.
# 8. Analyze forensic outputs for anomalies using ForensicAnomalyDetectionAgent
anomaly_detection_results = anomaly_agent.analyze_forensic_outputs(forensic_output_descriptions)
logger.info(f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
# Prepare table rows for Dataframe (exclude model path)
table_rows = [[
r.get("Model", ""),
r.get("Contributor", ""),
r.get("AI Score", 0.0) if r.get("AI Score") is not None else 0.0,
r.get("Real Score", 0.0) if r.get("Real Score") is not None else 0.0,
r.get("Label", "Error")
] for r in results]
logger.info(f"Type of table_rows: {type(table_rows)}")
for i, row in enumerate(table_rows):
logger.info(f"Row {i} types: {[type(item) for item in row]}")
# The get_consensus_label function is now replaced by final_prediction_label from weighted consensus
consensus_html = f"{final_prediction_label}"
# Prepare data for logging to Hugging Face dataset
inference_params = {
"confidence_threshold": confidence_threshold,
"augment_methods": augment_methods,
"rotate_degrees": rotate_degrees,
"noise_level": noise_level,
"sharpen_strength": sharpen_strength,
"detected_context_tags": detected_context_tags
}
ensemble_output_data = {
"final_prediction_label": final_prediction_label,
"weighted_predictions": weighted_predictions,
"adjusted_weights": adjusted_weights
}
# Collect agent monitoring data
agent_monitoring_data_log = {
"ensemble_monitor": {
"alerts": monitor_agent.alerts,
"performance_metrics": monitor_agent.performance_metrics
},
"weight_optimization": {
"prediction_history_length": len(optimization_agent.prediction_history),
# You might add a summary of recent accuracy here if _calculate_accuracy is exposed
},
"system_health": {
"memory_usage": health_agent.health_metrics["memory_usage"],
"gpu_utilization": health_agent.health_metrics["gpu_utilization"]
},
"context_intelligence": {
"detected_context_tags": detected_context_tags
},
"forensic_anomaly_detection": anomaly_detection_results
}
# Log the inference data
log_inference_data(
original_image=img, # Use the original uploaded image
inference_params=inference_params,
model_predictions=results, # This already contains detailed results for each model
ensemble_output=ensemble_output_data,
forensic_images=forensics_images, # This is the list of PIL images generated by forensic tools
agent_monitoring_data=agent_monitoring_data_log,
human_feedback=None # This can be populated later with human review data
)
# Final type safety check for forensic_images before returning
cleaned_forensics_images = []
for f_img in forensics_images:
if isinstance(f_img, Image.Image):
cleaned_forensics_images.append(f_img)
elif isinstance(f_img, np.ndarray):
try:
cleaned_forensics_images.append(Image.fromarray(f_img))
except Exception as e:
logger.warning(f"Could not convert numpy array to PIL Image for gallery: {e}")
# Optionally, append a placeholder or skip
else:
logger.warning(f"Unexpected type in forensic_images: {type(f_img)}. Skipping.")
logger.info(f"Cleaned forensic images types: {[type(img) for img in cleaned_forensics_images]}")
# Ensure numerical values in results are standard Python floats before JSON serialization
for i, res_dict in enumerate(results):
for key in ["AI Score", "Real Score"]:
value = res_dict.get(key)
if isinstance(value, np.float32):
res_dict[key] = float(value)
logger.info(f"Converted {key} for result {i} from numpy.float32 to float.")
# Return raw model results as JSON string for debug_json component
json_results = json.dumps(results, cls=NumpyEncoder)
return img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
with gr.Blocks(css="#post-gallery { overflow: hidden !important;} .grid-wrap{ overflow-y: hidden !important;} .ms-gr-ant-welcome-icon{ height:unset !important;} .tabs{margin-top:10px;}") as demo:
with ms.Application() as app:
with antd.ConfigProvider():
antdx.Welcome(
icon="https://cdn-avatars.huggingface.co/v1/production/uploads/639daf827270667011153fbc/WpeSFhuB81DY-1TjNUmV_.png",
title="Welcome to Project OpenSight",
description="The OpenSight aims to be an open-source SOTA generated image detection model. This HF Space is not only an introduction but a educational playground for the public to evaluate and challenge current open source models. **Space will be upgraded shortly; inference on all 6 models should take about 1.2~ seconds.** "
)
with gr.Tab("π Detection Models Eval / Playground"):
gr.Markdown("# Open Source Detection Models Found on the Hub\n\n - **Space will be upgraded shortly;** inference on all 6 models should take about 1.2~ seconds once we're back on CUDA.\n - The **Community Forensics** mother of all detection models is now available for inference, head to the middle tab above this.\n - Lots of exciting things coming up, stay tuned!")
with gr.Row():
with gr.Column(scale=1):
image_input = gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='pil')
with gr.Accordion("Settings (Optional)", open=False, elem_id="settings_accordion"):
augment_checkboxgroup = gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], label="Augmentation Methods")
rotate_slider = gr.Slider(0, 45, value=2, step=1, label="Rotate Degrees", visible=False)
noise_slider = gr.Slider(0, 50, value=4, step=1, label="Noise Level", visible=False)
sharpen_slider = gr.Slider(0, 50, value=11, step=1, label="Sharpen Strength", visible=False)
confidence_slider = gr.Slider(0.0, 1.0, value=0.75, step=0.05, label="Confidence Threshold")
inputs = [image_input, confidence_slider, augment_checkboxgroup, rotate_slider, noise_slider, sharpen_slider]
predict_button = gr.Button("Predict")
augment_button = gr.Button("Augment & Predict")
image_output = gr.Image(label="Processed Image", visible=False)
with gr.Column(scale=2):
# Use Gradio-native Dataframe to display results with headers
results_table = gr.Dataframe(
label="Model Predictions",
headers=["Model", "Contributor", "AI Score", "Real Score", "Label"],
datatype=["str", "str", "number", "number", "str"]
)
forensics_gallery = gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery")
with gr.Accordion("Debug Output (Raw JSON)", open=False):
debug_json = gr.JSON(label="Raw Model Results")
consensus_md = gr.Markdown(label="Consensus", value="")
outputs = [image_output, forensics_gallery, results_table, debug_json, consensus_md]
# Show/hide rotate slider based on selected augmentation method
augment_checkboxgroup.change(lambda methods: gr.update(visible="rotate" in methods), inputs=[augment_checkboxgroup], outputs=[rotate_slider])
augment_checkboxgroup.change(lambda methods: gr.update(visible="add_noise" in methods), inputs=[augment_checkboxgroup], outputs=[noise_slider])
augment_checkboxgroup.change(lambda methods: gr.update(visible="sharpen" in methods), inputs=[augment_checkboxgroup], outputs=[sharpen_slider])
predict_button.click(
fn=predict_image_with_json,
inputs=inputs,
outputs=outputs,
api_name="/predict"
)
augment_button.click( # Connect Augment button to the function
fn=predict_image_with_json,
inputs=[
image_input,
confidence_slider,
gr.CheckboxGroup(["rotate", "add_noise", "sharpen"], value=["rotate", "add_noise", "sharpen"], visible=False), # Default values
rotate_slider,
noise_slider,
sharpen_slider
],
outputs=outputs,
api_name="/augment"
)
with gr.Tab("π Project Introduction"):
gr.Markdown(QUICK_INTRO)
with gr.Tab("π Community Forensics Preview"):
# temp_space = gr.load("aiwithoutborders-xyz/OpenSight-Community-Forensics-Preview", src="spaces")
gr.Markdown("Community Forensics Preview coming soon!") # Placeholder for now
with gr.Tab("π₯ Leaderboard"):
gr.Markdown("# AI Generated / Deepfake Detection Models Leaderboard: Soonβ’")
with gr.Tab("Wavelet Blocking Noise Estimation", visible=False):
gr.Interface(
fn=wavelet_blocking_noise_estimation,
inputs=[gr.Image(type="pil"), gr.Slider(1, 32, value=8, step=1, label="Block Size")],
outputs=gr.Image(type="pil"),
title="Wavelet-Based Noise Analysis",
description="Analyzes image noise patterns using wavelet decomposition. This tool helps detect compression artifacts and artificial noise patterns that may indicate image manipulation. Higher noise levels in specific regions can reveal areas of potential tampering.",
api_name="/tool_waveletnoise"
)
with gr.Tab("Bit Plane Values", visible=False):
"""Forensics Tool: Bit Plane Extractor
Args:
image: PIL Image to analyze
channel: Color channel to extract bit plane from ("Luminance", "Red", "Green", "Blue", "RGB Norm")
bit_plane: Bit plane index to extract (0-7)
filter_type: Filter to apply ("Disabled", "Median", "Gaussian")
"""
gr.Interface(
fn=bit_plane_extractor,
inputs=[
gr.Image(type="pil"),
gr.Dropdown(["Luminance", "Red", "Green", "Blue", "RGB Norm"], label="Channel", value="Luminance"),
gr.Slider(0, 7, value=0, step=1, label="Bit Plane"),
gr.Dropdown(["Disabled", "Median", "Gaussian"], label="Filter", value="Disabled")
],
outputs=gr.Image(type="pil"),
title="Bit Plane Analysis",
description="Extracts and visualizes individual bit planes from different color channels. This forensic tool helps identify hidden patterns and artifacts in image data that may indicate manipulation. Different bit planes can reveal inconsistencies in image processing or editing.",
api_name="/tool_bitplane"
)
# with gr.Tab("EXIF Full Dump"):
# gr.Interface(
# fn=exif_full_dump,
# inputs=gr.Image(type="pil"),
# outputs=gr.JSON(),
# description="Extract all EXIF metadata from the uploaded image."
# )
# --- MCP-Ready Launch ---
if __name__ == "__main__":
# Initialize CommitScheduler
# The scheduler will monitor LOCAL_LOG_DIR and push changes to HF_DATASET_NAME
with CommitScheduler(
repo_id=HF_DATASET_NAME, # Your Hugging Face dataset repository ID
repo_type="dataset",
folder_path=LOCAL_LOG_DIR,
every=5, # Commit every 5 minutes
private=False, # Keep your dataset private
token=os.getenv("HF_TOKEN") # Uncomment and set if token is not saved globally
) as scheduler:
demo.launch(mcp_server=True)