pimath 0.1.40 → 0.2.1

package/src/geometry/triangle.ts

@@ -1,27 +1,27 @@
-import { Fraction } from "../coefficients/fraction"
-import { Line } from "./line"
-import { Vector } from "./vector"
-import { Point } from "./point"
-import type {remarquableLines} from "../pimath.interface"
+import {Fraction} from "../coefficients"
+import {Line} from "./line"
+import {Vector} from "./vector"
+import {Point} from "./point"
+import type {InputValue, remarquableLines} from "../pimath.interface"
+import {Numeric} from "../numeric"
 
+type TRIANGLE_SIDES = 'AB' | 'AC' | 'BC'
+
+// TODO: add a check if it's a triangle or not.
 export class Triangle {
+    // This defines the triangle
     #A: Point = new Point()
     #B: Point = new Point()
     #C: Point = new Point()
-    #lines: { 'AB': Line, 'AC': Line, 'BC': Line } = {
-        'AB': new Line(),
-        'AC': new Line(),
-        'BC': new Line()
-    }
-    #middles: { 'AB': Point, 'AC': Point, 'BC': Point } = {
-        'AB': new Point(),
-        'AC': new Point(),
-        'BC': new Point()
+    #isValid = false
+// This is calculated
+    #lines: Record<TRIANGLE_SIDES, Line> | null = null
+    #radians = true
+    #remarquables: remarquableLines = {
+        mediators: null, medians: null, heights: null, externalBisectors: null, bisectors: null
     }
-    #remarquables: remarquableLines | null = null
 
     constructor(...values: unknown[]) {
-
         if (values.length > 0) {
             this.parse(...values)
         }
@@ -29,26 +29,99 @@ export class Triangle {
         return this
     }
 
-    // ------------------------------------------
-    // Getter and setters
-    // ------------------------------------------
+    parse = (...values: unknown[]): this => {
 
-    get A(): Point {
-        return this.#A
+        if (values.length === 1) {
+            if (values[0] instanceof Triangle) {
+                return this.copy(values[0])
+            }
+        }
+
+        if (values.length === 3) {
+            // Possibilities:
+            // - Three points (or part of points, only dict for example, or array
+            // - Three lines
+            // - Three lines as text.
+            if (values.every((x: unknown) => typeof x === 'string')) {
+                // Three lines as text.
+                const [a, b, c] = values
+                return this.fromLines(a, b, c)
+            }
+
+            if (values.every((x: unknown) => x instanceof Line)) {
+                // We have three lines
+                return this.fromLines(values[0], values[1], values[2])
+            }
+
+            if (values.every((x: unknown) => (x instanceof Point))) {
+                return this.fromPoints(values[0], values[1], values[2])
+            }
+        }
+
+        if (values.length === 6) {
+            const v: Fraction[] = values.map((x: unknown) => new Fraction(x as string))
+
+            if (v.some(x => x.isNaN())) {
+                throw new Error('One of the values is not a valid number')
+            }
+
+            return this.fromCoordinates(v[0], v[1], v[2], v[3], v[4], v[5])
+        }
+
+        return this
     }
 
-    get B(): Point {
-        return this.#B
+    /**
+     * Clone the Triangle class
+     */
+    clone = (): Triangle => {
+        return new Triangle(
+            this.#A.clone(),
+            this.#B.clone(),
+            this.#C.clone()
+        )
     }
 
-    get C(): Point {
-        return this.#C
+    /**
+     * Copy the values from another triangle
+     * @param value
+     */
+    copy(value: Triangle): this {
+        this.#A = value.A.clone()
+        this.#B = value.B.clone()
+        this.#C = value.C.clone()
+
+        return this
+    }
+
+    get A(): Point {
+        return this.#A
+    }
+
+    set A(value: Point) {
+        this.#A = value
+        this.#A.onChange = () => this.reset()
+        this.reset()
     }
 
     get AB(): Vector {
         return this.#getSegment('A', 'B')
     }
 
+    get AC(): Vector {
+        return this.#getSegment('A', 'C')
+    }
+
+    get B(): Point {
+        return this.#B
+    }
+
+    set B(value: Point) {
+        this.#B = value
+        this.#B.onChange = () => this.reset()
+        this.reset()
+    }
+
     get BA(): Vector {
         return this.#getSegment('B', 'A')
     }
@@ -57,298 +130,353 @@ export class Triangle {
         return this.#getSegment('B', 'C')
     }
 
-    get CB(): Vector {
-        return this.#getSegment('C', 'B')
+    get C(): Point {
+        return this.#C
     }
 
-    get AC(): Vector {
-        return this.#getSegment('A', 'C')
+    set C(value: Point) {
+        this.#C = value
+        this.#C.onChange = () => this.reset()
+        this.reset()
     }
 
     get CA(): Vector {
         return this.#getSegment('C', 'A')
     }
 
-    get isRectangle(): boolean {
-        if (this.AB.isNormalTo(this.BC)) {
-            return true
+    get CB(): Vector {
+        return this.#getSegment('C', 'B')
+    }
+
+    get asDegree(): this {
+        this.#radians = false
+        return this
+    }
+
+    get asRadians(): this {
+        this.#radians = true
+        return this
+    }
+
+    fromCoordinates(
+        x1: InputValue<Fraction>, y1: InputValue<Fraction>,
+        x2: InputValue<Fraction>, y2: InputValue<Fraction>,
+        x3: InputValue<Fraction>, y3: InputValue<Fraction>): this {
+
+        return this.fromPoints(
+            new Point(x1, y1),
+            new Point(x2, y2),
+            new Point(x3, y3),
+        )
+    }
+
+    fromLines(line1: Line | string, line2: Line | string, line3: Line | string): this {
+        const AB: Line = new Line(line1).clone()
+        const BC: Line = new Line(line2).clone()
+        const AC: Line = new Line(line3).clone()
+
+        // Get the intersection points -> build the triangle using these intersection points.
+        let intersect = AB.intersection(BC)
+        if (intersect.hasIntersection) {
+            this.#B = intersect.point
+        } else {
+            this.#isValid = false
+            return this
         }
-        if (this.AB.isNormalTo(this.AC)) {
-            return true
+
+        intersect = BC.intersection(AC)
+        if (intersect.hasIntersection) {
+            this.#C = intersect.point
+        } else {
+            this.#isValid = false
+            return this
         }
-        if (this.BC.isNormalTo(this.AC)) {
-            return true
+
+        intersect = AC.intersection(AB)
+        if (intersect.hasIntersection) {
+            this.#A = intersect.point
+        } else {
+            this.#isValid = false
+            return this
         }
 
-        return false
-    }
+        // reset the remarquables lines.
+        this.reset()
 
-    get isEquilateral(): boolean {
-        return this.AB.normSquare.isEqual(this.BC.normSquare) &&
-            this.AB.normSquare.isEqual(this.AC.normSquare)
-    }
+        // Force the use of the given lines.
+        this.#lines = {AB, AC, BC}
+
+        return this
 
-    get isIsocele(): boolean {
-        return this.AB.normSquare.isEqual(this.BC.normSquare) ||
-            this.AB.normSquare.isEqual(this.AC.normSquare) ||
-            this.BC.normSquare.isEqual(this.AC.normSquare)
     }
 
-    get lines(): { 'AB': Line, 'BC': Line, 'AC': Line } {
-        return this.#lines
+    fromPoints(A: Point, B: Point, C: Point): this {
+        // We have three points.
+        this.#A = A.clone()
+        this.#B = B.clone()
+        this.#C = C.clone()
+
+        this.reset()
+
+        return this
     }
 
-    get remarquables(): remarquableLines | null {
-        return this.#remarquables
+    getAngle(name: 'A' | 'B' | 'C'): number {
+        const a = this.BC.norm
+        const b = this.AC.norm
+        const c = this.AB.norm
+
+        if (name === 'A') {
+            return this.#cosThm(a, b, c)
+        }
+
+        if (name === 'C') {
+            return this.#cosThm(c, b, a)
+        }
+
+        return this.#cosThm(b, a, c)
     }
 
-    // ------------------------------------------
-    // Creation / parsing functions
-    // ------------------------------------------
 
-    /**
-     * Parse values to a triangle. Supported formats:
-     * Vector2D, Vector2D, Vector2D
-     * x1, y1, x2, y2, x3, y3
-     * @param values
-     */
-    parse = (...values: unknown[]): Triangle => {
-        if (values.length === 6) {
-            // Check if all values are number or fractions.
-            const v: Fraction[] = values.map((x: unknown) => new Fraction(x as string))
+    getBisectors(internal = true): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
 
-            if (v.some(x => x.isNaN())) {
-                throw new Error('One of the values is not a valid number')
-            }
+        if (!this.#remarquables.bisectors) {
+            const A = this.#calculateBisectors('A', internal)
+            const B = this.#calculateBisectors('B', internal)
+            const C = this.#calculateBisectors('C', internal)
 
-            return this.parse(
-                new Vector(v[0], v[1]),
-                new Vector(v[2], v[3]),
-                new Vector(v[4], v[5]),
-            )
-        } else if (values.length === 3) {
-            // Possibilities:
-            // - Three points (or part of points, only dict for example, or array
-            // - Three lines
-            // - Three lines as text.
-            if (values.every((x: unknown) => typeof x === 'string')) {
-                // Three lines as text.
-                return this.parse(
-                    ...values.map((x) => {
-                        return new Line(x)
-                    })
-                )
-            } else if (values.every((x: unknown) => x instanceof Line)) {
-                // We have three lines
-                const AB: Line = (values[0]).clone()
-                const BC: Line = (values[1]).clone()
-                const AC: Line = (values[2]).clone()
-                this.#lines = { AB, BC, AC }
-
-                // Get the intersection points -> build the triangle using these intersection points.
-                let intersect = AB.intersection(BC)
-                if (intersect.hasIntersection) {
-                    this.#B = intersect.point.clone()
-                } else {
-                    throw new Error('Lines do not intersect !')
-                }
-
-                intersect = BC.intersection(AC)
-                if (intersect.hasIntersection) {
-                    this.#C = intersect.point.clone()
-                } else {
-                    throw new Error('Lines do not intersect !')
-                }
-
-                intersect = AC.intersection(AB)
-                if (intersect.hasIntersection) {
-                    this.#A = intersect.point.clone()
-                } else {
-                    throw new Error('Lines do not intersect !')
-                }
-
-            } else if (values.every((x: unknown) => (x instanceof Point))) {
-                // We have three points.
-                this.#A = (values[0]).clone()
-                this.#B = (values[1]).clone()
-                this.#C = (values[2]).clone()
-                this.#lines = {
-                    'AB': new Line(this.#A, this.#B),
-                    'BC': new Line(this.#B, this.#C),
-                    'AC': new Line(this.#A, this.#C)
-                }
-            }
-        } else if (values.length === 1) {
-            if (values[0] instanceof Triangle) {
-                return values[0].clone()
-            }
+            const intersection = A.intersection(B).point
+            this.#remarquables.bisectors = {A, B, C, intersection}
         }
 
-        this.#updateTriangle()
-        return this
+        return this.#remarquables.bisectors
     }
 
-    /**
-     * Clone the Triangle class
-     */
-    clone = (): Triangle => {
-        return new Triangle(
-            this.#A.clone(),
-            this.#B.clone(),
-            this.#C.clone()
-        )
+    getHeights(): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
+
+        if (!this.#remarquables.heights) {
+            const A = new Line().fromPointAndNormal(this.#A, new Vector(this.#B, this.#C))
+            const B = new Line().fromPointAndNormal(this.#B, new Vector(this.#A, this.#C))
+            const C = new Line().fromPointAndNormal(this.#C, new Vector(this.#A, this.#B))
+
+            const intersection = A.intersection(B).point
+            this.#remarquables.heights = {A, B, C, intersection}
+        }
+
+        return this.#remarquables.heights
     }
 
+    getMedians(): { 'A': Line, 'B': Line, 'C': Line, 'intersection': Point | null } {
+        const middles = this.getMiddles()
 
-    // ------------------------------------------
-    // Triangle operations and properties
-    // ------------------------------------------
+        if (!this.#remarquables.medians) {
+            const A = new Line().fromPoints(this.#A, middles.BC)
+            const B = new Line().fromPoints(this.#B, middles.AC)
+            const C = new Line().fromPoints(this.#C, middles.AB)
 
-    /**
-     * Generate the Line object for the three segments of the triangle
-     */
-    #updateTriangle = () => {
-        this.#A.asPoint = true
-        this.#B.asPoint = true
-        this.#C.asPoint = true
+            const intersection = A.intersection(B).point
+            this.#remarquables.medians = {A, B, C, intersection}
+        }
+
+        return this.#remarquables.medians
+    }
+
+    getMediators(): { 'a': Line, 'b': Line, 'c': Line, 'intersection': Point | null } {
+        const middles = this.getMiddles()
 
-        this.#middles = {
+        if (!this.#remarquables.mediators) {
+            const a = new Line().fromPointAndNormal(middles.BC, new Vector(this.#B, this.#C))
+            const b = new Line().fromPointAndNormal(middles.AC, new Vector(this.#A, this.#C))
+            const c = new Line().fromPointAndNormal(middles.AB, new Vector(this.#A, this.#B))
+
+            const intersection = a.intersection(b).point
+            this.#remarquables.mediators = {a, b, c, intersection}
+        }
+
+        return this.#remarquables.mediators
+    }
+
+    getMiddles() {
+        return {
             'AB': new Point().middleOf(this.#A, this.#B),
             'AC': new Point().middleOf(this.#A, this.#C),
             'BC': new Point().middleOf(this.#B, this.#C)
         }
+    }
 
-        this.#remarquables = this.#calculateRemarquableLines()
+    getPoints(): Point[] {
+        return [this.A, this.B, this.C]
     }
 
+    getSortedPoints(): Point[] {
+        return this.getPoints().sort((a, b) => {
+            return a.x.value === b.x.value
+                ? a.y.value - b.y.value
+                : a.x.value - b.x.value
+        })
+    }
 
-    /**
-     * Get the Vector2D class for the given name
-     * @param ptName
-     */
-    #getPointByName = (ptName: string): Point => {
-        switch (ptName.toUpperCase()) {
-            case 'A':
-                return this.#A
-            case 'B':
-                return this.#B
-            case 'C':
-                return this.#C
-        }
+    isEqual(T: Triangle): boolean {
+        if (!this.#isValid || !T.isValid) return false
+
+        // TODO: compare points in a particular order.
+        const tri1 = this.getSortedPoints()
+        const tri2 = T.getSortedPoints()
+
+        return tri1.every((_, index) => tri1[index].isEqual(tri2[index]))
 
-        // Something went wrong ! Return the first point
-        return this.#A
     }
-    /**
-     * Get the vector for the segment given by name.
-     * @param ptName1
-     * @param ptName2
-     */
-    #getSegment = (ptName1: string, ptName2: string): Vector => {
-        return new Vector(
-            this.#getPointByName(ptName1),
-            this.#getPointByName(ptName2)
-        )
+
+    isEquilateral(): boolean {
+        if (!this.#isValid) return false
+
+        const dAB = this.AB.normSquare.value
+        const dBC = this.BC.normSquare.value
+        const dAC = this.AC.normSquare.value
+
+        return (dAB === dBC) && (dAB === dAC)
     }
 
-    #calculateRemarquableLines = (): remarquableLines => {
+    isIsocele(): boolean {
+        if (!this.#isValid) return false
 
-        const medians = {
-            'A': new Line().fromPoints(this.#A, this.#middles.BC),
-            'B': new Line().fromPoints(this.#B, this.#middles.AC),
-            'C': new Line().fromPoints(this.#C, this.#middles.AB),
-            'intersection': null
-        }
+        const dAB = this.AB.normSquare.value
+        const dBC = this.BC.normSquare.value
+        const dAC = this.AC.normSquare.value
 
-        const mediators = {
-            'AB': new Line().fromPointAndNormal(this.#middles.AB, new Vector(this.#A, this.#B).normal()),
-            'AC': new Line().fromPointAndNormal(this.#middles.AC, new Vector(this.#A, this.#C).normal()),
-            'BC': new Line().fromPointAndNormal(this.#middles.BC, new Vector(this.#B, this.#C).normal()),
-            'intersection': null
-        }
+        return dAB === dBC ||
+            dAB === dAC ||
+            dBC === dAC
+    }
 
-        const heights = {
-            'A': new Line().fromPointAndNormal(this.#A, new Vector(this.#B, this.#C).normal()),
-            'B': new Line().fromPointAndNormal(this.#B, new Vector(this.#A, this.#C).normal()),
-            'C': new Line().fromPointAndNormal(this.#C, new Vector(this.#A, this.#B).normal()),
-            'intersection': null
-        }
+    isRectangle(): boolean {
+        if (!this.#isValid) return false
 
-        const bA = this.#calculateBisectors('A'),
-            bB = this.#calculateBisectors('B'),
-            bC = this.#calculateBisectors('C')
+        return this.AB.isNormalTo(this.BC) ||
+            this.AB.isNormalTo(this.AC) ||
+            this.BC.isNormalTo(this.AC)
+    }
 
-        const bisectors = {
-            'A': bA.internal,
-            'B': bB.internal,
-            'C': bB.internal,
-            'intersection': null
-        }
+    get isValid(): boolean {
+        return this.#isValid
+    }
 
-        const externalBisectors = {
-            'A': bA.external,
-            'B': bB.external,
-            'C': bC.external,
-            'intersection': null
-        }
+    set isValid(value: boolean) {
+        this.#isValid = value
+    }
 
-        const remarquables: remarquableLines = {
-            medians,
-            mediators,
-            heights,
-            bisectors,
-            externalBisectors
+    get lines(): Record<TRIANGLE_SIDES, Line> {
+        if (this.#lines === null) {
+            this.#lines = {
+                'AB': new Line(this.#A, this.#B),
+                'BC': new Line(this.#B, this.#C),
+                'AC': new Line(this.#A, this.#C)
+            }
         }
 
-        // As it's a triangle, we assume the lines are intersecting and aren't parallel or superposed.
-        remarquables.medians.intersection = remarquables.medians.A.intersection(remarquables.medians.B).point
-        remarquables.mediators.intersection = remarquables.mediators.AB.intersection(remarquables.mediators.BC).point
-        remarquables.heights.intersection = remarquables.heights.A.intersection(remarquables.heights.B).point
-        remarquables.bisectors.intersection = remarquables.bisectors.A.intersection(remarquables.bisectors.B).point
+        return this.#lines
+    }
 
-        // Everything was calculated for the remarquable lines.
-        return remarquables
+    medianA(): Line {
+        return this.getMedians().A
     }
 
-    #calculateBisectors = (pt: string): { internal: Line, external: Line } => {
+    medianB(): Line {
+        return this.getMedians().B
+    }
+
+    medianC(): Line {
+        return this.getMedians().C
+    }
+
+    get remarquables(): remarquableLines | null {
+        return this.#remarquables
+    }
+
+    public reset(): this {
+        // Check if the triangle is valid
+        // the three points must NOT be aligned.
+        this.#isValid = !this.AB.isColinearTo(this.AC)
+
+        this.#lines = null
+        this.#remarquables = {
+            mediators: null,
+            medians: null,
+            heights: null,
+            externalBisectors: null,
+            bisectors: null
+        }
+
+        return this
+    }
+
+    #calculateBisectors(pt: string, internal = true): Line {
         const tlines = this.lines
-        let d1, d2
+        let d1: Vector = new Vector()
+        let d2: Vector = new Vector()
+        let P: Point = new Point()
 
         if (pt === 'A') {
-            d1 = tlines.AB
-            d2 = tlines.AC
+            P = this.A.clone()
+            d1 = tlines.AB.clone().d
+            d2 = tlines.AC.clone().d
         } else if (pt === 'B') {
-            d1 = tlines.AB
-            d2 = tlines.BC
+            P = this.B.clone()
+            d1 = tlines.AB.clone().d.opposite()
+            d2 = tlines.BC.clone().d
         } else if (pt === 'C') {
-            d1 = tlines.BC
-            d2 = tlines.AC
+            P = this.C.clone()
+            d1 = tlines.BC.clone().d.opposite()
+            d2 = tlines.AC.clone().d.opposite()
         }
 
         if (d1 === undefined || d2 === undefined) {
             throw new Error(`The point ${pt} does not exist`)
         }
 
-        const d1n = d1.n.simplify().norm
-        const d2n = d2.n.simplify().norm
-        const d1Equ = d1.getEquation().multiply(d2n)
-        const d2Equ = d2.getEquation().multiply(d1n)
+        const director = internal
+            ? d1.unit().add(d2.unit())
+            : d1.unit().subtract(d2.unit())
 
-        const b1: Line = new Line(d1Equ.clone().subtract(d2Equ).simplify())
-        const b2: Line = new Line(d2Equ.clone().subtract(d1Equ).simplify())
+        return new Line().fromPointAndDirection(P, director)
+    }
 
-        // Must determine which bisectors is in the triangle
-        if (pt === 'A') {
-            return b1.hitSegment(this.B, this.C) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
-        }
-        if (pt === 'B') {
-            return b1.hitSegment(this.A, this.C) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
-        }
-        if (pt === 'C') {
-            return b1.hitSegment(this.B, this.A) ? { internal: b1, external: b2 } : { internal: b2, external: b1 }
+    #cosThm(opposite: number, adjacent1: number, adjacent2: number): number {
+        const ratio = ((adjacent1 ** 2 + adjacent2 ** 2) - opposite ** 2) / (2 * adjacent1 * adjacent2)
+
+        return this.#radians
+            ? Math.acos(ratio)
+            : Numeric.numberCorrection(Math.acos(ratio) * 180 / Math.PI)
+    }
+
+    /**
+     * Get the Point class for the given name
+     * @param ptName
+     */
+    #getPointByName = (ptName: string): Point => {
+        switch (ptName.toUpperCase()) {
+            case 'A':
+                return this.#A
+            case 'B':
+                return this.#B
+            case 'C':
+                return this.#C
         }
 
-        // Default returns the first bisector
-        return { internal: b1, external: b2 }
+        // Something went wrong ! Return the first point
+        return this.#A
+    }
+
+    /**
+     * Get the vector for the segment given by name.
+     * @param ptName1
+     * @param ptName2
+     */
+    #getSegment = (ptName1: string, ptName2: string): Vector => {
+        return new Vector(
+            this.#getPointByName(ptName1),
+            this.#getPointByName(ptName2)
+        )
     }
-}
+
+}