eebbc82e3f
- Atomarer Layer-Swap statt clearLayers (Marker verschwinden nie) - Einzelner API-Call (radius=250nm) statt 4 Grid-Calls (weniger Rate-Limits) - Refresh-Interval 15s -> 30s (weniger API-Last) - moveend-Debounce 1.2s -> 2s (ruhigeres Verhalten beim Navigieren) - Backend Cache-TTL 10s -> 20s, Koordinaten auf 0.5-Grad-Raster gerundet
625 Zeilen
27 KiB
JavaScript
625 Zeilen
27 KiB
JavaScript
/**
|
|
* GEOINT-Modus: Taktische Kartenansicht mit Echtzeit-Datenlayern.
|
|
* Eigenstaendiges Modul — alle GEOINT-Logik gekapselt.
|
|
*/
|
|
const GEOINT = {
|
|
_active: false,
|
|
_map: null,
|
|
_sublayers: {},
|
|
_flightLayer: null,
|
|
_quakeLayer: null,
|
|
_gdeltLayer: null,
|
|
_heatLayer: null,
|
|
_flightInterval: null,
|
|
_quakeInterval: null,
|
|
_gdeltInterval: null,
|
|
_flightFetching: false,
|
|
_moveHandler: null,
|
|
_coordControl: null,
|
|
_coordHandler: null,
|
|
_distanceActive: false,
|
|
_distancePoints: [],
|
|
_distanceLayers: null,
|
|
_distanceHandler: null,
|
|
_subControl: null,
|
|
_osmTileLayer: null,
|
|
_satTileLayer: null,
|
|
_satLabelLayer: null,
|
|
_timelineData: null,
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Hauptschalter
|
|
// -----------------------------------------------------------------------
|
|
toggle(enabled, map) {
|
|
this._active = enabled;
|
|
this._map = map;
|
|
|
|
// CSS-Klassen
|
|
var container = document.getElementById('map-container');
|
|
if (container) container.classList.toggle('geoint-active', enabled);
|
|
var fsContainer = document.getElementById('map-fullscreen-container');
|
|
if (fsContainer) fsContainer.classList.toggle('geoint-active', enabled);
|
|
var card = container ? container.closest('.map-card') : null;
|
|
if (card) card.classList.toggle('geoint-card-active', enabled);
|
|
|
|
// Sync beider Checkboxen
|
|
var cb1 = document.getElementById('geoint-mode-cb');
|
|
var cb2 = document.getElementById('geoint-mode-cb-fs');
|
|
if (cb1) cb1.checked = enabled;
|
|
if (cb2) cb2.checked = enabled;
|
|
|
|
if (enabled) {
|
|
this._applySatelliteTiles(map);
|
|
this._createSubControl(map);
|
|
this._restoreSublayers(map);
|
|
// Timeline anzeigen wenn Daten vorhanden
|
|
var tl = document.getElementById('geoint-timeline');
|
|
if (tl) tl.style.display = '';
|
|
} else {
|
|
this.cleanup();
|
|
this._restoreOsmTiles(map);
|
|
var tl = document.getElementById('geoint-timeline');
|
|
if (tl) tl.style.display = 'none';
|
|
}
|
|
|
|
this._saveState();
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Tile-Management
|
|
// -----------------------------------------------------------------------
|
|
_applySatelliteTiles(map) {
|
|
if (!map) return;
|
|
// Bestehende Tile-Layer in separatem Array sammeln, dann entfernen
|
|
var toRemove = [];
|
|
map.eachLayer(function(layer) {
|
|
if (layer instanceof L.TileLayer) toRemove.push(layer);
|
|
});
|
|
toRemove.forEach(function(layer) { map.removeLayer(layer); });
|
|
// Esri World Imagery
|
|
this._satTileLayer = L.tileLayer(
|
|
'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',
|
|
{ attribution: 'Tiles © Esri', maxZoom: 19, noWrap: true }
|
|
).addTo(map);
|
|
// Ortsnamen-Overlay
|
|
this._satLabelLayer = L.tileLayer(
|
|
'https://server.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}',
|
|
{ maxZoom: 19, noWrap: true }
|
|
).addTo(map);
|
|
// Satellite nach hinten, damit Marker darueber liegen
|
|
if (this._satTileLayer.bringToBack) this._satTileLayer.bringToBack();
|
|
},
|
|
|
|
_restoreOsmTiles(map) {
|
|
if (!map) return;
|
|
map.eachLayer(function(layer) {
|
|
if (layer instanceof L.TileLayer) map.removeLayer(layer);
|
|
});
|
|
// UI._applyMapTiles() wiederherstellen
|
|
if (typeof UI !== 'undefined' && UI._applyMapTiles) {
|
|
UI._applyMapTiles();
|
|
} else {
|
|
L.tileLayer('https://tile.openstreetmap.de/{z}/{x}/{y}.png', {
|
|
attribution: '© <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a>',
|
|
maxZoom: 18, noWrap: true
|
|
}).addTo(map);
|
|
}
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Sub-Layer Control Panel
|
|
// -----------------------------------------------------------------------
|
|
_createSubControl(map) {
|
|
if (this._subControl) return;
|
|
var self = this;
|
|
var SubControl = L.Control.extend({
|
|
options: { position: 'topright' },
|
|
onAdd: function() {
|
|
var div = L.DomUtil.create('div', 'geoint-sub-control');
|
|
L.DomEvent.disableClickPropagation(div);
|
|
L.DomEvent.disableScrollPropagation(div);
|
|
div.innerHTML =
|
|
'<h4>GEOINT Layer</h4>' +
|
|
self._subItemHtml('flights', 'Flugverkehr', 'flights') +
|
|
self._subItemHtml('quakes', 'Erdbeben', 'quakes') +
|
|
self._subItemHtml('gdelt', 'Nachrichten', 'gdelt') +
|
|
'<div class="geoint-sub-separator"></div>' +
|
|
self._subItemHtml('heatmap', 'Heatmap', 'heatmap') +
|
|
self._subItemHtml('coords', 'Koordinaten', 'coords') +
|
|
self._subItemHtml('distance', 'Distanz', 'distance');
|
|
return div;
|
|
}
|
|
});
|
|
this._subControl = new SubControl();
|
|
map.addControl(this._subControl);
|
|
|
|
// Event-Listener fuer Sub-Checkboxen
|
|
['flights', 'quakes', 'gdelt', 'heatmap', 'coords', 'distance'].forEach(function(id) {
|
|
var cb = document.getElementById('geoint-sub-' + id);
|
|
if (cb) {
|
|
cb.addEventListener('change', function() {
|
|
self._toggleSublayer(id, this.checked, map);
|
|
});
|
|
}
|
|
});
|
|
},
|
|
|
|
_subItemHtml(id, label, dotClass) {
|
|
var checked = this._sublayers[id] ? ' checked' : '';
|
|
return '<div class="geoint-sub-item">' +
|
|
'<input type="checkbox" id="geoint-sub-' + id + '"' + checked + '>' +
|
|
'<label for="geoint-sub-' + id + '"><span class="geoint-dot geoint-dot-' + dotClass + '"></span>' + label + '</label>' +
|
|
'</div>';
|
|
},
|
|
|
|
_removeSubControl() {
|
|
if (this._subControl && this._map) {
|
|
this._map.removeControl(this._subControl);
|
|
this._subControl = null;
|
|
}
|
|
},
|
|
|
|
_toggleSublayer(id, enabled, map) {
|
|
this._sublayers[id] = enabled;
|
|
this._saveState();
|
|
switch (id) {
|
|
case 'flights': enabled ? this._startFlights(map) : this._stopFlights(); break;
|
|
case 'quakes': enabled ? this._startQuakes(map) : this._stopQuakes(); break;
|
|
case 'gdelt': enabled ? this._startGdelt(map) : this._stopGdelt(); break;
|
|
case 'heatmap': enabled ? this._startHeatmap(map) : this._stopHeatmap(); break;
|
|
case 'coords': enabled ? this._startCoords(map) : this._stopCoords(); break;
|
|
case 'distance': enabled ? this._startDistance(map) : this._stopDistance(); break;
|
|
}
|
|
},
|
|
|
|
_restoreSublayers(map) {
|
|
var self = this;
|
|
Object.keys(this._sublayers).forEach(function(id) {
|
|
if (self._sublayers[id]) {
|
|
self._toggleSublayer(id, true, map);
|
|
}
|
|
});
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Layer: Flugverkehr
|
|
// -----------------------------------------------------------------------
|
|
_startFlights(map) {
|
|
if (this._flightLayer) return;
|
|
this._flightLayer = L.layerGroup().addTo(map);
|
|
var self = this;
|
|
this._fetchFlights(map);
|
|
this._flightInterval = setInterval(function() { self._fetchFlights(map); }, 30000);
|
|
// Bei Kartenbewegung neu laden
|
|
this._moveHandler = function() {
|
|
clearTimeout(self._moveDebounce);
|
|
self._moveDebounce = setTimeout(function() { self._fetchFlights(map); }, 2000);
|
|
};
|
|
map.on('moveend', this._moveHandler);
|
|
},
|
|
|
|
_stopFlights() {
|
|
if (this._flightInterval) { clearInterval(this._flightInterval); this._flightInterval = null; }
|
|
if (this._moveHandler && this._map) { this._map.off('moveend', this._moveHandler); this._moveHandler = null; }
|
|
if (this._flightLayer && this._map) { this._map.removeLayer(this._flightLayer); this._flightLayer = null; }
|
|
},
|
|
|
|
_fetchFlights(map) {
|
|
if (this._flightFetching || !map || map.getZoom() < 3) return;
|
|
this._flightFetching = true;
|
|
var center = map.getCenter();
|
|
var self = this;
|
|
var token = localStorage.getItem('osint_token') || '';
|
|
var headers = token ? { 'Authorization': 'Bearer ' + token } : {};
|
|
|
|
fetch('/api/geoint/flights?lat=' + center.lat.toFixed(2) + '&lon=' + center.lng.toFixed(2) + '&radius=250', { headers: headers })
|
|
.then(function(r) { return r.ok ? r.json() : { ac: [] }; })
|
|
.then(function(data) {
|
|
if (!self._flightLayer) return;
|
|
// Neue Marker in temporaerem Layer bauen, dann atomar swappen
|
|
var newLayer = L.layerGroup();
|
|
var ac = data.ac || data.aircraft || [];
|
|
ac.slice(0, 500).forEach(function(a) {
|
|
if (!a.lat || !a.lon) return;
|
|
var heading = a.track || a.true_heading || 0;
|
|
var icon = L.divIcon({
|
|
className: '',
|
|
html: '<div class="geoint-aircraft" style="transform:rotate(' + heading + 'deg)">' +
|
|
'<svg viewBox="0 0 24 24" fill="#00ff88" stroke="#004422" stroke-width="1">' +
|
|
'<path d="M12 2L8 10h-4l2 4-2 4h4l4 4 4-4h4l-2-4 2-4h-4z"/>' +
|
|
'</svg></div>',
|
|
iconSize: [14, 14],
|
|
iconAnchor: [7, 7],
|
|
});
|
|
var callsign = (a.flight || a.callsign || a.hex || '???').trim();
|
|
var alt = a.alt_baro || a.altitude || '?';
|
|
var spd = a.gs || a.ground_speed || '?';
|
|
var typ = a.t || a.type || '';
|
|
var popup = '<div class="geoint-popup">' +
|
|
'<strong>' + callsign + '</strong>' +
|
|
(typ ? ' <span style="opacity:0.5">(' + typ + ')</span>' : '') +
|
|
'<br><span class="geoint-popup-key">ALT</span> ' + (typeof alt === 'number' ? alt.toLocaleString() + ' ft' : alt) +
|
|
'<br><span class="geoint-popup-key">SPD</span> ' + (typeof spd === 'number' ? Math.round(spd) + ' kts' : spd) +
|
|
'<br><span class="geoint-popup-key">HDG</span> ' + Math.round(heading) + '°' +
|
|
'</div>';
|
|
L.marker([a.lat, a.lon], { icon: icon }).bindPopup(popup, { className: 'geoint-leaflet-popup' }).addTo(newLayer);
|
|
});
|
|
// Atomar swappen: alte Marker entfernen, neue hinzufuegen
|
|
if (self._map && self._flightLayer) {
|
|
self._map.removeLayer(self._flightLayer);
|
|
self._flightLayer = newLayer.addTo(self._map);
|
|
}
|
|
})
|
|
.catch(function(e) { if (typeof DEV_MODE !== 'undefined' && DEV_MODE) console.warn('GEOINT flights:', e); })
|
|
.finally(function() { self._flightFetching = false; });
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Layer: Erdbeben
|
|
// -----------------------------------------------------------------------
|
|
_startQuakes(map) {
|
|
if (this._quakeLayer) return;
|
|
this._quakeLayer = L.layerGroup().addTo(map);
|
|
this._fetchQuakes(map);
|
|
var self = this;
|
|
this._quakeInterval = setInterval(function() { self._fetchQuakes(map); }, 300000); // 5 min
|
|
},
|
|
|
|
_stopQuakes() {
|
|
if (this._quakeInterval) { clearInterval(this._quakeInterval); this._quakeInterval = null; }
|
|
if (this._quakeLayer && this._map) { this._map.removeLayer(this._quakeLayer); this._quakeLayer = null; }
|
|
},
|
|
|
|
_fetchQuakes(map) {
|
|
if (!this._quakeLayer) return;
|
|
var self = this;
|
|
fetch('https://earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson')
|
|
.then(function(r) { return r.json(); })
|
|
.then(function(data) {
|
|
if (!self._quakeLayer) return;
|
|
self._quakeLayer.clearLayers();
|
|
var now = Date.now();
|
|
(data.features || []).forEach(function(f) {
|
|
var coords = f.geometry.coordinates;
|
|
var p = f.properties;
|
|
var mag = p.mag || 1;
|
|
var ageH = (now - p.time) / 3600000;
|
|
var color = ageH < 1 ? '#ff0000' : ageH < 6 ? '#ff6600' : ageH < 12 ? '#ffaa00' : '#ffdd00';
|
|
var radius = Math.max(mag * 3.5, 5);
|
|
var cls = ageH < 2 ? 'geoint-quake-marker' : '';
|
|
var marker = L.circleMarker([coords[1], coords[0]], {
|
|
radius: radius,
|
|
fillColor: color,
|
|
color: color,
|
|
weight: 1.5,
|
|
fillOpacity: 0.6,
|
|
className: cls
|
|
});
|
|
var timeStr = new Date(p.time).toLocaleString('de-DE', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' });
|
|
marker.bindPopup(
|
|
'<div class="geoint-popup">' +
|
|
'<strong>M' + mag.toFixed(1) + '</strong> ' + (p.place || '') +
|
|
'<br><span class="geoint-popup-key">TIEFE</span> ' + (coords[2] || '?') + ' km' +
|
|
'<br><span class="geoint-popup-key">ZEIT</span> ' + timeStr +
|
|
'</div>', { className: 'geoint-leaflet-popup' }
|
|
);
|
|
marker.addTo(self._quakeLayer);
|
|
});
|
|
})
|
|
.catch(function(e) { if (typeof DEV_MODE !== 'undefined' && DEV_MODE) console.warn('GEOINT quakes:', e); });
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Layer: GDELT Nachrichten
|
|
// -----------------------------------------------------------------------
|
|
_startGdelt(map) {
|
|
if (this._gdeltLayer) return;
|
|
this._gdeltLayer = L.markerClusterGroup({
|
|
maxClusterRadius: 30,
|
|
iconCreateFunction: function(cluster) {
|
|
var count = cluster.getChildCount();
|
|
return L.divIcon({
|
|
html: '<div class="geoint-gdelt-icon">' + (count > 99 ? '99+' : count) + '</div>',
|
|
className: '',
|
|
iconSize: [22, 22],
|
|
});
|
|
}
|
|
}).addTo(map);
|
|
this._fetchGdelt(map);
|
|
var self = this;
|
|
this._gdeltInterval = setInterval(function() { self._fetchGdelt(map); }, 600000); // 10 min
|
|
},
|
|
|
|
_stopGdelt() {
|
|
if (this._gdeltInterval) { clearInterval(this._gdeltInterval); this._gdeltInterval = null; }
|
|
if (this._gdeltLayer && this._map) { this._map.removeLayer(this._gdeltLayer); this._gdeltLayer = null; }
|
|
},
|
|
|
|
_fetchGdelt(map) {
|
|
if (!this._gdeltLayer) return;
|
|
var self = this;
|
|
// Holt Lage-Kontext fuer GDELT-Suche
|
|
var query = '';
|
|
if (typeof App !== 'undefined' && App.currentIncidentId) {
|
|
var inc = (App.incidents || []).find(function(i) { return i.id === App.currentIncidentId; });
|
|
if (inc) query = encodeURIComponent((inc.title || '').substring(0, 80));
|
|
}
|
|
if (!query) query = 'conflict OR crisis OR disaster';
|
|
var token = localStorage.getItem('osint_token') || '';
|
|
|
|
fetch('/api/geoint/gdelt?query=' + query, {
|
|
headers: token ? { 'Authorization': 'Bearer ' + token } : {}
|
|
})
|
|
.then(function(r) { return r.ok ? r.json() : Promise.reject(r.status); })
|
|
.then(function(data) {
|
|
if (!self._gdeltLayer) return;
|
|
self._gdeltLayer.clearLayers();
|
|
var features = data.features || [];
|
|
features.slice(0, 200).forEach(function(f) {
|
|
var coords = f.geometry.coordinates;
|
|
var p = f.properties || {};
|
|
var name = p.name || p.title || 'Nachricht';
|
|
var url = p.url || p.shareimage || '';
|
|
var icon = L.divIcon({
|
|
className: '',
|
|
html: '<div class="geoint-gdelt-icon">N</div>',
|
|
iconSize: [18, 18],
|
|
iconAnchor: [9, 9],
|
|
});
|
|
var popup = '<div class="geoint-popup" style="max-width:240px">' +
|
|
'<strong>' + name.substring(0, 100) + '</strong>' +
|
|
(url ? '<br><a href="' + url + '" target="_blank" rel="noopener" style="color:#44aaff;font-size:10px">Quelle</a>' : '') +
|
|
'</div>';
|
|
L.marker([coords[1], coords[0]], { icon: icon }).bindPopup(popup, { className: 'geoint-leaflet-popup' }).addTo(self._gdeltLayer);
|
|
});
|
|
})
|
|
.catch(function(e) { if (typeof DEV_MODE !== 'undefined' && DEV_MODE) console.warn('GEOINT gdelt:', e); });
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Layer: Heatmap
|
|
// -----------------------------------------------------------------------
|
|
_startHeatmap(map) {
|
|
if (this._heatLayer) return;
|
|
if (typeof L.heatLayer === 'undefined') {
|
|
if (typeof DEV_MODE !== 'undefined' && DEV_MODE) console.warn('GEOINT: leaflet-heat nicht geladen');
|
|
return;
|
|
}
|
|
// Locations aus UI-State holen
|
|
var locations = (typeof UI !== 'undefined' && UI._lastLocations) ? UI._lastLocations : [];
|
|
if (!locations.length) return;
|
|
var maxCount = Math.max.apply(null, locations.map(function(l) { return l.article_count || 1; }));
|
|
var points = locations.map(function(l) {
|
|
return [l.lat, l.lon, (l.article_count || 1) / maxCount];
|
|
});
|
|
this._heatLayer = L.heatLayer(points, {
|
|
radius: 30,
|
|
blur: 20,
|
|
maxZoom: 12,
|
|
gradient: { 0.2: '#004400', 0.4: '#00ff88', 0.6: '#ffaa00', 0.8: '#ff4400', 1.0: '#ff0000' }
|
|
}).addTo(map);
|
|
},
|
|
|
|
_stopHeatmap() {
|
|
if (this._heatLayer && this._map) { this._map.removeLayer(this._heatLayer); this._heatLayer = null; }
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Koordinatenanzeige
|
|
// -----------------------------------------------------------------------
|
|
_startCoords(map) {
|
|
if (this._coordControl) return;
|
|
var CoordControl = L.Control.extend({
|
|
options: { position: 'bottomleft' },
|
|
onAdd: function() {
|
|
var div = L.DomUtil.create('div', 'geoint-coord-display');
|
|
div.id = 'geoint-coord-text';
|
|
div.textContent = 'LAT: -- LON: --';
|
|
return div;
|
|
}
|
|
});
|
|
this._coordControl = new CoordControl();
|
|
map.addControl(this._coordControl);
|
|
var el = document.getElementById('geoint-coord-text');
|
|
this._coordHandler = function(e) {
|
|
if (el) el.textContent = 'LAT: ' + e.latlng.lat.toFixed(4) + ' LON: ' + e.latlng.lng.toFixed(4);
|
|
};
|
|
map.on('mousemove', this._coordHandler);
|
|
},
|
|
|
|
_stopCoords() {
|
|
if (this._coordHandler && this._map) { this._map.off('mousemove', this._coordHandler); this._coordHandler = null; }
|
|
if (this._coordControl && this._map) { this._map.removeControl(this._coordControl); this._coordControl = null; }
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Distanzmessung
|
|
// -----------------------------------------------------------------------
|
|
_startDistance(map) {
|
|
if (this._distanceLayers) return;
|
|
this._distanceLayers = L.layerGroup().addTo(map);
|
|
this._distancePoints = [];
|
|
this._distanceActive = true;
|
|
map.getContainer().style.cursor = 'crosshair';
|
|
var self = this;
|
|
this._distanceHandler = function(e) {
|
|
self._distancePoints.push(e.latlng);
|
|
if (self._distancePoints.length >= 2) {
|
|
var p1 = self._distancePoints[self._distancePoints.length - 2];
|
|
var p2 = self._distancePoints[self._distancePoints.length - 1];
|
|
L.polyline([p1, p2], { color: '#000000', weight: 5, opacity: 0.5 }).addTo(self._distanceLayers); L.polyline([p1, p2], { color: '#ff2222', weight: 3, dashArray: '8 5' }).addTo(self._distanceLayers);
|
|
var dist = p1.distanceTo(p2);
|
|
var totalDist = 0;
|
|
for (var i = 1; i < self._distancePoints.length; i++) {
|
|
totalDist += self._distancePoints[i - 1].distanceTo(self._distancePoints[i]);
|
|
}
|
|
var label = dist >= 1000
|
|
? (dist / 1000).toFixed(1) + ' km'
|
|
: Math.round(dist) + ' m';
|
|
var totalLabel = totalDist >= 1000
|
|
? (totalDist / 1000).toFixed(1) + ' km'
|
|
: Math.round(totalDist) + ' m';
|
|
var midLat = (p1.lat + p2.lat) / 2;
|
|
var midLng = (p1.lng + p2.lng) / 2;
|
|
var text = self._distancePoints.length > 2
|
|
? label + ' (Σ ' + totalLabel + ')'
|
|
: label;
|
|
L.marker([midLat, midLng], {
|
|
icon: L.divIcon({
|
|
className: '',
|
|
html: '<div class="geoint-distance-label">' + text + '</div>',
|
|
iconSize: [0, 0],
|
|
iconAnchor: [0, 12],
|
|
})
|
|
}).addTo(self._distanceLayers);
|
|
}
|
|
// Punkt-Marker
|
|
L.circleMarker(e.latlng, { radius: 6, fillColor: '#ff2222', color: '#ffffff', fillOpacity: 1, weight: 2 }).addTo(self._distanceLayers);
|
|
};
|
|
map.on('click', this._distanceHandler);
|
|
},
|
|
|
|
_stopDistance() {
|
|
this._distanceActive = false;
|
|
this._distancePoints = [];
|
|
if (this._distanceHandler && this._map) {
|
|
this._map.off('click', this._distanceHandler);
|
|
this._distanceHandler = null;
|
|
this._map.getContainer().style.cursor = '';
|
|
}
|
|
if (this._distanceLayers && this._map) { this._map.removeLayer(this._distanceLayers); this._distanceLayers = null; }
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Timeline-Slider
|
|
// -----------------------------------------------------------------------
|
|
initTimeline(articles) {
|
|
if (!articles || !articles.length) return;
|
|
var dates = articles
|
|
.map(function(a) { return a.collected_at || a.published_at; })
|
|
.filter(Boolean)
|
|
.map(function(d) { return new Date(d).getTime(); })
|
|
.filter(function(t) { return !isNaN(t); })
|
|
.sort(function(a, b) { return a - b; });
|
|
if (dates.length < 2) return;
|
|
|
|
this._timelineData = { min: dates[0], max: dates[dates.length - 1], articles: articles };
|
|
var slider = document.getElementById('geoint-timeline-slider');
|
|
var label = document.getElementById('geoint-timeline-label');
|
|
if (!slider) return;
|
|
slider.min = dates[0];
|
|
slider.max = dates[dates.length - 1];
|
|
slider.value = dates[dates.length - 1];
|
|
if (label) label.textContent = this._formatTimelineDate(dates[dates.length - 1]);
|
|
},
|
|
|
|
_onTimelineChange(value) {
|
|
var label = document.getElementById('geoint-timeline-label');
|
|
if (label) label.textContent = this._formatTimelineDate(parseInt(value));
|
|
this._filterMarkersByTime(parseInt(value));
|
|
},
|
|
|
|
_formatTimelineDate(ts) {
|
|
var d = new Date(ts);
|
|
return d.toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit' }) + ' ' +
|
|
d.toLocaleTimeString('de-DE', { hour: '2-digit', minute: '2-digit' });
|
|
},
|
|
|
|
_filterMarkersByTime(maxTime) {
|
|
// Filtert die bestehenden Marker im Cluster anhand des Zeitstempels
|
|
if (!this._map || !UI._mapCluster || !this._timelineData) return;
|
|
var articles = this._timelineData.articles;
|
|
var visibleIds = new Set();
|
|
articles.forEach(function(a) {
|
|
var t = new Date(a.collected_at || a.published_at || 0).getTime();
|
|
if (t <= maxTime) visibleIds.add(a.id);
|
|
});
|
|
// Marker sichtbar/unsichtbar machen ueber Opacity
|
|
UI._mapCluster.eachLayer(function(marker) {
|
|
if (marker._articleIds) {
|
|
var visible = marker._articleIds.some(function(id) { return visibleIds.has(id); });
|
|
marker.setOpacity(visible ? 1 : 0.08);
|
|
}
|
|
});
|
|
},
|
|
|
|
_resetTimeline() {
|
|
var slider = document.getElementById('geoint-timeline-slider');
|
|
if (slider && this._timelineData) {
|
|
slider.value = this._timelineData.max;
|
|
this._onTimelineChange(this._timelineData.max);
|
|
}
|
|
},
|
|
|
|
|
|
// Berechnet Grid-Punkte fuer vollstaendige Kartenabdeckung
|
|
_calcGridPoints(bounds) {
|
|
var n = bounds.getNorth(), s = bounds.getSouth();
|
|
var e = bounds.getEast(), w = bounds.getWest();
|
|
var latSpan = Math.abs(n - s);
|
|
var lonSpan = Math.abs(e - w);
|
|
// Ein Punkt deckt ~250nm (~4.2 Grad) ab
|
|
var step = 3.5; // Grad pro Grid-Zelle (etwas Overlap)
|
|
var latSteps = Math.max(1, Math.ceil(latSpan / step));
|
|
var lonSteps = Math.max(1, Math.ceil(lonSpan / step));
|
|
// Maximal 4 Punkte (2x2 Grid) um API-Last zu begrenzen
|
|
if (latSteps > 2) latSteps = 2;
|
|
if (lonSteps > 2) lonSteps = 2;
|
|
var points = [];
|
|
var latStep = latSpan / latSteps;
|
|
var lonStep = lonSpan / lonSteps;
|
|
for (var i = 0; i < latSteps; i++) {
|
|
for (var j = 0; j < lonSteps; j++) {
|
|
points.push({
|
|
lat: s + latStep * (i + 0.5),
|
|
lon: w + lonStep * (j + 0.5),
|
|
radius: Math.min(Math.round(Math.max(latStep, lonStep) / 2 * 60), 250)
|
|
});
|
|
}
|
|
}
|
|
return points;
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Cleanup
|
|
// -----------------------------------------------------------------------
|
|
cleanup() {
|
|
this._stopFlights();
|
|
this._stopQuakes();
|
|
this._stopGdelt();
|
|
this._stopHeatmap();
|
|
this._stopCoords();
|
|
this._stopDistance();
|
|
this._removeSubControl();
|
|
// CSS-Klassen entfernen
|
|
var container = document.getElementById('map-container');
|
|
if (container) container.classList.remove('geoint-active');
|
|
var fsContainer = document.getElementById('map-fullscreen-container');
|
|
if (fsContainer) fsContainer.classList.remove('geoint-active');
|
|
},
|
|
|
|
// -----------------------------------------------------------------------
|
|
// State Persistenz
|
|
// -----------------------------------------------------------------------
|
|
_saveState() {
|
|
try {
|
|
localStorage.setItem('geoint_mode', this._active ? 'true' : 'false');
|
|
localStorage.setItem('geoint_sublayers', JSON.stringify(this._sublayers));
|
|
} catch (e) { /* quota exceeded */ }
|
|
},
|
|
|
|
restoreState(map) {
|
|
if (!map) return;
|
|
this._map = map;
|
|
try {
|
|
var savedSublayers = localStorage.getItem('geoint_sublayers');
|
|
if (savedSublayers) this._sublayers = JSON.parse(savedSublayers);
|
|
} catch (e) { this._sublayers = {}; }
|
|
|
|
var wasActive = localStorage.getItem('geoint_mode') === 'true';
|
|
if (wasActive) {
|
|
this.toggle(true, map);
|
|
}
|
|
},
|
|
};
|