@geode/opengeodeweb-front 10.22.1 → 10.23.0-rc.2

package/app/stores/app.js

@@ -2,6 +2,7 @@
 import { api_fetch } from "@ogw_internal/utils/api_fetch.js";
 import { upload_file } from "@ogw_internal/utils/upload_file.js";
 
+// oxlint-disable-next-line max-lines-per-function, max-statements
 export const useAppStore = defineStore("app", () => {
   const stores = [];
 

package/app/stores/hybrid_viewer.js

@@ -184,9 +184,28 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     });
   }
 
+  let renderPromise = undefined;
+  let renderPending = false;
+
   function remoteRender() {
-    const schema = viewer_schemas.opengeodeweb_viewer.viewer.render;
-    return viewerStore.request({ schema });
+    if (renderPromise) {
+      renderPending = true;
+      return renderPromise;
+    }
+
+    renderPromise = (async () => {
+      try {
+        const schema = viewer_schemas.opengeodeweb_viewer.viewer.render;
+        await viewerStore.request({ schema });
+      } finally {
+        renderPromise = undefined;
+        if (renderPending) {
+          renderPending = false;
+          await remoteRender();
+        }
+      }
+    })();
+    return renderPromise;
   }
 
   const hoverTimeoutRef = ref(undefined);

package/app/utils/default_styles/constants.js

@@ -0,0 +1,57 @@
+// Mesh
+const POINTS_DEFAULT_VISIBILITY = true;
+const POINTS_DEFAULT_SIZE = 10;
+const POINTS_DEFAULT_COLOR = { red: 20, green: 20, blue: 20, alpha: 1 };
+const EDGES_DEFAULT_VISIBILITY = true;
+const EDGES_DEFAULT_WIDTH = 2;
+const EDGES_DEFAULT_COLOR = { red: 20, green: 20, blue: 20, alpha: 1 };
+const CELLS_DEFAULT_VISIBILITY = true;
+const CELLS_DEFAULT_COLOR = { red: 255, green: 255, blue: 255, alpha: 1 };
+const POLYGONS_DEFAULT_VISIBILITY = true;
+const POLYGONS_DEFAULT_COLOR = { red: 255, green: 255, blue: 255, alpha: 1 };
+const POLYHEDRA_DEFAULT_VISIBILITY = true;
+const POLYHEDRA_DEFAULT_COLOR = { red: 255, green: 255, blue: 255, alpha: 1 };
+
+// Model
+const CORNERS_DEFAULT_VISIBILITY = true;
+const CORNERS_DEFAULT_COLOR = { red: 20, green: 20, blue: 20, alpha: 1 };
+const LINES_DEFAULT_VISIBILITY = true;
+const LINES_DEFAULT_COLOR = { red: 20, green: 20, blue: 20, alpha: 1 };
+const SURFACES_DEFAULT_VISIBILITY = true;
+const SURFACES_DEFAULT_COLOR = { red: 255, green: 255, blue: 255, alpha: 1 };
+const BLOCKS_DEFAULT_VISIBILITY = true;
+const BLOCKS_DEFAULT_COLOR = { red: 255, green: 255, blue: 255, alpha: 1 };
+
+const MESH_COMPONENT_TYPES = ["Corner", "Line", "Surface", "Block"];
+
+const DEFAULT_MODEL_COMPONENT_TYPE_COLORS = {
+  Corner: CORNERS_DEFAULT_COLOR,
+  Line: LINES_DEFAULT_COLOR,
+  Surface: SURFACES_DEFAULT_COLOR,
+  Block: BLOCKS_DEFAULT_COLOR,
+};
+
+export {
+  POINTS_DEFAULT_VISIBILITY,
+  POINTS_DEFAULT_SIZE,
+  POINTS_DEFAULT_COLOR,
+  EDGES_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_WIDTH,
+  EDGES_DEFAULT_COLOR,
+  CELLS_DEFAULT_VISIBILITY,
+  CELLS_DEFAULT_COLOR,
+  POLYGONS_DEFAULT_VISIBILITY,
+  POLYGONS_DEFAULT_COLOR,
+  POLYHEDRA_DEFAULT_VISIBILITY,
+  POLYHEDRA_DEFAULT_COLOR,
+  CORNERS_DEFAULT_VISIBILITY,
+  CORNERS_DEFAULT_COLOR,
+  LINES_DEFAULT_VISIBILITY,
+  LINES_DEFAULT_COLOR,
+  SURFACES_DEFAULT_VISIBILITY,
+  SURFACES_DEFAULT_COLOR,
+  BLOCKS_DEFAULT_VISIBILITY,
+  BLOCKS_DEFAULT_COLOR,
+  MESH_COMPONENT_TYPES,
+  DEFAULT_MODEL_COMPONENT_TYPE_COLORS,
+};

package/app/utils/default_styles/index.js

@@ -0,0 +1,54 @@
+import {
+  brepDefaultStyle,
+  crossSectionDefaultStyle,
+  implicitCrossSectionDefaultStyle,
+  implicitStructuralModelDefaultStyle,
+  sectionDefaultStyle,
+  structuralModelDefaultStyle,
+} from "./models";
+import {
+  edgedCurveDefaultStyle,
+  grid2dDefaultStyle,
+  grid3dDefaultStyle,
+  pointSetDefaultStyle,
+  solidDefaultStyle,
+  surfaceDefaultStyle,
+} from "./meshes";
+
+function default_styles() {
+  return {
+    BRep: brepDefaultStyle(),
+    CrossSection: crossSectionDefaultStyle(),
+    EdgedCurve2D: edgedCurveDefaultStyle(),
+    EdgedCurve3D: edgedCurveDefaultStyle(),
+    Graph: {},
+    HybridSolid3D: solidDefaultStyle(),
+    ImplicitCrossSection: implicitCrossSectionDefaultStyle(),
+    ImplicitStructuralModel: implicitStructuralModelDefaultStyle(),
+    LightRegularGrid2D: grid2dDefaultStyle(),
+    LightRegularGrid3D: grid3dDefaultStyle(),
+    PointSet2D: pointSetDefaultStyle(),
+    PointSet3D: pointSetDefaultStyle(),
+    PolygonalSurface2D: surfaceDefaultStyle(),
+    PolygonalSurface3D: surfaceDefaultStyle(),
+    PolyhedralSolid3D: solidDefaultStyle(),
+    RasterImage2D: {},
+    RasterImage3D: {},
+    RegularGrid2D: grid2dDefaultStyle(),
+    RegularGrid3D: grid3dDefaultStyle(),
+    Section: sectionDefaultStyle(),
+    StructuralModel: structuralModelDefaultStyle(),
+    TetrahedralSolid3D: solidDefaultStyle(),
+    TriangulatedSurface2D: surfaceDefaultStyle(),
+    TriangulatedSurface3D: surfaceDefaultStyle(),
+    VertexSet: {},
+  };
+}
+
+function getDefaultStyle(type) {
+  return default_styles()[type];
+}
+
+export { DEFAULT_MODEL_COMPONENT_TYPE_STYLES } from "./models";
+export { MESH_COMPONENT_TYPES, DEFAULT_MODEL_COMPONENT_TYPE_COLORS } from "./constants";
+export { getDefaultStyle };

package/app/utils/default_styles/meshes.js

@@ -0,0 +1,185 @@
+import {
+  CELLS_DEFAULT_COLOR,
+  CELLS_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_COLOR,
+  EDGES_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_WIDTH,
+  POINTS_DEFAULT_COLOR,
+  POINTS_DEFAULT_SIZE,
+  POINTS_DEFAULT_VISIBILITY,
+  POLYGONS_DEFAULT_COLOR,
+  POLYGONS_DEFAULT_VISIBILITY,
+  POLYHEDRA_DEFAULT_COLOR,
+  POLYHEDRA_DEFAULT_VISIBILITY,
+} from "./constants";
+
+function meshPointsDefaultStyle(
+  visibility = POINTS_DEFAULT_VISIBILITY,
+  size = POINTS_DEFAULT_SIZE,
+  color = POINTS_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      vertex: {
+        name: undefined,
+        storedConfigs: {},
+      },
+    },
+    size,
+  };
+}
+
+function meshEdgesDefaultStyle(
+  visibility = EDGES_DEFAULT_VISIBILITY,
+  width = EDGES_DEFAULT_WIDTH,
+  color = EDGES_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      edge: {
+        name: undefined,
+        storedConfigs: {},
+      },
+      vertex: {
+        name: undefined,
+        storedConfigs: {},
+      },
+    },
+    width,
+  };
+}
+
+function meshCellsDefaultStyle(visibility = CELLS_DEFAULT_VISIBILITY, color = CELLS_DEFAULT_COLOR) {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      cell: {
+        name: undefined,
+        storedConfigs: {},
+      },
+      color,
+      textures: undefined,
+      vertex: {
+        name: undefined,
+        storedConfigs: {},
+      },
+    },
+  };
+}
+
+function meshPolygonsDefaultStyle(
+  visibility = POLYGONS_DEFAULT_VISIBILITY,
+  color = POLYGONS_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      textures: undefined,
+      polygon: {
+        name: undefined,
+        storedConfigs: {},
+      },
+      vertex: {
+        name: undefined,
+        storedConfigs: {},
+      },
+    },
+  };
+}
+
+function meshPolyhedraDefaultStyle(
+  visibility = POLYHEDRA_DEFAULT_VISIBILITY,
+  color = POLYHEDRA_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    coloring: {
+      active: "color",
+      color,
+      polyhedron: {
+        name: undefined,
+        storedConfigs: {},
+      },
+      vertex: {
+        name: undefined,
+        storedConfigs: {},
+      },
+    },
+  };
+}
+
+function pointSetDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(),
+  };
+}
+
+function edgedCurveDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(),
+    edges: meshEdgesDefaultStyle(),
+  };
+}
+
+function grid2dDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    cells: meshCellsDefaultStyle(),
+  };
+}
+
+function grid3dDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    cells: meshCellsDefaultStyle(),
+    polyhedra: meshPolyhedraDefaultStyle(),
+  };
+}
+
+function surfaceDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+  };
+}
+
+function solidDefaultStyle() {
+  return {
+    visibility: true,
+    points: meshPointsDefaultStyle(false),
+    edges: meshEdgesDefaultStyle(false),
+    polygons: meshPolygonsDefaultStyle(),
+    polyhedra: meshPolyhedraDefaultStyle(),
+  };
+}
+
+export {
+  meshPointsDefaultStyle,
+  meshEdgesDefaultStyle,
+  meshCellsDefaultStyle,
+  meshPolygonsDefaultStyle,
+  meshPolyhedraDefaultStyle,
+  pointSetDefaultStyle,
+  edgedCurveDefaultStyle,
+  grid2dDefaultStyle,
+  grid3dDefaultStyle,
+  surfaceDefaultStyle,
+  solidDefaultStyle,
+};

package/app/utils/default_styles/models.js

@@ -0,0 +1,192 @@
+import {
+  BLOCKS_DEFAULT_COLOR,
+  BLOCKS_DEFAULT_VISIBILITY,
+  CORNERS_DEFAULT_COLOR,
+  CORNERS_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_VISIBILITY,
+  EDGES_DEFAULT_WIDTH,
+  LINES_DEFAULT_COLOR,
+  LINES_DEFAULT_VISIBILITY,
+  POINTS_DEFAULT_SIZE,
+  POINTS_DEFAULT_VISIBILITY,
+  SURFACES_DEFAULT_COLOR,
+  SURFACES_DEFAULT_VISIBILITY,
+} from "./constants";
+
+function modelCornersDefaultStyle(
+  visibility = CORNERS_DEFAULT_VISIBILITY,
+  color = CORNERS_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    color,
+    color_mode: "constant",
+    vertex_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+  };
+}
+
+function modelLinesDefaultStyle(
+  visibility = LINES_DEFAULT_VISIBILITY,
+  color = LINES_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    color,
+    color_mode: "constant",
+    vertex_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+    edge_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+  };
+}
+
+function modelSurfacesDefaultStyle(
+  visibility = SURFACES_DEFAULT_VISIBILITY,
+  color = SURFACES_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    color,
+    color_mode: "constant",
+    vertex_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+    polygon_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+  };
+}
+
+function modelBlocksDefaultStyle(
+  visibility = BLOCKS_DEFAULT_VISIBILITY,
+  color = BLOCKS_DEFAULT_COLOR,
+) {
+  return {
+    visibility,
+    color,
+    color_mode: "constant",
+    vertex_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+    polyhedron_attribute: {
+      name: undefined,
+      storedConfigs: {},
+    },
+  };
+}
+
+function modelPointsDefaultStyle(
+  visibility = POINTS_DEFAULT_VISIBILITY,
+  size = POINTS_DEFAULT_SIZE,
+) {
+  return { visibility, size };
+}
+
+function modelEdgesDefaultStyle(
+  visibility = EDGES_DEFAULT_VISIBILITY,
+  width = EDGES_DEFAULT_WIDTH,
+) {
+  return { visibility, width };
+}
+
+const DEFAULT_MODEL_COMPONENT_TYPE_STYLES = {
+  Corner: modelCornersDefaultStyle(),
+  Line: modelLinesDefaultStyle(),
+  Surface: modelSurfacesDefaultStyle(),
+  Block: modelBlocksDefaultStyle(),
+};
+
+function brepDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+function crossSectionDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+function structuralModelDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+function sectionDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+function implicitCrossSectionDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+function implicitStructuralModelDefaultStyle() {
+  return {
+    visibility: true,
+    corners: modelCornersDefaultStyle(),
+    lines: modelLinesDefaultStyle(),
+    surfaces: modelSurfacesDefaultStyle(),
+    blocks: modelBlocksDefaultStyle(),
+    points: modelPointsDefaultStyle(false),
+    edges: modelEdgesDefaultStyle(false),
+  };
+}
+
+export {
+  modelCornersDefaultStyle,
+  modelLinesDefaultStyle,
+  modelSurfacesDefaultStyle,
+  modelBlocksDefaultStyle,
+  modelPointsDefaultStyle,
+  modelEdgesDefaultStyle,
+  DEFAULT_MODEL_COMPONENT_TYPE_STYLES,
+  brepDefaultStyle,
+  crossSectionDefaultStyle,
+  structuralModelDefaultStyle,
+  sectionDefaultStyle,
+  implicitCrossSectionDefaultStyle,
+  implicitStructuralModelDefaultStyle,
+};

package/internal/stores/data_style/model/blocks/color.js

@@ -16,5 +16,10 @@ export function useModelBlocksColor() {
     return modelCommonStyle.setModelTypeColor(modelId, blocks_ids, color, schema, color_mode);
   }
 
-  return { setModelBlocksColor, modelBlockColor };
+  function modelBlockColorMode(id, block_id) {
+    const mode = modelBlocksCommonStyle.modelBlockStyle(id, block_id).color_mode || "constant";
+    return mode === "constant" ? "color" : mode;
+  }
+
+  return { setModelBlocksColor, modelBlockColor, modelBlockColorMode };
 }

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

@@ -1,6 +1,8 @@
 import { useDataStore } from "@ogw_front/stores/data";
 import { useModelBlocksColor } from "./color";
 import { useModelBlocksCommonStyle } from "./common";
+import { useModelBlocksPolyhedronAttribute } from "./polyhedron";
+import { useModelBlocksVertexAttribute } from "./vertex";
 import { useModelBlocksVisibility } from "./visibility";
 
 async function setModelBlocksDefaultStyle(_id) {
@@ -12,6 +14,8 @@ export function useModelBlocksStyle() {
   const modelCommonStyle = useModelBlocksCommonStyle();
   const modelVisibilityStyle = useModelBlocksVisibility();
   const modelColorStyle = useModelBlocksColor();
+  const modelBlocksVertexAttribute = useModelBlocksVertexAttribute();
+  const modelBlocksPolyhedronAttribute = useModelBlocksPolyhedronAttribute();
 
   async function applyModelBlocksStyle(modelId) {
     const blocks_ids = await dataStore.getBlocksGeodeIds(modelId);
@@ -21,6 +25,7 @@ export function useModelBlocksStyle() {
 
     const visibilityGroups = {};
     const colorGroups = {};
+    const attributeGroups = {};
 
     for (const block_id of blocks_ids) {
       const style = modelCommonStyle.modelBlockStyle(modelId, block_id);
@@ -32,11 +37,34 @@ export function useModelBlocksStyle() {
       visibilityGroups[visibility].push(block_id);
 
       const color_mode = style.color_mode || "constant";
-      const color_key = color_mode === "random" ? "random" : JSON.stringify(style.color);
-      if (!colorGroups[color_key]) {
-        colorGroups[color_key] = { color_mode, color: style.color, blocks_ids: [] };
+      if (color_mode === "constant" || color_mode === "random") {
+        const color_key = color_mode === "random" ? "random" : JSON.stringify(style.color);
+        if (!colorGroups[color_key]) {
+          colorGroups[color_key] = { color_mode, color: style.color, blocks_ids: [] };
+        }
+        colorGroups[color_key].blocks_ids.push(block_id);
+      } else {
+        const attributeTypeKey = `${color_mode}_attribute`;
+        const attributeStyle = style[attributeTypeKey] || {};
+        const { name } = attributeStyle;
+        if (name) {
+          const storedConfig =
+            (attributeStyle.storedConfigs && attributeStyle.storedConfigs[name]) || {};
+          const { minimum, maximum, colorMap } = storedConfig;
+          const attributeGroupKey = `${color_mode}_${name}_${colorMap}_${minimum}_${maximum}`;
+          if (!attributeGroups[attributeGroupKey]) {
+            attributeGroups[attributeGroupKey] = {
+              color_mode,
+              name,
+              minimum,
+              maximum,
+              colorMap,
+              blocks_ids: [],
+            };
+          }
+          attributeGroups[attributeGroupKey].blocks_ids.push(block_id);
+        }
       }
-      colorGroups[color_key].blocks_ids.push(block_id);
     }
 
     const promises = [
@@ -46,6 +74,32 @@ export function useModelBlocksStyle() {
       ...Object.values(colorGroups).map(({ color_mode, color, blocks_ids: ids }) =>
         modelColorStyle.setModelBlocksColor(modelId, ids, color, color_mode),
       ),
+      ...Object.values(attributeGroups).flatMap(
+        ({ color_mode, name, minimum, maximum, colorMap, blocks_ids: ids }) => {
+          const isVertex = color_mode === "vertex";
+          const attributeStyle = isVertex
+            ? modelBlocksVertexAttribute
+            : modelBlocksPolyhedronAttribute;
+          const setAttributeName = isVertex
+            ? attributeStyle.setModelBlocksVertexAttributeName
+            : attributeStyle.setModelBlocksPolyhedronAttributeName;
+          const setAttributeRange = isVertex
+            ? attributeStyle.setModelBlocksVertexAttributeRange
+            : attributeStyle.setModelBlocksPolyhedronAttributeRange;
+          const setAttributeColorMap = isVertex
+            ? attributeStyle.setModelBlocksVertexAttributeColorMap
+            : attributeStyle.setModelBlocksPolyhedronAttributeColorMap;
+
+          const list = [setAttributeName(modelId, ids, name)];
+          if (minimum !== undefined && maximum !== undefined) {
+            list.push(setAttributeRange(modelId, ids, minimum, maximum));
+          }
+          if (colorMap) {
+            list.push(setAttributeColorMap(modelId, ids, colorMap));
+          }
+          return list;
+        },
+      ),
     ];
 
     return Promise.all(promises);
@@ -57,5 +111,7 @@ export function useModelBlocksStyle() {
     ...modelCommonStyle,
     ...modelVisibilityStyle,
     ...modelColorStyle,
+    ...modelBlocksVertexAttribute,
+    ...modelBlocksPolyhedronAttribute,
   };
 }