@realsee/dnalogel 0.1.7 → 2.0.0-alpha.11

package/libs/shared-utils/filter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 对象属性筛选函数。
+ * 基于已有对象生成一个满足条件(属性)新的对象。
+ * @param {object} object
+ * @param {Function} check
+ */
+export declare function filter<T, K extends keyof T>(object: T, check: (key: K, value: T[K]) => boolean): Record<K, T[K]>;
+/**
+ * 对象镜子函数。
+ * 生成一个"镜子"对象：对象的属性名与其值相同。
+ * @param  {string[]} strings 对象属性
+ */
+export declare function mirror(strings: string[]): Record<string, string>;
+/**
+ * 过滤掉不需要的对象字段函数：实现从一个对象中排除某些指定属性后生成的新对象。
+ * @param object
+ * @param props 排除的属性
+ * @return
+ */
+export declare function omit<T, K extends keyof T>(object: T, props: Extract<K[], string[]>): Omit<T, K>;
+/**
+ * 筛选需要的对象字段：实现从一个对象中选择某些指定属性生成新的对象（与`omit()`功能相反）。
+ * @param  {object}    object
+ * @param  {string[]} props
+ * @return {object}
+ */
+export declare function pick<T, K extends keyof T>(object: T, props: K[]): Pick<T, K>;

package/libs/shared-utils/filter.js

@@ -0,0 +1,53 @@
+import tap from './tap';
+/**
+ * 对象属性筛选函数。
+ * 基于已有对象生成一个满足条件(属性)新的对象。
+ * @param {object} object
+ * @param {Function} check
+ */
+export function filter(object, check) {
+    return tap({}, (result) => {
+        Object.keys(object).forEach((key) => {
+            const _key = key;
+            if (check(_key, object[_key])) {
+                result[_key] = object[_key];
+            }
+        });
+    });
+}
+/**
+ * 对象镜子函数。
+ * 生成一个"镜子"对象：对象的属性名与其值相同。
+ * @param  {string[]} strings 对象属性
+ */
+export function mirror(strings) {
+    return tap({}, (result) => {
+        for (const string of strings)
+            result[string] = string;
+    });
+}
+/**
+ * 过滤掉不需要的对象字段函数：实现从一个对象中排除某些指定属性后生成的新对象。
+ * @param object
+ * @param props 排除的属性
+ * @return
+ */
+export function omit(object, props) {
+    return tap({}, (result) => {
+        for (const name in object) {
+            if (props.indexOf(name) !== -1)
+                continue;
+            result[name] = object[name];
+        }
+    });
+}
+/**
+ * 筛选需要的对象字段：实现从一个对象中选择某些指定属性生成新的对象（与`omit()`功能相反）。
+ * @param  {object}    object
+ * @param  {string[]} props
+ * @return {object}
+ */
+export function pick(object, props) {
+    // eslint-disable-next-line no-return-assign
+    return tap({}, (result) => props.forEach((prop) => (result[prop] = object[prop])));
+}

package/libs/shared-utils/five/changeMode.d.ts

@@ -0,0 +1,2 @@
+import type { Five } from '@realsee/five';
+export default function changeMode(five: Five, ...changeModeParams: Parameters<Five['changeMode']>): Promise<void>;

package/libs/shared-utils/five/changeMode.js

@@ -0,0 +1,15 @@
+import to from '../to';
+export default async function changeMode(five, ...changeModeParams) {
+    const [changeModeError] = await to(five.changeMode(...changeModeParams));
+    if (changeModeError)
+        throw changeModeError;
+    await new Promise((reslove, reject) => {
+        five.once('initAnimationEnded', reslove);
+        const handleModeChange = (mode) => {
+            if (mode !== changeModeParams[0])
+                reject('changeMode 被中断');
+            five.off('modeChange', handleModeChange);
+        };
+        five.on('modeChange', handleModeChange);
+    });
+}

package/libs/shared-utils/five/useFivePlugin.d.ts

@@ -0,0 +1 @@
+export declare function useFivePlugin<T extends (...args: any) => any>(name: string): ReturnType<T>;

package/libs/shared-utils/five/useFivePlugin.js

@@ -0,0 +1,8 @@
+import { unsafe__useFiveInstance } from '@realsee/five/react';
+export function useFivePlugin(name) {
+    const five = unsafe__useFiveInstance();
+    const plugin = five.plugins[name];
+    if (!plugin)
+        throw new Error(`can not find plugin "${name}"`);
+    return plugin;
+}

package/libs/shared-utils/formatRad.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 将弧度转成 0 - 2PI 中的值
+ * @param rad - 任意弧度值
+ * @return 0 - 2PI 的数值
+ */
+declare function formatRad(rad: number): number;
+export { formatRad };

package/libs/shared-utils/formatRad.js

@@ -0,0 +1,10 @@
+const PI_2 = Math.PI * 2;
+/**
+ * 将弧度转成 0 - 2PI 中的值
+ * @param rad - 任意弧度值
+ * @return 0 - 2PI 的数值
+ */
+function formatRad(rad) {
+    return ((rad % PI_2) + PI_2) % PI_2;
+}
+export { formatRad };

package/libs/shared-utils/getPxmm.d.ts

@@ -0,0 +1,11 @@
+import type { Five } from '@realsee/five';
+import { FLOOR_PLAN_ATTACHED_TO } from '../floorplan/constant';
+interface GetPxmmOption {
+    attachedTo: FLOOR_PLAN_ATTACHED_TO;
+}
+/**
+ * 获取「在俯视图」状态下，模型 mm 与屏幕像素 px 的对应关系，即每 mm 对应多少 px
+ * @param five five
+ */
+export default function getPxmm(five: Five, container: Element, floorIndex: number, options?: GetPxmmOption): number;
+export {};

package/libs/shared-utils/getPxmm.js

@@ -0,0 +1,34 @@
+import { FLOOR_PLAN_ATTACHED_TO } from '../floorplan/constant';
+import * as THREE from 'three';
+/**
+ * 获取「在俯视图」状态下，模型 mm 与屏幕像素 px 的对应关系，即每 mm 对应多少 px
+ * @param five five
+ */
+export default function getPxmm(five, container, floorIndex, options) {
+    const maxFloorIndex = Math.max(...five.work.observers.map((ob) => ob.floorIndex));
+    function getFloorY(floorIndex) {
+        return floorIndex > maxFloorIndex
+            ? five.model.bounding.max.y
+            : Math.max(...five.work.observers
+                .filter((ob) => ob.floorIndex === floorIndex)
+                .map((ob) => ob.standingPosition.y));
+    }
+    function getY() {
+        const currentFloorY = getFloorY(floorIndex);
+        const nextFloorY = getFloorY(floorIndex + 1);
+        const attachedTo = options?.attachedTo || FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER;
+        if (attachedTo === FLOOR_PLAN_ATTACHED_TO.BOUNDING_CENTER)
+            return (five.model.bounding.max.y + five.model.bounding.min.y) / 2;
+        else if (attachedTo === FLOOR_PLAN_ATTACHED_TO.CEILING)
+            return nextFloorY;
+        else
+            return currentFloorY;
+    }
+    const y = getY();
+    const originPosition = new THREE.Vector3(0, y, 0);
+    const originPositionXUnit = new THREE.Vector3(1, y, 0);
+    const mouse = originPosition.clone().project(five.camera);
+    const xUnitMouse = originPositionXUnit.clone().project(five.camera);
+    const pxmm = Math.abs((xUnitMouse.x - mouse.x) / 1000) * (container.getBoundingClientRect().width / 2);
+    return pxmm;
+}

package/libs/shared-utils/getRandomColor.d.ts

@@ -0,0 +1 @@
+export default function getRandomColor(): string;

package/libs/shared-utils/getRandomColor.js

@@ -0,0 +1,10 @@
+export default function getRandomColor() {
+    const color = '#' +
+        '0123456789abcdef'
+            .split('')
+            .map((_v, i, a) => {
+            return i > 5 ? null : a[Math.floor(Math.random() * 16)];
+        })
+            .join('');
+    return color;
+}

package/libs/shared-utils/isNil.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 判断对象是否为`null`或`undefined`。
+ * @param
+ * @return
+ */
+export declare function isNil<T>(value: T): value is Extract<T, undefined | null>;
+/**
+ * 判断对象不为`null`或`undefined`。
+ */
+export declare function notNil<T>(value: T | null | undefined): value is T;

package/libs/shared-utils/isNil.js

@@ -0,0 +1,14 @@
+/**
+ * 判断对象是否为`null`或`undefined`。
+ * @param
+ * @return
+ */
+export function isNil(value) {
+    return !notNil(value);
+}
+/**
+ * 判断对象不为`null`或`undefined`。
+ */
+export function notNil(value) {
+    return value !== null && value !== undefined;
+}

package/libs/shared-utils/isTruelyObject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 检查一个值是否是狭义上的对象
+ * @param {any} value 要检查的值
+ *
+ * isTruelyObject({})
+ * // => true
+ *
+ * isObjectLike([1, 2, 3])
+ * // => false
+ *
+ * isObjectLike(Function)
+ * // => false
+ *
+ * isObjectLike(null)
+ * // => false
+ *
+ */
+export default function isTruelyObject(value: any): boolean;

package/libs/shared-utils/isTruelyObject.js

@@ -0,0 +1,20 @@
+/**
+ * 检查一个值是否是狭义上的对象
+ * @param {any} value 要检查的值
+ *
+ * isTruelyObject({})
+ * // => true
+ *
+ * isObjectLike([1, 2, 3])
+ * // => false
+ *
+ * isObjectLike(Function)
+ * // => false
+ *
+ * isObjectLike(null)
+ * // => false
+ *
+ */
+export default function isTruelyObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}

package/libs/shared-utils/math/evenNumber.d.ts

@@ -0,0 +1,3 @@
+export default function evenNumber(num: number, config?: {
+    smaller?: boolean;
+}): number;

package/libs/shared-utils/math/evenNumber.js

@@ -0,0 +1,4 @@
+export default function evenNumber(num, config) {
+    const roundNum = Math.round(num);
+    return roundNum % 2 === 0 ? roundNum : roundNum + Number(config?.smaller ? -1 : 1);
+}

package/libs/shared-utils/math/planimetry.d.ts

@@ -0,0 +1,116 @@
+/**
+ * 平面几何相关数学函数
+ */
+/**
+ * 平面点坐标。
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * 检查两个点是否位置相同
+ * @param point1
+ * @param point2
+ * @return
+ */
+export declare function samePointAt(point1: Point, point2: Point): boolean;
+/**
+ * 计算两个点之间的位置
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export declare function distance(point1: Point, point2: Point): number;
+/**
+ * 两个计算的斜率是否相同
+ * @param  {number} k1
+ * @param  {number} k2
+ * @return
+ */
+export declare function sameK(k1: number, k2: number): boolean;
+/**
+ * 获取两点之间的斜率
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export declare function getK(point1: Point, point2: Point): number;
+/**
+ * 获取一点对于线段上最近的一点，
+ * 如果可以是过直线垂线的垂足，不行的话取线段的两端
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {point}
+ */
+export declare function closestPointOnLine(point: Point, linePoints: Point[]): {
+    x: any;
+    y: any;
+};
+/**
+ * 点到线段的距离，
+ * 如果可以是过直线垂线的垂足的距离，不行的话取线段的两端的距离
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {number}
+ */
+export declare function pointDistanceFromLine(point: Point, linePoints: Point[]): number;
+/**
+ * 做线段的距离一定值的平行线段
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @return {[linePoints, linePoints]}
+ */
+export declare function linesWithDistanceOfLine(distanceOfLine: number, linePoints: Point[]): {
+    x: any;
+    y: any;
+}[][];
+/**
+ * 做线段的距离一定值的平行线段 (如果线段是弧形的)
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @param  {number} 弧形定点到线段的距离
+ * @return {[linePoints, linePoints]}
+ */
+export declare function linesWithDistanceOfLineWithCurve(distanceOfLine: number, linePoints: Point[], curve: number): {
+    x: number;
+    y: number;
+}[][];
+/**
+ * 两条线段(包括延长线)的交点点
+ * @param  {linePoints} linePoints1
+ * @param  {linePoints} linePoints2
+ * @param   needIntersectionInLine 是否是延长线的相交
+ * @return {point || false}
+ */
+export declare function intersectionOfLine(linePoints1: Point[], linePoints2: Point[], needIntersectionInLine: boolean): false | Point;
+/**
+ * 是否点在线段上
+ * @param  {point} point
+ * @param  {linePoints} linePoints
+ * @return
+ */
+export declare function pointOnLine(point: Point, linePoints: Point[]): boolean;
+/**
+ * 让点按照另一个点为圆心，一定弧度的情况下转动得到下一个点
+ * @param  {point} point
+ * @param  {point} centerPoint
+ * @param  {number} rad
+ * @return {point}
+ */
+export declare function pointRotateByCenterPoint(point: Point, centerPoint: Point, rad: number): {
+    x: number;
+    y: number;
+};
+/**
+ * 获取一些点的中心点
+ * @param  {points} point
+ * @return {point}
+ */
+export declare function getCenterPointOfPoints(points: Point[]): {
+    x: number;
+    y: number;
+};
+export declare function isIntersect(linePoints1: Point[], linePoints2: Point[]): 1 | 0;
+export declare function getAreaSize(points: Point[]): number;
+export declare function getAreaSizeWithoutLine(points: Point[]): number;

package/libs/shared-utils/math/planimetry.js

@@ -0,0 +1,288 @@
+/**
+ * 平面几何相关数学函数
+ */
+/**
+ * 检查两个点是否位置相同
+ * @param point1
+ * @param point2
+ * @return
+ */
+export function samePointAt(point1, point2) {
+    return point1.x === point2.x && point1.y === point2.y;
+}
+/**
+ * 计算两个点之间的位置
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export function distance(point1, point2) {
+    return Math.sqrt(Math.pow(point2.x - point1.x, 2) + Math.pow(point2.y - point1.y, 2));
+}
+/**
+ * 两个计算的斜率是否相同
+ * @param  {number} k1
+ * @param  {number} k2
+ * @return
+ */
+export function sameK(k1, k2) {
+    if (Math.abs(k1) === Infinity && Math.abs(k2) === Infinity)
+        return true;
+    return Math.abs(k1 - k2) < 0.001;
+}
+/**
+ * 获取两点之间的斜率
+ * @param  {point} point1
+ * @param  {point} point2
+ * @return {number}
+ */
+export function getK(point1, point2) {
+    return (point2.y - point1.y) / (point2.x - point1.x);
+}
+/**
+ * 获取一点对于线段上最近的一点，
+ * 如果可以是过直线垂线的垂足，不行的话取线段的两端
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {point}
+ */
+export function closestPointOnLine(point, linePoints) {
+    const tA = point.x - linePoints[0].x;
+    const tB = point.y - linePoints[0].y;
+    const tC = linePoints[1].x - linePoints[0].x;
+    const tD = linePoints[1].y - linePoints[0].y;
+    const tDot = tA * tC + tB * tD;
+    const tLenSq = tC * tC + tD * tD;
+    const tParam = tDot / tLenSq;
+    let tXx, tYy;
+    if (tParam < 0 || samePointAt(linePoints[0], linePoints[1])) {
+        tXx = linePoints[0].x;
+        tYy = linePoints[0].y;
+    }
+    else if (tParam > 1) {
+        tXx = linePoints[1].x;
+        tYy = linePoints[1].y;
+    }
+    else {
+        tXx = linePoints[0].x + tParam * tC;
+        tYy = linePoints[0].y + tParam * tD;
+    }
+    return { x: tXx, y: tYy };
+}
+/**
+ * 点到线段的距离，
+ * 如果可以是过直线垂线的垂足的距离，不行的话取线段的两端的距离
+ * @param  {point} point1
+ * @param  {linePoints} linePoints
+ * @return {number}
+ */
+export function pointDistanceFromLine(point, linePoints) {
+    const closestPoint = closestPointOnLine(point, linePoints);
+    return distance(point, closestPoint);
+}
+/**
+ * 做线段的距离一定值的平行线段
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @return {[linePoints, linePoints]}
+ */
+export function linesWithDistanceOfLine(distanceOfLine, linePoints) {
+    const k = getK(linePoints[1], linePoints[0]);
+    let dx, dy;
+    if (Math.abs(k) === Infinity) {
+        dy = 0;
+        dx = distanceOfLine;
+    }
+    else {
+        dy = Math.sqrt((distanceOfLine * distanceOfLine) / (k * k + 1));
+        dx = dy / -(1 / k);
+    }
+    const result = [
+        [
+            { x: linePoints[0].x - dx, y: linePoints[0].y - dy },
+            { x: linePoints[1].x - dx, y: linePoints[1].y - dy },
+        ],
+        [
+            { x: linePoints[0].x + dx, y: linePoints[0].y + dy },
+            { x: linePoints[1].x + dx, y: linePoints[1].y + dy },
+        ],
+    ];
+    if (linePoints[1].x - linePoints[0].x < 0) {
+        return result;
+    }
+    else if (linePoints[1].x - linePoints[0].x > 0) {
+        return result.reverse();
+    }
+    else {
+        if (linePoints[1].y - linePoints[0].y < 0) {
+            return result.reverse();
+        }
+        else {
+            return result;
+        }
+    }
+}
+/**
+ * 做线段的距离一定值的平行线段 (如果线段是弧形的)
+ * @param  {number} distanceOfLine
+ * @param  {linePoints} linePoints
+ * @param  {number} 弧形定点到线段的距离
+ * @return {[linePoints, linePoints]}
+ */
+export function linesWithDistanceOfLineWithCurve(distanceOfLine, linePoints, curve) {
+    const centerPoint = getCenterPointOfPoints(linePoints);
+    const pHelfDistance = distance(linePoints[0], centerPoint);
+    const cDistance = Math.sqrt(curve * curve - pHelfDistance * pHelfDistance);
+    const cpoint = isNaN(cDistance)
+        ? centerPoint
+        : linesWithDistanceOfLine(cDistance, [centerPoint, linePoints[0]])[curve > 0 ? 0 : 1][0];
+    const dx1 = ((linePoints[0].x - cpoint.x) / curve) * distanceOfLine;
+    const dy1 = ((linePoints[0].y - cpoint.y) / curve) * distanceOfLine;
+    const dx2 = ((linePoints[1].x - cpoint.x) / curve) * distanceOfLine;
+    const dy2 = ((linePoints[1].y - cpoint.y) / curve) * distanceOfLine;
+    return [
+        [
+            { x: linePoints[0].x - dx1, y: linePoints[0].y - dy1 },
+            { x: linePoints[1].x - dx2, y: linePoints[1].y - dy2 },
+        ],
+        [
+            { x: linePoints[0].x + dx1, y: linePoints[0].y + dy1 },
+            { x: linePoints[1].x + dx2, y: linePoints[1].y + dy2 },
+        ],
+    ];
+}
+/**
+ * 两条线段(包括延长线)的交点点
+ * @param  {linePoints} linePoints1
+ * @param  {linePoints} linePoints2
+ * @param   needIntersectionInLine 是否是延长线的相交
+ * @return {point || false}
+ */
+export function intersectionOfLine(linePoints1, linePoints2, needIntersectionInLine) {
+    const k1 = getK(linePoints1[1], linePoints1[0]);
+    const k2 = getK(linePoints2[1], linePoints2[0]);
+    if (isNaN(k1) || isNaN(k2))
+        return false;
+    if (sameK(k1, k2))
+        return false;
+    if (pointOnLine(linePoints1[0], linePoints2))
+        return linePoints1[0];
+    if (pointOnLine(linePoints1[1], linePoints2))
+        return linePoints1[1];
+    if (pointOnLine(linePoints2[0], linePoints1))
+        return linePoints2[0];
+    if (pointOnLine(linePoints2[1], linePoints1))
+        return linePoints2[1];
+    //needIntersectionInLine 是否焦点在线段内
+    if (needIntersectionInLine && !isIntersect(linePoints1, linePoints2))
+        return false;
+    const p1 = linePoints1[0];
+    const p2 = linePoints2[0];
+    if (Math.abs(k1) === Infinity) {
+        return { x: p1.x, y: linePoints2[1].y - (linePoints2[1].x - p1.x) * k2 };
+    }
+    if (Math.abs(k2) === Infinity) {
+        return { x: p2.x, y: linePoints1[1].y - (linePoints1[1].x - p2.x) * k1 };
+    }
+    const x = (p2.y - p1.y + k1 * p1.x - k2 * p2.x) / (k1 - k2);
+    const y = k1 * x - k1 * p1.x + p1.y;
+    return { x, y };
+}
+/**
+ * 是否点在线段上
+ * @param  {point} point
+ * @param  {linePoints} linePoints
+ * @return
+ */
+export function pointOnLine(point, linePoints) {
+    if (samePointAt(point, linePoints[0]))
+        return true;
+    if (samePointAt(point, linePoints[1]))
+        return true;
+    return (true &&
+        (linePoints[0].x - point.x) * (point.x - linePoints[1].x) >= 0 &&
+        (linePoints[0].y - point.y) * (point.y - linePoints[1].y) >= 0 &&
+        sameK(getK(linePoints[0], point), getK(point, linePoints[1])));
+}
+/**
+ * 让点按照另一个点为圆心，一定弧度的情况下转动得到下一个点
+ * @param  {point} point
+ * @param  {point} centerPoint
+ * @param  {number} rad
+ * @return {point}
+ */
+export function pointRotateByCenterPoint(point, centerPoint, rad) {
+    const r = distance(point, centerPoint);
+    let nextRad = Math.atan2(point.y - centerPoint.y, point.x - centerPoint.x);
+    nextRad -= rad;
+    return {
+        x: centerPoint.x + Math.cos(nextRad) * r,
+        y: centerPoint.y + Math.sin(nextRad) * r,
+    };
+}
+/**
+ * 获取一些点的中心点
+ * @param  {points} point
+ * @return {point}
+ */
+export function getCenterPointOfPoints(points) {
+    let minX = Infinity, maxX = 0, minY = Infinity, maxY = 0;
+    points.forEach((point) => {
+        minX = Math.min(minX, point.x);
+        maxX = Math.max(maxX, point.x);
+        minY = Math.min(minY, point.y);
+        maxY = Math.max(maxY, point.y);
+    });
+    return { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+}
+/**
+ *  判断两条线段是否相交
+ */
+function multi(p1, p2, p0) {
+    return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
+}
+export function isIntersect(linePoints1, linePoints2) {
+    if (Math.max(linePoints1[0].x, linePoints1[1].x) >= Math.min(linePoints2[0].x, linePoints2[1].x) &&
+        Math.max(linePoints2[0].x, linePoints2[1].x) >= Math.min(linePoints1[0].x, linePoints1[1].x) &&
+        Math.max(linePoints1[0].y, linePoints1[1].y) >= Math.min(linePoints2[0].y, linePoints2[1].y) &&
+        multi(linePoints2[0], linePoints1[1], linePoints1[0]) * multi(linePoints1[1], linePoints2[1], linePoints1[0]) > 0 &&
+        multi(linePoints1[0], linePoints2[1], linePoints2[0]) * multi(linePoints2[1], linePoints1[1], linePoints2[0]) > 0)
+        return 1;
+    return 0;
+}
+/**
+ * 计算点按序围成区域的面就
+ * @param  {[point]} points
+ * @return {number}
+ */
+function cross(p1, p2) {
+    // 向量叉积
+    return p1.x * p2.y - p1.y * p2.x;
+}
+export function getAreaSize(points) {
+    let ret = 0;
+    return ((cross(points.reduce((pf, pn) => {
+        ret += cross(pf, pn);
+        return pn;
+    }), points[0]) +
+        ret) /
+        2);
+}
+export function getAreaSizeWithoutLine(points) {
+    let ret = 0;
+    const r = (cross(points.reduce((pf, pn) => {
+        ret += cross(pf, pn);
+        return pn;
+    }), points[0]) +
+        ret) /
+        2;
+    let wall = 0;
+    const wr = (distance(points.reduce((pf, pn) => {
+        wall += distance(pf, pn) * 250;
+        return pn;
+    }), points[0]) *
+        250 +
+        wall) /
+        2;
+    return r - (wr - 250 * 1000) * (r > 0 ? 1 : -1);
+}

package/libs/shared-utils/math/rad2Deg.d.ts

@@ -0,0 +1 @@
+export default function rad2Deg(rad: number): number;

package/libs/shared-utils/math/rad2Deg.js

@@ -0,0 +1,3 @@
+export default function rad2Deg(rad) {
+    return (rad * 180) / Math.PI;
+}