@linkiez/dxf-renew 5.3.1

package/src/entityToPolyline.ts

@@ -0,0 +1,338 @@
+import bSpline from './util/bSpline'
+import createArcForLWPolyine from './util/createArcForLWPolyline'
+import logger from './util/logger'
+
+import type {
+  ArcEntity,
+  CircleEntity,
+  ControlPoint,
+  EllipseEntity,
+  EntityToPolylineOptions,
+  HandlerVertex,
+  LineEntity,
+  SplineEntity,
+} from './types'
+import type { PointTuple } from './types/common'
+
+// Re-export types for backward compatibility
+export type { ControlPoint, EntityToPolylineOptions } from './types'
+
+type Point = PointTuple
+
+// Local vertex type with required coordinates for runtime processing
+interface LocalVertex extends HandlerVertex {
+  faces?: number[]
+}
+
+// Local polyline type that uses our vertex with required coordinates
+interface LocalPolylineEntity {
+  type: string
+  vertices: LocalVertex[]
+  closed?: boolean
+  polyfaceMesh?: boolean
+  polygonMesh?: boolean
+}
+
+type Entity =
+  | LineEntity
+  | (LocalPolylineEntity & { type: 'LWPOLYLINE' | 'POLYLINE' })
+  | CircleEntity
+  | EllipseEntity
+  | ArcEntity
+  | SplineEntity
+
+/**
+ * Rotate a set of points.
+ *
+ * @param points the points
+ * @param angle the rotation angle
+ */
+const rotate = (points: Point[], angle: number): Point[] => {
+  return points.map(function (p) {
+    return [
+      p[0] * Math.cos(angle) - p[1] * Math.sin(angle),
+      p[1] * Math.cos(angle) + p[0] * Math.sin(angle),
+    ]
+  })
+}
+
+/**
+ * Interpolate an ellipse
+ * @param cx center X
+ * @param cy center Y
+ * @param rx radius X
+ * @param ry radius Y
+ * @param start start angle in radians
+ * @param start end angle in radians
+ */
+const interpolateEllipse = (
+  cx: number,
+  cy: number,
+  rx: number,
+  ry: number,
+  start: number,
+  end: number,
+  rotationAngle?: number
+): Point[] => {
+  if (end < start) {
+    end += Math.PI * 2
+  }
+
+  // ----- Relative points -----
+
+  // Start point
+  let points: Point[] = []
+  const dTheta = (Math.PI * 2) / 72
+  const EPS = 1e-6
+  for (let theta = start; theta < end - EPS; theta += dTheta) {
+    points.push([Math.cos(theta) * rx, Math.sin(theta) * ry])
+  }
+  points.push([Math.cos(end) * rx, Math.sin(end) * ry])
+
+  // ----- Rotate -----
+  if (rotationAngle) {
+    points = rotate(points, rotationAngle)
+  }
+
+  // ----- Offset center -----
+  points = points.map(function (p): Point {
+    return [cx + p[0], cy + p[1]]
+  })
+
+  return points
+}
+
+/**
+ * Interpolate a b-spline. The algorithm examins the knot vector
+ * to create segments for interpolation. The parameterisation value
+ * is re-normalised back to [0,1] as that is what the lib expects (
+ * and t i de-normalised in the b-spline library)
+ *
+ * @param controlPoints the control points
+ * @param degree the b-spline degree
+ * @param knots the knot vector
+ * @returns the polyline
+ */
+export const interpolateBSpline = (
+  controlPoints: ControlPoint[],
+  degree: number,
+  knots: number[],
+  interpolationsPerSplineSegment?: number,
+  weights?: number[]
+): Point[] => {
+  const polyline: Point[] = []
+  const controlPointsForLib = controlPoints.map(function (p): Point {
+    return [p.x, p.y]
+  })
+
+  const segmentTs = [knots[degree]]
+  const domain: Point = [knots[degree], knots[knots.length - 1 - degree]]
+
+  for (let k = degree + 1; k < knots.length - degree; ++k) {
+    if (segmentTs[segmentTs.length - 1] !== knots[k]) {
+      segmentTs.push(knots[k])
+    }
+  }
+
+  interpolationsPerSplineSegment = interpolationsPerSplineSegment || 25
+  for (let i = 1; i < segmentTs.length; ++i) {
+    const uMin = segmentTs[i - 1]
+    const uMax = segmentTs[i]
+    for (let k = 0; k <= interpolationsPerSplineSegment; ++k) {
+      const u = (k / interpolationsPerSplineSegment) * (uMax - uMin) + uMin
+      // Clamp t to 0, 1 to handle numerical precision issues
+      let t = (u - domain[0]) / (domain[1] - domain[0])
+      t = Math.max(t, 0)
+      t = Math.min(t, 1)
+      const p = bSpline(t, degree, controlPointsForLib, knots, weights)
+      polyline.push([p[0], p[1]])
+    }
+  }
+  return polyline
+}
+
+export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => {
+  const vertices: Array<{ x: number; y: number }> = []
+  const faces: Array<{ indices: number[]; hiddens: boolean[] }> = []
+
+  for (const v of entity.vertices) {
+    if (v.faces) {
+      const face: { indices: number[]; hiddens: boolean[] } = {
+        indices: [],
+        hiddens: [],
+      }
+      for (const i of v.faces) {
+        if (i === 0) {
+          break
+        }
+        // Negative indices signify hidden edges
+        face.indices.push(i < 0 ? -i - 1 : i - 1)
+        face.hiddens.push(i < 0)
+      }
+      if ([3, 4].includes(face.indices.length)) faces.push(face)
+    } else {
+      vertices.push({ x: v.x, y: v.y })
+    }
+  }
+
+  // If a segment starts at the end of a previous line, continue it
+  const polylines: number[][] = []
+  const segment = (a: number, b: number): void => {
+    for (const prev of polylines) {
+      if (prev.slice(-1)[0] === a) {
+        prev.push(b)
+        return
+      }
+    }
+    polylines.push([a, b])
+  }
+
+  for (const face of faces) {
+    for (let beg = 0; beg < face.indices.length; beg++) {
+      if (face.hiddens[beg]) {
+        continue
+      }
+      const end = (beg + 1) % face.indices.length
+      segment(face.indices[beg], face.indices[end])
+    }
+  }
+
+  // Sometimes segments are not sequential, in that case
+  // we need to find if they can mend gaps between others
+  for (const a of polylines) {
+    for (const b of polylines) {
+      if (a !== b && a[0] === b.slice(-1)[0]) {
+        b.push(...a.slice(1))
+        a.splice(0, a.length)
+        break
+      }
+    }
+  }
+
+  return polylines
+    .filter((l) => l.length)
+    .map((l) => l.map((i) => vertices[i]).map((v) => [v.x, v.y]))
+}
+
+/**
+ * Convert a parsed DXF entity to a polyline. These can be used to render the
+ * the DXF in SVG, Canvas, WebGL etc., without depending on native support
+ * of primitive objects (ellispe, spline etc.)
+ */
+export default function entityToPolyline(
+  entity: Entity,
+  options?: EntityToPolylineOptions,
+): Point[] {
+  options = options || {}
+  let polyline: Point[] | undefined
+
+  if (entity.type === 'LINE') {
+    polyline = [
+      [entity.start.x, entity.start.y],
+      [entity.end.x, entity.end.y],
+    ]
+  }
+
+  if (entity.type === 'LWPOLYLINE' || entity.type === 'POLYLINE') {
+    polyline = []
+    if (entity.polyfaceMesh) {
+      // Only return the first polyline because we can't return many
+      polyline.push(...polyfaceOutline(entity)[0])
+    } else if (entity.polygonMesh) {
+      // Do not attempt to render polygon meshes
+    } else if (entity.vertices.length) {
+      if (entity.closed) {
+        entity.vertices = entity.vertices.concat(entity.vertices[0])
+      }
+      for (let i = 0, il = entity.vertices.length; i < il - 1; ++i) {
+        const from: Point = [entity.vertices[i].x, entity.vertices[i].y]
+        const to: Point = [entity.vertices[i + 1].x, entity.vertices[i + 1].y]
+        polyline.push(from)
+        if (entity.vertices[i].bulge) {
+          polyline = polyline.concat(
+            createArcForLWPolyine(from, to, entity.vertices[i].bulge!),
+          )
+        }
+        // The last iteration of the for loop
+        if (i === il - 2) {
+          polyline.push(to)
+        }
+      }
+    } else {
+      logger.warn('Polyline entity with no vertices')
+    }
+  }
+
+  if (entity.type === 'CIRCLE') {
+    polyline = interpolateEllipse(
+      entity.x,
+      entity.y,
+      entity.r,
+      entity.r,
+      0,
+      Math.PI * 2,
+    )
+    if (entity.extrusionZ === -1) {
+      polyline = polyline.map(function (p): Point {
+        return [-p[0], p[1]]
+      })
+    }
+  }
+
+  if (entity.type === 'ELLIPSE') {
+    const rx = Math.hypot(entity.majorX, entity.majorY)
+    const ry = entity.axisRatio * rx
+    const majorAxisRotation = -Math.atan2(-entity.majorY, entity.majorX)
+    polyline = interpolateEllipse(
+      entity.x,
+      entity.y,
+      rx,
+      ry,
+      entity.startAngle,
+      entity.endAngle,
+      majorAxisRotation,
+    )
+    if (entity.extrusionZ === -1) {
+      polyline = polyline.map(function (p): Point {
+        return [-p[0], p[1]]
+      })
+    }
+  }
+
+  if (entity.type === 'ARC') {
+    // Why on earth DXF has degree start & end angles for arc,
+    // and radian start & end angles for ellipses is a mystery
+    polyline = interpolateEllipse(
+      entity.x,
+      entity.y,
+      entity.r,
+      entity.r,
+      entity.startAngle,
+      entity.endAngle,
+    )
+
+    // I kid you not, ARCs and ELLIPSEs handle this differently,
+    // as evidenced by how AutoCAD actually renders these entities
+    if (entity.extrusionZ === -1) {
+      polyline = polyline.map(function (p): Point {
+        return [-p[0], p[1]]
+      })
+    }
+  }
+
+  if (entity.type === 'SPLINE') {
+    polyline = interpolateBSpline(
+      entity.controlPoints,
+      entity.degree,
+      entity.knots,
+      options.interpolationsPerSplineSegment,
+      entity.weights,
+    )
+  }
+
+  if (!polyline) {
+    logger.warn('unsupported entity for converting to polyline:', entity.type)
+    return []
+  }
+  return polyline
+}

package/src/getRGBForEntity.ts

@@ -0,0 +1,28 @@
+import colors from './util/colors'
+import logger from './util/logger'
+
+import type { ColorRGB, Entity, LayerTable } from './types'
+
+export default function getRGBForEntity(
+  layers: { [layerName: string]: LayerTable },
+  entity: Entity,
+): ColorRGB {
+  const layerTable = layers[entity.layer ?? '0']
+  if (layerTable) {
+    const colorDefinedInEntity =
+      'colorNumber' in entity && entity.colorNumber !== 256
+    const colorNumber = colorDefinedInEntity
+      ? entity.colorNumber
+      : layerTable.colorNumber
+    const rgb = colors[colorNumber ?? 0]
+    if (rgb) {
+      return rgb
+    } else {
+      logger.warn('Color index', colorNumber, 'invalid, defaulting to black')
+      return [0, 0, 0]
+    }
+  } else {
+    logger.warn('no layer table for layer:' + entity.layer)
+    return [0, 0, 0]
+  }
+}

package/src/groupEntitiesByLayer.ts

@@ -0,0 +1,14 @@
+import type { Entity, LayerGroups } from './types'
+
+export default function groupEntitiesByLayer(
+  entities: Entity[],
+): LayerGroups {
+  return entities.reduce((acc: LayerGroups, entity) => {
+    const layer = entity.layer ?? '0'
+    if (!acc[layer]) {
+      acc[layer] = []
+    }
+    acc[layer].push(entity)
+    return acc
+  }, {})
+}

package/src/handlers/blocks.ts

@@ -0,0 +1,65 @@
+import type { BlockInternal, DXFTuple } from '../types'
+
+import entitiesHandler from './entities'
+
+export default function parseBlocks(tuples: DXFTuple[]): any[] {
+  let state: 'block' | 'entities' | undefined
+  const blocks: BlockInternal[] = []
+  let block: BlockInternal | undefined
+  let entitiesTuples: DXFTuple[] | undefined = []
+
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    const value = tuple[1]
+
+    if (value === 'BLOCK') {
+      state = 'block'
+      block = {}
+      entitiesTuples = []
+      blocks.push(block)
+    } else if (value === 'ENDBLK') {
+      if (block) {
+        if (state === 'entities' && entitiesTuples) {
+          block.entities = entitiesHandler(entitiesTuples)
+        } else {
+          block.entities = []
+        }
+      }
+      entitiesTuples = undefined
+      state = undefined
+    } else if (state === 'block' && type !== 0 && block) {
+      switch (type) {
+        case 1:
+          block.xref = value
+          break
+        case 2:
+          block.name = value
+          break
+        case 10:
+          block.x = value
+          break
+        case 20:
+          block.y = value
+          break
+        case 30:
+          block.z = value
+          break
+        case 67:
+          if (value !== 0) block.paperSpace = value
+          break
+        case 410:
+          block.layout = value
+          break
+        default:
+          break
+      }
+    } else if (state === 'block' && type === 0) {
+      state = 'entities'
+      if (entitiesTuples) entitiesTuples.push(tuple)
+    } else if (state === 'entities') {
+      if (entitiesTuples) entitiesTuples.push(tuple)
+    }
+  }
+
+  return blocks
+}

package/src/handlers/entities.ts

@@ -0,0 +1,111 @@
+import type { DXFTuple } from '../types/dxf'
+import type { Entity } from '../types/entity'
+import type { PolylineEntity } 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 dimension from './entity/dimension'
+import ellipse from './entity/ellipse'
+import hatch from './entity/hatch'
+import insert from './entity/insert'
+import line from './entity/line'
+import lwpolyline from './entity/lwpolyline'
+import mtext from './entity/mtext'
+import ole2Frame from './entity/ole2Frame'
+import point from './entity/point'
+import polyline from './entity/polyline'
+import solid from './entity/solid'
+import spline from './entity/spline'
+import text from './entity/text'
+import threeDFace from './entity/threeDFace'
+import vertex from './entity/vertex'
+import viewport from './entity/viewport'
+
+interface EntityHandler {
+  TYPE: string
+  process: (tuples: DXFTuple[]) => Entity
+}
+
+const handlers: Record<string, EntityHandler> = [
+  point,
+  line,
+  lwpolyline,
+  polyline,
+  vertex,
+  circle,
+  arc,
+  ellipse,
+  spline,
+  solid,
+  hatch,
+  mtext,
+  attdef,
+  attrib,
+  text,
+  insert,
+  dimension,
+  threeDFace,
+  viewport,
+  ole2Frame,
+].reduce((acc, mod) => {
+  acc[mod.TYPE] = mod
+  return acc
+}, {} as Record<string, EntityHandler>)
+
+/**
+ * Parses entities from DXF tuples
+ *
+ * @param tuples - Array of DXF tuples representing entities
+ * @returns Array of parsed entities
+ */
+export default function parseEntities(tuples: DXFTuple[]): Entity[] {
+  const entities: Entity[] = []
+  const entityGroups: DXFTuple[][] = []
+  let currentEntityTuples: DXFTuple[] = []
+
+  // First group them together for easy processing
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    if (type === 0) {
+      currentEntityTuples = []
+      entityGroups.push(currentEntityTuples)
+    }
+    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
+}

package/src/handlers/entity/arc.ts

@@ -0,0 +1,61 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'ARC'
+
+
+interface ArcEntity {
+  type: typeof TYPE
+  x?: number
+  y?: number
+  z?: number
+  thickness?: number
+  r?: number
+  startAngle?: number
+  endAngle?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): ArcEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          entity.x = value as number
+          break
+        case 20:
+          entity.y = value as number
+          break
+        case 30:
+          entity.z = value as number
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        case 40:
+          entity.r = value as number
+          break
+        case 50:
+          // *Someone* decided that ELLIPSE angles are in radians but
+          // ARC angles are in degrees
+          entity.startAngle = ((value as number) / 180) * Math.PI
+          break
+        case 51:
+          entity.endAngle = ((value as number) / 180) * Math.PI
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+    } as ArcEntity,
+  )
+}
+
+export default { TYPE, process }