@vcmap/core 6.0.0-rc.4 → 6.0.0-rc.6

package/src/layer/cesium/vectorContext.ts

@@ -1,43 +1,28 @@
 import {
-  PrimitiveCollection,
+  type Billboard,
   BillboardCollection,
-  LabelCollection,
-  Matrix4,
   Cartesian3,
-  Math as CesiumMath,
-  Model,
-  type Primitive,
-  type GroundPrimitive,
-  type GroundPolylinePrimitive,
-  type ClassificationPrimitive,
-  type Billboard,
   type Entity,
   type Label,
-  type EntityCollection,
-  SplitDirection,
+  LabelCollection,
+  Math as CesiumMath,
+  Matrix4,
+  Model,
+  Primitive,
+  PrimitiveCollection,
   Scene,
+  SplitDirection,
 } from '@vcmap-cesium/engine';
-import { Style } from 'ol/style.js';
-import { StyleFunction } from 'ol/style/Style.js';
+import { StyleLike } from 'ol/style/Style.js';
 import type { Feature } from 'ol/index.js';
+
 import Viewpoint from '../../util/viewpoint.js';
 import type CesiumMap from '../../map/cesiumMap.js';
 import VectorProperties from '../vectorProperties.js';
-import convert from '../../util/featureconverter/convert.js';
-
-type PrimitiveType =
-  | Primitive
-  | GroundPrimitive
-  | GroundPolylinePrimitive
-  | ClassificationPrimitive
-  | Model;
-
-export type VectorContextFeatureCache = {
-  primitives?: PrimitiveType[];
-  scaledPrimitives?: PrimitiveType[];
-  billboards?: (Billboard | Entity)[];
-  labels?: (Label | Entity)[];
-};
+import convert, {
+  ConvertedItem,
+  PrimitiveType,
+} from '../../util/featureconverter/convert.js';
 
 export function setReferenceForPicking(
   feature: Feature,
@@ -46,71 +31,6 @@ export function setReferenceForPicking(
   primitive.olFeature = feature;
 }
 
-export function removeArrayFromCollection(
-  collection:
-    | PrimitiveCollection
-    | BillboardCollection
-    | LabelCollection
-    | EntityCollection,
-  array?: (PrimitiveType | Billboard | Label | Entity)[],
-): void {
-  if (array) {
-    array.forEach((primitive) => {
-      collection.remove(primitive);
-    });
-  }
-}
-
-export function removeFeatureFromMap(
-  feature: Feature,
-  featuresMap: Map<Feature, (PrimitiveType | Billboard | Label | Entity)[]>,
-  primitiveCollection:
-    | PrimitiveCollection
-    | BillboardCollection
-    | LabelCollection
-    | EntityCollection,
-): boolean {
-  removeArrayFromCollection(primitiveCollection, featuresMap.get(feature));
-  return featuresMap.delete(feature);
-}
-
-export function addPrimitiveToContext(
-  primitives: (PrimitiveType | Entity.ConstructorOptions)[],
-  feature: Feature,
-  allowPicking: boolean,
-  primitiveCollection:
-    | BillboardCollection
-    | LabelCollection
-    | PrimitiveCollection
-    | EntityCollection,
-  featureMap: Map<Feature, (Billboard | Label | PrimitiveType | Entity)[]>,
-  splitDirection?: SplitDirection,
-): void {
-  if (primitives.length) {
-    const cesiumPrimitives = primitives.map((primitiveOptions) => {
-      const primitive = primitiveCollection.add(primitiveOptions) as
-        | Billboard
-        | Label
-        | PrimitiveType
-        | Entity
-        | Model;
-      if (allowPicking) {
-        setReferenceForPicking(feature, primitive);
-      }
-      if (splitDirection && primitive instanceof Model) {
-        // Cesium currently only supports splitDirection on Model primitives
-        primitive.splitDirection = splitDirection;
-      }
-      return primitive;
-    });
-    if (!featureMap.has(feature)) {
-      featureMap.set(feature, cesiumPrimitives);
-    } else {
-      featureMap.get(feature)!.push(...cesiumPrimitives);
-    }
-  }
-}
-
 /**
  * Sets splitDirection on primitives. Currently only Model primitives support splitting.
  */
@@ -175,133 +95,19 @@ export function setupScalingPrimitiveCollection(
   });
 }
 
-export interface AsyncCesiumVectorContext {
-  addPrimitives(
-    primitives: PrimitiveType[],
-    feature: Feature,
-    allowPicking: boolean,
-  ): void;
-  addScaledPrimitives(
-    primitives: PrimitiveType[],
-    feature: Feature,
-    allowPicking: boolean,
-  ): void;
-  addBillboards(
-    billboardOptions: object[],
+export interface CesiumVectorContext {
+  addFeature(
     feature: Feature,
-    allowPicking: boolean,
-  ): void;
-  addLabels(
-    labelOptions: object[],
-    feature: Feature,
-    allowPicking: boolean,
-  ): void;
-}
-
-export interface CesiumVectorContext extends AsyncCesiumVectorContext {
+    style: StyleLike,
+    vectorProperties: VectorProperties,
+    scene: Scene,
+  ): Promise<void>;
   removeFeature(feature: Feature): void;
-  createFeatureCache(feature: Feature): VectorContextFeatureCache;
-  clearFeatureCache(cache: VectorContextFeatureCache): void;
   updateSplitDirection(splitDirection: SplitDirection): void;
   clear(): void;
 }
 
-function createAsyncFeatureConvert(
-  feature: Feature,
-  style: Style | StyleFunction,
-  vectorProperties: VectorProperties,
-  context: CesiumVectorContext,
-  scene: Scene,
-): () => void {
-  let isDestroyed = false;
-  const primitivesArray: {
-    primitives: PrimitiveType[];
-    allowPicking: boolean;
-  }[] = [];
-  const scaledPrimitives: {
-    primitives: PrimitiveType[];
-    allowPicking: boolean;
-  }[] = [];
-  const billboards: { billboardOptions: object[]; allowPicking: boolean }[] =
-    [];
-  const labels: { labelOptions: object[]; allowPicking: boolean }[] = [];
-
-  const asyncContext: AsyncCesiumVectorContext = {
-    addPrimitives(
-      primitives: PrimitiveType[],
-      _feature: Feature,
-      allowPicking: boolean,
-    ): void {
-      primitivesArray.push({ primitives, allowPicking });
-    },
-    addScaledPrimitives(
-      primitives: PrimitiveType[],
-      _feature: Feature,
-      allowPicking: boolean,
-    ): void {
-      scaledPrimitives.push({ primitives, allowPicking });
-    },
-    addBillboards(
-      billboardOptions: object[],
-      _feature: Feature,
-      allowPicking: boolean,
-    ): void {
-      billboards.push({ billboardOptions, allowPicking });
-    },
-    addLabels(
-      labelOptions: object[],
-      _feature: Feature,
-      allowPicking: boolean,
-    ): void {
-      labels.push({ labelOptions, allowPicking });
-    },
-  };
-
-  convert(feature, style, vectorProperties, asyncContext, scene)
-    .then(() => {
-      if (!isDestroyed) {
-        primitivesArray.forEach(({ primitives, allowPicking }) => {
-          context.addPrimitives(primitives, feature, allowPicking);
-        });
-        scaledPrimitives.forEach(({ primitives, allowPicking }) => {
-          context.addScaledPrimitives(primitives, feature, allowPicking);
-        });
-        billboards.forEach(({ billboardOptions, allowPicking }) => {
-          context.addBillboards(billboardOptions, feature, allowPicking);
-        });
-        labels.forEach(({ labelOptions, allowPicking }) => {
-          context.addLabels(labelOptions, feature, allowPicking);
-        });
-      } else {
-        primitivesArray.forEach(({ primitives }) => {
-          primitives.forEach((p) => {
-            p.destroy();
-          });
-        });
-        scaledPrimitives.forEach(({ primitives }) => {
-          primitives.forEach((p) => {
-            p.destroy();
-          });
-        });
-      }
-    })
-    .catch((err) => {
-      console.error('feature conversion failed');
-      console.error(err);
-    })
-    .finally(() => {
-      primitivesArray.splice(0);
-      scaledPrimitives.splice(0);
-      billboards.splice(0);
-      labels.splice(0);
-    });
-
-  return () => {
-    isDestroyed = true;
-  };
-}
-
-class VectorContext implements CesiumVectorContext {
+export default class VectorContext implements CesiumVectorContext {
   primitives = new PrimitiveCollection();
 
   scaledPrimitives = new PrimitiveCollection();
@@ -310,15 +116,9 @@ class VectorContext implements CesiumVectorContext {
 
   labels: LabelCollection;
 
-  featureToPrimitiveMap: Map<Feature, PrimitiveType[]> = new Map();
+  private _featureItems = new Map<Feature, (() => void)[]>();
 
-  featureToScaledPrimitiveMap: Map<Feature, PrimitiveType[]> = new Map();
-
-  featureToBillboardMap: Map<Feature, Array<Billboard>> = new Map();
-
-  featureToLabelMap: Map<Feature, Array<Label>> = new Map();
-
-  _features: Map<Feature, () => void> = new Map();
+  private _convertingFeatures: Map<Feature, () => void> = new Map();
 
   splitDirection: SplitDirection;
 
@@ -335,7 +135,7 @@ class VectorContext implements CesiumVectorContext {
     rootCollection: PrimitiveCollection,
     splitDirection: SplitDirection,
   ) {
-    const scene = map.getScene();
+    const scene = map.getScene()!;
     this.billboards = new BillboardCollection({ scene });
     this.labels = new LabelCollection({ scene });
     this.splitDirection = splitDirection;
@@ -354,150 +154,127 @@ class VectorContext implements CesiumVectorContext {
     );
   }
 
-  addPrimitives(
-    primitives: PrimitiveType[],
+  private _addConvertedItems(
     feature: Feature,
-    allowPicking = false,
+    allowPicking: boolean,
+    items: ConvertedItem[],
   ): void {
-    addPrimitiveToContext(
-      primitives,
-      feature,
-      allowPicking,
-      this.primitives,
-      this.featureToPrimitiveMap,
-      this.splitDirection,
-    );
-  }
+    const removeItems = items
+      .map((item) => {
+        let instance: PrimitiveType | Label | Billboard | undefined;
+        let removeItem: (() => void) | undefined;
+        if (item.type === 'primitive') {
+          if (item.autoScale) {
+            instance = this.scaledPrimitives.add(item.item) as PrimitiveType;
+            if (instance) {
+              removeItem = (): void => {
+                this._scaledDirty.value =
+                  this.scaledPrimitives.remove(instance);
+              };
+              this._scaledDirty.value = true;
+            }
+          } else {
+            instance = this.primitives.add(item.item) as PrimitiveType;
+            if (instance) {
+              removeItem = (): void => {
+                this.primitives.remove(instance);
+              };
+            }
+          }
+        } else if (item.type === 'billboard') {
+          instance = this.billboards.add(item.item);
+          if (instance) {
+            removeItem = (): void => {
+              this.billboards.remove(instance as Billboard);
+            };
+          }
+        } else if (item.type === 'label') {
+          instance = this.labels.add(item.item);
+          if (instance) {
+            removeItem = (): void => {
+              this.labels.remove(instance as Label);
+            };
+          }
+        }
 
-  addScaledPrimitives(
-    primitives: PrimitiveType[],
-    feature: Feature,
-    allowPicking = false,
-  ): void {
-    addPrimitiveToContext(
-      primitives,
-      feature,
-      allowPicking,
-      this.scaledPrimitives,
-      this.featureToScaledPrimitiveMap,
-      this.splitDirection,
-    );
-    this._scaledDirty.value = true;
-  }
+        if (instance) {
+          if (allowPicking) {
+            setReferenceForPicking(feature, instance);
+          }
 
-  addBillboards(
-    billboardOptions: object[],
-    feature: Feature,
-    allowPicking = false,
-  ): void {
-    addPrimitiveToContext(
-      billboardOptions,
-      feature,
-      allowPicking,
-      this.billboards,
-      this.featureToBillboardMap,
-      this.splitDirection,
-    );
+          if (this.splitDirection && instance instanceof Model) {
+            // Cesium currently only supports splitDirection on Model primitives // XXX this is no longer TRUE
+            instance.splitDirection = this.splitDirection;
+          }
+        }
+        return removeItem;
+      })
+      .filter((i): i is () => void => i != null);
+
+    this._featureItems.set(feature, removeItems);
   }
 
-  addLabels(
-    labelOptions: object[],
+  async addFeature(
     feature: Feature,
-    allowPicking = false,
-  ): void {
-    addPrimitiveToContext(
-      labelOptions,
-      feature,
-      allowPicking,
-      this.labels,
-      this.featureToLabelMap,
-      this.splitDirection,
-    );
-  }
+    style: StyleLike,
+    vectorProperties: VectorProperties,
+    scene: Scene,
+  ): Promise<void> {
+    this._convertingFeatures.get(feature)?.();
+    let deleted = false;
+    this._convertingFeatures.set(feature, () => {
+      deleted = true;
+    });
 
-  /**
-   * @param  feature
-   */
-  removeFeature(feature: Feature): void {
-    this._features.get(feature)?.();
-    this._features.delete(feature);
-    removeFeatureFromMap(feature, this.featureToPrimitiveMap, this.primitives);
-    this._scaledDirty.value = removeFeatureFromMap(
+    const convertedItems = await convert(
       feature,
-      this.featureToScaledPrimitiveMap,
-      this.scaledPrimitives,
+      style,
+      vectorProperties,
+      scene,
     );
-    removeFeatureFromMap(feature, this.featureToBillboardMap, this.billboards);
-    removeFeatureFromMap(feature, this.featureToLabelMap, this.labels);
-  }
 
-  /**
-   * Caches the current cesium resources for a feature, removing them from the feature map
-   * @param feature
-   */
-  createFeatureCache(feature: Feature): VectorContextFeatureCache {
-    const cache: VectorContextFeatureCache = {};
-    cache.primitives = this.featureToPrimitiveMap.get(feature);
-    this.featureToPrimitiveMap.delete(feature);
-    cache.scaledPrimitives = this.featureToScaledPrimitiveMap.get(feature);
-    this.featureToScaledPrimitiveMap.delete(feature);
-    cache.billboards = this.featureToBillboardMap.get(feature);
-    this.featureToBillboardMap.delete(feature);
-    cache.labels = this.featureToLabelMap.get(feature);
-    this.featureToLabelMap.delete(feature);
-    return cache;
+    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
+    this._featureItems.delete(feature);
+
+    if (deleted) {
+      convertedItems.forEach((item) => {
+        if (item.type === 'primitive') {
+          item.item.destroy();
+        }
+      });
+    } else {
+      this._addConvertedItems(
+        feature,
+        vectorProperties.getAllowPicking(feature),
+        convertedItems,
+      );
+    }
   }
 
-  /**
-   * @param  cache
-   */
-  clearFeatureCache(cache: VectorContextFeatureCache): void {
-    removeArrayFromCollection(this.primitives, cache.primitives);
-    removeArrayFromCollection(this.scaledPrimitives, cache.scaledPrimitives);
-    removeArrayFromCollection(this.billboards, cache.billboards);
-    removeArrayFromCollection(this.labels, cache.labels);
+  removeFeature(feature: Feature): void {
+    this._convertingFeatures.get(feature)?.();
+    this._convertingFeatures.delete(feature);
+    this._featureItems.get(feature)?.forEach((removeItem) => removeItem());
+    this._featureItems.delete(feature);
   }
 
-  /**
-   * Updates splitDirection on primitives. Currently only Model primitives support splitting.
-   * @param  splitDirection
-   */
   updateSplitDirection(splitDirection: SplitDirection): void {
     this.splitDirection = splitDirection;
     setSplitDirectionOnPrimitives(splitDirection, this.primitives);
     setSplitDirectionOnPrimitives(splitDirection, this.scaledPrimitives);
   }
 
-  /**
-   * Clears all collections and maps
-   */
   clear(): void {
     this.primitives.removeAll();
+    this._scaledDirty.value = this.scaledPrimitives.length > 0;
     this.scaledPrimitives.removeAll();
     this.billboards.removeAll();
     this.labels.removeAll();
-    this.featureToBillboardMap.clear();
-    this.featureToLabelMap.clear();
-    this.featureToPrimitiveMap.clear();
-    this._scaledDirty.value = this.featureToScaledPrimitiveMap.size > 0;
-    this.featureToScaledPrimitiveMap.clear();
-    this._features.forEach((destroy) => {
+    this._featureItems.clear();
+    this._convertingFeatures.forEach((destroy) => {
       destroy();
     });
-    this._features.clear();
-  }
-
-  convertFeature(
-    feature: Feature,
-    style: Style | StyleFunction,
-    vectorProperties: VectorProperties,
-    scene: Scene,
-  ): void {
-    this._features.get(feature)?.();
-    this._features.set(
-      feature,
-      createAsyncFeatureConvert(feature, style, vectorProperties, this, scene),
-    );
+    this._convertingFeatures.clear();
   }
 
   /**
@@ -513,16 +290,11 @@ class VectorContext implements CesiumVectorContext {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     this._rootCollection = null;
-    this.featureToBillboardMap.clear();
-    this.featureToLabelMap.clear();
-    this.featureToPrimitiveMap.clear();
-    this._features.forEach((destroy) => {
+    this._convertingFeatures.forEach((destroy) => {
       destroy();
     });
-    this._features.clear();
-    this.featureToScaledPrimitiveMap.clear();
+    this._convertingFeatures.clear();
+    this._featureItems.clear();
     this._postRenderListener();
   }
 }
-
-export default VectorContext;

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,
@@ -25,7 +25,7 @@ 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(