Update app.py

app.py

@@ -13,28 +13,11 @@ import asyncio
 import aiohttp
 import io
 
-import gradio as gr
-from PIL import Image
-import tempfile
-import os
-from pathlib import Path
-import shutil
-import base64
-import requests
-import re
-import time
-from PIL import ImageEnhance
-import concurrent.futures
-import asyncio
-import aiohttp
-import io
-
 class StreetViewDownloader:
     def __init__(self):
         self.headers = {
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
         }
-        # Using a smaller session for better connection reuse
         self.session = requests.Session()
         
     def extract_panoid(self, url):
@@ -43,7 +26,7 @@ class StreetViewDownloader:
         match = re.search(pattern, url)
         if match:
             return match.group(1)
-        raise ValueError("Could not find panorama ID in URL")
+        raise ValueError("Could not find panorama ID in URL. Please make sure you're using a valid Street View URL.")
 
     async def download_tile_async(self, session, panoid, x, y, adjusted_y, zoom, output_dir):
         """Download a single tile asynchronously."""
@@ -61,17 +44,11 @@ class StreetViewDownloader:
             print(f"Error downloading tile {x},{y}: {str(e)}")
         return None
 
-    async def download_tiles_async(self, panoid, output_dir):
-        """Download tiles asynchronously with reduced resolution."""
+    async def download_tiles_async(self, panoid, output_dir, zoom, cols, rows):
+        """Download tiles asynchronously with custom parameters."""
         Path(output_dir).mkdir(parents=True, exist_ok=True)
         
-        # Reduced parameters for faster download
-        zoom = 2  # Reduced zoom level (less detail but faster)
-        cols = 16  # Reduced number of horizontal tiles
-        rows = 8   # Reduced number of vertical tiles
-        vertical_offset = 2  # Adjusted for the new grid
-        
-        print(f"Downloading {cols * rows} tiles for panorama...")
+        vertical_offset = rows // 4  # Dynamic vertical offset based on rows
         
         async with aiohttp.ClientSession() as session:
             tasks = []
@@ -88,9 +65,9 @@ class StreetViewDownloader:
         
         return cols, rows, downloaded_tiles
 
-    def download_tiles(self, panoid, output_dir):
+    def download_tiles(self, panoid, output_dir, zoom, cols, rows):
         """Synchronous wrapper for async download."""
-        return asyncio.run(self.download_tiles_async(panoid, output_dir))
+        return asyncio.run(self.download_tiles_async(panoid, output_dir, zoom, cols, rows))
 
     def create_360_panorama(self, directory, cols, rows, downloaded_tiles, output_file):
         """Create an equirectangular 360° panorama from tiles with optimized processing."""
@@ -110,14 +87,11 @@ class StreetViewDownloader:
         tile_width, tile_height = valid_tile.size
         valid_tile.close()
         
-        # Create the panorama at optimized resolution
         panorama_width = tile_width * cols
         panorama_height = tile_height * rows
         
-        # Use RGB mode directly for better performance
         panorama = Image.new('RGB', (panorama_width, panorama_height))
         
-        # Process tiles in parallel
         def process_tile(tile_info):
             x, y = tile_info
             tile_path = directory / f"tile_{x}_{y}.jpg"
@@ -127,28 +101,22 @@ class StreetViewDownloader:
                         return (x * tile_width, y * tile_height, tile.copy())
             return None
 
-        # Use ThreadPoolExecutor for parallel processing
         with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
             tile_results = list(executor.map(process_tile, downloaded_tiles))
         
-        # Paste all valid tiles
         for result in tile_results:
             if result:
                 x, y, tile = result
                 panorama.paste(tile, (x, y))
                 tile.close()
         
-        # Crop out any remaining black regions
         bbox = panorama.getbbox()
         if bbox:
             panorama = panorama.crop(bbox)
         
-        # Quick enhancement
         panorama = self.enhance_panorama(panorama)
-        
-        # Save with optimized settings
         panorama.save(output_file, 'JPEG', quality=95, optimize=True)
-        return output_file
+        return panorama
 
     def enhance_panorama(self, panorama):
         """Quick enhancement with minimal processing."""
@@ -157,6 +125,7 @@ class StreetViewDownloader:
         return panorama
 
 
+
 def process_street_view(url, zoom, cols, rows, progress=gr.Progress()):
     """Process the Street View URL with custom parameters."""
     try: