@jscad/dxf-deserializer 2.3.21 → 3.0.0-alpha.0

package/{instantiate.js → src/instantiate.js}

@@ -1,38 +1,31 @@
-/*
-## License
+import { arc, circle, ellipse, geom2, geom3, mat4, line, path2, poly3, vec2, vec3 } from '@jscad/modeling'
 
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
+import { getColor, getColorNumber } from './helpers.js'
 
-All code released under MIT license
-
-*/
-const { geometries, maths, primitives } = require('@jscad/modeling')
 const EPS = 1e-5 // FIXME
 
-const { getColor, getColorNumber } = require('./helpers')
-
 //
 // instantiate the given object (3dface) as a polygon
 //
-const instantiatePolygon = (obj, layers, options) => {
+export const instantiatePolygon = (obj, layers, options) => {
   const vertices = []
   // FIXME: should check global variable to instantiate in the proper orientation
-  vertices.push(maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz))
-  vertices.push(maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz))
-  vertices.push(maths.vec3.fromValues(obj.tptx, obj.tpty, obj.tptz))
+  vertices.push(vec3.fromValues(obj.pptx, obj.ppty, obj.pptz))
+  vertices.push(vec3.fromValues(obj.sptx, obj.spty, obj.sptz))
+  vertices.push(vec3.fromValues(obj.tptx, obj.tpty, obj.tptz))
   if (obj.fptx) {
     let pushit = false
     if (obj.tptx !== obj.fptx) { pushit = true }
     if (obj.tpty !== obj.fpty) { pushit = true }
     if (obj.tptz !== obj.fptz) { pushit = true }
     if (pushit) {
-      vertices.push(maths.vec3.fromValues(obj.fptx, obj.fpty, obj.fptz))
+      vertices.push(vec3.fromValues(obj.fptx, obj.fpty, obj.fptz))
     }
   }
   const cn = getColorNumber(obj, layers)
   const color = getColor(cn, options.colorindex)
 
-  const polygon = geometries.poly3.create(vertices)
+  const polygon = poly3.create(vertices)
   if (color) polygon.color = color
   return polygon
 }
@@ -43,21 +36,21 @@ const instantiatePolygon = (obj, layers, options) => {
 const instantiateLine = (obj, layers, options) => {
   // console.log('***** instantiateLine',obj)
   if (obj.pptz === obj.sptz && obj.pptz === 0) {
-    const p1 = maths.vec2.fromValues(obj.pptx, obj.ppty)
-    const p2 = maths.vec2.fromValues(obj.sptx, obj.spty)
-    return primitives.line([p1, p2])
+    const p1 = vec2.fromValues(obj.pptx, obj.ppty)
+    const p2 = vec2.fromValues(obj.sptx, obj.spty)
+    return line([p1, p2])
   }
 
-  const p1 = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
-  const p2 = maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
+  const p1 = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+  const p2 = vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
   // FIXME what should this really create?
-  return primitives.line([p1, p2])
+  return line([p1, p2])
 }
 
 //
 // instantiate the give object as 2D Vector or 3D Vector wrapped as an object
 //
-const instantiateVector = (obj) => {
+export const instantiateVector = (obj) => {
   const d3line = parseInt('00000000000100000', 2)
   const d3mesh = parseInt('00000000001000000', 2)
   const d3face = parseInt('00000000010000000', 2)
@@ -65,20 +58,20 @@ const instantiateVector = (obj) => {
   const flags = obj.lflg
   const vtype = {}
   if ((flags & d3line) === d3line) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
   } else
   if ((flags & d3mesh) === d3mesh) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
   } else
   if ((flags & d3face) === d3face) {
-    vtype.vec = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    vtype.vec = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
     // pass on face indexes
     vtype.fvia = obj.fvia
     vtype.fvib = obj.fvib
     vtype.fvic = obj.fvic
     vtype.fvid = obj.fvid
   } else {
-    vtype.vec = maths.vec2.fromValues(obj.pptx, obj.ppty)
+    vtype.vec = vec2.fromValues(obj.pptx, obj.ppty)
     vtype.bulg = obj.bulg // for rendering curved sections
   }
   return vtype
@@ -90,20 +83,20 @@ const instantiateVector = (obj) => {
 const addSection = (path, x1, y1, bulg) => {
   if (bulg === 0) {
   // add straight line to the end of the path
-    path = geometries.path2.appendPoints([[x1, y1]], path)
+    path = path2.appendPoints([[x1, y1]], path)
   } else {
   // add arc to the end of the path
-    const points = geometries.path2.toPoints(path)
+    const points = path2.toPoints(path)
     const prev = points[points.length - 1]
-    const curr = maths.vec2.fromValues(x1, y1)
-    const u = maths.vec2.distance(prev, curr)
+    const curr = vec2.fromValues(x1, y1)
+    const u = vec2.distance(prev, curr)
     const r = u * ((1 + Math.pow(bulg, 2)) / (4 * bulg))
     const clockwise = (bulg < 0)
     const large = false // FIXME how to determine?
     const d = Math.atan(bulg) * 4
     // FIXME; how to determine resolution
     const res = 16
-    path = geometries.path2.appendArc({ endpoint: [x1, y1], radius: [r, r], xaxisrotation: d, clockwise: clockwise, large: large, segments: res }, path)
+    path = path2.appendArc({ endpoint: [x1, y1], radius: [r, r], xaxisrotation: d, clockwise: clockwise, large: large, segments: res }, path)
   }
   return path
 }
@@ -123,7 +116,7 @@ const instantiatePath2D = (obj, layers, options) => {
   const flags = obj.lflg
 
   // conversion
-  let path = geometries.path2.create()
+  let path = path2.create()
   const isclosed = ((flags & closed) === closed)
   if (vlen === pptxs.length && vlen === pptys.length && vlen === bulgs.length) {
     pptxs.forEach((item, index, array) => {
@@ -140,7 +133,7 @@ const instantiatePath2D = (obj, layers, options) => {
   if (isclosed && (!path.isClosed)) {
   // apply the last section between last and first points
     path = addSection(path, pptxs[0], pptys[0], bulgs[vlen - 1])
-    path = geometries.path2.close(path)
+    path = path2.close(path)
     // FIXME add optional to create 2D geometry from the path
   }
   return path
@@ -166,10 +159,10 @@ const instantiateArc = (obj, layers, options) => {
   // conversion
   if (lthk === 0.0) {
     // convert to 2D object
-    return primitives.arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
+    return arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
   }
   // FIXME how to represent 3D arc?
-  return primitives.arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
+  return arc({ center: [pptx, ppty], radius: swid, startAngle: ang0, endAngle: ang1, segments: res })
 }
 
 //
@@ -191,12 +184,12 @@ const instantiateCircle = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    const cag = primitives.circle({ center: [pptx, ppty], radius: swid, segments: res })
+    const cag = circle({ center: [pptx, ppty], radius: swid, segments: res })
     if (color) cag.color = color
     return cag
   }
   // convert to 3D object
-  const cag = primitives.circle({ center: [pptx, ppty], radius: swid, segments: res })
+  const cag = circle({ center: [pptx, ppty], radius: swid, segments: res })
   const csg = cag.extrude({ offset: [0, 0, lthk] })
   // FIXME need to use 210/220/230 for direction of extrusion
   if (color) csg.color = color
@@ -220,19 +213,19 @@ const instantiateEllipse = (obj, layers, options) => {
 
   // convert to 2D object
   if (pptz === 0.0 && sptz === 0.0) {
-    const center = maths.vec2.fromValues(0, 0)
-    const mjaxis = maths.vec2.fromValues(sptx, spty)
-    const rx = maths.vec2.distance(center, mjaxis)
+    const center = vec2.fromValues(0, 0)
+    const mjaxis = vec2.fromValues(sptx, spty)
+    const rx = vec2.distance(center, mjaxis)
     const ry = rx * swid
     let angle = Math.atan2(spty, sptx) * 180 / Math.PI
     if (angle < EPS) angle = 0
     angle = angle * 0.017453292519943295 // radians
 
     // FIXME add start and end angle when supported
-    const cag = primitives.ellipse({ center: [0, 0], radius: [rx, ry], segments: res })
-    const matrix = maths.mat4.fromZRotation(maths.mat4.create(), angle)
-    maths.mat4.multiply(matrix, matrix, maths.mat4.fromTranslation(maths.mat4.create(), [pptx, ppty, 0]))
-    return geometries.geom2.transform(matrix, cag)
+    const cag = ellipse({ center: [0, 0], radius: [rx, ry], segments: res })
+    const matrix = mat4.fromZRotation(mat4.create(), angle)
+    mat4.multiply(matrix, matrix, mat4.fromTranslation(mat4.create(), [pptx, ppty, 0]))
+    return geom2.transform(matrix, cag)
   }
   // convert to 3D object
 }
@@ -297,7 +290,7 @@ const instantiateMesh = (obj, layers, options) => {
         let vi = 0
         while (vi < face.length) {
           const pi = face[vi]
-          const vertex = maths.vec3.clone(points[pi])
+          const vertex = vec3.clone(points[pi])
           vertices.push(vertex)
           vi++
         }
@@ -306,7 +299,7 @@ const instantiateMesh = (obj, layers, options) => {
         }
         // FIXME how to correct bad normals?
 
-        const poly = geometries.poly3.create(vertices)
+        const poly = poly3.create(vertices)
         if (color) poly.color = color
         polygons.push(poly)
 
@@ -318,7 +311,7 @@ const instantiateMesh = (obj, layers, options) => {
   } else {
     // invalid vlen
   }
-  return geometries.geom3.create(polygons)
+  return geom3.create(polygons)
 }
 
 // works for both POLYLINE
@@ -336,16 +329,16 @@ const getPolyType = (obj) => {
     ptype = null // FIXME what to do?
   } else
   if ((flags & d3mesh) === d3mesh) {
-    ptype = geometries.geom3.create()
+    ptype = geom3.create()
     ptype.closedM = ((flags & closedM) === closedM)
     ptype.closedN = ((flags & closedN) === closedN)
   } else
   if ((flags & d3face) === d3face) {
-    ptype = geometries.geom3.create()
+    ptype = geom3.create()
     ptype.closedM = ((flags & closedM) === closedM)
     ptype.closedN = ((flags & closedN) === closedN)
   } else {
-    ptype = geometries.path2.create()
+    ptype = path2.create()
     ptype.closedM = ((flags & closedM) === closedM)
   }
   if ('cnmb' in obj) { ptype.cnmb = obj.cnmb }
@@ -358,23 +351,23 @@ const getPolyType = (obj) => {
 // - a series of vertex => vectors => 2D geometry
 //
 const completeCurrent = (objects, baseobj, polygons, vectors, options) => {
-  if (geometries.path2.isA(baseobj)) {
+  if (path2.isA(baseobj)) {
     // console.log('##### completing 2D geometry')
     const points = vectors.map((vector) => vector.vec)
     // FIXME add color support
-    objects.push(geometries.path2.fromPoints({ closed: baseobj.closed }, points))
+    objects.push(path2.fromPoints({ closed: baseobj.closed }, points))
   }
-  if (geometries.geom3.isA(baseobj)) {
+  if (geom3.isA(baseobj)) {
     // console.log('##### completing 3D geometry')
     // FIXME add color support
-    objects.push(geometries.geom3.create(polygons))
+    objects.push(geom3.create(polygons))
   }
   return null
 }
 
-const instantiateAsciiDxf = (reader, options) => {
+export const instantiateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
-  // console.log(JSON.stringify(reader.objstack));
+  // console.log(JSON.stringify(reader.objstack))
   // console.log('**************************************************')
 
   const layers = [] // list of layers with various information like color
@@ -391,7 +384,7 @@ const instantiateAsciiDxf = (reader, options) => {
       // console.log('##### skip')
       continue
     }
-    // console.log(JSON.stringify(obj));
+    // console.log(JSON.stringify(obj))
 
     switch (obj.type) {
     // control objects
@@ -412,7 +405,7 @@ const instantiateAsciiDxf = (reader, options) => {
         p = instantiatePolygon(obj, layers, options)
         if (current === null) {
           // console.log('##### start of 3dfaces')
-          current = geometries.geom3.create()
+          current = geom3.create()
         }
         break
       case 'mesh':
@@ -470,7 +463,7 @@ const instantiateAsciiDxf = (reader, options) => {
         break
     }
     // accumlate polygons if necessary
-    if (geometries.poly3.isA(p)) {
+    if (poly3.isA(p)) {
       polygons.push(p)
     }
     // accumlate vectors if necessary
@@ -488,15 +481,9 @@ const instantiateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
   // objects.forEach(
   //   (e) => {
-  //     console.log(JSON.stringify(e));
+  //     console.log(JSON.stringify(e))
   //   }
-  // );
+  // )
   // console.log('**************************************************')
   return objects
 }
-
-module.exports = {
-  instantiatePolygon,
-  instantiateVector,
-  instantiateAsciiDxf
-}

package/{translate.js → src/translate.js}

@@ -1,16 +1,8 @@
-/*
-## License
+import { poly3, vec2, vec3 } from '@jscad/modeling'
 
-Copyright (c) 2017-2019 Z3 Development https://github.com/z3dev
+import { instantiatePolygon, instantiateVector } from './instantiate.js'
 
-All code released under MIT license
-
-*/
-const { maths, geometries } = require('@jscad/modeling')
-
-const { instantiatePolygon, instantiateVector } = require('./instantiate')
-
-const { findLayer, getColor, getColorNumber } = require('./helpers')
+import { findLayer, getColor, getColorNumber } from './helpers.js'
 
 //
 // translate the give 2D vector to JSCAD script
@@ -32,7 +24,7 @@ const translateVector3D = (vector) => {
 // translate the given polygon into JSCAD script
 //
 const translatePolygon = (polygon) => {
-  const vertices = geometries.poly3.toPoints(polygon)
+  const vertices = poly3.toVertices(polygon)
   let script = 'createPolygon(['
   vertices.forEach((vertice) => {
     script += `[${translateVector3D(vertice)}],`
@@ -64,16 +56,16 @@ const translateLine = (obj, layers, options) => {
 
   let script = ''
   if (!obj.pptz || (obj.pptz === obj.sptz && obj.pptz === 0)) {
-    const p1 = maths.vec2.fromValues(obj.pptx, obj.ppty)
-    const p2 = maths.vec2.fromValues(obj.sptx, obj.spty)
-    script = `  let ${name} = primitives.line([[${translateVector2D(p1)}],[${translateVector2D(p2)}]])\n`
+    const p1 = vec2.fromValues(obj.pptx, obj.ppty)
+    const p2 = vec2.fromValues(obj.sptx, obj.spty)
+    script = `  let ${name} = line([[${translateVector2D(p1)}],[${translateVector2D(p2)}]])\n`
   } else {
-    const p1 = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
-    const p2 = maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
-    script = `  let ${name} = primitives.line([[${translateVector3D(p1)}],[${translateVector3D(p2)}]])\n`
+    const p1 = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    const p2 = vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
+    script = `  let ${name} = line([[${translateVector3D(p1)}],[${translateVector3D(p2)}]])\n`
   }
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -86,21 +78,21 @@ const translateSection = (name, x1, y1, bulg, px, py) => {
   // console.log('translateSection',x1,y1,bulg,px,py)
   if (bulg === 0) {
   // add straight line to the end of the path
-    return `geometries.path2.appendPoints([[${x1},${y1}]], ${name})
+    return `path2.appendPoints([[${x1},${y1}]], ${name})
 `
   }
 
   // add arc to the end of the path
-  const prev = maths.vec2.fromValues(px, py)
-  const curr = maths.vec2.fromValues(x1, y1)
-  const u = maths.vec2.distance(prev, curr)
+  const prev = vec2.fromValues(px, py)
+  const curr = vec2.fromValues(x1, y1)
+  const u = vec2.distance(prev, curr)
   const r = u * ((1 + Math.pow(bulg, 2)) / (4 * bulg))
   const clockwise = (bulg < 0)
   const large = false // FIXME how to determine?
   const d = Math.atan(bulg) * 4
   // FIXME need to determine segments from object/layer/variables
   const res = 16
-  return `geometries.path2.appendArc({endpoint: [${x1},${y1}],radius: [${r},${r}],xaxisrotation: ${d},clockwise: ${clockwise},large: ${large},segments: ${res}}, ${name})
+  return `path2.appendArc({endpoint: [${x1},${y1}],radius: [${r},${r}],xaxisrotation: ${d},clockwise: ${clockwise},large: ${large},segments: ${res}}, ${name})
 `
 }
 
@@ -122,11 +114,11 @@ const translatePath2D = (obj, layers, options) => {
   const color = getColor(cn, options.colorindex)
 
   // translation
-  let script = `  let ${name} = geometries.path2.create()\n`
+  let script = `  let ${name} = path2.create()\n`
   const isclosed = ((flags & closed) === closed)
   if (vlen === pptxs.length && vlen === pptys.length && vlen === bulgs.length) {
     // add initial point
-    script += `  ${name} = geometries.path2.appendPoints([[${pptxs[0]}, ${pptys[0]}]], ${name})\n`
+    script += `  ${name} = path2.appendPoints([[${pptxs[0]}, ${pptys[0]}]], ${name})\n`
     // add sections
     for (let i = 0; i < pptxs.length; i++) {
       const j = (i + 1) % pptxs.length
@@ -149,12 +141,12 @@ const translatePath2D = (obj, layers, options) => {
     return
   }
   if (isclosed) {
-    script += `  ${name} = geometries.path2.close(${name})\n`
+    script += `  ${name} = path2.close(${name})\n`
   } else {
     script += '\n'
   }
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -186,18 +178,18 @@ const translateArc = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    let script = `  let ${name} = primitives.arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
+    let script = `  let ${name} = arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
     return
   }
   // FIXME how to represent 3D arc?
-  let script = `  let ${name} = primitives.arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
+  let script = `  let ${name} = arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -223,9 +215,9 @@ const translateCircle = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    let script = `  let ${name} = primitives.circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}})\n`
+    let script = `  let ${name} = circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}})\n`
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
@@ -233,9 +225,9 @@ const translateCircle = (obj, layers, options) => {
   }
 
   // convert to 3D object
-  let script = `  let ${name} = primitives.circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}}).extrude({offset: [0,0,${lthk}]}))\n`
+  let script = `  let ${name} = circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}}).extrude({offset: [0,0,${lthk}]}))\n`
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
 
   // FIXME need to use 210/220/230 for direction of rotation
@@ -265,19 +257,19 @@ const translateEllipse = (obj, layers, options) => {
 
   // convert to 2D object
   if (pptz === 0.0 && sptz === 0.0) {
-    const center = maths.vec2.fromValues(0, 0)
-    const mjaxis = maths.vec2.fromValues(sptx, spty)
-    const rx = maths.vec2.distance(center, mjaxis)
+    const center = vec2.fromValues(0, 0)
+    const mjaxis = vec2.fromValues(sptx, spty)
+    const rx = vec2.distance(center, mjaxis)
     const ry = rx * swid
     const angle = Math.atan2(spty, sptx) // * 180 / Math.PI
     // FIXME add start and end angle when supported
 
-    let script = `  let ${name} = primitives.ellipse({center: [0, 0, 0], radius: [${rx}, ${ry}], segments: ${res}})
-  let ${name}matrix = maths.mat4.multiply(maths.mat4.create(), maths.mat4.fromTranslation(maths.mat4.create(), [${pptx}, ${ppty}, 0]), maths.mat4.fromZRotation(maths.mat4.create(), ${angle}))
-  ${name} = geometries.geom2.transform(${name}matrix, ${name})
+    let script = `  let ${name} = ellipse({center: [0, 0, 0], radius: [${rx}, ${ry}], segments: ${res}})
+  let ${name}matrix = mat4.multiply(mat4.create(), mat4.fromTranslation(mat4.create(), [${pptx}, ${ppty}, 0]), mat4.fromZRotation(mat4.create(), ${angle}))
+  ${name} = geom2.transform(${name}matrix, ${name})
 `
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
@@ -345,7 +337,7 @@ const translateMesh = (obj, layers, options) => {
         let vi = 0
         while (vi < face.length) {
           const pi = face[vi]
-          const vector = maths.vec3.clone(points[pi])
+          const vector = vec3.clone(points[pi])
           vertices.push(vector)
           vi++
         }
@@ -354,7 +346,7 @@ const translateMesh = (obj, layers, options) => {
         }
         // FIXME how to correct bad normals?
 
-        const poly = geometries.poly3.create(vertices)
+        const poly = poly3.create(vertices)
         if (color) poly.color = color
         polygons.push(poly)
 
@@ -374,7 +366,7 @@ const translateMesh = (obj, layers, options) => {
     script += '    ' + translatePolygon(polygon) + ',\n'
   }
   script += `  ]
-  let ${name} = geometries.geom3.create(${name}_polygons)
+  let ${name} = geom3.create(${name}_polygons)
 `
   obj.script = script
   addToLayer(obj, layers)
@@ -497,8 +489,8 @@ const instantiateFacets = (meshM, meshN, parts, color, options) => {
       if (options.dxf.angdir === 1) {
         facet = facet.reverse()
       }
-      const polygon = geometries.poly3.create(facet)
-      const plane = geometries.poly3.plane(polygon)
+      const polygon = poly3.create(facet)
+      const plane = poly3.plane(polygon)
       if (Number.isFinite(plane[3])) {
         if (color) polygon.color = color
         facets.push(polygon)
@@ -556,7 +548,7 @@ const instantiatePolyFaces = (meshM, meshN, parts, color, options) => {
       if (options.dxf.angdir === 1) {
         vertices = vertices.reverse()
       }
-      const polygon = geometries.poly3.create(vertices)
+      const polygon = poly3.create(vertices)
       faces.push(polygon)
     }
     i++
@@ -640,7 +632,7 @@ const translateCurrent = (obj, layers, parts, options) => {
     script += '    ' + translatePolygon(polygon) + ',\n'
   }
   script += `  ]
-  let ${name} = geometries.geom3.create(${name}_polygons)
+  let ${name} = geom3.create(${name}_polygons)
 `
   if (color) {
     script += `  ${name}.color = [${color}]
@@ -657,7 +649,7 @@ const translateCurrent = (obj, layers, parts, options) => {
 const translateLayer = (layer) => {
   const name = layer.lnam || 'Unknown'
 
-  let script = `function ${name}() {
+  let script = `const ${name} = () => {
 `
   for (const object of layer.objects) {
     script += object.script
@@ -685,7 +677,7 @@ const saveVariable = (obj, options) => {
   }
 }
 
-const translateAsciiDxf = (reader, options) => {
+export const translateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
   // console.log(JSON.stringify(reader.objstack))
   // console.log('**************************************************')
@@ -815,28 +807,23 @@ const translateAsciiDxf = (reader, options) => {
         break
     }
     // accumlate polygons if necessary
-    if (geometries.poly3.isA(p)) {
-      // console.log('##### push Polygon')
+    if (poly3.isA(p)) {
       parts.push(p)
     }
     // accumlate vectors if necessary
     if (p && 'vec' in p && p.vec.length === 3) {
-      // console.log('##### push vec3')
       parts.push(p)
     }
     if (p && 'vec' in p && p.vec.length === 2) {
-      // console.log('##### push vec2')
       parts.push(p)
     }
   }
   // translate the last object if necessary
   current = translateCurrent(current, layers, parts, options)
 
-  // debug output
-  // console.log('**************************************************')
-  let script = `const {colors, geometries, maths, primitives, transforms} = require('@jscad/modeling')
+  let script = `import * from '@jscad/modeling'
 
-const main = () => {
+export const main = () => {
   let layers = []
   return layers.concat(`
 
@@ -849,10 +836,9 @@ const main = () => {
   // add helper functions for polygons and lines
   script +=
 `
-function createPolygon(listofpoints, color) {
-  let polygon = geometries.poly3.fromPoints(listofpoints)
-  if (color) polygon.color = color
-  return polygon
+const createPolygon = (listofpoints, color) => {
+  let polygon = poly3.create(listofpoints)
+  return colorize(color, polygon)
 }
 `
 
@@ -860,11 +846,5 @@ function createPolygon(listofpoints, color) {
     script += translateLayer(layer)
   })
 
-  script += 'module.exports = {main}\n'
-
-  // console.log(script)
-  // console.log('**************************************************')
   return script
 }
-
-module.exports = translateAsciiDxf