@geode/opengeodeweb-front 10.31.0 → 10.31.1-rc.1

package/internal/stores/hybrid_viewer.js

@@ -1,300 +0,0 @@
-import { centerCameraOnPosition } from "./hybrid_viewer_camera";
-
-function performClickPicking(event, options) {
-  const { container, viewerStore, viewer_schemas, genericRenderWindow, syncRemoteCamera } = options;
-  const rect = container.getBoundingClientRect();
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.get_point_position;
-  const params = {
-    x: Math.round(event.clientX - rect.left),
-    y: Math.round(rect.height - (event.clientY - rect.top)),
-  };
-  viewerStore.request(
-    {
-      schema,
-      params,
-    },
-    {
-      response_function: ({ x, y, z }) => {
-        const pickedPos = [x, y, z];
-        if (pickedPos.some((val) => val !== 0)) {
-          const camera = genericRenderWindow.getRenderer().getActiveCamera();
-          centerCameraOnPosition(camera, pickedPos);
-          genericRenderWindow.getRenderWindow().render();
-          syncRemoteCamera();
-        }
-      },
-    },
-  );
-}
-
-function performHoverHighlight(event, options) {
-  const {
-    is_hover_highlight,
-    genericRenderWindow,
-    viewerStore,
-    viewer_schemas,
-    hover_highlight_field_type,
-    hybridDb,
-    onResponse,
-  } = options;
-  if (!is_hover_highlight.value) {
-    return;
-  }
-  const container = genericRenderWindow.getContainer();
-  if (!container) {
-    return;
-  }
-  const rect = container.getBoundingClientRect();
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.highlight;
-  const params = {
-    x: Math.round(event.clientX - rect.left),
-    y: Math.round(rect.height - (event.clientY - rect.top)),
-    field_type: hover_highlight_field_type.value,
-    ids: Object.keys(hybridDb),
-  };
-  viewerStore.request(
-    {
-      schema,
-      params,
-    },
-    {
-      response_function: onResponse,
-    },
-  );
-}
-
-function performClearHoverHighlight(options) {
-  const { viewerStore, viewer_schemas, hover_highlight_field_type, hybridDb } = options;
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.highlight;
-  const params = {
-    x: -1,
-    y: -1,
-    field_type: hover_highlight_field_type.value,
-    ids: Object.keys(hybridDb),
-  };
-  viewerStore.request({ schema, params });
-}
-
-async function performAddItem(id, options) {
-  const {
-    genericRenderWindow,
-    dataStore,
-    vtkXMLPolyDataReader,
-    vtkActor,
-    vtkMapper,
-    actorColor,
-    hybridDb,
-  } = options;
-  if (!genericRenderWindow) {
-    return;
-  }
-  const value = await dataStore.item(id);
-  if (value && !dataStore.isItemViewable(value)) {
-    return;
-  }
-  const reader = vtkXMLPolyDataReader();
-  await reader.parseAsArrayBuffer(new TextEncoder().encode(value.binary_light_viewable));
-  const actor = vtkActor();
-  const mapper = vtkMapper();
-  const polydata = reader.getOutputData(0);
-  mapper.setInputData(polydata);
-  actor.getProperty().setColor(actorColor);
-  actor.setMapper(mapper);
-  const renderer = genericRenderWindow.getRenderer();
-  if (hybridDb[id] && hybridDb[id].actor) {
-    renderer.removeActor(hybridDb[id].actor);
-  }
-  const isFirst = renderer.getActors().length === 0;
-  renderer.addActor(actor);
-  if (isFirst) {
-    renderer.resetCamera();
-  }
-  hybridDb[id] = { actor, polydata, mapper };
-}
-
-async function performSetZScaling(z_scale, options) {
-  const { zScale, genericRenderWindow, gridActor, viewerStore, viewer_schemas, remoteRender } =
-    options;
-  zScale.value = z_scale;
-  const renderer = genericRenderWindow.getRenderer();
-  for (const actor of renderer.getActors()) {
-    if (actor !== gridActor) {
-      const scale = actor.getScale();
-      actor.setScale(scale[0], scale[1], z_scale);
-    }
-  }
-  renderer.resetCamera();
-  genericRenderWindow.getRenderWindow().render();
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.set_z_scaling;
-  const params = { z_scale };
-  await viewerStore.request({ schema, params });
-  remoteRender();
-}
-
-function performSetContainer(options) {
-  const {
-    container,
-    genericRenderWindow,
-    imageStyleSetter,
-    resize,
-    useMousePressed,
-    useEventListener,
-    is_picking,
-    is_moving,
-    clickPickingCallback,
-    viewerStore,
-    viewer_schemas,
-    syncRemoteCamera,
-    hoverHighlight,
-    wheelTimeoutMs,
-    wheelEventEndTimeout,
-    wheelTimeoutSetter,
-  } = options;
-
-  if (!container.value) {
-    return;
-  }
-
-  genericRenderWindow.setContainer(container.value.$el);
-  const webGLRenderWindow = genericRenderWindow.getApiSpecificRenderWindow();
-  webGLRenderWindow.setUseBackgroundImage(true);
-  const imageStyle = webGLRenderWindow.getReferenceByName("bgImage").style;
-  Object.assign(imageStyle, { transition: "opacity 0.1s ease-in", zIndex: 1 });
-  imageStyleSetter(imageStyle);
-
-  resize(container.value.$el.offsetWidth, container.value.$el.offsetHeight);
-
-  let has_dragged = false;
-  useMousePressed({
-    target: container,
-    onPressed: (event) => {
-      if (event.button !== 0 && event.button !== 1) {
-        return;
-      }
-      if (event.button === 0 && is_picking.value) {
-        clickPickingCallback(event, {
-          container: container.value.$el,
-          viewerStore,
-          viewer_schemas,
-          genericRenderWindow,
-          syncRemoteCamera,
-        });
-        is_picking.value = false;
-        return;
-      }
-      is_moving.value = true;
-      has_dragged = false;
-      event.stopPropagation();
-    },
-    onReleased: () => {
-      is_moving.value = false;
-      if (has_dragged) {
-        genericRenderWindow.getRenderer().resetCameraClippingRange();
-        syncRemoteCamera();
-      }
-      has_dragged = false;
-    },
-  });
-
-  useEventListener(container, "mousemove", (event) => {
-    if (is_moving.value) {
-      has_dragged = true;
-      if (imageStyle) {
-        imageStyle.opacity = 0;
-      }
-    }
-    hoverHighlight(event);
-  });
-  useEventListener(container, "wheel", () => {
-    is_moving.value = true;
-    if (imageStyle) {
-      imageStyle.opacity = 0;
-    }
-    clearTimeout(wheelEventEndTimeout);
-    wheelTimeoutSetter(
-      setTimeout(() => {
-        is_moving.value = false;
-        genericRenderWindow.getRenderer().resetCameraClippingRange();
-        syncRemoteCamera();
-      }, wheelTimeoutMs),
-    );
-  });
-}
-
-function performRemoveItem(id, options) {
-  const { genericRenderWindow, hybridDb } = options;
-  if (!hybridDb[id]) {
-    return;
-  }
-  genericRenderWindow.getRenderer().removeActor(hybridDb[id].actor);
-  genericRenderWindow.getRenderWindow().render();
-  delete hybridDb[id];
-}
-
-function performSetVisibility(id, visibility, options) {
-  const { genericRenderWindow, hybridDb } = options;
-  if (!hybridDb[id]) {
-    return;
-  }
-  hybridDb[id].actor.setVisibility(visibility);
-  genericRenderWindow.getRenderWindow().render();
-}
-
-function performClear(options) {
-  const { genericRenderWindow, hybridDb } = options;
-  const renderer = genericRenderWindow.getRenderer();
-  for (const actor of renderer.getActors()) {
-    renderer.removeActor(actor);
-  }
-  genericRenderWindow.getRenderWindow().render();
-  for (const id of Object.keys(hybridDb)) {
-    delete hybridDb[id];
-  }
-}
-
-async function performSetClippingPlanes(ids, planes, options) {
-  const { viewerStore, viewer_schemas, remoteRender } = options;
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.clipping_planes;
-  const params = { ids, planes };
-  await viewerStore.request({ schema, params });
-  await remoteRender();
-}
-
-async function performSetShrink(ids, shrink_factor, options) {
-  const { viewerStore, viewer_schemas, remoteRender } = options;
-  const schema = viewer_schemas.opengeodeweb_viewer.viewer.shrink;
-  const params = { ids, shrink_factor };
-  await viewerStore.request({ schema, params });
-  await remoteRender();
-}
-
-async function performResize(width, height, options) {
-  const { viewerStore, status, Status, genericRenderWindow, viewStream, remoteRender } = options;
-  if (viewerStore.status !== Status.CONNECTED || status.value !== Status.CREATED) {
-    return;
-  }
-  const webGLRenderWindow = genericRenderWindow.getApiSpecificRenderWindow();
-  const canvas = webGLRenderWindow.getCanvas();
-  canvas.width = width;
-  canvas.height = height;
-  await nextTick();
-  webGLRenderWindow.setSize(width, height);
-  viewStream.setSize(width, height);
-  genericRenderWindow.getRenderWindow().render();
-  remoteRender();
-}
-
-export {
-  performAddItem,
-  performClear,
-  performClearHoverHighlight,
-  performClickPicking,
-  performHoverHighlight,
-  performRemoveItem,
-  performResize,
-  performSetClippingPlanes,
-  performSetContainer,
-  performSetShrink,
-  performSetVisibility,
-  performSetZScaling,
-};

package/internal/stores/hybrid_viewer_highlight.js

@@ -1,114 +0,0 @@
-import { HOVER_DEBOUNCE_MS, HOVER_TIMEOUT_MS } from "./hybrid_viewer_constants";
-import { database } from "@ogw_internal/database/database.js";
-import { performHoverHighlight } from "./hybrid_viewer";
-
-function createClearHoverData(hoverTimeoutRef, hoverData, currentHoverId) {
-  return function clearHoverData() {
-    if (hoverTimeoutRef.value) {
-      clearTimeout(hoverTimeoutRef.value);
-      hoverTimeoutRef.value = undefined;
-    }
-    hoverData.value = undefined;
-    currentHoverId.value = undefined;
-  };
-}
-
-function createHoverHighlight(options) {
-  const {
-    genericRenderWindow,
-    is_hover_highlight,
-    viewerStore,
-    viewer_schemas,
-    hover_highlight_field_type,
-    hybridDb,
-    hoverData,
-    hoverPosition,
-    currentHoverId,
-    hoverTimeoutRef,
-    clearHoverData,
-  } = options;
-
-  return useDebounceFn((event) => {
-    const containerElement = genericRenderWindow.value?.getContainer();
-    let relativeMousePosition = { x: 0, y: 0 };
-    if (containerElement) {
-      const containerRect = containerElement.getBoundingClientRect();
-      relativeMousePosition = {
-        x: event.clientX - containerRect.left,
-        y: event.clientY - containerRect.top,
-      };
-    } else {
-      relativeMousePosition = { x: event.clientX, y: event.clientY };
-    }
-
-    performHoverHighlight(event, {
-      is_hover_highlight,
-      genericRenderWindow: genericRenderWindow.value,
-      viewerStore,
-      viewer_schemas,
-      hover_highlight_field_type,
-      hybridDb,
-      onResponse: async (response) => {
-        const isResponseValid =
-          response && response.id && response.picked_id !== undefined && response.picked_id !== -1;
-        if (!is_hover_highlight.value || !isResponseValid) {
-          clearHoverData();
-          return;
-        }
-
-        const hoverKey = `${response.id}_${response.field_type}_${response.picked_id}`;
-        if (currentHoverId.value === hoverKey) {
-          return;
-        }
-
-        if (hoverTimeoutRef.value) {
-          clearTimeout(hoverTimeoutRef.value);
-          hoverTimeoutRef.value = undefined;
-        }
-
-        hoverData.value = undefined;
-        currentHoverId.value = hoverKey;
-
-        let componentInfo = undefined;
-        let modelName = undefined;
-
-        const modelRecord = await database.data.get(response.id);
-        if (modelRecord) {
-          modelName = modelRecord.name;
-        }
-
-        if (response.geode_id) {
-          const component = await database.model_components
-            .where("[id+geode_id]")
-            .equals([response.id, response.geode_id])
-            .first();
-          if (component) {
-            componentInfo = {
-              name: component.name,
-              id: component.geode_id,
-              type: component.type,
-            };
-          }
-        }
-
-        const newHoverData = {
-          modelId: response.id,
-          modelName,
-          blockName: response.geode_id,
-          pickedId: response.picked_id,
-          fieldType: response.field_type,
-          component: componentInfo,
-          attributes: response.attributes || {},
-        };
-
-        hoverTimeoutRef.value = setTimeout(() => {
-          hoverPosition.value = relativeMousePosition;
-          hoverData.value = newHoverData;
-          hoverTimeoutRef.value = undefined;
-        }, HOVER_TIMEOUT_MS);
-      },
-    });
-  }, HOVER_DEBOUNCE_MS);
-}
-
-export { createClearHoverData, createHoverHighlight };