@geode/opengeodeweb-front 9.9.0 → 9.10.0-rc.2

package/internal_stores/mesh/edges.js

@@ -0,0 +1,106 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
+
+export function useMeshEdgesStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+
+  /** Getters **/
+  function edgesVisibility(id) {
+    return dataStyleStore.styles[id].edges.visibility
+  }
+  function edgesActiveColoring(id) {
+    return dataStyleStore.styles[id].edges.coloring.active
+  }
+  function edgesColor(id) {
+    return dataStyleStore.styles[id].edges.coloring.color
+  }
+  function edgesSize(id) {
+    return dataStyleStore.styles[id].edges.size
+  }
+
+  /** Actions **/
+  function setEdgesVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: mesh_edges_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].edges.visibility = visibility
+          console.log(
+            "setEdgesVisibility",
+            dataStyleStore.styles[id].edges.visibility,
+          )
+        },
+      },
+    )
+  }
+  function setEdgesActiveColoring(id, type) {
+    if (type == "color")
+      setEdgesColor(id, dataStyleStore.styles[id].edges.coloring.color)
+    else if (type == "vertex") {
+      const vertex = dataStyleStore.styles[id].edges.coloring.vertex
+      if (vertex !== null) setEdgesVertexAttribute(id, vertex)
+    } else if (type == "edges") {
+      const edges = dataStyleStore.styles[id].edges.coloring.edges
+      if (edges !== null) setEdgesEdgeAttribute(id, edges)
+    } else throw new Error("Unknown edges coloring type: " + type)
+    dataStyleStore.styles[id].edges.coloring.active = type
+    console.log(
+      "setEdgesActiveColoring",
+      dataStyleStore.styles[id].edges.coloring.active,
+    )
+  }
+
+  function setEdgesColor(id, color) {
+    viewer_call(
+      {
+        schema: mesh_edges_schemas.color,
+        params: { id, color },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].edges.coloring.color = color
+          console.log(
+            "setEdgesColor",
+            dataStyleStore.styles[id].edges.coloring.color,
+          )
+        },
+      },
+    )
+  }
+  function setEdgesSize(id, size) {
+    viewer_call(
+      {
+        schema: mesh_edges_schemas.size,
+        params: { id, size },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].edges.size = size
+          console.log("setEdgesSize", dataStyleStore.styles[id].edges.size)
+        },
+      },
+    )
+  }
+
+  function applyEdgesStyle(id, style) {
+    setEdgesVisibility(id, style.visibility)
+    setEdgesActiveColoring(id, style.coloring.active)
+    // setEdgesSize(id, style.size);
+  }
+
+  return {
+    edgesVisibility,
+    edgesActiveColoring,
+    edgesColor,
+    edgesSize,
+    setEdgesVisibility,
+    setEdgesActiveColoring,
+    setEdgesColor,
+    setEdgesSize,
+    applyEdgesStyle,
+  }
+}

package/internal_stores/mesh/index.js

@@ -0,0 +1,50 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { useMeshPointsStyle } from "./points.js"
+import { useMeshEdgesStyle } from "./edges.js"
+import { useMeshPolygonsStyle } from "./polygons.js"
+import { useMeshPolyhedraStyle } from "./polyhedra.js"
+
+export default function useMeshStyle() {
+  const dataStyleStore = useDataStyleStore()
+  const pointsStyleStore = useMeshPointsStyle()
+  const edgesStyleStore = useMeshEdgesStyle()
+  const polygonsStyleStore = useMeshPolygonsStyle()
+  const polyhedraStyleStore = useMeshPolyhedraStyle()
+
+  function setMeshVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.mesh.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].visibility = visibility
+          console.log("setMeshVisibility", dataStyleStore.styles[id].visibility)
+        },
+      },
+    )
+  }
+
+  function applyMeshDefaultStyle(id) {
+    const id_style = dataStyleStore.styles[id]
+    for (const [key, value] of Object.entries(id_style)) {
+      if (key == "visibility") setMeshVisibility(id, value)
+      else if (key == "points") pointsStyleStore.applyPointsStyle(id, value)
+      else if (key == "edges") edgesStyleStore.applyEdgesStyle(id, value)
+      else if (key == "polygons")
+        polygonsStyleStore.applyPolygonsStyle(id, value)
+      else if (key == "polyhedra")
+        polyhedraStyleStore.applyPolyhedraStyle(id, value)
+    }
+  }
+
+  return {
+    setMeshVisibility,
+    applyMeshDefaultStyle,
+    ...useMeshPointsStyle(),
+    ...useMeshEdgesStyle(),
+    ...useMeshPolygonsStyle(),
+    ...useMeshPolyhedraStyle(),
+  }
+}

package/internal_stores/mesh/points.js

@@ -0,0 +1,131 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
+
+export function useMeshPointsStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+
+  /** Getters **/
+  function pointsVisibility(id) {
+    return dataStyleStore.styles[id].points.visibility
+  }
+  function pointsActiveColoring(id) {
+    return dataStyleStore.styles[id].points.coloring.active
+  }
+  function pointsColor(id) {
+    return dataStyleStore.styles[id].points.coloring.color
+  }
+  function pointsVertexAttribute(id) {
+    return dataStyleStore.styles[id].points.coloring.vertex
+  }
+  function pointsSize(id) {
+    return dataStyleStore.styles[id].points.size
+  }
+
+  /** Actions **/
+  function setPointsVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: mesh_points_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.visibility = visibility
+          console.log(
+            "setPointsVisibility",
+            dataStyleStore.styles[id].points.visibility,
+          )
+        },
+      },
+    )
+  }
+
+  function setPointsColor(id, color) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.color,
+        params: { id, color },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.coloring.color = color
+          console.log(
+            "setPointsColor",
+            dataStyleStore.styles[id].points.coloring.color,
+          )
+        },
+      },
+    )
+  }
+  function setPointsVertexAttribute(id, vertex_attribute) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.vertex_attribute,
+        params: { id, ...vertex_attribute },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.coloring.vertex = vertex_attribute
+          console.log(
+            "setPointsVertexAttribute",
+            dataStyleStore.styles[id].points.coloring.vertex,
+          )
+        },
+      },
+    )
+  }
+  function setPointsSize(id, size) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.mesh.points.size,
+        params: { id, size },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.size = size
+          console.log("setPointsSize", dataStyleStore.styles[id].points.size)
+        },
+      },
+    )
+  }
+
+  function setPointsActiveColoring(id, type) {
+    if (type == "color")
+      dataStyleStore.setPointsColor(
+        id,
+        dataStyleStore.styles[id].points.coloring.color,
+      )
+    else if (type == "vertex") {
+      const vertex = dataStyleStore.styles[id].points.coloring.vertex
+      if (vertex !== null) dataStyleStore.setPointsVertexAttribute(id, vertex)
+    } else throw new Error("Unknown edges coloring type: " + type)
+    dataStyleStore.styles[id].points.coloring.active = type
+    console.log(
+      "setPointsActiveColoring",
+      dataStyleStore.styles[id].points.coloring.active,
+    )
+  }
+
+  function applyPointsStyle(id, style) {
+    setPointsVisibility(id, style.visibility)
+    setPointsActiveColoring(id, style.coloring.active)
+    setPointsSize(id, style.size)
+  }
+
+  return {
+    pointsVisibility,
+    pointsActiveColoring,
+    pointsColor,
+    pointsVertexAttribute,
+    pointsSize,
+    setPointsVisibility,
+    setPointsActiveColoring,
+    setPointsColor,
+    setPointsVertexAttribute,
+    setPointsSize,
+    applyPointsStyle,
+  }
+}
+
+export default useMeshPointsStyle

package/internal_stores/mesh/polygons.js

@@ -0,0 +1,159 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
+
+export function useMeshPolygonsStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+
+  /** Getters **/
+  function polygonsVisibility(id) {
+    return dataStyleStore.styles[id].polygons.visibility
+  }
+  function polygonsActiveColoring(id) {
+    return dataStyleStore.styles[id].polygons.coloring.active
+  }
+  function polygonsColor(id) {
+    return dataStyleStore.styles[id].polygons.coloring.color
+  }
+  function polygonsTextures(id) {
+    return dataStyleStore.styles[id].polygons.coloring.textures
+  }
+  function polygonsPolygonAttribute(id) {
+    return dataStyleStore.styles[id].polygons.coloring.polygon
+  }
+  function polygonsVertexAttribute(id) {
+    return dataStyleStore.styles[id].polygons.coloring.vertex
+  }
+
+  /** Actions **/
+  function setPolygonsVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: mesh_polygons_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polygons.visibility = visibility
+          console.log(
+            "setPolygonsVisibility",
+            dataStyleStore.styles[id].polygons.visibility,
+          )
+        },
+      },
+    )
+  }
+  function setPolygonsActiveColoring(id, type) {
+    console.log("setPolygonsActiveColoring", id, type)
+    if (type == "color") {
+      setPolygonsColor(id, dataStyleStore.styles[id].polygons.coloring.color)
+    } else if (type == "textures") {
+      const textures = dataStyleStore.styles[id].polygons.coloring.textures
+      if (textures !== null) setPolygonsTextures(id, textures)
+    } else if (type == "vertex") {
+      const vertex = dataStyleStore.styles[id].polygons.coloring.vertex
+      if (vertex !== null) {
+        console.log("vertex", vertex)
+        setPolygonsVertexAttribute(id, vertex)
+      }
+    } else if (type == "polygon") {
+      const polygon = dataStyleStore.styles[id].polygons.coloring.polygon
+      if (polygon !== null) setPolygonsPolygonAttribute(id, polygon)
+    } else throw new Error("Unknown polygons coloring type: " + type)
+    dataStyleStore.styles[id].polygons.coloring.active = type
+    console.log(
+      "setPolygonsActiveColoring",
+      dataStyleStore.styles[id].polygons.coloring.active,
+    )
+  }
+  function setPolygonsColor(id, color) {
+    viewer_call(
+      {
+        schema: mesh_polygons_schemas.color,
+        params: { id, color },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polygons.coloring.color = color
+          console.log(
+            "setPolygonsColor",
+            dataStyleStore.styles[id].polygons.coloring.color,
+          )
+        },
+      },
+    )
+  }
+  function setPolygonsTextures(id, textures) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.mesh.apply_textures,
+        params: { id, textures },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polygons.coloring.textures = textures
+          console.log(
+            "setPolygonsTextures",
+            dataStyleStore.styles[id].polygons.coloring.textures,
+          )
+        },
+      },
+    )
+  }
+  function setPolygonsVertexAttribute(id, vertex_attribute) {
+    viewer_call(
+      {
+        schema: mesh_polygons_schemas.vertex_attribute,
+        params: { id, ...vertex_attribute },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polygons.coloring.vertex = vertex_attribute
+          console.log(
+            "setPolygonsVertexAttribute",
+            dataStyleStore.styles[id].polygons.coloring.vertex,
+          )
+        },
+      },
+    )
+  }
+  function setPolygonsPolygonAttribute(id, polygon_attribute) {
+    viewer_call(
+      {
+        schema: mesh_polygons_schemas.polygon_attribute,
+        params: { id, ...polygon_attribute },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polygons.coloring.polygon =
+            polygon_attribute
+          console.log(
+            "setPolygonsPolygonAttribute",
+            dataStyleStore.styles[id].polygons.coloring.polygon,
+          )
+        },
+      },
+    )
+  }
+
+  function applyPolygonsStyle(id, style) {
+    setPolygonsVisibility(id, style.visibility)
+    setPolygonsActiveColoring(id, style.coloring.active)
+  }
+
+  return {
+    polygonsVisibility,
+    polygonsActiveColoring,
+    polygonsColor,
+    polygonsTextures,
+    polygonsPolygonAttribute,
+    polygonsVertexAttribute,
+    setPolygonsVisibility,
+    setPolygonsActiveColoring,
+    setPolygonsColor,
+    setPolygonsTextures,
+    setPolygonsVertexAttribute,
+    setPolygonsPolygonAttribute,
+    applyPolygonsStyle,
+  }
+}

package/internal_stores/mesh/polyhedra.js

@@ -0,0 +1,136 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
+
+export function useMeshPolyhedraStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+
+  /** Getters **/
+  function polyhedraVisibility(id) {
+    return dataStyleStore.styles[id].polyhedra.visibility
+  }
+  function polyhedraActiveColoring(id) {
+    return dataStyleStore.styles[id].polyhedra.coloring.active
+  }
+  function polyhedraColor(id) {
+    return dataStyleStore.styles[id].polyhedra.coloring.color
+  }
+  function polyhedraVertexAttribute(id) {
+    return dataStyleStore.styles[id].polyhedra.coloring.vertex
+  }
+  function polyhedraPolygonAttribute(id) {
+    return dataStyleStore.styles[id].polyhedra.coloring.polygon
+  }
+  function polyhedraPolyhedronAttribute(id) {
+    return dataStyleStore.styles[id].polyhedra.coloring.polyhedron
+  }
+
+  /** Actions **/
+  function setPolyhedraVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: mesh_polyhedra_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polyhedra.visibility = visibility
+          console.log(
+            "setPolyhedraVisibility",
+            dataStyleStore.styles[id].polyhedra.visibility,
+          )
+        },
+      },
+    )
+  }
+  function setPolyhedraActiveColoring(id, type) {
+    if (type == "color")
+      setPolyhedraColor(id, dataStyleStore.styles[id].polyhedra.coloring.color)
+    else if (type == "vertex") {
+      const vertex = dataStyleStore.styles[id].polyhedra.coloring.vertex
+      if (vertex !== null) setPolyhedraVertexAttribute(id, vertex)
+    } else if (type == "polyhedron") {
+      const polyhedron = dataStyleStore.styles[id].polyhedra.coloring.polyhedron
+      if (polyhedron !== null) setPolyhedraPolyhedronAttribute(id, polyhedron)
+    } else throw new Error("Unknown polyhedra coloring type: " + type)
+    dataStyleStore.styles[id].polyhedra.coloring.active = type
+    console.log(
+      "setPolyhedraActiveColoring",
+      dataStyleStore.styles[id].polyhedra.coloring.active,
+    )
+  }
+  function setPolyhedraColor(id, color) {
+    viewer_call(
+      {
+        schema: mesh_polyhedra_schemas.color,
+        params: { id, color },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polyhedra.coloring.color = color
+          console.log(
+            "setPolyhedraColor",
+            dataStyleStore.styles[id].polyhedra.coloring.color,
+          )
+        },
+      },
+    )
+  }
+
+  function setPolyhedraVertexAttribute(id, vertex_attribute) {
+    viewer_call(
+      {
+        schema: mesh_polyhedra_schemas.vertex_attribute,
+        params: { id, ...vertex_attribute },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polyhedra.coloring.vertex = vertex_attribute
+          console.log(
+            "setPolyhedraVertexAttribute",
+            dataStyleStore.styles[id].polyhedra.coloring.vertex,
+          )
+        },
+      },
+    )
+  }
+
+  function setPolyhedraPolyhedronAttribute(id, polyhedron_attribute) {
+    viewer_call(
+      {
+        schema: mesh_polyhedra_schemas.polyhedron_attribute,
+        params: { id, ...polyhedron_attribute },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].polyhedra.coloring.polyhedron =
+            polyhedron_attribute
+          console.log(
+            "setPolyhedraPolyhedronAttribute",
+            dataStyleStore.styles[id].polyhedra.coloring.polyhedron,
+          )
+        },
+      },
+    )
+  }
+
+  function applyPolyhedraStyle(id, style) {
+    setPolyhedraVisibility(id, style.visibility)
+    setPolyhedraActiveColoring(id, style.coloring.active)
+  }
+
+  return {
+    polyhedraVisibility,
+    polyhedraActiveColoring,
+    polyhedraColor,
+    polyhedraVertexAttribute,
+    polyhedraPolygonAttribute,
+    polyhedraPolyhedronAttribute,
+    setPolyhedraVisibility,
+    setPolyhedraActiveColoring,
+    setPolyhedraColor,
+    setPolyhedraVertexAttribute,
+    setPolyhedraPolyhedronAttribute,
+    applyPolyhedraStyle,
+  }
+}

package/internal_stores/model/blocks.js

@@ -0,0 +1,60 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import _ from "lodash"
+const blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
+
+export function useBlocksStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
+
+  /** Getters **/
+  function blockVisibility(id, block_id) {
+    return dataStyleStore.styles[id].blocks[block_id].visibility
+  }
+
+  /** Actions **/
+  function setBlockVisibility(id, block_ids, visibility) {
+    const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
+    viewer_call(
+      {
+        schema: blocks_schemas.visibility,
+        params: { id, block_ids: block_flat_indexes, visibility },
+      },
+      {
+        response_function: () => {
+          for (const block_id of block_ids) {
+            if (!dataStyleStore.styles[id].blocks[block_id])
+              dataStyleStore.styles[id].blocks[block_id] = {}
+            dataStyleStore.styles[id].blocks[block_id].visibility = visibility
+          }
+          console.log("setBlockVisibility", block_ids, visibility)
+        },
+      },
+    )
+  }
+
+  function setBlocksDefaultStyle(id) {
+    const block_ids = dataBaseStore.getBlocksUuids(id)
+    setBlockVisibility(
+      id,
+      block_ids,
+      dataStyleStore.styles[id].blocks.visibility,
+    )
+  }
+
+  function applyBlocksStyle(id) {
+    const blocks = dataStyleStore.styles[id].blocks
+    for (const [block_id, style] of Object.entries(blocks)) {
+      setBlockVisibility(id, [block_id], style.visibility)
+    }
+  }
+
+  return {
+    blockVisibility,
+    setBlocksDefaultStyle,
+    setBlockVisibility,
+    applyBlocksStyle,
+  }
+}
+
+export default useBlocksStyle

package/internal_stores/model/corners.js

@@ -0,0 +1,63 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const corners_schemas = viewer_schemas.opengeodeweb_viewer.model.corners
+
+export function useCornersStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
+
+  /** Getters **/
+  function cornerVisibility(id, corner_id) {
+    return dataStyleStore.styles[id].corners[corner_id].visibility
+  }
+
+  /** Actions **/
+  function setCornerVisibility(id, corner_ids, visibility) {
+    const corner_flat_indexes = dataBaseStore.getFlatIndexes(id, corner_ids)
+    viewer_call(
+      {
+        schema: corners_schemas.visibility,
+        params: { id, block_ids: corner_flat_indexes, visibility },
+      },
+      {
+        response_function: () => {
+          for (const corner_id of corner_ids) {
+            if (!dataStyleStore.styles[id].corners[corner_id])
+              dataStyleStore.styles[id].corners[corner_id] = {}
+            dataStyleStore.styles[id].corners[corner_id].visibility = visibility
+          }
+          console.log("setCornerVisibility", corner_ids, visibility)
+        },
+      },
+    )
+  }
+
+  function setCornersDefaultStyle(id) {
+    const corner_ids = dataBaseStore.getCornersUuids(id)
+    console.log(
+      "dataStyleStore.styles[id].corners.visibility",
+      dataStyleStore.styles[id].corners.visibility,
+    )
+    setCornerVisibility(
+      id,
+      corner_ids,
+      dataStyleStore.styles[id].corners.visibility,
+    )
+  }
+
+  function applyCornersStyle(id) {
+    const corners = dataStyleStore.styles[id].corners
+    for (const [corner_id, style] of Object.entries(corners)) {
+      setCornerVisibility(id, [corner_id], style.visibility)
+    }
+  }
+
+  return {
+    cornerVisibility,
+    setCornersDefaultStyle,
+    setCornerVisibility,
+    applyCornersStyle,
+  }
+}
+
+export default useCornersStyle