@eturnity/eturnity_maths 7.20.0 → 7.24.1

package/src/matrix.js

@@ -1,59 +1,65 @@
-import { substractVector } from "./vector"
+import { substractVector } from './vector'
 export function inverse2x2Matrix([a, b, c, d]) {
-    //inverse matrix |a,c|
-    //               |b,d|
-    const det = a * b - c * b
-    if (det == 0) {
-      return null
-    }
-    return [d / det, -b / det, -c / det, a / det]
+  //inverse matrix |a,c|
+  //               |b,d|
+  const det = a * b - c * b
+  if (det == 0) {
+    return null
   }
+  return [d / det, -b / det, -c / det, a / det]
+}
 
 export function inverse3x3matrix(m) {
-    let [[a, b, c], [d, e, f], [g, h, i]] = m
-    let x = e * i - h * f
-    let y = f * g - d * i
-    let z = d * h - g * e
-    let det = a * x + b * y + c * z
-    return det != 0
-      ? [
-          [x, c * h - b * i, b * f - c * e],
-          [y, a * i - c * g, d * c - a * f],
-          [z, g * b - a * h, a * e - d * b]
-        ].map((r) => r.map((v) => (v /= det)))
-      : null
+  let [[a, b, c], [d, e, f], [g, h, i]] = m
+  let x = e * i - h * f
+  let y = f * g - d * i
+  let z = d * h - g * e
+  let det = a * x + b * y + c * z
+  return det != 0
+    ? [
+        [x, c * h - b * i, b * f - c * e],
+        [y, a * i - c * g, d * c - a * f],
+        [z, g * b - a * h, a * e - d * b]
+      ].map((r) => r.map((v) => (v /= det)))
+    : null
+}
+export function multiplyMatrices(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || !a.length || !b.length) {
+    throw new Error('arguments should be in 2-dimensional array format')
   }
-  export function multiplyMatrices(a, b) {
-    if (!Array.isArray(a) || !Array.isArray(b) || !a.length || !b.length) {
-      throw new Error('arguments should be in 2-dimensional array format')
-    }
-    let x = a.length
-    let z = a[0].length
-    let y = b[0].length
-    if (b.length !== z) {
-      throw new Error(
-        'number of columns in the first matrix should be the same as the number of rows in the second'
-      )
-    }
-    let productRow = Array.apply(null, new Array(y)).map(
-      Number.prototype.valueOf,
-      0
+  let x = a.length
+  let z = a[0].length
+  let y = b[0].length
+  if (b.length !== z) {
+    throw new Error(
+      'number of columns in the first matrix should be the same as the number of rows in the second'
     )
-    let product = new Array(x)
-    for (let p = 0; p < x; p++) {
-      product[p] = productRow.slice()
-    }
-    for (let i = 0; i < x; i++) {
-      for (let j = 0; j < y; j++) {
-        for (let k = 0; k < z; k++) {
-          product[i][j] += a[i][k] * b[k][j]
-        }
+  }
+  let productRow = Array.apply(null, new Array(y)).map(
+    Number.prototype.valueOf,
+    0
+  )
+  let product = new Array(x)
+  for (let p = 0; p < x; p++) {
+    product[p] = productRow.slice()
+  }
+  for (let i = 0; i < x; i++) {
+    for (let j = 0; j < y; j++) {
+      for (let k = 0; k < z; k++) {
+        product[i][j] += a[i][k] * b[k][j]
       }
     }
-    return product
   }
-  export function rotateTransformation(point,angle,center = {x:0,y:0}){
-    let rotationMatrix=[[Math.cos(angle),Math.sin(angle)],[-Math.sin(angle),Math.cos(angle)]]
-    let k=multiplyMatrices(rotationMatrix,[[point.x-center.x],[point.y-center.y]])
-    return {x:k[0][0]+center.x,y:k[1][0]+center.y}
-  }
+  return product
+}
+export function rotateTransformation(point, angle, center = { x: 0, y: 0 }) {
+  let rotationMatrix = [
+    [Math.cos(angle), Math.sin(angle)],
+    [-Math.sin(angle), Math.cos(angle)]
+  ]
+  let k = multiplyMatrices(rotationMatrix, [
+    [point.x - center.x],
+    [point.y - center.y]
+  ])
+  return { x: k[0][0] + center.x, y: k[1][0] + center.y }
+}

package/src/miscellaneous.js

@@ -0,0 +1,45 @@
+export function groupIntoConsecutiveBuckets(arr, periodicity) {
+  if (arr.length == 0) {
+    return []
+  }
+  // Sort the array
+  arr.sort((a, b) => a - b)
+
+  // Initialize an array to store buckets
+  const buckets = []
+
+  // Initialize the first bucket with the first element of the array
+  let currentBucket = [arr[0]]
+
+  // Iterate through the sorted array
+  for (let i = 1; i < arr.length; i++) {
+    // Calculate the gap considering the periodicity
+    let gap = (arr[i] - arr[i - 1] + periodicity) % periodicity
+
+    // If the current element is consecutive to the previous one, add it to the current bucket
+    if (gap === 1) {
+      currentBucket.push(arr[i])
+    } else {
+      // If there's a gap, start a new bucket
+      buckets.push(currentBucket)
+      currentBucket = [arr[i]]
+    }
+  }
+
+  // Push the last bucket into the buckets array
+  buckets.push(currentBucket)
+
+  // Check if the last bucket and the first bucket are consecutive
+  if (
+    (buckets[buckets.length - 1][buckets[buckets.length - 1].length - 1] + 1) %
+      periodicity ===
+    buckets[0][0]
+  ) {
+    // Merge the last bucket with the first one
+    buckets[0] = buckets[buckets.length - 1].concat(buckets[0])
+    // Remove the last bucket
+    buckets.pop()
+  }
+
+  return buckets
+}

package/src/objects/Circle.js

@@ -1,15 +1,20 @@
-
 import {
   translate2D,
   verticalProjectionOnPlane,
   get3DDistanceBetweenPoints,
-  getDistanceBetweenPoints,
+  getDistanceBetweenPoints
 } from '../geometry'
 import { v4 as uuidv4 } from 'uuid'
-import {Point} from './Point'
-import { addVector, multiplyVector, substractVector,vectorLength,crossProduct,dotProduct,normalizeVector } from '../vector'
-
-
+import { Point } from './Point'
+import {
+  addVector,
+  multiplyVector,
+  substractVector,
+  vectorLength,
+  crossProduct,
+  dotProduct,
+  normalizeVector
+} from '../vector'
 
 export class Circle {
   constructor(center, radius, layer) {
@@ -31,21 +36,33 @@ export class Circle {
     circle.id = uuidv4()
     return circle
   }
-  getIntersections(object){
-    const intersections=[]
-    if(!object)return
-    if(object.type=="point"){
-      if(get3DDistanceBetweenPoints(object,this.center)==this.radius){
-        intersections.push({...object})
+  getIntersections(object) {
+    const intersections = []
+    if (!object) return
+    if (object.type == 'point') {
+      if (get3DDistanceBetweenPoints(object, this.center) == this.radius) {
+        intersections.push({ ...object })
       }
-    }else if(object.type=="line"){
-      let P=object.getProjectedPoint(this.center)
-      let distance = get3DDistanceBetweenPoints(P,this.center)
-      if(distance<=this.radius){
-        let A=addVector(P,multiplyVector(Math.sqrt(Math.pow(this.radius,2)-Math.pow(distance,2)),object.getDirectionVector()))
-        let B=addVector(P,multiplyVector(-Math.sqrt(Math.pow(this.radius,2)-Math.pow(distance,2)),object.getDirectionVector()))
-        intersections.push({...A})
-        intersections.push({...B})
+    } else if (object.type == 'line') {
+      let P = object.getProjectedPoint(this.center)
+      let distance = get3DDistanceBetweenPoints(P, this.center)
+      if (distance <= this.radius) {
+        let A = addVector(
+          P,
+          multiplyVector(
+            Math.sqrt(Math.pow(this.radius, 2) - Math.pow(distance, 2)),
+            object.getDirectionVector()
+          )
+        )
+        let B = addVector(
+          P,
+          multiplyVector(
+            -Math.sqrt(Math.pow(this.radius, 2) - Math.pow(distance, 2)),
+            object.getDirectionVector()
+          )
+        )
+        intersections.push({ ...A })
+        intersections.push({ ...B })
       }
     }
     return intersections
@@ -54,35 +71,53 @@ export class Circle {
     const toCanvasRef = canvasContext.toCanvasRef
     let pxCenter = toCanvasRef(this.center)
     let pxRadius = this.radius / canvasContext.mmPerPx
-    if(this.normalVector){
-      point.z=verticalProjectionOnPlane(point,this.normalVector,this.center).z
-    }else{
-      point.z=this.center.z
+    if (this.normalVector) {
+      point.z = verticalProjectionOnPlane(
+        point,
+        this.normalVector,
+        this.center
+      ).z
+    } else {
+      point.z = this.center.z
     }
     return Math.abs(get3DDistanceBetweenPoints(point, pxCenter) - pxRadius)
   }
   getDistanceToPoint(point) {
     return get3DDistanceBetweenPoints(point, this.getProjectedPoint(point))
-   }
-   getHorizontalDistanceToPoint(point) {
-   return getDistanceBetweenPoints(point, this.getVerticalProjectedPoint(point))
   }
-  isInPlane(plane){
-    if(!plane) return false
-    const {point,normalVector}=plane
-    const circleNormalVector=this.normalVector || {x:0,y:0,z:1}
-    if(vectorLength(crossProduct(circleNormalVector,normalVector))>0.1) return false
-    if(dotProduct(normalizeVector(substractVector(point,this.center)),normalVector)>0.1) return false
+  getHorizontalDistanceToPoint(point) {
+    return getDistanceBetweenPoints(
+      point,
+      this.getVerticalProjectedPoint(point)
+    )
+  }
+  isInPlane(plane) {
+    if (!plane) return false
+    const { point, normalVector } = plane
+    const circleNormalVector = this.normalVector || { x: 0, y: 0, z: 1 }
+    if (vectorLength(crossProduct(circleNormalVector, normalVector)) > 0.1)
+      return false
+    if (
+      dotProduct(
+        normalizeVector(substractVector(point, this.center)),
+        normalVector
+      ) > 0.1
+    )
+      return false
     return true
-   }
+  }
   getProjectedPoint(point) {
-    if(this.normalVector){
-      point.z=verticalProjectionOnPlane(point,this.normalVector,this.center).z
-    }else{
-      point.z=this.center.z
+    if (this.normalVector) {
+      point.z = verticalProjectionOnPlane(
+        point,
+        this.normalVector,
+        this.center
+      ).z
+    } else {
+      point.z = this.center.z
     }
     let distance = get3DDistanceBetweenPoints(point, this.center)
-        if (distance == 0) {
+    if (distance == 0) {
       console.error("can't project center to cercle", this)
       return null
     }
@@ -93,9 +128,9 @@ export class Circle {
     return P
   }
   getVerticalProjectedPoint(point) {
-   return this.getProjectedPoint(point)
+    return this.getProjectedPoint(point)
   }
   translate(vectorInMm) {
     this.center = translate2D(this.center, vectorInMm)
   }
-}
+}