@geode/opengeodeweb-front 10.3.1 → 10.3.2-rc.1

package/app/components/Viewer/EdgedCurve/SpecificEdgesOptions.vue

@@ -48,7 +48,6 @@
     get: () => dataStyleStore.meshEdgesVertexAttributeName(id.value),
     set: async (newValue) => {
       await dataStyleStore.setMeshEdgesVertexAttributeName(id.value, newValue)
-      await dataStyleStore.updateMeshEdgesVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -60,7 +59,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshEdgesVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })

package/app/components/Viewer/Generic/Mesh/CellsOptions.vue

@@ -49,7 +49,6 @@
     get: () => dataStyleStore.meshCellsVertexAttributeName(id.value),
     set: async (newValue) => {
       await dataStyleStore.setMeshCellsVertexAttributeName(id.value, newValue)
-      await dataStyleStore.updateMeshCellsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -61,7 +60,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshCellsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -79,7 +77,6 @@
     get: () => dataStyleStore.meshCellsCellAttributeName(id.value),
     set: async (newValue) => {
       await dataStyleStore.setMeshCellsCellAttributeName(id.value, newValue)
-      await dataStyleStore.updateMeshCellsCellAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -91,7 +88,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshCellsCellAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })

package/app/components/Viewer/Generic/Mesh/EdgesOptions.vue

@@ -44,6 +44,59 @@
       hybridViewerStore.remoteRender()
     },
   })
+  const vertex_attribute_name = computed({
+    get: () => dataStyleStore.meshEdgesVertexAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesVertexAttributeName(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_range = computed({
+    get: () => dataStyleStore.meshEdgesVertexAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesVertexAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_color_map = computed({
+    get: () => dataStyleStore.meshEdgesVertexAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesVertexAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const edge_attribute_name = computed({
+    get: () => dataStyleStore.meshEdgesEdgeAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesEdgeAttributeName(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const edge_attribute_range = computed({
+    get: () => dataStyleStore.meshEdgesEdgeAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesEdgeAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const edge_attribute_color_map = computed({
+    get: () => dataStyleStore.meshEdgesEdgeAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshEdgesEdgeAttributeColorMap(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
 </script>
 
 <template>
@@ -78,6 +131,12 @@
               :id="id"
               v-model:coloring_style_key="coloring_style_key"
               v-model:color="color"
+              v-model:vertex_attribute_name="vertex_attribute_name"
+              v-model:vertex_attribute_range="vertex_attribute_range"
+              v-model:vertex_attribute_color_map="vertex_attribute_color_map"
+              v-model:edge_attribute_name="edge_attribute_name"
+              v-model:edge_attribute_range="edge_attribute_range"
+              v-model:edge_attribute_color_map="edge_attribute_color_map"
             />
           </v-col>
         </v-row>

package/app/components/Viewer/Generic/Mesh/PointsOptions.vue

@@ -44,6 +44,34 @@
       hybridViewerStore.remoteRender()
     },
   })
+  const vertex_attribute_name = computed({
+    get: () => dataStyleStore.meshPointsVertexAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPointsVertexAttributeName(id.value, newValue)
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_range = computed({
+    get: () => dataStyleStore.meshPointsVertexAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPointsVertexAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_color_map = computed({
+    get: () => dataStyleStore.meshPointsVertexAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPointsVertexAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
 </script>
 
 <template>
@@ -78,6 +106,9 @@
               :id="id"
               v-model:coloring_style_key="coloring_style_key"
               v-model:color="color"
+              v-model:vertex_attribute_name="vertex_attribute_name"
+              v-model:vertex_attribute_range="vertex_attribute_range"
+              v-model:vertex_attribute_color_map="vertex_attribute_color_map"
             />
           </v-col>
         </v-row>

package/app/components/Viewer/Generic/Mesh/PolygonsOptions.vue

@@ -45,6 +45,68 @@
       hybridViewerStore.remoteRender()
     },
   })
+  const vertex_attribute_name = computed({
+    get: () => dataStyleStore.meshPolygonsVertexAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsVertexAttributeName(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_range = computed({
+    get: () => dataStyleStore.meshPolygonsVertexAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsVertexAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_color_map = computed({
+    get: () => dataStyleStore.meshPolygonsVertexAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsVertexAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polygon_attribute_name = computed({
+    get: () => dataStyleStore.meshPolygonsPolygonAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsPolygonAttributeName(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polygon_attribute_range = computed({
+    get: () => dataStyleStore.meshPolygonsPolygonAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsPolygonAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polygon_attribute_color_map = computed({
+    get: () => dataStyleStore.meshPolygonsPolygonAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolygonsPolygonAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
 </script>
 
 <template>
@@ -61,6 +123,12 @@
           v-model:coloring_style_key="coloring_style_key"
           v-model:color="color"
           v-model:textures="textures"
+          v-model:vertex_attribute_name="vertex_attribute_name"
+          v-model:vertex_attribute_range="vertex_attribute_range"
+          v-model:vertex_attribute_color_map="vertex_attribute_color_map"
+          v-model:polygon_attribute_name="polygon_attribute_name"
+          v-model:polygon_attribute_range="polygon_attribute_range"
+          v-model:polygon_attribute_color_map="polygon_attribute_color_map"
         />
       </template>
     </template>

package/app/components/Viewer/Generic/Mesh/PolyhedraOptions.vue

@@ -38,6 +38,69 @@
       hybridViewerStore.remoteRender()
     },
   })
+  const vertex_attribute_name = computed({
+    get: () => dataStyleStore.meshPolyhedraVertexAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraVertexAttributeName(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_range = computed({
+    get: () => dataStyleStore.meshPolyhedraVertexAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraVertexAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const vertex_attribute_color_map = computed({
+    get: () => dataStyleStore.meshPolyhedraVertexAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraVertexAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polyhedron_attribute_name = computed({
+    get: () => dataStyleStore.meshPolyhedraPolyhedronAttributeName(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraPolyhedronAttributeName(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polyhedron_attribute_range = computed({
+    get: () => dataStyleStore.meshPolyhedraPolyhedronAttributeRange(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraPolyhedronAttributeRange(
+        id.value,
+        newValue[0],
+        newValue[1],
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
+  const polyhedron_attribute_color_map = computed({
+    get: () =>
+      dataStyleStore.meshPolyhedraPolyhedronAttributeColorMap(id.value),
+    set: async (newValue) => {
+      await dataStyleStore.setMeshPolyhedraPolyhedronAttributeColorMap(
+        id.value,
+        newValue,
+      )
+      hybridViewerStore.remoteRender()
+    },
+  })
 </script>
 
 <template>
@@ -53,6 +116,14 @@
           :id="id"
           v-model:coloring_style_key="coloring_style_key"
           v-model:color="color"
+          v-model:vertex_attribute_name="vertex_attribute_name"
+          v-model:vertex_attribute_range="vertex_attribute_range"
+          v-model:vertex_attribute_color_map="vertex_attribute_color_map"
+          v-model:polyhedron_attribute_name="polyhedron_attribute_name"
+          v-model:polyhedron_attribute_range="polyhedron_attribute_range"
+          v-model:polyhedron_attribute_color_map="
+            polyhedron_attribute_color_map
+          "
         />
       </template>
     </template>

package/app/components/Viewer/Options/AttributeColorBar.vue

@@ -22,6 +22,7 @@
           @update:model-value="(value) => (minimum = Number(value))"
           label="Min"
           type="number"
+          :max="maximum"
           density="compact"
           hide-details
           variant="outlined"
@@ -42,6 +43,7 @@
           @update:model-value="(value) => (maximum = Number(value))"
           label="Max"
           type="number"
+          :min="minimum"
           density="compact"
           hide-details
           variant="outlined"

package/app/components/Viewer/Options/AttributeSelector.vue

@@ -0,0 +1,112 @@
+<script setup>
+  import ViewerOptionsAttributeColorBar from "@ogw_front/components/Viewer/Options/AttributeColorBar.vue"
+  import { useGeodeStore } from "@ogw_front/stores/geode"
+
+  const geodeStore = useGeodeStore()
+
+  const name = defineModel("name", { type: String })
+  const range = defineModel("range", { type: Array })
+  const colorMap = defineModel("colorMap", { type: String })
+
+  const { id, schema } = defineProps({
+    id: { type: String, required: true },
+    schema: { type: Object, required: true },
+  })
+
+  const attributes = ref([])
+
+  const rangeMin = computed({
+    get: () => (range.value ? range.value[0] : undefined),
+    set: (val) => {
+      const currentMax = range.value ? range.value[1] : undefined
+      let newMin = val
+      if (currentMax !== undefined && val > currentMax) {
+        newMin = currentMax
+      }
+      range.value = [newMin, currentMax]
+    },
+  })
+  const rangeMax = computed({
+    get: () => (range.value ? range.value[1] : undefined),
+    set: (val) => {
+      const currentMin = range.value ? range.value[0] : undefined
+      let newMax = val
+      if (currentMin !== undefined && val < currentMin) {
+        newMax = currentMin
+      }
+      range.value = [currentMin, newMax]
+    },
+  })
+
+  const currentAttribute = computed(() =>
+    attributes.value.find((attr) => attr.attribute_name === name.value),
+  )
+
+  function resetRange() {
+    if (currentAttribute.value) {
+      range.value = [
+        currentAttribute.value.min_value,
+        currentAttribute.value.max_value,
+      ]
+    }
+  }
+
+  function getAttributes() {
+    geodeStore.request(
+      schema,
+      { id },
+      {
+        response_function: (response) => {
+          attributes.value = response.attributes
+        },
+      },
+    )
+  }
+
+  onMounted(() => {
+    getAttributes()
+  })
+
+  watch(
+    () => [id, schema],
+    () => {
+      getAttributes()
+    },
+  )
+
+  watch(
+    () => [name.value, attributes.value],
+    () => {
+      if (
+        name.value &&
+        attributes.value.length > 0 &&
+        (range.value === undefined ||
+          range.value[0] === undefined ||
+          colorMap.value === undefined)
+      ) {
+        resetRange()
+        if (colorMap.value === undefined) {
+          colorMap.value = "Cool to Warm"
+        }
+      }
+    },
+  )
+</script>
+
+<template>
+  <v-select
+    v-model="name"
+    :items="attributes.map((attribute) => attribute.attribute_name)"
+    item-title="attribute_name"
+    item-value="attribute_name"
+    density="compact"
+    label="Select an attribute"
+  />
+  <ViewerOptionsAttributeColorBar
+    v-if="name"
+    v-model:minimum="rangeMin"
+    v-model:maximum="rangeMax"
+    v-model:colorMap="colorMap"
+    @reset="resetRange"
+  />
+</template>

package/app/components/Viewer/Options/ColoringTypeSelector.vue

@@ -1,11 +1,8 @@
 <script setup>
-  import ViewerOptionsCellAttributeSelector from "@ogw_front/components/Viewer/Options/CellAttributeSelector"
-  import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker"
-  import ViewerOptionsEdgeAttributeSelector from "@ogw_front/components/Viewer/Options/EdgeAttributeSelector"
-  import ViewerOptionsPolygonAttributeSelector from "@ogw_front/components/Viewer/Options/PolygonAttributeSelector"
-  import ViewerOptionsPolyhedronAttributeSelector from "@ogw_front/components/Viewer/Options/PolyhedronAttributeSelector"
-  import ViewerOptionsTexturesSelector from "@ogw_front/components/Viewer/Options/TexturesSelector"
-  import ViewerOptionsVertexAttributeSelector from "@ogw_front/components/Viewer/Options/VertexAttributeSelector"
+  import ViewerOptionsAttributeSelector from "@ogw_front/components/Viewer/Options/AttributeSelector.vue"
+  import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker.vue"
+  import ViewerOptionsTexturesSelector from "@ogw_front/components/Viewer/Options/TexturesSelector.vue"
+  import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 
   const coloring_style_key = defineModel("coloring_style_key")
 
@@ -132,45 +129,50 @@
             <ViewerOptionsTexturesSelector v-model="textures" :id="id" />
           </template>
           <template v-if="coloring_style_key === vertex_dict['value']">
-            <ViewerOptionsVertexAttributeSelector
-              v-model:vertex_attribute_name="vertex_attribute_name"
-              v-model:vertex_attribute_range="vertex_attribute_range"
-              v-model:vertex_attribute_color_map="vertex_attribute_color_map"
+            <ViewerOptionsAttributeSelector
+              v-model:name="vertex_attribute_name"
+              v-model:range="vertex_attribute_range"
+              v-model:colorMap="vertex_attribute_color_map"
               :id="id"
+              :schema="back_schemas.opengeodeweb_back.vertex_attribute_names"
             />
           </template>
           <template v-if="coloring_style_key === edge_dict['value']">
-            <ViewerOptionsEdgeAttributeSelector
-              v-model:edge_attribute_name="edge_attribute_name"
-              v-model:edge_attribute_range="edge_attribute_range"
-              v-model:edge_attribute_color_map="edge_attribute_color_map"
+            <ViewerOptionsAttributeSelector
+              v-model:name="edge_attribute_name"
+              v-model:range="edge_attribute_range"
+              v-model:colorMap="edge_attribute_color_map"
               :id="id"
+              :schema="back_schemas.opengeodeweb_back.edge_attribute_names"
             />
           </template>
           <template v-if="coloring_style_key === cell_dict['value']">
-            <ViewerOptionsCellAttributeSelector
-              v-model:cell_attribute_name="cell_attribute_name"
-              v-model:cell_attribute_range="cell_attribute_range"
-              v-model:cell_attribute_color_map="cell_attribute_color_map"
+            <ViewerOptionsAttributeSelector
+              v-model:name="cell_attribute_name"
+              v-model:range="cell_attribute_range"
+              v-model:colorMap="cell_attribute_color_map"
               :id="id"
+              :schema="back_schemas.opengeodeweb_back.cell_attribute_names"
             />
           </template>
           <template v-if="coloring_style_key === polygon_dict['value']">
-            <ViewerOptionsPolygonAttributeSelector
-              v-model:polygon_attribute_name="polygon_attribute_name"
-              v-model:polygon_attribute_range="polygon_attribute_range"
-              v-model:polygon_attribute_color_map="polygon_attribute_color_map"
+            <ViewerOptionsAttributeSelector
+              v-model:name="polygon_attribute_name"
+              v-model:range="polygon_attribute_range"
+              v-model:colorMap="polygon_attribute_color_map"
               :id="id"
+              :schema="back_schemas.opengeodeweb_back.polygon_attribute_names"
             />
           </template>
           <template v-if="coloring_style_key === polyhedron_dict['value']">
-            <ViewerOptionsPolyhedronAttributeSelector
-              v-model:polyhedron_attribute_name="polyhedron_attribute_name"
-              v-model:polyhedron_attribute_range="polyhedron_attribute_range"
-              v-model:polyhedron_attribute_color_map="
-                polyhedron_attribute_color_map
-              "
+            <ViewerOptionsAttributeSelector
+              v-model:name="polyhedron_attribute_name"
+              v-model:range="polyhedron_attribute_range"
+              v-model:colorMap="polyhedron_attribute_color_map"
               :id="id"
+              :schema="
+                back_schemas.opengeodeweb_back.polyhedron_attribute_names
+              "
             />
           </template>
         </v-col>

package/app/components/Viewer/PointSet/SpecificPointsOptions.vue

@@ -48,7 +48,6 @@
     get: () => dataStyleStore.meshPointsVertexAttributeName(id.value),
     set: async (newValue) => {
       await dataStyleStore.setMeshPointsVertexAttributeName(id.value, newValue)
-      await dataStyleStore.updateMeshPointsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -60,7 +59,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshPointsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })

package/app/components/Viewer/PolygonalSurface/SpecificPolygonsOptions.vue

@@ -52,7 +52,6 @@
         id.value,
         newValue,
       )
-      await dataStyleStore.updateMeshPolygonsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -64,7 +63,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshPolygonsVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -85,7 +83,6 @@
         id.value,
         newValue,
       )
-      await dataStyleStore.updateMeshPolygonsPolygonAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -97,7 +94,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshPolygonsPolygonAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })

package/app/components/Viewer/Solid/SpecificPolyhedraOptions.vue

@@ -45,7 +45,6 @@
         id.value,
         newValue,
       )
-      await dataStyleStore.updateMeshPolyhedraVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -57,7 +56,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshPolyhedraVertexAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -78,7 +76,6 @@
         id.value,
         newValue,
       )
-      await dataStyleStore.updateMeshPolyhedraPolyhedronAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })
@@ -90,7 +87,6 @@
         newValue[0],
         newValue[1],
       )
-      await dataStyleStore.updateMeshPolyhedraPolyhedronAttribute(id.value)
       hybridViewerStore.remoteRender()
     },
   })