@linkiez/dxf-renew 7.0.0 → 7.1.0

package/src/handlers/entities.ts

@@ -1,16 +1,21 @@
 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 pdfUnderlay from './entity/pdfUnderlay'
 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 mtext from './entity/mtext'
@@ -21,6 +26,7 @@ import solid from './entity/solid'
 import spline from './entity/spline'
 import text from './entity/text'
 import threeDFace from './entity/threeDFace'
+import tolerance from './entity/tolerance'
 import vertex from './entity/vertex'
 import viewport from './entity/viewport'
 
@@ -41,7 +47,13 @@ const handlers: Record<string, EntityHandler> = [
   spline,
   solid,
   hatch,
+  image,
+  leader,
+  dwfUnderlay,
+  dgnUnderlay,
+  pdfUnderlay,
   mtext,
+  tolerance,
   attdef,
   attrib,
   text,
@@ -61,8 +73,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 +182,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 }

package/src/handlers/entity/image.ts

@@ -0,0 +1,118 @@
+import type { DXFTuple, PartialPoint3D } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'IMAGE'
+
+interface ImageEntity {
+  type: typeof TYPE
+
+  insertionPoint: PartialPoint3D
+  uVector: PartialPoint3D
+  vVector: PartialPoint3D
+
+  pixelSizeX: number
+  pixelSizeY: number
+
+  imageDefHandle?: string
+  imageDefReactorHandle?: string
+
+  displayProperties?: number
+  clippingState?: number
+  brightness?: number
+  contrast?: number
+  fade?: number
+  classVersion?: number
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): ImageEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 90:
+          entity.classVersion = value as number
+          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 11:
+          entity.uVector.x = value as number
+          break
+        case 21:
+          entity.uVector.y = value as number
+          break
+        case 31:
+          entity.uVector.z = value as number
+          break
+
+        case 12:
+          entity.vVector.x = value as number
+          break
+        case 22:
+          entity.vVector.y = value as number
+          break
+        case 32:
+          entity.vVector.z = value as number
+          break
+
+        case 13:
+          entity.pixelSizeX = value as number
+          break
+        case 23:
+          entity.pixelSizeY = value as number
+          break
+
+        case 340:
+          entity.imageDefHandle = String(value)
+          break
+        case 360:
+          entity.imageDefReactorHandle = String(value)
+          break
+
+        case 70:
+          entity.displayProperties = value as number
+          break
+        case 280:
+          entity.clippingState = value as number
+          break
+        case 281:
+          entity.brightness = value as number
+          break
+        case 282:
+          entity.contrast = value as number
+          break
+        case 283:
+          entity.fade = value as number
+          break
+
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: {},
+      uVector: {},
+      vVector: {},
+      pixelSizeX: 0,
+      pixelSizeY: 0,
+    } as ImageEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/leader.ts

@@ -0,0 +1,153 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'LEADER'
+
+interface LeaderEntity {
+  type: typeof TYPE
+  vertices: Array<{ x: number; y: number; z: number }>
+
+  dimensionStyleName?: string
+  arrowheadFlag?: number
+  pathType?: number
+  creationFlag?: number
+  hooklineDirectionFlag?: number
+  hooklineFlag?: number
+  textHeight?: number
+  textWidth?: number
+  color?: number
+  annotationHandle?: string
+
+  normal?: { x: number; y: number; z: number }
+  horizontalDirection?: { x: number; y: number; z: number }
+  blockOffset?: { x: number; y: number; z: number }
+  annotationOffset?: { x: number; y: number; z: number }
+
+  [key: string]: unknown
+}
+
+function ensureVector3(
+  entity: LeaderEntity,
+  key: 'normal' | 'horizontalDirection' | 'blockOffset' | 'annotationOffset',
+): { x: number; y: number; z: number } {
+  if (!entity[key]) entity[key] = { x: 0, y: 0, z: 0 }
+  return entity[key] as { x: number; y: number; z: number }
+}
+
+export const process = (tuples: DXFTuple[]): LeaderEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 3:
+          entity.dimensionStyleName = String(value)
+          break
+
+        case 71:
+          entity.arrowheadFlag = value as number
+          break
+        case 72:
+          entity.pathType = value as number
+          break
+        case 73:
+          entity.creationFlag = value as number
+          break
+        case 74:
+          entity.hooklineDirectionFlag = value as number
+          break
+        case 75:
+          entity.hooklineFlag = value as number
+          break
+
+        case 40:
+          entity.textHeight = value as number
+          break
+        case 41:
+          entity.textWidth = value as number
+          break
+
+        case 76:
+          // Number of vertices in leader. Keep as metadata only.
+          entity.vertexCount = value as number
+          break
+
+        case 10:
+          entity.vertices.push({ x: value as number, y: 0, z: 0 })
+          break
+        case 20: {
+          const current = entity.vertices[entity.vertices.length - 1]
+          if (current) current.y = value as number
+          break
+        }
+        case 30: {
+          const current = entity.vertices[entity.vertices.length - 1]
+          if (current) current.z = value as number
+          break
+        }
+
+        case 77:
+          entity.color = value as number
+          break
+
+        case 340:
+          entity.annotationHandle = String(value)
+          break
+
+        case 210:
+          ensureVector3(entity, 'normal').x = value as number
+          break
+        case 220:
+          ensureVector3(entity, 'normal').y = value as number
+          break
+        case 230:
+          ensureVector3(entity, 'normal').z = value as number
+          break
+
+        case 211:
+          ensureVector3(entity, 'horizontalDirection').x = value as number
+          break
+        case 221:
+          ensureVector3(entity, 'horizontalDirection').y = value as number
+          break
+        case 231:
+          ensureVector3(entity, 'horizontalDirection').z = value as number
+          break
+
+        case 212:
+          ensureVector3(entity, 'blockOffset').x = value as number
+          break
+        case 222:
+          ensureVector3(entity, 'blockOffset').y = value as number
+          break
+        case 232:
+          ensureVector3(entity, 'blockOffset').z = value as number
+          break
+
+        case 213:
+          ensureVector3(entity, 'annotationOffset').x = value as number
+          break
+        case 223:
+          ensureVector3(entity, 'annotationOffset').y = value as number
+          break
+        case 233:
+          ensureVector3(entity, 'annotationOffset').z = value as number
+          break
+
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+      vertices: [],
+    } as LeaderEntity,
+  )
+}
+
+export default { TYPE, process }