@eturnity/eturnity_maths 9.7.0 → 9.10.0

package/src/objects/hydrate.js

@@ -1,4 +1,25 @@
 import { Polygon } from './Polygon'
+import { Circle } from './Circle'
+import { Line } from './Line'
+import { Point } from './Point'
+import { Measurement } from './Measurement'
+import { Plane, defaultPlane } from './Plane'
+import { updateComputedGeometryPolygon } from './derivedState/updateComputedGeometryPolygon'
+export function hydrateItem(serializedItem) {
+  if (serializedItem.type == 'circle') {
+    return hydrateCircle(serializedItem)
+  } else if (serializedItem.type == 'polygon') {
+    return hydratePolygon(serializedItem)
+  } else if (serializedItem.type == 'line') {
+    return hydrateLine(serializedItem)
+  } else if (serializedItem.type == 'point') {
+    return hydratePoint(serializedItem)
+  } else if (serializedItem.type == 'measurement') {
+    return hydrateMeasurement(serializedItem)
+  } else if (serializedItem.type == 'plane') {
+    return hydratePlane(serializedItem)
+  }
+}
 export function hydratePolygon(serializedPolygon) {
   const layer = serializedPolygon.layer
   let polygon = new Polygon(serializedPolygon.outline, layer)
@@ -24,6 +45,214 @@ export function hydratePolygon(serializedPolygon) {
     polygon.row_index = serializedPolygon.row_index
     polygon.col_index = serializedPolygon.col_index
     polygon.moduleField = serializedPolygon.moduleField
+  } else if (layer == 'roof_plan_item') {
+    polygon.shape = 'polygon'
+    polygon.colorIndex = serializedPolygon.colorIndex
+    polygon.hasFillColor = serializedPolygon.hasFillColor
   }
+  updateComputedGeometryPolygon(polygon)
   return polygon
 }
+export function hydrateCircle(serializedCircle) {
+  const layer = serializedCircle.layer
+  let circle = new Circle(
+    serializedCircle.center,
+    serializedCircle.radius,
+    layer
+  )
+  circle.id = serializedCircle.id
+  circle.version = serializedCircle.version
+  circle.name = serializedCircle.name
+  circle.margins = serializedCircle.margins
+  if (layer == 'roof_plan_item') {
+    circle.shape = 'circle'
+    circle.colorIndex = serializedCircle.colorIndex
+    circle.hasFillColor = serializedCircle.hasFillColor
+  }
+  return circle
+}
+export function hydrateLine(serializedLine) {
+  // Convert outline points to Point instances (handles both 2D and 3D)
+  const firstPoint =
+    serializedLine.outline && serializedLine.outline[0]
+      ? new Point(
+          serializedLine.outline[0].x,
+          serializedLine.outline[0].y,
+          serializedLine.outline[0].z !== undefined
+            ? serializedLine.outline[0].z
+            : 0,
+          serializedLine.layer
+        )
+      : null
+  const lastPoint =
+    serializedLine.outline && serializedLine.outline[1]
+      ? new Point(
+          serializedLine.outline[1].x,
+          serializedLine.outline[1].y,
+          serializedLine.outline[1].z !== undefined
+            ? serializedLine.outline[1].z
+            : 0,
+          serializedLine.layer
+        )
+      : null
+
+  const layer = serializedLine.layer
+  let line = new Line(
+    firstPoint,
+    lastPoint,
+    layer,
+    serializedLine.infiniteLine || false
+  )
+
+  // Restore belongsTo, hydrating items if they are serialized
+  if (serializedLine.belongsTo && Array.isArray(serializedLine.belongsTo)) {
+    line.belongsTo = serializedLine.belongsTo.map((belongsToEntry) => {
+      const belongsToItem = {
+        itemId: belongsToEntry.itemId,
+        index: belongsToEntry.index,
+      }
+      // If item is serialized, hydrate it based on type
+      if (belongsToEntry.item && belongsToEntry.item.type) {
+        belongsToItem.item =
+          belongsToEntry.item.type === 'circle'
+            ? hydrateCircle(belongsToEntry.item)
+            : hydratePolygon(belongsToEntry.item)
+      } else {
+        belongsToItem.item = belongsToEntry.item
+      }
+      return belongsToItem
+    })
+  }
+
+  // Restore itemType (node2D, node3D, edge2D, edge3D, etc.)
+  if (serializedLine.itemType) {
+    line.itemType = serializedLine.itemType
+  }
+
+  // Restore other properties if present
+  if (serializedLine.id !== undefined) {
+    line.id = serializedLine.id
+  }
+  if (serializedLine.version !== undefined) {
+    line.version = serializedLine.version
+  }
+  if (serializedLine.infiniteLine !== undefined) {
+    line.infiniteLine = serializedLine.infiniteLine
+  }
+  if (serializedLine.selected !== undefined) {
+    line.selected = serializedLine.selected
+  }
+  if (serializedLine.colorIndex !== undefined) {
+    line.colorIndex = serializedLine.colorIndex
+  }
+
+  return line
+}
+export function hydratePoint(serializedPoint) {
+  const layer = serializedPoint.layer
+  let point = new Point(
+    serializedPoint.x,
+    serializedPoint.y,
+    serializedPoint.z !== undefined ? serializedPoint.z : 0,
+    layer
+  )
+
+  // Restore belongsTo, hydrating items if they are serialized
+  if (serializedPoint.belongsTo && Array.isArray(serializedPoint.belongsTo)) {
+    point.belongsTo = serializedPoint.belongsTo.map((belongsToEntry) => {
+      const belongsToItem = {
+        itemId: belongsToEntry.itemId, // fallback for backward compatibility
+        index: belongsToEntry.index,
+      }
+      // If item is serialized, hydrate it based on type
+      if (belongsToEntry.item && belongsToEntry.item.type) {
+        belongsToItem.item =
+          belongsToEntry.item.type === 'circle'
+            ? hydrateCircle(belongsToEntry.item)
+            : hydratePolygon(belongsToEntry.item)
+      } else {
+        belongsToItem.item = belongsToEntry.item
+      }
+      return belongsToItem
+    })
+  }
+
+  // Restore itemType (node2D, node3D, edge2D, edge3D, etc.)
+  if (serializedPoint.itemType) {
+    point.itemType = serializedPoint.itemType
+  }
+
+  // Restore other properties if present
+  if (serializedPoint.id !== undefined) {
+    point.id = serializedPoint.id
+  }
+  if (serializedPoint.version !== undefined) {
+    point.version = serializedPoint.version
+  }
+  if (serializedPoint.open !== undefined) {
+    point.open = serializedPoint.open
+  }
+  if (serializedPoint.selected !== undefined) {
+    point.selected = serializedPoint.selected
+  }
+  if (serializedPoint.visible !== undefined) {
+    point.visible = serializedPoint.visible
+  }
+  if (serializedPoint.hasWarning !== undefined) {
+    point.hasWarning = serializedPoint.hasWarning
+  }
+  if (serializedPoint.colorIndex !== undefined) {
+    point.colorIndex = serializedPoint.colorIndex
+  }
+  if (serializedPoint.masterHandle !== undefined) {
+    point.masterHandle = serializedPoint.masterHandle
+  }
+
+  return point
+}
+export function hydrateMeasurement(serializedMeasurement) {
+  const measurement = new Measurement({
+    references: serializedMeasurement.references.map((ref) => hydrateItem(ref)),
+    refPoint: serializedMeasurement.refPoint
+      ? hydrateItem(serializedMeasurement.refPoint)
+      : null,
+    projectionPlane: serializedMeasurement.projectionPlane
+      ? hydratePlane(serializedMeasurement.projectionPlane)
+      : defaultPlane,
+  })
+  if (serializedMeasurement.id !== undefined) {
+    measurement.id = serializedMeasurement.id
+  }
+  measurement.offsetMm = serializedMeasurement.offsetMm
+  measurement.customLength = serializedMeasurement.customLength
+  measurement.projectionPlane = serializedMeasurement.projectionPlane
+    ? hydratePlane(serializedMeasurement.projectionPlane)
+    : null
+  measurement.update()
+  return measurement
+}
+
+export function hydratePlane(serializedPlane) {
+  // Handle case where serializedPlane is already a Plane instance
+  if (serializedPlane instanceof Plane) {
+    return serializedPlane
+  }
+
+  // Handle case where serializedPlane is a plain object (backward compatibility)
+  const plane = new Plane({
+    id: serializedPlane.id,
+    origin: serializedPlane.origin,
+    normalVector: serializedPlane.normalVector,
+    horizontalVector: serializedPlane.horizontalVector,
+    upVector: serializedPlane.upVector,
+    matrixRealityToPlane: serializedPlane.matrixRealityToPlane,
+    matrixPlaneToReality: serializedPlane.matrixPlaneToReality,
+  })
+
+  // Restore version if present
+  if (serializedPlane.version !== undefined) {
+    plane.version = serializedPlane.version
+  }
+
+  return plane
+}

package/src/objects/index.js

@@ -2,6 +2,8 @@ export * from './Point'
 export * from './Line'
 export * from './Polygon'
 export * from './Circle'
+export * from './Measurement'
+export * from './Plane'
 export * from './hydrate'
 export * from './Vector'
 export * from './derivedState'

package/src/plane.js

@@ -0,0 +1,76 @@
+import { inverse3x3Matrix } from './matrix'
+import {
+  get3DDistanceBetweenPoints,
+  pointProjectionOnPlane,
+  isClockWise,
+} from './geometry'
+import {
+  normalizeVector,
+  crossProduct,
+  substractVector,
+  multiplyVector,
+} from './vector'
+import { Plane } from './objects/Plane'
+
+export function getLongestEdgeData(outline) {
+  if (!outline || outline.length < 3) {
+    throw new Error('invalid outline', outline)
+  }
+  let longestEdgeLength = 0
+  let longestEdgeIndex = 0
+  let edge = [outline[0], outline[1]]
+  for (let index = 0; index < outline.length; index++) {
+    const p = outline[index]
+    const indexNext = (index + 1) % outline.length
+    const pNext = outline[indexNext]
+    const edgeLength = get3DDistanceBetweenPoints(p, pNext)
+    if (edgeLength > longestEdgeLength) {
+      longestEdgeLength = edgeLength
+      longestEdgeIndex = index
+      edge = [p, pNext]
+    }
+  }
+  return {
+    edge,
+    index: longestEdgeIndex,
+    edgeLength: longestEdgeLength,
+    edgeDirectionVector: normalizeVector(substractVector(edge[1], edge[0])),
+  }
+}
+
+export function getPlaneFromPolygon(polygon) {
+  const origin = pointProjectionOnPlane(
+    { x: 0, y: 0, z: 0 },
+    polygon.normalVector,
+    polygon.outline[0]
+  )
+  const normalVector = polygon.normalVector
+  const { edgeDirectionVector } = getLongestEdgeData(polygon.outline)
+  let horizontalVector = {
+    x: edgeDirectionVector.x,
+    y: edgeDirectionVector.y,
+    z: edgeDirectionVector.z,
+  }
+  if (polygon.incline > 3) {
+    horizontalVector = {
+      x: Math.cos((polygon.direction * Math.PI) / 180),
+      y: -Math.sin((polygon.direction * Math.PI) / 180),
+      z: 0,
+    }
+  }
+  let upVector = normalizeVector(
+    crossProduct(polygon.normalVector, horizontalVector)
+  )
+  const isOutlineClockwise = isClockWise(polygon.outline)
+  if (!isOutlineClockwise) {
+    horizontalVector = multiplyVector(-1, horizontalVector)
+    upVector = multiplyVector(-1, upVector)
+  }
+  return new Plane({
+    id: polygon.id,
+    origin,
+    normalVector,
+    horizontalVector,
+    upVector,
+  })
+}

package/src/splitMergePolygons.js

@@ -28,8 +28,8 @@ export function mergePolygons(polygonIdsToMerge, edges, layer, polygons) {
   const insideEdge = edges.filter((e) => e.belongsTo.length == 2)
   const insideEdgeToKeep = insideEdge.filter((e) => {
     return (
-      !polygonIdsToMerge.includes(e.belongsTo[0].polygonId) ||
-      !polygonIdsToMerge.includes(e.belongsTo[1].polygonId)
+      !polygonIdsToMerge.includes(e.belongsTo[0].itemId) ||
+      !polygonIdsToMerge.includes(e.belongsTo[1].itemId)
     )
   })
   const newEdges = [...outsideEdge, ...insideEdgeToKeep]
@@ -151,7 +151,7 @@ export function splitPolygonsV2(polygons) {
             const edge2 = edges[intersection.edge_index_2]
 
             for (let i = 0; i < edge1.belongsTo.length; i++) {
-              if (edge1.belongsTo[i].polygonId === candidate.id) {
+              if (edge1.belongsTo[i].itemId === candidate.id) {
                 if (!intersectedEdges[edge2.id]) {
                   intersectedEdges[edge2.id] = {
                     count: 0,
@@ -164,7 +164,7 @@ export function splitPolygonsV2(polygons) {
             }
 
             for (let i = 0; i < edge2.belongsTo.length; i++) {
-              if (edge2.belongsTo[i].polygonId === candidate.id) {
+              if (edge2.belongsTo[i].itemId === candidate.id) {
                 if (!intersectedEdges[edge1.id]) {
                   intersectedEdges[edge1.id] = {
                     count: 0,
@@ -184,9 +184,9 @@ export function splitPolygonsV2(polygons) {
 
           if (commmonEdgeId) {
             const edge = intersectedEdges[commmonEdgeId].edge
-            const parentPolygons = edge.belongsTo.map(
-              (element) => element.polygon
-            )
+          const parentPolygons = edge.belongsTo
+            .filter((element) => element.item?.type === 'polygon')
+            .map((element) => element.item)
             parentPolygons.sort(
               (a, b) => calculateArea(b.outline) - calculateArea(a.outline)
             )
@@ -392,7 +392,7 @@ export function getEdgeIntersections(edges, tolerance = FLOAT_PRECISION) {
       let skipNextEdge = false
       edge.belongsTo.forEach((edgeParent) => {
         nextEdge.belongsTo.forEach((nextEdgeParent) => {
-          if (edgeParent.polygonId === nextEdgeParent.polygonId) {
+          if (edgeParent.itemId === nextEdgeParent.itemId) {
             skipNextEdge = true
           }
         })

package/src/tests/Line/isTouchingLine.spec.js

@@ -0,0 +1,233 @@
+import { Line } from '../../objects/Line'
+import { Point } from '../../objects/Point'
+
+describe('Line.isTouchingLine', () => {
+  describe('when lines intersect at one point', () => {
+    test('should return true when lines intersect perpendicularly', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(1, -1, 0), new Point(1, 1, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines intersect at an angle', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 2, 0))
+      const line2 = new Line(new Point(0, 2, 0), new Point(2, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines intersect at endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(2, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+  })
+
+  describe('when lines are parallel but not collinear', () => {
+    test('should return false when lines are parallel and separated', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 1, 0), new Point(2, 1, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+
+    test('should return false when lines are parallel and separated vertically', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(0, 2, 0))
+      const line2 = new Line(new Point(1, 0, 0), new Point(1, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+
+    test('should return false when lines are parallel and separated diagonally', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 2, 0))
+      const line2 = new Line(new Point(1, 0, 0), new Point(3, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+  })
+
+  describe('when lines are collinear', () => {
+    test('should return true when lines overlap completely', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines overlap partially', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(3, 0, 0))
+      const line2 = new Line(new Point(1, 0, 0), new Point(4, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when one line is contained within the other', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(4, 0, 0))
+      const line2 = new Line(new Point(1, 0, 0), new Point(3, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines touch at one endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(4, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return false when lines are collinear but do not overlap', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(1, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(3, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+
+    test('should return true when lines are collinear and share one endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(4, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+  })
+
+  describe('when lines touch at extremities', () => {
+    test('should return true when lines touch at first endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 0, 0), new Point(0, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines touch at last endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, -2, 0), new Point(2, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines touch at middle point', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(1, 0, 0), new Point(1, 2, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+  })
+
+  describe('edge cases', () => {
+    test('should return true when lines are identical', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when lines are identical but reversed', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(0, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return false when lines are very close but not touching', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 0.001, 0), new Point(2, 0.001, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+
+    test('should return false when lines are skew (not parallel and not intersecting)', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(0, 0, 1), new Point(2, 0, 1))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+  })
+  describe('aligned lines cases ', () => {
+    test('should return true line touching on one endpoint', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(10, 0, 0))
+      const line2 = new Line(new Point(10, 0, 0), new Point(20, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+    test('should return false line not touching', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(10, 0, 0))
+      const line2 = new Line(new Point(11, 0, 0), new Point(20, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+  })
+  describe('collinear edge cases with different orientations', () => {
+    test('should return true when collinear lines overlap with different directions', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(3, 0, 0))
+      const line2 = new Line(new Point(3, 0, 0), new Point(1, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when collinear lines touch at endpoints', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 0, 0))
+      const line2 = new Line(new Point(2, 0, 0), new Point(4, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return false when collinear lines are adjacent but not overlapping', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(1, 0, 0))
+      const line2 = new Line(new Point(1.1, 0, 0), new Point(2, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+  })
+
+  describe('diagonal lines', () => {
+    test('should return true when diagonal lines intersect', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 2, 0))
+      const line2 = new Line(new Point(0, 2, 0), new Point(2, 0, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return true when diagonal collinear lines overlap', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(3, 3, 0))
+      const line2 = new Line(new Point(1, 1, 0), new Point(4, 4, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(true)
+      expect(line2.isTouchingLine(line1)).toBe(true)
+    })
+
+    test('should return false when diagonal parallel lines are separated', () => {
+      const line1 = new Line(new Point(0, 0, 0), new Point(2, 2, 0))
+      const line2 = new Line(new Point(0, 1, 0), new Point(2, 3, 0))
+
+      expect(line1.isTouchingLine(line2)).toBe(false)
+      expect(line2.isTouchingLine(line1)).toBe(false)
+    })
+  })
+})

package/src/tests/Plane/CoordinateChange.spec.js

@@ -0,0 +1,32 @@
+import { Plane } from '../../objects/Plane'
+import { Point } from '../../objects/Point'
+
+describe('Plane.toRealityCoordinates & Plane.toPlaneCoordinates test', () => {
+  test('should return the same coordinates when converting to plane coordinates and back to reality coordinates', () => {
+    const plane = new Plane({
+      origin: { x: 10, y: 10, z: 10 },
+      normalVector: { x: 1, y: 1, z: 1 },
+      horizontalVector: { x: 1, y: -1, z: 0 },
+      upVector: { x: 1, y: 1, z: -2 },
+    })
+    const point = new Point(1, 2, 3)
+    const realityPoint = plane.toRealityCoordinates(point)
+    const planePoint = plane.toPlaneCoordinates(realityPoint)
+    expect(planePoint.x).toBeCloseTo(point.x)
+    expect(planePoint.y).toBeCloseTo(point.y)
+    expect(planePoint.z).toBeCloseTo(point.z)
+  })
+  test('should return correct coordinates 1', () => {
+    const plane = new Plane({
+      origin: { x: 10, y: 10, z: 10 },
+      normalVector: { x: 1, y: 1, z: 1 },
+      horizontalVector: { x: 1, y: -1, z: 0 },
+      upVector: { x: 1, y: 1, z: -2 },
+    })
+    const point = new Point(13, 11, 9)
+    const planePoint = plane.toPlaneCoordinates(point)
+    expect(planePoint.x).toBeCloseTo(1)
+    expect(planePoint.y).toBeCloseTo(1)
+    expect(planePoint.z).toBeCloseTo(1)
+  })
+})

package/src/tests/coords/toRealityRefFunction.spec.js

@@ -0,0 +1,25 @@
+import { toRealityRefFunction } from '../../index'
+import { Plane } from '../../objects/Plane'
+
+const RoofPlane = new Plane({
+  origin: { x: 0, y: 1, z: 0 },
+  normalVector: { x: 0, y: 0.71, z: 0.71 },
+  horizontalVector: { x: 1, y: 0, z: 0 },
+  upVector: { x: 0, y: -0.71, z: 0.71 },
+})
+describe('toRealityRefFunction', () => {
+  test('should convert canvas coordinates to reality coordinates with default plane', () => {
+    const canvasSize = { width: 800, height: 600 }
+    const mmPerPx = 1
+    const layoutOffset = { x: 0, y: 0 }
+    const toReality = toRealityRefFunction(canvasSize, mmPerPx, layoutOffset,RoofPlane)
+
+    const canvasPoint = { x: 1, y: -1.4142, z: 0 }
+    const realityPoint = toReality(canvasPoint)
+    expect(realityPoint.x).toBeCloseTo(1, 2)
+    expect(realityPoint.y).toBeCloseTo(0, 2)
+    expect(realityPoint.z).toBeCloseTo(1, 2)
+  })
+})
+
+