@inweb/viewer-visualize 25.3.13

package/src/Viewer/Draggers/OdZoomWindowDragger/OdSelectionFrame.ts

@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+import { Point3d } from "../Common/Geometry";
+
+export class OdSelectionFrame {
+  protected m_start: number[];
+  protected m_end: number[];
+  protected m_model: any;
+  protected m_module: any;
+  protected m_entity: any;
+  protected m_frame: any;
+
+  constructor() {
+    this.m_start = [0, 0, 0]; // 0
+    this.m_end = [0, 0, 0]; // 2
+
+    this.m_model = null;
+  }
+
+  createPoint3d(): Point3d {
+    return new this.m_module.Point3d();
+  }
+
+  init(instance: any, model: any): void {
+    this.m_module = instance;
+    this.m_model = model;
+  }
+
+  getViewer() {
+    return this.m_module.getViewer();
+  }
+
+  setValue(value: number[]): void {
+    this.m_end = value;
+    this.draw();
+  }
+
+  setStartPoint(point: number[]): void {
+    this.m_start = point;
+    this.m_end = point;
+    this.draw();
+  }
+
+  toDoubleArray(points: Point3d[]): number[] {
+    const p: number[] = [];
+    for (let i = 0; i < points.length; i++) {
+      p.push(points[i].x);
+      p.push(points[i].y);
+      p.push(points[i].z);
+    }
+    return p;
+  }
+
+  draw(): void {
+    const view = this.getViewer().activeView;
+    const viewM = view.viewingMatrix;
+
+    const points = [];
+    points.push(this.m_start);
+    points.push(this.createPoint3d());
+    points.push(this.m_end);
+    points.push(this.createPoint3d());
+
+    const p0 = this.createPoint3d();
+    p0.set(this.m_start[0], this.m_start[1], this.m_start[2]);
+
+    const p2 = this.createPoint3d();
+    p2.set(this.m_end[0], this.m_end[1], this.m_end[2]);
+
+    p0.transformBy(viewM);
+    p2.transformBy(viewM);
+
+    points[1].x = p0.x;
+    points[3].x = p2.x;
+    points[1].y = p2.y;
+    points[3].y = p0.y;
+    points[1].z = points[3].z = p2.z;
+
+    const eyeM = view.eyeToWorldMatrix;
+    points[1].transformBy(eyeM);
+    points[3].transformBy(eyeM);
+
+    if (!this.m_entity) {
+      this.m_entity = this.m_model.appendEntity("");
+      const entityPtr = this.m_entity.openObject();
+
+      entityPtr.setColor(112, 112, 112);
+      entityPtr.setLineWeight(2);
+
+      this.m_frame = entityPtr.appendPolygon(this.toDoubleArray(points));
+      entityPtr.delete();
+    } else {
+      this.m_frame.openAsPolygon().setPoints(this.toDoubleArray(points));
+    }
+  }
+
+  clear(): void {
+    if (this.m_entity) {
+      this.m_model.removeEntity(this.m_entity);
+      this.m_entity = null;
+    }
+  }
+}

package/src/Viewer/Draggers/OdZoomWindowDragger/index.ts

@@ -0,0 +1,75 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+/* eslint-disable no-unused-vars */
+
+import { Viewer } from "../../Viewer";
+import { OdBaseDragger } from "../Common/OdBaseDragger";
+import { OdSelectionFrame } from "./OdSelectionFrame";
+
+export class OdZoomWindowDragger extends OdBaseDragger {
+  protected m_frame: any;
+  protected m_minX: number;
+  protected m_minY: number;
+  protected m_maxX: number;
+  protected m_maxY: number;
+
+  constructor(subject: Viewer) {
+    super(subject);
+    this.autoSelect = true;
+    this.press = false;
+    this.needInputText = false;
+
+    this.m_frame = new OdSelectionFrame();
+    this.m_frame.init(this.m_module, this.getModel());
+  }
+
+  override start(x: number, y: number): void {
+    this.press = true;
+    this.m_minX = x;
+    this.m_minY = y;
+
+    const startPoint = this.screenToWorld(x, y);
+    this.m_frame.setStartPoint(startPoint);
+  }
+
+  override drag(x: number, y: number, dltX: number, dltY: number): void {
+    if (this.press) {
+      this.m_maxX = x;
+      this.m_maxY = y;
+
+      const point = this.screenToWorld(x, y);
+      this.m_frame.setValue(point);
+    }
+  }
+
+  override end(x: number, y: number): void {
+    this.press = false;
+    this.m_maxX = x;
+    this.m_maxY = y;
+
+    if (this.m_minX !== this.m_maxX && this.m_minY !== this.m_maxY) {
+      this.m_frame.clear();
+      this.getViewer().zoomWindow(this.m_minX, this.m_minY, this.m_maxX, this.m_maxY);
+    }
+  }
+}

package/src/Viewer/Draggers/OdaLineDragger.ts

@@ -0,0 +1,80 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+import { Viewer } from "../Viewer";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+export const MARKUP_ENTITY_LINE = "$MarkupTempEntity_Line";
+
+export class OdaLineDragger extends OdBaseDragger {
+  protected entity: any;
+  protected points: any[];
+  protected drawPoints: any[];
+
+  constructor(subject: Viewer) {
+    super(subject);
+    this.press = false;
+  }
+
+  override dispose(): void {
+    super.dispose();
+    this.end();
+    this.points = null;
+    this.drawPoints = null;
+  }
+
+  override start(x: number, y: number): void {
+    const point = this.getViewer().screenToWorld(x, y);
+    this.drawPoints = [point[0], point[1], point[2]];
+  }
+
+  override drag(x: number, y: number): void {
+    if (this.isDragging) {
+      const point = this.getViewer().screenToWorld(x, y);
+      this.drawPoints.push(point[0], point[1], point[2]);
+      this._updateFrame();
+    }
+  }
+
+  override end(): void {
+    if (this.entity) {
+      this.entity.delete();
+      this.drawPoints = null;
+      this.entity = null;
+    }
+  }
+
+  private _updateFrame(): void {
+    if (this.entity) {
+      const model = this.getViewer().getMarkupModel();
+      model.removeEntity(this.entity);
+      model.delete();
+      this.entity.delete();
+    }
+
+    this.entity = this.getActiveMarkupEntity(MARKUP_ENTITY_LINE);
+
+    const entityPtr = this.entity.openObject();
+    entityPtr.appendPolyline(this.drawPoints).delete();
+    entityPtr.delete();
+  }
+}

package/src/Viewer/Draggers/OdaTextDragger.ts

@@ -0,0 +1,118 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+import { Viewer } from "../Viewer";
+import { Point3d } from "./Common/Geometry";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+export const MARKUP_ENTITY_TEXT = "$MarkupTempEntity_Text";
+
+export class OdaTextDragger extends OdBaseDragger {
+  protected textRef: HTMLTextAreaElement;
+  protected m_center: Point3d;
+  protected entity: any;
+  protected readonly TEXT_HEIGHT_ALIGN = 24;
+
+  constructor(subject: Viewer) {
+    super(subject);
+    this.press = false;
+  }
+
+  override dispose(): void {
+    super.dispose();
+    this.textRef?.remove();
+    this.textRef = null;
+  }
+
+  private _finishInput(): void {
+    if (this.textRef && this.textRef.value.trimLeft()) {
+      this._updateFrame();
+    }
+    this.textRef?.remove();
+    this.textRef = null;
+  }
+
+  override start(x: number, y: number, absoluteX: number, absoluteY: number) {
+    if (!this.textRef) {
+      this.textRef = document.createElement("textarea");
+      this.textRef.style.zIndex = "9999";
+      this.textRef.style.position = "absolute";
+      this.textRef.style.display = "block";
+      this.textRef.style.top = absoluteY + "px";
+      this.textRef.style.left = absoluteX + "px";
+      this.textRef.onkeypress = (event) => {
+        if (event.key === "Enter") {
+          event.preventDefault();
+          this._finishInput();
+        }
+      };
+      document.body.appendChild(this.textRef);
+
+      this.press = true;
+      this.m_center = this.screenToWorld(x, y + this.TEXT_HEIGHT_ALIGN);
+      this.needInputText = true;
+    } else {
+      this._finishInput();
+    }
+  }
+
+  private _updateFrame(): void {
+    this.entity = this.getActiveMarkupEntity(MARKUP_ENTITY_TEXT);
+    const entityPtr = this.entity.openObject();
+
+    const view = this.getViewer().activeView;
+    const pos = this.toPoint(view.viewPosition);
+    const target = this.toPoint(view.viewTarget);
+
+    const eyeToWorld = view.eyeToWorldMatrix;
+    const eyeDir = pos.sub(target).asVector();
+
+    const xDir = this.toVector([1.0, 0.0, 0.0]);
+    const direction = xDir.transformBy(eyeToWorld);
+
+    const mtrx = this.createMatrix3d();
+    mtrx.setToWorldToPlane(this.toGeVector(eyeDir));
+    direction.transformBy(mtrx);
+
+    const angel = -Math.atan2(-direction.y, direction.x);
+
+    const textSize = 0.02;
+    let textScale = 1.0;
+
+    const projMtrx = view.projectionMatrix;
+    const mtrxNumber = projMtrx.get(1, 1);
+    const tol = 1.0e-6;
+    if (!(mtrxNumber < tol && mtrxNumber > -tol)) {
+      textScale = 1 / mtrxNumber;
+    }
+
+    const geomData = entityPtr.appendText(this.toGePoint(this.m_center), this.textRef.value.trimLeft());
+    const textPtr = geomData.openAsText();
+
+    textPtr.setNormal(this.toGeVector(eyeDir));
+    textPtr.setRotation(angel);
+    textPtr.setTextSize(textSize * textScale);
+    textPtr.delete();
+    geomData.delete();
+    entityPtr.delete();
+  }
+}

package/src/Viewer/Draggers/OdaWalkDragger.ts

@@ -0,0 +1,278 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2021, Open Design Alliance (the "Alliance").
+// All rights reserved.
+//
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+//
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2021 by Open Design Alliance.
+//   All rights reserved.
+//
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+import { Viewer } from "../Viewer";
+import { Point2d, Vector3 } from "./Common/Geometry";
+import { OdBaseDragger } from "./Common/OdBaseDragger";
+
+const FocalLengthConst = 42.0;
+
+const calcFocalLength = (lensLength: number, fieldWidth: number, fieldHeight: number): number => {
+  return (lensLength / FocalLengthConst) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+};
+
+export class OdaWalkDragger extends OdBaseDragger {
+  protected lastCoord: Point2d;
+  protected speed: number;
+  protected delta: number;
+  protected keyPressMap: Set<string>;
+  protected oldWCSEnableValue: boolean;
+  protected viewParams: any;
+  protected cameraId: any;
+  protected cameraWalker: any;
+  protected viewer: any;
+  protected multiplier: number;
+  protected lastFrameTS: number;
+  protected animationId: any;
+  protected deltaAngle: number;
+  protected enableZoomWheelPreviousValue: boolean;
+
+  constructor(subject: Viewer) {
+    super(subject);
+    this.viewer = undefined;
+
+    this.multiplier = 5;
+    this.speed = 1;
+
+    this.keyPressMap = new Set();
+    this.keydown = this.keydown.bind(this);
+    this.keyup = this.keyup.bind(this);
+
+    this.lastFrameTS = 0;
+    this.animationId = undefined;
+    this.processMovement = this.processMovement.bind(this);
+
+    this.deltaAngle = Math.PI / 3600;
+    this.autoSelect = true;
+  }
+
+  override initialize() {
+    super.initialize();
+    this.viewer = this.getViewer();
+
+    window.addEventListener("keydown", this.keydown, false);
+    window.addEventListener("keyup", this.keyup, false);
+
+    this.oldWCSEnableValue = this.viewer.getEnableWCS();
+    this.viewer.setEnableWCS(false);
+
+    const view = this.viewer.activeView;
+    const maxDimension = this.getMaxDimension(view);
+    this.speed = maxDimension / 30000;
+
+    this.subject.emitEvent({ type: "walkstart" });
+
+    this.viewParams = this.getViewParams();
+    //this.viewParams.lensLength = view.lensLength;
+
+    this.setViewParams(this.viewParams);
+    //view.lensLength = (view.lensLength * 42) / 120;
+
+    const model = this.viewer.getActiveModel();
+    this.cameraId = model.appendCamera("Camera0");
+    this.setupCamera(view);
+    model.delete();
+
+    //pCamera.setAdjustLensLength(true);
+    this.cameraWalker = new this.m_module.OdTvCameraWalker();
+    this.cameraWalker.setCamera(this.cameraId);
+
+    this.subject.update();
+    this.enableZoomWheelPreviousValue = this.subject.options.enableZoomWheel;
+    this.subject.options.enableZoomWheel = false;
+  }
+
+  override dispose() {
+    this.oldWCSEnableValue =
+      this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
+    this.viewer.setEnableWCS(this.oldWCSEnableValue);
+
+    super.dispose();
+
+    this.keyPressMap.clear();
+
+    window.removeEventListener("keydown", this.keydown);
+    window.removeEventListener("keyup", this.keyup);
+
+    if (this.animationId) {
+      window.cancelAnimationFrame(this.animationId);
+      this.animationId = undefined;
+    }
+
+    if (this.cameraId) {
+      const model = this.viewer.getActiveModel();
+      model.removeEntity(this.cameraId);
+      model.delete();
+      this.cameraWalker?.delete();
+    }
+
+    if (this.viewParams) {
+      this.setViewParams(this.viewParams);
+
+      const avp = this.viewer.activeView;
+      //avp.lensLength = this.viewParams.lensLength;
+      avp.delete();
+    }
+
+    this.subject.update();
+    this.subject.options.enableZoomWheel = this.enableZoomWheelPreviousValue;
+  }
+
+  keydown(ev) {
+    switch (ev.code) {
+      case "NumpadSubtract":
+      case "Minus":
+        if (this.multiplier > 1) {
+          this.multiplier = this.multiplier - 1;
+          this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+        }
+        break;
+      case "NumpadAdd":
+      case "Equal":
+        if (this.multiplier < 10) {
+          this.multiplier = this.multiplier + 1;
+          this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+        }
+        break;
+      case "KeyW":
+      case "KeyA":
+      case "KeyS":
+      case "KeyD":
+      case "KeyQ":
+      case "KeyE":
+        this.keyPressMap.add(ev.code);
+        if (!this.animationId) this.processMovement(0);
+        break;
+    }
+  }
+
+  keyup(ev) {
+    this.keyPressMap.delete(ev.code);
+    if (this.keyPressMap.size < 1 && this.animationId) {
+      window.cancelAnimationFrame(this.animationId);
+      this.animationId = undefined;
+      this.lastFrameTS = 0;
+    }
+  }
+
+  processMovement(timestamp) {
+    this.animationId = requestAnimationFrame(this.processMovement);
+
+    if (this.lastFrameTS !== 0) {
+      const deltaTS = timestamp - this.lastFrameTS;
+      const currentDelta = this.multiplier * deltaTS * this.speed;
+
+      for (const keyCode of this.keyPressMap) {
+        switch (keyCode) {
+          case "KeyW":
+            this.cameraWalker.moveForward(currentDelta);
+            break;
+          case "KeyS":
+            this.cameraWalker.moveBackward(currentDelta);
+            break;
+          case "KeyA":
+            this.cameraWalker.moveLeft(currentDelta);
+            break;
+          case "KeyD":
+            this.cameraWalker.moveRight(currentDelta);
+            break;
+          case "KeyQ":
+            this.cameraWalker.moveUp(currentDelta);
+            break;
+          case "KeyE":
+            this.cameraWalker.moveDown(currentDelta);
+            break;
+        }
+      }
+      this.subject.update();
+    }
+
+    this.lastFrameTS = timestamp;
+  }
+
+  override drag(x, y, dltX, dltY) {
+    if (this.cameraId && this.isDragging) {
+      if (dltX !== 0.0) this.turnLeft(-dltX * this.deltaAngle);
+      if (dltY !== 0.0) this.cameraWalker.turnDown(dltY * this.deltaAngle);
+      this.subject.update();
+    }
+  }
+
+  turnLeft(angle) {
+    //TODO: migrate to VisualizeJS
+    const pCamera = this.cameraWalker.camera().openObjectAsCamera();
+    const dir = this.toVector(pCamera.direction());
+    const up = this.toVector(pCamera.upVector());
+
+    const pos = pCamera.position();
+
+    const rotMatrix = this.createMatrix3d();
+    const zAxisVector: Vector3 = [0, 0, 1];
+    rotMatrix.setToRotation(angle, zAxisVector, pos);
+    dir.transformBy(rotMatrix);
+    up.transformBy(rotMatrix);
+    pCamera.setupCameraByDirection(pos, dir.toArray(), up.toArray());
+    pCamera.delete();
+  }
+
+  setupCamera(view) {
+    const pCamera = this.cameraId.openObjectAsCamera();
+    const target = view.viewTarget;
+
+    pCamera.setDisplayGlyph(false);
+    pCamera.setDisplayTarget(false);
+    pCamera.setAutoAdjust(true);
+    pCamera.setupCamera(view.viewPosition, target, view.upVector);
+    pCamera.setNearClip(false, 1.0);
+    pCamera.setFarClip(false, 0);
+    pCamera.setViewParameters(view.viewFieldWidth, view.viewFieldHeight, true);
+
+    const focalL = calcFocalLength(view.lensLength, view.viewFieldWidth, view.viewFieldHeight);
+
+    const pTarget = this.toPoint(view.viewTarget);
+    const viewDir = this.toPoint(view.viewPosition);
+    const viewDirSub = viewDir.sub(pTarget);
+    const viewDirVec = viewDirSub.asVector();
+    const viewDirVecNormal = viewDirVec.normalize();
+
+    const geViewDir = this.toGeVector(viewDirVecNormal);
+    const newGeViewDir = [geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL];
+
+    const pTarget2 = this.toPoint(view.viewTarget);
+    const newGeViewDirPt = this.toPoint(newGeViewDir);
+
+    const newPos = pTarget2.add(newGeViewDirPt);
+    pCamera.setupCamera(this.toGePoint(newPos), view.viewTarget, view.upVector);
+
+    this.deleteAll([pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos]);
+
+    pCamera.assignView(view);
+    pCamera.delete();
+  }
+
+  getMaxDimension(view) {
+    const [xmax, ymax, zmax] = view.sceneExtents.max();
+    const [xmin, ymin, zmin] = view.sceneExtents.min();
+    const volume = [xmax - xmin, ymax - ymin, zmax - zmin];
+    return Math.max(...volume);
+  }
+}