@panoramax/web-viewer 3.0.2-develop-a8ea8e60

package/src/utils/Exif.js

@@ -0,0 +1,198 @@
+/**
+ * Read float value from EXIF tags (to handle fractions & all)
+ * @param {*} val The input EXIF tag value
+ * @returns {number|undefined} The parsed value, or undefined if value is not readable
+ * @private
+ */
+export function getExifFloat(val) {
+	// Null-like values
+	if(
+		[null, undefined, ""].includes(val)
+		|| typeof val === "string" && val.trim() === ""
+	) {
+		return undefined;
+	}
+	// Already valid number
+	else if(typeof val === "number") {
+		return val;
+	}
+	// String
+	else if(typeof val === "string") {
+		// Check if looks like a fraction
+		if(/^-?\d+(\.\d+)?\/-?\d+(\.\d+)?$/.test(val)) {
+			const parts = val.split("/").map(p => parseFloat(p));
+			return parts[0] / parts[1];
+		}
+
+		// Try a direct cast to float
+		try { return parseFloat(val); }
+		catch(e) {} // eslint-disable-line no-empty
+
+		// Unrecognized
+		return undefined;
+	}
+	else { return undefined; }
+}
+
+/**
+ * Find in picture metadata the GPS precision.
+ * @param {object} picture The GeoJSON picture feature
+ * @returns {string} The precision value (poor, fair, moderate, good, excellent, ideal, unknown)
+ * @private
+ */
+export function getGPSPrecision(picture) {
+	let quality = "unknown";
+	const gpsHPosError = getExifFloat(picture?.properties?.exif?.["Exif.GPSInfo.GPSHPositioningError"]);
+	const gpsDop = getExifFloat(picture?.properties?.exif?.["Exif.GPSInfo.GPSDOP"]);
+	
+	if(gpsHPosError !== undefined) {
+		if(gpsHPosError < 0.5) { quality = "ideal"; }
+		else if(gpsHPosError < 1) { quality = "excellent"; }
+		else if(gpsHPosError < 3) { quality = "good"; }
+		else if(gpsHPosError < 7) { quality = "moderate"; }
+		else if(gpsHPosError < 10) { quality = "fair"; }
+		else { quality = "poor"; }
+	}
+	else if(gpsDop !== undefined) {
+		if(gpsDop < 1) { quality = "ideal"; }
+		else if(gpsDop < 2) { quality = "excellent"; }
+		else if(gpsDop < 5) { quality = "good"; }
+		else if(gpsDop < 10) { quality = "moderate"; }
+		else if(gpsDop < 20) { quality = "fair"; }
+		else { quality = "poor"; }
+	}
+
+	return quality;
+}
+
+/**
+ * Compute PSV sphere correction based on picture metadata & EXIF tags.
+ * @param {object} picture The GeoJSON picture feature
+ * @returns {object} The PSV sphereCorrection value
+ * @private
+ */
+export function getSphereCorrection(picture) {
+	// Photo direction
+	let dir = picture.properties?.["view:azimuth"];
+	if(dir === undefined) {
+		const v = getExifFloat(picture.properties?.exif?.["Exif.GPSInfo.GPSImgDirection"]);
+		if(v !== undefined) {
+			dir = v;
+		}
+	}
+	dir = dir || 0;
+
+	// Yaw
+	let yaw = picture.properties?.["pers:yaw"];
+	let exifFallbacks = ["Xmp.GPano.PoseHeadingDegrees", "Xmp.Camera.Yaw", "Exif.MpfInfo.MPFYawAngle"];
+	if(yaw === undefined) {
+		for(let exif of exifFallbacks) {
+			const v = getExifFloat(picture.properties?.exif?.[exif]);
+			if(v !== undefined) {
+				yaw = v;
+				break;
+			}
+		}
+	}
+	yaw = yaw || 0;
+
+	// Check if yaw is applicable: different from photo direction
+	if(Math.round(dir) === Math.round(yaw) && yaw > 0) {
+		console.warn("Picture with UUID", picture.id, "has same GPS Image direction and Yaw, could cause rendering issues");
+		// yaw = 0;
+	}
+
+	// Pitch
+	let pitch = picture.properties?.["pers:pitch"];
+	exifFallbacks = ["Xmp.GPano.PosePitchDegrees", "Xmp.Camera.Pitch", "Exif.MpfInfo.MPFPitchAngle"];
+	if(pitch === undefined) {
+		for(let exif of exifFallbacks) {
+			const v = getExifFloat(picture.properties?.exif?.[exif]);
+			if(v !== undefined) {
+				pitch = v;
+				break;
+			}
+		}
+	}
+	pitch = pitch || 0;
+
+	// Roll
+	let roll = picture.properties?.["pers:roll"];
+	exifFallbacks = ["Xmp.GPano.PoseRollDegrees", "Xmp.Camera.Roll", "Exif.MpfInfo.MPFRollAngle"];
+	if(roll === undefined) {
+		for(let exif of exifFallbacks) {
+			const v = getExifFloat(picture.properties?.exif?.[exif]);
+			if(v !== undefined) {
+				roll = v;
+				break;
+			}
+		}
+	}
+	roll = roll || 0;
+
+	// Send result
+	return {
+		pan:  yaw * Math.PI / 180,
+		tilt: pitch * Math.PI / 180,
+		roll: roll * Math.PI / 180,
+	};
+}
+
+/**
+ * Compute PSV panoData for cropped panorama based on picture metadata & EXIF tags.
+ * @param {object} picture The GeoJSON picture feature
+ * @returns {object} The PSV panoData values
+ * @private
+ */
+export function getCroppedPanoData(picture) {
+	let res;
+
+	if(picture.properties?.["pers:interior_orientation"]) {
+		if(
+			picture.properties["pers:interior_orientation"]?.["visible_area"]
+			&& picture.properties["pers:interior_orientation"]?.["sensor_array_dimensions"]
+		) {
+			const va = picture.properties["pers:interior_orientation"]["visible_area"];
+			const sad = picture.properties["pers:interior_orientation"]["sensor_array_dimensions"];
+			try {
+				res = {
+					fullWidth: parseInt(sad[0]),
+					fullHeight: parseInt(sad[1]),
+					croppedX: parseInt(va[0]),
+					croppedY: parseInt(va[1]),
+					croppedWidth: parseInt(sad[0]) - parseInt(va[2]) - parseInt(va[0]),
+					croppedHeight: parseInt(sad[1]) - parseInt(va[3]) - parseInt(va[1]),
+				};
+			}
+			catch(e) {
+				console.warn("Invalid pers:interior_orientation values for cropped panorama "+picture.id);
+			}
+		}
+	}
+
+	if(!res && picture.properties?.exif) {
+		try {
+			res = {
+				fullWidth: parseInt(picture.properties.exif?.["Xmp.GPano.FullPanoWidthPixels"]),
+				fullHeight: parseInt(picture.properties.exif?.["Xmp.GPano.FullPanoHeightPixels"]),
+				croppedX: parseInt(picture.properties.exif?.["Xmp.GPano.CroppedAreaLeftPixels"]),
+				croppedY: parseInt(picture.properties.exif?.["Xmp.GPano.CroppedAreaTopPixels"]),
+				croppedWidth: parseInt(picture.properties.exif?.["Xmp.GPano.CroppedAreaImageWidthPixels"]),
+				croppedHeight: parseInt(picture.properties.exif?.["Xmp.GPano.CroppedAreaImageHeightPixels"]),
+			};
+		}
+		catch(e) {
+			console.warn("Invalid XMP.GPano values for cropped panorama "+picture.id);
+		}
+	}
+
+	// Check if crop is really necessary
+	if(res) {
+		res = Object.fromEntries(Object.entries(res || {}).filter(e => !isNaN(e[1])));
+		if(res.fullWidth == res.croppedWidth && res.fullHeight == res.croppedHeight) {
+			res = {};
+		}
+	}
+
+	return res || {};
+}

package/src/utils/I18n.js

@@ -0,0 +1,75 @@
+import T_de from "../translations/de.json";
+import T_en from "../translations/en.json";
+import T_es from "../translations/es.json";
+import T_fr from "../translations/fr.json";
+import T_hu from "../translations/hu.json";
+import T_zh_Hant from "../translations/zh_Hant.json";
+
+const FALLBACK_LOCALE = "en";
+const TRANSLATIONS = {
+	"de": T_de, "en": T_en, "es": T_es, "fr": T_fr, "hu": T_hu, "zh_Hant": T_zh_Hant,
+};
+
+const autoDetectLocale = () => {
+	for (const navigatorLang of window.navigator.languages) {
+		let language = navigatorLang;
+		// Convert browser code to weblate code
+		switch (language) {
+		case "zh-TW":
+		case "zh-HK":
+		case "zh-MO":
+			language = "zh_Hant";
+			break;
+		case "zh-CN":
+		case "zh-SG":
+			language = "zh_Hans";
+			break;
+		default:
+			if (language.length > 2) {
+				language = navigatorLang.substring(0, 2);
+			}
+			break;
+		}
+		const pair = Object.entries(TRANSLATIONS).find((pair) => pair[0] === language);
+		if (pair) {
+			return pair[0];
+		}
+	}
+	return FALLBACK_LOCALE;
+};
+/**
+ * Get text labels translations in given language
+ *
+ * @param {string} lang The language code (fr, en)
+ * @returns {object} Translations in given language, with fallback to english
+ * @private
+ */
+export function getTranslations(lang = "") {
+	const myTr = JSON.parse(JSON.stringify(T_en));
+	let preferedTr;
+	
+	// No specific lang set -> use browser lang
+	if(!lang) {
+		lang = autoDetectLocale();
+	}
+
+	// Lang exists -> send it
+	if(TRANSLATIONS[lang] && lang !== "en") {
+		preferedTr = TRANSLATIONS[lang];
+	}
+
+	// Look for primary lang
+	if(lang.length > 2) {
+		const primaryLang = lang.substring(0, 2);
+		if(TRANSLATIONS[primaryLang]) { preferedTr = TRANSLATIONS[primaryLang]; }
+	}
+
+	// Merge labels to avoid missing ones
+	if(preferedTr) {
+		Object.entries(preferedTr).forEach(([k1, v1]) => {
+			Object.assign(myTr[k1], v1);
+		});
+	}
+
+	return myTr;
+}

package/src/utils/Map.js

@@ -0,0 +1,382 @@
+// DO NOT REMOVE THE "!": bundled builds breaks otherwise !!!
+import maplibregl from "!maplibre-gl";
+import LoaderImg from "../img/marker.svg";
+import { COLORS } from "./Utils";
+
+export const DEFAULT_TILES = "https://panoramax.openstreetmap.fr/pmtiles/basic.json";
+export const RASTER_LAYER_ID = "gvs-aerial";
+
+export const TILES_PICTURES_ZOOM = 15;
+export const TILES_PICTURES_SYMBOL_ZOOM = 18;
+
+export const VECTOR_STYLES = {
+	PICTURES: {
+		"paint": {
+			"circle-radius": ["interpolate", ["linear"], ["zoom"],
+				TILES_PICTURES_ZOOM, 4.5,
+				TILES_PICTURES_SYMBOL_ZOOM, 6,
+				24, 12
+			],
+			"circle-opacity": ["interpolate", ["linear"], ["zoom"],
+				TILES_PICTURES_ZOOM, 0,
+				TILES_PICTURES_ZOOM+1, 1
+			],
+			"circle-stroke-color": "#ffffff",
+			"circle-stroke-width": ["interpolate", ["linear"], ["zoom"],
+				TILES_PICTURES_ZOOM+1, 0,
+				TILES_PICTURES_ZOOM+2, 1,
+				TILES_PICTURES_SYMBOL_ZOOM, 1.5,
+				24, 3
+			],
+		},
+		"layout": {}
+	},
+	PICTURES_SYMBOLS: {
+		"paint": {
+			"icon-opacity": ["interpolate", ["linear"], ["zoom"], TILES_PICTURES_SYMBOL_ZOOM, 0, TILES_PICTURES_SYMBOL_ZOOM+1, 1],
+		},
+		"layout": {
+			"icon-image": ["case", ["==", ["get", "type"], "equirectangular"], "gvs-arrow-360", "gvs-arrow-flat"],
+			"icon-size": ["interpolate", ["linear"], ["zoom"], TILES_PICTURES_SYMBOL_ZOOM, 0.5, 24, 1],
+			"icon-rotate": ["to-number", ["get", "heading"]],
+			"icon-allow-overlap": true,
+		},
+	},
+	SEQUENCES: {
+		"paint": {
+			"line-width": ["interpolate", ["linear"], ["zoom"], 0, 0.5, 10, 2, 14, 4, 16, 5, 22, 3],
+		},
+		"layout": {
+			"line-cap": "square",
+		}
+	},
+	SEQUENCES_PLUS: {
+		"paint": {
+			"line-width": ["interpolate", ["linear"], ["zoom"], 0, 15, TILES_PICTURES_ZOOM+1, 30, TILES_PICTURES_ZOOM+2, 0],
+			"line-opacity": 0,
+			"line-color": "#ff0000",
+		},
+		"layout": {
+			"line-cap": "square",
+		}
+	}
+};
+
+/**
+ * Get the GIF shown while thumbnail loads
+ * @param {object} lang Translations
+ * @returns The DOM element for this GIF
+ * @private
+ */
+export function getThumbGif(lang) {
+	const thumbGif = document.createElement("img");
+	thumbGif.src = LoaderImg;
+	thumbGif.alt = lang.loading;
+	thumbGif.title = lang.loading;
+	thumbGif.classList.add("gvs-map-thumb", "gvs-map-thumb-loader");
+	return thumbGif;
+}
+
+/**
+ * Is given layer a label layer.
+ * 
+ * This is useful for inserting new vector layer before labels in MapLibre.
+ * @param {object} l The layer to check
+ * @returns {boolean} True if it's a label layer
+ * @private
+ */
+export function isLabelLayer(l) {
+	return l.type === "symbol"
+		&& l?.layout?.["text-field"]
+		&& (l.minzoom === undefined || l.minzoom < 15);
+}
+
+/**
+ * Create all-in-one map style for MapLibre GL JS
+ * 
+ * @param {CoreView} parent The parent view
+ * @param {object} options Options from Map component
+ * @param {object} [options.raster] The MapLibre raster source for aerial background. This must be a JSON object following [MapLibre raster source definition](https://maplibre.org/maplibre-style-spec/sources/#raster).
+ * @param {string} [options.background] Choose default map background to display (streets or aerial, if raster aerial background available). Defaults to street.
+ * @param {object} [options.supplementaryStyle] Additional style properties (completing CoreView style and STAC API style)
+ * @returns {object} The full MapLibre style
+ * @private
+ */
+export function combineStyles(parent, options) {
+	// Get basic vector styles
+	const style = parent._api.getMapStyle();
+	
+	// Complete styles
+	style.layers = style.layers.concat(getMissingLayerStyles(style.sources, style.layers));
+
+	// Complementary style
+	if(options.supplementaryStyle) {
+		Object.assign(style.sources, options.supplementaryStyle.sources || {});
+		style.layers = style.layers.concat(options.supplementaryStyle.layers || []);
+	}
+
+	// Aerial imagery background
+	if(options.raster) {
+		style.sources["gvs-aerial"] = options.raster;
+		style.layers.push({
+			"id": RASTER_LAYER_ID,
+			"type": "raster",
+			"source": "gvs-aerial",
+			"layout": {
+				"visibility": options.background === "aerial" ? "visible" : "none",
+			}
+		});
+	}
+
+	// Filter out general tiles if necessary
+	if(!parent._options?.users?.includes("geovisio")) {
+		style.layers.forEach(l => {
+			if(l.source === "geovisio") {
+				if(!l.layout) { l.layout = {}; }
+				l.layout.visibility = "none";
+			}
+		});
+	}
+
+	// Order layers (base, geovisio, labels)
+	style.layers.sort((a,b) => {
+		if(isLabelLayer(a) && !isLabelLayer(b)) { return 1; }
+		else if(!isLabelLayer(a) && isLabelLayer(b)) { return -1; }
+		else {
+			if(a.id.startsWith("geovisio") && !b.id.startsWith("geovisio")) { return 1; }
+			else if(!a.id.startsWith("geovisio") && b.id.startsWith("geovisio")) { return -1; }
+			else {
+				if(a.id.endsWith("_pictures") && !b.id.endsWith("_pictures")) { return 1; }
+				if(!a.id.endsWith("_pictures") && b.id.endsWith("_pictures")) { return -1; }
+				else { return 0; }
+			}
+		}
+	});
+	
+	return style;
+}
+
+/**
+ * Identifies missing layers for a complete rendering of GeoVisio vector tiles.
+ * This allows retro-compatibility with GeoVisio instances <= 2.5.0
+ *   which didn't offer a MapLibre JSON style directly.
+ * 
+ * @param {object} sources Pre-existing MapLibre style sources
+ * @param {object} layers Pre-existing MapLibre style layers
+ * @returns List of layers to add
+ * @private
+ */
+export function getMissingLayerStyles(sources, layers) {
+	const newLayers = [];
+
+	// GeoVisio API <= 2.5.0 : add sequences + pictures
+	Object.keys(sources).filter(s => (
+		layers.find(l => l?.source === s) === undefined
+	)).forEach(s => {
+		if(s.startsWith("geovisio")) {
+			// Basic sequences
+			newLayers.push({
+				"id": `${s}_sequences`,
+				"type": "line",
+				"source": s,
+				"source-layer": "sequences",
+				"layout": {
+					...VECTOR_STYLES.SEQUENCES.layout
+				},
+				"paint": {
+					...VECTOR_STYLES.SEQUENCES.paint,
+					"line-color": COLORS.BASE,
+				},
+			});
+
+			// Padded sequence (for easier click)
+			newLayers.push({
+				"id": `${s}_sequences_plus`,
+				"type": "line",
+				"source": s,
+				"source-layer": "sequences",
+				"layout": {
+					...VECTOR_STYLES.SEQUENCES_PLUS.layout
+				},
+				"paint": {
+					...VECTOR_STYLES.SEQUENCES_PLUS.paint
+				},
+			});
+
+			// Pictures symbols
+			newLayers.push({
+				"id": `${s}_pictures_symbols`,
+				"type": "symbol",
+				"source": s,
+				"source-layer": "pictures",
+				...VECTOR_STYLES.PICTURES_SYMBOLS,
+			});
+
+			// Pictures symbols
+			newLayers.push({
+				"id": `${s}_pictures_symbols`,
+				"type": "symbol",
+				"source": s,
+				"source-layer": "pictures",
+				...VECTOR_STYLES.PICTURES_SYMBOLS,
+			});
+
+			// Pictures
+			newLayers.push({
+				"id": `${s}_pictures`,
+				"type": "circle",
+				"source": s,
+				"source-layer": "pictures",
+				"layout": {
+					...VECTOR_STYLES.PICTURES.layout
+				},
+				"paint": {
+					...VECTOR_STYLES.PICTURES.paint,
+					"circle-color": COLORS.BASE,
+				},
+			});
+		}
+	});
+
+	// Add sequences_plus for easier click on map
+	layers.filter(l => (
+		l?.id?.endsWith("_sequences")
+		&& layers.find(sl => sl?.id === l.id+"_plus") === undefined
+	)).forEach(l => {
+		newLayers.push({
+			"id": `${l.id}_plus`,
+			"type": "line",
+			"source": l.source,
+			"source-layer": l["source-layer"],
+			"layout": {
+				...VECTOR_STYLES.SEQUENCES_PLUS.layout
+			},
+			"paint": {
+				...VECTOR_STYLES.SEQUENCES_PLUS.paint
+			},
+		});
+	});
+
+	// Add pictures symbol for high-level zooms
+	layers.filter(l => (
+		l?.id?.endsWith("_pictures")
+		&& layers.find(sl => sl?.id === l.id+"_symbols") === undefined
+	)).forEach(l => {
+		// Symbols
+		newLayers.unshift({
+			"id": `${l.id}_symbols`,
+			"type": "symbol",
+			"source": l.source,
+			"source-layer": "pictures",
+			...VECTOR_STYLES.PICTURES_SYMBOLS,
+		});
+
+		// Patch style of pictures layer
+		l.paint = Object.assign(l.paint || {}, VECTOR_STYLES.PICTURES.paint);
+		l.layout = Object.assign(l.layout || {}, VECTOR_STYLES.PICTURES.layout);
+	});
+
+
+	return newLayers;
+}
+
+/**
+ * Get cleaned-up layer ID for a specific user.
+ * @param {string} userId The user UUID (or "geovisio" for general layer)
+ * @param {string} layerType The kind of layer (pictures, sequences...)
+ * @returns {string} The cleaned-up layer ID for MapLibre
+ * @private
+ */
+export function getUserLayerId(userId, layerType) {
+	return `${getUserSourceId(userId)}_${layerType}`;
+}
+
+/**
+ * Get cleaned-up source ID for a specific user.
+ * @param {string} userId The user UUID (or "geovisio" for general layer)
+ * @returns {string} The cleaned-up source ID for MapLibre
+ * @private
+ */
+export function getUserSourceId(userId) {
+	return userId === "geovisio" ? "geovisio" : "geovisio_"+userId;
+}
+
+/**
+ * Transforms a set of parameters into an URL-ready string
+ * It also removes null/undefined values
+ *
+ * @param {object} params The parameters object
+ * @return {string} The URL query part
+ * @private
+ */
+export function geocoderParamsToURLString(params) {
+	let p = {};
+	Object.entries(params)
+		.filter(e => e[1] !== undefined && e[1] !== null)
+		.forEach(e => p[e[0]] = e[1]);
+
+	return new URLSearchParams(p).toString();
+}
+
+/**
+ * Nominatim (OSM) geocoder, ready to use for our Map
+ * @private
+ */
+export function forwardGeocodingNominatim(config) {
+	// Transform parameters into Nominatim format
+	const params = {
+		q: config.query,
+		countrycodes: config.countries,
+		limit: config.limit,
+		viewbox: config.bbox,
+	};
+
+	return fetch(`https://nominatim.openstreetmap.org/search?${geocoderParamsToURLString(params)}&format=geojson&polygon_geojson=1&addressdetails=1`)
+		.then(res => res.json())
+		.then(res => {
+			const finalRes = { features: [] };
+			const listedNames = [];
+			res.features.forEach(f => {
+				if(!listedNames.includes(f.properties.display_name)) {
+					finalRes.features.push({
+						place_type: ["place"],
+						place_name: f.properties.display_name,
+						bounds: new maplibregl.LngLatBounds(f.bbox),
+					});
+					listedNames.push(f.properties.display_name);
+				}
+			});
+			return finalRes;
+		});
+}
+
+/**
+ * Base adresse nationale (FR) geocoder, ready to use for our Map
+ * @param {object} config Configuration sent by MapLibre GL Geocoder, following the geocoderApi format ( https://github.com/maplibre/maplibre-gl-geocoder/blob/main/API.md#setgeocoderapi )
+ * @returns {object} GeoJSON Feature collection in Carmen GeoJSON format
+ * @private
+ */
+export function forwardGeocodingBAN(config) {
+	// Transform parameters into BAN format
+	const params = { q: config.query, limit: config.limit };
+	if(typeof config.proximity === "string") {
+		const [lat, lon] = config.proximity.split(",").map(v => parseFloat(v.trim()));
+		params.lat = lat;
+		params.lon = lon;
+	}
+
+	const toPlaceName = p => [p.name, p.district, p.city].filter(v => v).join(", ");
+	const placeTypeToZoom =  { "housenumber": 20, "street": 18, "locality": 15, "municipality": 12 };
+	
+	return fetch(`https://api-adresse.data.gouv.fr/search/?${geocoderParamsToURLString(params)}`)
+		.then(res => res.json())
+		.then(res => {
+			res.features = res.features.map(f => ({
+				place_type: ["place"],
+				place_name: toPlaceName(f.properties),
+				center: new maplibregl.LngLat(...f.geometry.coordinates),
+				zoom: placeTypeToZoom[f.properties.type],
+			}));
+			return res;
+		});
+}

package/src/utils/PhotoAdapter.js

@@ -0,0 +1,45 @@
+import { EquirectangularTilesAdapter } from "@photo-sphere-viewer/equirectangular-tiles-adapter";
+
+/**
+ * Override of PSV EquirectangularTilesAdapter for fine-tweaking.
+ * @private
+ */
+export default class PhotoAdapter extends EquirectangularTilesAdapter {
+	constructor(viewer, config) {
+		super(viewer, config);
+		this._shouldGoFast = config.shouldGoFast || (() => true);
+	}
+
+	/**
+	 * Override to skip loading SD images according to shouldGoFast option.
+	 */
+	loadTexture(panorama, loader) {
+		if(!panorama.origBaseUrl) { panorama.origBaseUrl = panorama.baseUrl; }
+		else { panorama.baseUrl = panorama.origBaseUrl; }
+		
+		// Fast mode + thumbnail available + no HD image loaded yet + flat picture
+		if(
+			this._shouldGoFast()
+			&& panorama.thumbUrl
+			&& !panorama.hdLoaded
+			&& panorama.rows == 1
+		) {
+			panorama.baseUrl = panorama.thumbUrl;
+		}
+
+		return super.loadTexture(panorama, loader).then(data => {
+			if(panorama.baseUrl === panorama.origBaseUrl) {
+				panorama.hdLoaded = true;
+			}
+			return data;
+		});
+	}
+
+	/**
+	 * Override to skip loading tiles according to shouldGoFast option.
+	 * @private
+	 */
+	__loadTiles(tiles) {
+		if(!this._shouldGoFast()) { super.__loadTiles(tiles); }
+	}
+}