@geode/opengeodeweb-front 10.2.1 → 10.3.0

package/internal/stores/data_style/mesh/polygons/polygon.js

@@ -0,0 +1,145 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshPolygonsCommonStyle } from "./common"
+
+// Local constants
+const meshPolygonsPolygonAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.polygon
+
+export function useMeshPolygonsPolygonAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+
+  function meshPolygonsPolygonAttribute(id) {
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).polygon
+  }
+
+  async function updateMeshPolygonsPolygonAttribute(id) {
+    const name = meshPolygonsPolygonAttributeName(id)
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    await meshPolygonsPolygonAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshPolygonsPolygonAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshPolygonsPolygonAttributeStoredConfig(id, name) {
+    const storedConfigs = meshPolygonsPolygonAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshPolygonsPolygonAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshPolygonsPolygonAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshPolygonsPolygonAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshPolygonsPolygonAttributeName(id) {
+    return meshPolygonsPolygonAttribute(id).name
+  }
+  function setMeshPolygonsPolygonAttributeName(id, name) {
+    return viewerStore.request(
+      meshPolygonsPolygonAttributeSchemas.name,
+      { id, name },
+      {
+        response_function: () => {
+          meshPolygonsPolygonAttribute(id).name = name
+          console.log(
+            setMeshPolygonsPolygonAttributeName.name,
+            { id },
+            meshPolygonsPolygonAttributeName(id),
+          )
+        },
+      },
+    )
+  }
+  function meshPolygonsPolygonAttributeRange(id) {
+    const name = meshPolygonsPolygonAttributeName(id)
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    const { minimum, maximum } = storedConfig
+    console.log(
+      meshPolygonsPolygonAttributeRange.name,
+      { id },
+      { minimum, maximum },
+    )
+    return [minimum, maximum]
+  }
+  async function setMeshPolygonsPolygonAttributeRange(id, minimum, maximum) {
+    console.log(setMeshPolygonsPolygonAttributeRange.name, {
+      id,
+      minimum,
+      maximum,
+    })
+    const name = meshPolygonsPolygonAttributeName(id)
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshPolygonsPolygonAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshPolygonsPolygonAttributeRange.name,
+            { id },
+            meshPolygonsPolygonAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolygonsPolygonAttributeColorMap(id) {
+    const name = meshPolygonsPolygonAttributeName(id)
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    const { colorMap } = storedConfig
+    return colorMap
+  }
+  function setMeshPolygonsPolygonAttributeColorMap(id, colorMap) {
+    const name = meshPolygonsPolygonAttributeName(id)
+    const storedConfig = meshPolygonsPolygonAttributeStoredConfig(id, name)
+    const points = getRGBPointsFromPreset(colorMap)
+    const { minimum, maximum } = storedConfig
+    return viewerStore.request(
+      meshPolygonsPolygonAttributeSchemas.color_map,
+      { id, points, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.colorMap = colorMap
+          console.log(
+            setMeshPolygonsPolygonAttributeColorMap.name,
+            { id },
+            meshPolygonsPolygonAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolygonsPolygonAttributeName,
+    meshPolygonsPolygonAttributeRange,
+    meshPolygonsPolygonAttributeColorMap,
+    setMeshPolygonsPolygonAttributeName,
+    setMeshPolygonsPolygonAttributeRange,
+    setMeshPolygonsPolygonAttributeColorMap,
+    updateMeshPolygonsPolygonAttribute,
+  }
+}

package/internal/stores/data_style/mesh/polygons/textures.js

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolygonsCommonStyle } from "./common"
+
+// Local constants
+const meshPolygonsTexturesSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.apply_textures
+
+export function useMeshPolygonsTexturesStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+
+  function meshPolygonsTextures(id) {
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).textures
+  }
+  function setMeshPolygonsTextures(id, textures) {
+    return viewerStore.request(
+      meshPolygonsTexturesSchemas,
+      { id, textures },
+      {
+        response_function: () => {
+          meshPolygonsCommonStyle.meshPolygonsColoring(id).textures = textures
+          console.log(
+            setMeshPolygonsTextures.name,
+            { id },
+            meshPolygonsTextures(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolygonsTextures,
+    setMeshPolygonsTextures,
+  }
+}

package/internal/stores/data_style/mesh/polygons/vertex.js

@@ -0,0 +1,153 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshPolygonsCommonStyle } from "./common"
+
+// Local constants
+const meshPolygonsVertexAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.attribute.vertex
+
+export function useMeshPolygonsVertexAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+
+  function meshPolygonsVertexAttribute(id) {
+    return meshPolygonsCommonStyle.meshPolygonsColoring(id).vertex
+  }
+
+  async function updateMeshPolygonsVertexAttribute(id) {
+    const name = meshPolygonsVertexAttributeName(id)
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    await meshPolygonsVertexAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshPolygonsVertexAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshPolygonsVertexAttributeStoredConfig(id, name) {
+    const storedConfigs = meshPolygonsVertexAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshPolygonsVertexAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshPolygonsVertexAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshPolygonsVertexAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshPolygonsVertexAttributeName(id) {
+    console.log(
+      meshPolygonsVertexAttributeName.name,
+      { id },
+      meshPolygonsVertexAttribute(id),
+    )
+    return meshPolygonsVertexAttribute(id).name
+  }
+  function setMeshPolygonsVertexAttributeName(id, name) {
+    console.log(setMeshPolygonsVertexAttributeName.name, { id, name })
+    return viewerStore.request(
+      meshPolygonsVertexAttributeSchemas.name,
+      { id, name },
+      {
+        response_function: async () => {
+          meshPolygonsVertexAttribute(id).name = name
+          const { minimum, maximum, colorMap } =
+            meshPolygonsVertexAttributeStoredConfig(id, name)
+          await setMeshPolygonsVertexAttributeRange(id, minimum, maximum)
+          await setMeshPolygonsVertexAttributeColorMap(id, colorMap)
+          console.log(
+            setMeshPolygonsVertexAttributeName.name,
+            { id },
+            meshPolygonsVertexAttributeName(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolygonsVertexAttributeRange(id) {
+    const name = meshPolygonsVertexAttributeName(id)
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    const { minimum, maximum } = storedConfig
+    return [minimum, maximum]
+  }
+  function setMeshPolygonsVertexAttributeRange(id, minimum, maximum) {
+    const name = meshPolygonsVertexAttributeName(id)
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshPolygonsVertexAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshPolygonsVertexAttributeRange.name,
+            { id },
+            meshPolygonsVertexAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolygonsVertexAttributeColorMap(id) {
+    const name = meshPolygonsVertexAttributeName(id)
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    const { colorMap } = storedConfig
+    return colorMap
+  }
+  function setMeshPolygonsVertexAttributeColorMap(id, colorMap) {
+    const name = meshPolygonsVertexAttributeName(id)
+    const storedConfig = meshPolygonsVertexAttributeStoredConfig(id, name)
+    const points = getRGBPointsFromPreset(colorMap)
+    const { minimum, maximum } = storedConfig
+
+    console.log(setMeshPolygonsVertexAttributeColorMap.name, {
+      id,
+      minimum,
+      maximum,
+      colorMap,
+    })
+    return viewerStore.request(
+      meshPolygonsVertexAttributeSchemas.color_map,
+      { id, points, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.colorMap = colorMap
+          console.log(
+            setMeshPolygonsVertexAttributeColorMap.name,
+            { id },
+            meshPolygonsVertexAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolygonsVertexAttributeName,
+    meshPolygonsVertexAttributeRange,
+    meshPolygonsVertexAttributeColorMap,
+    setMeshPolygonsVertexAttributeName,
+    setMeshPolygonsVertexAttributeRange,
+    setMeshPolygonsVertexAttributeColorMap,
+    updateMeshPolygonsVertexAttribute,
+  }
+}

package/internal/stores/data_style/mesh/polygons/visibility.js

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolygonsCommonStyle } from "./common"
+
+// Local constants
+const meshPolygonsVisibilitySchema =
+  viewer_schemas.opengeodeweb_viewer.mesh.polygons.visibility
+
+export function useMeshPolygonsVisibilityStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolygonsCommonStyle = useMeshPolygonsCommonStyle()
+
+  function meshPolygonsVisibility(id) {
+    return meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility
+  }
+  function setMeshPolygonsVisibility(id, visibility) {
+    return viewerStore.request(
+      meshPolygonsVisibilitySchema,
+      { id, visibility },
+      {
+        response_function: () => {
+          meshPolygonsCommonStyle.meshPolygonsStyle(id).visibility = visibility
+          console.log(
+            setMeshPolygonsVisibility.name,
+            { id },
+            meshPolygonsVisibility(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolygonsVisibility,
+    setMeshPolygonsVisibility,
+  }
+}

package/internal/stores/data_style/mesh/polyhedra/color.js

@@ -0,0 +1,40 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { useMeshPolyhedraCommonStyle } from "./common"
+
+// Local constants
+const meshPolyhedraColorSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.color
+
+export function useMeshPolyhedraColorStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+
+  function meshPolyhedraColor(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color
+  }
+  function setMeshPolyhedraColor(id, color) {
+    return viewerStore.request(
+      meshPolyhedraColorSchemas,
+      { id, color },
+      {
+        response_function: () => {
+          meshPolyhedraCommonStyle.meshPolyhedraColoring(id).color = color
+          console.log(
+            setMeshPolyhedraColor.name,
+            { id },
+            JSON.stringify(meshPolyhedraColor(id)),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolyhedraColor,
+    setMeshPolyhedraColor,
+  }
+}

package/internal/stores/data_style/mesh/polyhedra/common.js

@@ -0,0 +1,23 @@
+import { useDataStyleStateStore } from "../../state"
+
+export function useMeshPolyhedraCommonStyle() {
+  const dataStyleStateStore = useDataStyleStateStore()
+
+  function meshPolyhedraStyle(id) {
+    return dataStyleStateStore.getStyle(id).polyhedra
+  }
+
+  function meshPolyhedraColoring(id) {
+    return meshPolyhedraStyle(id).coloring
+  }
+
+  function meshPolyhedraActiveColoring(id) {
+    return meshPolyhedraColoring(id).active
+  }
+
+  return {
+    meshPolyhedraStyle,
+    meshPolyhedraColoring,
+    meshPolyhedraActiveColoring,
+  }
+}

package/internal/stores/data_style/mesh/polyhedra/index.js

@@ -0,0 +1,83 @@
+// Third party imports
+
+// Local imports
+import { useMeshPolyhedraCommonStyle } from "./common"
+import { useMeshPolyhedraVisibilityStyle } from "./visibility"
+import { useMeshPolyhedraColorStyle } from "./color"
+import { useMeshPolyhedraVertexAttributeStyle } from "./vertex"
+import { useMeshPolyhedraPolyhedronAttributeStyle } from "./polyhedron"
+
+// Local constants
+
+export function useMeshPolyhedraStyle() {
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+  const meshPolyhedraVisibility = useMeshPolyhedraVisibilityStyle()
+  const meshPolyhedraColorStyle = useMeshPolyhedraColorStyle()
+  const meshPolyhedraVertexAttributeStyle =
+    useMeshPolyhedraVertexAttributeStyle()
+  const meshPolyhedraPolyhedronAttributeStyle =
+    useMeshPolyhedraPolyhedronAttributeStyle()
+
+  async function setMeshPolyhedraActiveColoring(id, type) {
+    const coloring = meshPolyhedraCommonStyle.meshPolyhedraColoring(id)
+    coloring.active = type
+    console.log(
+      setMeshPolyhedraActiveColoring.name,
+      { id },
+      meshPolyhedraCommonStyle.meshPolyhedraActiveColoring(id),
+    )
+    if (type === "color") {
+      return meshPolyhedraColorStyle.setMeshPolyhedraColor(
+        id,
+        meshPolyhedraColorStyle.meshPolyhedraColor(id),
+      )
+    } else if (type === "vertex") {
+      const name =
+        meshPolyhedraVertexAttributeStyle.meshPolyhedraVertexAttributeName(id)
+      if (name === null) {
+        return Promise.resolve()
+      }
+      return meshPolyhedraVertexAttributeStyle.setMeshPolyhedraVertexAttributeName(
+        id,
+        name,
+      )
+    } else if (type === "polyhedron") {
+      const name =
+        meshPolyhedraPolyhedronAttributeStyle.meshPolyhedraPolyhedronAttributeName(
+          id,
+        )
+      if (name === null) {
+        return Promise.resolve()
+      }
+      await meshPolyhedraPolyhedronAttributeStyle.setMeshPolyhedraPolyhedronAttributeName(
+        id,
+        name,
+      )
+    } else {
+      throw new Error("Unknown mesh polyhedra coloring type: " + type)
+    }
+  }
+
+  function applyMeshPolyhedraStyle(id) {
+    return Promise.all([
+      meshPolyhedraVisibility.setMeshPolyhedraVisibility(
+        id,
+        meshPolyhedraVisibility.meshPolyhedraVisibility(id),
+      ),
+      setMeshPolyhedraActiveColoring(
+        id,
+        meshPolyhedraCommonStyle.meshPolyhedraActiveColoring(id),
+      ),
+    ])
+  }
+
+  return {
+    setMeshPolyhedraActiveColoring,
+    applyMeshPolyhedraStyle,
+    ...meshPolyhedraCommonStyle,
+    ...meshPolyhedraVisibility,
+    ...meshPolyhedraColorStyle,
+    ...meshPolyhedraVertexAttributeStyle,
+    ...meshPolyhedraPolyhedronAttributeStyle,
+  }
+}

package/internal/stores/data_style/mesh/polyhedra/polyhedron.js

@@ -0,0 +1,139 @@
+// Third party imports
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+import { useViewerStore } from "@ogw_front/stores/viewer"
+import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
+import { useMeshPolyhedraCommonStyle } from "./common"
+
+// Local constants
+const meshPolyhedraPolyhedronAttributeSchemas =
+  viewer_schemas.opengeodeweb_viewer.mesh.polyhedra.attribute.polyhedron
+
+export function useMeshPolyhedraPolyhedronAttributeStyle() {
+  const viewerStore = useViewerStore()
+  const meshPolyhedraCommonStyle = useMeshPolyhedraCommonStyle()
+
+  function meshPolyhedraPolyhedronAttribute(id) {
+    return meshPolyhedraCommonStyle.meshPolyhedraColoring(id).polyhedron
+  }
+
+  async function updateMeshPolyhedraPolyhedronAttribute(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id)
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    await meshPolyhedraPolyhedronAttributeRange(
+      id,
+      storedConfig.minimum,
+      storedConfig.maximum,
+    )
+    await meshPolyhedraPolyhedronAttributeColorMap(id, storedConfig.colorMap)
+  }
+
+  function meshPolyhedraPolyhedronAttributeStoredConfig(id, name) {
+    const storedConfigs = meshPolyhedraPolyhedronAttribute(id).storedConfigs
+    if (name in storedConfigs) {
+      return storedConfigs[name]
+    }
+    return setMeshPolyhedraPolyhedronAttributeStoredConfig(id, name, {
+      minimum: 0,
+      maximum: 1,
+      colorMap: "Cool to Warm",
+    })
+  }
+
+  function setMeshPolyhedraPolyhedronAttributeStoredConfig(
+    id,
+    name,
+    { minimum, maximum, colorMap },
+  ) {
+    const storedConfigs = meshPolyhedraPolyhedronAttribute(id).storedConfigs
+    storedConfigs[name] = { minimum, maximum, colorMap }
+    return storedConfigs[name]
+  }
+
+  function meshPolyhedraPolyhedronAttributeName(id) {
+    return meshPolyhedraPolyhedronAttribute(id).name
+  }
+  function setMeshPolyhedraPolyhedronAttributeName(id, name) {
+    return viewerStore.request(
+      meshPolyhedraPolyhedronAttributeSchemas.name,
+      { id, name },
+      {
+        response_function: async () => {
+          meshPolyhedraPolyhedronAttribute(id).name = name
+          const { minimum, maximum, colorMap } =
+            meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+          await setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum)
+          await setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap)
+          console.log(
+            setMeshPolyhedraPolyhedronAttributeName.name,
+            { id },
+            meshPolyhedraPolyhedronAttributeName(id),
+          )
+        },
+      },
+    )
+  }
+  function meshPolyhedraPolyhedronAttributeRange(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id)
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    const { minimum, maximum } = storedConfig
+    return [minimum, maximum]
+  }
+  function setMeshPolyhedraPolyhedronAttributeRange(id, minimum, maximum) {
+    const name = meshPolyhedraPolyhedronAttributeName(id)
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    return viewerStore.request(
+      meshPolyhedraPolyhedronAttributeSchemas.scalar_range,
+      { id, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.minimum = minimum
+          storedConfig.maximum = maximum
+          console.log(
+            setMeshPolyhedraPolyhedronAttributeRange.name,
+            { id },
+            meshPolyhedraPolyhedronAttributeRange(id),
+          )
+        },
+      },
+    )
+  }
+
+  function meshPolyhedraPolyhedronAttributeColorMap(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id)
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    const { colorMap } = storedConfig
+    return colorMap
+  }
+  function setMeshPolyhedraPolyhedronAttributeColorMap(id, colorMap) {
+    const name = meshPolyhedraPolyhedronAttributeName(id)
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name)
+    const points = getRGBPointsFromPreset(colorMap)
+    const { minimum, maximum } = storedConfig
+    return viewerStore.request(
+      meshPolyhedraPolyhedronAttributeSchemas.color_map,
+      { id, points, minimum, maximum },
+      {
+        response_function: () => {
+          storedConfig.colorMap = colorMap
+          console.log(
+            setMeshPolyhedraPolyhedronAttributeColorMap.name,
+            { id },
+            meshPolyhedraPolyhedronAttributeColorMap(id),
+          )
+        },
+      },
+    )
+  }
+
+  return {
+    meshPolyhedraPolyhedronAttributeName,
+    meshPolyhedraPolyhedronAttributeRange,
+    meshPolyhedraPolyhedronAttributeColorMap,
+    setMeshPolyhedraPolyhedronAttributeName,
+    setMeshPolyhedraPolyhedronAttributeRange,
+    setMeshPolyhedraPolyhedronAttributeColorMap,
+    updateMeshPolyhedraPolyhedronAttribute,
+  }
+}