qwc2-lts
Version:
QGIS Web Client
670 lines (655 loc) • 32.7 kB
JavaScript
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
/**
* Copyright 2024 Sourcepole AG
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
import React from 'react';
import { connect } from 'react-redux';
import Instance from '@giro3d/giro3d/core/Instance.js';
import Extent from '@giro3d/giro3d/core/geographic/Extent.js';
import ElevationLayer from '@giro3d/giro3d/core/layer/ElevationLayer.js';
import Map from '@giro3d/giro3d/entities/Map.js';
import Tiles3D from "@giro3d/giro3d/entities/Tiles3D.js";
import GeoTIFFSource from "@giro3d/giro3d/sources/GeoTIFFSource.js";
import Tiles3DSource from "@giro3d/giro3d/sources/Tiles3DSource.js";
import { fromUrl } from "geotiff";
import PropTypes from 'prop-types';
import { Vector2, CubeTextureLoader, Group, Raycaster, Mesh } from 'three';
import { v1 as uuidv1 } from 'uuid';
import { LayerRole } from '../../actions/layers';
import { setMapCrs } from '../../actions/map3d';
import { setCurrentTask } from '../../actions/task';
import { BackgroundSwitcher } from '../../plugins/BackgroundSwitcher';
import ConfigUtils from '../../utils/ConfigUtils';
import CoordinatesUtils from '../../utils/CoordinatesUtils';
import BottomBar3D from './BottomBar3D';
import Compare3D from './Compare3D';
import Draw3D from './Draw3D';
import LayerTree3D from './LayerTree3D';
import Map3DLight from './Map3DLight';
import MapControls3D from './MapControls3D';
import MapExport3D from './MapExport3D';
import Measure3D from './Measure3D';
import OverviewMap3D from './OverviewMap3D';
import TopBar3D from './TopBar3D';
import LayerRegistry from './layers/index';
import './style/Map3D.css';
var UnloadWrapper = /*#__PURE__*/function (_React$Component) {
function UnloadWrapper() {
var _this;
_classCallCheck(this, UnloadWrapper);
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_this = _callSuper(this, UnloadWrapper, [].concat(args));
_defineProperty(_this, "onUnload", function (el) {
if (!el) {
_this.props.onUnload(_this.props.sceneId);
}
});
return _this;
}
_inherits(UnloadWrapper, _React$Component);
return _createClass(UnloadWrapper, [{
key: "render",
value: function render() {
return /*#__PURE__*/React.createElement("div", null, this.props.children, /*#__PURE__*/React.createElement("span", {
ref: this.onUnload
}));
}
}]);
}(React.Component);
_defineProperty(UnloadWrapper, "propTypes", {
children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
onUnload: PropTypes.func,
sceneId: PropTypes.string
});
var Map3D = /*#__PURE__*/function (_React$Component2) {
function Map3D(props) {
var _this2;
_classCallCheck(this, Map3D);
_this2 = _callSuper(this, Map3D, [props]);
_defineProperty(_this2, "state", {
sceneContext: _objectSpread(_objectSpread({}, Map3D.defaultSceneState), {}, {
addLayer: function addLayer(layer) {},
getLayer: function getLayer(layerId) {},
removeLayer: function removeLayer(layerId) {},
updateColorLayer: function updateColorLayer(layerId, options) {},
addSceneObject: function addSceneObject(objectId, object) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
},
getSceneObject: function getSceneObject(objectId) {},
removeSceneObject: function removeSceneObject(objectId) {},
updateSceneObject: function updateSceneObject(objectId, options) {},
setViewToExtent: function setViewToExtent(bounds, angle) {},
getTerrainHeight: function getTerrainHeight(scenePos) {},
getSceneIntersection: function getSceneIntersection(x, y) {}
}),
sceneId: null
});
_defineProperty(_this2, "applyBaseLayer", function () {
var baseLayer = _this2.state.sceneContext.baseLayers.find(function (e) {
return e.visibility === true;
});
_this2.removeLayer("__baselayer");
if (!baseLayer) {
return;
}
var layerCreator = LayerRegistry[baseLayer.type];
if (layerCreator !== null && layerCreator !== void 0 && layerCreator.create3d) {
var layer3d = layerCreator.create3d(baseLayer, _this2.props.projection);
_this2.addLayer("__baselayer", layer3d);
_this2.map.insertLayerAfter(layer3d, null);
}
});
_defineProperty(_this2, "setBaseLayer", function (layer, visibility) {
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
baseLayers: state.sceneContext.baseLayers.map(function (entry) {
return _objectSpread(_objectSpread({}, entry), {}, {
visibility: entry.name === layer.name ? visibility : false
});
})
})
};
});
});
_defineProperty(_this2, "collectColorLayers", function (prevColorLayers) {
var prevLayersMap = prevColorLayers.reduce(function (res, layer) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, layer.id, layer));
}, {});
return _this2.props.layers.map(function (layer) {
var _prevLayer$visibility, _prevLayer$opacity;
if (layer.role !== LayerRole.THEME && layer.role !== LayerRole.USERLAYER) {
return null;
}
var layerCreator = LayerRegistry[layer.type];
if (!layerCreator || !layerCreator.create3d) {
return null;
}
var prevLayer = prevLayersMap[layer.id];
return _objectSpread(_objectSpread({}, layer), {}, {
visibility: (_prevLayer$visibility = prevLayer === null || prevLayer === void 0 ? void 0 : prevLayer.visibility) !== null && _prevLayer$visibility !== void 0 ? _prevLayer$visibility : false,
opacity: (_prevLayer$opacity = prevLayer === null || prevLayer === void 0 ? void 0 : prevLayer.opacity) !== null && _prevLayer$opacity !== void 0 ? _prevLayer$opacity : 255
});
}).filter(Boolean);
});
_defineProperty(_this2, "applyColorLayerUpdates", function (layers, prevLayers) {
var layersMap = layers.reduce(function (res, layer) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, layer.id, layer));
}, {});
var prevLayersMap = prevLayers.reduce(function (res, layer) {
return _objectSpread(_objectSpread({}, res), {}, _defineProperty({}, layer.id, layer));
}, {});
// Add-update new layers
var prevLayer = _this2.getLayer("__baselayer");
_toConsumableArray(layers).reverse().forEach(function (layer) {
var layerCreator = LayerRegistry[layer.type];
var mapLayer = _this2.getLayer(layer.id);
if (mapLayer) {
layerCreator.update3d(mapLayer.source, layer, prevLayersMap[layer.id], _this2.props.projection);
} else {
mapLayer = layerCreator.create3d(layer, _this2.props.projection);
_this2.addLayer(layer.id, mapLayer);
}
_this2.map.insertLayerAfter(mapLayer, prevLayer);
mapLayer.visible = layer.visibility;
mapLayer.opacity = layer.opacity / 255;
prevLayer = mapLayer;
});
// Remove old layers
Object.keys(prevLayers).forEach(function (layer) {
if (!(layer.id in layersMap)) {
_this2.removeLayer(layer.id);
}
});
_this2.instance.notifyChange(_this2.map);
});
_defineProperty(_this2, "applySceneObjectUpdates", function (sceneObjects) {
Object.entries(sceneObjects).forEach(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
objectId = _ref2[0],
options = _ref2[1];
var object = _this2.objectMap[objectId];
object.visible = options.visible;
object.opacity = options.opacity;
_this2.instance.notifyChange(object);
});
});
_defineProperty(_this2, "addLayer", function (layerId, layer) {
layer.userData.layerId = layerId;
_this2.map.addLayer(layer);
});
_defineProperty(_this2, "getLayer", function (layerId) {
var _this2$map$getLayers$;
return (_this2$map$getLayers$ = _this2.map.getLayers(function (l) {
return l.userData.layerId === layerId;
})[0]) !== null && _this2$map$getLayers$ !== void 0 ? _this2$map$getLayers$ : null;
});
_defineProperty(_this2, "removeLayer", function (layerId) {
_this2.map.getLayers(function (l) {
return l.userData.layerId === layerId;
}).forEach(function (layer) {
_this2.map.removeLayer(layer, {
dispose: true
});
});
});
_defineProperty(_this2, "updateColorLayer", function (layerId, diff) {
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
colorLayers: state.sceneContext.colorLayers.map(function (entry) {
return entry.id === layerId ? _objectSpread(_objectSpread({}, entry), diff) : entry;
})
})
};
});
});
_defineProperty(_this2, "addSceneObject", function (objectId, object) {
var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
_this2.sceneObjectGroup.add(object);
_this2.objectMap[objectId] = object;
_this2.setState(function (state) {
var objectState = _objectSpread({
visible: true,
opacity: 100,
layertree: false
}, options);
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
sceneObjects: _objectSpread(_objectSpread({}, state.sceneContext.sceneObjects), {}, _defineProperty({}, objectId, objectState))
})
};
});
});
_defineProperty(_this2, "getSceneObject", function (objectId) {
return _this2.objectMap[objectId];
});
_defineProperty(_this2, "removeSceneObject", function (objectId) {
if (!_this2.objectMap[objectId]) {
return;
}
_this2.setState(function (state) {
_this2.instance.remove(_this2.objectMap[objectId]);
delete _this2.objectMap[objectId];
var newSceneObjects = _objectSpread({}, state.sceneContext.sceneObjects);
delete newSceneObjects[objectId];
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
sceneObjects: newSceneObjects
})
};
});
});
_defineProperty(_this2, "updateSceneObject", function (objectId, options) {
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
sceneObjects: _objectSpread(_objectSpread({}, state.sceneContext.sceneObjects), {}, _defineProperty({}, objectId, _objectSpread(_objectSpread({}, state.sceneContext.sceneObjects[objectId]), options)))
})
};
});
});
_defineProperty(_this2, "setupContainer", function (el) {
if (el) {
_this2.container = el;
_this2.setupInstance();
}
});
_defineProperty(_this2, "setupInstance", function () {
var _this2$props$theme$ma, _this2$props$theme$ma2, _this2$props$theme$ma3, _this2$props$theme$ma6, _this2$props$theme$ma7;
if (_this2.instance) {
_this2.disposeInstance();
}
var projection = _this2.props.projection;
_this2.props.setMapCrs(projection);
// Setup instance
_this2.instance = new Instance({
target: _this2.container,
crs: projection,
renderer: {
clearColor: 0x000000,
preserveDrawingBuffer: true
}
});
_this2.sceneObjectGroup = new Group();
_this2.instance.add(_this2.sceneObjectGroup);
// Setup map
var bounds = CoordinatesUtils.reprojectBbox(_this2.props.theme.bbox.bounds, _this2.props.theme.bbox.crs, projection);
var extent = new Extent(projection, bounds[0], bounds[2], bounds[1], bounds[3]);
_this2.map = new Map({
extent: extent,
backgroundColor: "white",
hillshading: true
});
_this2.instance.add(_this2.map);
// Setup camera
var center = extent.center();
_this2.instance.view.camera.position.set(center.x, center.y, 0.5 * (extent.east - extent.west));
// Skybox
var cubeTextureLoader = new CubeTextureLoader();
cubeTextureLoader.setPath(ConfigUtils.getAssetsPath() + "/3d/skybox/");
var cubeTexture = cubeTextureLoader.load(["px.jpg", "nx.jpg", "py.jpg", "ny.jpg", "pz.jpg", "nz.jpg"]);
_this2.instance.scene.background = cubeTexture;
// Setup elevation
var demUrl = (_this2$props$theme$ma = (_this2$props$theme$ma2 = _this2.props.theme.map3d) === null || _this2$props$theme$ma2 === void 0 || (_this2$props$theme$ma2 = _this2$props$theme$ma2.dtm) === null || _this2$props$theme$ma2 === void 0 ? void 0 : _this2$props$theme$ma2.url) !== null && _this2$props$theme$ma !== void 0 ? _this2$props$theme$ma : "";
if (demUrl.startsWith(":")) {
demUrl = location.href.split("?")[0] + ConfigUtils.getAssetsPath() + demUrl.substr(1);
}
var demCrs = ((_this2$props$theme$ma3 = _this2.props.theme.map3d) === null || _this2$props$theme$ma3 === void 0 || (_this2$props$theme$ma3 = _this2$props$theme$ma3.dtm) === null || _this2$props$theme$ma3 === void 0 ? void 0 : _this2$props$theme$ma3.crs) || "EPSG:3857";
if (demUrl) {
var _this2$props$theme$ma4, _this2$props$theme$ma5;
var demSource = new GeoTIFFSource({
url: demUrl,
crs: demCrs
});
var demMin = (_this2$props$theme$ma4 = _this2.props.theme.map3d.dtm.min) !== null && _this2$props$theme$ma4 !== void 0 ? _this2$props$theme$ma4 : undefined;
var demMax = (_this2$props$theme$ma5 = _this2.props.theme.map3d.dtm.max) !== null && _this2$props$theme$ma5 !== void 0 ? _this2$props$theme$ma5 : undefined;
var elevationLayer = new ElevationLayer({
name: 'dem',
extent: extent,
source: demSource,
minmax: demMin !== undefined && demMax !== undefined ? {
demMin: demMin,
demMax: demMax
} : undefined
});
_this2.addLayer("__dtm", elevationLayer);
}
// Collect baselayers
var visibleBaseLayer = null;
var baseLayers = (((_this2$props$theme$ma6 = _this2.props.theme.map3d) === null || _this2$props$theme$ma6 === void 0 ? void 0 : _this2$props$theme$ma6.basemaps) || []).map(function (e) {
var baseLayer = _objectSpread(_objectSpread({}, _this2.props.layers.find(function (bl) {
return bl.name === e.name;
})), {}, {
visibility: e.visibility === true
});
if (baseLayer.visibility) {
visibleBaseLayer = baseLayer;
}
return baseLayer;
});
if (visibleBaseLayer) {
_this2.setBaseLayer(visibleBaseLayer, true);
}
// Collect color layers
var colorLayers = _this2.collectColorLayers([]);
// Add 3d tiles
_this2.objectMap = {};
var sceneObjects = {};
(((_this2$props$theme$ma7 = _this2.props.theme.map3d) === null || _this2$props$theme$ma7 === void 0 ? void 0 : _this2$props$theme$ma7.tiles3d) || []).forEach(function (entry) {
var _entry$title;
var tilesUrl = entry.url;
if (tilesUrl.startsWith(":")) {
tilesUrl = location.href.split("?")[0] + ConfigUtils.getAssetsPath() + tilesUrl.substr(1);
}
var tiles = new Tiles3D(new Tiles3DSource(tilesUrl));
tiles.userData.layertree = true;
_this2.instance.add(tiles);
_this2.objectMap[entry.name] = tiles;
sceneObjects[entry.name] = {
visible: true,
opacity: 100,
layertree: true,
title: (_entry$title = entry.title) !== null && _entry$title !== void 0 ? _entry$title : entry.name
};
});
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
scene: _this2.instance,
map: _this2.map,
mapCrs: projection,
dtmUrl: demUrl,
dtmCrs: demCrs,
baseLayers: baseLayers,
colorLayers: colorLayers,
sceneObjects: sceneObjects
}),
sceneId: uuidv1()
};
});
// this.inspector = Inspector.attach("map3dinspector", this.instance);
});
_defineProperty(_this2, "disposeInstance", function () {
if (_this2.inspector) {
_this2.inspector.detach();
}
_this2.map.dispose({
disposeLayers: true
});
_this2.instance.dispose();
Object.values(_this2.objectMap).forEach(function (object) {
_this2.instance.remove(object);
object.traverse(function (obj) {
var _obj$dispose;
return (_obj$dispose = obj.dispose) === null || _obj$dispose === void 0 ? void 0 : _obj$dispose.call(obj);
});
});
_this2.inspector = null;
_this2.map = null;
_this2.objectMap = {};
_this2.sceneObjectGroup = null;
_this2.instance = null;
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), Map3D.defaultSceneState)
};
});
_this2.props.setCurrentTask(null);
});
_defineProperty(_this2, "onUnload", function (key) {
// Ensure scene has not already been disposed
if (_this2.state.sceneId === key) {
_this2.disposeInstance();
}
});
_defineProperty(_this2, "setupControls", function (instance) {
var _instance$setViewToEx;
_this2.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
setViewToExtent: instance === null || instance === void 0 ? void 0 : instance.setViewToExtent
})
};
});
instance === null || instance === void 0 || (_instance$setViewToEx = instance.setViewToExtent) === null || _instance$setViewToEx === void 0 || _instance$setViewToEx.call(instance, _this2.props.mapBBox.bounds, _this2.props.mapBBox.rotation);
});
_defineProperty(_this2, "getTerrainHeight", function (scenePos) {
var dtmPos = CoordinatesUtils.reproject(scenePos, _this2.state.sceneContext.mapCrs, _this2.state.sceneContext.dtmCrs);
return new Promise(function (resolve) {
fromUrl(_this2.state.sceneContext.dtmUrl).then(function (tiff) {
tiff.getImage().then(function (image) {
var _image$fileDirectory = image.fileDirectory,
ModelTiepoint = _image$fileDirectory.ModelTiepoint,
ModelPixelScale = _image$fileDirectory.ModelPixelScale;
// Extract scale and tiepoint values
var _ref3 = [ModelPixelScale[0], ModelPixelScale[1]],
scaleX = _ref3[0],
scaleY = _ref3[1];
var _ref4 = [ModelTiepoint[3], ModelTiepoint[4]],
tiepointX = _ref4[0],
tiepointY = _ref4[1]; // Tiepoint world coordinates
// Calculate pixel indices (rounded to nearest integers)
var pixelX = Math.round((dtmPos[0] - tiepointX) / scaleX);
var pixelY = Math.round((tiepointY - dtmPos[1]) / scaleY); // Inverted Y-axis in image
image.readRasters({
window: [pixelX, pixelY, pixelX + 1, pixelY + 1]
}).then(function (raster) {
resolve(raster[0][0]);
});
});
});
});
});
_defineProperty(_this2, "getSceneIntersection", function (x, y) {
var objects = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
var raycaster = new Raycaster();
var camera = _this2.instance.view.camera;
raycaster.setFromCamera(new Vector2(x, y), camera);
// Query object intersection
var objInter = objects ? raycaster.intersectObjects([_this2.sceneObjectGroup].concat(_toConsumableArray(_this2.instance.getEntities().filter(function (e) {
return e !== _this2.map;
}).map(function (entity) {
return entity.object3d;
}))), true)[0] : undefined;
// Query highest resolution terrain tile (i.e. tile with no children)
var terrInter = raycaster.intersectObjects([_this2.map.object3d]).filter(function (result) {
return result.object.children.length === 0;
})[0];
// Return closest result
if (objInter && terrInter) {
return objInter.distance < terrInter.distance ? objInter : terrInter;
}
return objInter !== null && objInter !== void 0 ? objInter : terrInter;
});
_defineProperty(_this2, "redrawScene", function (ev) {
var width = ev.target.innerWidth;
var height = ev.target.innerHeight;
_this2.instance.renderer.setSize(width, height);
_this2.instance.view.camera.aspect = width / height;
_this2.instance.view.camera.updateProjectionMatrix();
_this2.instance.renderer.render(_this2.instance.scene, _this2.instance.view.camera);
});
_defineProperty(_this2, "setViewToExtent", function (bounds, rotation) {
_this2.state.sceneContext.setViewToExtent(bounds, rotation);
});
_this2.container = null;
_this2.inspector = null;
_this2.instance = null;
_this2.map = null;
_this2.sceneObjectGroup = null;
_this2.objectMap = {};
_this2.state.sceneContext.addLayer = _this2.addLayer;
_this2.state.sceneContext.getLayer = _this2.getLayer;
_this2.state.sceneContext.removeLayer = _this2.removeLayer;
_this2.state.sceneContext.updateColorLayer = _this2.updateColorLayer;
_this2.state.sceneContext.addSceneObject = _this2.addSceneObject;
_this2.state.sceneContext.getSceneObject = _this2.getSceneObject;
_this2.state.sceneContext.removeSceneObject = _this2.removeSceneObject;
_this2.state.sceneContext.updateSceneObject = _this2.updateSceneObject;
_this2.state.sceneContext.getTerrainHeight = _this2.getTerrainHeight;
_this2.state.sceneContext.getSceneIntersection = _this2.getSceneIntersection;
return _this2;
}
_inherits(Map3D, _React$Component2);
return _createClass(Map3D, [{
key: "componentDidMount",
value: function componentDidMount() {
this.props.innerRef(this);
}
}, {
key: "componentDidUpdate",
value: function componentDidUpdate(prevProps, prevState) {
var _this3 = this;
if (this.props.theme !== prevProps.theme) {
this.setupInstance();
} else if (this.props.layers !== prevProps.layers) {
this.setState(function (state) {
return {
sceneContext: _objectSpread(_objectSpread({}, state.sceneContext), {}, {
colorLayers: _this3.collectColorLayers(state.sceneContext.colorLayers)
})
};
});
}
// Update map layers
if (this.state.sceneContext.baseLayers !== prevState.sceneContext.baseLayers) {
this.applyBaseLayer();
}
if (this.state.sceneContext.colorLayers !== prevState.sceneContext.colorLayers) {
this.applyColorLayerUpdates(this.state.sceneContext.colorLayers, prevState.sceneContext.colorLayers);
}
// Update scene objects
if (this.state.sceneContext.sceneObjects !== prevState.sceneContext.sceneObjects) {
this.applySceneObjectUpdates(this.state.sceneContext.sceneObjects);
}
}
}, {
key: "render",
value: function render() {
var baseLayer = this.state.sceneContext.baseLayers.find(function (l) {
return l.visibility === true;
});
var style = {
marginTop: this.props.mapMargins.top,
marginRight: this.props.mapMargins.right,
marginBottom: this.props.mapMargins.bottom,
marginLeft: this.props.mapMargins.left
};
return /*#__PURE__*/React.createElement("div", {
className: "map3d-body"
}, /*#__PURE__*/React.createElement("div", {
className: "map3d-map",
onMouseDown: this.stopAnimations,
ref: this.setupContainer,
style: style
}), this.state.sceneContext.scene ? /*#__PURE__*/React.createElement(UnloadWrapper, {
key: this.state.sceneId,
onUnload: this.onUnload,
sceneId: this.state.sceneId
}, /*#__PURE__*/React.createElement(MapControls3D, {
ref: this.setupControls,
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(BackgroundSwitcher, {
bottombarHeight: 10,
changeLayerVisibility: this.setBaseLayer,
layers: this.state.sceneContext.baseLayers
}), /*#__PURE__*/React.createElement(TopBar3D, {
options: this.props.options,
sceneContext: this.state.sceneContext,
searchProviders: this.props.searchProviders
}), /*#__PURE__*/React.createElement(LayerTree3D, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(BottomBar3D, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(OverviewMap3D, {
baseLayer: baseLayer,
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(Map3DLight, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(Measure3D, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(Compare3D, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(Draw3D, {
sceneContext: this.state.sceneContext
}), /*#__PURE__*/React.createElement(MapExport3D, {
sceneContext: this.state.sceneContext,
theme: this.props.theme
})) : null);
}
}]);
}(React.Component);
_defineProperty(Map3D, "propTypes", {
innerRef: PropTypes.func,
layers: PropTypes.array,
mapBBox: PropTypes.object,
mapMargins: PropTypes.object,
options: PropTypes.object,
projection: PropTypes.string,
searchProviders: PropTypes.object,
setCurrentTask: PropTypes.func,
setMapCrs: PropTypes.func,
theme: PropTypes.object
});
_defineProperty(Map3D, "defaultProps", {
geometry: {
initialWidth: 600,
initialHeight: 800,
initialX: 0,
initialY: 0,
initiallyDocked: true
},
options: {
searchMinScaleDenom: 1000
}
});
_defineProperty(Map3D, "defaultSceneState", {
scene: null,
map: null,
mapCrs: null,
dtmUrl: null,
dtmCrs: null,
baseLayers: [],
colorLayers: [],
sceneObjects: {}
});
export default connect(function (state) {
return {
mapMargins: state.windows.mapMargins
};
}, {
setMapCrs: setMapCrs,
setCurrentTask: setCurrentTask
})(Map3D);