Преобразование дуги пути SVG в DXF

// arc command values
let p0 = {
  x: 20,
  y: 25
}
let values = [1, 3, 45, 0, 0, 50, 50]
let vertices = 12;


let polylinePts = arcToPolyline(p0, values, vertices)
//render polyline
polyline.setAttribute('points', polylinePts.map(pt => {
  return `${pt.x} ${pt.y}`
}))


function arcToPolyline(p0, values, vertices = 12) {
  let [rxC, ryC, xAxisRotation, largeArc, sweep, x, y] = values;

  // parametrize arc command to get actual rx,ry and center
  let param = svgArcToCenterParam(p0.x, p0.y, rxC, ryC, xAxisRotation, largeArc, sweep, x, y);
  let {
    cx,
    cy,
    rx,
    ry,
    startAngle,
    deltaAngle,
    endAngle
  } = param;
  let splitAngle = deltaAngle / vertices;

  let pts = []
  for (let i = 0; i <= vertices; i++) {
    let angle = startAngle - splitAngle * i;
    let xAxisRotation_radian = xAxisRotation * Math.PI / 180;
    let pt = getEllipsePointForAngle(cx, cy, rx, ry, xAxisRotation_radian, deltaAngle + angle)
    pts.push(pt)
  }
  return pts;
}


/**
 * based on @cuixiping;
 * https://stackoverflow.com/questions/9017100/calculate-center-of-svg-arc/12329083#12329083
 */
function svgArcToCenterParam(p0x, p0y, rx, ry, angle, largeArc, sweep, px, py) {
  const radian = (ux, uy, vx, vy) => {
    let dot = ux * vx + uy * vy;
    let mod = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
    let rad = Math.acos(dot / mod);
    if (ux * vy - uy * vx < 0) {
      rad = -rad;
    }
    return rad;
  };
  // degree to radian – if rx equals ry the x-axis rotation has no effect
  let phi = rx === ry ? 0 : (angle * Math.PI) / 180;
  let cx, cy, startAngle, deltaAngle, endAngle;
  let PI = Math.PI;
  //let PIpx = PI * 2;

  // invalid arguments
  if (rx == 0 || ry == 0) {
    throw Error("rx and ry can not be 0");
  }
  if (rx < 0) {
    rx = -rx;
  }
  if (ry < 0) {
    ry = -ry;
  }
  let s_phi = Math.sin(phi);
  let c_phi = Math.cos(phi);
  let hd_x = (p0x - px) / 2; // half diff of x
  let hd_y = (p0y - py) / 2; // half diff of y
  let hs_x = (p0x + px) / 2; // half sum of x
  let hs_y = (p0y + py) / 2; // half sum of y
  // F6.5.1
  let p0x_ = c_phi * hd_x + s_phi * hd_y;
  let p0y_ = c_phi * hd_y - s_phi * hd_x;
  // F.6.6 Correction of out-of-range radii
  //   Step 3: Ensure radii are large enough
  let lambda = (p0x_ * p0x_) / (rx * rx) + (p0y_ * p0y_) / (ry * ry);
  if (lambda > 1) {
    rx = rx * Math.sqrt(lambda);
    ry = ry * Math.sqrt(lambda);
  }
  let rxry = rx * ry;
  let rxp0y_ = rx * p0y_;
  let ryp0x_ = ry * p0x_;
  let sum_of_sq = rxp0y_ * rxp0y_ + ryp0x_ * ryp0x_; // sum of square
  if (!sum_of_sq) {
    console.info("start point can not be same as end point");
  }
  let coe = Math.sqrt(Math.abs((rxry * rxry - sum_of_sq) / sum_of_sq));
  if (largeArc == sweep) {
    coe = -coe;
  }
  // F6.5.2
  let cx_ = (coe * rxp0y_) / ry;
  let cy_ = (-coe * ryp0x_) / rx;
  // F6.5.3
  cx = c_phi * cx_ - s_phi * cy_ + hs_x;
  cy = s_phi * cx_ + c_phi * cy_ + hs_y;
  let xcr1 = (p0x_ - cx_) / rx;
  let xcr2 = (p0x_ + cx_) / rx;
  let ycr1 = (p0y_ - cy_) / ry;
  let ycr2 = (p0y_ + cy_) / ry;
  // F6.5.5
  startAngle = radian(1, 0, xcr1, ycr1);
  // F6.5.6
  deltaAngle = radian(xcr1, ycr1, -xcr2, -ycr2);
  if (deltaAngle > PI * 2) {
    deltaAngle -= PI * 2;
  } else if (deltaAngle < 0) {
    deltaAngle += PI * 2;
  }
  if (sweep == false || sweep == 0) {
    deltaAngle -= PI * 2;
  }
  endAngle = startAngle + deltaAngle;
  if (endAngle > PI * 2) {
    endAngle -= PI * 2;
  } else if (endAngle < 0) {
    endAngle += PI * 2;
  }
  let outputObj = {
    cx: cx,
    cy: cy,
    rx: rx,
    ry: ry,
    startAngle: startAngle,
    deltaAngle: deltaAngle,
    endAngle: endAngle,
    sweep: sweep
  };
  return outputObj;
}



/*
 * based on
 * https://source.chromium.org/chromium/chromium/src/+/main:third_party/skia/modules/canvaskit/htmlcanvas/path2d.js
 * and https://observablehq.com/@toja/ellipse-and-elliptical-arc-conversion
 */

function getEllipsePointForAngle(cx, cy, rx, ry, rotation_angle, angle) {
  let M = Math.abs(rx) * Math.cos(angle),
    N = Math.abs(ry) * Math.sin(angle);
  return {
    x: cx + Math.cos(rotation_angle) * M - Math.sin(rotation_angle) * N,
    y: cy + Math.sin(rotation_angle) * M + Math.cos(rotation_angle) * N
  };
}

svg {
  overflow: visible;
  border: 1px solid #ccc;
}

<svg id = "svg" viewBox = "-9 0 100 100">
  <path id = "path" d = "M 10 10
          L 20 25
          A 1 3 45 0 0 50 50
          L 90 90
          V 80 
          Z" fill = "none" stroke = "#000" />
  <polyline id = "polyline" fill = "none" stroke = "red"></polyline>
</svg>

var m = require("makerjs");

var pathData = `M10,10L20,25 A1,3,0,0,0,50,50L90,90V80Z`;
var path =  m.importer.fromSVGPathData(pathData)

// convert to maker.js model object
var model = {models: {path}}

//export
var dxf = m.exporter.toDXF(model)
outputDxf.value=dxf;

textarea{
  display:block;
  width:100%;
  min-height:50vmin
}

<script src = "https://cdn.jsdelivr.net/npm/makerjs@0/target/js/browser.maker.js"></script>
<script src = "https://cdn.jsdelivr.net/npm/bezier-js@2/bezier.js"></script>


<h3>DXF</h3>
<textarea id = "outputDxf"></textarea>