@vcmap/core 6.0.0-rc.7 → 6.0.0-rc.9

package/src/util/geometryHelpers.ts

@@ -272,104 +272,125 @@ export async function from2Dto3DLayout(
   }
 }
 
-export async function createAbsoluteFeatures(
-  features: Feature[],
+function setZCoordinate(geometry: Geometry, z: number): void {
+  const layout = geometry.getLayout();
+  const coordinates = geometry.getCoordinates() as any[];
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
+
+  flatCoordinates.forEach((c) => {
+    if (layout === 'XYM') {
+      c[3] = c[2];
+      c[2] = z;
+    } else {
+      c[2] = z;
+    }
+  });
+
+  geometry.setCoordinates(
+    coordinates,
+    layout === 'XYM' || layout === 'XYZM' ? 'XYZM' : 'XYZ',
+  );
+}
+
+export async function createAbsoluteFeature(
+  feature: Feature,
   vectorProperties: VectorProperties,
   scene: Scene,
-): Promise<Feature[]> {
-  const clones = features.map((feature) => feature.clone());
-  const absoluteClones = await Promise.all(
-    clones.map(async (feature) => {
-      const geometry = feature.getGeometry();
-      if (!geometry) {
-        return null;
-      }
+): Promise<Feature | null> {
+  const clone = feature.clone();
+  const geometry = clone.getGeometry();
+  if (!geometry) {
+    return null;
+  }
 
-      const altitudeMode = vectorProperties.getAltitudeMode(feature);
-      if (altitudeMode === HeightReference.NONE) {
-        if (is2DLayout(geometry.getLayout())) {
-          await from2Dto3DLayout(
-            geometry,
-            scene,
-            HeightReference.CLAMP_TO_GROUND,
-          );
-        }
-      } else if (isClampedHeightReference(altitudeMode)) {
-        await placeGeometryOnGround(
-          geometry,
-          scene,
-          altitudeMode !== HeightReference.CLAMP_TO_TERRAIN
-            ? HeightReference.CLAMP_TO_GROUND
-            : HeightReference.CLAMP_TO_TERRAIN,
-        );
-      } else if (isRelativeHeightReference(altitudeMode)) {
-        const singleGeometries = getSingleGeometriesFromGeometry(geometry);
-        await Promise.all(
-          singleGeometries.map(async (singleGeometry) => {
-            const heightInfo = getHeightInfo(
-              feature,
-              singleGeometry,
-              vectorProperties,
-            ) as VectorHeightInfo<RelativeHeightReference>;
+  const altitudeMode = vectorProperties.getAltitudeMode(clone);
+  let groundLevel = vectorProperties.getGroundLevel(clone);
 
-            let { groundLevel } = heightInfo;
-            if (heightInfo.clampOrigin) {
-              const cartographics = [
-                mercatorToCartographic(heightInfo.clampOrigin),
-              ];
-              if (
-                heightInfo.heightReference ===
-                HeightReference.RELATIVE_TO_TERRAIN
-              ) {
-                await sampleTerrainMostDetailed(
-                  scene.terrainProvider,
-                  cartographics,
-                );
-              } else {
-                await scene.sampleHeightMostDetailed(cartographics);
-              }
-              groundLevel = cartographics[0].height;
-            }
+  if (altitudeMode === HeightReference.NONE) {
+    if (groundLevel != null) {
+      setZCoordinate(geometry, groundLevel);
+    } else if (is2DLayout(geometry.getLayout())) {
+      await from2Dto3DLayout(geometry, scene, HeightReference.CLAMP_TO_GROUND);
+    }
+  } else if (isClampedHeightReference(altitudeMode)) {
+    if (groundLevel != null) {
+      setZCoordinate(geometry, groundLevel);
+    } else {
+      await placeGeometryOnGround(
+        geometry,
+        scene,
+        altitudeMode !== HeightReference.CLAMP_TO_TERRAIN
+          ? HeightReference.CLAMP_TO_GROUND
+          : HeightReference.CLAMP_TO_TERRAIN,
+      );
+    }
+  } else if (isRelativeHeightReference(altitudeMode)) {
+    const singleGeometries = getSingleGeometriesFromGeometry(geometry);
+    await Promise.all(
+      singleGeometries.map(async (singleGeometry) => {
+        const heightInfo = getHeightInfo(
+          clone,
+          singleGeometry,
+          vectorProperties,
+        ) as VectorHeightInfo<RelativeHeightReference>;
 
-            const coordinates = singleGeometry.getCoordinates() as any[];
-            const flatCoordinates = getFlatCoordinateReferences(
-              singleGeometry,
-              coordinates,
+        ({ groundLevel } = heightInfo);
+        if (heightInfo.clampOrigin) {
+          const cartographics = [
+            mercatorToCartographic(heightInfo.clampOrigin),
+          ];
+          if (
+            heightInfo.heightReference === HeightReference.RELATIVE_TO_TERRAIN
+          ) {
+            await sampleTerrainMostDetailed(
+              scene.terrainProvider,
+              cartographics,
             );
-            const { heightAboveGround } = heightInfo;
-            const setCoordinate =
-              heightAboveGround == null
-                ? (c: Coordinate): void => {
-                    c[2] += groundLevel as number;
-                  }
-                : (c: Coordinate): void => {
-                    c[2] = (groundLevel as number) + heightAboveGround;
-                  };
-            flatCoordinates.forEach(setCoordinate);
-            singleGeometry.setCoordinates(coordinates, 'XYZ');
-          }),
+          } else {
+            await scene.sampleHeightMostDetailed(cartographics);
+          }
+          groundLevel = cartographics[0].height;
+        }
+
+        const coordinates = singleGeometry.getCoordinates() as any[];
+        const flatCoordinates = getFlatCoordinateReferences(
+          singleGeometry,
+          coordinates,
         );
+        const { heightAboveGround } = heightInfo;
+        const setCoordinate =
+          heightAboveGround == null
+            ? (c: Coordinate): void => {
+                c[2] += groundLevel as number;
+              }
+            : (c: Coordinate): void => {
+                c[2] = (groundLevel as number) + heightAboveGround;
+              };
+        flatCoordinates.forEach(setCoordinate);
+        singleGeometry.setCoordinates(coordinates, 'XYZ');
+      }),
+    );
 
-        if (geometry instanceof MultiPoint) {
-          geometry.setCoordinates(
-            singleGeometries.map((g) => g.getCoordinates() as Coordinate),
-          );
-        } else if (geometry instanceof MultiPolygon) {
-          geometry.setCoordinates(
-            singleGeometries.map((g) => g.getCoordinates() as Coordinate[][]),
-          );
-        } else if (geometry instanceof MultiLineString) {
-          geometry.setCoordinates(
-            singleGeometries.map((g) => g.getCoordinates() as Coordinate[]),
-          );
-        } else if (geometry instanceof GeometryCollection) {
-          geometry.setGeometries(singleGeometries);
-        }
-      }
+    if (geometry instanceof MultiPoint) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate),
+      );
+    } else if (geometry instanceof MultiPolygon) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate[][]),
+      );
+    } else if (geometry instanceof MultiLineString) {
+      geometry.setCoordinates(
+        singleGeometries.map((g) => g.getCoordinates() as Coordinate[]),
+      );
+    } else if (geometry instanceof GeometryCollection) {
+      geometry.setGeometries(singleGeometries);
+    }
+  }
 
-      return feature;
-    }),
-  );
+  clone.set('olcs_altitudeMode', 'absolute');
+  clone.unset('olcs_groundLevel');
+  clone.unset('olcs_heightAboveGround');
 
-  return absoluteClones.filter((f): f is Feature => !!f);
+  return clone;
 }

package/src/vcsApp.ts

@@ -27,6 +27,7 @@ import { setDefaultProjectionOptions } from './util/projection.js';
 import ObliqueMap from './map/obliqueMap.js';
 import OverrideClassRegistry from './overrideClassRegistry.js';
 import ClassRegistry, {
+  AbstractCtor,
   categoryClassRegistry,
   Ctor,
   featureProviderClassRegistry,
@@ -117,7 +118,9 @@ class VcsApp {
 
   private _flights: OverrideCollection<FlightInstance, FlightCollection>;
 
-  private _categoryClassRegistry: OverrideClassRegistry<typeof Category>;
+  private _categoryClassRegistry: OverrideClassRegistry<
+    typeof Category<any, any>
+  >;
 
   private _categories: CategoryCollection;
 
@@ -347,11 +350,13 @@ class VcsApp {
     return this._styleClassRegistry;
   }
 
-  get categoryClassRegistry(): OverrideClassRegistry<typeof Category> {
+  get categoryClassRegistry(): OverrideClassRegistry<
+    typeof Category<any, any>
+  > {
     return this._categoryClassRegistry;
   }
 
-  get categoryItemClassRegistry(): OverrideClassRegistry<Ctor<any>> {
+  get categoryItemClassRegistry(): OverrideClassRegistry<AbstractCtor> {
     return this._categoryItemClassRegistry;
   }
 
@@ -422,7 +427,7 @@ class VcsApp {
           [...this._maps]
             .filter((m) => m instanceof ObliqueMap)
             .map((m) => {
-              return (m as ObliqueMap).setCollection(startingObliqueCollection);
+              return m.setCollection(startingObliqueCollection);
             }),
         );
       }
@@ -623,5 +628,7 @@ export function getVcsAppById(id: string): VcsApp | undefined {
 
 window.vcs = window.vcs || {};
 window.vcs.apps = vcsApps;
+window.vcs.createModuleFromConfig = (config: VcsModuleConfig): VcsModule =>
+  new VcsModule(config);
 
 export default VcsApp;