test model blocks okay

Author: JulienChampagnol

components/Viewer/TreeComponent.vue

@@ -40,22 +40,42 @@
           removed_blocks,
         ] = sortMeshComponents(removed)
         if (added_corners.length > 0)
-          dataStyleStore.setCornerVisibility(props.id, added_corners, true)
+          dataStyleStore.setModelCornersVisibility(
+            props.id,
+            added_corners,
+            true,
+          )
         if (added_lines.length > 0)
-          dataStyleStore.setLineVisibility(props.id, added_lines, true)
+          dataStyleStore.setModelLinesVisibility(props.id, added_lines, true)
         if (added_surfaces.length > 0)
-          dataStyleStore.setSurfaceVisibility(props.id, added_surfaces, true)
+          dataStyleStore.setModelSurfacesVisibility(
+            props.id,
+            added_surfaces,
+            true,
+          )
         if (added_blocks.length > 0)
-          dataStyleStore.setBlockVisibility(props.id, added_blocks, true)
+          dataStyleStore.setModelBlocksVisibility(props.id, added_blocks, true)
 
         if (removed_corners.length > 0)
-          dataStyleStore.setCornerVisibility(props.id, removed_corners, false)
+          dataStyleStore.setModelCornersVisibility(
+            props.id,
+            removed_corners,
+            false,
+          )
         if (removed_lines.length > 0)
-          dataStyleStore.setLineVisibility(props.id, removed_lines, false)
+          dataStyleStore.setModelLinesVisibility(props.id, removed_lines, false)
         if (removed_surfaces.length > 0)
-          dataStyleStore.setSurfaceVisibility(props.id, removed_surfaces, false)
+          dataStyleStore.setModelSurfacesVisibility(
+            props.id,
+            removed_surfaces,
+            false,
+          )
         if (removed_blocks.length > 0)
-          dataStyleStore.setBlockVisibility(props.id, removed_blocks, false)
+          dataStyleStore.setModelBlocksVisibility(
+            props.id,
+            removed_blocks,
+            false,
+          )
       }
     },
     { immediate: true, deep: true },

internal_stores/mesh/edges.js

@@ -1,5 +1,11 @@
+// Node.js imports
+
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local imports
+
+// Local constants
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 
 export function useMeshEdgesStyle() {
@@ -42,7 +48,9 @@ export function useMeshEdgesStyle() {
       //   return setEdgesVertexAttribute(id, coloring.vertex)
       // } else if (type == "edges" && coloring.edges !== null) {
       //   return setEdgesEdgeAttribute(id, coloring.edges)
-    } else throw new Error("Unknown edges coloring type: " + type)
+    } else {
+      throw new Error("Unknown mesh edges coloring type: " + type)
+    }
   }
 
   function meshEdgesColor(id) {

internal_stores/mesh/index.js

@@ -7,6 +7,9 @@ import { useMeshEdgesStyle } from "./edges.js"
 import { useMeshPolygonsStyle } from "./polygons.js"
 import { useMeshPolyhedraStyle } from "./polyhedra.js"
 
+// Local constants
+const mesh_schemas = viewer_schemas.opengeodeweb_viewer.mesh
+
 export default function useMeshStyle() {
   const dataStyleStore = useDataStyleStore()
   const pointsStyleStore = useMeshPointsStyle()
@@ -21,7 +24,7 @@ export default function useMeshStyle() {
   function setMeshVisibility(id, visibility) {
     return viewer_call(
       {
-        schema: viewer_schemas.opengeodeweb_viewer.mesh.visibility,
+        schema: mesh_schemas.visibility,
         params: { id, visibility },
       },
       {
@@ -38,20 +41,22 @@ export default function useMeshStyle() {
     const style = dataStyleStore.getStyle(id)
     const promise_array = []
     for (const [key, value] of Object.entries(style)) {
-      if (key == "visibility") {
+      if (key === "visibility") {
         promise_array.push(setMeshVisibility(id, value))
-      } else if (key == "points") {
+      } else if (key === "points") {
         promise_array.push(pointsStyleStore.applyMeshPointsStyle(id, value))
-      } else if (key == "edges") {
+      } else if (key === "edges") {
         promise_array.push(edgesStyleStore.applyMeshEdgesStyle(id, value))
-      } else if (key == "polygons") {
+      } else if (key === "polygons") {
         promise_array.push(
           meshPolygonsStyleStore.applyMeshPolygonsStyle(id, value),
         )
-      } else if (key == "polyhedra") {
+      } else if (key === "polyhedra") {
         promise_array.push(
           meshPolyhedraStyleStore.applyMeshPolyhedraStyle(id, value),
         )
+      } else {
+        throw new Error("Unknown key")
       }
     }
     return promise_array

internal_stores/mesh/points.js

@@ -1,4 +1,7 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local constants
 const mesh_points_schemas = viewer_schemas.opengeodeweb_viewer.mesh.points
 
 export function useMeshPointsStyle() {
@@ -39,7 +42,9 @@ export function useMeshPointsStyle() {
       return dataStyleStore.setMeshPointsColor(id, coloring.color)
     } else if (type == "vertex" && coloring.vertex !== null) {
       return dataStyleStore.setMeshPointsVertexAttribute(id, coloring.vertex)
-    } else throw new Error("Unknown points coloring type: " + type)
+    } else {
+      throw new Error("Unknown mesh points coloring type: " + type)
+    }
   }
 
   function meshPointsColor(id) {

internal_stores/mesh/polygons.js

@@ -1,4 +1,7 @@
+// Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local constants
 const mesh_polygons_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polygons
 
 export function useMeshPolygonsStyle() {
@@ -125,7 +128,9 @@ export function useMeshPolygonsStyle() {
       return setMeshPolygonsVertexAttribute(id, coloring.vertex)
     } else if (type === "polygon" && coloring.polygon !== null) {
       return setMeshPolygonsPolygonAttribute(id, coloring.polygon)
-    } else throw new Error("Unknown polygons coloring type: " + type)
+    } else {
+      throw new Error("Unknown mesh polygons coloring type: " + type)
+    }
   }
 
   function applyMeshPolygonsStyle(id, style) {

internal_stores/mesh/polyhedra.js

@@ -1,5 +1,7 @@
 // Third party imports
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+
+// Local constants
 const mesh_polyhedra_schemas = viewer_schemas.opengeodeweb_viewer.mesh.polyhedra
 
 export function useMeshPolyhedraStyle() {
@@ -41,7 +43,9 @@ export function useMeshPolyhedraStyle() {
       //   return setPolyhedraVertexAttribute(id, coloring.vertex)
       // } else if (type === "polyhedron" && coloring.polyhedron !== null) {
       //   return setPolyhedraPolyhedronAttribute(id, coloring.polyhedron)
-    } else throw new Error("Unknown mesh polyhedra coloring type: " + type)
+    } else {
+      throw new Error("Unknown mesh polyhedra coloring type: " + type)
+    }
   }
 
   function meshPolyhedraColor(id) {

internal_stores/model/blocks.js

@@ -1,58 +1,104 @@
+// Third party imports
 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 **/
+// Local constants
+const model_blocks_schemas = viewer_schemas.opengeodeweb_viewer.model.blocks
+
+export function useModelBlocksStyle() {
   const dataStyleStore = useDataStyleStore()
   const dataBaseStore = useDataBaseStore()
 
-  /** Getters **/
-  function blockVisibility(id, block_id) {
-    return dataStyleStore.styles[id].blocks[block_id].visibility
+  function modelBlockStyle(id, block_id) {
+    if (!dataStyleStore.getStyle(id).blocks[block_id]) {
+      dataStyleStore.getStyle(id).blocks[block_id] = {}
+    }
+    return dataStyleStore.getStyle(id).blocks[block_id]
+  }
+
+  function modelBlockVisibility(id, block_id) {
+    return modelBlockStyle(id, block_id).visibility
   }
 
-  /** Actions **/
-  function setBlockVisibility(id, block_ids, visibility) {
+  function saveModelBlockVisibility(id, block_id, visibility) {
+    modelBlockStyle(id, block_id).visibility = visibility
+  }
+  function setModelBlocksVisibility(id, block_ids, visibility) {
     const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
     return viewer_call(
       {
-        schema: blocks_schemas.visibility,
+        schema: model_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
+            saveModelBlockVisibility(id, block_id, visibility)
           }
-          console.log("setBlockVisibility", block_ids, visibility)
+          console.log(
+            `${setModelBlocksVisibility.name} ${id} ${block_ids} ${modelBlockVisibility(id, block_ids[0])}`,
+          )
         },
       },
     )
   }
+  function modelBlockColor(id, block_id) {
+    return modelBlockStyle(id, block_id).color
+  }
 
-  function setBlocksDefaultStyle(id) {
-    const block_ids = dataBaseStore.getBlocksUuids(id)
-    setBlockVisibility(
-      id,
-      block_ids,
-      dataStyleStore.styles[id].blocks.visibility,
+  function saveModelBlockColor(id, block_id, color) {
+    modelBlockStyle(id, block_id).color = color
+  }
+
+  function setModelBlocksColor(id, block_ids, color) {
+    const block_flat_indexes = dataBaseStore.getFlatIndexes(id, block_ids)
+    return viewer_call(
+      {
+        schema: model_blocks_schemas.color,
+        params: { id, block_ids: block_flat_indexes, color },
+      },
+      {
+        response_function: () => {
+          for (const block_id of block_ids) {
+            saveModelBlockColor(id, block_id, color)
+          }
+          console.log(
+            `${setModelBlocksColor.name} ${id} ${block_ids} ${JSON.stringify(modelBlockColor(id, block_ids[0]))}`,
+          )
+        },
+      },
     )
   }
 
-  function applyBlocksStyle(id) {
-    const blocks = dataStyleStore.styles[id].blocks
-    for (const [block_id, style] of Object.entries(blocks)) {
-      setBlockVisibility(id, [block_id], style.visibility)
-    }
+  function setModelBlocksDefaultStyle(id) {
+    const blocks = dataBaseStore.getBlocksUuids(id)
+    return Promise.all([
+      setModelBlocksVisibility(
+        id,
+        blocks,
+        dataStyleStore.styles[id].blocks.visibility,
+      ),
+      setModelBlocksColor(id, blocks, dataStyleStore.styles[id].blocks.color),
+    ])
+  }
+
+  function applyModelBlocksStyle(id) {
+    console.log("applyModelBlocksStyle", id)
+    const blocks_style = dataStyleStore.getStyle(id).blocks
+    console.log("blocks_style", blocks_style)
+
+    const block_ids = dataBaseStore.getBlocksUuids(id)
+    return Promise.all([
+      setModelBlocksVisibility(id, [block_ids], blocks_style.visibility),
+      setModelBlocksColor(id, [block_ids], blocks_style.color),
+    ])
   }
 
   return {
-    blockVisibility,
-    setBlocksDefaultStyle,
-    setBlockVisibility,
-    applyBlocksStyle,
+    modelBlockVisibility,
+    modelBlockColor,
+    setModelBlocksVisibility,
+    setModelBlocksColor,
+    setModelBlocksDefaultStyle,
+    applyModelBlocksStyle,
   }
 }