pcb-scene3d-viewer 1.1.49 → 1.2.0

package/src/PcbScene3dCopperFillMeshBuilder.mjs

@@ -1,6 +1,7 @@
 import earcut from 'earcut'
-import { PcbAssemblyFillGeometryResolver } from './PcbAssemblyFillGeometryResolver.mjs'
 import { PcbScene3dCopperFillAreaClipper } from './PcbScene3dCopperFillAreaClipper.mjs'
+import { PcbScene3dCopperFillCoverageContext } from './PcbScene3dCopperFillCoverageContext.mjs'
+import { PcbScene3dCopperFillLoopSetResolver } from './PcbScene3dCopperFillLoopSetResolver.mjs'
 import { PcbScene3dCopperFillPolygonBoolean } from './PcbScene3dCopperFillPolygonBoolean.mjs'
 import { PcbScene3dCopperOcclusionClipper } from './PcbScene3dCopperOcclusionClipper.mjs'
 
@@ -8,8 +9,6 @@ import { PcbScene3dCopperOcclusionClipper } from './PcbScene3dCopperOcclusionCli
  * Builds saved copper fill meshes for the interactive 3D scene.
  */
 export class PcbScene3dCopperFillMeshBuilder {
-    static #AREA_EPSILON = 0.001
-
     /**
      * Builds one combined copper fill mesh.
      * @param {any} THREE Three.js namespace.
@@ -20,7 +19,7 @@ export class PcbScene3dCopperFillMeshBuilder {
      * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
      * @param {any} material Copper material.
      * @param {{ x: number, y: number }[][]} [cutouts] Optional normalized overlay cutouts.
-     * @param {{ surfaceOnly?: boolean, clipContainedFillOverlaps?: boolean }} [options] Optional mesh options.
+     * @param {{ surfaceOnly?: boolean, clipContainedFillOverlaps?: boolean, loopSets?: { outer: number[][], holes: number[][][], bounds: object }[], coverageContext?: object }} [options] Optional mesh options.
      * @returns {any | null}
      */
     static build(
@@ -38,6 +37,13 @@ export class PcbScene3dCopperFillMeshBuilder {
         const halfThickness = Math.max(Number(thickness || 0), 0.001) / 2
         const bottomZ = Number(z || 0) - halfThickness
         const topZ = Number(z || 0) + halfThickness
+        const loopSets = Array.isArray(options?.loopSets)
+            ? options.loopSets
+            : PcbScene3dCopperFillLoopSetResolver.resolve(
+                  fills,
+                  normalizeBoardPoint,
+                  mirrorY
+              )
 
         if (
             PcbScene3dCopperFillMeshBuilder.#shouldClipContainedFillOverlaps(
@@ -47,22 +53,18 @@ export class PcbScene3dCopperFillMeshBuilder {
             PcbScene3dCopperFillMeshBuilder.#appendClippedFillPositions(
                 THREE,
                 positions,
-                fills,
+                loopSets,
                 bottomZ,
                 topZ,
-                normalizeBoardPoint,
-                mirrorY,
                 options
             )
         } else {
-            for (const fill of fills || []) {
-                PcbScene3dCopperFillMeshBuilder.#appendFillPositions(
+            for (const loopSet of loopSets) {
+                PcbScene3dCopperFillMeshBuilder.#appendNormalizedLoopSetPositions(
                     positions,
-                    fill,
+                    loopSet,
                     bottomZ,
                     topZ,
-                    normalizeBoardPoint,
-                    mirrorY,
                     options
                 )
             }
@@ -107,70 +109,34 @@ export class PcbScene3dCopperFillMeshBuilder {
         return PcbScene3dCopperOcclusionClipper.filter(THREE, geometry, cutouts)
     }
 
-    /**
-     * Appends one filled primitive to a shared position buffer.
-     * @param {number[]} positions Position buffer.
-     * @param {object} fill Filled copper primitive.
-     * @param {number} bottomZ Lower Z.
-     * @param {number} topZ Upper Z.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @param {{ surfaceOnly?: boolean }} options Mesh options.
-     * @returns {void}
-     */
-    static #appendFillPositions(
-        positions,
-        fill,
-        bottomZ,
-        topZ,
-        normalizeBoardPoint,
-        mirrorY,
-        options
-    ) {
-        for (const loops of PcbAssemblyFillGeometryResolver.resolveAll(fill)) {
-            PcbScene3dCopperFillMeshBuilder.#appendLoopSetPositions(
-                positions,
-                loops,
-                bottomZ,
-                topZ,
-                normalizeBoardPoint,
-                mirrorY,
-                options
-            )
-        }
-    }
-
     /**
      * Appends fill positions while removing duplicate overlap surfaces.
      * @param {any} THREE Three.js namespace.
      * @param {number[]} positions Position buffer.
-     * @param {object[]} fills Filled copper primitives.
+     * @param {{ outer: number[][], holes: number[][][], bounds: object }[]} loopSets Normalized fill islands.
      * @param {number} bottomZ Lower Z.
      * @param {number} topZ Upper Z.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @param {{ surfaceOnly?: boolean, clipContainedFillOverlaps?: boolean }} options Mesh options.
+     * @param {{ surfaceOnly?: boolean, clipContainedFillOverlaps?: boolean, coverageContext?: object }} options Mesh options.
      * @returns {void}
      */
     static #appendClippedFillPositions(
         THREE,
         positions,
-        fills,
+        loopSets,
         bottomZ,
         topZ,
-        normalizeBoardPoint,
-        mirrorY,
         options
     ) {
-        const loopSets = PcbScene3dCopperFillMeshBuilder.#resolveLoopSets(
-            fills,
-            normalizeBoardPoint,
-            mirrorY
-        )
         const emittedPolygons = []
         const emittedLoopSets = []
+        let coverageContext = null
 
-        for (const loopSet of loopSets) {
+        for (
+            let loopSetIndex = 0;
+            loopSetIndex < loopSets.length;
+            loopSetIndex += 1
+        ) {
+            const loopSet = loopSets[loopSetIndex]
             const remainingLoopSets =
                 PcbScene3dCopperFillPolygonBoolean.resolveRemainingLoopSets(
                     loopSet,
@@ -188,11 +154,23 @@ export class PcbScene3dCopperFillMeshBuilder {
                     )
                 }
             } else {
+                if (!coverageContext) {
+                    coverageContext =
+                        options?.coverageContext?.matchesLoopSets?.(
+                            loopSets
+                        ) === true
+                            ? options.coverageContext
+                            : PcbScene3dCopperFillCoverageContext.fromLoopSets(
+                                  loopSets
+                              )
+                }
                 PcbScene3dCopperFillMeshBuilder.#appendTriangleClippedLoopSet(
                     THREE,
                     positions,
                     loopSet,
                     emittedLoopSets,
+                    loopSetIndex,
+                    coverageContext,
                     bottomZ,
                     topZ,
                     options
@@ -214,6 +192,8 @@ export class PcbScene3dCopperFillMeshBuilder {
      * @param {number[]} positions Position buffer.
      * @param {{ outer: number[][], holes: number[][][], bounds: object }} loopSet Candidate loop set.
      * @param {{ outer: number[][], holes: number[][][], bounds: object }[]} emittedLoopSets Already emitted loop sets.
+     * @param {number} loopSetIndex Flattened candidate source index.
+     * @param {object} coverageContext Prepared ordered fill coverage.
      * @param {number} bottomZ Lower Z.
      * @param {number} topZ Upper Z.
      * @param {{ surfaceOnly?: boolean, clipContainedFillOverlaps?: boolean }} options Mesh options.
@@ -224,6 +204,8 @@ export class PcbScene3dCopperFillMeshBuilder {
         positions,
         loopSet,
         emittedLoopSets,
+        loopSetIndex,
+        coverageContext,
         bottomZ,
         topZ,
         options
@@ -249,10 +231,12 @@ export class PcbScene3dCopperFillMeshBuilder {
         )
         PcbScene3dCopperFillMeshBuilder.#appendPositions(
             positions,
-            PcbScene3dCopperFillMeshBuilder.#clipPositionsAgainstLoopSets(
+            PcbScene3dCopperFillMeshBuilder.#clipPositionsAgainstCoverage(
                 THREE,
                 loopPositions,
-                PcbScene3dCopperFillMeshBuilder.#resolveClipLoopSets(
+                coverageContext,
+                loopSetIndex,
+                PcbScene3dCopperFillMeshBuilder.#resolveClipSourceIndexes(
                     loopSet,
                     emittedLoopSets
                 )
@@ -261,14 +245,21 @@ export class PcbScene3dCopperFillMeshBuilder {
     }
 
     /**
-     * Resolves earlier loop sets that can actually overlap a candidate.
+     * Resolves indexes of earlier loop sets that can overlap a candidate.
      * @param {{ outer: number[][], holes: number[][][], bounds: object }} candidate Candidate loop set.
      * @param {{ outer: number[][], holes: number[][][], bounds: object }[]} loopSets Emitted loop sets.
-     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[]}
+     * @returns {Set<number>}
      */
-    static #resolveClipLoopSets(candidate, loopSets) {
-        return loopSets.filter(
-            (loopSet) =>
+    static #resolveClipSourceIndexes(candidate, loopSets) {
+        const sourceIndexes = new Set()
+
+        for (
+            let sourceIndex = 0;
+            sourceIndex < loopSets.length;
+            sourceIndex += 1
+        ) {
+            const loopSet = loopSets[sourceIndex]
+            if (
                 PcbScene3dCopperFillMeshBuilder.#boundsOverlap(
                     candidate.bounds,
                     loopSet.bounds
@@ -277,7 +268,12 @@ export class PcbScene3dCopperFillMeshBuilder {
                     candidate,
                     loopSet
                 )
-        )
+            ) {
+                sourceIndexes.add(sourceIndex)
+            }
+        }
+
+        return sourceIndexes
     }
 
     /**
@@ -293,14 +289,22 @@ export class PcbScene3dCopperFillMeshBuilder {
     }
 
     /**
-     * Clips position triangles against already-emitted fill loop sets.
+     * Clips position triangles against eligible prepared fill areas.
      * @param {any} THREE Three.js namespace.
      * @param {number[]} positions Candidate triangle positions.
-     * @param {{ outer: number[][], holes: number[][][] }[]} loopSets Filled areas already represented.
+     * @param {object} coverageContext Prepared ordered fill coverage.
+     * @param {number} beforeSourceIndex Exclusive source-order prefix.
+     * @param {Set<number>} allowedSourceIndexes Eligible earlier sources.
      * @returns {number[]}
      */
-    static #clipPositionsAgainstLoopSets(THREE, positions, loopSets) {
-        if (!positions.length || !loopSets.length) {
+    static #clipPositionsAgainstCoverage(
+        THREE,
+        positions,
+        coverageContext,
+        beforeSourceIndex,
+        allowedSourceIndexes
+    ) {
+        if (!positions.length || !allowedSourceIndexes.size) {
             return positions
         }
 
@@ -310,12 +314,11 @@ export class PcbScene3dCopperFillMeshBuilder {
             new THREE.Float32BufferAttribute(positions, 3)
         )
         const mesh = new THREE.Mesh(geometry)
-        const clippedMesh = PcbScene3dCopperFillAreaClipper.filter(
+        const clippedMesh = PcbScene3dCopperFillAreaClipper.filterPrepared(
             THREE,
             mesh,
-            PcbScene3dCopperFillMeshBuilder.#loopSetsToFills(loopSets),
-            (x, y) => ({ x, y }),
-            false
+            coverageContext,
+            { beforeSourceIndex, allowedSourceIndexes }
         )
         if (!clippedMesh) {
             return []
@@ -323,77 +326,6 @@ export class PcbScene3dCopperFillMeshBuilder {
 
         return Array.from(clippedMesh.geometry.attributes.position.array)
     }
-
-    /**
-     * Converts normalized loop sets back to fill primitives for shared clipping.
-     * @param {{ outer: number[][], holes: number[][][] }[]} loopSets Loop sets.
-     * @returns {object[]}
-     */
-    static #loopSetsToFills(loopSets) {
-        return loopSets.map((loopSet) => ({
-            points: loopSet.outer.map((point) => ({
-                x: point[0],
-                y: point[1]
-            })),
-            holes: (loopSet.holes || []).map((hole) =>
-                hole.map((point) => ({
-                    x: point[0],
-                    y: point[1]
-                }))
-            )
-        }))
-    }
-
-    /**
-     * Appends one fill island loop set to a shared position buffer.
-     * @param {number[]} positions Position buffer.
-     * @param {{ outer: number[][], holes: number[][][] }} loops Fill loop set.
-     * @param {number} bottomZ Lower Z.
-     * @param {number} topZ Upper Z.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @param {{ surfaceOnly?: boolean }} options Mesh options.
-     * @returns {void}
-     */
-    static #appendLoopSetPositions(
-        positions,
-        loops,
-        bottomZ,
-        topZ,
-        normalizeBoardPoint,
-        mirrorY,
-        options
-    ) {
-        const outer = PcbScene3dCopperFillMeshBuilder.#normalizeLoop(
-            loops.outer,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        const holes = (loops.holes || [])
-            .map((loop) =>
-                PcbScene3dCopperFillMeshBuilder.#normalizeLoop(
-                    loop,
-                    normalizeBoardPoint,
-                    mirrorY
-                )
-            )
-            .filter((loop) =>
-                PcbScene3dCopperFillMeshBuilder.#isValidLoop(loop)
-            )
-
-        if (!PcbScene3dCopperFillMeshBuilder.#isValidLoop(outer)) {
-            return
-        }
-
-        PcbScene3dCopperFillMeshBuilder.#appendNormalizedLoopSetPositions(
-            positions,
-            { outer, holes },
-            bottomZ,
-            topZ,
-            options
-        )
-    }
-
     /**
      * Appends one already-normalized fill island loop set.
      * @param {number[]} positions Position buffer.
@@ -453,63 +385,6 @@ export class PcbScene3dCopperFillMeshBuilder {
         }
     }
 
-    /**
-     * Resolves normalized fill loop sets.
-     * @param {object[]} fills Filled copper primitives.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @returns {{ outer: number[][], holes: number[][][], bounds: object }[]}
-     */
-    static #resolveLoopSets(fills, normalizeBoardPoint, mirrorY) {
-        return (fills || []).flatMap((fill) =>
-            PcbAssemblyFillGeometryResolver.resolveAll(fill)
-                .map((loops) =>
-                    PcbScene3dCopperFillMeshBuilder.#normalizeLoopSet(
-                        loops,
-                        normalizeBoardPoint,
-                        mirrorY
-                    )
-                )
-                .filter(Boolean)
-        )
-    }
-
-    /**
-     * Normalizes one fill loop set.
-     * @param {{ outer: number[][], holes: number[][][] }} loops Source loops.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @returns {{ outer: number[][], holes: number[][][], bounds: object } | null}
-     */
-    static #normalizeLoopSet(loops, normalizeBoardPoint, mirrorY) {
-        const outer = PcbScene3dCopperFillMeshBuilder.#normalizeLoop(
-            loops.outer,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        if (!PcbScene3dCopperFillMeshBuilder.#isValidLoop(outer)) {
-            return null
-        }
-
-        const holes = (loops.holes || [])
-            .map((loop) =>
-                PcbScene3dCopperFillMeshBuilder.#normalizeLoop(
-                    loop,
-                    normalizeBoardPoint,
-                    mirrorY
-                )
-            )
-            .filter((loop) =>
-                PcbScene3dCopperFillMeshBuilder.#isValidLoop(loop)
-            )
-
-        return {
-            outer,
-            holes,
-            bounds: PcbScene3dCopperFillMeshBuilder.#loopBounds(outer)
-        }
-    }
-
     /**
      * Resolves later fill loops fully contained by an earlier loop set.
      * @param {{ outer: number[][], holes: number[][][], bounds: object }} loopSet Current loop set.
@@ -579,31 +454,6 @@ export class PcbScene3dCopperFillMeshBuilder {
         return options?.clipContainedFillOverlaps === true
     }
 
-    /**
-     * Normalizes one loop into local copper-side coordinates.
-     * @param {number[][]} loop Source loop.
-     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
-     * @param {boolean} mirrorY Whether to mirror underside Y coordinates.
-     * @returns {number[][]}
-     */
-    static #normalizeLoop(loop, normalizeBoardPoint, mirrorY) {
-        const points = []
-        for (const point of loop || []) {
-            const normalized = normalizeBoardPoint(
-                Number(point?.[0]),
-                Number(point?.[1])
-            )
-            const nextPoint = [
-                Number(normalized?.x),
-                mirrorY ? -Number(normalized?.y) : Number(normalized?.y)
-            ]
-            if (nextPoint.every(Number.isFinite)) {
-                points.push(nextPoint)
-            }
-        }
-        return PcbScene3dCopperFillMeshBuilder.#cleanLoop(points)
-    }
-
     /**
      * Flattens loops for triangulation.
      * @param {number[][]} outer Outer loop.
@@ -711,59 +561,6 @@ export class PcbScene3dCopperFillMeshBuilder {
         positions.push(point[0], point[1], z)
     }
 
-    /**
-     * Removes invalid and duplicate loop points.
-     * @param {number[][]} points Candidate points.
-     * @returns {number[][]}
-     */
-    static #cleanLoop(points) {
-        const loop = []
-        for (const point of points || []) {
-            const x = Number(point?.[0])
-            const y = Number(point?.[1])
-            if (!Number.isFinite(x) || !Number.isFinite(y)) {
-                continue
-            }
-
-            const previous = loop[loop.length - 1]
-            if (
-                previous &&
-                Math.abs(previous[0] - x) < 0.001 &&
-                Math.abs(previous[1] - y) < 0.001
-            ) {
-                continue
-            }
-            loop.push([x, y])
-        }
-
-        const first = loop[0]
-        const last = loop[loop.length - 1]
-        if (
-            first &&
-            last &&
-            Math.abs(first[0] - last[0]) < 0.001 &&
-            Math.abs(first[1] - last[1]) < 0.001
-        ) {
-            loop.pop()
-        }
-
-        return loop
-    }
-
-    /**
-     * Checks whether one loop has enough non-collinear area.
-     * @param {number[][]} loop Candidate loop.
-     * @returns {boolean}
-     */
-    static #isValidLoop(loop) {
-        return (
-            Array.isArray(loop) &&
-            loop.length >= 3 &&
-            Math.abs(PcbScene3dCopperFillMeshBuilder.#signedArea(loop)) >
-                PcbScene3dCopperFillMeshBuilder.#AREA_EPSILON
-        )
-    }
-
     /**
      * Computes axis-aligned bounds for one loop.
      * @param {number[][]} loop Candidate loop.
@@ -897,19 +694,4 @@ export class PcbScene3dCopperFillMeshBuilder {
 
         return inside
     }
-
-    /**
-     * Computes signed loop area.
-     * @param {number[][]} loop Candidate loop.
-     * @returns {number}
-     */
-    static #signedArea(loop) {
-        let area = 0
-        for (let index = 0; index < loop.length; index += 1) {
-            const current = loop[index]
-            const next = loop[(index + 1) % loop.length]
-            area += current[0] * next[1] - next[0] * current[1]
-        }
-        return area / 2
-    }
 }

package/src/PcbScene3dCopperTextFactory.mjs

@@ -17,7 +17,7 @@ export class PcbScene3dCopperTextFactory {
      * @param {any[]} texts
      * @param {number} z
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
-     * @param {{ side?: 'top' | 'bottom', mirrorY?: boolean, materialColor?: number, materialProperties?: { materialKind?: 'basic' | 'standard', roughness?: number, metalness?: number, transparent?: boolean, opacity?: number, toneMapped?: boolean, fog?: boolean }, filterSide?: boolean, glyphYUp?: boolean, drillCutouts?: { x: number, y: number }[][] }} [options]
+     * @param {{ side?: 'top' | 'bottom', mirrorY?: boolean, materialColor?: number, materialProperties?: { materialKind?: 'basic' | 'standard', roughness?: number, metalness?: number, transparent?: boolean, opacity?: number, toneMapped?: boolean, fog?: boolean }, filterSide?: boolean, glyphYUp?: boolean, drillCutouts?: { x: number, y: number }[][], preparedPolygonCache?: Map }} [options]
      * @returns {any}
      */
     static buildGroup(THREE, texts, z, normalizeBoardPoint, options = {}) {
@@ -59,7 +59,8 @@ export class PcbScene3dCopperTextFactory {
             PcbScene3dCopperTextFactory.#filterDrillCutouts(
                 THREE,
                 geometry,
-                options?.drillCutouts
+                options?.drillCutouts,
+                options?.preparedPolygonCache
             )
 
         if (
@@ -88,14 +89,21 @@ export class PcbScene3dCopperTextFactory {
      * @param {any} THREE
      * @param {any} geometry
      * @param {{ x: number, y: number }[][] | undefined} drillCutouts
+     * @param {Map | undefined} preparedPolygonCache Request-scoped prepared cache.
      * @returns {any}
      */
-    static #filterDrillCutouts(THREE, geometry, drillCutouts) {
+    static #filterDrillCutouts(
+        THREE,
+        geometry,
+        drillCutouts,
+        preparedPolygonCache
+    ) {
         return Array.isArray(drillCutouts) && drillCutouts.length
             ? PcbScene3dCutoutGeometryFilter.filter(
                   THREE,
                   geometry,
-                  drillCutouts
+                  drillCutouts,
+                  { preparedPolygonCache }
               )
             : geometry
     }

package/src/PcbScene3dCutoutCircleDetector.mjs

@@ -21,14 +21,27 @@ export class PcbScene3dCutoutCircleDetector {
         }
 
         const center = PcbScene3dCutoutCircleDetector.#resolveCentroid(points)
-        const radii = points.map((point) =>
-            Math.hypot(point.x - center.x, point.y - center.y)
-        )
-        const radius =
-            radii.reduce((sum, value) => sum + value, 0) / radii.length
-        const maxError = Math.max(
-            ...radii.map((value) => Math.abs(value - radius))
-        )
+        let radiusSum = 0
+        for (let index = 0; index < points.length; index += 1) {
+            if (!(index in points)) {
+                continue
+            }
+
+            const point = points[index]
+            radiusSum += Math.hypot(point.x - center.x, point.y - center.y)
+        }
+        const radius = radiusSum / points.length
+        let maxError = -Infinity
+        for (let index = 0; index < points.length; index += 1) {
+            if (!(index in points)) {
+                maxError = Math.max(maxError, undefined)
+                continue
+            }
+
+            const point = points[index]
+            const value = Math.hypot(point.x - center.x, point.y - center.y)
+            maxError = Math.max(maxError, Math.abs(value - radius))
+        }
         const tolerance = Math.max(
             Number(epsilon || 0),
             radius * PcbScene3dCutoutCircleDetector.#MAX_RELATIVE_ERROR
@@ -68,17 +81,21 @@ export class PcbScene3dCutoutCircleDetector {
      * @returns {{ x: number, y: number }}
      */
     static #resolveCentroid(points) {
-        const sum = points.reduce(
-            (accumulator, point) => ({
-                x: accumulator.x + Number(point.x || 0),
-                y: accumulator.y + Number(point.y || 0)
-            }),
-            { x: 0, y: 0 }
-        )
+        let totalX = 0
+        let totalY = 0
+        for (let index = 0; index < points.length; index += 1) {
+            if (!(index in points)) {
+                continue
+            }
+
+            const point = points[index]
+            totalX += Number(point.x || 0)
+            totalY += Number(point.y || 0)
+        }
 
         return {
-            x: sum.x / points.length,
-            y: sum.y / points.length
+            x: totalX / points.length,
+            y: totalY / points.length
         }
     }
 }