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

package/internal_stores/model/edges.js

@@ -0,0 +1,47 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const model_edges_schemas = viewer_schemas.opengeodeweb_viewer.model.edges
+
+export function useModelEdgesStyle() {
+  const dataStyleStore = useDataStyleStore()
+
+  function modelEdgesVisibility(id) {
+    return dataStyleStore.styles[id].edges.visibility
+  }
+
+  function setModelEdgesVisibility(id, visibility) {
+    if (!dataStyleStore.styles[id]) {
+      dataStyleStore.styles[id] = {}
+    }
+    if (!dataStyleStore.styles[id].edges) {
+      dataStyleStore.styles[id].edges = {}
+    }
+
+    viewer_call(
+      {
+        schema: model_edges_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].edges.visibility = visibility
+          console.log("setModelEdgesVisibility", visibility)
+        },
+      },
+    )
+  }
+
+  function applyModelEdgesStyle(id, style) {
+    setModelEdgesVisibility(id, style.visibility)
+  }
+
+  function setModelEdgesDefaultStyle(id) {
+    setModelEdgesVisibility(id, false)
+  }
+
+  return {
+    modelEdgesVisibility,
+    setModelEdgesVisibility,
+    applyModelEdgesStyle,
+    setModelEdgesDefaultStyle,
+  }
+}

package/internal_stores/model/index.js

@@ -0,0 +1,154 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { useSurfacesStyle } from "./surfaces.js"
+import { useCornersStyle } from "./corners.js"
+import { useBlocksStyle } from "./blocks.js"
+import { useLinesStyle } from "./lines.js"
+import { useModelEdgesStyle } from "./edges.js"
+import { useModelPointsStyle } from "./points.js"
+
+export default function useModelStyle() {
+  /** States **/
+  const dataBaseStore = useDataBaseStore()
+  const dataStyleStore = useDataStyleStore()
+  const cornersStyleStore = useCornersStyle()
+  const linesStyleStore = useLinesStyle()
+  const surfacesStyleStore = useSurfacesStyle()
+  const blocksStyleStore = useBlocksStyle()
+  const modelEdgesStore = useModelEdgesStyle()
+  const modelPointsStore = useModelPointsStyle()
+
+  /** Getters **/
+  function modelVisibility(id) {
+    return dataStyleStore.styles[id]?.visibility
+  }
+
+  function visibleMeshComponents(id) {
+    const visible_mesh_components = ref([])
+    const styles = dataStyleStore.styles[id]
+    if (!styles) return visible_mesh_components
+
+    Object.entries(styles.corners || {}).forEach(([corner_id, style]) => {
+      if (style.visibility) visible_mesh_components.value.push(corner_id)
+    })
+
+    Object.entries(styles.lines || {}).forEach(([line_id, style]) => {
+      if (style.visibility) visible_mesh_components.value.push(line_id)
+    })
+
+    Object.entries(styles.surfaces || {}).forEach(([surface_id, style]) => {
+      if (style.visibility) visible_mesh_components.value.push(surface_id)
+    })
+
+    Object.entries(styles.blocks || {}).forEach(([block_id, style]) => {
+      if (style.visibility) visible_mesh_components.value.push(block_id)
+    })
+
+    return visible_mesh_components
+  }
+
+  function modelMeshComponentVisibility(id, component_type, component_id) {
+    switch (component_type) {
+      case "Corner":
+        return cornersStyleStore.cornerVisibility(id, component_id)
+      case "Line":
+        return linesStyleStore.lineVisibility(id, component_id)
+      case "Surface":
+        return surfacesStyleStore.surfaceVisibility(id, component_id)
+      case "Block":
+        return blocksStyleStore.blockVisibility(id, component_id)
+      default:
+        return false
+    }
+  }
+
+  function setModelVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.model.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].visibility = visibility
+          console.log("setModelVisibility", visibility)
+        },
+      },
+    )
+  }
+
+  function setModelColor(id, color) {
+    viewer_call(
+      {
+        schema: viewer_schemas.opengeodeweb_viewer.model.color,
+        params: { id, color },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].color = color
+          console.log("setModelColor", color)
+        },
+      },
+    )
+  }
+
+  function setModelMeshComponentVisibility(
+    id,
+    component_type,
+    component_id,
+    visibility,
+  ) {
+    switch (component_type) {
+      case "Corner":
+        cornersStyleStore.setCornerVisibility(id, [component_id], visibility)
+        break
+      case "Line":
+        linesStyleStore.setLineVisibility(id, [component_id], visibility)
+        break
+      case "Surface":
+        surfacesStyleStore.setSurfaceVisibility(id, [component_id], visibility)
+        break
+      case "Block":
+        blocksStyleStore.setBlockVisibility(id, [component_id], visibility)
+        break
+    }
+  }
+
+  function applyModelDefaultStyle(id) {
+    const id_style = dataStyleStore.styles[id]
+    for (const [key, value] of Object.entries(id_style)) {
+      if (key === "visibility") setModelVisibility(id, value)
+      else if (key === "edges") modelEdgesStore.applyModelEdgesStyle(id, value)
+      else if (key === "points")
+        modelPointsStore.applyModelPointsStyle(id, value)
+    }
+  }
+
+  function setMeshComponentsDefaultStyle(id) {
+    const { mesh_components } = dataBaseStore.itemMetaDatas(id)
+    if ("Corner" in mesh_components)
+      cornersStyleStore.setCornersDefaultStyle(id)
+    if ("Line" in mesh_components) linesStyleStore.setLinesDefaultStyle(id)
+    if ("Surface" in mesh_components)
+      surfacesStyleStore.setSurfacesDefaultStyle(id)
+    if ("Block" in mesh_components) blocksStyleStore.setBlocksDefaultStyle(id)
+    modelEdgesStore.setModelEdgesDefaultStyle(id)
+    modelPointsStore.setModelPointsDefaultStyle(id)
+  }
+
+  return {
+    modelVisibility,
+    visibleMeshComponents,
+    modelMeshComponentVisibility,
+    setModelVisibility,
+    setModelColor,
+    setModelMeshComponentVisibility,
+    applyModelDefaultStyle,
+    setMeshComponentsDefaultStyle,
+    ...useSurfacesStyle(),
+    ...useCornersStyle(),
+    ...useBlocksStyle(),
+    ...useLinesStyle(),
+    ...useModelEdgesStyle(),
+    ...useModelPointsStyle(),
+  }
+}

package/internal_stores/model/lines.js

@@ -0,0 +1,81 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const lines_schemas = viewer_schemas.opengeodeweb_viewer.model.lines
+
+export function useLinesStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
+
+  /** Getters **/
+  function lineVisibility(id, line_id) {
+    return dataStyleStore.styles[id].lines[line_id].visibility
+  }
+
+  function linesColor(id) {
+    return dataStyleStore.styles[id].lines.color
+  }
+
+  /** Actions **/
+  function setLineVisibility(id, line_ids, visibility) {
+    const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
+    viewer_call(
+      {
+        schema: lines_schemas.visibility,
+        params: { id, block_ids: line_flat_indexes, visibility },
+      },
+      {
+        response_function: () => {
+          for (const line_id of line_ids) {
+            if (!dataStyleStore.styles[id].lines[line_id])
+              dataStyleStore.styles[id].lines[line_id] = {}
+            dataStyleStore.styles[id].lines[line_id].visibility = visibility
+          }
+          console.log("setLineVisibility", line_ids, visibility)
+        },
+      },
+    )
+  }
+
+  function setLineColor(id, line_ids, color) {
+    const line_flat_indexes = dataBaseStore.getFlatIndexes(id, line_ids)
+    viewer_call(
+      {
+        schema: lines_schemas.color,
+        params: { id, block_ids: line_flat_indexes, color },
+      },
+      {
+        response_function: () => {
+          for (const line_id of line_ids) {
+            if (!dataStyleStore.styles[id].lines[line_id])
+              dataStyleStore.styles[id].lines[line_id] = {}
+            dataStyleStore.styles[id].lines[line_id].color = color
+          }
+          console.log("setLineColor", line_ids, color)
+        },
+      },
+    )
+  }
+
+  function setLinesDefaultStyle(id) {
+    const line_ids = dataBaseStore.getLinesUuids(id)
+    setLineVisibility(id, line_ids, dataStyleStore.styles[id].lines.visibility)
+    setLineColor(id, line_ids, dataStyleStore.styles[id].lines.color)
+  }
+
+  function applyLinesStyle(id) {
+    const lines = dataStyleStore.styles[id].lines
+    for (const [line_id, style] of Object.entries(lines)) {
+      setLineVisibility(id, [line_id], style.visibility)
+    }
+  }
+
+  return {
+    lineVisibility,
+    linesColor,
+    setLinesDefaultStyle,
+    setLineVisibility,
+    applyLinesStyle,
+  }
+}
+
+export default useLinesStyle

package/internal_stores/model/points.js

@@ -0,0 +1,61 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const model_points_schemas = viewer_schemas.opengeodeweb_viewer.model.points
+
+export function useModelPointsStyle() {
+  const dataStyleStore = useDataStyleStore()
+
+  function modelPointsVisibility(id) {
+    return dataStyleStore.styles[id].points.visibility
+  }
+  function modelPointsSize(id) {
+    return dataStyleStore.styles[id].points.size
+  }
+
+  function setModelPointsVisibility(id, visibility) {
+    viewer_call(
+      {
+        schema: model_points_schemas.visibility,
+        params: { id, visibility },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.visibility = visibility
+          console.log("setModelPointsVisibility", visibility)
+        },
+      },
+    )
+  }
+
+  function setModelPointsSize(id, size) {
+    viewer_call(
+      {
+        schema: model_points_schemas.size,
+        params: { id, size },
+      },
+      {
+        response_function: () => {
+          dataStyleStore.styles[id].points.size = size
+          console.log("setModelPointsSize", size)
+        },
+      },
+    )
+  }
+
+  function applyModelPointsStyle(id, style) {
+    setModelPointsVisibility(id, style.visibility)
+    setModelPointsSize(id, style.size)
+  }
+
+  function setModelPointsDefaultStyle(id) {
+    setModelPointsVisibility(id, false)
+  }
+
+  return {
+    modelPointsVisibility,
+    modelPointsSize,
+    setModelPointsVisibility,
+    setModelPointsSize,
+    applyModelPointsStyle,
+    setModelPointsDefaultStyle,
+  }
+}

package/internal_stores/model/surfaces.js

@@ -0,0 +1,60 @@
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+const surfaces_schemas = viewer_schemas.opengeodeweb_viewer.model.surfaces
+
+export function useSurfacesStyle() {
+  /** State **/
+  const dataStyleStore = useDataStyleStore()
+  const dataBaseStore = useDataBaseStore()
+
+  /** Getters **/
+  function surfaceVisibility(id, surface_id) {
+    return dataStyleStore.styles[id].surfaces[surface_id].visibility
+  }
+
+  /** Actions **/
+  function setSurfaceVisibility(id, surface_ids, visibility) {
+    const surface_flat_indexes = dataBaseStore.getFlatIndexes(id, surface_ids)
+    viewer_call(
+      {
+        schema: surfaces_schemas.visibility,
+        params: { id, block_ids: surface_flat_indexes, visibility },
+      },
+      {
+        response_function: () => {
+          for (const surface_id of surface_ids) {
+            if (!dataStyleStore.styles[id].surfaces[surface_id])
+              dataStyleStore.styles[id].surfaces[surface_id] = {}
+            dataStyleStore.styles[id].surfaces[surface_id].visibility =
+              visibility
+          }
+          console.log("setSurfaceVisibility", surface_ids, visibility)
+        },
+      },
+    )
+  }
+
+  function setSurfacesDefaultStyle(id) {
+    const surface_ids = dataBaseStore.getSurfacesUuids(id)
+    setSurfaceVisibility(
+      id,
+      surface_ids,
+      dataStyleStore.styles[id].surfaces.visibility,
+    )
+  }
+
+  function applySurfacesStyle(id) {
+    const surfaces = dataStyleStore.styles[id].surfaces
+    for (const [surface_id, style] of Object.entries(surfaces)) {
+      setSurfaceVisibility(id, [surface_id], style.visibility)
+    }
+  }
+
+  return {
+    surfaceVisibility,
+    setSurfacesDefaultStyle,
+    setSurfaceVisibility,
+    applySurfacesStyle,
+  }
+}
+
+export default useSurfacesStyle

package/package.json

@@ -34,7 +34,7 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.9.0",
+  "version": "9.10.0-rc.1",
   "main": "./nuxt.config.js",
   "dependencies": {
     "@geode/opengeodeweb-back": "5.8.7",

package/stores/data_base.js

@@ -0,0 +1,148 @@
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+
+export const useDataBaseStore = defineStore("dataBase", () => {
+  const treeview_store = use_treeview_store()
+  const hybridViewerStore = useHybridViewerStore()
+
+  /** State **/
+  const db = reactive({})
+
+  /** Getters **/
+  function itemMetaDatas(id) {
+    return db[id]
+  }
+
+  function formatedMeshComponents(id) {
+    const { mesh_components } = itemMetaDatas(id)
+    const formated_mesh_components = ref([])
+
+    for (const [category, uuids] of Object.entries(mesh_components)) {
+      formated_mesh_components.value.push({
+        id: category,
+        title: category,
+        children: uuids.map((uuid) => ({
+          id: uuid,
+          title: uuid,
+          category,
+        })),
+      })
+    }
+    return formated_mesh_components.value
+  }
+
+  function meshComponentType(id, uuid) {
+    const { mesh_components } = itemMetaDatas(id)
+
+    if (mesh_components["Corner"]?.includes(uuid)) return "corner"
+    else if (mesh_components["Line"]?.includes(uuid)) return "line"
+    else if (mesh_components["Surface"]?.includes(uuid)) return "surface"
+    else if (mesh_components["Block"]?.includes(uuid)) return "block"
+    return null
+  }
+
+  /** Actions **/
+  async function addItem(
+    id,
+    value = {
+      object_type,
+      geode_object,
+      native_filename,
+      viewable_filename,
+      displayed_name,
+      vtk_js: { binary_light_viewable },
+    },
+  ) {
+    db[id] = value
+
+    if (value.object_type === "model") {
+      await fetchMeshComponents(id)
+      await fetchUuidToFlatIndexDict(id)
+    }
+    treeview_store.addItem(
+      value.geode_object,
+      value.displayed_name,
+      id,
+      value.object_type,
+    )
+
+    hybridViewerStore.addItem(id, value.vtk_js)
+  }
+
+  async function fetchMeshComponents(id) {
+    const { native_filename, geode_object } = itemMetaDatas(id)
+    await api_fetch(
+      {
+        schema: back_schemas.opengeodeweb_back.models.mesh_components,
+        params: {
+          filename: native_filename,
+          geode_object,
+        },
+      },
+      {
+        response_function: async (response) => {
+          if (response._data?.uuid_dict) {
+            db[id].mesh_components = response._data.uuid_dict
+          }
+        },
+      },
+    )
+  }
+
+  async function fetchUuidToFlatIndexDict(id) {
+    await api_fetch(
+      {
+        schema: back_schemas.opengeodeweb_back.models.vtm_component_indices,
+        params: { id },
+      },
+      {
+        response_function: async (response) => {
+          if (response._data?.uuid_to_flat_index) {
+            db[id]["uuid_to_flat_index"] = response._data.uuid_to_flat_index
+          }
+        },
+      },
+    )
+  }
+
+  function getCornersUuids(id) {
+    const { mesh_components } = itemMetaDatas(id)
+    return Object.values(mesh_components["Corner"])
+  }
+
+  function getLinesUuids(id) {
+    const { mesh_components } = itemMetaDatas(id)
+    return Object.values(mesh_components["Line"])
+  }
+  function getSurfacesUuids(id) {
+    const { mesh_components } = itemMetaDatas(id)
+    return Object.values(mesh_components["Surface"])
+  }
+  function getBlocksUuids(id) {
+    const { mesh_components } = itemMetaDatas(id)
+    return Object.values(mesh_components["Block"])
+  }
+
+  function getFlatIndexes(id, mesh_component_ids) {
+    const { uuid_to_flat_index } = itemMetaDatas(id)
+
+    const flat_indexes = mesh_component_ids.map(
+      (mesh_component_id) => uuid_to_flat_index[mesh_component_id] || null,
+    )
+    return flat_indexes.filter((index) => index !== null)
+  }
+
+  return {
+    db,
+    itemMetaDatas,
+    meshComponentType,
+    formatedMeshComponents,
+    addItem,
+    fetchUuidToFlatIndexDict,
+    fetchMeshComponents,
+    getCornersUuids,
+    getLinesUuids,
+    getSurfacesUuids,
+    getBlocksUuids,
+    getFlatIndexes,
+  }
+})

package/stores/data_style.js

@@ -0,0 +1,57 @@
+import useDataStyleState from "../internal_stores/data_style_state.js"
+import useMeshStyle from "../internal_stores/mesh/index.js"
+import useModelStyle from "../internal_stores/model/index.js"
+
+export const useDataStyleStore = defineStore("dataStyle", () => {
+  /** States **/
+  const dataStyleState = useDataStyleState()
+  const meshStyleStore = useMeshStyle()
+  const modelStyleStore = useModelStyle()
+  const dataBaseStore = useDataBaseStore()
+
+  /** Actions **/
+  function addDataStyle(id, geode_object, object_type) {
+    dataStyleState.styles[id] = getDefaultStyle(geode_object)
+
+    if (object_type === "mesh") {
+      meshStyleStore.applyMeshDefaultStyle(id)
+    } else if (object_type === "model") {
+      modelStyleStore.setMeshComponentsDefaultStyle(id)
+      modelStyleStore.applyModelDefaultStyle(id)
+    }
+  }
+
+  function setVisibility(id, visibility) {
+    const object_type = dataBaseStore.itemMetaDatas(id).object_type
+    if (object_type === "mesh") {
+      meshStyleStore.setMeshVisibility(id, visibility)
+    } else if (object_type === "model") {
+      modelStyleStore.setModelVisibility(id, visibility)
+    }
+  }
+
+  function setModelEdgesVisibility(id, visibility) {
+    modelStyleStore.setModelMeshComponentVisibility(
+      id,
+      "Edge",
+      null,
+      visibility,
+    )
+  }
+
+  function modelEdgesVisibility(id) {
+    return modelStyleStore.modelMeshComponentVisibility(id, "Edge", null)
+  }
+
+  return {
+    ...dataStyleState,
+    addDataStyle,
+    setVisibility,
+    setModelEdgesVisibility,
+    modelEdgesVisibility,
+    ...meshStyleStore,
+    ...modelStyleStore,
+  }
+})
+
+export default useDataStyleStore