@linkiez/dxf-renew 5.3.1

package/src/util/colors.ts

@@ -0,0 +1,266 @@
+// DXF color table mapping color numbers to RGB values
+import type { ColorRGB } from '../types/common'
+
+// Re-export for backward compatibility
+export type { ColorRGB } from '../types/common'
+
+const colors: ColorRGB[] = [
+  [0, 0, 0],
+  [255, 0, 0],
+  [255, 255, 0],
+  [0, 255, 0],
+  [0, 255, 255],
+  [0, 0, 255],
+  [255, 0, 255],
+  [255, 255, 255],
+  [65, 65, 65],
+  [128, 128, 128],
+  [255, 0, 0],
+  [255, 170, 170],
+  [189, 0, 0],
+  [189, 126, 126],
+  [129, 0, 0],
+  [129, 86, 86],
+  [104, 0, 0],
+  [104, 69, 69],
+  [79, 0, 0],
+  [79, 53, 53],
+  [255, 63, 0],
+  [255, 191, 170],
+  [189, 46, 0],
+  [189, 141, 126],
+  [129, 31, 0],
+  [129, 96, 86],
+  [104, 25, 0],
+  [104, 78, 69],
+  [79, 19, 0],
+  [79, 59, 53],
+  [255, 127, 0],
+  [255, 212, 170],
+  [189, 94, 0],
+  [189, 157, 126],
+  [129, 64, 0],
+  [129, 107, 86],
+  [104, 52, 0],
+  [104, 86, 69],
+  [79, 39, 0],
+  [79, 66, 53],
+  [255, 191, 0],
+  [255, 234, 170],
+  [189, 141, 0],
+  [189, 173, 126],
+  [129, 96, 0],
+  [129, 118, 86],
+  [104, 78, 0],
+  [104, 95, 69],
+  [79, 59, 0],
+  [79, 73, 53],
+  [255, 255, 0],
+  [255, 255, 170],
+  [189, 189, 0],
+  [189, 189, 126],
+  [129, 129, 0],
+  [129, 129, 86],
+  [104, 104, 0],
+  [104, 104, 69],
+  [79, 79, 0],
+  [79, 79, 53],
+  [191, 255, 0],
+  [234, 255, 170],
+  [141, 189, 0],
+  [173, 189, 126],
+  [96, 129, 0],
+  [118, 129, 86],
+  [78, 104, 0],
+  [95, 104, 69],
+  [59, 79, 0],
+  [73, 79, 53],
+  [127, 255, 0],
+  [212, 255, 170],
+  [94, 189, 0],
+  [157, 189, 126],
+  [64, 129, 0],
+  [107, 129, 86],
+  [52, 104, 0],
+  [86, 104, 69],
+  [39, 79, 0],
+  [66, 79, 53],
+  [63, 255, 0],
+  [191, 255, 170],
+  [46, 189, 0],
+  [141, 189, 126],
+  [31, 129, 0],
+  [96, 129, 86],
+  [25, 104, 0],
+  [78, 104, 69],
+  [19, 79, 0],
+  [59, 79, 53],
+  [0, 255, 0],
+  [170, 255, 170],
+  [0, 189, 0],
+  [126, 189, 126],
+  [0, 129, 0],
+  [86, 129, 86],
+  [0, 104, 0],
+  [69, 104, 69],
+  [0, 79, 0],
+  [53, 79, 53],
+  [0, 255, 63],
+  [170, 255, 191],
+  [0, 189, 46],
+  [126, 189, 141],
+  [0, 129, 31],
+  [86, 129, 96],
+  [0, 104, 25],
+  [69, 104, 78],
+  [0, 79, 19],
+  [53, 79, 59],
+  [0, 255, 127],
+  [170, 255, 212],
+  [0, 189, 94],
+  [126, 189, 157],
+  [0, 129, 64],
+  [86, 129, 107],
+  [0, 104, 52],
+  [69, 104, 86],
+  [0, 79, 39],
+  [53, 79, 66],
+  [0, 255, 191],
+  [170, 255, 234],
+  [0, 189, 141],
+  [126, 189, 173],
+  [0, 129, 96],
+  [86, 129, 118],
+  [0, 104, 78],
+  [69, 104, 95],
+  [0, 79, 59],
+  [53, 79, 73],
+  [0, 255, 255],
+  [170, 255, 255],
+  [0, 189, 189],
+  [126, 189, 189],
+  [0, 129, 129],
+  [86, 129, 129],
+  [0, 104, 104],
+  [69, 104, 104],
+  [0, 79, 79],
+  [53, 79, 79],
+  [0, 191, 255],
+  [170, 234, 255],
+  [0, 141, 189],
+  [126, 173, 189],
+  [0, 96, 129],
+  [86, 118, 129],
+  [0, 78, 104],
+  [69, 95, 104],
+  [0, 59, 79],
+  [53, 73, 79],
+  [0, 127, 255],
+  [170, 212, 255],
+  [0, 94, 189],
+  [126, 157, 189],
+  [0, 64, 129],
+  [86, 107, 129],
+  [0, 52, 104],
+  [69, 86, 104],
+  [0, 39, 79],
+  [53, 66, 79],
+  [0, 63, 255],
+  [170, 191, 255],
+  [0, 46, 189],
+  [126, 141, 189],
+  [0, 31, 129],
+  [86, 96, 129],
+  [0, 25, 104],
+  [69, 78, 104],
+  [0, 19, 79],
+  [53, 59, 79],
+  [0, 0, 255],
+  [170, 170, 255],
+  [0, 0, 189],
+  [126, 126, 189],
+  [0, 0, 129],
+  [86, 86, 129],
+  [0, 0, 104],
+  [69, 69, 104],
+  [0, 0, 79],
+  [53, 53, 79],
+  [63, 0, 255],
+  [191, 170, 255],
+  [46, 0, 189],
+  [141, 126, 189],
+  [31, 0, 129],
+  [96, 86, 129],
+  [25, 0, 104],
+  [78, 69, 104],
+  [19, 0, 79],
+  [59, 53, 79],
+  [127, 0, 255],
+  [212, 170, 255],
+  [94, 0, 189],
+  [157, 126, 189],
+  [64, 0, 129],
+  [107, 86, 129],
+  [52, 0, 104],
+  [86, 69, 104],
+  [39, 0, 79],
+  [66, 53, 79],
+  [191, 0, 255],
+  [234, 170, 255],
+  [141, 0, 189],
+  [173, 126, 189],
+  [96, 0, 129],
+  [118, 86, 129],
+  [78, 0, 104],
+  [95, 69, 104],
+  [59, 0, 79],
+  [73, 53, 79],
+  [255, 0, 255],
+  [255, 170, 255],
+  [189, 0, 189],
+  [189, 126, 189],
+  [129, 0, 129],
+  [129, 86, 129],
+  [104, 0, 104],
+  [104, 69, 104],
+  [79, 0, 79],
+  [79, 53, 79],
+  [255, 0, 191],
+  [255, 170, 234],
+  [189, 0, 141],
+  [189, 126, 173],
+  [129, 0, 96],
+  [129, 86, 118],
+  [104, 0, 78],
+  [104, 69, 95],
+  [79, 0, 59],
+  [79, 53, 73],
+  [255, 0, 127],
+  [255, 170, 212],
+  [189, 0, 94],
+  [189, 126, 157],
+  [129, 0, 64],
+  [129, 86, 107],
+  [104, 0, 52],
+  [104, 69, 86],
+  [79, 0, 39],
+  [79, 53, 66],
+  [255, 0, 63],
+  [255, 170, 191],
+  [189, 0, 46],
+  [189, 126, 141],
+  [129, 0, 31],
+  [129, 86, 96],
+  [104, 0, 25],
+  [104, 69, 78],
+  [79, 0, 19],
+  [79, 53, 59],
+    [51, 51, 51],
+  [80, 80, 80],
+  [105, 105, 105],
+  [130, 130, 130],
+  [190, 190, 190],
+  [255, 255, 255],
+]
+
+export default colors

package/src/util/createArcForLWPolyline.ts

@@ -0,0 +1,93 @@
+import { V2 } from 'vecks'
+
+type Point = [number, number]
+
+/**
+ * Create the arcs point for a LWPOLYLINE. The start and end are excluded
+ *
+ * See diagram.png in this directory for description of points and angles used.
+ */
+export default function createArcForLWPolyline(
+  from: Point,
+  to: Point,
+  bulge: number,
+  resolution?: number
+): Point[] {
+  // Resolution in degrees
+  if (!resolution) {
+    resolution = 5
+  }
+
+  // If the bulge is < 0, the arc goes clockwise. So we simply
+  // reverse a and b and invert sign
+  // Bulge = tan(theta/4)
+  let theta: number
+  let a: V2
+  let b: V2
+
+  if (bulge < 0) {
+    theta = Math.atan(-bulge) * 4
+    a = new V2(from[0], from[1])
+    b = new V2(to[0], to[1])
+  } else {
+    // Default is counter-clockwise
+    theta = Math.atan(bulge) * 4
+    a = new V2(to[0], to[1])
+    b = new V2(from[0], from[1])
+  }
+
+  const ab = b.sub(a)
+  const lengthAB = ab.length()
+  const c = a.add(ab.multiply(0.5))
+
+  // Distance from center of arc to line between form and to points
+  const lengthCD = Math.abs(lengthAB / 2 / Math.tan(theta / 2))
+  const normAB = ab.norm()
+
+  let d: V2
+  if (theta < Math.PI) {
+    const normDC = new V2(
+      normAB.x * Math.cos(Math.PI / 2) - normAB.y * Math.sin(Math.PI / 2),
+      normAB.y * Math.cos(Math.PI / 2) + normAB.x * Math.sin(Math.PI / 2),
+    )
+    // D is the center of the arc
+    d = c.add(normDC.multiply(-lengthCD))
+  } else {
+    const normCD = new V2(
+      normAB.x * Math.cos(Math.PI / 2) - normAB.y * Math.sin(Math.PI / 2),
+      normAB.y * Math.cos(Math.PI / 2) + normAB.x * Math.sin(Math.PI / 2),
+    )
+    // D is the center of the arc
+    d = c.add(normCD.multiply(lengthCD))
+  }
+
+  // Add points between start start and eng angle relative
+  // to the center point
+  const startAngle = (Math.atan2(b.y - d.y, b.x - d.x) / Math.PI) * 180
+  let endAngle = (Math.atan2(a.y - d.y, a.x - d.x) / Math.PI) * 180
+  if (endAngle < startAngle) {
+    endAngle += 360
+  }
+  const r = b.sub(d).length()
+
+  const startInter =
+    Math.floor(startAngle / resolution) * resolution + resolution
+  const endInter = Math.ceil(endAngle / resolution) * resolution - resolution
+
+  const points: V2[] = []
+  for (let i = startInter; i <= endInter; i += resolution) {
+    points.push(
+      d.add(
+        new V2(
+          Math.cos((i / 180) * Math.PI) * r,
+          Math.sin((i / 180) * Math.PI) * r,
+        ),
+      ),
+    )
+  }
+  // Maintain the right ordering to join the from and to points
+  if (bulge < 0) {
+    points.reverse()
+  }
+  return points.map((p): Point => [p.x, p.y])
+}

package/src/util/dxfColorToRGB.ts

@@ -0,0 +1,106 @@
+/**
+ * Convert DXF ACI (AutoCAD Color Index) to RGB color
+ * Based on AutoCAD's standard 256 color palette
+ */
+export default function dxfColorToRGB(colorNumber: number): { r: number; g: number; b: number } {
+  // Standard AutoCAD Color Index (ACI) colors
+  const aciColors: Array<[number, number, number]> = [
+    [0, 0, 0],       // 0 - ByBlock
+    [255, 0, 0],     // 1 - Red
+    [255, 255, 0],   // 2 - Yellow
+    [0, 255, 0],     // 3 - Green
+    [0, 255, 255],   // 4 - Cyan
+    [0, 0, 255],     // 5 - Blue
+    [255, 0, 255],   // 6 - Magenta
+    [255, 255, 255], // 7 - White/Black (depends on background)
+    [128, 128, 128], // 8 - Gray
+    [192, 192, 192], // 9 - Light Gray
+  ]
+
+  // Handle special cases
+  if (colorNumber === 0 || colorNumber === 256) {
+    // ByBlock or ByLayer - return black as default
+    return { r: 0, g: 0, b: 0 }
+  }
+
+  if (colorNumber === 7) {
+    // White/Black - return black for light backgrounds
+    return { r: 0, g: 0, b: 0 }
+  }
+
+  // Colors 1-9 are standard
+  if (colorNumber >= 1 && colorNumber <= 9) {
+    const [r, g, b] = aciColors[colorNumber]
+    return { r, g, b }
+  }
+
+  // Colors 10-249 follow a pattern
+  // Simplified approximation for extended colors
+  if (colorNumber >= 10 && colorNumber <= 249) {
+    const base = colorNumber - 10
+    const hue = (base % 10) * 36
+    const lightness = Math.floor(base / 10) * 10 + 50
+    
+    // Convert HSL to RGB (simplified)
+    const c = (1 - Math.abs(2 * lightness / 100 - 1)) * 100
+    const x = c * (1 - Math.abs(((hue / 60) % 2) - 1))
+    const m = lightness - c / 2
+    
+    let r = 0
+    let g = 0
+    let b = 0
+    
+    if (hue < 60) {
+      r = c
+      g = x
+    } else if (hue < 120) {
+      r = x
+      g = c
+    } else if (hue < 180) {
+      g = c
+      b = x
+    } else if (hue < 240) {
+      g = x
+      b = c
+    } else if (hue < 300) {
+      r = x
+      b = c
+    } else {
+      r = c
+      b = x
+    }
+    
+    return {
+      r: Math.round((r + m) * 2.55),
+      g: Math.round((g + m) * 2.55),
+      b: Math.round((b + m) * 2.55),
+    }
+  }
+
+  // Grayscale colors 250-255
+  if (colorNumber >= 250 && colorNumber <= 255) {
+    const gray = Math.round(((colorNumber - 250) / 5) * 255)
+    return { r: gray, g: gray, b: gray }
+  }
+
+  // Default to black for unknown colors
+  return { r: 0, g: 0, b: 0 }
+}
+
+/**
+ * Convert RGB object to SVG color string
+ */
+export function rgbToSVGColor(rgb: { r: number; g: number; b: number }): string {
+  return `rgb(${rgb.r},${rgb.g},${rgb.b})`
+}
+
+/**
+ * Convert DXF color number directly to SVG color string
+ */
+export function dxfColorToSVG(colorNumber: number | undefined): string {
+  if (colorNumber === undefined) {
+    return 'currentColor'
+  }
+  const rgb = dxfColorToRGB(colorNumber)
+  return rgbToSVGColor(rgb)
+}

package/src/util/insertKnot.ts

@@ -0,0 +1,69 @@
+import type { InsertKnotResult, UtilPoint } from '../types/util-types'
+
+/**
+ * Knot insertion is known as "Boehm's algorithm"
+ *
+ * https://math.stackexchange.com/questions/417859/convert-a-b-spline-into-bezier-curves
+ * code adapted from http://preserve.mactech.com/articles/develop/issue_25/schneider.html
+ */
+export default function insertKnot(
+  k: number,
+  controlPoints: UtilPoint[],
+  knots: number[],
+  newKnot: number
+): InsertKnotResult {
+  const x = knots
+  const b = controlPoints
+  const n = controlPoints.length
+  let i = 0
+  let foundIndex = false
+  for (let j = 0; j < n + k; j++) {
+    if (newKnot > x[j] && newKnot <= x[j + 1]) {
+      i = j
+      foundIndex = true
+      break
+    }
+  }
+  if (!foundIndex) {
+    throw new Error('invalid new knot')
+  }
+
+  const xHat: number[] = []
+  for (let j = 0; j < n + k + 1; j++) {
+    if (j <= i) {
+      xHat[j] = x[j]
+    } else if (j === i + 1) {
+      xHat[j] = newKnot
+    } else {
+      xHat[j] = x[j - 1]
+    }
+  }
+
+  let alpha: number
+  const bHat: UtilPoint[] = []
+  for (let j = 0; j < n + 1; j++) {
+    if (j <= i - k + 1) {
+      alpha = 1
+    } else if (i - k + 2 <= j && j <= i) {
+      if (x[j + k - 1] - x[j] === 0) {
+        alpha = 0
+      } else {
+        alpha = (newKnot - x[j]) / (x[j + k - 1] - x[j])
+      }
+    } else {
+      alpha = 0
+    }
+
+    if (alpha === 0) {
+      bHat[j] = b[j - 1]
+    } else if (alpha === 1) {
+      bHat[j] = b[j]
+    } else {
+      bHat[j] = {
+        x: (1 - alpha) * b[j - 1].x + alpha * b[j].x,
+        y: (1 - alpha) * b[j - 1].y + alpha * b[j].y,
+      }
+    }
+  }
+  return { controlPoints: bHat, knots: xHat }
+}

package/src/util/logger.ts

@@ -0,0 +1,23 @@
+import config from '../config'
+
+function info(...args: any[]): void {
+  if (config.verbose) {
+    console.info(...args)
+  }
+}
+
+function warn(...args: any[]): void {
+  if (config.verbose) {
+    console.warn(...args)
+  }
+}
+
+function error(...args: any[]): void {
+  console.error(...args)
+}
+
+export default {
+  info,
+  warn,
+  error,
+}

package/src/util/rgbToColorAttribute.ts

@@ -0,0 +1,14 @@
+import type { ColorRGB } from './colors'
+
+/**
+ * Convert a ColorRGB tuple to a CSS string definition.
+ * Converts white lines to black as the default.
+ */
+export default function rgbToColorAttribute(rgb: ColorRGB): string {
+  const [r, g, b] = rgb
+  if (r === 255 && g === 255 && b === 255) {
+    return 'rgb(0, 0, 0)'
+  } else {
+    return `rgb(${r}, ${g}, ${b})`
+  }
+}

package/src/util/rotate.ts

@@ -0,0 +1,14 @@
+import { Point2D } from '../types'
+
+/**
+ * Rotate a point by the given angle.
+ *
+ * @param p the point
+ * @param angle the rotation angle in radians
+ */
+export default function rotate(p: Point2D, angle: number): Point2D {
+  return {
+    x: p.x * Math.cos(angle) - p.y * Math.sin(angle),
+    y: p.y * Math.cos(angle) + p.x * Math.sin(angle),
+  }
+}

package/src/util/round10.ts

@@ -0,0 +1,24 @@
+// This is based on the example code found from:
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor
+// Example code on MDN is public domain or CC0 (your preference) or MIT depending when the
+// example code was added:
+// https://developer.mozilla.org/en-US/docs/MDN/About
+
+export default function round10(value: number, exp?: number): number {
+  // If the exp is undefined or zero...
+  if (exp === undefined || +exp === 0) {
+    return Math.round(value)
+  }
+  const numValue = +value
+  const numExp = +exp
+  // If the value is not a number or the exp is not an integer...
+  if (Number.isNaN(numValue) || !(typeof numExp === 'number' && numExp % 1 === 0)) {
+    return Number.NaN
+  }
+  // Shift
+  let valueStr = numValue.toString().split('e')
+  const roundedValue = Math.round(+(valueStr[0] + 'e' + (valueStr[1] ? +valueStr[1] - numExp : -numExp)))
+  // Shift back
+  valueStr = roundedValue.toString().split('e')
+  return +(valueStr[0] + 'e' + (valueStr[1] ? +valueStr[1] + numExp : numExp))
+}

package/src/util/toPiecewiseBezier.ts

@@ -0,0 +1,70 @@
+import type { BezierResult, UtilPoint } from '../types/util-types'
+import insertKnot from './insertKnot'
+
+/**
+ * For a pinned spline, the knots have to be repeated k times
+ * (where k is the order), at both the beginning and the end
+ */
+export const checkPinned = (k: number, knots: number[]): void => {
+  // Pinned at the start
+  for (let i = 1; i < k; ++i) {
+    if (knots[i] !== knots[0]) {
+      throw new Error(`not pinned. order: ${k} knots: ${knots}`)
+    }
+  }
+  // Pinned at the end
+  for (let i = knots.length - 2; i > knots.length - k - 1; --i) {
+    if (knots[i] !== knots[knots.length - 1]) {
+      throw new Error(`not pinned. order: ${k} knots: ${knots}`)
+    }
+  }
+}
+
+export const multiplicity = (knots: number[], index: number): number => {
+  let m = 1
+  for (let i = index + 1; i < knots.length; ++i) {
+    if (knots[i] === knots[index]) {
+      ++m
+    } else {
+      break
+    }
+  }
+  return m
+}
+
+/**
+ * https://saccade.com/writing/graphics/KnotVectors.pdf
+ * A quadratic piecewise Bézier knot vector with seven control points
+ * will look like this [0 0 0 1 1 2 2 3 3 3]. In general, in a
+ * piecewise Bézier knot vector the first k knots are the same,
+ * then each subsequent group of k-1 knots is the same,
+ * until you get to the end.
+ */
+export const computeInsertions = (k: number, knots: number[]): number[] => {
+  const inserts: number[] = []
+  let i = k
+  while (i < knots.length - k) {
+    const knot = knots[i]
+    const m = multiplicity(knots, i)
+    for (let j = 0; j < k - m - 1; ++j) {
+      inserts.push(knot)
+    }
+    i = i + m
+  }
+  return inserts
+}
+
+export default function toPiecewiseBezier(
+  k: number,
+  controlPoints: UtilPoint[],
+  knots: number[]
+): BezierResult {
+  checkPinned(k, knots)
+  const insertions = computeInsertions(k, knots)
+  return insertions.reduce(
+    (acc, tNew) => {
+      return insertKnot(k, acc.controlPoints, acc.knots, tNew)
+    },
+    { controlPoints, knots },
+  )
+}