@linkiez/dxf-renew 7.0.0 → 7.2.0

package/src/entityToPolyline.ts

@@ -9,8 +9,13 @@ import type {
   EllipseEntity,
   EntityToPolylineOptions,
   HandlerVertex,
+  LeaderEntity,
   LineEntity,
+  RayEntity,
+  ShapeEntity,
   SplineEntity,
+  WipeoutEntity,
+  XLineEntity,
 } from './types'
 import type { PointTuple } from './types/common'
 
@@ -35,7 +40,17 @@ interface LocalPolylineEntity {
 
 type Entity =
   | LineEntity
+  | LeaderEntity
+  | RayEntity
+  | XLineEntity
+  | ShapeEntity
+  | WipeoutEntity
   | (LocalPolylineEntity & { type: 'LWPOLYLINE' | 'POLYLINE' })
+  | {
+      type: 'SOLID' | 'TRACE'
+      corners?: Array<{ x: number; y: number }>
+      points?: Array<{ x: number; y: number }>
+    }
   | CircleEntity
   | EllipseEntity
   | ArcEntity
@@ -151,7 +166,7 @@ export const interpolateBSpline = (
   return polyline
 }
 
-export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => {
+export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => { // NOSONAR
   const vertices: Array<{ x: number; y: number }> = []
   const faces: Array<{ indices: number[]; hiddens: boolean[] }> = []
 
@@ -219,13 +234,21 @@ export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => {
  * the DXF in SVG, Canvas, WebGL etc., without depending on native support
  * of primitive objects (ellispe, spline etc.)
  */
-export default function entityToPolyline(
+export default function entityToPolyline( // NOSONAR
   entity: Entity,
   options?: EntityToPolylineOptions,
 ): Point[] {
   options = options || {}
   let polyline: Point[] | undefined
 
+  const INFINITE_LINE_LENGTH = 1000
+
+  const normalize2 = (x: number, y: number): { x: number; y: number } | null => {
+    const len = Math.hypot(x, y)
+    if (len === 0) return null
+    return { x: x / len, y: y / len }
+  }
+
   if (entity.type === 'LINE') {
     polyline = [
       [entity.start.x, entity.start.y],
@@ -233,6 +256,92 @@ export default function entityToPolyline(
     ]
   }
 
+  if (entity.type === 'LEADER') {
+    if (entity.vertices.length >= 2) {
+      polyline = entity.vertices.map((v) => [v.x, v.y])
+    } else {
+      logger.warn('LEADER entity with insufficient vertices')
+      polyline = []
+    }
+  }
+
+  if (entity.type === 'RAY') {
+    const dir = normalize2(entity.direction.x, entity.direction.y)
+    if (dir === null) {
+      logger.warn('RAY entity with zero direction vector')
+      polyline = []
+    } else {
+      polyline = [
+        [entity.start.x, entity.start.y],
+        [
+          entity.start.x + dir.x * INFINITE_LINE_LENGTH,
+          entity.start.y + dir.y * INFINITE_LINE_LENGTH,
+        ],
+      ]
+    }
+  }
+
+  if (entity.type === 'XLINE') {
+    const dir = normalize2(entity.direction.x, entity.direction.y)
+    if (dir === null) {
+      logger.warn('XLINE entity with zero direction vector')
+      polyline = []
+    } else {
+      polyline = [
+        [
+          entity.basePoint.x - dir.x * INFINITE_LINE_LENGTH,
+          entity.basePoint.y - dir.y * INFINITE_LINE_LENGTH,
+        ],
+        [
+          entity.basePoint.x + dir.x * INFINITE_LINE_LENGTH,
+          entity.basePoint.y + dir.y * INFINITE_LINE_LENGTH,
+        ],
+      ]
+    }
+  }
+
+  if (entity.type === 'SHAPE') {
+    const x = entity.insertionPoint?.x ?? 0
+    const y = entity.insertionPoint?.y ?? 0
+    const size = entity.size ?? 0
+    const scaleX = entity.relativeXScale ?? 1
+    const length = size * scaleX
+    polyline = [
+      [x, y],
+      [x + length, y],
+    ]
+  }
+
+  if (entity.type === 'WIPEOUT') {
+    const verts = entity.clipBoundaryVertices
+    if (!verts || verts.length < 2) {
+      logger.warn('WIPEOUT entity with missing clip boundary vertices')
+      polyline = []
+    } else {
+      const insX = entity.insertionPoint?.x ?? 0
+      const insY = entity.insertionPoint?.y ?? 0
+
+      const ux = entity.uVector?.x ?? 1
+      const uy = entity.uVector?.y ?? 0
+
+      const vx = entity.vVector?.x ?? 0
+      const vy = entity.vVector?.y ?? 1
+
+      polyline = verts.map((p) => [
+        insX + ux * p.x + vx * p.y,
+        insY + uy * p.x + vy * p.y,
+      ])
+
+      if (polyline.length > 0) {
+        const first = polyline[0]
+        const last = polyline[polyline.length - 1]
+        if (first[0] !== last[0] || first[1] !== last[1]) {
+          polyline.push(first)
+        }
+      }
+    }
+  }
+
   if (entity.type === 'LWPOLYLINE' || entity.type === 'POLYLINE') {
     polyline = []
     if (entity.polyfaceMesh) {
@@ -330,6 +439,19 @@ export default function entityToPolyline(
     )
   }
 
+  if (entity.type === 'SOLID' || entity.type === 'TRACE') {
+    const corners = entity.corners ?? entity.points
+    if (corners && corners.length >= 4) {
+      polyline = [
+        [corners[0].x, corners[0].y],
+        [corners[1].x, corners[1].y],
+        [corners[2].x, corners[2].y],
+        [corners[3].x, corners[3].y],
+        [corners[0].x, corners[0].y],
+      ]
+    }
+  }
+
   if (!polyline) {
     logger.warn('unsupported entity for converting to polyline:', entity.type)
     return []

package/src/handlers/entities.ts

@@ -1,28 +1,44 @@
 import type { DXFTuple } from '../types/dxf'
 import type { Entity } from '../types/entity'
-import type { PolylineEntity } from '../types/polyline-entity'
+import type { PolylineEntity, Vertex } from '../types/polyline-entity'
 
 import logger from '../util/logger'
 import arc from './entity/arc'
 import attdef from './entity/attdef'
 import attrib from './entity/attrib'
 import circle from './entity/circle'
+import dgnUnderlay from './entity/dgnUnderlay'
 import dimension from './entity/dimension'
+import dwfUnderlay from './entity/dwfUnderlay'
 import ellipse from './entity/ellipse'
 import hatch from './entity/hatch'
+import image from './entity/image'
 import insert from './entity/insert'
+import leader from './entity/leader'
 import line from './entity/line'
 import lwpolyline from './entity/lwpolyline'
+import mleader from './entity/mleader'
+import mline from './entity/mline'
 import mtext from './entity/mtext'
 import ole2Frame from './entity/ole2Frame'
+import oleFrame from './entity/oleframe'
+import pdfUnderlay from './entity/pdfUnderlay'
 import point from './entity/point'
 import polyline from './entity/polyline'
+import ray from './entity/ray'
+import region from './entity/region'
+import shape from './entity/shape'
 import solid from './entity/solid'
 import spline from './entity/spline'
+import table from './entity/table'
 import text from './entity/text'
 import threeDFace from './entity/threeDFace'
+import tolerance from './entity/tolerance'
+import trace from './entity/trace'
 import vertex from './entity/vertex'
 import viewport from './entity/viewport'
+import wipeout from './entity/wipeout'
+import xline from './entity/xline'
 
 interface EntityHandler {
   TYPE: string
@@ -33,15 +49,28 @@ const handlers: Record<string, EntityHandler> = [
   point,
   line,
   lwpolyline,
+  mline,
+  mleader,
   polyline,
   vertex,
   circle,
   arc,
   ellipse,
   spline,
+  table,
   solid,
+  trace,
   hatch,
+  image,
+  leader,
+  ray,
+  region,
+  dwfUnderlay,
+  dgnUnderlay,
+  pdfUnderlay,
+  shape,
   mtext,
+  tolerance,
   attdef,
   attrib,
   text,
@@ -50,6 +79,9 @@ const handlers: Record<string, EntityHandler> = [
   threeDFace,
   viewport,
   ole2Frame,
+  oleFrame,
+  xline,
+  wipeout,
 ].reduce((acc, mod) => {
   acc[mod.TYPE] = mod
   return acc
@@ -61,8 +93,102 @@ const handlers: Record<string, EntityHandler> = [
  * @param tuples - Array of DXF tuples representing entities
  * @returns Array of parsed entities
  */
+class EntityGroupProcessor {
+  private readonly entities: Entity[] = []
+  private currentPolyline: PolylineEntity | undefined
+
+  getEntities(): Entity[] {
+    return this.entities
+  }
+
+  finalize(): void {
+    this.flushOpenPolyline('DXF ended with an open POLYLINE (missing SEQEND); flushing open polyline')
+  }
+
+  processGroup(tuples: DXFTuple[]): void {
+    const entityType = String(tuples[0][1])
+    const contentTuples = tuples.slice(1)
+
+    switch (entityType) {
+      case 'SEQEND':
+        this.endSequence()
+        break
+      case 'POLYLINE':
+        this.startPolyline(contentTuples)
+        break
+      case 'VERTEX':
+        this.addVertex(contentTuples)
+        break
+      default:
+        this.addEntity(entityType, contentTuples)
+        break
+    }
+  }
+
+  private parseEntity(entityType: string, contentTuples: DXFTuple[]): Entity | undefined {
+    const handler = handlers[entityType]
+    if (!handler) {
+      logger.warn('unsupported type in ENTITIES section:', entityType)
+      return undefined
+    }
+    return handler.process(contentTuples)
+  }
+
+  private flushOpenPolyline(reason: string): void {
+    if (!this.currentPolyline) return
+    logger.warn(reason)
+    this.currentPolyline = undefined
+  }
+
+  private endSequence(): void {
+    // SEQEND may also terminate other sequences (e.g. INSERT attributes).
+    // Only treat it as significant when we're inside a POLYLINE sequence.
+    this.currentPolyline = undefined
+  }
+
+  private startPolyline(contentTuples: DXFTuple[]): void {
+    this.flushOpenPolyline(
+      'POLYLINE started while previous POLYLINE is still open; flushing previous polyline',
+    )
+
+    const e = this.parseEntity('POLYLINE', contentTuples)
+    if (!e) return
+
+    this.currentPolyline = e as PolylineEntity
+    this.entities.push(e)
+  }
+
+  private addVertex(contentTuples: DXFTuple[]): void {
+    const e = this.parseEntity('VERTEX', contentTuples)
+    if (!e) return
+
+    if (!this.currentPolyline) {
+      logger.error('ignoring invalid VERTEX entity')
+      return
+    }
+
+    this.currentPolyline.vertices.push(e as Vertex)
+  }
+
+  private addEntity(entityType: string, contentTuples: DXFTuple[]): void {
+    this.flushOpenPolyline('POLYLINE sequence ended without SEQEND; flushing open polyline')
+
+    const e = this.parseEntity(entityType, contentTuples)
+    if (!e) return
+    this.entities.push(e)
+  }
+}
+
+function processEntityGroups(entityGroups: DXFTuple[][]): Entity[] {
+  const processor = new EntityGroupProcessor()
+  for (const tuples of entityGroups) {
+    processor.processGroup(tuples)
+  }
+  processor.finalize()
+  return processor.getEntities()
+}
+
 export default function parseEntities(tuples: DXFTuple[]): Entity[] {
-  const entities: Entity[] = []
   const entityGroups: DXFTuple[][] = []
   let currentEntityTuples: DXFTuple[] = []
 
@@ -76,36 +202,5 @@ export default function parseEntities(tuples: DXFTuple[]): Entity[] {
     currentEntityTuples.push(tuple)
   }
 
-  let currentPolyline: PolylineEntity | undefined
-  for (const tuples of entityGroups) {
-    const entityType = tuples[0][1]
-    const contentTuples = tuples.slice(1)
-
-    if (entityType in handlers) {
-      const e = handlers[entityType].process(contentTuples)
-      // "POLYLINE" cannot be parsed in isolation, it is followed by
-      // N "VERTEX" entities and ended with a "SEQEND" entity.
-      // Essentially we convert POLYLINE to LWPOLYLINE - the extra
-      // vertex flags are not supported
-      if (entityType === 'POLYLINE') {
-        currentPolyline = e as PolylineEntity
-        entities.push(e)
-      } else if (entityType === 'VERTEX') {
-        if (currentPolyline) {
-          currentPolyline.vertices.push(e as any)
-        } else {
-          logger.error('ignoring invalid VERTEX entity')
-        }
-      } else if (entityType === 'SEQEND') {
-        currentPolyline = undefined
-      } else {
-        // All other entities
-        entities.push(e)
-      }
-    } else {
-      logger.warn('unsupported type in ENTITIES section:', entityType)
-    }
-  }
-
-  return entities
+  return processEntityGroups(entityGroups)
 }

package/src/handlers/entity/dgnUnderlay.ts

@@ -0,0 +1,94 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'DGNUNDERLAY'
+
+interface UnderlayEntity {
+  type: typeof TYPE
+
+  insertionPoint: { x: number; y: number; z: number }
+  scale: { x: number; y: number; z: number }
+  normal: { x: number; y: number; z: number }
+
+  underlayDefinitionHandle?: string
+  rotation?: number
+  flags?: number
+  contrast?: number
+  fade?: number
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): UnderlayEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 340:
+          entity.underlayDefinitionHandle = String(value)
+          break
+
+        case 10:
+          entity.insertionPoint.x = value as number
+          break
+        case 20:
+          entity.insertionPoint.y = value as number
+          break
+        case 30:
+          entity.insertionPoint.z = value as number
+          break
+
+        case 41:
+          entity.scale.x = value as number
+          break
+        case 42:
+          entity.scale.y = value as number
+          break
+        case 43:
+          entity.scale.z = value as number
+          break
+
+        case 50:
+          entity.rotation = value as number
+          break
+
+        case 210:
+          entity.normal.x = value as number
+          break
+        case 220:
+          entity.normal.y = value as number
+          break
+        case 230:
+          entity.normal.z = value as number
+          break
+
+        case 280:
+          entity.flags = value as number
+          break
+        case 281:
+          entity.contrast = value as number
+          break
+        case 282:
+          entity.fade = value as number
+          break
+
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 },
+      normal: { x: 0, y: 0, z: 1 },
+    } as UnderlayEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/dimension.ts

@@ -15,6 +15,8 @@ interface DimensionEntity {
   type: typeof TYPE
   block?: string
   start: Point3D
+  angleVertex?: Point3D
+  arcPoint?: Point3D
   textMidpoint: Point3D
   measureStart: Point3D
   measureEnd: Point3D
@@ -89,6 +91,30 @@ export const process = (tuples: DXFTuple[]): DimensionEntity => {
         case 34:
           entity.measureEnd.z = value as number
           break
+        case 15:
+          entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 }
+          entity.angleVertex.x = value as number
+          break
+        case 25:
+          entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 }
+          entity.angleVertex.y = value as number
+          break
+        case 35:
+          entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 }
+          entity.angleVertex.z = value as number
+          break
+        case 16:
+          entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 }
+          entity.arcPoint.x = value as number
+          break
+        case 26:
+          entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 }
+          entity.arcPoint.y = value as number
+          break
+        case 36:
+          entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 }
+          entity.arcPoint.z = value as number
+          break
         case 50:
           entity.rotation = value as number
           break
@@ -177,7 +203,7 @@ function parseBitCombinationsFromValue(value: number): BitCombinationsResult {
   let ordinateType = false
   let userDefinedLocation = false
 
-  // ToDo: Solve in some more clever way??
+  // Note: keep this logic explicit; DXF stores flags as bit combinations.
   if (value > 6) {
     const alt1 = value - 32
     const alt2 = value - 64

package/src/handlers/entity/dwfUnderlay.ts

@@ -0,0 +1,94 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'DWFUNDERLAY'
+
+interface UnderlayEntity {
+  type: typeof TYPE
+
+  insertionPoint: { x: number; y: number; z: number }
+  scale: { x: number; y: number; z: number }
+  normal: { x: number; y: number; z: number }
+
+  underlayDefinitionHandle?: string
+  rotation?: number
+  flags?: number
+  contrast?: number
+  fade?: number
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): UnderlayEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 340:
+          entity.underlayDefinitionHandle = String(value)
+          break
+
+        case 10:
+          entity.insertionPoint.x = value as number
+          break
+        case 20:
+          entity.insertionPoint.y = value as number
+          break
+        case 30:
+          entity.insertionPoint.z = value as number
+          break
+
+        case 41:
+          entity.scale.x = value as number
+          break
+        case 42:
+          entity.scale.y = value as number
+          break
+        case 43:
+          entity.scale.z = value as number
+          break
+
+        case 50:
+          entity.rotation = value as number
+          break
+
+        case 210:
+          entity.normal.x = value as number
+          break
+        case 220:
+          entity.normal.y = value as number
+          break
+        case 230:
+          entity.normal.z = value as number
+          break
+
+        case 280:
+          entity.flags = value as number
+          break
+        case 281:
+          entity.contrast = value as number
+          break
+        case 282:
+          entity.fade = value as number
+          break
+
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 },
+      normal: { x: 0, y: 0, z: 1 },
+    } as UnderlayEntity,
+  )
+}
+
+export default { TYPE, process }