@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/internal/stores/data_style/state.js

@@ -1,197 +0,0 @@
-import { database } from "@ogw_internal/database/database";
-import { liveQuery } from "dexie";
-import merge from "lodash/merge";
-import { useObservable } from "@vueuse/rxjs";
-
-let sharedState = undefined;
-
-function getSharedState() {
-  if (sharedState) {
-    return sharedState;
-  }
-
-  const dataStyleTable = database.data_style;
-  const modelComponentDataStyleTable = database.model_component_datastyle;
-  const modelComponentTypeDataStyleTable = database.model_component_type_datastyle;
-
-  const styles = useObservable(
-    liveQuery(async () => {
-      const objectStyles = await dataStyleTable.toArray();
-      const stylesByObjectId = {};
-      for (const objectStyle of objectStyles) {
-        stylesByObjectId[objectStyle.id] = objectStyle;
-      }
-      return stylesByObjectId;
-    }),
-    { initialValue: {} },
-  );
-
-  const modelComponentTypeStyles = ref({});
-  const componentStyles = ref({});
-
-  async function loadFromDatabase() {
-    const [fetchedTypeStyles, fetchedComponentStyles] = await Promise.all([
-      modelComponentTypeDataStyleTable.toArray(),
-      modelComponentDataStyleTable.toArray(),
-    ]);
-    const typeStylesMap = {};
-    for (const typeStyle of fetchedTypeStyles) {
-      const cacheKey = `${typeStyle.id_model}_${typeStyle.type}`;
-      typeStylesMap[cacheKey] = typeStyle;
-    }
-    modelComponentTypeStyles.value = typeStylesMap;
-
-    const componentStylesMap = {};
-    for (const componentStyle of fetchedComponentStyles) {
-      const cacheKey = `${componentStyle.id_model}_${componentStyle.id_component}`;
-      componentStylesMap[cacheKey] = componentStyle;
-    }
-    componentStyles.value = componentStylesMap;
-  }
-
-  loadFromDatabase();
-
-  function updateComponentStyleCache(modelId, componentId, styleValues) {
-    const cacheKey = `${modelId}_${componentId}`;
-    const existingStyle = componentStyles.value[cacheKey];
-    if (existingStyle) {
-      merge(existingStyle, styleValues);
-    } else {
-      componentStyles.value[cacheKey] = merge(
-        { id_model: modelId, id_component: componentId },
-        styleValues,
-      );
-    }
-  }
-
-  function bulkUpdateComponentStyleCache(modelId, componentStyleUpdates) {
-    const updatedComponentStyles = { ...componentStyles.value };
-    for (const { id_component: componentId, values: styleValues } of componentStyleUpdates) {
-      const cacheKey = `${modelId}_${componentId}`;
-      const existingStyle = updatedComponentStyles[cacheKey];
-      if (existingStyle) {
-        updatedComponentStyles[cacheKey] = merge({}, existingStyle, styleValues);
-      } else {
-        updatedComponentStyles[cacheKey] = merge(
-          { id_model: modelId, id_component: componentId },
-          styleValues,
-        );
-      }
-    }
-    componentStyles.value = updatedComponentStyles;
-  }
-
-  function bulkUpdateComponentStylesCache(modelId, componentIds, styleValues) {
-    const updatedComponentStyles = { ...componentStyles.value };
-    for (const componentId of componentIds) {
-      const cacheKey = `${modelId}_${componentId}`;
-      const existingStyle = updatedComponentStyles[cacheKey];
-      if (existingStyle) {
-        updatedComponentStyles[cacheKey] = merge({}, existingStyle, styleValues);
-      } else {
-        updatedComponentStyles[cacheKey] = merge(
-          { id_model: modelId, id_component: componentId },
-          styleValues,
-        );
-      }
-    }
-    componentStyles.value = updatedComponentStyles;
-  }
-
-  function updateModelComponentTypeStyleCache(modelId, componentType, styleValues) {
-    const cacheKey = `${modelId}_${componentType}`;
-    if (!modelComponentTypeStyles.value[cacheKey]) {
-      modelComponentTypeStyles.value[cacheKey] = { id_model: modelId, type: componentType };
-    }
-    merge(modelComponentTypeStyles.value[cacheKey], styleValues);
-  }
-
-  function updateStyleCache(objectId, styleValues) {
-    if (!styles.value[objectId]) {
-      styles.value[objectId] = { id: objectId };
-    }
-    merge(styles.value[objectId], styleValues);
-  }
-
-  sharedState = {
-    styles,
-    modelComponentTypeStyles,
-    componentStyles,
-    loadFromDatabase,
-    updateComponentStyleCache,
-    bulkUpdateComponentStyleCache,
-    bulkUpdateComponentStylesCache,
-    updateModelComponentTypeStyleCache,
-    updateStyleCache,
-  };
-
-  return sharedState;
-}
-
-export function useDataStyleState() {
-  const dataStyleTable = database.data_style;
-  const modelComponentDataStyleTable = database.model_component_datastyle;
-  const modelComponentTypeDataStyleTable = database.model_component_type_datastyle;
-
-  const state = getSharedState();
-  const { styles, modelComponentTypeStyles, componentStyles } = state;
-
-  const objectVisibility = computed(() => (objectId) => {
-    if (styles.value[objectId]) {
-      return styles.value[objectId].visibility;
-    }
-    return false;
-  });
-
-  const selectedObjects = computed(() => {
-    const visibleObjectIds = [];
-    for (const [objectId, objectStyle] of Object.entries(styles.value)) {
-      if (objectStyle.visibility === true) {
-        visibleObjectIds.push(objectId);
-      }
-    }
-    return visibleObjectIds;
-  });
-
-  function getStyle(objectId) {
-    return { ...toRaw(styles.value[objectId]) };
-  }
-
-  function mutateStyle(objectId, styleValues) {
-    state.updateStyleCache(objectId, styleValues);
-    const currentStyle = getStyle(objectId);
-    merge(currentStyle, styleValues);
-    return dataStyleTable.put(structuredClone({ id: objectId, ...toRaw(currentStyle) }));
-  }
-
-  function getComponentStyle(modelId, componentId) {
-    const cacheKey = `${modelId}_${componentId}`;
-    return merge({ coloring: {} }, componentStyles.value[cacheKey]);
-  }
-
-  function getModelComponentTypeStyle(modelId, componentType) {
-    const cacheKey = `${modelId}_${componentType}`;
-    return merge({ coloring: {} }, modelComponentTypeStyles.value[cacheKey]);
-  }
-
-  async function clear() {
-    await Promise.all([
-      dataStyleTable.clear(),
-      modelComponentDataStyleTable.clear(),
-      modelComponentTypeDataStyleTable.clear(),
-    ]);
-    modelComponentTypeStyles.value = {};
-    componentStyles.value = {};
-  }
-
-  return {
-    ...state,
-    getStyle,
-    getComponentStyle,
-    getModelComponentTypeStyle,
-    mutateStyle,
-    objectVisibility,
-    selectedObjects,
-    clear,
-  };
-}

package/internal/stores/hybrid_viewer/brightness.js

@@ -1,82 +0,0 @@
-import { BACKGROUND_GREY_VALUE, RGB_MAX } from "./constants";
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
-
-const RGBA_CHANNELS = 4;
-const SAMPLE_SIZE = 10;
-const TOTAL_CHANNELS = 400;
-function mapRect(rect, latestImage, canvasRect) {
-  const scaleX = latestImage.width / canvasRect.width;
-  const scaleY = latestImage.height / canvasRect.height;
-  return {
-    relX: (rect.x - canvasRect.left) * scaleX,
-    relY: (rect.y - canvasRect.top) * scaleY,
-    relW: rect.width * scaleX,
-    relH: rect.height * scaleY,
-  };
-}
-function computeAverageBrightness(rect, options) {
-  const { latestImage, offscreenCtx, offscreenCanvas } = options;
-  const { genericRenderWindow } = useHybridViewerStore();
-  if (!latestImage || !offscreenCtx || !offscreenCanvas || !genericRenderWindow.value) {
-    return BACKGROUND_GREY_VALUE / RGB_MAX;
-  }
-  const canvas = genericRenderWindow.value.getApiSpecificRenderWindow().getCanvas();
-  if (!canvas) {
-    return BACKGROUND_GREY_VALUE / RGB_MAX;
-  }
-  if (rect.width <= 0 || rect.height <= 0) {
-    return BACKGROUND_GREY_VALUE / RGB_MAX;
-  }
-  const { relX, relY, relW, relH } = mapRect(rect, latestImage, canvas.getBoundingClientRect());
-  if (relW <= 0 || relH <= 0) {
-    return BACKGROUND_GREY_VALUE / RGB_MAX;
-  }
-  offscreenCanvas.width = SAMPLE_SIZE;
-  offscreenCanvas.height = SAMPLE_SIZE;
-  try {
-    offscreenCtx.drawImage(
-      latestImage,
-      Math.max(0, relX),
-      Math.max(0, relY),
-      Math.min(latestImage.width, relW),
-      Math.min(latestImage.height, relH),
-      0,
-      0,
-      SAMPLE_SIZE,
-      SAMPLE_SIZE,
-    );
-    const { data } = offscreenCtx.getImageData(0, 0, SAMPLE_SIZE, SAMPLE_SIZE);
-    let minBrightness = 1;
-    for (let i = 0; i < TOTAL_CHANNELS; i += RGBA_CHANNELS) {
-      const brightness = (data[i] + data[i + 1] + data[i + 2]) / (3 * RGB_MAX);
-      if (brightness < minBrightness) {
-        minBrightness = brightness;
-      }
-    }
-    return minBrightness;
-  } catch {
-    return BACKGROUND_GREY_VALUE / RGB_MAX;
-  }
-}
-function useHybridViewerBrightness() {
-  const latestImage = ref(undefined);
-  const offscreenCanvas =
-    typeof document === "undefined" ? undefined : document.createElement("canvas");
-  const offscreenCtx = offscreenCanvas
-    ? offscreenCanvas.getContext("2d", {
-        willReadFrequently: true,
-      })
-    : undefined;
-  function getAverageBrightness(rect) {
-    return computeAverageBrightness(rect, {
-      latestImage: latestImage.value,
-      offscreenCtx,
-      offscreenCanvas,
-    });
-  }
-  return {
-    latestImage,
-    getAverageBrightness,
-  };
-}
-export { computeAverageBrightness, useHybridViewerBrightness };

package/internal/stores/hybrid_viewer/camera.js

@@ -1,274 +0,0 @@
-import {
-  LONG_ANIMATION_DURATION,
-  SHORT_ANIMATION_DURATION,
-  animateCamera,
-  computeAnimationDuration,
-} from "./camera_animation";
-import { dot } from "@kitware/vtk.js/Common/Core/Math";
-import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
-import { useViewerStore } from "@ogw_front/stores/viewer";
-import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
-
-const BUMP_MULTIPLIER = 0.2;
-const ALIGNMENT_THRESHOLD = 0.9;
-const EASE_EXPONENT = 1.1;
-const ORIENTATIONS = {
-  zplus: {
-    position: [0, 0, 1],
-    view_up: [0, 1, 0],
-  },
-  zminus: {
-    position: [0, 0, -1],
-    view_up: [0, 1, 0],
-  },
-  yplus: {
-    position: [0, 1, 0],
-    view_up: [0, 0, 1],
-  },
-  yminus: {
-    position: [0, -1, 0],
-    view_up: [0, 0, 1],
-  },
-  xplus: {
-    position: [1, 0, 0],
-    view_up: [0, 0, 1],
-  },
-  xminus: {
-    position: [-1, 0, 0],
-    view_up: [0, 0, 1],
-  },
-};
-function getImageStyle() {
-  const { genericRenderWindow } = useHybridViewerStore();
-  if (!genericRenderWindow.value) {
-    return undefined;
-  }
-  const webGLRenderWindow = genericRenderWindow.value.getApiSpecificRenderWindow();
-  if (!webGLRenderWindow) {
-    return undefined;
-  }
-  const bgImage = webGLRenderWindow.getReferenceByName("bgImage");
-  return bgImage ? bgImage.style : undefined;
-}
-function getCameraOptions(camera) {
-  if (!camera || !camera.getFocalPoint) {
-    return camera;
-  }
-  return {
-    focal_point: [...(camera.getFocalPoint() ?? [])],
-    view_up: [...(camera.getViewUp() ?? [])],
-    position: [...(camera.getPosition() ?? [])],
-    view_angle: camera.getViewAngle(),
-    clipping_range: [...(camera.getClippingRange() ?? [])],
-    distance: camera.getDistance(),
-  };
-}
-function performSyncRemoteCamera() {
-  const { genericRenderWindow, camera_options, remoteRender } = useHybridViewerStore();
-  const viewerStore = useViewerStore();
-  const renderer = genericRenderWindow.value.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const options_camera = getCameraOptions(camera);
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
-  const params = {
-    camera_options: options_camera,
-  };
-  viewerStore.request(
-    {
-      schema,
-      params,
-    },
-    {
-      response_function: () => {
-        remoteRender();
-        if (camera_options) {
-          Object.assign(camera_options, options_camera);
-        }
-      },
-    },
-  );
-}
-function applyCameraOptions(camera, options) {
-  if (camera && camera.set && options) {
-    camera.set({
-      focalPoint: options.focal_point,
-      viewUp: options.view_up,
-      position: options.position,
-      viewAngle: options.view_angle,
-      clippingRange: options.clipping_range,
-    });
-  }
-}
-
-function performSetCamera(targetCameraOptions) {
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow } = hybridViewerStore;
-  const { is_moving } = storeToRefs(hybridViewerStore);
-  const imageStyle = getImageStyle();
-  const renderer = genericRenderWindow.value.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const startState = getCameraOptions(camera);
-  const duration = computeAnimationDuration(startState, targetCameraOptions);
-  is_moving.value = true;
-  if (imageStyle) {
-    imageStyle.opacity = 0;
-  }
-  animateCamera({
-    camera,
-    startState,
-    targetState: targetCameraOptions,
-    duration,
-    bumpMultiplier: 0,
-    easeExponent: EASE_EXPONENT,
-    onUpdate: () => {
-      const renderWindow = genericRenderWindow.value.getRenderWindow();
-      renderWindow.render();
-    },
-    onEnd: () => {
-      applyCameraOptions(camera, targetCameraOptions);
-      const renderWindow = genericRenderWindow.value.getRenderWindow();
-      renderWindow.render();
-      is_moving.value = false;
-      performSyncRemoteCamera();
-    },
-  });
-}
-async function performFocusCameraOnObject(id, block_ids = []) {
-  const { genericRenderWindow, hybridDb } = useHybridViewerStore();
-  if (!hybridDb[id]) {
-    return;
-  }
-  const viewerStore = useViewerStore();
-  let bounds = [];
-  if (block_ids.length > 0) {
-    const schema = viewer_schemas.opengeodeweb_viewer.model.get_blocks_bounds;
-    const params = {
-      id,
-      block_ids,
-    };
-    bounds = await viewerStore.request({
-      schema,
-      params,
-    });
-  } else {
-    bounds = hybridDb[id].actor.getBounds();
-  }
-  const renderer = genericRenderWindow.value.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const startOptions = getCameraOptions(camera);
-  renderer.resetCamera(bounds);
-  const targetOptions = getCameraOptions(camera);
-  applyCameraOptions(camera, startOptions);
-  performSetCamera(targetOptions);
-}
-function performCameraOrientation(orientation) {
-  const hybridViewerStore = useHybridViewerStore();
-  const { genericRenderWindow } = hybridViewerStore;
-  const { is_moving } = storeToRefs(hybridViewerStore);
-  const imageStyle = getImageStyle();
-  const config = ORIENTATIONS[orientation.toLowerCase()];
-  const renderer = genericRenderWindow.value.getRenderer();
-  const camera = renderer.getActiveCamera();
-  const startState = getCameraOptions(camera);
-  applyCameraOptions(camera, {
-    ...config,
-    focal_point: [0, 0, 0],
-  });
-  renderer.resetCamera();
-  const targetState = getCameraOptions(camera);
-  applyCameraOptions(camera, startState);
-  const alignment = dot(camera.getDirectionOfProjection(), config.position);
-  const duration =
-    alignment > ALIGNMENT_THRESHOLD ? LONG_ANIMATION_DURATION : SHORT_ANIMATION_DURATION;
-  is_moving.value = true;
-  if (imageStyle) {
-    imageStyle.opacity = 0;
-  }
-  animateCamera({
-    camera,
-    startState,
-    targetState,
-    duration,
-    bumpMultiplier: BUMP_MULTIPLIER,
-    easeExponent: EASE_EXPONENT,
-    onUpdate: () => {
-      const renderWindow = genericRenderWindow.value.getRenderWindow();
-      renderWindow.render();
-    },
-    onEnd: () => {
-      is_moving.value = false;
-      performSyncRemoteCamera();
-    },
-  });
-}
-function useHybridViewerCamera() {
-  const camera_options = reactive({});
-  function syncRemoteCamera() {
-    performSyncRemoteCamera();
-  }
-  function setCamera(targetCameraOptions) {
-    performSetCamera(targetCameraOptions);
-  }
-  function resetCamera() {
-    const { genericRenderWindow } = useHybridViewerStore();
-    const renderer = genericRenderWindow.value.getRenderer();
-    renderer.resetCamera();
-    const renderWindow = genericRenderWindow.value.getRenderWindow();
-    renderWindow.render();
-    syncRemoteCamera();
-  }
-  async function focusCameraOnObject(id, block_ids = []) {
-    await performFocusCameraOnObject(id, block_ids);
-  }
-  function setCameraOrientation(orientation) {
-    performCameraOrientation(orientation);
-  }
-  return {
-    camera_options,
-    syncRemoteCamera,
-    setCamera,
-    resetCamera,
-    focusCameraOnObject,
-    setCameraOrientation,
-  };
-}
-function centerCameraOnPosition(camera, pickedPosition) {
-  if (!camera || !pickedPosition) {
-    return;
-  }
-  const focalPoint = camera.getFocalPoint();
-  const position = camera.getPosition();
-  camera.setFocalPoint(...pickedPosition);
-  camera.setPosition(
-    position[0] + pickedPosition[0] - focalPoint[0],
-    position[1] + pickedPosition[1] - focalPoint[1],
-    position[2] + pickedPosition[2] - focalPoint[2],
-  );
-}
-async function applySnapshot(snapshot) {
-  if (!snapshot) {
-    return;
-  }
-  const { setZScaling, setCamera } = useHybridViewerStore();
-  if (typeof snapshot.zScale === "number") {
-    await setZScaling(snapshot.zScale);
-  }
-  if (snapshot.camera_options) {
-    setCamera(snapshot.camera_options);
-  }
-}
-export {
-  ALIGNMENT_THRESHOLD,
-  BUMP_MULTIPLIER,
-  EASE_EXPONENT,
-  ORIENTATIONS,
-  applyCameraOptions,
-  applySnapshot,
-  centerCameraOnPosition,
-  getCameraOptions,
-  performCameraOrientation,
-  performFocusCameraOnObject,
-  performSetCamera,
-  performSyncRemoteCamera,
-  useHybridViewerCamera,
-};