@reearth/core 0.0.1

package/src/engines/Cesium/core/labels/JapanGSIOptimalBVmapVectorMapLabel/JapanGSIOptimalBVmapVectorMapLabel.tsx

@@ -0,0 +1,258 @@
+import {
+  type Globe,
+  type ImageryProvider,
+  type Scene,
+  type ImageryLayer as CesiumImageryLayer,
+  LabelCollection,
+} from "cesium";
+import { atom, useAtomValue, useSetAtom, type Atom, type SetStateAction } from "jotai";
+import { fromPairs, uniqBy, xorBy } from "lodash-es";
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState, type FC } from "react";
+import { CesiumComponentRef, useCesium } from "resium";
+
+import { assertType } from "../../../../../utils/assertType";
+import { usePreRender } from "../../../hooks/useSceneEvent";
+
+import { makeKey } from "./helpers";
+import {
+  JapanGSIOptimalBVmapLabelImagery,
+  type AnnotationStyle,
+} from "./JapanGSIOptimalBVmapLabelImagery";
+import { LabelImageryLayer } from "./JapanGSIOptimalBVmapLabelImageryLayer";
+import { JapanGSIOptimalBVmapLabelImageryProvider } from "./JapanGSIOptimalBVmapLabelImageryProvider";
+import { type Imagery, type ImageryCoords, type KeyedImagery } from "./types";
+
+interface TileImagery {
+  readyImagery?: Imagery;
+}
+
+interface GlobeSurfaceTile {
+  imagery: readonly TileImagery[];
+}
+
+interface QuadtreeTile {
+  data?: GlobeSurfaceTile;
+}
+
+interface QuadtreePrimitive {
+  _tilesToRender: readonly QuadtreeTile[];
+}
+
+function getAncestorKeys(coords: ImageryCoords, minLevel: number): string[] {
+  if (coords.level === minLevel) {
+    return [];
+  }
+  const divisor = 2 ** coords.level;
+  const x = coords.x / divisor;
+  const y = coords.y / divisor;
+  return [...Array(coords.level - minLevel)].map((_, index) => {
+    const level = coords.level - (index + 1);
+    const scale = 2 ** level;
+    return makeKey({
+      x: Math.floor(x * scale),
+      y: Math.floor(y * scale),
+      level,
+    });
+  });
+}
+
+function isEqualKeys(a: readonly KeyedImagery[], b?: readonly KeyedImagery[]): boolean {
+  return b != null && a.length === b.length && xorBy(a, b, "key").length === 0;
+}
+
+function getImageriesToRender(scene: Scene, imageryProvider: ImageryProvider): KeyedImagery[] {
+  const globe = scene.globe as Globe & {
+    _surface: QuadtreePrimitive;
+  };
+
+  let minLevel = Infinity;
+  let maxLevel = -Infinity;
+  const imageries = uniqBy(
+    globe._surface._tilesToRender.flatMap(
+      tile =>
+        tile.data?.imagery
+          .map(imagery => imagery.readyImagery)
+          .filter((imagery): imagery is KeyedImagery => {
+            if (imagery?.imageryLayer.imageryProvider !== imageryProvider) {
+              return false;
+            }
+            assertType<KeyedImagery>(imagery);
+            imagery.key = makeKey(imagery);
+            if (imagery.level < minLevel) {
+              minLevel = imagery.level;
+            }
+            if (imagery.level > maxLevel) {
+              maxLevel = imagery.level;
+            }
+            return true;
+          }) ?? [],
+    ),
+    "key",
+  ).sort((a, b) => a.key.localeCompare(b.key));
+
+  if (minLevel === maxLevel || minLevel === Infinity || maxLevel === -Infinity) {
+    return imageries;
+  }
+
+  // Populate children and descendants fields.
+  const map: Record<
+    string,
+    {
+      imagery: KeyedImagery;
+      children: KeyedImagery[];
+      descendants: KeyedImagery[];
+    }
+  > = fromPairs(
+    imageries.map(imagery => [
+      imagery.key,
+      {
+        imagery,
+        children: [],
+        descendants: [],
+      },
+    ]),
+  );
+  imageries.forEach(imagery => {
+    const ancestorKeys = getAncestorKeys(imagery, minLevel);
+    ancestorKeys.forEach(key => {
+      const ancestor = map[key];
+      if (ancestor != null) {
+        ancestor.descendants.push(imagery);
+        if (imagery.level - ancestor.imagery.level === 1) {
+          ancestor.children.push(imagery);
+        }
+      }
+    });
+  });
+  Object.values(map).forEach(({ imagery, children, descendants }) => {
+    // Maintain object-equality of arrays.
+    if (!isEqualKeys(children, imagery.children)) {
+      imagery.children = children;
+    }
+    if (!isEqualKeys(descendants, imagery.descendants)) {
+      imagery.descendants = descendants;
+    }
+  });
+
+  // Imageries that have 4 children will not be visible.
+  return imageries.filter(imagery => imagery.children != null && imagery.children.length < 4);
+}
+
+const LabelImageryCollection: FC<{
+  imageryProvider: JapanGSIOptimalBVmapLabelImageryProvider;
+  imageriesAtom: Atom<KeyedImagery[]>;
+  style?: AnnotationStyle;
+  labelCollection?: LabelCollection;
+}> = ({ imageryProvider, imageriesAtom, style, labelCollection }) => {
+  const imageries = useAtomValue(imageriesAtom);
+  return (
+    <>
+      {imageries.map(imagery => (
+        <Suspense key={imagery.key}>
+          <JapanGSIOptimalBVmapLabelImagery
+            imageryProvider={imageryProvider}
+            imagery={imagery}
+            descendants={imagery.descendants}
+            style={style}
+            labelCollection={labelCollection}
+          />
+        </Suspense>
+      ))}
+    </>
+  );
+};
+
+export interface VectorMapLabelProps {
+  style?: Record<string, any>;
+}
+
+export const JapanGSIOptimalBVmapVectorMapLabel: FC<VectorMapLabelProps> = ({ style }) => {
+  const [imageryProvider, setImageryProvider] =
+    useState<JapanGSIOptimalBVmapLabelImageryProvider>();
+  const setRef = useCallback((handle: CesiumComponentRef<CesiumImageryLayer> | null) => {
+    setImageryProvider(
+      handle?.cesiumElement?.imageryProvider instanceof JapanGSIOptimalBVmapLabelImageryProvider
+        ? handle.cesiumElement.imageryProvider
+        : undefined,
+    );
+  }, []);
+
+  const imageriesAtom = useMemo(() => {
+    const primitiveAtom = atom<KeyedImagery[]>([]);
+    return atom(
+      get => get(primitiveAtom),
+      (get, set, value: SetStateAction<KeyedImagery[]>) => {
+        const prevValue = get(primitiveAtom);
+        const nextValue = typeof value === "function" ? value(prevValue) : value;
+        if (
+          prevValue.length !== nextValue.length &&
+          xorBy(prevValue, nextValue, "key").length > 0
+        ) {
+          set(primitiveAtom, nextValue);
+        }
+      },
+    );
+  }, []);
+
+  const setImageries = useSetAtom(imageriesAtom);
+  usePreRender(scene => {
+    if (imageryProvider == null) {
+      return;
+    }
+    const imageries = getImageriesToRender(scene, imageryProvider);
+    setImageries(imageries);
+  });
+
+  const { labelCollection, scene } = useCesium();
+  const isLabelCollectionInitialized = useRef(false);
+  const labels = useMemo(() => {
+    return labelCollection ?? (scene ? new LabelCollection({ scene }) : undefined);
+  }, [scene, labelCollection]);
+  useEffect(() => {
+    if (!labelCollection && scene && !isLabelCollectionInitialized.current) {
+      scene.primitives.add(labels);
+      isLabelCollectionInitialized.current = true;
+    }
+  }, [labelCollection, labels, scene]);
+  const labelsToUpdateRef = useRef(0);
+  usePreRender(scene => {
+    assertType<
+      LabelCollection & {
+        _labelsToUpdate: readonly unknown[];
+      }
+    >(labels);
+    if (labels && labelsToUpdateRef.current !== labels._labelsToUpdate.length) {
+      scene.requestRender();
+      labelsToUpdateRef.current = labels._labelsToUpdate.length;
+    }
+  });
+
+  useEffect(() => {
+    return () => {
+      if (scene?.isDestroyed()) return;
+      scene?.requestRender();
+    };
+  }, [scene]);
+
+  return (
+    <>
+      <LabelImageryLayer
+        ref={setRef}
+        url="https://cyberjapandata.gsi.go.jp/xyz/optimal_bvmap-v1/{z}/{x}/{y}.pbf"
+        tileWidth={1024}
+        tileHeight={1024}
+        maximumLevel={17}
+        minimumDataLevel={4}
+        maximumDataLevel={16}
+      />
+      {imageryProvider != null && (
+        <LabelImageryCollection
+          imageryProvider={imageryProvider}
+          imageriesAtom={imageriesAtom}
+          style={style}
+          labelCollection={labels}
+        />
+      )}
+    </>
+  );
+};

package/src/engines/Cesium/core/labels/JapanGSIOptimalBVmapVectorMapLabel/getAnnotationType.ts

@@ -0,0 +1,117 @@
+import { fromPairs } from "lodash-es";
+
+const annotationTypes = {
+  municipalities: [
+    110, // 市区町村
+    140, // 都道府県
+  ],
+  towns: [
+    120, // 飛び地
+    130, // 郡
+    210, // 公称（町字名）
+    220, // 集落名称（通称）
+    800, // 居住地名（大字・町・丁目）
+  ],
+  roads: [
+    411, // 道路名
+  ],
+  railways: [
+    421, // 鉄道路線名
+  ],
+  stations: [
+    422, // 鉄道駅名
+  ],
+  landmarks: [
+    412, // 道路施設（IC、PA、道の駅等）
+    413, // 道路構造物（橋、トンネル等）
+    423, // 鉄道構造物（橋、トンネル、操車場等）
+    431, // 港湾
+    432, // 港湾施設（フェリー発着所、埠頭等）
+    441, // 空港名
+    511, // 構造物名称（高塔、煙突等）
+    521, // ダム
+    522, // 堰
+    523, // 河川・海岸施設（水門、堤防）
+    531, // 土地利用名（演習場、ゴルフ場、遊園地、建設予定地等）
+    532, // 史跡名勝天然記念物
+    533, // 漁港
+    534, // 公園
+    611, // 合同庁舎
+    612, // 国の機関（合同庁舎、矯正施設及び自衛隊を除く）
+    613, // 矯正施設（刑務所、少年院等）
+    615, // 自衛隊・米軍
+    621, // 都道府県庁、北海道の総合振興局・振興局、支庁
+    631, // 大学・大学院
+    632, // 短期大学
+    633, // 高等専門学校
+    634, // 特殊学校
+    651, // 水族館・動植物園
+    653, // 発電所
+    661, // 神社
+    662, // 寺院
+    671, // 商業施設
+    673, // 文教施設
+    681, // その他の主要・著名な建物
+    860, // 道の駅
+    870, // 公園
+    880, // 国の機関
+    881, // 地方の機関
+    882, // 保健所
+    883, // 警察
+    884, // 消防
+    885, // 学校
+    886, // 病院
+    887, // 郵便局
+    888, // 指定公共機関
+    889, // 博物館
+    890, // 老人ホーム
+    899, // その他
+  ],
+  topography: [
+    311, // 山の総称
+    312, // 山、岳、峰等
+    313, // 尖峰、丘、塚等
+    314, // 山、岳、峰等（3000m以上）
+    315, // 山、岳、峰等（1000m以上）
+    316, // 山、岳、峰等（1000m未満）
+    321, // 湖、沼、池、浦等
+    322, // 河川、用水等
+    323, // 沢、瀬、淵、瀞、谷、峡、雪渓、河原、州、滝、浜、崎、半島、尻、島等
+    331, // 高原、原、森、林、砂丘、湿原
+    332, // 岩、溶岩、崖、鍾乳洞、温泉、湧水、噴泉、噴火口、峠、坂等
+    333, // 山脈、山地、平原（ZL4-7）
+    341, // 海、湾、灘、淵、浦、瀬、海峡、瀬戸等
+    342, // 海岸、浜、半島
+    343, // 岬、鼻、崎、磯、敷等
+    344, // 海、灘
+    345, // 湾、淵、浦、瀬、海峡、瀬戸等、水道
+    346, // 半島
+    347, // 海岸、浜、洲、干潟
+    348, // 海山、海嶺、海盆等
+    351, // 群島、列島、島の総称等
+    352, // 島
+    353, // はえ、岩礁等
+    361, // 到達注記
+    810, // 山
+    820, // 湖沼
+    822, // 滝
+    830, // 高原、平原、湿原
+    831, // 温泉、泉、噴気口
+    832, // 峠
+    840, // 海峡、水道
+    841, // 湾、灘
+    842, // 海岸、浜、磯
+    843, // 岬、崎、鼻
+    850, // 島
+  ],
+};
+
+export type AnnotationType = keyof typeof annotationTypes;
+
+const typeMap: Record<number, AnnotationType | undefined> = fromPairs(
+  Object.entries(annotationTypes).flatMap(([type, codes]) => codes.map(code => [code, type])),
+);
+
+export function getAnnotationType(code: number): AnnotationType | undefined {
+  return typeMap[code];
+}

package/src/engines/Cesium/core/labels/JapanGSIOptimalBVmapVectorMapLabel/helpers.ts

@@ -0,0 +1,24 @@
+import { type Zxy } from "protomaps";
+
+import { type ImageryCoords } from "./types";
+
+export function makeKey({ x, y, level }: ImageryCoords): string {
+  return `${level}:${x}:${y}`;
+}
+
+export function getTileCoords(coords: ImageryCoords, maximumDataLevel?: number): Zxy {
+  if (maximumDataLevel != null && coords.level > maximumDataLevel) {
+    // Clamp coordinates at the maximum data level.
+    const scale = 2 ** (coords.level - maximumDataLevel);
+    return {
+      x: Math.floor(coords.x / scale),
+      y: Math.floor(coords.y / scale),
+      z: maximumDataLevel,
+    };
+  }
+  return {
+    x: coords.x,
+    y: coords.y,
+    z: coords.level,
+  };
+}

package/src/engines/Cesium/core/labels/JapanGSIOptimalBVmapVectorMapLabel/index.ts

@@ -0,0 +1,3 @@
+export * from "./getAnnotationType";
+export { type AnnotationStyle } from "./JapanGSIOptimalBVmapLabelImagery";
+export * from "./JapanGSIOptimalBVmapVectorMapLabel";

package/src/engines/Cesium/core/labels/JapanGSIOptimalBVmapVectorMapLabel/types.ts

@@ -0,0 +1,26 @@
+import { ImageryLayer as CesiumImageryLayer, type ImageryProvider } from "@cesium/engine";
+
+export interface Imagery {
+  imageryLayer: CesiumImageryLayer;
+  x: number;
+  y: number;
+  level: number;
+}
+
+export interface KeyedImagery extends Imagery {
+  key: string;
+  children?: KeyedImagery[];
+  descendants?: KeyedImagery[];
+}
+
+export interface ImageryLayerHandle {
+  imageryLayer: CesiumImageryLayer;
+  bringToFront: () => void;
+  sendToBack: () => void;
+}
+
+export interface ImageryLayerProps extends CesiumImageryLayer.ConstructorOptions {
+  imageryProvider: ImageryProvider;
+}
+
+export type ImageryCoords = Pick<Imagery, "x" | "y" | "level">;

package/src/engines/Cesium/core/labels/LabelImageryLayers.tsx

@@ -0,0 +1,39 @@
+import { isEqual } from "lodash-es";
+import { memo } from "react";
+
+import { JapanGSIOptimalBVmapVectorMapLabel } from "./JapanGSIOptimalBVmapVectorMapLabel";
+
+export interface TileLabelConfig {
+  id: string;
+  labelType: "japan_gsi_optimal_bvmap";
+  fillColor?: string;
+  outlineColor?: string;
+  style: Record<string, any>;
+}
+
+interface JapanGSIOptimalBVmapLabelImageryLayersProps {
+  tileLabels?: TileLabelConfig[];
+}
+
+const LabelImageryLayers = memo(
+  ({ tileLabels = [] }: JapanGSIOptimalBVmapLabelImageryLayersProps) => {
+    return (
+      <>
+        {tileLabels.map(label => {
+          if (!label) return null;
+          switch (label.labelType) {
+            case "japan_gsi_optimal_bvmap":
+              return <JapanGSIOptimalBVmapVectorMapLabel key={label.id} style={label.style} />;
+            default:
+              return null;
+          }
+        })}
+      </>
+    );
+  },
+  (prev, next) => isEqual(prev.tileLabels, next.tileLabels),
+);
+
+export default LabelImageryLayers;
+
+LabelImageryLayers.displayName = "LabelImageryLayers";

package/src/engines/Cesium/core/presets.ts

@@ -0,0 +1,95 @@
+import { WebMercatorTilingScheme } from "@cesium/engine";
+import {
+  ImageryProvider,
+  ArcGisMapServerImageryProvider,
+  IonImageryProvider,
+  OpenStreetMapImageryProvider,
+  IonWorldImageryStyle,
+  UrlTemplateImageryProvider,
+  DiscardEmptyTileImagePolicy,
+} from "cesium";
+
+import { JapanGSIOptimalBVmapLabelImageryProvider } from "./labels/JapanGSIOptimalBVmapVectorMapLabel/JapanGSIOptimalBVmapLabelImageryProvider";
+
+export const tiles = {
+  default: ({ cesiumIonAccessToken } = {}) =>
+    IonImageryProvider.fromAssetId(IonWorldImageryStyle.AERIAL, {
+      accessToken: cesiumIonAccessToken,
+    }).catch(console.error),
+  default_label: ({ cesiumIonAccessToken } = {}) =>
+    IonImageryProvider.fromAssetId(IonWorldImageryStyle.AERIAL_WITH_LABELS, {
+      accessToken: cesiumIonAccessToken,
+    }).catch(console.error),
+  default_road: ({ cesiumIonAccessToken } = {}) =>
+    IonImageryProvider.fromAssetId(IonWorldImageryStyle.ROAD, {
+      accessToken: cesiumIonAccessToken,
+    }).catch(console.error),
+  stamen_watercolor: () =>
+    new OpenStreetMapImageryProvider({
+      url: "https://stamen-tiles.a.ssl.fastly.net/watercolor/",
+      credit: "Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA.",
+      fileExtension: "jpg",
+    }),
+  stamen_toner: () =>
+    new OpenStreetMapImageryProvider({
+      url: "https://stamen-tiles.a.ssl.fastly.net/toner/",
+      credit: "Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA.",
+    }),
+  open_street_map: () =>
+    new OpenStreetMapImageryProvider({
+      url: "https://a.tile.openstreetmap.org/",
+      credit:
+        "Copyright: Tiles © Esri — Source: Esri, DeLorme, NAVTEQ, USGS, Intermap, iPC, NRCAN, Esri Japan, METI, Esri China (Hong Kong), Esri (Thailand), TomTom, 2012",
+    }),
+  esri_world_topo: () =>
+    ArcGisMapServerImageryProvider.fromUrl(
+      "https://services.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer",
+      {
+        credit:
+          "Copyright: Tiles © Esri — Esri, DeLorme, NAVTEQ, TomTom, Intermap, iPC, USGS, FAO, NPS, NRCAN, GeoBase, Kadaster NL, Ordnance Survey, Esri Japan, METI, Esri China (Hong Kong), and the GIS User Communit",
+        enablePickFeatures: false,
+      },
+    ).catch(console.error),
+  black_marble: ({ cesiumIonAccessToken } = {}) =>
+    IonImageryProvider.fromAssetId(3812, { accessToken: cesiumIonAccessToken }).catch(
+      console.error,
+    ),
+  japan_gsi_standard: () =>
+    new OpenStreetMapImageryProvider({
+      url: "https://cyberjapandata.gsi.go.jp/xyz/std/",
+    }),
+  url: ({ url, heatmap, tile_zoomLevel } = {}) =>
+    url
+      ? new UrlTemplateImageryProvider({
+          url,
+          tileDiscardPolicy: heatmap ? new DiscardEmptyTileImagePolicy() : undefined,
+          minimumLevel: tile_zoomLevel?.[0],
+          maximumLevel: tile_zoomLevel?.[1],
+        })
+      : null,
+} as {
+  [key: string]: (opts?: {
+    url?: string;
+    cesiumIonAccessToken?: string;
+    heatmap?: boolean;
+    tile_zoomLevel?: number[];
+  }) => Promise<ImageryProvider> | ImageryProvider | null;
+};
+
+export const labelTiles = {
+  japan_gsi_optimal_bvmap: (params: {
+    url: string;
+    minimumLevel?: number;
+    maximumLevel?: number;
+    minimumDataLevel: number;
+    maximumDataLevel: number;
+  }) =>
+    new JapanGSIOptimalBVmapLabelImageryProvider({
+      url: params.url,
+      tilingScheme: new WebMercatorTilingScheme(),
+      tileWidth: 256,
+      tileHeight: 256,
+      minimumDataLevel: params.minimumDataLevel,
+      maximumDataLevel: params.maximumDataLevel,
+    }),
+};

package/src/engines/Cesium/helpers/createUniforms.ts

@@ -0,0 +1,64 @@
+import { groupBy } from "lodash-es";
+import { type RequireExactlyOne } from "type-fest";
+
+interface Stage {
+  uniforms: Record<string, unknown>;
+}
+
+type Entry<Uniforms> = RequireExactlyOne<
+  {
+    stage: Stage;
+    stages: readonly Stage[];
+    uniforms: ReadonlyArray<keyof Uniforms | { [K in keyof Uniforms]?: string }>;
+  },
+  "stage" | "stages"
+>;
+
+interface Handler {
+  name: string;
+  get: () => unknown;
+  set: (value: unknown) => void;
+}
+
+function makeHandler(source: string, target: string, stages: readonly Stage[]): Handler {
+  return {
+    name: source,
+    get: () => stages[0].uniforms[target],
+    set: (value: unknown) => {
+      stages.forEach(stage => {
+        stage.uniforms[target] = value;
+      });
+    },
+  };
+}
+
+export function createUniforms<Uniforms extends object>(
+  entries: ReadonlyArray<Entry<Uniforms>>,
+): Uniforms {
+  const handlers = groupBy(
+    entries.flatMap(({ stage, stages, uniforms }) =>
+      uniforms.flatMap(uniform =>
+        typeof uniform === "string"
+          ? [makeHandler(uniform, uniform, stage != null ? [stage] : stages)]
+          : Object.entries(uniform).map(([source, target]) =>
+              makeHandler(source, target, stage != null ? [stage] : stages),
+            ),
+      ),
+    ),
+    ({ name }) => name,
+  );
+
+  const uniforms = {};
+  Object.entries(handlers).forEach(([name, handlers]) => {
+    Object.defineProperty(uniforms, name, {
+      get: () => handlers[0].get(),
+      set: (value: unknown) => {
+        handlers.forEach(handler => {
+          handler.set(value);
+        });
+      },
+    });
+  });
+
+  return uniforms as Uniforms;
+}

package/src/engines/Cesium/helpers/sphericalHaromic.test.ts

@@ -0,0 +1,33 @@
+import { Cartesian3 } from "cesium";
+import { expect, test } from "vitest";
+
+import { arrayToCartecian3 } from "./sphericalHaromic";
+
+test("arrayToCartecian3", () => {
+  expect(
+    arrayToCartecian3(
+      [
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+        [1, 1, 1],
+      ],
+      2,
+    ),
+  ).toEqual([
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+    new Cartesian3(2, 2, 2),
+  ]);
+});

package/src/engines/Cesium/helpers/sphericalHaromic.ts

@@ -0,0 +1,27 @@
+import { Cartesian3 } from "cesium";
+
+const sphericalHarmonicCoefficientsScratch = [
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+  new Cartesian3(),
+];
+
+export const arrayToCartecian3 = (
+  sphericalHarmonicCoefficients: [x: number, y: number, z: number][] | undefined,
+  intensity: number | undefined,
+) =>
+  sphericalHarmonicCoefficients?.length === 9
+    ? sphericalHarmonicCoefficients.map((cartesian, index) =>
+        Cartesian3.multiplyByScalar(
+          new Cartesian3(...cartesian),
+          intensity ?? 1.0,
+          sphericalHarmonicCoefficientsScratch[index],
+        ),
+      )
+    : undefined;