@fbltd/math 1.0.2

package/README.md

@@ -0,0 +1 @@
+# math

package/bundler.config.json

@@ -0,0 +1,6 @@
+{
+    "mode": "development",
+    "entry": "index.ts",
+    "output": "dist/bundled-file.js",
+    "library": "math"
+}

package/index.ts

@@ -0,0 +1 @@
+export * from './src'

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@fbltd/math",
+  "version": "1.0.2",
+  "description": "",
+  "main": "index.ts",
+  "scripts": {
+    "build": "node_modules/.bin/tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GlennMiller1991/math.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/GlennMiller1991/math/issues"
+  },
+  "homepage": "https://github.com/GlennMiller1991/math#readme",
+  "dependencies": {
+    "@fbltd/bundler": "^2.0.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/angle.ts

@@ -0,0 +1,87 @@
+import {isCorrectNumber, toPositive} from "./utils";
+
+export enum AngleUnits {
+    Deg = 0,
+    Rad = 1,
+    Turn = 2,
+}
+
+
+export class Angle {
+
+    // region Converters
+    static toRad(angle: number, unit: AngleUnits = AngleUnits.Deg) {
+        switch (unit) {
+            case AngleUnits.Rad:
+                return angle
+            case AngleUnits.Deg:
+                return angle * Math.PI / 180
+            case AngleUnits.Turn:
+                return Math.PI * 2 * angle
+        }
+    }
+
+    static toTurn(angle: number, unit: AngleUnits = AngleUnits.Deg) {
+        switch (unit) {
+            case AngleUnits.Turn:
+                return angle
+            case AngleUnits.Deg:
+                return angle / 360
+            case AngleUnits.Rad:
+                return angle / (Math.PI * 2)
+        }
+    }
+
+    static toDeg(angle: number, unit: AngleUnits = AngleUnits.Rad) {
+        switch (unit) {
+            case AngleUnits.Deg:
+                return angle
+            case AngleUnits.Turn:
+                return angle * 360
+            case AngleUnits.Rad:
+                return angle * 180 / Math.PI
+        }
+    }
+
+    // endregion Converters
+
+    static toPositive(angle: number, unit: AngleUnits) {
+        switch (unit) {
+            case AngleUnits.Deg:
+                return toPositive(angle, 360)
+            case AngleUnits.Turn:
+                return toPositive(angle, 1)
+            case AngleUnits.Rad:
+                return toPositive(angle, Math.PI * 2)
+        }
+    }
+
+    static normalize(angle: number, unit: AngleUnits) {
+        switch (unit) {
+            // 0 - 359.9999
+            case AngleUnits.Deg:
+                return Angle.toPositive(angle, unit) % 360
+            // 0 - Math.PI * 2
+            case AngleUnits.Rad:
+                return Angle.toPositive(angle, unit) % (Math.PI * 2)
+            // 0 - 1
+            case AngleUnits.Turn:
+                return Angle.toPositive(angle, unit) % 1
+        }
+    }
+
+    // region representation
+    static toCSS(angle: number, unit: AngleUnits) {
+        if (!isCorrectNumber(angle)) return ''
+        return `rotate(${angle}${Angle.angleUnitCorrespondence[unit]})`
+    }
+
+    static angleUnitCorrespondence: Record<AngleUnits, string> = {
+        [AngleUnits.Rad]: 'rad',
+        [AngleUnits.Turn]: 'turn',
+        [AngleUnits.Deg]: 'deg',
+    }
+    // endregion representation
+
+}
+

package/src/colors/color.ts

@@ -0,0 +1,11 @@
+export class Color {
+    constructor(public red: number, public green: number, public blue: number) {
+        this.red = Math.max(Math.min(red, 255), 0)
+        this.green = Math.max(Math.min(green, 255), 0)
+        this.blue = Math.max(Math.min(blue, 255), 0)
+    }
+
+    toCSS() {
+        return `rgb(${this.red}, ${this.green}, ${this.blue})`
+    }
+}

package/src/colors/conic.gradient.ts

@@ -0,0 +1,105 @@
+import {Color} from "./color";
+import {IPoint2} from "../figures";
+
+export class ConicGradient {
+    colors: { angle: number, color: Color }[]
+
+    constructor(...colors: { angle: number, color: Color }[]) {
+        this.colors = [...colors].sort((a, b) => a.angle - b.angle)
+        this.colors.push({
+            angle: 1,
+            color: this.colors[0].color
+        })
+    }
+
+    /**
+     * Получить цвет по углу от оси X по часовой стрелке
+     * @param angle единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
+     */
+    getColorAtAngle(angle: number) {
+        let prev = undefined
+        let next = undefined
+        for (let color of this.colors) {
+            if (color.angle === angle) return color.color
+            if (color.angle < angle) prev = color
+            if (color.angle > angle) {
+                next = color
+                break
+            }
+        }
+
+        if (!prev || !next) return undefined
+
+        const coef = (angle - prev.angle) / (next.angle - prev.angle)
+
+        return new Color(
+            Math.floor((next.color.red - prev.color.red) * coef + prev.color.red),
+            Math.floor((next.color.green - prev.color.green) * coef + prev.color.green),
+            Math.floor((next.color.blue - prev.color.blue) * coef + prev.color.blue),
+        )
+    }
+
+    getAngleByColor(color: Color) {
+        let prev: typeof this.colors[number]
+        let next = this.colors[0]
+        if (color.red === next.color.red && color.green === next.color.green && color.blue === next.color.blue) return next.angle
+        for (let i = 1; i < this.colors.length; i++) {
+            next = this.colors[i]
+            prev = this.colors[i - 1]
+            if (color.red === next.color.red && color.green === next.color.green && color.blue === next.color.blue) return next.angle
+
+            let redDif = next.color.red - prev.color.red
+            let greenDif = next.color.green - prev.color.green
+            let blueDif = next.color.blue - prev.color.blue
+            let redDifColor = color.red - prev.color.red
+            let greenDifColor = color.green - prev.color.green
+            let blueDifColor = color.blue - prev.color.blue
+
+            if (
+                ((redDifColor >= 0 && redDifColor <= redDif) || (redDifColor <= 0 && redDifColor >= redDif)) &&
+                ((greenDifColor >= 0 && greenDifColor <= greenDif) || (greenDifColor <= 0 && greenDifColor >= greenDif)) &&
+                ((blueDifColor >= 0 && blueDifColor <= blueDif) || (blueDifColor <= 0 && blueDifColor >= blueDif))
+            ) {
+
+                const redCoef = ((color.red - prev.color.red) / (next.color.red - prev.color.red))
+                const greenCoef = ((color.green - prev.color.green) / (next.color.green - prev.color.green))
+                const blueCoef = ((color.blue - prev.color.blue) / (next.color.blue - prev.color.blue))
+                const coefs = [redCoef, greenCoef, blueCoef].filter(Boolean)
+                return (next.angle - prev.angle) * Math.min(...coefs) + prev.angle
+            }
+        }
+        return undefined
+    }
+
+    isColorInRange(color: Color): boolean {
+        return Boolean(this.getAngleByColor(color))
+    }
+
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCanvas(ctx: CanvasRenderingContext2D, center: IPoint2) {
+        const gradient = ctx.createConicGradient(0, ...center as [number, number])
+        for (let color of this.colors) {
+            gradient.addColorStop(color.angle, color.color.toCSS())
+        }
+
+        return gradient
+    }
+
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCSS() {
+        let s = ''
+
+        for (let color of this.colors) {
+            if (s) s += ','
+            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`
+        }
+
+        s = `conic-gradient(in srgb from 0.25turn at 50% 50%, ${s})`
+        return s
+    }
+
+}

package/src/colors/index.ts

@@ -0,0 +1,2 @@
+export * from './color'
+export * from './conic.gradient'

package/src/figures/circle.ts

@@ -0,0 +1,12 @@
+import {IPoint2} from "./point";
+import {IMatrix2d, Matrix2d} from "../matrix";
+
+export class Circle {
+    constructor(public center: IPoint2, public r: number) {
+
+    }
+
+    transform(matrix: IMatrix2d) {
+        this.center = Matrix2d.apply(matrix, this.center)
+    }
+}

package/src/figures/index.ts

@@ -0,0 +1,3 @@
+export * from './point'
+export * from './circle'
+export * from './straight-line'

package/src/figures/point.ts

@@ -0,0 +1,23 @@
+/**
+ * Точка/вектор
+ */
+export type IPoint2 = [number, number]
+
+/**
+ * Точка/вектор
+ */
+export class Point2 {
+    static sum(p1: IPoint2, p2: IPoint2): IPoint2 {
+        return [
+            p1[0] + p2[0],
+            p1[1] + p2[1],
+        ]
+    }
+
+    static scale(v: IPoint2, factor: number): IPoint2 {
+        return [
+            v[0] * factor,
+            v[1] * factor,
+        ]
+    }
+}

package/src/figures/straight-line.ts

@@ -0,0 +1,15 @@
+import {IPoint2} from "./point";
+import {IMatrix2d, Matrix2d} from "../matrix";
+
+export class StraightLine {
+    constructor(public p1: IPoint2, public p2: IPoint2) {
+
+    }
+
+    transform(matrix: IMatrix2d, transformThis = false) {
+        if (transformThis) {
+            return this
+        }
+        return new StraightLine(Matrix2d.apply(matrix, this.p1), Matrix2d.apply(matrix, this.p2))
+    }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './angle'
+export * from './matrix'
+export * from './operator'
+export * from './utils'
+export * from './colors'
+export * from './figures'

package/src/matrix.ts

@@ -0,0 +1,32 @@
+import {IPoint2} from "./figures";
+
+export type IMatrix2d = [
+    number, number, number,
+    number, number, number,
+]
+
+export const identityMatrix: IMatrix2d = [1, 0, 0, 1, 0, 0]
+
+export class Matrix2d {
+    static multiply(matrix: IMatrix2d, ...matrices: IMatrix2d[]) {
+        for (let m of matrices) {
+            matrix = [
+                matrix[0] * m[0] + matrix[2] * m[1],
+                matrix[1] * m[0] + matrix[3] * m[1],
+                matrix[0] * m[2] + matrix[2] * m[3],
+                matrix[1] * m[2] + matrix[3] * m[3],
+                matrix[0] * m[4] + matrix[2] * m[5] + matrix[4],
+                matrix[1] * m[4] + matrix[3] * m[5] + matrix[5],
+            ]
+        }
+
+        return matrix
+    }
+
+    static apply(matrix: IMatrix2d, point: IPoint2): IPoint2 {
+        return [
+            matrix[0] * point[0] + matrix[2] * point[1] + matrix[4],
+            matrix[1] * point[0] + matrix[3] * point[1] + matrix[5],
+        ]
+    }
+}

package/src/operator.ts

@@ -0,0 +1,23 @@
+import {IMatrix2d} from "./matrix";
+import {Angle, AngleUnits} from "./angle";
+
+export class Operator {
+    private static temp1: number
+    private static temp2: number
+
+    /**
+     * @param angle поворот в градусах
+     */
+    static rotateIdentity(angle: number, unit: AngleUnits = AngleUnits.Deg): IMatrix2d {
+        angle = Angle.toRad(angle, unit)
+        this.temp1 = Math.cos(angle)
+        this.temp2 = Math.sin(angle)
+        return [
+            this.temp1,
+            this.temp2,
+            -this.temp2,
+            this.temp1,
+            0, 0
+        ]
+    }
+}

package/src/utils.ts

@@ -0,0 +1,17 @@
+export function approximately(theValue: number, is: number, withPrecision: number = 1e-8) {
+    return Math.abs(theValue - is) <= withPrecision
+}
+
+export function toPositive(value: number, range: number) {
+    if (value >= 0) return Math.abs(value)
+    return Math.abs((range + value % range) % range)
+}
+
+export function isCorrectNumber(value: any) {
+    let v: number = +value
+    if (!isNaN(value) && isFinite(value)) {
+        v = parseFloat(value)
+        return !isNaN(v) && isFinite(v)
+    }
+    return false
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "extends": "./node_modules/@fbltd/bundler/tsconfig.json",
+    "compilerOptions": {
+        "moduleResolution": "Node",
+        "outFile": "dist/math.js",
+        "module": "AMD",
+        "sourceMap": true,
+        "declaration": true
+    }
+}