@vcmap/core 5.0.0-rc.10 → 5.0.0-rc.13

package/tests/unit/helpers/obliqueHelpers.js

@@ -0,0 +1,112 @@
+import Projection from '../../../src/util/projection.js';
+import ObliqueMap from '../../../src/map/obliqueMap.js';
+import ViewPoint from '../../../src/util/viewpoint.js';
+
+import { getTerrainProvider } from './terrain/terrainData.js';
+import ObliqueCollection from '../../../src/oblique/obliqueCollection.js';
+import ObliqueDataSet from '../../../src/oblique/obliqueDataSet.js';
+import importJSON from './importJSON.js';
+import getFileNameFromUrl from './getFileNameFromUrl.js';
+
+const fileName = getFileNameFromUrl(import.meta.url, '../../../data/oblique/imageData/imagev35.json');
+const imageJson = await importJSON(fileName);
+
+/**
+ * Center point of first image
+ * @type {import("ol/coordinate").Coordinate}
+ */
+export const mercatorCoordinates = [1488644.796500772, 6892246.018669462, 0];
+
+/**
+ * cached oblique Projection
+ * @type {Projection}
+ */
+let obliqueProjection = null;
+
+/**
+ * @returns {ViewPoint}
+ */
+function getStartingViewpoint() {
+  return new ViewPoint({
+    name: '5b609a0d-28a1-4f4e-ba6c-29f2592fa889',
+    distance: 264.6285087486175,
+    cameraPosition: null,
+    groundPosition: [
+      13.41528061371218,
+      52.50232648590358,
+    ],
+    heading: 0,
+    pitch: -90,
+    roll: 0,
+    animate: false,
+  });
+}
+
+/**
+ * returns an oblique Dataset
+ * @param {Scope=} scope if provided the dataset is initialized with a terrainProvider
+ * @returns {vcs-oblique/ObliqueDataSet}
+ */
+export function getObliqueDataSet(scope) {
+  if (!obliqueProjection) {
+    obliqueProjection = new Projection({
+      epsg: 'EPSG:25833',
+      proj4: '+proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs',
+    });
+  }
+  let terrainProvider;
+  if (scope) {
+    getTerrainProvider(scope);
+    terrainProvider = {
+      url: 'http://localhost/terrain/',
+    };
+  }
+  const obliqueDataSet = new ObliqueDataSet('http://localhost/', obliqueProjection, terrainProvider);
+  obliqueDataSet.initialize(imageJson);
+  return obliqueDataSet;
+}
+
+
+/**
+ * @param {Array<ObliqueDataSet>=} obliqueDataSets
+ * @returns {ObliqueCollection}
+ */
+export function getObliqueCollection(obliqueDataSets) {
+  const dataSets = obliqueDataSets || [getObliqueDataSet()];
+  const obliqueCollection = new ObliqueCollection({
+    name: 'obliqueCollection',
+    dataSets,
+  });
+  return obliqueCollection;
+}
+
+/**
+ * @param {ObliqueOptions} mapOptions
+ * @param {Scope=} scope optional server, if provided the map will be initialized with a terrainProvider
+ * @returns {Promise<ObliqueMap>}
+ */
+export async function getObliqueMap(mapOptions = {}, scope) {
+  const obliqueDataSet = getObliqueDataSet(scope);
+  const obliqueCollection = getObliqueCollection([obliqueDataSet]);
+  const map = new ObliqueMap(mapOptions);
+  await map.initialize();
+  await map.setCollection(obliqueCollection);
+  return map;
+}
+
+/**
+ * @param {VcsApp} app
+ * @param {Scope=} scope optional server, if provided the map will be initialized with a terrainProvider
+ * @param {ViewPoint=} startingVP
+ * @returns {Promise<ObliqueMap>}
+ */
+export async function setObliqueMap(app, scope, startingVP) {
+  const map = await getObliqueMap(
+    { layerCollection: app.layers, target: app.maps.target },
+    scope,
+  );
+  app.maps.add(map);
+  await app.maps.setActiveMap(map.name);
+  await map.gotoViewPoint(startingVP || getStartingViewpoint());
+  return map;
+}

package/tests/unit/helpers/openlayersHelpers.js

@@ -0,0 +1,22 @@
+import OpenlayersMap from '../../../src/map/openlayersMap.js';
+
+/**
+ * @param {OpenlayersOptions=} mapOptions
+ * @returns {Promise<OpenlayersMap>}
+ */
+export async function getOpenlayersMap(mapOptions) {
+  const map = new OpenlayersMap(mapOptions || {});
+  await map.initialize();
+  return map;
+}
+
+/**
+ * @param {VcsApp} app
+ * @returns {Promise<OpenlayersMap>}
+ */
+export async function setOpenlayersMap(app) {
+  const map = await getOpenlayersMap({ layerCollection: app.layers, target: app.maps.target });
+  app.maps.add(map);
+  await app.maps.setActiveMap(map.name);
+  return map;
+}

package/tests/unit/helpers/terrain/terrainData.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import { CesiumTerrainProvider } from '@vcmap/cesium';
+import importJSON from '../importJSON.js';
+import getFileNameFromUrl from '../getFileNameFromUrl.js';
+
+const fileName = getFileNameFromUrl(import.meta.url, '../../../../data/terrain/layer.json');
+const layerJson = await importJSON(fileName);
+const terrainFiles = {
+  1388006485: './tests/data/terrain/13/8800/6485.terrain',
+  1388006486: './tests/data/terrain/13/8800/6486.terrain',
+  1388016485: './tests/data/terrain/13/8801/6485.terrain',
+  1388016486: './tests/data/terrain/13/8801/6486.terrain',
+};
+
+/**
+ * serves http://myTerrainProvider/terrain/
+ * @param {import("nock").Scope} scope
+ */
+export function setTerrainServer(scope) {
+  scope
+    .get('/terrain/layer.json')
+    .reply(200, layerJson, { 'Content-Type': 'application/json' })
+    .get(/terrain\/(\d{2})\/(\d{4})\/(\d{4})\.terrain.*/)
+    .reply((uri) => {
+      const [x, y] = uri.match(/(\d{4})/g);
+      const terrainFile = terrainFiles[`13${x}${y}`];
+      const res = terrainFile ? fs.createReadStream(terrainFiles[`13${x}${y}`]) : Buffer.from('');
+      return [
+        200,
+        res,
+        { 'Content-Type': 'application/vnd.quantized-mesh' },
+      ];
+    })
+    .persist();
+}
+
+/**
+ * @param {Scope} scope
+ * @returns {cesium/CesiumTerrainProvider}
+ */
+export function getTerrainProvider(scope) {
+  setTerrainServer(scope);
+  return new CesiumTerrainProvider({
+    url: 'http://localhost/terrain/',
+  });
+}

package/src/util/dateTime.js

@@ -1,60 +0,0 @@
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleDate(date, locale) {
-  // dateStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { dateStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleTime(date, locale) {
-  // timeStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { timeStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @returns {string}
- */
-export function getISODateString(date) {
-  const month = date.getMonth() + 1;
-  const day = date.getDate();
-  return `${date.getFullYear()}-${month > 9 ? '' : 0}${month}-${day > 9 ? '' : 0}${day}`;
-}
-
-/**
- * @param {Date} date
- * @returns {number}
- */
-export function getDayOfYear(date) {
-  const start = new Date(date.getFullYear(), 0, 0);
-  // TS cant handle date manipulation
-  // @ts-ignore
-  const diff = (date - start) + ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
-  const oneDay = 1000 * 60 * 60 * 24;
-  return Math.floor(diff / oneDay);
-}
-
-/**
- * @param {Date} date
- * @returns {boolean}
- */
-export function isLeapYear(date) {
-  const currentYear = date.getFullYear();
-  if (currentYear % 4 !== 0) {
-    return false;
-  } else if (currentYear % 100 !== 0) {
-    return true;
-  } else if (currentYear % 400 !== 0) {
-    return false;
-  }
-  return true;
-}