@linkiez/dxf-renew 7.0.0 → 7.2.0

package/src/denormalise.ts

@@ -3,19 +3,186 @@ import cloneDeep from 'lodash/cloneDeep'
 import logger from './util/logger'
 
 import type {
-  ArcEntity,
-  Block,
-  CircleEntity,
-  EllipseEntity,
-  Entity,
-  InsertEntity,
-  LineEntity,
-  ParsedDXF,
-  PolylineEntity,
-  SplineEntity,
-  Transform,
+    ArcEntity,
+    Block,
+    CircleEntity,
+    DimensionEntity,
+    EllipseEntity,
+    Entity,
+    InsertEntity,
+    LineEntity,
+    MTextEntity,
+    ParsedDXF,
+    PolylineEntity,
+    SplineEntity,
+    TextEntity,
+    Transform,
 } from './types'
 
+type BlockBasePointAdjuster = (entity: Entity, block: Block) => void
+
+function adjustLineForBlockBasePoint(entity: Entity, block: Block): void {
+  const line = entity as LineEntity
+  line.start.x -= block.x
+  line.start.y -= block.y
+  line.end.x -= block.x
+  line.end.y -= block.y
+}
+
+function adjustPolylineForBlockBasePoint(entity: Entity, block: Block): void {
+  const poly = entity as PolylineEntity
+  for (const v of poly.vertices) {
+    if (v.x !== undefined) v.x -= block.x
+    if (v.y !== undefined) v.y -= block.y
+  }
+}
+
+function adjustCircleForBlockBasePoint(entity: Entity, block: Block): void {
+  const circle = entity as CircleEntity
+  circle.x -= block.x
+  circle.y -= block.y
+}
+
+function adjustEllipseForBlockBasePoint(entity: Entity, block: Block): void {
+  const ellipse = entity as EllipseEntity
+  ellipse.x -= block.x
+  ellipse.y -= block.y
+}
+
+function adjustArcForBlockBasePoint(entity: Entity, block: Block): void {
+  const arc = entity as ArcEntity
+  arc.x -= block.x
+  arc.y -= block.y
+}
+
+function adjustSplineForBlockBasePoint(entity: Entity, block: Block): void {
+  const spline = entity as SplineEntity
+  for (const cp of spline.controlPoints) {
+    cp.x -= block.x
+    cp.y -= block.y
+  }
+}
+
+function adjustTextForBlockBasePoint(entity: Entity, block: Block): void {
+  const text = entity as TextEntity
+  if (text.x !== undefined) text.x -= block.x
+  if (text.y !== undefined) text.y -= block.y
+  if (text.x2 !== undefined) text.x2 -= block.x
+  if (text.y2 !== undefined) text.y2 -= block.y
+}
+
+function adjustMTextForBlockBasePoint(entity: Entity, block: Block): void {
+  const mtext = entity as MTextEntity
+  if (mtext.x !== undefined) mtext.x -= block.x
+  if (mtext.y !== undefined) mtext.y -= block.y
+}
+
+function adjustDimensionForBlockBasePoint(entity: Entity, block: Block): void {
+  const dim = entity as DimensionEntity
+  dim.start.x -= block.x
+  dim.start.y -= block.y
+  dim.textMidpoint.x -= block.x
+  dim.textMidpoint.y -= block.y
+  dim.measureStart.x -= block.x
+  dim.measureStart.y -= block.y
+  dim.measureEnd.x -= block.x
+  dim.measureEnd.y -= block.y
+}
+
+const BLOCK_BASEPOINT_ADJUSTERS: Record<string, BlockBasePointAdjuster> = {
+  LINE: adjustLineForBlockBasePoint,
+  LWPOLYLINE: adjustPolylineForBlockBasePoint,
+  POLYLINE: adjustPolylineForBlockBasePoint,
+  CIRCLE: adjustCircleForBlockBasePoint,
+  ELLIPSE: adjustEllipseForBlockBasePoint,
+  ARC: adjustArcForBlockBasePoint,
+  SPLINE: adjustSplineForBlockBasePoint,
+  TEXT: adjustTextForBlockBasePoint,
+  MTEXT: adjustMTextForBlockBasePoint,
+  DIMENSION: adjustDimensionForBlockBasePoint,
+}
+
+function applyBlockBasePointAdjustment(entity: Entity, block: Block): void {
+  // https://github.com/bjnortier/dxf/issues/52
+  // See Issue 52. If we don't modify the entity coordinates here it creates an
+  // issue with the transformation matrices (which are only applied AFTER block
+  // insertion modifications has been applied).
+  const adjust = BLOCK_BASEPOINT_ADJUSTERS[entity.type]
+  if (adjust) adjust(entity, block)
+}
+
+function computeRectangularArrayVectors(insert: InsertEntity): {
+  rowVec: { x: number; y: number }
+  colVec: { x: number; y: number }
+} {
+  const rowCount = insert.rowCount ?? 1
+  const columnCount = insert.columnCount ?? 1
+  const rowSpacing = insert.rowSpacing ?? 0
+  const columnSpacing = insert.columnSpacing ?? 0
+  const rotation = insert.rotation ?? 0
+
+  // It appears that the rectangular array is affected by rotation, but NOT by scale.
+  if (rowCount <= 1 && columnCount <= 1) {
+    return { rowVec: { x: 0, y: 0 }, colVec: { x: 0, y: 0 } }
+  }
+
+  const cos = Math.cos((rotation * Math.PI) / 180)
+  const sin = Math.sin((rotation * Math.PI) / 180)
+  return {
+    rowVec: { x: -sin * rowSpacing, y: cos * rowSpacing },
+    colVec: { x: cos * columnSpacing, y: sin * columnSpacing },
+  }
+}
+
+function expandInsert(
+  insert: InsertEntity,
+  blocksByName: Record<string, Block>,
+  transforms: Transform[],
+  gatherEntities: (entities: Entity[], transforms: Transform[]) => Entity[],
+): Entity[] {
+  const block = blocksByName[insert.block]
+  if (!block) {
+    logger.error('no block found for insert. block:', insert.block)
+    return []
+  }
+
+  const rowCount = insert.rowCount ?? 1
+  const columnCount = insert.columnCount ?? 1
+  const { rowVec, colVec } = computeRectangularArrayVectors(insert)
+
+  const current: Entity[] = []
+  for (let r = 0; r < rowCount; r++) {
+    for (let c = 0; c < columnCount; c++) {
+      const t: Transform = {
+        x: insert.x + rowVec.x * r + colVec.x * c,
+        y: insert.y + rowVec.y * r + colVec.y * c,
+        scaleX: insert.scaleX,
+        scaleY: insert.scaleY,
+        scaleZ: insert.scaleZ,
+        extrusionX: insert.extrusionX,
+        extrusionY: insert.extrusionY,
+        extrusionZ: insert.extrusionZ,
+        rotation: insert.rotation,
+      }
+
+      const transforms2 = transforms.slice(0)
+      transforms2.push(t)
+
+      // Use the insert layer
+      const blockEntities = block.entities.map((be: Entity) => {
+        const be2 = cloneDeep(be)
+        be2.layer = insert.layer
+        applyBlockBasePointAdjustment(be2, block)
+        return be2
+      })
+
+      current.push(...gatherEntities(blockEntities, transforms2))
+    }
+  }
+
+  return current
+}
+
 export default function denormalise(parseResult: ParsedDXF): Entity[] {
   const blocksByName = parseResult.blocks.reduce(
     (acc: { [name: string]: Block }, b: Block) => {
@@ -29,113 +196,12 @@ export default function denormalise(parseResult: ParsedDXF): Entity[] {
     entities: Entity[],
     transforms: Transform[],
   ): Entity[] => {
-    let current: Entity[] = []
+    const current: Entity[] = []
     for (const e of entities) {
       if (e.type === 'INSERT') {
-        const insert = e as InsertEntity
-        const block = blocksByName[insert.block]
-        if (!block) {
-          logger.error('no block found for insert. block:', insert.block)
-          continue
-        }
-
-        const rowCount = insert.rowCount ?? 1
-        const columnCount = insert.columnCount ?? 1
-        const rowSpacing = insert.rowSpacing ?? 0
-        const columnSpacing = insert.columnSpacing ?? 0
-        const rotation = insert.rotation ?? 0
-
-        // It appears that the rectangular array is affected by rotation, but NOT by scale.
-        let rowVec: { x: number; y: number }
-        let colVec: { x: number; y: number }
-        if (rowCount > 1 || columnCount > 1) {
-          const cos = Math.cos((rotation * Math.PI) / 180)
-          const sin = Math.sin((rotation * Math.PI) / 180)
-          rowVec = { x: -sin * rowSpacing, y: cos * rowSpacing }
-          colVec = { x: cos * columnSpacing, y: sin * columnSpacing }
-        } else {
-          rowVec = { x: 0, y: 0 }
-          colVec = { x: 0, y: 0 }
-        }
-
-        // For rectangular arrays, add the block entities for each location in the array
-        for (let r = 0; r < rowCount; r++) {
-          for (let c = 0; c < columnCount; c++) {
-            // Adjust insert transform by row and column for rectangular arrays
-            const t: Transform = {
-              x: insert.x + rowVec.x * r + colVec.x * c,
-              y: insert.y + rowVec.y * r + colVec.y * c,
-              scaleX: insert.scaleX,
-              scaleY: insert.scaleY,
-              scaleZ: insert.scaleZ,
-              extrusionX: insert.extrusionX,
-              extrusionY: insert.extrusionY,
-              extrusionZ: insert.extrusionZ,
-              rotation: insert.rotation,
-            }
-            // Add the insert transform and recursively add entities
-            const transforms2 = transforms.slice(0)
-            transforms2.push(t)
-
-            // Use the insert layer
-            const blockEntities = block.entities.map((be: Entity) => {
-              const be2 = cloneDeep(be)
-              be2.layer = insert.layer
-              // https://github.com/bjnortier/dxf/issues/52
-              // See Issue 52. If we don't modify the
-              // entity coordinates here it creates an issue with the
-              // transformation matrices (which are only applied AFTER
-              // block insertion modifications has been applied).
-              switch (be2.type) {
-                case 'LINE': {
-                  const line = be2 as LineEntity
-                  line.start.x -= block.x
-                  line.start.y -= block.y
-                  line.end.x -= block.x
-                  line.end.y -= block.y
-                  break
-                }
-                case 'LWPOLYLINE':
-                case 'POLYLINE': {
-                  const poly = be2 as PolylineEntity
-                  for (const v of poly.vertices) {
-                    if (v.x !== undefined) v.x -= block.x
-                    if (v.y !== undefined) v.y -= block.y
-                  }
-                  break
-                }
-                case 'CIRCLE': {
-                  const circle = be2 as CircleEntity
-                  circle.x -= block.x
-                  circle.y -= block.y
-                  break
-                }
-                case 'ELLIPSE': {
-                  const ellipse = be2 as EllipseEntity
-                  ellipse.x -= block.x
-                  ellipse.y -= block.y
-                  break
-                }
-                case 'ARC': {
-                  const arc = be2 as ArcEntity
-                  arc.x -= block.x
-                  arc.y -= block.y
-                  break
-                }
-                case 'SPLINE': {
-                  const spline = be2 as SplineEntity
-                  for (const cp of spline.controlPoints) {
-                    cp.x -= block.x
-                    cp.y -= block.y
-                  }
-                  break
-                }
-              }
-              return be2
-            })
-            current = current.concat(gatherEntities(blockEntities, transforms2))
-          }
-        }
+        current.push(
+          ...expandInsert(e as InsertEntity, blocksByName, transforms, gatherEntities),
+        )
       } else {
         // Top-level entity. Clone and add the transforms
         // The transforms are reversed so they occur in