@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.31

package/src/{vcs/vcm/oblique → oblique}/helpers.js

@@ -1,19 +1,25 @@
 /* eslint no-underscore-dangle: ["error", { "allow": ["_listeners", "_scopes", "_toRemove"] }] */
 /* eslint-disable no-continue */
-import { boundingExtent, getBottomLeft, getBottomRight, getTopLeft, getTopRight } from 'ol/extent.js';
+import {
+  boundingExtent,
+  getBottomLeft,
+  getBottomRight,
+  getTopLeft,
+  getTopRight,
+} from 'ol/extent.js';
 import { transform } from 'ol/proj.js';
-import { Cartesian2 } from '@vcmap/cesium';
-import { ObliqueViewDirection } from './ObliqueViewDirection.js';
+import { Cartesian2 } from '@vcmap-cesium/engine';
+import { ObliqueViewDirection } from './obliqueViewDirection.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
 import { cartesian2DDistance } from '../util/math.js';
 import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 
 /**
- * @type {import("@vcmap/cesium").Cartesian2}
+ * @type {import("@vcmap-cesium/engine").Cartesian2}
  */
 let scratchCartesian2A = new Cartesian2();
 /**
- * @type {import("@vcmap/cesium").Cartesian2}
+ * @type {import("@vcmap-cesium/engine").Cartesian2}
  */
 let scratchCartesian2B = new Cartesian2();
 
@@ -32,7 +38,10 @@ let scratchCartesian2B = new Cartesian2();
  * @param {(ObliqueViewDirection|boolean)=} [sortDirection=false]
  * @returns {Array<import("ol/coordinate").Coordinate>}
  */
-export function sortRealWordEdgeCoordinates(inputCornerPoints, sortDirection = false) {
+export function sortRealWordEdgeCoordinates(
+  inputCornerPoints,
+  sortDirection = false,
+) {
   const cornerPoints = inputCornerPoints.slice();
   const extent = boundingExtent(cornerPoints);
   const extentPoints = [
@@ -70,8 +79,16 @@ export function sortRealWordEdgeCoordinates(inputCornerPoints, sortDirection = f
  * @returns {number|null}
  */
 function angleBetweenTwo2DVectors(v1, v2) {
-  scratchCartesian2A = Cartesian2.fromElements(v1[0], v1[1], scratchCartesian2A);
-  scratchCartesian2B = Cartesian2.fromElements(v2[0], v2[1], scratchCartesian2B);
+  scratchCartesian2A = Cartesian2.fromElements(
+    v1[0],
+    v1[1],
+    scratchCartesian2A,
+  );
+  scratchCartesian2B = Cartesian2.fromElements(
+    v2[0],
+    v2[1],
+    scratchCartesian2B,
+  );
   return Cartesian2.angleBetween(scratchCartesian2A, scratchCartesian2B);
 }
 
@@ -80,7 +97,6 @@ function angleBetweenTwo2DVectors(v1, v2) {
  * @param {Array<import("ol/coordinate").Coordinate>} segment1
  * @param {Array<import("ol/coordinate").Coordinate>} segment2
  * @returns {{x: (number|null), y:(number|null), onLine1: boolean, onLine2: boolean}}
- * @export
  */
 export function checkLineIntersection(segment1, segment2) {
   // if the lines intersect, the result contains the x and y of the intersection (treating the lines as infinite) and booleans for whether line segment 1 or line segment 2 contain the point
@@ -97,22 +113,24 @@ export function checkLineIntersection(segment1, segment2) {
   };
 
   const denominator =
-    ((line2EndY - line2StartY) * (line1EndX - line1StartX)) -
-    ((line2EndX - line2StartX) * (line1EndY - line1StartY));
+    (line2EndY - line2StartY) * (line1EndX - line1StartX) -
+    (line2EndX - line2StartX) * (line1EndY - line1StartY);
 
   if (denominator === 0) {
     return result;
   }
   a = line1StartY - line2StartY;
   b = line1StartX - line2StartX;
-  const numerator1 = ((line2EndX - line2StartX) * a) - ((line2EndY - line2StartY) * b);
-  const numerator2 = ((line1EndX - line1StartX) * a) - ((line1EndY - line1StartY) * b);
+  const numerator1 =
+    (line2EndX - line2StartX) * a - (line2EndY - line2StartY) * b;
+  const numerator2 =
+    (line1EndX - line1StartX) * a - (line1EndY - line1StartY) * b;
   a = numerator1 / denominator;
   b = numerator2 / denominator;
 
   // if we cast these lines infinitely in both directions, they intersect here:
-  result.x = line1StartX + (a * (line1EndX - line1StartX));
-  result.y = line1StartY + (a * (line1EndY - line1StartY));
+  result.x = line1StartX + a * (line1EndX - line1StartX);
+  result.y = line1StartY + a * (line1EndY - line1StartY);
   /*
    // it is worth noting that this should be the same as:
    x = line2StartX + (b * (line2EndX - line2StartX));
@@ -139,9 +157,21 @@ export function checkLineIntersection(segment1, segment2) {
  * @param {ObliqueViewDirection} viewDirection
  * @returns {{x: (number|null), y:(number|null), onLine1: boolean, onLine2: boolean}|null}
  */
-export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordinate2Transform, viewDirection) {
-  const origin = sortRealWordEdgeCoordinates(inputOrigin, originIsImage ? false : viewDirection);
-  const target = sortRealWordEdgeCoordinates(inputTarget, originIsImage ? viewDirection : false);
+export function transformCWIFC(
+  inputOrigin,
+  inputTarget,
+  originIsImage,
+  coordinate2Transform,
+  viewDirection,
+) {
+  const origin = sortRealWordEdgeCoordinates(
+    inputOrigin,
+    originIsImage ? false : viewDirection,
+  );
+  const target = sortRealWordEdgeCoordinates(
+    inputTarget,
+    originIsImage ? viewDirection : false,
+  );
 
   // test intersections from all corner points over coordinate to all non neighbouring borders
   // and non side borders too - so actually remains only upper and lower border
@@ -153,58 +183,110 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
   // - distance ratio while negative means negative direction
   // to be able to recreate the situation in the target system
   const intersections = [];
-  for (let cp = 0; cp < origin.length; ++cp) { // TODO write into a proper map and function
+  for (let cp = 0; cp < origin.length; ++cp) {
+    // TODO write into a proper map and function
     const intrCurrCP = [];
 
     for (let sp = 0; sp < origin.length; ++sp) {
       const ep = sp === origin.length - 1 ? 0 : sp + 1; // end point of edge
 
       // skip if cp is sp or ep - neighbouring edge
-      if (cp === sp || cp === ep) { continue; }
+      if (cp === sp || cp === ep) {
+        continue;
+      }
 
       // skip also if sp is 3 and ep is 0 and also skip sp is 1 and ep is 2 since does only work over the upper and lower boundary
-      if ((sp === 3 && ep === 0) || (sp === 1 && ep === 2)) { continue; }
+      if ((sp === 3 && ep === 0) || (sp === 1 && ep === 2)) {
+        continue;
+      }
 
       // get intersection from cp over coordinate2Transform to current border edge
-      const currIntr = checkLineIntersection([origin[cp], coordinate2Transform], [origin[sp], origin[ep]]);
-      if (currIntr.x == null || currIntr.y == null) { continue; }
+      const currIntr = checkLineIntersection(
+        [origin[cp], coordinate2Transform],
+        [origin[sp], origin[ep]],
+      );
+      if (currIntr.x == null || currIntr.y == null) {
+        continue;
+      }
 
       // get vector from current cp to coordinate2Transform to be able to determine if the intersection is in same direction
       // might be in different direction when point is outside - then we dont need this data
-      const vectorCP2Coordinate = [coordinate2Transform[0] - origin[cp][0], coordinate2Transform[1] - origin[cp][1]];
-      const vectorCP2Intr = [currIntr.x - origin[cp][0], currIntr.y - origin[cp][1]];
-      const angleDirectionCheck = angleBetweenTwo2DVectors(vectorCP2Coordinate, vectorCP2Intr);
-      if (angleDirectionCheck == null) { continue; }
+      const vectorCP2Coordinate = [
+        coordinate2Transform[0] - origin[cp][0],
+        coordinate2Transform[1] - origin[cp][1],
+      ];
+      const vectorCP2Intr = [
+        currIntr.x - origin[cp][0],
+        currIntr.y - origin[cp][1],
+      ];
+      const angleDirectionCheck = angleBetweenTwo2DVectors(
+        vectorCP2Coordinate,
+        vectorCP2Intr,
+      );
+      if (angleDirectionCheck == null) {
+        continue;
+      }
 
-      if (angleDirectionCheck / (Math.PI * 180.0) > 5) { continue; }
+      if (angleDirectionCheck / (Math.PI * 180.0) > 5) {
+        continue;
+      }
 
-      const sp2ep = [origin[sp][0] - origin[ep][0], origin[sp][1] - origin[ep][1]];
-      const ep2sp = [origin[ep][0] - origin[sp][0], origin[ep][1] - origin[sp][1]];
+      const sp2ep = [
+        origin[sp][0] - origin[ep][0],
+        origin[sp][1] - origin[ep][1],
+      ];
+      const ep2sp = [
+        origin[ep][0] - origin[sp][0],
+        origin[ep][1] - origin[sp][1],
+      ];
       // regarding the angle find the smallest
-      const angleStart2End = angleBetweenTwo2DVectors(vectorCP2Coordinate, sp2ep);
-      if (angleStart2End == null) { continue; }
+      const angleStart2End = angleBetweenTwo2DVectors(
+        vectorCP2Coordinate,
+        sp2ep,
+      );
+      if (angleStart2End == null) {
+        continue;
+      }
 
-      const angleEnd2Start = angleBetweenTwo2DVectors(vectorCP2Coordinate, ep2sp);
-      if (angleEnd2Start == null) { continue; }
+      const angleEnd2Start = angleBetweenTwo2DVectors(
+        vectorCP2Coordinate,
+        ep2sp,
+      );
+      if (angleEnd2Start == null) {
+        continue;
+      }
 
       // regarding ratioStart2End get ratio and then direction
       const distStartEnd = cartesian2DDistance(origin[sp], origin[ep]);
-      if (distStartEnd === 0) { continue; }
-      const tempRatioStartEnd = cartesian2DDistance(origin[sp], [currIntr.x, currIntr.y]) / distStartEnd;
+      if (distStartEnd === 0) {
+        continue;
+      }
+      const tempRatioStartEnd =
+        cartesian2DDistance(origin[sp], [currIntr.x, currIntr.y]) /
+        distStartEnd;
       let angleEdge2Intr = 0;
       if (tempRatioStartEnd !== 0) {
-        angleEdge2Intr = angleBetweenTwo2DVectors(ep2sp, [currIntr.x - origin[sp][0], currIntr.y - origin[sp][1]]);
-        if (angleEdge2Intr == null) { continue; }
+        angleEdge2Intr = angleBetweenTwo2DVectors(ep2sp, [
+          currIntr.x - origin[sp][0],
+          currIntr.y - origin[sp][1],
+        ]);
+        if (angleEdge2Intr == null) {
+          continue;
+        }
       }
 
       intrCurrCP.push({
         cornerPoint: cp,
         intrX: currIntr.x,
         intrY: currIntr.y,
-        angle: angleStart2End <= angleEnd2Start ? angleStart2End : angleEnd2Start,
+        angle:
+          angleStart2End <= angleEnd2Start ? angleStart2End : angleEnd2Start,
         edgeStart: sp,
         edgeEnd: ep,
-        ratioStart2End: (angleEdge2Intr / Math.PI) * 180.0 > 5 ? tempRatioStartEnd * (-1) : tempRatioStartEnd,
+        ratioStart2End:
+          (angleEdge2Intr / Math.PI) * 180.0 > 5
+            ? tempRatioStartEnd * -1
+            : tempRatioStartEnd,
       });
     }
 
@@ -217,11 +299,15 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
         indLargestAngle = i;
       }
     }
-    if (indLargestAngle !== -1) { intersections.push(intrCurrCP[indLargestAngle]); }
+    if (indLargestAngle !== -1) {
+      intersections.push(intrCurrCP[indLargestAngle]);
+    }
   }
 
   // if we don not have enough data to recreate the situation in target system stop
-  if (intersections.length < 2) { return null; }
+  if (intersections.length < 2) {
+    return null;
+  }
 
   // make list with intersection combinations and sort after strength (add angles together)
   const intrCombis = []; // will contain [addedAngle, intersectionsIndex_i, intersectionsIndex_j]
@@ -236,7 +322,10 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
     .sort()
     .reverse()
     .find((intersection) => {
-      const intersectionsSorted = [intersections[intersection[1]], intersections[intersection[2]]];
+      const intersectionsSorted = [
+        intersections[intersection[1]],
+        intersections[intersection[2]],
+      ];
 
       const targetEdgeEnd0 = target[intersectionsSorted[0].edgeEnd];
       const targetEdgeStart0 = target[intersectionsSorted[0].edgeStart];
@@ -247,17 +336,24 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
       ];
 
       const intrFor0InTarget = [
-        targetEdgeStart0[0] + (targetEdgeVectorFor0[0] * intersectionsSorted[0].ratioStart2End),
-        targetEdgeStart0[1] + (targetEdgeVectorFor0[1] * intersectionsSorted[0].ratioStart2End),
+        targetEdgeStart0[0] +
+          targetEdgeVectorFor0[0] * intersectionsSorted[0].ratioStart2End,
+        targetEdgeStart0[1] +
+          targetEdgeVectorFor0[1] * intersectionsSorted[0].ratioStart2End,
       ];
 
       const targetEdgeEnd1 = target[intersectionsSorted[1].edgeEnd];
       const targetEdgeStart1 = target[intersectionsSorted[1].edgeStart];
 
-      const targetEdgeVectorFor1 = [targetEdgeEnd1[0] - targetEdgeStart1[0], targetEdgeEnd1[1] - targetEdgeStart1[1]];
+      const targetEdgeVectorFor1 = [
+        targetEdgeEnd1[0] - targetEdgeStart1[0],
+        targetEdgeEnd1[1] - targetEdgeStart1[1],
+      ];
       const intrFor1InTarget = [
-        targetEdgeStart1[0] + (targetEdgeVectorFor1[0] * intersectionsSorted[1].ratioStart2End),
-        targetEdgeStart1[1] + (targetEdgeVectorFor1[1] * intersectionsSorted[1].ratioStart2End),
+        targetEdgeStart1[0] +
+          targetEdgeVectorFor1[0] * intersectionsSorted[1].ratioStart2End,
+        targetEdgeStart1[1] +
+          targetEdgeVectorFor1[1] * intersectionsSorted[1].ratioStart2End,
       ];
 
       const vecCP0ToIntr0 = [
@@ -270,7 +366,9 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
       ];
 
       const angleCross = angleBetweenTwo2DVectors(vecCP0ToIntr0, vecCP1ToIntr1);
-      if (angleCross == null) { return false; }
+      if (angleCross == null) {
+        return false;
+      }
       /* var thresholdInDegree = 3;
        if (angleCross/Math.PI*180.0 < thresholdInDegree || angleCross/Math.PI*180.0 > 180-thresholdInDegree)
        continue; */
@@ -306,16 +404,26 @@ export function transformCWIFC(inputOrigin, inputTarget, originIsImage, coordina
  * @param {import("ol/coordinate").Coordinate} worldCoordinate if not in web mercatpr, specify data-projection in options
  * @param {ImageTransformationOptions=} options
  * @returns {Promise<{coords: import("ol/coordinate").Coordinate, height: number, estimate: (boolean|undefined)}>}
- * @export
  */
 export function transformToImage(image, worldCoordinate, options = {}) {
   let gpInternalCoordinates;
-  if (options.dataProjection && options.dataProjection === image.meta.projection) {
+  if (
+    options.dataProjection &&
+    options.dataProjection === image.meta.projection
+  ) {
     gpInternalCoordinates = worldCoordinate;
   } else {
-    gpInternalCoordinates = options.dataProjection ?
-      transform(worldCoordinate, options.dataProjection.proj, image.meta.projection.proj) :
-      transform(worldCoordinate, mercatorProjection.proj, image.meta.projection.proj);
+    gpInternalCoordinates = options.dataProjection
+      ? transform(
+          worldCoordinate,
+          options.dataProjection.proj,
+          image.meta.projection.proj,
+        )
+      : transform(
+          worldCoordinate,
+          mercatorProjection.proj,
+          image.meta.projection.proj,
+        );
   }
 
   function useAverageHeight() {
@@ -324,19 +432,39 @@ export function transformToImage(image, worldCoordinate, options = {}) {
   }
 
   if (worldCoordinate[2]) {
-    const coords = image.transformRealWorld2Image(gpInternalCoordinates, worldCoordinate[2]);
-    return Promise.resolve({ coords, height: worldCoordinate[2], estimate: false });
+    const coords = image.transformRealWorld2Image(
+      gpInternalCoordinates,
+      worldCoordinate[2],
+    );
+    return Promise.resolve({
+      coords,
+      height: worldCoordinate[2],
+      estimate: false,
+    });
   }
 
   if (!options.dontUseTerrain && image.meta.terrainProvider) {
-    return getHeightFromTerrainProvider(image.meta.terrainProvider, [gpInternalCoordinates], image.meta.projection)
+    return getHeightFromTerrainProvider(
+      image.meta.terrainProvider,
+      [gpInternalCoordinates],
+      image.meta.projection,
+    )
       .then(([gpWithHeight]) => {
         if (gpWithHeight[2]) {
-          const imageCoordinates = image.transformRealWorld2Image(gpInternalCoordinates, gpWithHeight[2]);
-          return { coords: imageCoordinates, height: gpInternalCoordinates[2], estimate: false };
+          const imageCoordinates = image.transformRealWorld2Image(
+            gpInternalCoordinates,
+            gpWithHeight[2],
+          );
+          return {
+            coords: imageCoordinates,
+            height: gpInternalCoordinates[2],
+            estimate: false,
+          };
         }
         // eslint-disable-next-line no-console
-        console.warn('The configured terrain on the oblique layer could not be queried, position might be inaccurate');
+        console.warn(
+          'The configured terrain on the oblique layer could not be queried, position might be inaccurate',
+        );
         return useAverageHeight();
       })
       .catch(() => useAverageHeight());
@@ -371,18 +499,24 @@ function pickTerrain(pickTerrainOptions) {
     height,
   } = pickTerrainOptions;
 
-  return getHeightFromTerrainProvider(image.meta.terrainProvider, [worldCoordinate])
+  return getHeightFromTerrainProvider(image.meta.terrainProvider, [
+    worldCoordinate,
+  ])
     .then(([worldCoordinateWithHeights]) => {
       if (worldCoordinateWithHeights[2] != null) {
         const newWorldCoords = transform(
-          image.transformImage2RealWorld(imageCoordinate, worldCoordinateWithHeights[2]),
+          image.transformImage2RealWorld(
+            imageCoordinate,
+            worldCoordinateWithHeights[2],
+          ),
           image.meta.projection.proj,
           wgs84Projection.proj,
         );
         newWorldCoords[2] = worldCoordinateWithHeights[2];
         if (
-          Math.abs(height - worldCoordinateWithHeights[2]) < terrainErrorThreshold ||
-          (count > terrainErrorCountThreshold)
+          Math.abs(height - worldCoordinateWithHeights[2]) <
+            terrainErrorThreshold ||
+          count > terrainErrorCountThreshold
         ) {
           return { coords: newWorldCoords, estimate: false };
         }
@@ -391,7 +525,9 @@ function pickTerrain(pickTerrainOptions) {
         return pickTerrain(pickTerrainOptions);
       }
       // eslint-disable-next-line no-console
-      console.log('The configured terrain on the oblique layer could not be queried, position might be inaccurate');
+      console.log(
+        'The configured terrain on the oblique layer could not be queried, position might be inaccurate',
+      );
       return { coords: worldCoordinateWithHeights, estimate: true };
     })
     .catch(() => ({ coords: worldCoordinate, estimate: true }));
@@ -404,7 +540,6 @@ function pickTerrain(pickTerrainOptions) {
  * @param {import("ol/coordinate").Coordinate} imageCoordinate
  * @param {ImageTransformationOptions=} options
  * @returns {Promise<PickTerrainReturn>} return coordinates are in mercator if not specified in options
- * @export
  */
 export async function transformFromImage(image, imageCoordinate, options = {}) {
   const initialWorldCoords = transform(
@@ -429,9 +564,17 @@ export async function transformFromImage(image, imageCoordinate, options = {}) {
     });
   }
 
-  coordsObj.coords = options.dataProjection ?
-    transform(coordsObj.coords, wgs84Projection.proj, options.dataProjection.proj) :
-    transform(coordsObj.coords, wgs84Projection.proj, mercatorProjection.proj);
+  coordsObj.coords = options.dataProjection
+    ? transform(
+        coordsObj.coords,
+        wgs84Projection.proj,
+        options.dataProjection.proj,
+      )
+    : transform(
+        coordsObj.coords,
+        wgs84Projection.proj,
+        mercatorProjection.proj,
+      );
   return coordsObj;
 }
 
@@ -440,16 +583,16 @@ export async function transformFromImage(image, imageCoordinate, options = {}) {
  * @returns {boolean}
  */
 export function hasSameOrigin(url) {
-  // relative Url, return true;
-  if (!/^[a-z][a-z0-9+.-]*:/.test(url)) {
-    return true;
-  }
-  // data uri, return true
-  if (/^data:/.test(url)) {
+  const windowUrl = new URL(window.location.href);
+  const parsedUrl = new URL(url, window.location.href);
+
+  if (parsedUrl.protocol === 'data:') {
     return true;
   }
 
-  const currentUri = new URL(window.location.href);
-  const uri = new URL(url);
-  return currentUri.host.toLowerCase() === uri.host.toLocaleLowerCase();
+  return (
+    windowUrl.origin === parsedUrl.origin &&
+    windowUrl.port === parsedUrl.port &&
+    windowUrl.protocol === parsedUrl.protocol
+  );
 }