@inweb/viewer-visualize 25.3.13

package/src/Viewer/Commands/ZoomToObjects.ts

@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2023, 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 { commands } from "@inweb/viewer-core";
+import { Viewer } from "../Viewer";
+
+function zoomToObjects(viewer: Viewer, handles: string[] = []): void {
+  if (!viewer.visualizeJs) return;
+
+  const visLib = viewer.visLib();
+  const visViewer = viewer.visViewer();
+
+  const selectionSet = new visLib.OdTvSelectionSet();
+  handles.forEach((handle) => {
+    const entityId = visViewer.getEntityByOriginalHandle(handle + "");
+    if (!entityId.isNull()) selectionSet.appendEntity(entityId);
+  });
+
+  visViewer.zoomToObjects?.(selectionSet);
+
+  viewer.update();
+  viewer.emitEvent({ type: "zoom" });
+
+  selectionSet.delete();
+}
+
+commands("VisualizeJS").registerCommand("zoomToObjects", zoomToObjects);

package/src/Viewer/Commands/ZoomToSelected.ts

@@ -0,0 +1,39 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2023, 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 { commands } from "@inweb/viewer-core";
+import { Viewer } from "../Viewer";
+
+function zoomToSelected(viewer: Viewer): void {
+  if (!viewer.visualizeJs) return;
+
+  const visViewer = viewer.visViewer();
+
+  const selectionSet = visViewer.getSelected();
+  visViewer.zoomToObjects?.(selectionSet);
+
+  viewer.update();
+  viewer.emitEvent({ type: "zoom" });
+}
+
+commands("VisualizeJS").registerCommand("zoomToSelected", zoomToSelected);

package/src/Viewer/Commands/index.ts

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2023, 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 "./ApplyModelTransform";
+import "./ClearMarkup";
+import "./ClearSlices";
+import "./CreatePreview";
+import "./Explode";
+import "./GetDefaultViewPositions";
+import "./GetModels";
+import "./GetSelected";
+import "./HideSelected";
+import "./IsolateSelected";
+import "./RegenerateAll";
+import "./ResetView";
+import "./SelectModel";
+import "./SetActiveDragger";
+import "./SetDefaultViewPosition";
+import "./SetMarkupColor";
+import "./SetSelected";
+import "./ShowAll";
+import "./Unselect";
+import "./ZoomToExtents";
+import "./ZoomToObjects";
+import "./ZoomToSelected";

package/src/Viewer/Draggers/Actions/OrbitAction.ts

@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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 { Point2d, Point3d, Vector3d } from "../Common/Geometry";
+import { Viewer } from "../../Viewer";
+
+export class OrbitAction {
+  private _m_module: any;
+  private _subject: Viewer;
+  private _beginInteractivity: () => void;
+  private _endInteractivity: () => void;
+  private m_viewCenter: any;
+  private m_startPoint: Point2d;
+
+  constructor(m_module: any, subject: Viewer, beginInteractivity: () => void, endInteractivity: () => void) {
+    this._m_module = m_module;
+    this._subject = subject;
+    this._beginInteractivity = beginInteractivity;
+    this._endInteractivity = endInteractivity;
+  }
+
+  public beginAction(x: number, y: number) {
+    this.m_viewCenter = this.getCenter();
+    this.m_startPoint = { x, y };
+
+    const view = this.getViewer().activeView;
+
+    view.delete();
+    this._beginInteractivity();
+  }
+
+  public action(x: number, y: number) {
+    const view = this.getViewer().activeView;
+
+    const corners = view.vportRect;
+
+    const size = Math.max(Math.abs(corners[2] - corners[0]), Math.abs(corners[3] - corners[1]));
+
+    const distX = ((this.m_startPoint.x - x) * Math.PI) / size;
+    const distY = ((this.m_startPoint.y - y) * Math.PI) / size;
+
+    this.m_startPoint.x = x;
+    this.m_startPoint.y = y;
+
+    const xOrbit = distY;
+    const yOrbit = distX;
+
+    const viewParams = {
+      position: view.viewPosition,
+      target: view.viewTarget,
+      upVector: view.upVector,
+      viewFieldWidth: view.viewFieldWidth,
+      viewFieldHeight: view.viewFieldHeight,
+      perspective: view.perspective,
+    };
+
+    view.delete();
+
+    const sideVector = this.getSideVector(viewParams);
+
+    if (xOrbit !== 0.0) {
+      this.calculateXOrbit(viewParams, -xOrbit, sideVector);
+    }
+
+    if (yOrbit !== 0.0) {
+      this.calculateYOrbit(viewParams, yOrbit, sideVector);
+    }
+
+    sideVector.delete();
+
+    const extView = this.getViewer().getActiveTvExtendedView();
+
+    extView.setView(
+      viewParams.position,
+      viewParams.target,
+      viewParams.upVector,
+      viewParams.viewFieldWidth,
+      viewParams.viewFieldHeight,
+      viewParams.perspective
+    );
+    extView.delete();
+
+    this._subject.activeDragger()?.updatePreview();
+  }
+
+  public endAction() {
+    this._endInteractivity();
+  }
+
+  private getSideVector(viewParams: any): any {
+    const pUpV = this.toVector(viewParams.upVector);
+    const pTarget = this.toPoint(viewParams.target);
+    const pPosition = this.toPoint(viewParams.position);
+
+    const direct = pTarget.sub(pPosition);
+    const vDirect = direct.asVector();
+
+    const vCross = pUpV.crossProduct(vDirect);
+    const sideVector = vCross.normalize();
+
+    this.deleteAll([direct, pUpV, pTarget, pPosition, vDirect, vCross]);
+
+    return sideVector;
+  }
+
+  private calculateXOrbit(viewParams: any, delta: number, sideVector: Vector3d): void {
+    {
+      const pPoint = this.toPoint(viewParams.position);
+      const pCenter = this.toPoint(this.m_viewCenter);
+
+      const rotatePoint = pPoint.rotateByBasePoint(delta, sideVector, pCenter);
+      viewParams.position = rotatePoint.toArray();
+
+      this.deleteAll([pPoint, pCenter, rotatePoint]);
+    }
+
+    {
+      const pTarget = this.toPoint(viewParams.target);
+      const pCenter = this.toPoint(this.m_viewCenter);
+
+      const rotatePoint = pTarget.rotateByBasePoint(delta, sideVector, pCenter);
+      viewParams.target = rotatePoint.toArray();
+
+      this.deleteAll([pTarget, pCenter, rotatePoint]);
+    }
+
+    {
+      const pPoint = this.toPoint(viewParams.position);
+      const pTarget = this.toPoint(viewParams.target);
+      const pCenter = this.toPoint(this.m_viewCenter);
+
+      const pUp = pTarget.sub(pPoint);
+      const vUp = pUp.asVector();
+
+      const crossProduct = vUp.crossProduct(sideVector);
+      const crossProductNormal = crossProduct.normalize();
+
+      viewParams.upVector = crossProductNormal.toArray();
+
+      this.deleteAll([pPoint, pTarget, pCenter, pUp, vUp, crossProduct, crossProductNormal]);
+    }
+  }
+
+  private calculateYOrbit(viewParams: any, delta: number, sideVector: any): void {
+    {
+      const pPoint = this.toPoint(viewParams.position);
+      const pCenter = this.toPoint(this.m_viewCenter);
+
+      const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
+
+      const rotatePoint = pPoint.rotateByBasePoint(delta, zAxis, pCenter);
+      viewParams.position = rotatePoint.toArray();
+
+      this.deleteAll([zAxis, pPoint, pCenter, rotatePoint]);
+    }
+
+    {
+      const pTarget = this.toPoint(viewParams.target);
+      const pCenter = this.toPoint(this.m_viewCenter);
+
+      const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
+
+      const rotatePoint = pTarget.rotateByBasePoint(delta, zAxis, pCenter);
+      viewParams.target = rotatePoint.toArray();
+
+      this.deleteAll([zAxis, pTarget, pCenter, rotatePoint]);
+    }
+
+    {
+      const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
+      const pTarget = this.toPoint(viewParams.target);
+      const pPoint = this.toPoint(viewParams.position);
+
+      const side = sideVector.rotateBy(delta, zAxis);
+
+      const pUp = pTarget.sub(pPoint);
+      const vUp = pUp.asVector();
+
+      const cross = vUp.crossProduct(side);
+      const crossNormal = cross.normalize();
+
+      viewParams.upVector = crossNormal.toArray();
+
+      this.deleteAll([zAxis, pTarget, pPoint, side, pUp, vUp, cross, crossNormal]);
+    }
+  }
+
+  private getCenter(): any {
+    const viewer = this.getViewer();
+    let center;
+
+    const pSet = viewer.getSelected();
+    if (!pSet.isNull() && pSet.numItems() !== 0) {
+      const itr = pSet.getIterator();
+      let ext, entId, extSelected;
+      for (; !itr.done(); itr.step()) {
+        entId = itr.getEntity();
+        ext = entId.getWCSExtents();
+        if (extSelected) extSelected.addExt(ext);
+        else extSelected = ext;
+      }
+      center = extSelected.center();
+
+      extSelected.delete();
+      itr.delete();
+    } else {
+      center = viewer.getActiveExtents().center();
+    }
+
+    return center;
+  }
+
+  private getViewer(): any {
+    return this._m_module.getViewer();
+  }
+
+  private toVector(geVector): Vector3d {
+    return this._m_module.Vector3d.createFromArray(geVector);
+  }
+
+  private toPoint(gePoint: number[]): Point3d {
+    return this._m_module.Point3d.createFromArray(gePoint);
+  }
+
+  private deleteAll(objects): void {
+    for (const obj of objects) {
+      obj?.delete?.();
+    }
+  }
+}

package/src/Viewer/Draggers/Actions/PanAction.ts

@@ -0,0 +1,102 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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 { Point2d, Point3d } from "../Common/Geometry";
+import { ViewParams } from "../Common/OdaGeAction";
+import { Viewer } from "../../Viewer";
+
+export class PanAction {
+  private _m_module: any;
+  private _subject: Viewer;
+  private _m_start: Point3d;
+  private _deltaScreenPosition: Point2d;
+  private _beginInteractivity: () => void;
+  private _endInteractivity: () => void;
+  private _getViewParams: () => ViewParams;
+  private _setViewParams: (params: ViewParams) => void;
+
+  constructor(
+    m_module: any,
+    subject: Viewer,
+    beginInteractivity: () => void,
+    endInteractivity: () => void,
+    getViewParams: () => ViewParams,
+    setViewParams: (params: ViewParams) => void
+  ) {
+    this._m_module = m_module;
+    this._subject = subject;
+    this._beginInteractivity = beginInteractivity;
+    this._endInteractivity = endInteractivity;
+    this._getViewParams = getViewParams;
+    this._setViewParams = setViewParams;
+  }
+
+  public beginAction(x: number, y: number) {
+    this._m_start = this.screenToWorld(x, y);
+    this._deltaScreenPosition = { x, y };
+    this._beginInteractivity();
+  }
+
+  public action(x: number, y: number) {
+    const { Vector3d } = this._m_module;
+    const params = this._getViewParams();
+    const pt = this.screenToWorld(x, y);
+
+    const ptSub = this._m_start.sub(pt);
+    const delta = ptSub.asVector();
+
+    const target = Vector3d.createFromArray(params.target);
+    const targetWithDelta = target.add(delta);
+    params.target = targetWithDelta.toArray();
+
+    const position = Vector3d.createFromArray(params.position);
+    const positionWithDelta = position.add(delta);
+    params.position = positionWithDelta.toArray();
+
+    this._setViewParams(params);
+    target.delete();
+
+    targetWithDelta.delete();
+    position.delete();
+    positionWithDelta.delete();
+
+    this._subject.activeDragger()?.updatePreview();
+    this._subject.emitEvent({
+      type: "pan",
+      x,
+      y,
+      dX: x - this._deltaScreenPosition.x,
+      dY: y - this._deltaScreenPosition.y,
+    });
+
+    this._deltaScreenPosition = { x, y };
+  }
+
+  public endAction() {
+    this._endInteractivity();
+  }
+
+  private screenToWorld(x: number, y: number): Point3d {
+    return this._m_module.Point3d.createFromArray(this._m_module.getViewer().screenToWorld(x, y));
+  }
+}

package/src/Viewer/Draggers/Actions/ZoomAction.ts

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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";
+
+export class ZoomAction {
+  private _m_module: any;
+  private _subject: Viewer;
+
+  constructor(m_module: any, subject: Viewer) {
+    this._m_module = m_module;
+    this._subject = subject;
+  }
+
+  public action(x: number, y: number, zoomFactor: number) {
+    const viewer = this._m_module.getViewer();
+    viewer.zoomAt(zoomFactor, x, y);
+
+    this._subject.activeDragger()?.updatePreview();
+    this._subject.emitEvent({
+      type: "zoomat",
+      data: zoomFactor,
+    });
+  }
+}

package/src/Viewer/Draggers/Common/Geometry.ts

@@ -0,0 +1,152 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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.
+///////////////////////////////////////////////////////////////////////////////
+export interface Point2d {
+  x: number;
+  y: number;
+}
+
+export type Vector3 = [x: number, y: number, z: number];
+
+export interface Point3d {
+  add(point: Point3d);
+  asVector(): Vector3d;
+  distanceTo(point: Point3d);
+  rotateBy(angle: number, vector: Vector3d);
+  rotateByBasePoint(angle: number, vector: Vector3d, basePoint: Point3d);
+  scaleBy(factor: number, basePoint: Point3d);
+  set(x: number, y: number, z: number);
+  setToProduct(matrix: any, point: Point3d);
+  setToSum(point: Point3d, vector: Vector3d);
+  sub(point: Point3d): Point3d;
+  toArray(): number[];
+  transformBy(matrix: any);
+  translate(vector: Vector3d);
+  get x(): number;
+  set x(x: number);
+  get y(): number;
+  set y(y: number);
+  get z(): number;
+  set z(z: number);
+}
+
+export interface Vector3d {
+  add(vector: Vector3d);
+  angleTo(vector: Vector3d);
+  angleToWithRef(vector: Vector3d, ref: Vector3d);
+  asPoint(): Point3d;
+  crossProduct(vector: Vector3d);
+  dotProduct(vector: Vector3d);
+  isEqualTo(vector: Vector3d): boolean;
+  length(): number;
+  lengthSqrd(): number;
+  mirror();
+  negate();
+  normal();
+  normalize();
+  rotateBy(angle: number, vector: Vector3d);
+  set(x: number, y: number, z: number);
+  setLength(length: number);
+  setToProduct(vector: Vector3d, scale: number);
+  setToSum(vector1: Vector3d, vector2: Vector3d);
+  sub(vector: Vector3d);
+  toArray(): number[];
+  transformBy(matrix: any);
+  get x(): number;
+  set x(x: number);
+  get y(): number;
+  set y(y: number);
+  get z(): number;
+  set z(z: number);
+}
+
+export interface Matrix3d {
+  det(): number;
+  get(row: number, col: number): number;
+  getCoordSystem(origin: Point3d, xAxis: Vector3d, yAxis: Vector3d, zAxis: Vector3d);
+  getCsOrigin(): Point3d;
+  getCsXAxis(): Vector3d;
+  getCsYAxis(): Vector3d;
+  getCsZAxis(): Vector3d;
+  invert(): Matrix3d;
+  isEqualTo();
+  isPerspective();
+  isScaledOrtho();
+  isSingular();
+  isUniScaledOrtho();
+  norm(): number;
+  postMultBy(rightSide: Matrix3d): Matrix3d;
+  preMultBy(leftSide: Matrix3d): Matrix3d;
+  scale();
+  set(row: number, col: number, value: number);
+  setCoordSystem(origin: Point3d, xAxis: Vector3d, yAxis: Vector3d, zAxis: Vector3d): Matrix3d;
+  setToAlignCoordSys(
+    fromOrigin: Point3d,
+    fromXAxis: Vector3d,
+    fromYAxis: Vector3d,
+    fromZAxis: Vector3d,
+    toOrigin: Point3d,
+    toXAxis: Vector3d,
+    toYAxis: Vector3d,
+    toZAxis: Vector3d
+  );
+  setToIdentity(): Matrix3d;
+  setToProduct(matrix1: Matrix3d, matrix2): Matrix3d;
+  setToProjection(projectionPlane: OdTvPlane, projectDir: Vector3d): Matrix3d;
+  setToRotation(angle: number, axis: Vector3, center: Point3d): Matrix3d;
+  setToScaling(arg0: any, arg1: any);
+  setToWorldToPlane(geVector3d: number[]);
+  setTranslation(vect: Vector3d);
+  transpose(): Matrix3d;
+  transposeIt(): Matrix3d;
+  validateZero(): void;
+}
+
+export interface OdTvPlane {
+  getOrigin();
+  getUAxis();
+  getVAxis();
+  normal();
+  set(point: number[], normal: OdTvVector);
+  set3ptr(uPnt: OdTvVector, origin: OdTvVector, vPnt: OdTvVector);
+  set4double(a: number, b: number, c: number, d: number);
+  setUV(origin: OdTvPoint, uAxis: OdTvPoint, vAxis: OdTvPoint);
+}
+
+export interface OdTvPoint {
+  setParam(controlPoints: any[]);
+  getParam(): any[];
+  getPointsCount(): number;
+  editPointsViaRange(startPos: number, points: any[]);
+  editPointsViaList(indPoints: any[], points: any[]);
+  setPointSize(value: number);
+  getPointSize(): number;
+  setPointColorsViaList(indPoints: any[], colors: any[]);
+  setPointColorsViaRange(indStart: number, nCount: number, colors: any[]);
+  getPointColor(ind: number): any;
+  setPointNormalsViaList(indPoints: any[], vectors: any[]);
+  setPointNormalsViaRange(indStart: number, vectors: any[]);
+  getPointNormal(ind: number);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface OdTvVector {}