@vcmap/core 5.3.3 → 6.0.0-rc.10

package/src/layer/featureVisibility.ts

@@ -244,13 +244,10 @@ class FeatureVisibility {
         usedStyle = fromCesiumColor(style);
       } else if (style instanceof Style) {
         usedStyle = new VectorStyleItem({});
-        if (
-          style.getText() &&
-          style.getText().getText() &&
-          !Array.isArray(style.getText().getText())
-        ) {
+        const text = style.getText()?.getText();
+        if (text && !Array.isArray(text)) {
           // getText can return a rich Text string[] We do not support this at the moment.
-          usedStyle.label = String(style.getText().getText());
+          usedStyle.label = String(text);
         }
         usedStyle.style = style;
       } else if (is(style, Function)) {

package/src/layer/geojsonHelpers.ts

@@ -248,16 +248,10 @@ function readFeature(
 
   if (featureObj.radius && geometry instanceof Point) {
     const coordinates = geometry.getCoordinates();
-    if (coordinates.length === 2) {
-      coordinates.push(0);
-    }
-    geometry = new Circle(coordinates, featureObj.radius, 'XYZ');
+    geometry = new Circle(coordinates, featureObj.radius);
   }
   if (radius && geometry instanceof Point) {
     const coordinates = geometry.getCoordinates();
-    if (coordinates.length === 2) {
-      coordinates.push(0);
-    }
     geometry = circleFromCenterRadius(coordinates, radius);
   }
   if (String(options.formatOptions?.featureProjection) === 'EPSG:3857') {
@@ -467,23 +461,26 @@ export function writeGeoJSONFeature(
 /**
  * Writes all the features of the current layer to GeojsonLayer
  */
-export function writeGeoJSON(
+export function writeGeoJSON<O extends GeoJSONwriteOptions>(
   data: GeoJSONData,
-  options: GeoJSONwriteOptions = {},
-): string | FeatureCollection {
+  options?: O,
+): O['asObject'] extends true ? FeatureCollection : string {
   // how to handel embedded icons when they are not set on the vcsMeta but options is true?
   const vcsMeta = data.vcsMeta || { version: vcsMetaVersion };
   vcsMeta.version = vcsMetaVersion;
   const featureObjs = data.features.map((feature) =>
     writeGeoJSONFeature(feature, options, vcsMeta.embeddedIcons),
   );
+
   const obj: FeatureCollection = {
     type: 'FeatureCollection',
     features: featureObjs,
     vcsMeta,
   };
 
-  return options.asObject
+  const returnValue = options?.asObject
     ? obj
-    : JSON.stringify(obj, undefined, options.prettyPrint ? 2 : undefined);
+    : JSON.stringify(obj, undefined, options?.prettyPrint ? 2 : undefined);
+
+  return returnValue as O['asObject'] extends true ? FeatureCollection : string;
 }

package/src/layer/oblique/obliqueHelpers.ts

@@ -7,7 +7,7 @@ import type { Geometry } from 'ol/geom.js';
 import type { Feature } from 'ol/index.js';
 
 import { Cartographic, sampleTerrainMostDetailed } from '@vcmap-cesium/engine';
-import { cartesian2DDistance } from '../../util/math.js';
+import { cartesian2DDistanceSquared } from '../../util/math.js';
 import Projection, {
   mercatorProjection,
   wgs84Projection,
@@ -19,13 +19,13 @@ import {
 } from '../vectorSymbols.js';
 import {
   convertGeometryToPolygon,
-  getFlatCoordinatesFromGeometry,
+  getFlatCoordinateReferences,
 } from '../../util/geometryHelpers.js';
 import { transformFromImage } from '../../oblique/helpers.js';
 import type ObliqueImage from '../../oblique/obliqueImage.js';
 
 export function getLongestSide(coordinates: Coordinate[]): number {
-  let side = 0;
+  let sideSquared = 0;
   for (let i = 0; i < coordinates.length; i++) {
     let j = i + 1;
     if (j >= coordinates.length) {
@@ -33,12 +33,12 @@ export function getLongestSide(coordinates: Coordinate[]): number {
     }
     const point1 = coordinates[i];
     const point2 = coordinates[j];
-    const currentSide = cartesian2DDistance(point1, point2);
-    if (currentSide > side) {
-      side = currentSide;
+    const currentSideSquared = cartesian2DDistanceSquared(point1, point2);
+    if (currentSideSquared > sideSquared) {
+      sideSquared = currentSideSquared;
     }
   }
-  return side;
+  return Math.sqrt(sideSquared);
 }
 
 export function getResolutionOptions(
@@ -97,7 +97,7 @@ export async function mercatorGeometryToImageGeometry(
       ? fromCircle(inputSourceGeometry)
       : inputSourceGeometry;
   const coordinates = sourceGeometry.getCoordinates() as any[];
-  const flattenCoordinates = getFlatCoordinatesFromGeometry(
+  const flattenCoordinates = getFlatCoordinateReferences(
     sourceGeometry,
     coordinates,
   );
@@ -151,7 +151,7 @@ export function imageGeometryToMercatorGeometry(
   image: ObliqueImage,
 ): Promise<Geometry> {
   const coordinates = sourceGeometry.getCoordinates() as any[];
-  const flattenCoordinates = getFlatCoordinatesFromGeometry(
+  const flattenCoordinates = getFlatCoordinateReferences(
     sourceGeometry,
     coordinates,
   );

package/src/layer/oblique/vectorObliqueImpl.ts

@@ -78,7 +78,7 @@ class VectorObliqueImpl
 
   featureVisibility: FeatureVisibility;
 
-  olLayer: OLVectorLayer<VectorSource> | null = null;
+  olLayer: OLVectorLayer | null = null;
 
   private _imageChangedListener: (() => void) | null | undefined = null;
 
@@ -91,7 +91,7 @@ class VectorObliqueImpl
     this.featureVisibility = options.featureVisibility;
   }
 
-  getOLLayer(): OLVectorLayer<VectorSource> {
+  getOLLayer(): OLVectorLayer {
     return new OLVectorLayer({
       visible: false,
       source: this.obliqueSource,

package/src/layer/openlayers/vectorOpenlayersImpl.ts

@@ -32,7 +32,7 @@ class VectorOpenlayersImpl
 
   private _featureVisibilityListeners: (() => void)[] = [];
 
-  olLayer: OLVectorLayer<VectorSource> | null = null;
+  olLayer: OLVectorLayer | null = null;
 
   globalHider: GlobalHider;
 
@@ -54,7 +54,7 @@ class VectorOpenlayersImpl
     }
   }
 
-  getOLLayer(): OLVectorLayer<VectorSource> {
+  getOLLayer(): OLVectorLayer {
     const olLayer = new OLVectorLayer({
       visible: false,
       source: this.source,

package/src/layer/openlayers/vectorTileOpenlayersImpl.ts

@@ -3,6 +3,7 @@ import VectorTileSource from 'ol/source/VectorTile.js';
 import TileState from 'ol/TileState.js';
 import type { Size } from 'ol/size.js';
 import type VectorTile from 'ol/VectorTile.js';
+import { Feature } from 'ol';
 import LayerOpenlayersImpl from './layerOpenlayersImpl.js';
 import { mercatorProjection } from '../../util/projection.js';
 import type {
@@ -31,13 +32,6 @@ class VectorTileOpenlayersImpl
 
   tileSize: Size;
 
-  /**
-   * tiles to update on next TileRedraw
-   */
-  private _tilesToUpdate: Set<string> = new Set();
-
-  private _reloadTimeout: number | undefined = undefined;
-
   minLevel: number | undefined;
 
   maxLevel: number | undefined;
@@ -62,22 +56,25 @@ class VectorTileOpenlayersImpl
       minZoom: 0,
       maxZoom: 26,
       tileSize: this.tileSize,
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      tileLoadFunction: async (tile: VectorTile): Promise<void> => {
-        const features = await this.tileProvider.getFeaturesForTile(
-          tile.tileCoord[1],
-          tile.tileCoord[2],
-          tile.tileCoord[0],
-          this.headers,
-        );
-        if (features.length > 0) {
-          tile.setFeatures(features);
-        } else {
-          tile.setFeatures([]);
-          tile.setState(TileState.EMPTY);
-        }
+      tileLoadFunction: (tile): void => {
+        this.tileProvider
+          .getFeaturesForTile(
+            tile.tileCoord[1],
+            tile.tileCoord[2],
+            tile.tileCoord[0],
+            this.headers,
+          )
+          .then((features) => {
+            if (features.length > 0) {
+              (tile as VectorTile<Feature>).setFeatures(features);
+            } else {
+              (tile as VectorTile<Feature>).setFeatures([]);
+              tile.setState(TileState.EMPTY);
+            }
+          })
+          .catch((err) => {
+            this.getLogger().error((err as Error).message);
+          });
       },
       // url needs to be set for the tileLoadFunction to work.
       url: '/{z}/{x}/{y}',
@@ -103,45 +100,18 @@ class VectorTileOpenlayersImpl
   }
 
   /**
-   * rerenders the specified tiles
-   * rendering happens async
+   * refreshes the openlayers Layer, which will redraw the scene, seems to magically work
    */
   updateTiles(tileIds: string[]): void {
     if (tileIds.length > 0) {
-      tileIds.forEach((tileId) => {
-        this._tilesToUpdate.add(tileId);
-      });
-      if (this.source) {
-        if (!this._reloadTimeout) {
-          this._reloadTimeout = window.setTimeout(() => {
-            this._tilesToUpdate.forEach((tileId) => {
-              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-              // @ts-ignore
-              const tCache = this.source.tileCache;
-              if (tCache.containsKey(tileId)) {
-                // change of key of tile (will trigger a reload)
-                const tile = tCache.get(tileId) as VectorTile;
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                tile.key = false;
-              }
-            });
-            this.source!.changed();
-            this._tilesToUpdate.clear();
-            this._reloadTimeout = undefined;
-          }, 0);
-        }
-      }
+      this.olLayer?.changed();
     }
   }
 
   // eslint-disable-next-line no-unused-vars
   updateStyle(_style: StyleItem, _silent?: boolean): void {
     if (this.initialized) {
-      window.clearTimeout(this._reloadTimeout);
-      this._reloadTimeout = undefined;
-      this._tilesToUpdate.clear();
-      this.source!.refresh();
+      this.olLayer?.changed();
     }
   }
 

package/src/layer/tileLoadedHelper.ts

@@ -33,9 +33,7 @@ export async function tiledLayerLoaded(
 ): Promise<void> {
   const impls = layer
     .getImplementations()
-    .filter(
-      (i) => i instanceof CesiumTilesetCesiumImpl,
-    ) as CesiumTilesetCesiumImpl[];
+    .filter((i) => i instanceof CesiumTilesetCesiumImpl);
   if (!layer.active || impls.every((i) => i.cesium3DTileset?.tilesLoaded)) {
     return;
   }

package/src/layer/tileProvider/mvtTileProvider.ts

@@ -41,7 +41,7 @@ class MVTTileProvider extends TileProvider {
 
   idProperty: string | undefined;
 
-  private _MVTFormat = new MVT({ featureClass: Feature });
+  private _MVTFormat = new MVT<Feature>({ featureClass: Feature });
 
   constructor(options: MVTTileProviderOptions) {
     const defaultOptions = MVTTileProvider.getDefaultOptions();
@@ -80,7 +80,7 @@ class MVTTileProvider extends TileProvider {
     const center = getCenter(extent);
     const init = getInitForUrl(this.url, headers);
     const data = await requestArrayBuffer(url, init);
-    const features = this._MVTFormat.readFeatures(data) as Feature[];
+    const features = this._MVTFormat.readFeatures(data);
     const sx = (extent[2] - extent[0]) / 4096;
     const sy = -((extent[3] - extent[1]) / 4096);
     features.forEach((feature) => {

package/src/layer/vectorLayer.ts

@@ -1,19 +1,6 @@
 import VectorSource from 'ol/source/Vector.js';
 import Style, { type StyleFunction } from 'ol/style/Style.js';
 import Feature from 'ol/Feature.js';
-import type { SimpleGeometry } from 'ol/geom.js';
-import type { Coordinate } from 'ol/coordinate.js';
-import type {
-  CircleGeometry,
-  CircleOutlineGeometry,
-  GroundPolylineGeometry,
-  HeightReference,
-  PolygonGeometry,
-  PolygonOutlineGeometry,
-  PolylineGeometry,
-  WallGeometry,
-  WallOutlineGeometry,
-} from '@vcmap-cesium/engine';
 
 import { v4 as uuidv4 } from 'uuid';
 import { check, oneOf } from '@vcsuite/check';
@@ -76,64 +63,6 @@ export type VectorOptions = FeatureLayerOptions & {
   vectorProperties?: VectorPropertiesOptions;
 };
 
-export type VectorGeometryFactoryType = {
-  getCoordinates(geom: SimpleGeometry[]): Coordinate[];
-  getGeometryOptions(
-    geom: SimpleGeometry,
-    num: number,
-    perPositionHeight: boolean,
-    groundLevelOrMinHeight: number,
-  ): unknown;
-  createSolidGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-    num2?: number,
-  ): (PolygonGeometry | CircleGeometry | WallGeometry)[];
-  createOutlineGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-    num2?: number,
-  ): (CircleOutlineGeometry | WallOutlineGeometry | PolygonOutlineGeometry)[];
-  createFillGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-  ): (CircleGeometry | PolygonGeometry)[];
-  createGroundLineGeometries(
-    obj: unknown,
-    style: Style,
-  ): GroundPolylineGeometry[];
-  createLineGeometries(obj: unknown, style: Style): PolylineGeometry[];
-};
-
-export type VectorHeightInfo = {
-  /**
-   *  if the object is extruded
-   */
-  extruded: boolean;
-  /**
-   * storey heights above ground, list has the same length as storeysAboveGround
-   */
-  storeyHeightsAboveGround: number[];
-  /**
-   * storey heights below ground, list has the same length as storeysBelowGround
-   */
-  storeyHeightsBelowGround: number[];
-  /**
-   * the level above or below mean sea level (minZ value or ground_level or 0)
-   */
-  groundLevel: number;
-  /**
-   * a negative height to <i>push</i> the geometry visually into the ground
-   */
-  skirt: number;
-  perPositionHeight: boolean;
-  heightReference: HeightReference;
-  heightAboveGroundAdjustment: number;
-};
-
 export type VectorImplementationOptions = FeatureLayerImplementationOptions & {
   source: VectorSource;
   maxResolution?: number;
@@ -504,9 +433,7 @@ class VectorLayer
    */
   getFeaturesById(ids: (string | number)[]): Feature[] {
     check(ids, [oneOf(String, Number)]);
-    return ids
-      .map((id) => this.getFeatureById(id))
-      .filter((f) => f != null) as Feature[];
+    return ids.map((id) => this.getFeatureById(id)).filter((f) => f != null);
   }
 
   /**

package/src/layer/vectorProperties.ts

@@ -77,7 +77,11 @@ export function vectorPropertiesOfType<T extends PrimitiveOptionsType>(
 export type AltitudeModeType =
   | 'absolute'
   | 'relativeToGround'
-  | 'clampToGround';
+  | 'relativeToTerrain'
+  | 'relativeTo3DTiles'
+  | 'clampToGround'
+  | 'clampToTerrain'
+  | 'clampTo3DTiles';
 
 export type ClassificationTypeType = 'both' | 'terrain' | 'cesium3DTile';
 
@@ -197,8 +201,12 @@ export const vcsMetaVersion = '2.1';
 
 export const AltitudeModeCesium: Record<AltitudeModeType, HeightReference> = {
   clampToGround: HeightReference.CLAMP_TO_GROUND,
+  clampTo3DTiles: HeightReference.CLAMP_TO_3D_TILE,
+  clampToTerrain: HeightReference.CLAMP_TO_TERRAIN,
   absolute: HeightReference.NONE,
   relativeToGround: HeightReference.RELATIVE_TO_GROUND,
+  relativeTo3DTiles: HeightReference.RELATIVE_TO_3D_TILE,
+  relativeToTerrain: HeightReference.RELATIVE_TO_TERRAIN,
 };
 
 export const ClassificationTypeCesium: Record<
@@ -217,7 +225,7 @@ export function parseNearFarScalar(
   if (Array.isArray(value)) {
     const valid = value
       .map((entry) => parseNumber(entry))
-      .filter((entry) => entry != null) as number[];
+      .filter((entry) => entry != null);
     if (valid.length === 4) {
       return new NearFarScalar(valid[0], valid[1], valid[2], valid[3]);
     }
@@ -232,7 +240,7 @@ export function parseCartesian3(
   if (Array.isArray(value)) {
     const valid = value
       .map((entry) => parseNumber(entry))
-      .filter((entry) => entry != null) as number[];
+      .filter((entry) => entry != null);
     if (valid.length === 3) {
       return new Cartesian3(valid[0], valid[1], valid[2]);
     }
@@ -318,7 +326,7 @@ class VectorProperties {
       classificationType: undefined,
       scaleByDistance: undefined,
       eyeOffset: undefined,
-      heightAboveGround: 0,
+      heightAboveGround: undefined,
       skirt: 0,
       groundLevel: undefined,
       extrudedHeight: 0,
@@ -350,7 +358,7 @@ class VectorProperties {
 
   private _eyeOffset: Cartesian3 | undefined;
 
-  private _heightAboveGround: number;
+  private _heightAboveGround: number | undefined;
 
   private _skirt: number;
 
@@ -608,13 +616,13 @@ class VectorProperties {
     return parseCartesian3(featureValue, this.eyeOffset);
   }
 
-  get heightAboveGround(): number {
+  get heightAboveGround(): number | undefined {
     return this._heightAboveGround;
   }
 
-  set heightAboveGround(value: number) {
+  set heightAboveGround(value: number | undefined) {
     if (value !== this._heightAboveGround) {
-      check(value, Number);
+      check(value, maybe(Number));
       this._heightAboveGround = value;
       this.propertyChanged.raiseEvent(['heightAboveGround']);
     }
@@ -889,10 +897,10 @@ class VectorProperties {
   }
 
   /**
-   * Get the features or the properties modelOptions. Returns an empty Object if both are undefined
+   * Get the features or the properties modelOptions.
    * @param  feature
    */
-  getModelOptions(feature: Feature): Record<string, unknown> {
+  getModelOptions(feature: Feature): Record<string, unknown> | undefined {
     const featureValue = feature.get('olcs_modelOptions') as
       | Record<string, unknown>
       | undefined;
@@ -902,7 +910,7 @@ class VectorProperties {
     if (this.modelOptions) {
       return this.modelOptions;
     }
-    return {};
+    return undefined;
   }
 
   get modelAutoScale(): boolean {
@@ -968,10 +976,11 @@ class VectorProperties {
 
   private _getBaseOptions(feature: Feature): VectorPropertiesBaseOptions {
     return {
+      // 0 is not a valid scale value and will crash cesium
       scale: [
-        this.getModelScaleX(feature),
-        this.getModelScaleY(feature),
-        this.getModelScaleZ(feature),
+        this.getModelScaleX(feature) || 1,
+        this.getModelScaleY(feature) || 1,
+        this.getModelScaleZ(feature) || 1,
       ],
       heading: this.getModelHeading(feature),
       pitch: this.getModelPitch(feature),
@@ -1013,6 +1022,34 @@ class VectorProperties {
     };
   }
 
+  /**
+   * Determines if a feature (in general with a point geometry) should be rendered as a geometry (billboard & label etc) or a model or a primitive
+   * @param feature
+   */
+  renderAs(feature: Feature): 'geometry' | 'model' | 'primitive' {
+    if (feature.get('olcs_modelUrl')) {
+      return 'model';
+    }
+
+    const primitiveOptions = feature.get('olcs_primitiveOptions') as
+      | VectorPropertiesPrimitiveOptions
+      | undefined;
+
+    if (primitiveOptions?.geometryOptions) {
+      return 'primitive';
+    }
+
+    if (this.modelUrl) {
+      return 'model';
+    }
+
+    if (this.primitiveOptions?.geometryOptions) {
+      return 'primitive';
+    }
+
+    return 'geometry';
+  }
+
   /**
    * resets values, either given, or default Value raises propertyChanged event once;
    * @param  vcsMeta
@@ -1265,6 +1302,22 @@ class VectorProperties {
       }
     }
 
+    if ('modelOptions' in options) {
+      if (!deepEqual(this._modelOptions, options.modelOptions)) {
+        this._modelOptions = options.modelOptions
+          ? structuredClone(options.modelOptions)
+          : undefined;
+        changedProperties.push('modelOptions');
+      }
+    }
+
+    if ('modelAutoScale' in options) {
+      if (this._modelAutoScale !== options.modelAutoScale) {
+        this._modelAutoScale = !!options.modelAutoScale;
+        changedProperties.push('modelAutoScale');
+      }
+    }
+
     if ('baseUrl' in options) {
       if (options.baseUrl !== this._baseUrl) {
         this._baseUrl = options.baseUrl ?? '';
@@ -1272,13 +1325,22 @@ class VectorProperties {
       }
     }
 
+    if ('primitiveOptions' in options) {
+      if (!deepEqual(this._primitiveOptions, options.primitiveOptions)) {
+        this._primitiveOptions = options.primitiveOptions
+          ? structuredClone(options.primitiveOptions)
+          : undefined;
+        changedProperties.push('primitiveOptions');
+      }
+    }
+
     if (changedProperties.length) {
       this.propertyChanged.raiseEvent(changedProperties);
     }
   }
 
   getValues(): VectorPropertiesOptions {
-    const values = {
+    return {
       altitudeMode: getAltitudeModeOptions(this.altitudeMode),
       allowPicking: this.allowPicking,
       classificationType: getClassificationTypeOptions(this.classificationType),
@@ -1299,9 +1361,11 @@ class VectorProperties {
       modelHeading: this.modelHeading,
       modelPitch: this.modelPitch,
       modelRoll: this.modelRoll,
+      modelAutoScale: this.modelAutoScale,
+      modelOptions: this.modelOptions,
       baseUrl: this.baseUrl,
+      primitiveOptions: this.primitiveOptions,
     };
-    return values;
   }
 
   /**

package/src/map/baseOLMap.ts

@@ -87,7 +87,7 @@ class BaseOLMap extends VcsMap<OLLayer> {
       olEvent.preventDefault();
     }
     olEvent.originalEvent.preventDefault();
-    const position = [olEvent.coordinate[0], olEvent.coordinate[1], 0];
+    const position = [olEvent.coordinate[0], olEvent.coordinate[1]];
     this.pointerInteractionEvent.raiseEvent({
       map: this,
       position,

package/src/oblique/helpers.ts

@@ -13,7 +13,10 @@ import { transform } from 'ol/proj.js';
 import { Cartesian2, type CesiumTerrainProvider } from '@vcmap-cesium/engine';
 import { ObliqueViewDirection } from './obliqueViewDirection.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
-import { cartesian2DDistance } from '../util/math.js';
+import {
+  cartesian2DDistance,
+  cartesian2DDistanceSquared,
+} from '../util/math.js';
 import Projection, {
   mercatorProjection,
   wgs84Projection,
@@ -52,11 +55,14 @@ export function sortRealWordEdgeCoordinates(
 
   let sorted = extentPoints.map((extentPoint) => {
     let closest = 0;
-    let distance = Infinity;
+    let distanceSquared = Infinity;
     cornerPoints.forEach((cornerPoint, cornerIndex) => {
-      const currentDistance = cartesian2DDistance(extentPoint, cornerPoint);
-      if (currentDistance < distance) {
-        distance = currentDistance;
+      const currentDistanceSquared = cartesian2DDistanceSquared(
+        extentPoint,
+        cornerPoint,
+      );
+      if (currentDistanceSquared < distanceSquared) {
+        distanceSquared = currentDistanceSquared;
         closest = cornerIndex;
       }
     });

package/src/oblique/obliqueDataSet.ts

@@ -3,7 +3,7 @@ import { createXYZ } from 'ol/tilegrid.js';
 import type { Coordinate } from 'ol/coordinate.js';
 import type { TileCoord } from 'ol/tilecoord.js';
 import type { Extent } from 'ol/extent.js';
-import { cartesian2DDistance } from '../util/math.js';
+import { cartesian2DDistanceSquared } from '../util/math.js';
 import {
   parseImageData,
   parseImageMeta,
@@ -235,12 +235,12 @@ class ObliqueDataSet {
     let minTile = null;
     [...this._tiles.keys()].forEach((tile) => {
       const tileCoord = tile.split('/').map(Number);
-      const dist = cartesian2DDistance(
+      const squaredDist = cartesian2DDistanceSquared(
         [actualTile[1], actualTile[2]],
         [tileCoord[1], tileCoord[2]],
       );
-      if (dist < minDistance) {
-        minDistance = dist;
+      if (squaredDist < minDistance) {
+        minDistance = squaredDist;
         minTile = tileCoord;
       }
     });