import gradio as gr
import cv2
import numpy as np
from PIL import Image
import io
import json
from datetime import datetime
from typing import List, Tuple, Optional
import tempfile
import zipfile
from pathlib import Path
class WarehouseStitcher:
"""Production-ready warehouse image stitching pipeline"""
def __init__(self):
self.version = "1.0.0"
self.config = {
'feature_extractor': 'SIFT',
'matcher': 'BF',
'use_clahe': True,
'detect_rack_labels': True,
'ransac_threshold': 5.0,
'min_match_count': 10,
}
def preprocess_image(self, img: np.ndarray) -> np.ndarray:
"""Apply CLAHE and preprocessing"""
if len(img.shape) == 3:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
gray = img
if self.config['use_clahe']:
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
gray = clahe.apply(gray)
return gray
def detect_rack_labels(self, img: np.ndarray) -> List[dict]:
"""Detect warehouse rack labels"""
labels = []
gray = self.preprocess_image(img)
edges = cv2.Canny(gray, 50, 150)
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
area = cv2.contourArea(contour)
if 500 < area < 50000:
x, y, w, h = cv2.boundingRect(contour)
aspect_ratio = w / float(h)
if 2.0 < aspect_ratio < 8.0:
labels.append({
'bbox': (x, y, w, h),
'area': area,
'center': (x + w//2, y + h//2)
})
return labels
def extract_features(self, img: np.ndarray) -> Tuple:
"""Extract features with selected method"""
gray = self.preprocess_image(img)
if self.config['feature_extractor'] == 'SIFT':
detector = cv2.SIFT_create(nfeatures=2000, contrastThreshold=0.03, edgeThreshold=10)
elif self.config['feature_extractor'] == 'ORB':
detector = cv2.ORB_create(nfeatures=2000)
else:
detector = cv2.AKAZE_create()
# keypoints, descriptors = detector.detectAndCompute(gray, None)
keypoints, descriptors = detector.detectAndCompute(gray, None)
keypoints = list(keypoints) if keypoints is not None else []
# Add rack label keypoints
if self.config['detect_rack_labels']:
labels = self.detect_rack_labels(gray)
for label in labels:
cx, cy = label['center']
keypoints.append(cv2.KeyPoint(float(cx), float(cy), 10))
return keypoints, descriptors, gray
def match_features(self, desc1: np.ndarray, desc2: np.ndarray) -> List:
"""Match features with Lowe's ratio test"""
if desc1 is None or desc2 is None:
return []
if self.config['feature_extractor'] == 'ORB':
matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
else:
matcher = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
matches = matcher.knnMatch(desc1, desc2, k=2)
good_matches = []
for match_pair in matches:
if len(match_pair) == 2:
m, n = match_pair
if m.distance < 0.75 * n.distance:
good_matches.append(m)
return good_matches
def estimate_homography(self, kp1, kp2, matches):
"""Estimate homography with RANSAC"""
if len(matches) < self.config['min_match_count']:
return None, None, 0.0
src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,
self.config['ransac_threshold'])
if H is None:
return None, None, 0.0
inliers = np.sum(mask)
confidence = inliers / len(matches)
return H, mask, confidence
def blend_images(self, img1: np.ndarray, img2: np.ndarray, H: np.ndarray) -> np.ndarray:
"""Blend images using homography"""
h1, w1 = img1.shape[:2]
h2, w2 = img2.shape[:2]
pts2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)
pts2_transformed = cv2.perspectiveTransform(pts2, H)
pts = np.concatenate((pts2_transformed,
np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)),
axis=0)
[xmin, ymin] = np.int32(pts.min(axis=0).ravel() - 0.5)
[xmax, ymax] = np.int32(pts.max(axis=0).ravel() + 0.5)
t = [-xmin, -ymin]
Ht = np.array([[1, 0, t[0]], [0, 1, t[1]], [0, 0, 1]])
result = cv2.warpPerspective(img2, Ht.dot(H), (xmax - xmin, ymax - ymin))
result[t[1]:h1 + t[1], t[0]:w1 + t[0]] = img1
return result
def stitch_images(self, images: List, progress=gr.Progress()) -> Tuple:
"""Main stitching pipeline with progress tracking"""
if not images or len(images) < 2:
return None, "❌ Error: Please upload at least 2 images", None
logs = []
logs.append("=" * 70)
logs.append("🏭 INDUSTRIAL WAREHOUSE IMAGE STITCHING PIPELINE")
logs.append("=" * 70)
logs.append(f"📅 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
logs.append(f"📸 Images to process: {len(images)}")
logs.append("")
# Convert images
cv_images = []
for i, img in enumerate(images):
if isinstance(img, str):
img = cv2.imread(img)
elif isinstance(img, Image.Image):
img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
cv_images.append(img)
logs.append(f"✓ Image {i+1}: {img.shape[1]}x{img.shape[0]} pixels")
logs.append("")
# Start stitching
result = cv_images[0]
total_matches = 0
total_inliers = 0
for i in range(1, len(cv_images)):
# progress((i / len(cv_images), f"Processing image {i+1}/{len(cv_images)}"))
progress(i / len(cv_images))
logs.append("-" * 70)
logs.append(f"🔄 PROCESSING IMAGE {i+1}/{len(cv_images)}")
logs.append("-" * 70)
# Extract features
kp1, desc1, _ = self.extract_features(result)
kp2, desc2, _ = self.extract_features(cv_images[i])
logs.append(f"🔍 Features: {len(kp1)} ↔ {len(kp2)}")
# Match features
matches = self.match_features(desc1, desc2)
total_matches += len(matches)
logs.append(f"🔗 Matches: {len(matches)} good matches")
if len(matches) < self.config['min_match_count']:
logs.append(f"⚠️ WARNING: Only {len(matches)} matches")
logs.append(f"⏭️ Skipping image {i+1}")
continue
# Estimate homography
H, mask, confidence = self.estimate_homography(kp1, kp2, matches)
if H is None:
logs.append(f"❌ ERROR: Failed to compute homography")
continue
inliers = int(np.sum(mask))
total_inliers += inliers
logs.append(f"📐 Homography: {inliers}/{len(matches)} inliers ({confidence:.1%})")
# Blend
result = self.blend_images(result, cv_images[i], H)
logs.append(f"✅ Success! New size: {result.shape[1]}x{result.shape[0]}")
logs.append("")
# Final summary
logs.append("=" * 70)
logs.append("📊 FINAL STATISTICS")
logs.append("=" * 70)
logs.append(f"✓ Final Resolution: {result.shape[1]} x {result.shape[0]} pixels")
logs.append(f"✓ Total Matches: {total_matches:,}")
logs.append(f"✓ Total Inliers: {total_inliers:,}")
logs.append("=" * 70)
# Convert result to RGB
result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
result_pil = Image.fromarray(result_rgb)
# Save to temporary file for download
with tempfile.NamedTemporaryFile(mode='wb', suffix='.png', delete=False) as f:
result_pil.save(f, format='PNG', optimize=True)
temp_path = f.name
# Return (image preview, logs, downloadable file path)
return result_pil, "\n".join(logs), temp_path
class PoseGuidedWarehouseStitcher(WarehouseStitcher):
"""Enhanced version using drone pose metadata for guided stitching"""
def load_metadata_from_file(self, json_path: str) -> dict:
"""Load JSON metadata file"""
with open(json_path, 'r') as f:
return json.load(f)
def calculate_relative_motion(self, pose1: dict, pose2: dict) -> dict:
"""Calculate relative motion between two poses"""
nav1 = pose1['nav_snapshot']
nav2 = pose2['nav_snapshot']
dx = nav2['x'] - nav1['x']
dy = nav2['y'] - nav1['y']
dz = nav2['z'] - nav1['z']
dyaw = nav2['yaw'] - nav1['yaw']
distance = np.sqrt(dx**2 + dy**2 + dz**2)
return {
'dx': dx, 'dy': dy, 'dz': dz,
'dyaw': dyaw,
'distance': distance,
'avg_height': (abs(nav1['z']) + abs(nav2['z'])) / 2
}
def estimate_homography_from_pose(self, motion: dict, img_width: int, img_height: int) -> np.ndarray:
"""Estimate initial homography from drone pose data"""
focal_length_px = img_width * 0.8
scale = abs(motion['avg_height']) if motion['avg_height'] != 0 else 10.0
tx = (motion['dx'] / scale) * focal_length_px
ty = (motion['dy'] / scale) * focal_length_px
theta = motion['dyaw']
cos_theta = np.cos(theta)
sin_theta = np.sin(theta)
H = np.array([
[cos_theta, -sin_theta, tx],
[sin_theta, cos_theta, ty],
[0, 0, 1]
], dtype=np.float64)
return H
def sort_by_capture_sequence(self, image_paths: List[str], metadata_paths: List[str]) -> Tuple[List, List]:
"""Sort images by capture timestamp"""
pairs = []
for img_path, meta_path in zip(image_paths, metadata_paths):
metadata = self.load_metadata_from_file(meta_path)
timestamp = metadata['nav_snapshot']['timestamp_usec']
pairs.append((timestamp, img_path, meta_path, metadata))
pairs.sort(key=lambda x: x[0])
sorted_imgs = [p[1] for p in pairs]
sorted_metas = [p[3] for p in pairs]
return sorted_imgs, sorted_metas
def stitch_with_poses(self, image_paths: List[str], metadata_paths: List[str],
progress=gr.Progress()) -> Tuple:
"""Main pose-guided stitching pipeline"""
if len(image_paths) != len(metadata_paths):
return None, "❌ Error: Number of images and metadata files must match", None
if len(image_paths) < 2:
return None, "❌ Error: Need at least 2 images", None
logs = []
logs.append("=" * 70)
logs.append("🚁 POSE-GUIDED DRONE IMAGE STITCHING PIPELINE")
logs.append("=" * 70)
logs.append(f"📅 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
logs.append(f"📸 Image pairs to process: {len(image_paths)}")
logs.append("")
# Sort by timestamp
logs.append("🔄 Sorting images by capture sequence...")
sorted_imgs, sorted_metas = self.sort_by_capture_sequence(image_paths, metadata_paths)
logs.append(f"✓ Images sorted chronologically")
logs.append("")
# Load first image
result = cv2.imread(sorted_imgs[0])
logs.append(f"📸 Image 1: {result.shape[1]}x{result.shape[0]} @ z={sorted_metas[0]['nav_snapshot']['z']:.2f}m")
total_matches = 0
total_inliers = 0
# Process each subsequent image
for i in range(1, len(sorted_imgs)):
# progress((i / len(sorted_imgs), f"Stitching image {i+1}/{len(sorted_imgs)}"))
progress(i / len(sorted_imgs))
logs.append("-" * 70)
logs.append(f"🔄 PROCESSING IMAGE PAIR {i}/{len(sorted_imgs)-1}")
logs.append("-" * 70)
# Load current image
current_img = cv2.imread(sorted_imgs[i])
logs.append(f"📸 Image {i+1}: {current_img.shape[1]}x{current_img.shape[0]} @ z={sorted_metas[i]['nav_snapshot']['z']:.2f}m")
# Calculate relative motion
motion = self.calculate_relative_motion(sorted_metas[i-1], sorted_metas[i])
logs.append(f"📍 Drone motion: Δx={motion['dx']:.3f}m, Δy={motion['dy']:.3f}m, Δz={motion['dz']:.3f}m")
logs.append(f"🧭 Yaw change: {np.degrees(motion['dyaw']):.2f}°")
logs.append(f"📏 Distance: {motion['distance']:.3f}m")
# Get initial homography estimate from pose
H_initial = self.estimate_homography_from_pose(motion, result.shape[1], result.shape[0])
logs.append(f"🎯 Initial homography estimated from drone pose")
# Extract features
kp1, desc1, _ = self.extract_features(result)
kp2, desc2, _ = self.extract_features(current_img)
logs.append(f"🔍 Features: {len(kp1)} ↔ {len(kp2)}")
# Match features
matches = self.match_features(desc1, desc2)
total_matches += len(matches)
logs.append(f"🔗 Matches: {len(matches)} good matches")
if len(matches) < self.config['min_match_count']:
logs.append(f"⚠️ WARNING: Insufficient matches, using pose-only homography")
H_final = H_initial
else:
# Refine homography with feature matches
H_refined, mask, confidence = self.estimate_homography(kp1, kp2, matches)
if H_refined is not None:
inliers = int(np.sum(mask))
total_inliers += inliers
logs.append(f"📐 Refined homography: {inliers}/{len(matches)} inliers ({confidence:.1%})")
H_final = H_refined
else:
logs.append(f"⚠️ Feature-based homography failed, using pose estimate")
H_final = H_initial
# Blend images
result = self.blend_images(result, current_img, H_final)
logs.append(f"✅ Blended! New size: {result.shape[1]}x{result.shape[0]}")
logs.append("")
# Final summary
logs.append("=" * 70)
logs.append("📊 FINAL STATISTICS")
logs.append("=" * 70)
logs.append(f"✓ Final Resolution: {result.shape[1]} x {result.shape[0]} pixels")
logs.append(f"✓ Total Matches: {total_matches:,}")
logs.append(f"✓ Total Inliers: {total_inliers:,}")
logs.append(f"✓ Completed: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
logs.append("=" * 70)
# Convert to RGB
result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
result_pil = Image.fromarray(result_rgb)
# Save to temporary file for download
with tempfile.NamedTemporaryFile(mode='wb', suffix='.png', delete=False) as f:
result_pil.save(f, format='PNG', optimize=True)
temp_path = f.name
return result_pil, "\n".join(logs), temp_path
def create_demo():
"""Create and configure Gradio interface"""
# Initialize both stitchers
basic_stitcher = WarehouseStitcher()
pose_stitcher = PoseGuidedWarehouseStitcher()
def process_images_basic(files, feature_type, matcher_type, use_clahe, detect_labels, ransac_thresh):
"""Process uploaded images (basic mode)"""
if not files or len(files) < 2:
return None, "❌ Please upload at least 2 images for stitching", None
# FIX: Extract file paths from tuples
file_paths = []
for f in files:
if isinstance(f, tuple):
# Gradio returns (file_path,)
file_paths.append(f[0])
else:
file_paths.append(f)
# Validate images
valid_paths = []
for path in file_paths:
try:
img = cv2.imread(path)
if img is not None:
valid_paths.append(path)
except:
pass
if len(valid_paths) < 2:
return None, f"❌ Only {len(valid_paths)} valid images found", None
file_paths = valid_paths
# Update configuration
basic_stitcher.config['feature_extractor'] = feature_type
basic_stitcher.config['matcher'] = matcher_type
basic_stitcher.config['use_clahe'] = use_clahe
basic_stitcher.config['detect_rack_labels'] = detect_labels
basic_stitcher.config['ransac_threshold'] = ransac_thresh
# Load images
try:
images = [Image.open(f) for f in file_paths]
return basic_stitcher.stitch_images(images)
except Exception as e:
return None, f"❌ Error: {str(e)}", None
def process_zip_with_metadata(zip_file, feature_type, matcher_type, use_clahe, detect_labels, ransac_thresh):
"""Process ZIP file containing images and metadata"""
if not zip_file:
return None, "❌ Please upload a ZIP file", None
# FIX: Extract file path from tuple
if isinstance(zip_file, tuple):
zip_path = zip_file[0]
else:
zip_path = zip_file
try:
with tempfile.TemporaryDirectory() as tmpdir:
tmpdir_path = Path(tmpdir)
# Extract ZIP
with zipfile.ZipFile(zip_path, 'r') as zip_ref:
zip_ref.extractall(tmpdir_path)
# Find images and metadata
image_files = sorted(list(tmpdir_path.rglob('*.jpg')) +
list(tmpdir_path.rglob('*.png')))
json_files = sorted(list(tmpdir_path.rglob('*.json')))
if len(image_files) < 2:
return None, f"❌ Found only {len(image_files)} images, need at least 2", None
if len(json_files) == 0:
return None, "❌ No JSON metadata files found in ZIP", None
# NEW: Match images with metadata by extracting base timestamp
# Pattern: z-9000_cam0_20251030_152626_496053_cam0.png -> z-9000_cam0_20251030_152626_496053
image_metadata_pairs = []
for img_file in image_files:
img_name = img_file.stem # Filename without extension
# Try to extract base name (remove _camX suffix if present)
# Pattern: z-9000_cam0_20251030_152626_496053_cam0 -> z-9000_cam0_20251030_152626_496053
if '_cam' in img_name:
parts = img_name.rsplit('_cam', 1)
if len(parts) == 2:
base_name = parts[0] # Everything before last _camX
else:
base_name = img_name
else:
base_name = img_name
# Look for matching JSON with base name
json_name = base_name + '.json'
json_candidates = [j for j in json_files if j.name == json_name]
if json_candidates:
image_metadata_pairs.append({
'image': str(img_file),
'metadata': str(json_candidates[0]),
'base_name': base_name,
'timestamp': None # Will be loaded from JSON
})
if len(image_metadata_pairs) < 2:
return None, f"❌ Only {len(image_metadata_pairs)} images have matching metadata. Need at least 2.\n\nFound images: {[f.name for f in image_files[:5]]}\nFound JSON: {[j.name for j in json_files[:5]]}", None
# Load timestamps and sort
for pair in image_metadata_pairs:
try:
with open(pair['metadata'], 'r') as f:
metadata = json.load(f)
pair['timestamp'] = metadata['nav_snapshot']['timestamp_usec']
except Exception as e:
return None, f"❌ Error reading metadata {pair['metadata']}: {str(e)}", None
# Sort by timestamp
image_metadata_pairs.sort(key=lambda x: x['timestamp'])
# Extract sorted lists
image_paths = [p['image'] for p in image_metadata_pairs]
metadata_paths = [p['metadata'] for p in image_metadata_pairs]
# Update configuration
pose_stitcher.config['feature_extractor'] = feature_type
pose_stitcher.config['matcher'] = matcher_type
pose_stitcher.config['use_clahe'] = use_clahe
pose_stitcher.config['detect_rack_labels'] = detect_labels
pose_stitcher.config['ransac_threshold'] = ransac_thresh
# Process with pose guidance
return pose_stitcher.stitch_with_poses(image_paths, metadata_paths)
except Exception as e:
import traceback
return None, f"❌ Error processing ZIP: {str(e)}\n\n{traceback.format_exc()}", None
# Custom CSS
custom_css = """
.gradio-container {
font-family: 'Arial', sans-serif;
}
.output-image {
border: 2px solid #4CAF50;
border-radius: 8px;
}
"""
# Create interface
with gr.Blocks(title="Warehouse Image Stitching", theme=gr.themes.Soft(), css=custom_css) as demo:
# Header
gr.Markdown("""
# 🏭 Industrial Warehouse Image Stitching Pipeline
🎯 Production-Ready Stitching for Warehouse Environments
**Key Features:**
- 🚁 **Pose-Guided Stitching**: Uses drone navigation data for intelligent alignment
- ✨ Handles specular reflections from shrink wrap and metallic surfaces
- 🏷️ Detects and uses warehouse rack labels as alignment anchors
- 🔍 CLAHE preprocessing for enhanced contrast
- 🎯 RANSAC-based robust homography estimation
""")
# Mode selection tabs
with gr.Tabs():
# TAB 1: Basic Mode
with gr.TabItem("📸 Basic Mode"):
gr.Markdown("""
### Upload images directly (no metadata needed)
Perfect for general-purpose panoramas and quick stitching.
""")
with gr.Row():
with gr.Column(scale=1):
gr.Markdown("## ⚙️ Configuration")
feature_type_basic = gr.Radio(
choices=['SIFT', 'ORB', 'AKAZE'],
value='SIFT',
label="🔍 Feature Extractor"
)
matcher_type_basic = gr.Radio(
choices=['BF', 'FLANN'],
value='BF',
label="🔗 Feature Matcher"
)
use_clahe_basic = gr.Checkbox(
value=True,
label="✨ Enable CLAHE Enhancement"
)
detect_labels_basic = gr.Checkbox(
value=True,
label="🏷️ Detect Rack Labels"
)
ransac_thresh_basic = gr.Slider(
minimum=1.0,
maximum=10.0,
value=5.0,
step=0.5,
label="📐 RANSAC Threshold"
)
with gr.Column(scale=2):
file_input = gr.File(
file_count="multiple",
file_types=["image"],
label="📸 Upload Warehouse Images (minimum 2)",
type="filepath"
)
process_basic_btn = gr.Button(
"🔨 Stitch Images",
variant="primary",
size="lg"
)
# TAB 2: Pose-Guided Mode
with gr.TabItem("🚁 Pose-Guided Mode"):
gr.Markdown("""
### Upload ZIP file with images + JSON metadata
For drone captures with navigation data - more robust and accurate!
📦 ZIP Structure Example:
dataset.zip
├── image_001.jpg
├── image_001.json (with nav_snapshot)
├── image_002.jpg
├── image_002.json
└── ...
Or nested folders:
dataset.zip
├── images/
│ ├── img1.jpg
│ └── img2.jpg
└── metadata/
├── img1.json
└── img2.json
""")
with gr.Row():
with gr.Column(scale=1):
gr.Markdown("## ⚙️ Configuration")
feature_type_pose = gr.Radio(
choices=['SIFT', 'ORB', 'AKAZE'],
value='SIFT',
label="🔍 Feature Extractor"
)
matcher_type_pose = gr.Radio(
choices=['BF', 'FLANN'],
value='BF',
label="🔗 Feature Matcher"
)
use_clahe_pose = gr.Checkbox(
value=True,
label="✨ Enable CLAHE Enhancement"
)
detect_labels_pose = gr.Checkbox(
value=True,
label="🏷️ Detect Rack Labels"
)
ransac_thresh_pose = gr.Slider(
minimum=1.0,
maximum=10.0,
value=5.0,
step=0.5,
label="📐 RANSAC Threshold"
)
with gr.Column(scale=2):
zip_input = gr.File(
file_count="single",
file_types=[".zip"],
label="📦 Upload ZIP (images + metadata)",
type="filepath"
)
process_pose_btn = gr.Button(
"🔨 Stitch with Pose Guidance",
variant="primary",
size="lg"
)
# Results section (shared by both tabs)
gr.Markdown("## 📊 Results")
with gr.Row():
with gr.Column(scale=2):
output_image = gr.Image(
label="🖼️ Stitched Panorama",
type="pil",
height=500,
elem_classes=["output-image"]
)
download_btn = gr.File(
label="⬇️ Download High-Resolution Result"
)
with gr.Column(scale=1):
logs_output = gr.Textbox(
label="📋 Processing Logs",
lines=25,
max_lines=35,
autoscroll=True,
show_copy_button=True
)
# Footer
gr.Markdown("""
---
Industrial Warehouse Image Stitching Pipeline v1.0.0
Powered by OpenCV • SIFT • RANSAC • Pose-Guided Alignment
""")
# Connect events
process_basic_btn.click(
fn=process_images_basic,
inputs=[file_input, feature_type_basic, matcher_type_basic, use_clahe_basic, detect_labels_basic, ransac_thresh_basic],
outputs=[output_image, logs_output, download_btn],
api_name="stitch"
)
process_pose_btn.click(
fn=process_zip_with_metadata,
inputs=[zip_input, feature_type_pose, matcher_type_pose, use_clahe_pose, detect_labels_pose, ransac_thresh_pose],
outputs=[output_image, logs_output, download_btn],
api_name="pose_stitch"
)
return demo
# Main execution
if __name__ == "__main__":
demo = create_demo()
demo.queue(max_size=5) # Enable queuing for multiple users
demo.launch(
server_name="0.0.0.0",
server_port=7860,
share=True,
show_error=True
)