@linkiez/dxf-renew 5.3.1

package/src/toPolylines.ts

@@ -0,0 +1,47 @@
+import { Box2 } from 'vecks'
+
+import applyTransforms from './applyTransforms'
+import denormalise from './denormalise'
+import entityToPolyline from './entityToPolyline'
+import colors from './util/colors'
+import logger from './util/logger'
+
+import type { Entity, ParsedDXF } from './types'
+import type { Polyline, PolylineResult } from './types/polylines'
+
+export default function toPolylines(parsed: ParsedDXF): PolylineResult {
+  const entities = denormalise(parsed)
+  const polylines: Polyline[] = entities.map((entity: Entity) => {
+    const layer = entity.layer ?? '0'
+    const layerTable = parsed.tables.layers[layer]
+    let colorNumber = 0
+    if ('colorNumber' in entity && typeof entity.colorNumber === 'number') {
+      colorNumber = entity.colorNumber
+    } else if (
+      layerTable &&
+      typeof layerTable.colorNumber === 'number'
+    ) {
+      colorNumber = layerTable.colorNumber
+    }
+
+    if (colors[colorNumber] === undefined) {
+      logger.warn('Color index', colorNumber, 'invalid, defaulting to black')
+      colorNumber = 0
+    }
+
+    return {
+      rgb: colors[colorNumber],
+      layer: layerTable,
+      vertices: applyTransforms(entityToPolyline(entity as any), entity.transforms),
+    }
+  })
+
+  const bbox = new Box2()
+  for (const polyline of polylines) {
+    for (const vertex of polyline.vertices) {
+      bbox.expandByPoint({ x: vertex[0], y: vertex[1] })
+    }
+  }
+
+  return { bbox, polylines }
+}

package/src/toSVG.ts

@@ -0,0 +1,518 @@
+import { Box2 } from 'vecks'
+
+import denormalise from './denormalise'
+import dimensionToSVG from './dimensionToSVG'
+import entityToPolyline from './entityToPolyline'
+import getRGBForEntity from './getRGBForEntity'
+import logger from './util/logger'
+import rgbToColorAttribute from './util/rgbToColorAttribute'
+import rotate from './util/rotate'
+import toPiecewiseBezier, { multiplicity } from './util/toPiecewiseBezier'
+import transformBoundingBoxAndElement from './util/transformBoundingBoxAndElement'
+
+import type {
+  ArcEntity,
+  CircleEntity,
+  DimensionEntity,
+  EllipseEntity,
+  Entity,
+  MTextEntity,
+  ParsedDXF,
+  SplineEntity,
+  TextEntity,
+} from './types'
+import type { BoundsAndElement } from './types/svg'
+
+const addFlipXIfApplicable = (
+  entity: Entity,
+  { bbox, element }: BoundsAndElement,
+): BoundsAndElement => {
+  if (entity.extrusionZ === -1) {
+    return {
+      bbox: new Box2()
+        .expandByPoint({ x: -bbox.min.x, y: bbox.min.y })
+        .expandByPoint({ x: -bbox.max.x, y: bbox.max.y }),
+      element: `<g transform="matrix(-1 0 0 1 0 0)">
+        ${element}
+      </g>`,
+    }
+  } else {
+    return { bbox, element }
+  }
+}
+
+/**
+ * Create a <path /> element. Interpolates curved entities.
+ */
+const polyline = (entity: Entity): BoundsAndElement => {
+  const vertices = entityToPolyline(entity as any)
+  const bbox = vertices.reduce(
+    (acc, [x, y]) => acc.expandByPoint({ x, y }),
+    new Box2(),
+  )
+  const d = vertices.reduce((acc, point, i) => {
+    acc += i === 0 ? 'M' : 'L'
+    acc += point[0] + ',' + point[1]
+    return acc
+  }, '')
+  // Empirically it appears that flipping horizontally does not apply to polyline
+  return transformBoundingBoxAndElement(
+    bbox,
+    `<path d="${d}" />`,
+    entity.transforms ?? [],
+  )
+}
+
+/**
+ * Create a <path /> element. Interpolates curved entities.
+ * lwpolyline is the same as polyline but addFlipXIfApplicable does apply
+ */
+const lwpolyline = (entity: Entity): BoundsAndElement => {
+  const vertices = entityToPolyline(entity as any)
+  const bbox0 = vertices.reduce(
+    (acc, [x, y]) => acc.expandByPoint({ x, y }),
+    new Box2(),
+  )
+  const d = vertices.reduce((acc, point, i) => {
+    acc += i === 0 ? 'M' : 'L'
+    acc += point[0] + ',' + point[1]
+    return acc
+  }, '')
+  const element0 = `<path d="${d}" />`
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(
+    bbox,
+    element,
+    entity.transforms ?? [],
+  )
+}
+
+
+/**
+ * Create a <circle /> element for the CIRCLE entity.
+ */
+const circle = (entity: CircleEntity): BoundsAndElement => {
+  const bbox0 = new Box2()
+    .expandByPoint({
+      x: entity.x + entity.r,
+      y: entity.y + entity.r,
+    })
+    .expandByPoint({
+      x: entity.x - entity.r,
+      y: entity.y - entity.r,
+    })
+  const element0 = `<circle cx="${entity.x}" cy="${entity.y}" r="${entity.r}" />`
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+interface EllipticArcParams {
+  cx: number
+  cy: number
+  majorX: number
+  majorY: number
+  axisRatio: number
+  startAngle: number
+  endAngle: number
+  flipX?: boolean
+}
+
+/**
+ * Create a a <path d="A..." /> or <ellipse /> element for the ARC or ELLIPSE
+ * DXF entity (<ellipse /> if start and end point are the same).
+ */
+const ellipseOrArc = (params: EllipticArcParams): BoundsAndElement => {
+  const { cx, cy, majorX, majorY, axisRatio, startAngle, endAngle } = params
+  const rx = Math.hypot(majorX, majorY)
+  const ry = axisRatio * rx
+  const rotationAngle = -Math.atan2(-majorY, majorX)
+
+  const bbox = bboxEllipseOrArc(params)
+
+  if (
+    Math.abs(startAngle - endAngle) < 1e-9 ||
+    Math.abs(startAngle - endAngle + Math.PI * 2) < 1e-9
+  ) {
+    // Use a native <ellipse> when start and end angles are the same, and
+    // arc paths with same start and end points don't render (at least on Safari)
+    const element = `<g transform="rotate(${
+      (rotationAngle / Math.PI) * 180
+    } ${cx}, ${cy})">
+      <ellipse cx="${cx}" cy="${cy}" rx="${rx}" ry="${ry}" />
+    </g>`
+    return { bbox, element }
+  } else {
+    const startOffset = rotate(
+      {
+        x: Math.cos(startAngle) * rx,
+        y: Math.sin(startAngle) * ry,
+      },
+      rotationAngle,
+    )
+    const startPoint = {
+      x: cx + startOffset.x,
+      y: cy + startOffset.y,
+    }
+    const endOffset = rotate(
+      {
+        x: Math.cos(endAngle) * rx,
+        y: Math.sin(endAngle) * ry,
+      },
+      rotationAngle,
+    )
+    const endPoint = {
+      x: cx + endOffset.x,
+      y: cy + endOffset.y,
+    }
+    const adjustedEndAngle =
+      endAngle < startAngle ? endAngle + Math.PI * 2 : endAngle
+    const largeArcFlag = adjustedEndAngle - startAngle < Math.PI ? 0 : 1
+    const d = `M ${startPoint.x} ${startPoint.y} A ${rx} ${ry} ${
+      (rotationAngle / Math.PI) * 180
+    } ${largeArcFlag} 1 ${endPoint.x} ${endPoint.y}`
+    const element = `<path d="${d}" />`
+    return { bbox, element }
+  }
+}
+
+/**
+ * Compute the bounding box of an elliptical arc, given the DXF entity parameters
+ */
+
+const bboxEllipseOrArc = (params: EllipticArcParams): Box2 => {
+  const { cx, cy, majorX, majorY, axisRatio } = params
+  let { startAngle, endAngle } = params
+
+  // The bounding box will be defined by the starting point of the ellipse, and ending point,
+  // and any extrema on the ellipse that are between startAngle and endAngle.
+  // The extrema are found by setting either the x or y component of the ellipse's
+  // tangent vector to zero and solving for the angle.
+
+  // Ensure start and end angles are > 0 and well-ordered
+  while (startAngle < 0) startAngle += Math.PI * 2
+  while (endAngle <= startAngle) endAngle += Math.PI * 2
+
+  // When rotated, the extrema of the ellipse will be found at these angles
+  const angles = []
+
+  if (Math.abs(majorX) < 1e-12 || Math.abs(majorY) < 1e-12) {
+    // Special case for majorX or majorY = 0
+    for (let i = 0; i < 4; i++) {
+      angles.push((i / 2) * Math.PI)
+    }
+  } else {
+    // reference https://github.com/bjnortier/dxf/issues/47#issuecomment-545915042
+    angles[0] = Math.atan((-majorY * axisRatio) / majorX) - Math.PI // Ensure angles < 0
+    angles[1] = Math.atan((majorX * axisRatio) / majorY) - Math.PI
+    angles[2] = angles[0] - Math.PI
+    angles[3] = angles[1] - Math.PI
+  }
+
+  // Remove angles not falling between start and end
+  for (let i = 4; i >= 0; i--) {
+    while (angles[i] < startAngle) angles[i] += Math.PI * 2
+    if (angles[i] > endAngle) {
+      angles.splice(i, 1)
+    }
+  }
+
+  // Also to consider are the starting and ending points:
+  angles.push(startAngle, endAngle)
+
+  // Compute points lying on the unit circle at these angles
+  const pts = angles.map((a) => ({
+    x: Math.cos(a),
+    y: Math.sin(a),
+  }))
+
+  // Transformation matrix, formed by the major and minor axes
+  const M = [
+    [majorX, -majorY * axisRatio],
+    [majorY, majorX * axisRatio],
+  ]
+
+  // Rotate, scale, and translate points
+  const rotatedPts = pts.map((p) => ({
+    x: p.x * M[0][0] + p.y * M[0][1] + cx,
+    y: p.x * M[1][0] + p.y * M[1][1] + cy,
+  }))
+
+  // Compute extents of bounding box
+  const bbox = rotatedPts.reduce((acc, p) => {
+    acc.expandByPoint(p)
+    return acc
+  }, new Box2())
+
+  return bbox
+}
+
+/**
+ * An ELLIPSE is defined by the major axis, convert to X and Y radius with
+ * a rotation angle
+ */
+const ellipse = (entity: EllipseEntity): BoundsAndElement => {
+  const { bbox: bbox0, element: element0 } = ellipseOrArc({
+    cx: entity.x,
+    cy: entity.y,
+    majorX: entity.majorX,
+    majorY: entity.majorY,
+    axisRatio: entity.axisRatio,
+    startAngle: entity.startAngle,
+    endAngle: entity.endAngle,
+  })
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * An ARC is an ellipse with equal radii
+ */
+const arc = (entity: ArcEntity): BoundsAndElement => {
+  const { bbox: bbox0, element: element0 } = ellipseOrArc({
+    cx: entity.x,
+    cy: entity.y,
+    majorX: entity.r,
+    majorY: 0,
+    axisRatio: 1,
+    startAngle: entity.startAngle,
+    endAngle: entity.endAngle,
+    flipX: entity.extrusionZ === -1,
+  })
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * Create a <text /> element for TEXT entity
+ */
+const text = (entity: TextEntity): BoundsAndElement => {
+  const x = entity.x ?? 0
+  const y = entity.y ?? 0
+  const height = entity.textHeight ?? 1
+  const rotation = entity.rotation ?? 0
+  const content = entity.string ?? ''
+
+  // Estimate text bounding box (approximate)
+  const textWidth = content.length * height * 0.6
+  const bbox0 = new Box2()
+    .expandByPoint({ x, y })
+    .expandByPoint({ x: x + textWidth, y: y + height })
+
+  const rotationDegrees = (rotation * 180) / Math.PI
+  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${content}</text>`
+
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * Create a <text /> element for MTEXT entity
+ */
+const mtext = (entity: MTextEntity): BoundsAndElement => {
+  const x = entity.x ?? 0
+  const y = entity.y ?? 0
+  const height = entity.nominalTextHeight ?? entity.textHeight ?? 1
+  const content = entity.string ?? ''
+
+  // Estimate text bounding box (approximate)
+  const textWidth = (entity.refRectangleWidth ?? content.length * height * 0.6)
+  const bbox0 = new Box2()
+    .expandByPoint({ x, y })
+    .expandByPoint({ x: x + textWidth, y: y + height })
+
+  // Calculate rotation from x-axis direction
+  const rotation = entity.xAxisX !== undefined && entity.xAxisY !== undefined
+    ? Math.atan2(entity.xAxisY, entity.xAxisX)
+    : 0
+  const rotationDegrees = (rotation * 180) / Math.PI
+
+  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${content}</text>`
+
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * Create dimension visualization with DIMSTYLE support
+ */
+const dimension = (
+  entity: DimensionEntity,
+  dimStyle?: any,
+): BoundsAndElement => {
+  const result = dimensionToSVG(entity, dimStyle)
+  return transformBoundingBoxAndElement(
+    result.bbox,
+    result.element,
+    entity.transforms ?? [],
+  )
+}
+
+export const piecewiseToPaths = (
+  k: number,
+  knots: number[],
+  controlPoints: Array<{ x: number; y: number }>,
+): string[] => {
+  const paths: string[] = []
+  let controlPointIndex = 0
+  let knotIndex = k
+  while (knotIndex < knots.length - k + 1) {
+    const m = multiplicity(knots, knotIndex)
+    const cp = controlPoints.slice(controlPointIndex, controlPointIndex + k)
+    if (k === 4) {
+      paths.push(
+        `<path d="M ${cp[0].x} ${cp[0].y} C ${cp[1].x} ${cp[1].y} ${cp[2].x} ${cp[2].y} ${cp[3].x} ${cp[3].y}" />`,
+      )
+    } else if (k === 3) {
+      paths.push(
+        `<path d="M ${cp[0].x} ${cp[0].y} Q ${cp[1].x} ${cp[1].y} ${cp[2].x} ${cp[2].y}" />`,
+      )
+    }
+    controlPointIndex += m
+    knotIndex += m
+  }
+  return paths
+}
+
+const bezier = (entity: SplineEntity): BoundsAndElement => {
+  let bbox = new Box2()
+  for (const p of entity.controlPoints) {
+    bbox = bbox.expandByPoint(p)
+  }
+  const k = entity.degree + 1
+  const piecewise = toPiecewiseBezier(k, entity.controlPoints, entity.knots)
+  const paths = piecewiseToPaths(k, piecewise.knots, piecewise.controlPoints)
+  const element = `<g>${paths.join('')}</g>`
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * Switch the appropriate function on entity type. CIRCLE, ARC and ELLIPSE
+ * produce native SVG elements, the rest produce interpolated polylines.
+ */
+const entityToBoundsAndElement = (
+  entity: Entity,
+  dimStyles?: { [name: string]: any },
+): BoundsAndElement | null => {
+  switch (entity.type) {
+    case 'CIRCLE':
+      return circle(entity as CircleEntity)
+    case 'ELLIPSE':
+      return ellipse(entity as EllipseEntity)
+    case 'ARC':
+      return arc(entity as ArcEntity)
+    case 'TEXT':
+      return text(entity as TextEntity)
+    case 'MTEXT':
+      return mtext(entity as MTextEntity)
+    case 'DIMENSION': {
+      const dimEntity = entity as DimensionEntity
+      const styleName = typeof dimEntity.styleName === 'string'
+        ? dimEntity.styleName
+        : undefined
+      const dimStyle = styleName && dimStyles
+        ? dimStyles[styleName]
+        : undefined
+      return dimension(dimEntity, dimStyle)
+    }
+    case 'SPLINE': {
+      const splineEntity = entity as SplineEntity
+      const hasWeights = splineEntity.weights?.some((w: number) => w !== 1)
+      if ((splineEntity.degree === 2 || splineEntity.degree === 3) && !hasWeights) {
+        try {
+          return bezier(splineEntity)
+        } catch (err) {
+          const error = err as Error
+          logger.warn('bezier conversion failed, using polyline:', error.message)
+          return polyline(entity)
+        }
+      } else {
+        return polyline(entity)
+      }
+    }
+    case 'LINE':
+    case 'POLYLINE': {
+      return polyline(entity)
+    }
+    case 'LWPOLYLINE': {
+      return lwpolyline(entity)
+    }
+    default:
+      logger.warn('entity type not supported in SVG rendering:', entity.type)
+      return null
+  }
+}
+
+export default function toSVG(parsed: ParsedDXF): string {
+  const entities = denormalise(parsed)
+  const dimStyles = parsed.tables.dimStyles
+  const { bbox, elements } = entities.reduce(
+    (
+      acc: { bbox: Box2; elements: string[] },
+      entity: Entity,
+    ): { bbox: Box2; elements: string[] } => {
+      const rgb = getRGBForEntity(parsed.tables.layers, entity)
+      const boundsAndElement = entityToBoundsAndElement(entity, dimStyles)
+      // Ignore entities that don't produce SVG elements or have unsupported types
+      if (boundsAndElement) {
+        const { bbox, element } = boundsAndElement
+        // Ignore invalid bounding boxes
+        if (bbox.valid) {
+          acc.bbox.expandByPoint(bbox.min)
+          acc.bbox.expandByPoint(bbox.max)
+        }
+        acc.elements.push(
+          `<g stroke="${rgbToColorAttribute(rgb)}">${element}</g>`,
+        )
+      }
+      return acc
+    },
+    {
+      bbox: new Box2(),
+      elements: [],
+    },
+  )
+
+  const viewBox = bbox.valid
+    ? {
+        x: bbox.min.x,
+        y: -bbox.max.y,
+        width: bbox.max.x - bbox.min.x,
+        height: bbox.max.y - bbox.min.y,
+      }
+    : {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+      }
+  return `<?xml version="1.0"?>
+<svg
+  xmlns="http://www.w3.org/2000/svg"
+  xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1"
+  preserveAspectRatio="xMinYMin meet"
+  viewBox="${viewBox.x} ${viewBox.y} ${viewBox.width} ${viewBox.height}"
+  width="100%" height="100%"
+>
+  <g stroke="#000000" stroke-width="0.1%" fill="none" transform="matrix(1,0,0,-1,0,0)">
+    ${elements.join('\n')}
+  </g>
+</svg>`
+}

package/src/types/README.md

@@ -0,0 +1,91 @@
+# DXF Types
+
+Tipos TypeScript organizados para o parser DXF.
+
+## Estrutura
+
+### Tipos Comuns (`common.ts`)
+
+- `Point2D` - Ponto 2D (x, y)
+- `Point3D` - Ponto 3D (x, y, z)
+- `RGB` - Cor RGB
+- `ColorRGB` - Tupla de cor [r, g, b]
+- `Transform` - Transformação geométrica
+- `ZeroTransform` - Transformação zero completa
+
+### Entidade Base (`base-entity.ts`)
+
+- `BaseEntity` - Interface base que todas as entidades DXF estendem
+
+### Entidades DXF
+
+Cada tipo de entidade em seu próprio arquivo:
+
+- `line-entity.ts` - `LineEntity` (LINE)
+- `circle-entity.ts` - `CircleEntity` (CIRCLE)
+- `arc-entity.ts` - `ArcEntity` (ARC)
+- `ellipse-entity.ts` - `EllipseEntity` (ELLIPSE)
+- `text-entity.ts` - `TextEntity` (TEXT)
+- `mtext-entity.ts` - `MTextEntity` (MTEXT)
+- `point-entity.ts` - `PointEntity` (POINT)
+- `polyline-entity.ts` - `PolylineEntity`, `Vertex` (POLYLINE/LWPOLYLINE)
+- `spline-entity.ts` - `SplineEntity` (SPLINE)
+- `dimension-entity.ts` - `DimensionEntity` (DIMENSION)
+- `solid-entity.ts` - `SolidEntity` (SOLID/3DFACE)
+- `insert-entity.ts` - `InsertEntity` (INSERT)
+- `hatch-entity.ts` - `HatchEntity` (HATCH)
+
+### Tipos Estruturais
+
+- `entity.ts` - Union type `Entity` de todas as entidades
+- `dxf.ts` - Estruturas DXF principais
+  - `LayerTable`
+  - `Tables`
+  - `Block`
+  - `Blocks`
+  - `BlockArray`
+  - `ParsedDXF`
+  - `DXFTuple`
+
+### Tipos Utilitários
+
+- `handler.ts` - `EntityHandler` - Interface para handlers de entidades
+- `options.ts` - Opções de configuração
+  - `ToPolylinesOptions`
+  - `ToSVGOptions`
+  - `Config`
+- `helper.ts` - `HelperInterface` - Interface da classe Helper
+
+## Uso
+
+### Import Barrel (Recomendado)
+
+```typescript
+import type { LineEntity, Point3D, ParsedDXF } from './types'
+```
+
+### Import Específico
+
+```typescript
+import type { LineEntity } from './types/line-entity'
+import type { Point3D } from './types/common'
+```
+
+### Backward Compatibility
+
+O arquivo `types.ts` na raiz re-exporta todos os tipos para compatibilidade:
+
+```typescript
+import type { LineEntity } from './types' // Funciona
+```
+
+## Organização
+
+Cada arquivo segue o padrão:
+
+1. Comentário descritivo do tipo
+2. Imports de tipos dependentes
+3. Definição da interface/type
+4. Exports
+
+O arquivo `index.ts` faz barrel export de todos os tipos.

package/src/types/arc-entity.ts

@@ -0,0 +1,10 @@
+// ARC entity type
+
+import type { PositionalEntity } from './base-entity'
+
+export interface ArcEntity extends PositionalEntity {
+  type: 'ARC'
+  r: number
+  startAngle: number
+  endAngle: number
+}

package/src/types/base-entity.ts

@@ -0,0 +1,25 @@
+// Base entity interface that all DXF entities extend from
+
+import type { Point3D, Transform } from './common'
+
+export interface BaseEntity {
+  type: string
+  handle?: string
+  layer?: string
+  lineTypeName?: string
+  lineTypeScale?: number
+  visible?: boolean
+  colorNumber?: number
+  paperSpace?: number
+  viewportOn?: number
+  extrusionDirection?: Point3D
+  extrusionZ?: number
+  transforms?: Transform[]
+}
+
+/** Base for entities with positional coordinates (x, y, z) */
+export interface PositionalEntity extends BaseEntity {
+  x: number
+  y: number
+  z?: number
+}

package/src/types/circle-entity.ts

@@ -0,0 +1,8 @@
+// CIRCLE entity type
+
+import type { PositionalEntity } from './base-entity'
+
+export interface CircleEntity extends PositionalEntity {
+  type: 'CIRCLE'
+  r: number
+}