@geode/opengeodeweb-front 10.14.2-rc.2 → 10.14.2-rc.3

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

@@ -46,48 +46,6 @@ const color = computed({
     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>
@@ -110,12 +68,6 @@ const edge_attribute_color_map = computed({
               :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

@@ -95,6 +95,7 @@ const vertex_attribute_color_map = computed({
               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"
+              :capabilities="{ vertex: { available: false } }"
             />
           </v-col>
         </v-row>

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

@@ -45,48 +45,6 @@ const textures = computed({
     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>
@@ -107,12 +65,6 @@ const polygon_attribute_color_map = computed({
           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

@@ -109,6 +109,10 @@ const polyhedron_attribute_color_map = computed({
           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"
+          :capabilities="{
+            vertex: { available: true, hasColorMap: false },
+            polyhedron: { available: true, hasColorMap: true },
+          }"
         />
       </template>
     </template>

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

@@ -29,17 +29,50 @@ const polyhedron_attribute_name = defineModel("polyhedron_attribute_name");
 const polyhedron_attribute_range = defineModel("polyhedron_attribute_range");
 const polyhedron_attribute_color_map = defineModel("polyhedron_attribute_color_map");
 
-const { id } = defineProps({
+const { id, capabilities } = defineProps({
   id: { type: String, required: true },
+  capabilities: {
+    type: Object,
+    default: () => ({}),
+  },
 });
 
-const has_color = computed(() => color.value !== undefined);
-const has_textures = computed(() => textures.value !== undefined);
-const has_vertex = computed(() => vertex_attribute_range.value !== undefined);
-const has_edge = computed(() => edge_attribute_range.value !== undefined);
-const has_cells = computed(() => cell_attribute_range.value !== undefined);
-const has_polygons = computed(() => polygon_attribute_range.value !== undefined);
-const has_polyhedra = computed(() => polyhedron_attribute_range.value !== undefined);
+function isAvailable(key) {
+  if (capabilities[key] && capabilities[key].available === false) {
+    return false;
+  }
+  return true;
+}
+
+function hasColorMap(key) {
+  if (capabilities[key] && capabilities[key].hasColorMap === false) {
+    return false;
+  }
+  return true;
+}
+
+const has_color = computed(() => color.value !== undefined && isAvailable("color"));
+const has_textures = computed(() => textures.value !== undefined && isAvailable("textures"));
+const has_vertex = computed(
+  () =>
+    vertex_attribute_range.value !== undefined && isAvailable("vertex") && hasColorMap("vertex"),
+);
+const has_edge = computed(
+  () => edge_attribute_range.value !== undefined && isAvailable("edge") && hasColorMap("edge"),
+);
+const has_cells = computed(
+  () => cell_attribute_range.value !== undefined && isAvailable("cell") && hasColorMap("cell"),
+);
+const has_polygons = computed(
+  () =>
+    polygon_attribute_range.value !== undefined && isAvailable("polygon") && hasColorMap("polygon"),
+);
+const has_polyhedra = computed(
+  () =>
+    polyhedron_attribute_range.value !== undefined &&
+    isAvailable("polyhedron") &&
+    hasColorMap("polyhedron"),
+);
 
 const color_dict = { name: "Color", value: "color" };
 const textures_dict = { name: "Textures", value: "textures" };
@@ -116,7 +149,7 @@ watch(coloring_style_label, (value) => {
           <template v-if="coloring_style_key === textures_dict['value']">
             <ViewerOptionsTexturesSelector v-model="textures" :id="id" />
           </template>
-          <template v-if="coloring_style_key === vertex_dict['value']">
+          <template v-if="coloring_style_key === vertex_dict['value'] && hasColorMap('vertex')">
             <ViewerOptionsAttributeSelector
               v-model:name="vertex_attribute_name"
               v-model:range="vertex_attribute_range"
@@ -125,7 +158,7 @@ watch(coloring_style_label, (value) => {
               :schema="back_schemas.opengeodeweb_back.vertex_attribute_names"
             />
           </template>
-          <template v-if="coloring_style_key === edge_dict['value']">
+          <template v-if="coloring_style_key === edge_dict['value'] && hasColorMap('edge')">
             <ViewerOptionsAttributeSelector
               v-model:name="edge_attribute_name"
               v-model:range="edge_attribute_range"
@@ -134,7 +167,7 @@ watch(coloring_style_label, (value) => {
               :schema="back_schemas.opengeodeweb_back.edge_attribute_names"
             />
           </template>
-          <template v-if="coloring_style_key === cell_dict['value']">
+          <template v-if="coloring_style_key === cell_dict['value'] && hasColorMap('cell')">
             <ViewerOptionsAttributeSelector
               v-model:name="cell_attribute_name"
               v-model:range="cell_attribute_range"
@@ -143,7 +176,7 @@ watch(coloring_style_label, (value) => {
               :schema="back_schemas.opengeodeweb_back.cell_attribute_names"
             />
           </template>
-          <template v-if="coloring_style_key === polygon_dict['value']">
+          <template v-if="coloring_style_key === polygon_dict['value'] && hasColorMap('polygon')">
             <ViewerOptionsAttributeSelector
               v-model:name="polygon_attribute_name"
               v-model:range="polygon_attribute_range"
@@ -152,7 +185,9 @@ watch(coloring_style_label, (value) => {
               :schema="back_schemas.opengeodeweb_back.polygon_attribute_names"
             />
           </template>
-          <template v-if="coloring_style_key === polyhedron_dict['value']">
+          <template
+            v-if="coloring_style_key === polyhedron_dict['value'] && hasColorMap('polyhedron')"
+          >
             <ViewerOptionsAttributeSelector
               v-model:name="polyhedron_attribute_name"
               v-model:range="polyhedron_attribute_range"

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

@@ -89,6 +89,7 @@ const vertex_attribute_color_map = computed({
               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"
+              :vertex_has_colormap="true"
             />
           </v-col>
         </v-row>

package/app/stores/hybrid_viewer.js

@@ -170,6 +170,9 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
   }
 
   function setContainer(container) {
+    if (!container.value) {
+      return;
+    }
     genericRenderWindow.value.setContainer(container.value.$el);
     const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
     webGLRenderWindow.setUseBackgroundImage(true);

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

@@ -49,12 +49,28 @@ function useMeshPointsVertexAttributeConfig() {
     return meshPointsVertexAttribute(id).name;
   }
 
+  function meshPointsVertexAttributeRange(id) {
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+
+  function meshPointsVertexAttributeColorMap(id) {
+    const name = meshPointsVertexAttributeName(id);
+    const storedConfig = meshPointsVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
+  }
+
   return {
     meshPointsVertexAttribute,
     meshPointsVertexAttributeStoredConfig,
     setMeshPointsVertexAttributeStoredConfig,
     mutateMeshPointsVertexStyle,
     meshPointsVertexAttributeName,
+    meshPointsVertexAttributeRange,
+    meshPointsVertexAttributeColorMap,
   };
 }
 
@@ -133,23 +149,7 @@ export function useMeshPointsVertexAttributeStyle() {
   const config = useMeshPointsVertexAttributeConfig();
   const actions = useMeshPointsVertexAttributeActions();
 
-  function meshPointsVertexAttributeRange(id) {
-    const name = config.meshPointsVertexAttributeName(id);
-    const storedConfig = config.meshPointsVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
-  }
-
-  function meshPointsVertexAttributeColorMap(id) {
-    const name = config.meshPointsVertexAttributeName(id);
-    const storedConfig = config.meshPointsVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
-  }
-
   return {
-    meshPointsVertexAttributeRange,
-    meshPointsVertexAttributeColorMap,
     ...config,
     ...actions,
   };

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

@@ -49,12 +49,28 @@ function useMeshPolyhedraPolyhedronAttributeConfig() {
     return meshPolyhedraPolyhedronAttribute(id).name;
   }
 
+  function meshPolyhedraPolyhedronAttributeRange(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+
+  function meshPolyhedraPolyhedronAttributeColorMap(id) {
+    const name = meshPolyhedraPolyhedronAttributeName(id);
+    const storedConfig = meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
+  }
+
   return {
     meshPolyhedraPolyhedronAttribute,
     meshPolyhedraPolyhedronAttributeStoredConfig,
     setMeshPolyhedraPolyhedronAttributeStoredConfig,
     mutateMeshPolyhedraPolyhedronStyle,
     meshPolyhedraPolyhedronAttributeName,
+    meshPolyhedraPolyhedronAttributeRange,
+    meshPolyhedraPolyhedronAttributeColorMap,
   };
 }
 
@@ -133,23 +149,7 @@ export function useMeshPolyhedraPolyhedronAttributeStyle() {
   const config = useMeshPolyhedraPolyhedronAttributeConfig();
   const actions = useMeshPolyhedraPolyhedronAttributeActions();
 
-  function meshPolyhedraPolyhedronAttributeRange(id) {
-    const name = config.meshPolyhedraPolyhedronAttributeName(id);
-    const storedConfig = config.meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
-  }
-
-  function meshPolyhedraPolyhedronAttributeColorMap(id) {
-    const name = config.meshPolyhedraPolyhedronAttributeName(id);
-    const storedConfig = config.meshPolyhedraPolyhedronAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
-  }
-
   return {
-    meshPolyhedraPolyhedronAttributeRange,
-    meshPolyhedraPolyhedronAttributeColorMap,
     ...config,
     ...actions,
   };

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

@@ -49,12 +49,28 @@ function useMeshPolyhedraVertexAttributeConfig() {
     return meshPolyhedraVertexAttribute(id).name;
   }
 
+  function meshPolyhedraVertexAttributeRange(id) {
+    const name = meshPolyhedraVertexAttributeName(id);
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name);
+    const { minimum, maximum } = storedConfig;
+    return [minimum, maximum];
+  }
+
+  function meshPolyhedraVertexAttributeColorMap(id) {
+    const name = meshPolyhedraVertexAttributeName(id);
+    const storedConfig = meshPolyhedraVertexAttributeStoredConfig(id, name);
+    const { colorMap } = storedConfig;
+    return colorMap;
+  }
+
   return {
     meshPolyhedraVertexAttribute,
     meshPolyhedraVertexAttributeStoredConfig,
     setMeshPolyhedraVertexAttributeStoredConfig,
     mutateMeshPolyhedraVertexStyle,
     meshPolyhedraVertexAttributeName,
+    meshPolyhedraVertexAttributeRange,
+    meshPolyhedraVertexAttributeColorMap,
   };
 }
 
@@ -133,23 +149,7 @@ export function useMeshPolyhedraVertexAttributeStyle() {
   const config = useMeshPolyhedraVertexAttributeConfig();
   const actions = useMeshPolyhedraVertexAttributeActions();
 
-  function meshPolyhedraVertexAttributeRange(id) {
-    const name = config.meshPolyhedraVertexAttributeName(id);
-    const storedConfig = config.meshPolyhedraVertexAttributeStoredConfig(id, name);
-    const { minimum, maximum } = storedConfig;
-    return [minimum, maximum];
-  }
-
-  function meshPolyhedraVertexAttributeColorMap(id) {
-    const name = config.meshPolyhedraVertexAttributeName(id);
-    const storedConfig = config.meshPolyhedraVertexAttributeStoredConfig(id, name);
-    const { colorMap } = storedConfig;
-    return colorMap;
-  }
-
   return {
-    meshPolyhedraVertexAttributeRange,
-    meshPolyhedraVertexAttributeColorMap,
     ...config,
     ...actions,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.14.2-rc.2",
+  "version": "10.14.2-rc.3",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {