Skip to content

armgit / Aleph

Public Imported from GitHub
0

Give satellite imagery, terrain data, buildings, streetview photos to your LLM

Add sphere streetview capture

Belluxx22c4beea9ef7
diff --git a/aleph.py b/aleph.py
index 320dc18..e81f1bf 100644
--- a/aleph.py
+++ b/aleph.py
@@ -27,7 +27,8 @@ def describe(run):
mode = stage["mode"]
if mode == "streetview":
label = "Street View"
- message = f"{estimate['streetview_photos']:,} photos at {estimate['streetview_stops']:,} stops"
+ kind = "spheres" if stage.get("full_sphere") else "photos"
+ message = f"{estimate['streetview_photos']:,} {kind} at {estimate['streetview_stops']:,} stops"
elif mode == "satellite":
label = "Satellite"
g = stage["grid"]
@@ -39,6 +40,9 @@ def describe(run):
maps = estimate["osm_maps"]
message = f"{maps:,} OSM {'map' if maps == 1 else 'maps'} and {estimate['terrain_tiles']:,} terrain tiles"
print(f" {label:<15}{message}", file=sys.stderr)
+ if estimate["seconds"] is None:
+ print(" Download time depends on panorama tile counts; progress is shown during capture.", file=sys.stderr)
+ return
minutes, seconds = divmod(estimate["seconds"], 60)
hours, minutes = divmod(minutes, 60)
duration = f"{hours} hr {minutes} min" if hours else f"{minutes} min {seconds} sec" if minutes else f"{seconds} sec"
@@ -96,7 +100,7 @@ def query(args, progress):
if args.pano_id and args.radius is not None:
raise ValueError("--radius applies to coordinates or a place name.")
keys += ("pano_id", "street", "route", "reverse", "stops", "step", "view", "heading",
- "look_at", "pitch", "fov", "radius", "streetview_format")
+ "look_at", "pitch", "fov", "radius", "streetview_format", "full_sphere", "sphere_zoom")
operation = quick.street_photos
else:
if args.size is not None and (args.bbox is not None or args.tile is not None):
diff --git a/docs/cli.md b/docs/cli.md
index 1231521..92d632f 100644
--- a/docs/cli.md
+++ b/docs/cli.md
@@ -30,6 +30,10 @@ Missing tiles remain transparent PNGs, including when JPEG is selected.
Choose Street View photo formats with `streetview --streetview-format png`
or `capture create --streetview-format png` (default: `jpg`).
+Add `--full-sphere` to `streetview` or `capture create` for one 360° panorama per stop.
+`--sphere-zoom 0–5` controls resolution (default: `3`); higher levels download more tiles.
+In the dashboard, choose **Street View → Capture type → Full sphere**.
+
## Use coordinates
Coordinates are `LAT LON`; distances are in meters.
diff --git a/src/assets/app.js b/src/assets/app.js
index f220a87..fd7733b 100644
--- a/src/assets/app.js
+++ b/src/assets/app.js
@@ -571,12 +571,14 @@ function showPhoto(index, move = false) {
const figures = stop.photos.map((photo) => {
const figure = node("figure", undefined, "photo-figure");
const image = node("img");
- image.alt = `${photo.side} view${photo.path_name ? " of " + photo.path_name : ""}`;
+ const sphere = photo.projection === "equirectangular";
+ image.alt = `${sphere ? "Full sphere panorama" : photo.side + " view"}${photo.path_name ? " of " + photo.path_name : ""}`;
image.src = fileURL(state.selected.id, photo.filename);
image.addEventListener("error", () => notice(`The saved photo ${photo.filename} could not be loaded.`), {once: true});
const caption = node("figcaption");
const imageryDate = photo.imagery_date;
- caption.append(node("span", `${photo.side === "left" ? "Left" : "Right"} view, ${Math.round(photo.heading)}°${imageryDate ? " (" + imageryDate + ")" : ""}`));
+ const description = sphere ? `Full sphere · ${photo.width} × ${photo.height}` : `${photo.side === "left" ? "Left" : "Right"} view, ${Math.round(photo.heading)}°`;
+ caption.append(node("span", `${description}${imageryDate ? " (" + imageryDate + ")" : ""}`));
const address = photo.streetview_url;
if (address && /^https:\/\/(www\.)?google\.com\//.test(address)) {
const link = node("a", "Open in Google ↗");
@@ -709,6 +711,9 @@ function renderCapturePanel() {
$("stop-planning").disabled = !job.active || job.state === "stopping";
}
const sources = form.querySelectorAll('input[name="include"]:checked').length;
+ const sphere = form.elements.full_sphere.value === "true";
+ form.elements.fov.closest("label").hidden = sphere;
+ $("sphere-resolution").hidden = !sphere;
for (const section of form.querySelectorAll("[data-source]")) {
section.hidden = !form.querySelector(`input[name="include"][value="${section.dataset.source}"]`).checked;
}
@@ -931,8 +936,9 @@ async function planCapture(event) {
$("form-error").hidden = true;
const data = new FormData(form);
const options = {include: data.getAll("include"), depth: data.get("depth"),
+ full_sphere: data.get("full_sphere") === "true",
streetview_format: data.get("streetview_format"), satellite_format: data.get("satellite_format")};
- for (const key of ["step", "fov", "delay", "satellite_zoom", "terrain_zoom"]) options[key] = Number(data.get(key));
+ for (const key of ["step", "fov", "delay", "satellite_zoom", "terrain_zoom", "sphere_zoom"]) options[key] = Number(data.get(key));
const bounds = [...state.draftBounds];
state.submitting = true;
setDrawMode(false);
@@ -969,7 +975,7 @@ function showPlan(plan) {
if (!state.composing) return;
state.plan = plan;
const estimate = plan.estimate;
- $("plan-duration").textContent = `About ${durationLabel(estimate.seconds)}`;
+ $("plan-duration").textContent = estimate.seconds === null ? "Download time depends on sphere resolution" : `About ${durationLabel(estimate.seconds)}`;
const counts = $("plan-counts");
counts.replaceChildren();
const row = (label, value) => {
@@ -980,7 +986,7 @@ function showPlan(plan) {
row("Selected area", areaLabel(areaMetrics(plan.bounds).area));
const sources = plan.options.include;
if (sources.includes("streetview")) {
- row("Street View photos", estimate.streetview_photos.toLocaleString());
+ row(plan.options.full_sphere ? "Street View spheres" : "Street View photos", estimate.streetview_photos.toLocaleString());
row("Street View stops", estimate.streetview_stops.toLocaleString());
}
if (sources.includes("satellite")) row("Satellite tiles", estimate.satellite_tiles.toLocaleString());
diff --git a/src/assets/index.html b/src/assets/index.html
index 8e15637..6c2efa7 100644
--- a/src/assets/index.html
+++ b/src/assets/index.html
@@ -112,8 +112,10 @@
<div class="settings-group" data-source="streetview">
<h3 class="settings-divider"><svg viewBox="0 0 24 24" fill="none" aria-hidden="true"><path d="M3 7h4l2-3h6l2 3h4v13H3Z"/><circle cx="12" cy="13" r="4"/></svg>Street View</h3>
<div class="settings-grid">
+ <label>Capture type<select name="full_sphere"><option value="false">Left and right photos</option><option value="true">Full sphere (360°)</option></select></label>
<label>Photo spacing (m)<input name="step" type="number" min="0" step="any" required></label>
<label>Field of view (°)<input name="fov" type="number" min="5" max="175" step="1" required></label>
+ <label id="sphere-resolution" hidden>Sphere resolution<select name="sphere_zoom"><option value="0">0 — Lowest</option><option value="1">1 — Low</option><option value="2">2 — Medium</option><option value="3">3 — High</option><option value="4">4 — Very high</option><option value="5">5 — Maximum</option></select></label>
</div>
</div>
</fieldset>
diff --git a/src/capture.py b/src/capture.py
index 4b3b743..1042d94 100644
--- a/src/capture.py
+++ b/src/capture.py
@@ -36,6 +36,7 @@ SOURCES = ("streetview", "satellite", "osm")
FORMAT_VERSION = 3
DEFAULT_OPTIONS = dict(
include=list(SOURCES), step=30, fov=75, depth="roads", streetview_format="jpg",
+ full_sphere=False, sphere_zoom=3,
delay=0, satellite_zoom=18, satellite_format="jpg", terrain_zoom=14,
)
@@ -68,6 +69,9 @@ def settings(values=None):
requirement = "positive" if key == "step" else "nonnegative"
raise ValueError(f"{key}: use a {requirement} finite number.")
options["fov"] = streetview.validate_fov(options["fov"])
+ if type(options["full_sphere"]) is not bool:
+ raise ValueError("full_sphere must be true or false.")
+ options["sphere_zoom"] = streetview.validate_sphere_zoom(options["sphere_zoom"])
for key, low, high in (
("satellite_zoom", 1, 21), ("terrain_zoom", 1, 14),
):
@@ -128,28 +132,23 @@ def plan(client, area, options, progress):
def total(stage):
if stage["mode"] == "streetview":
- return len(stage["samples"]) * 2
+ return len(stage["samples"]) * (1 if stage.get("full_sphere") else 2)
return stage["grid"]["rows"] * stage["grid"]["columns"] + (stage["mode"] == "osm")
def estimate(run):
- """Estimate remaining downloads using observed zero-delay capture timings.
-
- 2026-09-19 17:26:41 UTC: 66 Street View photos in 36 s,
- including panorama metadata. 2026-09-19 17:09:18 UTC:
- 1,020 satellite tiles in 374 s and 9 terrain tiles in 10 s.
- 2026-09-21: map exports with completed multipolygons took 17–29 s for
- 10–1,000 km² from the 384 MB central Italy region. Region size affects this cost.
- Planning, initial regional downloads and final exports are excluded.
- """
+ """Estimate remaining downloads using observed download time with average internet connection"""
counts = dict(streetview_photos=0, streetview_stops=0, satellite_tiles=0,
terrain_tiles=0, osm_maps=0)
metadata_requests = 0
+ sphere_pending = False
for stage in run["stages"]:
remaining = total(stage) - len(stage["results"])
if stage["mode"] == "streetview":
counts["streetview_photos"] = remaining
- samples = stage["samples"][len(stage["results"]) // 2:]
+ sphere_pending = bool(stage.get("full_sphere") and remaining)
+ per_stop = 1 if stage.get("full_sphere") else 2
+ samples = stage["samples"][len(stage["results"]) // per_stop:]
counts["streetview_stops"] = len(samples)
previous = None # Metadata is fetched again when resuming a run.
for sample in samples:
@@ -168,7 +167,9 @@ def estimate(run):
+ counts["satellite_tiles"] * 0.37
+ counts["terrain_tiles"] * 1.1 + counts["osm_maps"] * 30)
delay_seconds = max(0, requests - 1) * run["options"]["delay"]
- return dict(counts, seconds=math.ceil(download_seconds + delay_seconds))
+ # Native tile dimensions are learned during capture, so a sphere ETA is
+ # unavailable at planning time. Do not apply the two-thumbnail timings.
+ return dict(counts, seconds=None if sphere_pending else math.ceil(download_seconds + delay_seconds))
def photos(run, after=0):
@@ -193,6 +194,9 @@ def open_image(data, size):
def capture_streets(stage, run, folder, client, progress):
options = run["options"]
+ if stage.get("full_sphere"):
+ yield from capture_spheres(stage, run, folder, client, progress)
+ return
cached_id, metadata = None, None
for index in range(len(stage["results"]), total(stage)):
sample = stage["samples"][index // 2]
@@ -259,6 +263,35 @@ def capture_streets(stage, run, folder, client, progress):
progress("Street View", index + 1, total(stage))
+def capture_spheres(stage, run, folder, client, progress):
+ options = run["options"]
+ for index in range(len(stage["results"]), total(stage)):
+ sample = stage["samples"][index]
+ part = stage["paths"][sample["path_index"]]
+ photo = dict(sample, sequence=index + 1, path_id=part["id"], path_name=part["name"],
+ osm_id=part["osm_id"], highway=part["highway"], layer=part["layer"],
+ road_heading=sample["heading"], projection="equirectangular")
+ photo.pop("heading") # A sphere has no single perspective camera heading.
+ try:
+ metadata = streetview.parse_metadata(
+ client.get(streetview.metadata_url(sample["pano_id"])), full_sphere=True)
+ if (metadata["pano_id"] != sample["pano_id"]
+ or distance((sample["lat"], sample["lon"]), (metadata["lat"], metadata["lon"])) > 0.1):
+ raise ValueError("The planned panorama identity or position changed. Plan a new run.")
+ photo.update(metadata)
+ photo["filename"] = f"streetview/photos/{index + 1:06d}_sphere.{options['streetview_format']}"
+ photo.update(streetview.save_sphere(
+ client, metadata, options["sphere_zoom"], folder / photo["filename"], progress))
+ photo.update(captured_at=now(), status="saved", source_url=streetview.metadata_url(sample["pano_id"]),
+ streetview_url=url("https://www.google.com/maps/@", api=1, map_action="pano",
+ pano=sample["pano_id"], viewpoint=f"{photo['lat']},{photo['lon']}"))
+ except MissingImagery as error:
+ photo.update(status="skipped", reason=str(error))
+ stage["results"].append(photo)
+ yield
+ progress("Street View spheres", index + 1, total(stage))
+
+
def capture_satellite(stage, folder, client, progress, satellite_format):
for i, tile in enumerate(tiles(stage["grid"])):
if i < len(stage["results"]):
@@ -459,7 +492,7 @@ def download(run, folder, client, progress):
work = capture_osm(stage, run["bounds"], folder, client, progress)
for _ in work:
saved_count += 1
- if stage["mode"] == "osm" or saved_count >= 50 or time.monotonic() - saved_at >= 30:
+ if stage["mode"] == "osm" or stage.get("full_sphere") or saved_count >= 50 or time.monotonic() - saved_at >= 30:
write_json(folder / "manifest.json", run)
saved_at, saved_count = time.monotonic(), 0
write_json(folder / "manifest.json", run)
diff --git a/src/cli.py b/src/cli.py
index 318b983..112719f 100644
--- a/src/cli.py
+++ b/src/cli.py
@@ -101,6 +101,7 @@ def _streetview_command(commands):
# Camera settings shared by single views and street sequences.
street.add_argument("--pitch", type=float, default=0, help="vertical angle, positive up and negative down; any finite float32 degrees (default: 0)")
street.add_argument("--fov", type=int, default=75, help="horizontal field of view, 5–175 whole degrees (default: 75)")
+ _sphere_options(street)
_network_options(street)
street.add_argument("--streetview-format", choices=("jpg", "png"), default="jpg")
@@ -140,6 +141,7 @@ def _capture_command(commands):
area.add_argument("--step", type=float, help="target Street View spacing in meters (default: 30)")
area.add_argument("--fov", type=int, help="horizontal field of view, 5–175 whole degrees (default: 75)")
area.add_argument("--streetview-format", choices=("jpg", "png"), help="Street View photo format (default: jpg)")
+ _sphere_options(area)
# Satellite imagery.
area.add_argument("--satellite-zoom", type=int, help="satellite zoom, 1–21 (default: 18)")
@@ -167,6 +169,12 @@ def _capture_command(commands):
_output_options(export)
+def _sphere_options(command):
+ command.add_argument("--full-sphere", action="store_true", help="save one full 360° panorama per stop; camera direction and fov do not apply")
+ command.add_argument("--sphere-zoom", type=int, choices=range(6), default=3,
+ help="panorama resolution level, 0–5 (default: 3); capped at the highest available")
+
+
def _dashboard_command(commands):
dashboard = commands.add_parser("dashboard", help="Open the local capture dashboard")
dashboard.add_argument("--root", type=Path, default=Path("."), help="capture directory (default: current directory)")
diff --git a/src/quick.py b/src/quick.py
index 2c64f35..38cad70 100644
--- a/src/quick.py
+++ b/src/quick.py
@@ -35,7 +35,8 @@ def location(client, *, at=None, place=None, match=None, best_match=False, endpo
def street_photos(client, output, progress, *, at=None, place=None, pano_id=None,
street=None, match=None, best_match=False, endpoint=places.GEOCODER, route=None,
reverse=False, stops=None, step=None, view="forward", heading=0, look_at=None,
- pitch=0, fov=75, radius=50, streetview_format="jpg"):
+ pitch=0, fov=75, radius=50, streetview_format="jpg", full_sphere=False, sphere_zoom=3):
+ streetview.validate_sphere_zoom(sphere_zoom)
streetview.validate_angle(heading, "heading")
streetview.validate_angle(pitch, "pitch")
fov = streetview.validate_fov(fov)
@@ -102,13 +103,23 @@ def street_photos(client, output, progress, *, at=None, place=None, pano_id=None
try:
for index, sample in enumerate(samples, 1):
try:
- metadata = streetview.parse_metadata(client.get(streetview.metadata_url(sample["pano_id"])))
+ metadata = streetview.parse_metadata(client.get(streetview.metadata_url(sample["pano_id"])),
+ full_sphere=full_sphere)
if metadata["pano_id"] != sample["pano_id"]:
raise ValueError("The provider returned a different panorama.")
actual = (metadata["lat"], metadata["lon"])
if "lat" in sample and distance(actual, (sample["lat"], sample["lon"])) > 1:
raise MissingImagery("Panorama position changed; retry with --refresh.")
- for direction in directions if street else (None,):
+ for direction in directions if street and not full_sphere else (None,):
+ if full_sphere:
+ name = f"{len(result['photos']) + 1:03d}_sphere.{streetview_format}"
+ photo = {**sample, **metadata}
+ if "heading" in photo:
+ photo["road_heading"] = photo.pop("heading")
+ photo.update(streetview.save_sphere(client, metadata, sphere_zoom, folder / name, progress))
+ photo.update(path=str(folder / name), source_url=streetview.metadata_url(sample["pano_id"]))
+ result["photos"].append(photo)
+ continue
angle = (sample["heading"] + offsets[direction]) % 360 if street else heading
if look_at is not None:
angle = bearing(actual, look_at)
diff --git a/src/streetview.py b/src/streetview.py
index aa96f7d..fd8c6c5 100644
--- a/src/streetview.py
+++ b/src/streetview.py
@@ -3,10 +3,15 @@
import json
import math
import re
+import shutil
import unicodedata
+from io import BytesIO
from itertools import pairwise
+from pathlib import Path
-from .common import MissingImagery, url
+from PIL import Image
+
+from .common import MissingImagery, atomic_path, url, write_bytes
from .geo import Line, RoadIndex, clip, distance, grid, inside, tiles
EXCLUDED = re.compile(r"^(construction|proposed|planned|abandoned|razed|demolished)$")
@@ -51,7 +56,7 @@ def parse_coverage(data):
) from error
-def parse_metadata(data):
+def parse_metadata(data, *, full_sphere=False):
try:
message = google_json(data)[1][0]
code = message[0][0]
@@ -74,6 +79,22 @@ def parse_metadata(data):
and 1 <= date[1] <= 12
):
result["imagery_date"] = f"{date[0]:04d}-{date[1]:02d}"
+ if full_sphere:
+ sizes, tile_size = message[2][3][:2]
+ sizes = [[size[0][1], size[0][0]] for size in sizes]
+ if (not sizes or len(sizes) > 6 or len(tile_size) != 2
+ or any(type(v) is not int or not 1 <= v <= 32768
+ for size in sizes + [tile_size] for v in size)
+ or any(w * h > 150_000_000 for w, h in sizes)):
+ raise ValueError("Invalid panorama dimensions.")
+ orientation = message[5][0][1][2][:3]
+ if len(orientation) != 3:
+ raise ValueError("Missing panorama orientation.")
+ for angle in orientation:
+ validate_angle(angle, "panorama orientation")
+ result.update(image_sizes=sizes, tile_size=tile_size,
+ panorama_heading=orientation[0],
+ panorama_pitch=90 - orientation[1], panorama_roll=orientation[2])
return result
except (ValueError, TypeError, IndexError, KeyError) as error:
raise ValueError(
@@ -120,6 +141,50 @@ def image_url(pano_id, heading, fov, pitch=0):
)
+def validate_sphere_zoom(zoom):
+ if type(zoom) is not int or not 0 <= zoom <= 5:
+ raise ValueError("sphere_zoom: use a whole number from 0 to 5.")
+ return zoom
+
+
+def tile_url(pano_id, zoom, x, y):
+ return url("https://streetviewpixels-pa.googleapis.com/v1/tile",
+ cb_client="maps_sv.tactile", panoid=pano_id, zoom=zoom, x=x, y=y)
+
+
+def save_sphere(client, metadata, zoom, target, progress):
+ """Assemble native panorama tiles; retain partial tiles for retry/resume."""
+ zoom = min(validate_sphere_zoom(zoom), len(metadata["image_sizes"]) - 1)
+ width, height = metadata["image_sizes"][zoom]
+ tw, th = metadata["tile_size"]
+ columns, rows = math.ceil(width / tw), math.ceil(height / th)
+ target = Path(target)
+ cache = target.parent / ".sphere-tiles" / metadata["pano_id"] / f"{zoom}-{width}x{height}-{tw}x{th}"
+ count = columns * rows
+ progress("Panorama tiles", 0, count)
+ with Image.new("RGB", (width, height)) as sphere:
+ for y in range(rows):
+ for x in range(columns):
+ client.check_cancel()
+ path = cache / f"{x}-{y}.tile"
+ data = path.read_bytes() if path.is_file() else client.get(
+ tile_url(metadata["pano_id"], zoom, x, y), missing_ok=True)
+ with Image.open(BytesIO(data)) as tile:
+ if tile.format not in ("JPEG", "PNG") or tile.size != (tw, th):
+ raise ValueError(f"Expected a panorama tile of {tw} × {th} pixels.")
+ tile.load()
+ if not path.is_file():
+ write_bytes(path, data)
+ sphere.paste(tile, (x * tw, y * th))
+ progress("Panorama tiles", y * columns + x + 1, count)
+ client.check_cancel()
+ with atomic_path(target) as temporary:
+ sphere.save(temporary, format="PNG" if target.suffix == ".png" else "JPEG", quality=90)
+ shutil.rmtree(cache)
+ return dict(projection="equirectangular", width=width, height=height,
+ sphere_zoom=zoom, tile_count=count)
+
+
def roads(ways, area, depth):
parts, seen_edges = [], set()
for way in sorted(ways, key=lambda way: way["id"]):
@@ -297,6 +362,7 @@ def plan(client, area, options, progress, *, allow_empty=False):
samples.append(dict(view, stop_in_path=stop))
return dict(
mode="streetview",
+ full_sphere=options["full_sphere"],
paths=parts,
samples=samples,
results=[],
diff --git a/tests/test_capture.py b/tests/test_capture.py
index aef848e..72299ee 100644
--- a/tests/test_capture.py
+++ b/tests/test_capture.py
@@ -10,7 +10,7 @@ from urllib.parse import parse_qs, urlsplit
from PIL import Image
-from src import capture, streetview
+from src import capture, quick, streetview
from src.common import MissingImagery
from src.geo import coordinate
@@ -30,6 +30,20 @@ def metadata(pano_id="test_panorama_123", lat=45.0, lon=9.0):
]]]).encode()
+def sphere_metadata():
+ payload = json.loads(metadata()[5:])
+ message = payload[1][0]
+ message[2] = [None, None, None, [[[[3, 6]]], [4, 2]]]
+ message[5][0][1] += [None, [120, 88, 1]]
+ return json.dumps(payload).encode()
+
+
+def sphere_tile(color):
+ with BytesIO() as buffer, Image.new("RGB", (4, 2), color) as image:
+ image.save(buffer, format="PNG")
+ return buffer.getvalue()
+
+
class CaptureTests(unittest.TestCase):
def setUp(self):
temporary = TemporaryDirectory()
@@ -142,8 +156,90 @@ class CaptureTests(unittest.TestCase):
client.get.assert_called_once()
self.assertEqual(capture.load(self.folder)["stages"][0]["results"], [])
+ def sphere_run(self):
+ run = self.street_run()
+ run["options"].update(full_sphere=True, sphere_zoom=5, streetview_format="png")
+ run["stages"][0]["full_sphere"] = True
+ return run
+
+ def test_sphere_resume_reuses_tiles_and_exports_one_cropped_panorama(self):
+ run = self.sphere_run()
+ self.assertEqual(capture.total(run["stages"][0]), 1)
+ self.assertEqual(capture.estimate(run)["streetview_stops"], 1)
+ self.assertIsNone(capture.estimate(run)["seconds"])
+ client = Mock()
+ client.get.side_effect = [sphere_metadata(), sphere_tile("red"), sphere_tile("green"), KeyboardInterrupt()]
+ with self.assertRaises(KeyboardInterrupt):
+ capture.download(run, self.folder, client, self.progress)
+ saved = capture.load(self.folder)
+ self.assertEqual(saved["stages"][0]["results"], [])
+ self.assertFalse(list(self.folder.glob("streetview/photos/*_sphere.png")))
+ self.assertEqual(len(list(self.folder.rglob("*.tile"))), 2)
+
+ client.get.reset_mock(side_effect=True)
+ client.get.side_effect = [sphere_metadata(), sphere_tile("blue"), sphere_tile("white")]
+ capture.download(saved, self.folder, client, self.progress)
+ self.assertEqual(client.get.call_count, 3)
+ queries = [parse_qs(urlsplit(call.args[0]).query) for call in client.get.call_args_list[1:]]
+ self.assertEqual([(q["x"], q["y"], q["zoom"]) for q in queries],
+ [(["0"], ["1"], ["0"]), (["1"], ["1"], ["0"])])
+ completed = capture.load(self.folder)
+ photo, = completed["stages"][0]["results"]
+ self.assertEqual((photo["projection"], photo["sphere_zoom"], photo["tile_count"]),
+ ("equirectangular", 0, 4))
+ self.assertEqual((photo["panorama_heading"], photo["panorama_pitch"], photo["panorama_roll"]), (120, 2, 1))
+ self.assertNotIn("heading", photo)
+ self.assertNotIn("fov", photo)
+ with Image.open(self.folder / photo["filename"]) as image:
+ self.assertEqual(image.size, (6, 3))
+ self.assertEqual([image.getpixel(p) for p in [(0, 0), (5, 0), (0, 2), (5, 2)]],
+ [(255, 0, 0), (0, 128, 0), (0, 0, 255), (255, 255, 255)])
+ self.assertFalse(list(self.folder.rglob("*.tile")))
+ exported = json.loads((self.folder / "streetview/photos.geojson").read_text())
+ self.assertEqual(len(exported["features"]), 1)
+ self.assertEqual(exported["features"][0]["properties"]["projection"], "equirectangular")
+ client.get.reset_mock()
+ capture.download(completed, self.folder, client, self.progress)
+ client.get.assert_not_called()
+ self.assertEqual(capture.estimate(completed)["seconds"], 0)
+
+ def test_unavailable_sphere_is_skipped_but_bad_tile_stops_capture(self):
+ for tile, state in [(MissingImagery("Gone"), "complete"), (image_bytes(), "failed")]:
+ with self.subTest(state=state):
+ run = self.sphere_run()
+ client = Mock()
+ client.get.side_effect = [sphere_metadata(), tile]
+ if state == "failed":
+ with self.assertRaisesRegex(ValueError, "panorama tile"):
+ capture.download(run, self.folder, client, self.progress)
+ else:
+ capture.download(run, self.folder, client, self.progress)
+ self.assertEqual(run["stages"][0]["results"][0]["status"], "skipped")
+ self.assertEqual(capture.load(self.folder)["state"], state)
+ self.assertFalse(list(self.folder.glob("streetview/photos/*_sphere.png")))
+
+ def test_quick_sphere_uses_tiles_and_saves_projection(self):
+ client = Mock()
+ client.get.side_effect = [sphere_metadata()] + [sphere_tile("red")] * 4
+ result = quick.street_photos(client, self.folder, self.progress, pano_id="test_panorama_123",
+ full_sphere=True, sphere_zoom=3, streetview_format="png")
+ self.assertEqual((result["saved_stops"], len(result["photos"])), (1, 1))
+ photo = result["photos"][0]
+ self.assertEqual(photo["projection"], "equirectangular")
+ with Image.open(photo["path"]) as image:
+ self.assertEqual(image.size, (6, 3))
+
class GoogleResponseTests(unittest.TestCase):
+ def test_sphere_requires_valid_dimensions_and_orientation(self):
+ with self.assertRaisesRegex(ValueError, "Unreadable Google panorama metadata"):
+ streetview.parse_metadata(metadata(), full_sphere=True)
+ for invalid in (0, -1, True, 1.5, 100000):
+ payload = json.loads(sphere_metadata())
+ payload[1][0][2][3][0][0][0][0] = invalid
+ with self.subTest(size=invalid), self.assertRaises(ValueError):
+ streetview.parse_metadata(json.dumps(payload).encode(), full_sphere=True)
+
def test_coverage_skips_sentinels_and_non_google_panoramas(self):
payload = [None, [None, [
[[1]],
diff --git a/tests/test_routes.py b/tests/test_routes.py
index 44622ab..1482fe5 100644
--- a/tests/test_routes.py
+++ b/tests/test_routes.py
@@ -106,7 +106,7 @@ class BranchedStreetTests(unittest.TestCase):
patch("src.quick.places.choose", return_value=self.place),
patch("src.quick.coverage", return_value=list(views.values())) as coverage,
patch("src.quick.streetview.metadata_url", side_effect=lambda pano_id: pano_id),
- patch("src.quick.streetview.parse_metadata", side_effect=lambda data: data)):
+ patch("src.quick.streetview.parse_metadata", side_effect=lambda data, **kwargs: data)):
result = quick.street_photos(self.client, directory, lambda *args: None,
street="Test Street", view="both", **options)
self.assertEqual([section["route"] for section in result["routes"]], section_ids)