@geode/opengeodeweb-front 10.41.0-rc.1 → 10.41.0-rc.3

package/app/composables/model_attribute_style.ts

@@ -0,0 +1,79 @@
+import {
+  type AttributeColoring,
+  type AttributeColoringStyle,
+  attributeSchemas,
+  attributeType,
+  storeMethod,
+  useAttributeColoringStyle,
+} from "@ogw_front/composables/attribute_coloring_style";
+import { useDataStore } from "@ogw_front/stores/data";
+import { useDataStyleStore } from "@ogw_front/stores/data_style";
+
+// Components of the same type colored by the same attribute share the store methods, e.g. "modelBlocksPolyhedronAttributeName"
+interface ComponentGroup {
+  // Component type of the store methods, e.g. "Block"
+  type: string;
+  activeColoring: string;
+  componentIds: string[];
+}
+
+function modelColoring(
+  dataStyleStore: object,
+  modelId: string,
+  { type, activeColoring, componentIds }: ComponentGroup,
+): AttributeColoring {
+  const methodName = `${type}s${attributeType(activeColoring)}`;
+  return {
+    // Every component of the coloring shares its style: reading the first one is enough
+    read: (property): unknown =>
+      storeMethod(dataStyleStore, `model${methodName}${property}`)(modelId, componentIds[0]),
+    write: async (property, ...values): Promise<void> => {
+      await storeMethod(dataStyleStore, `setModel${methodName}${property}`)(
+        modelId,
+        componentIds,
+        ...values,
+      );
+    },
+    schemas: attributeSchemas("model_component_", activeColoring),
+    params: { id: modelId, component_ids: componentIds },
+  };
+}
+
+// Styles the model components colored by the picked scalar bar
+export function useModelAttributeStyle(
+  modelIdRef: Ref<string>,
+  blockViewerIdsRef: Ref<number[]>,
+): AttributeColoringStyle {
+  const dataStyleStore = useDataStyleStore();
+  const dataStore = useDataStore();
+
+  const colorings = shallowRef<AttributeColoring[]>([]);
+  const style = useAttributeColoringStyle(colorings);
+
+  async function loadColorings(): Promise<void> {
+    const modelId = modelIdRef.value;
+    const blockViewerIds = blockViewerIdsRef.value;
+    const components = await dataStore.getComponentsByViewerIds(modelId, blockViewerIds);
+    // A newer pick replaced this one while the components were read
+    if (modelId !== modelIdRef.value || blockViewerIds !== blockViewerIdsRef.value) {
+      return;
+    }
+    const groups = new Map<string, ComponentGroup>();
+    for (const { type, geode_id } of components) {
+      const activeColoring = String(
+        storeMethod(dataStyleStore, `model${type}ActiveColoring`)(modelId, geode_id),
+      );
+      const key = `${type}_${activeColoring}`;
+      const group = groups.get(key) ?? { type, activeColoring, componentIds: [] };
+      group.componentIds.push(geode_id);
+      groups.set(key, group);
+    }
+    colorings.value = [...groups.values()].map((group) =>
+      modelColoring(dataStyleStore, modelId, group),
+    );
+    await style.loadTimeSteps();
+  }
+
+  watch([modelIdRef, blockViewerIdsRef], loadColorings, { immediate: true });
+  return style;
+}

package/app/composables/model_menu_context.ts

@@ -0,0 +1,101 @@
+import { type ComputedRef, type Ref, computed, ref, watch } from "vue";
+import type { CollectionComponent } from "@ogw_front/stores/data_helpers/collections";
+import { MESH_COMPONENT_TYPES } from "@ogw_front/utils/default_styles";
+import { useDataStore } from "@ogw_front/stores/data";
+
+interface ModelMenuMetaData {
+  modelId?: string;
+  pickedComponentId?: string;
+  viewer_type?: string;
+  modelComponentType?: string;
+  targetComponentIds?: string[];
+}
+
+interface ModelMenuItemProps {
+  id: string;
+  meta_data: Record<string, unknown>;
+}
+
+interface ModelMenuContext {
+  modelId: ComputedRef<string>;
+  componentId: ComputedRef<string | undefined>;
+  componentType: Ref<string | undefined>;
+  collections: Ref<CollectionComponent[] | undefined>;
+  targetComponentIds: Ref<string[]>;
+}
+
+// Resolves what a model context menu targets: the whole model, a component type, a collection or one component
+// oxlint-disable-next-line max-lines-per-function
+function useModelMenuContext(getItemProps: () => ModelMenuItemProps): ModelMenuContext {
+  const dataStore = useDataStore();
+  // oxlint-disable-next-line no-unsafe-type-assertion -- meta_data is filled by the viewer context menu with these keys.
+  const metaData = computed(() => getItemProps().meta_data as ModelMenuMetaData);
+
+  const modelId = computed<string>(() => metaData.value.modelId ?? getItemProps().id);
+  const componentId = computed<string | undefined>(() => metaData.value.pickedComponentId);
+  const componentType = ref<string | undefined>(undefined);
+  const collections = ref<CollectionComponent[] | undefined>(undefined);
+
+  watch(
+    () => [
+      modelId.value,
+      componentId.value,
+      metaData.value.viewer_type,
+      metaData.value.modelComponentType,
+    ],
+    async () => {
+      componentType.value = undefined;
+      collections.value = undefined;
+      if (metaData.value.viewer_type === "model_component_type") {
+        const { modelComponentType = "", targetComponentIds: ids = [] } = metaData.value;
+        if (MESH_COMPONENT_TYPES.includes(modelComponentType)) {
+          componentType.value = modelComponentType;
+        } else {
+          const collectionsByType = await dataStore.fetchAllCollectionComponents(modelId.value);
+          collections.value = (collectionsByType[modelComponentType] ?? []).filter((collection) =>
+            collection.children.every((child) => ids.includes(child.id)),
+          );
+          componentType.value = collections.value[0]?.children[0]?.category;
+        }
+      } else if (componentId.value !== undefined && modelId.value !== "") {
+        const currentModelId = modelId.value;
+        const currentCompId = componentId.value;
+        const type = await dataStore.meshComponentType(currentModelId, currentCompId);
+        if (
+          modelId.value === currentModelId &&
+          componentId.value === currentCompId &&
+          metaData.value.viewer_type !== "model_component_type"
+        ) {
+          componentType.value = type;
+        }
+      }
+    },
+    { immediate: true },
+  );
+
+  const targetComponentIds = ref<string[]>([]);
+  watch(
+    () => [modelId.value, componentType.value, metaData.value.targetComponentIds],
+    async () => {
+      targetComponentIds.value = [];
+      if (metaData.value.targetComponentIds !== undefined) {
+        targetComponentIds.value = metaData.value.targetComponentIds;
+        return;
+      }
+      if (componentType.value !== undefined && modelId.value !== "") {
+        const currentModelId = modelId.value;
+        const currentType = componentType.value;
+        const ids = await dataStore.getMeshComponentGeodeIds(currentModelId, currentType);
+        if (modelId.value === currentModelId && componentType.value === currentType) {
+          targetComponentIds.value = ids;
+        }
+      }
+    },
+    { immediate: true },
+  );
+
+  return { modelId, componentId, componentType, collections, targetComponentIds };
+}
+
+export { useModelMenuContext };
+export type { ModelMenuItemProps };

package/app/composables/use_quick_colormap.ts

@@ -9,11 +9,13 @@ export function useQuickColormap(): {
   const viewerStore = useViewerStore();
   const quickColormap = reactive<{
     data_id: string | undefined;
+    block_ids: number[] | undefined;
     show: boolean;
     x: number;
     y: number;
   }>({
     data_id: undefined,
+    block_ids: undefined,
     show: false,
     x: 0,
     y: 0,
@@ -28,9 +30,10 @@ export function useQuickColormap(): {
     try {
       const schema = viewer_schemas.opengeodeweb_viewer.viewer.pick_colormap;
       const params = { x: offsetX, y: offsetY };
-      const { data_id } = await viewerStore.request({ schema, params });
+      const { data_id, block_ids } = await viewerStore.request({ schema, params });
       if (data_id !== undefined && data_id !== "") {
         quickColormap.data_id = data_id;
+        quickColormap.block_ids = block_ids;
         quickColormap.x = clientX;
         quickColormap.y = clientY;
         quickColormap.show = true;

package/app/stores/data.ts

@@ -285,6 +285,17 @@ export const useDataStore = defineStore("data", () => {
       .first();
     return component;
   }
+  async function getComponentsByViewerIds(
+    modelId: string,
+    viewer_ids: number[],
+  ): Promise<ModelComponentRecord[]> {
+    const components = await model_components_db
+      .where("viewer_id")
+      .anyOf(viewer_ids)
+      .and((model_component: ModelComponentRecord) => model_component.id === modelId)
+      .toArray();
+    return components;
+  }
   async function deleteModelComponents(modelId: string): Promise<void> {
     await model_components_db.where("id").equals(modelId).delete();
     await model_components_relation_db.where("id").equals(modelId).delete();
@@ -365,6 +376,7 @@ export const useDataStore = defineStore("data", () => {
     getAllModelComponentsViewerIds,
     getMeshComponentsViewerIds,
     getComponentByViewerId,
+    getComponentsByViewerIds,
     exportStores,
     importStores,
     clear,

package/app/utils/attribute_range.ts

@@ -19,38 +19,38 @@ interface AttributeRangeTarget {
 }
 
 // A data never changes once imported: selectors showing the same attribute share one request
-const rangeRequests = new Map<string, Promise<AttributeRangeInfo | undefined>>();
+const rangeRequests = new Map<string, Promise<AttributeRangeInfo>>();
 
 async function requestAttributeRange(
   rangeSchema: JsonRpcSchema,
   params: Record<string, unknown>,
-  key: string,
-): Promise<AttributeRangeInfo | undefined> {
+): Promise<AttributeRangeInfo> {
   const backStore = useBackStore();
-  try {
-    const range = await backStore.request({ schema: rangeSchema, params });
-    // oxlint-disable-next-line no-unsafe-type-assertion -- every *_attribute_range schema shares this response.
-    return range as AttributeRangeInfo;
-  } catch {
-    rangeRequests.delete(key);
-    return undefined;
-  }
+  const range = await backStore.request({ schema: rangeSchema, params });
+  // oxlint-disable-next-line no-unsafe-type-assertion -- every *_attribute_range schema shares this response.
+  return range as AttributeRangeInfo;
 }
 
 async function fetchAttributeRange(
   rangeSchema: JsonRpcSchema,
   target: AttributeRangeTarget,
   attributeName: string,
-): Promise<AttributeRangeInfo | undefined> {
+): Promise<AttributeRangeInfo> {
   const params = { ...target, attribute_name: attributeName };
   const key = JSON.stringify([rangeSchema.$id, params]);
   let request = rangeRequests.get(key);
   if (request === undefined) {
-    request = requestAttributeRange(rangeSchema, params, key);
+    request = requestAttributeRange(rangeSchema, params);
     rangeRequests.set(key, request);
   }
-  const range = await request;
-  return range;
+  try {
+    const range = await request;
+    return range;
+  } catch (error) {
+    // A failed request is not kept: the next call retries it
+    rangeRequests.delete(key);
+    throw error;
+  }
 }
 
 export { type AttributeRangeInfo, type AttributeSchemas, fetchAttributeRange };

package/internal/stores/data_style/model/blocks/index.ts

@@ -7,6 +7,7 @@ import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksColor } from "./color";
 import { useModelBlocksCommonStyle } from "./common";
+import { useModelBlocksPointsStyle } from "./points";
 import { useModelBlocksVisibility } from "./visibility";
 
 interface ColorGroup {
@@ -34,6 +35,7 @@ type UseModelBlocksStyleReturn = {
 } & ReturnType<typeof useModelBlocksCommonStyle> &
   ReturnType<typeof useModelBlocksVisibility> &
   ReturnType<typeof useModelBlocksColor> &
+  ReturnType<typeof useModelBlocksPointsStyle> &
   ReturnType<typeof useModelBlocksVertexAttribute> &
   ReturnType<typeof useModelBlocksPolyhedronAttribute>;
 
@@ -45,6 +47,7 @@ export function useModelBlocksStyle(): UseModelBlocksStyleReturn {
   const modelColorStyle = useModelBlocksColor();
   const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
   const modelBlocksPolyhedronAttribute = useModelBlocksPolyhedronAttribute();
+  const modelBlocksPointsStyle = useModelBlocksPointsStyle();
 
   async function applyModelBlocksVisibilityStyle(
     modelId: string,
@@ -245,5 +248,6 @@ export function useModelBlocksStyle(): UseModelBlocksStyleReturn {
     ...modelColorStyle,
     ...modelBlocksVertexAttribute,
     ...modelBlocksPolyhedronAttribute,
+    ...modelBlocksPointsStyle,
   };
 }

package/internal/stores/data_style/model/blocks/points.ts

@@ -0,0 +1,51 @@
+import {
+  type ModelComponentPointsStyle,
+  useModelComponentPointsStyle,
+} from "@ogw_internal/stores/data_style/model/points/component";
+
+interface UseModelBlocksPointsStyleReturn {
+  modelBlockPointsVisibility: ModelComponentPointsStyle["visibility"];
+  modelBlockPointsSize: ModelComponentPointsStyle["size"];
+  modelBlockPointsColor: ModelComponentPointsStyle["color"];
+  modelBlockPointsActiveColoring: ModelComponentPointsStyle["activeColoring"];
+  modelBlockPointsVertexAttributeName: ModelComponentPointsStyle["vertexAttributeName"];
+  modelBlockPointsVertexAttributeItem: ModelComponentPointsStyle["vertexAttributeItem"];
+  modelBlockPointsVertexAttributeRange: ModelComponentPointsStyle["vertexAttributeRange"];
+  modelBlockPointsVertexAttributeColorMap: ModelComponentPointsStyle["vertexAttributeColorMap"];
+  modelBlockPointsVertexAttributeNoDataColor: ModelComponentPointsStyle["vertexAttributeNoDataColor"];
+  setModelBlocksPointsVisibility: ModelComponentPointsStyle["setVisibility"];
+  setModelBlocksPointsSize: ModelComponentPointsStyle["setSize"];
+  setModelBlocksPointsColor: ModelComponentPointsStyle["setColor"];
+  setModelBlocksPointsActiveColoring: ModelComponentPointsStyle["setActiveColoring"];
+  setModelBlocksPointsVertexAttributeName: ModelComponentPointsStyle["setVertexAttributeName"];
+  setModelBlocksPointsVertexAttributeItem: ModelComponentPointsStyle["setVertexAttributeItem"];
+  setModelBlocksPointsVertexAttributeRange: ModelComponentPointsStyle["setVertexAttributeRange"];
+  setModelBlocksPointsVertexAttributeColorMap: ModelComponentPointsStyle["setVertexAttributeColorMap"];
+  setModelBlocksPointsVertexAttributeNoDataColor: ModelComponentPointsStyle["setVertexAttributeNoDataColor"];
+  applyModelBlocksPointsStyle: ModelComponentPointsStyle["applyPointsStyle"];
+}
+
+export function useModelBlocksPointsStyle(): UseModelBlocksPointsStyleReturn {
+  const points = useModelComponentPointsStyle("Block");
+  return {
+    modelBlockPointsVisibility: points.visibility,
+    modelBlockPointsSize: points.size,
+    modelBlockPointsColor: points.color,
+    modelBlockPointsActiveColoring: points.activeColoring,
+    modelBlockPointsVertexAttributeName: points.vertexAttributeName,
+    modelBlockPointsVertexAttributeItem: points.vertexAttributeItem,
+    modelBlockPointsVertexAttributeRange: points.vertexAttributeRange,
+    modelBlockPointsVertexAttributeColorMap: points.vertexAttributeColorMap,
+    modelBlockPointsVertexAttributeNoDataColor: points.vertexAttributeNoDataColor,
+    setModelBlocksPointsVisibility: points.setVisibility,
+    setModelBlocksPointsSize: points.setSize,
+    setModelBlocksPointsColor: points.setColor,
+    setModelBlocksPointsActiveColoring: points.setActiveColoring,
+    setModelBlocksPointsVertexAttributeName: points.setVertexAttributeName,
+    setModelBlocksPointsVertexAttributeItem: points.setVertexAttributeItem,
+    setModelBlocksPointsVertexAttributeRange: points.setVertexAttributeRange,
+    setModelBlocksPointsVertexAttributeColorMap: points.setVertexAttributeColorMap,
+    setModelBlocksPointsVertexAttributeNoDataColor: points.setVertexAttributeNoDataColor,
+    applyModelBlocksPointsStyle: points.applyPointsStyle,
+  };
+}

package/internal/stores/data_style/model/index.ts

@@ -61,6 +61,12 @@ function useModelStyle(): UseModelStyleReturn {
       modelPointsStyle.applyModelPointsStyle(modelId),
       modelEdgesStyle.applyModelEdgesStyle(modelId),
     ]);
+    // Components points come after the model points, which override every component
+    await Promise.all([
+      modelSurfacesStyle.applyModelSurfacesPointsStyle(modelId),
+      modelLinesStyle.applyModelLinesPointsStyle(modelId),
+      modelBlocksStyle.applyModelBlocksPointsStyle(modelId),
+    ]);
     return results;
   }
 

package/internal/stores/data_style/model/lines/index.ts

@@ -4,6 +4,7 @@ import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelLinesColor } from "./color";
 import { useModelLinesCommonStyle } from "./common";
+import { useModelLinesPointsStyle } from "./points";
 import { useModelLinesVisibility } from "./visibility";
 
 interface ColorGroup {
@@ -29,6 +30,7 @@ async function setModelLinesDefaultStyle(_id: string): Promise<void> {
 export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle> &
   ReturnType<typeof useModelLinesVisibility> &
   ReturnType<typeof useModelLinesColor> &
+  ReturnType<typeof useModelLinesPointsStyle> &
   ReturnType<typeof useModelLinesVertexAttribute> &
   ReturnType<typeof useModelLinesEdgeAttribute> & {
     applyModelLinesStyle: (modelId: string) => Promise<void>;
@@ -40,6 +42,7 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
   const modelColorStyle = useModelLinesColor();
   const modelLinesVertexAttribute = useModelLinesVertexAttribute();
   const modelLinesEdgeAttribute = useModelLinesEdgeAttribute();
+  const modelLinesPointsStyle = useModelLinesPointsStyle();
 
   async function applyModelLinesVisibilityStyle(
     modelId: string,
@@ -232,5 +235,6 @@ export function useModelLinesStyle(): ReturnType<typeof useModelLinesCommonStyle
     ...modelColorStyle,
     ...modelLinesVertexAttribute,
     ...modelLinesEdgeAttribute,
+    ...modelLinesPointsStyle,
   };
 }

package/internal/stores/data_style/model/lines/points.ts

@@ -0,0 +1,51 @@
+import {
+  type ModelComponentPointsStyle,
+  useModelComponentPointsStyle,
+} from "@ogw_internal/stores/data_style/model/points/component";
+
+interface UseModelLinesPointsStyleReturn {
+  modelLinePointsVisibility: ModelComponentPointsStyle["visibility"];
+  modelLinePointsSize: ModelComponentPointsStyle["size"];
+  modelLinePointsColor: ModelComponentPointsStyle["color"];
+  modelLinePointsActiveColoring: ModelComponentPointsStyle["activeColoring"];
+  modelLinePointsVertexAttributeName: ModelComponentPointsStyle["vertexAttributeName"];
+  modelLinePointsVertexAttributeItem: ModelComponentPointsStyle["vertexAttributeItem"];
+  modelLinePointsVertexAttributeRange: ModelComponentPointsStyle["vertexAttributeRange"];
+  modelLinePointsVertexAttributeColorMap: ModelComponentPointsStyle["vertexAttributeColorMap"];
+  modelLinePointsVertexAttributeNoDataColor: ModelComponentPointsStyle["vertexAttributeNoDataColor"];
+  setModelLinesPointsVisibility: ModelComponentPointsStyle["setVisibility"];
+  setModelLinesPointsSize: ModelComponentPointsStyle["setSize"];
+  setModelLinesPointsColor: ModelComponentPointsStyle["setColor"];
+  setModelLinesPointsActiveColoring: ModelComponentPointsStyle["setActiveColoring"];
+  setModelLinesPointsVertexAttributeName: ModelComponentPointsStyle["setVertexAttributeName"];
+  setModelLinesPointsVertexAttributeItem: ModelComponentPointsStyle["setVertexAttributeItem"];
+  setModelLinesPointsVertexAttributeRange: ModelComponentPointsStyle["setVertexAttributeRange"];
+  setModelLinesPointsVertexAttributeColorMap: ModelComponentPointsStyle["setVertexAttributeColorMap"];
+  setModelLinesPointsVertexAttributeNoDataColor: ModelComponentPointsStyle["setVertexAttributeNoDataColor"];
+  applyModelLinesPointsStyle: ModelComponentPointsStyle["applyPointsStyle"];
+}
+
+export function useModelLinesPointsStyle(): UseModelLinesPointsStyleReturn {
+  const points = useModelComponentPointsStyle("Line");
+  return {
+    modelLinePointsVisibility: points.visibility,
+    modelLinePointsSize: points.size,
+    modelLinePointsColor: points.color,
+    modelLinePointsActiveColoring: points.activeColoring,
+    modelLinePointsVertexAttributeName: points.vertexAttributeName,
+    modelLinePointsVertexAttributeItem: points.vertexAttributeItem,
+    modelLinePointsVertexAttributeRange: points.vertexAttributeRange,
+    modelLinePointsVertexAttributeColorMap: points.vertexAttributeColorMap,
+    modelLinePointsVertexAttributeNoDataColor: points.vertexAttributeNoDataColor,
+    setModelLinesPointsVisibility: points.setVisibility,
+    setModelLinesPointsSize: points.setSize,
+    setModelLinesPointsColor: points.setColor,
+    setModelLinesPointsActiveColoring: points.setActiveColoring,
+    setModelLinesPointsVertexAttributeName: points.setVertexAttributeName,
+    setModelLinesPointsVertexAttributeItem: points.setVertexAttributeItem,
+    setModelLinesPointsVertexAttributeRange: points.setVertexAttributeRange,
+    setModelLinesPointsVertexAttributeColorMap: points.setVertexAttributeColorMap,
+    setModelLinesPointsVertexAttributeNoDataColor: points.setVertexAttributeNoDataColor,
+    applyModelLinesPointsStyle: points.applyPointsStyle,
+  };
+}