import gradio as gr
from PIL import Image
import tempfile
import os
from pathlib import Path
import shutil
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'
}
self.session = requests.Session()
def extract_panoid(self, url):
"""Extract panorama ID from Google Maps URL."""
pattern = r'!1s([A-Za-z0-9-_]+)!'
match = re.search(pattern, url)
if match:
return match.group(1)
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."""
tile_url = f"https://streetviewpixels-pa.googleapis.com/v1/tile?cb_client=maps_sv.tactile&panoid={panoid}&x={x}&y={adjusted_y}&zoom={zoom}"
output_file = Path(output_dir) / f"tile_{x}_{y}.jpg"
try:
async with session.get(tile_url, headers=self.headers) as response:
if response.status == 200:
content = await response.read()
if len(content) > 1000:
output_file.write_bytes(content)
return (x, y)
except Exception as e:
print(f"Error downloading tile {x},{y}: {str(e)}")
return None
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)
vertical_offset = rows // 4 # Dynamic vertical offset based on rows
async with aiohttp.ClientSession() as session:
tasks = []
for x in range(cols):
for y in range(rows):
adjusted_y = y - (rows // 2) + vertical_offset
task = self.download_tile_async(session, panoid, x, y, adjusted_y, zoom, output_dir)
tasks.append(task)
downloaded_tiles = []
for result in await asyncio.gather(*tasks):
if result:
downloaded_tiles.append(result)
return cols, rows, downloaded_tiles
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, 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."""
directory = Path(directory)
# Find a valid tile to get dimensions
valid_tile = None
for x, y in downloaded_tiles:
tile_path = directory / f"tile_{x}_{y}.jpg"
if tile_path.exists():
valid_tile = Image.open(tile_path)
break
if not valid_tile:
raise Exception("No valid tiles found in directory")
tile_width, tile_height = valid_tile.size
valid_tile.close()
panorama_width = tile_width * cols
panorama_height = tile_height * rows
panorama = Image.new('RGB', (panorama_width, panorama_height))
def process_tile(tile_info):
x, y = tile_info
tile_path = directory / f"tile_{x}_{y}.jpg"
if tile_path.exists():
with Image.open(tile_path) as tile:
if tile.getbbox():
return (x * tile_width, y * tile_height, tile.copy())
return None
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
tile_results = list(executor.map(process_tile, downloaded_tiles))
for result in tile_results:
if result:
x, y, tile = result
panorama.paste(tile, (x, y))
tile.close()
bbox = panorama.getbbox()
if bbox:
panorama = panorama.crop(bbox)
panorama = self.enhance_panorama(panorama)
panorama.save(output_file, 'JPEG', quality=95, optimize=True)
return panorama
def enhance_panorama(self, panorama):
"""Quick enhancement with minimal processing."""
enhancer = ImageEnhance.Contrast(panorama)
panorama = enhancer.enhance(1.1)
return panorama
def process_street_view(url, zoom, cols, rows, progress=gr.Progress()):
"""Process the Street View URL with custom parameters."""
try:
# Input validation
zoom = int(zoom)
cols = int(cols)
rows = int(rows)
if zoom < 0 or zoom > 5:
raise ValueError("Zoom level must be between 0 and 5")
if cols < 1 or rows < 1:
raise ValueError("Columns and rows must be positive numbers")
if cols * rows > 1000:
raise ValueError("Total number of tiles (cols * rows) cannot exceed 1000")
temp_dir = tempfile.mkdtemp()
progress(0.1, desc="Initializing...")
downloader = StreetViewDownloader()
panoid = downloader.extract_panoid(url)
progress(0.2, desc="Extracted panorama ID...")
tiles_dir = os.path.join(temp_dir, f"{panoid}_tiles")
output_file = os.path.join(temp_dir, f"{panoid}_360panorama.jpg")
progress(0.3, desc=f"Downloading {cols}x{rows} tiles at zoom level {zoom}...")
cols, rows, downloaded_tiles = downloader.download_tiles(panoid, tiles_dir, zoom, cols, rows)
progress(0.7, desc="Creating panorama...")
panorama = downloader.create_360_panorama(tiles_dir, cols, rows, downloaded_tiles, output_file)
progress(0.9, desc="Cleaning up...")
shutil.rmtree(tiles_dir)
progress(1.0, desc="Done!")
return output_file, panorama
except Exception as e:
print(f"Error: {str(e)}") # Debug print
return None, None
def create_gradio_interface():
# Example links with their respective parameters
example_links = [
["https://www.google.com/maps/@40.7579718,-73.9855442,3a,75y,36.7h,81.89t/data=!3m7!1e1!3m5!1sNYigM1H6Vz7eLR8fRmykuw!2e0!6shttps:%2F%2Fstreetviewpixels-pa.googleapis.com%2Fv1%2Fthumbnail%3Fpanoid%3DNYigM1H6Vz7eLR8fRmykuw%26cb_client%3Dmaps_sv.tactile.gps%26w%3D203%26h%3D100%26yaw%3D136.23409%26pitch%3D0%26thumbfov%3D100!7i16384!8i8192?coh=205409&entry=ttu&g_ep=EgoyMDI0MTAyMy4wIKXMDSoASAFQAw%3D%3D", "2", "16", "8"], # Times Square
["https://www.google.com/maps/@48.8560009,2.2981995,3a,75y,315.8h,98.33t/data=!3m7!1e1!3m5!1sgaXVhUqbqmZ006KVmB6TLw!2e0!6shttps:%2F%2Fstreetviewpixels-pa.googleapis.com%2Fv1%2Fthumbnail%3Fpanoid%3DgaXVhUqbqmZ006KVmB6TLw%26cb_client%3Dmaps_sv.tactile.gps%26w%3D203%26h%3D100%26yaw%3D294.00525%26pitch%3D0%26thumbfov%3D100!7i16384!8i8192?coh=205409&entry=ttu&g_ep=EgoyMDI0MTAyMy4wIKXMDSoASAFQAw%3D%3D", "3", "32", "16"], # Eiffel Tower
["https://www.google.com/maps/@27.1749733,78.0430361,2a,75y,276.92h,78.63t/data=!3m6!1e1!3m4!1sIinHqsOZDjMDKZ7STo_Kdw!2e0!7i13312!8i6656?coh=205409&entry=ttu&g_ep=EgoyMDI0MTAyMy4wIKXMDSoASAFQAw%3D%3D", "1", "8", "4"] # Taj Mahal
]
with gr.Blocks() as app:
gr.Markdown("# Street View Panorama Downloader")
gr.Markdown("Download panoramic images from Google Street View")
with gr.Row():
with gr.Column():
url_input = gr.Textbox(
label="Street View URL",
placeholder="Paste Google Street View URL here...",
info="Open Street View, copy the URL from your browser"
)
with gr.Row():
zoom_level = gr.Number(
label="Zoom Level (0-5)",
value=2,
minimum=0,
maximum=5,
step=1,
info="Higher zoom = more detail but slower download"
)
cols_input = gr.Number(
label="Columns",
value=16,
minimum=1,
maximum=128,
step=1,
info="Number of horizontal tiles"
)
rows_input = gr.Number(
label="Rows",
value=8,
minimum=1,
maximum=64,
step=1,
info="Number of vertical tiles"
)
submit_btn = gr.Button("Download and Process", variant="primary")
with gr.Row():
with gr.Column():
output_file = gr.File(label="Download Panorama")
with gr.Column():
output_image = gr.Image(label="Preview", type="pil")
# Examples section
gr.Examples(
examples=example_links,
inputs=[url_input, zoom_level, cols_input, rows_input],
outputs=[output_file, output_image],
fn=process_street_view,
cache_examples=True,
label="Example Locations"
)
submit_btn.click(
fn=process_street_view,
inputs=[url_input, zoom_level, cols_input, rows_input],
outputs=[output_file, output_image]
)
gr.Markdown("""
### Parameter Guide:
1. **Zoom Level (0-5):**
- 0: Lowest quality, fastest download (~4x4 tiles)
- 1: Low quality (~8x4 tiles)
- 2: Medium quality, recommended (~16x8 tiles)
- 3: High quality, slower (~32x16 tiles)
- 4: Very high quality, very slow (~64x32 tiles)
- 5: Maximum quality, extremely slow (~128x64 tiles)
2. **Columns:**
- Controls horizontal resolution
- More columns = wider image
- Recommended values:
- Fast: 8-16 columns
- Balanced: 16-32 columns
- High quality: 32-64 columns
3. **Rows:**
- Controls vertical resolution
- More rows = taller image
- Typically use half the number of columns
- Recommended values:
- Fast: 4-8 rows
- Balanced: 8-16 rows
- High quality: 16-32 rows
### Example Settings:
- Times Square: Balanced quality (zoom=2, cols=16, rows=8)
- Eiffel Tower: High quality (zoom=3, cols=32, rows=16)
- Taj Mahal: Fast preview (zoom=1, cols=8, rows=4)
""")
return app
if __name__ == "__main__":
app = create_gradio_interface()
app.launch(share=True)