@jscad/x3d-deserializer 2.2.10 → 3.0.1-alpha.0

package/src/objects.js

@@ -1,6 +1,6 @@
-const { maths } = require('@jscad/modeling')
+import { area } from '@jscad/modeling'
 
-const x3dTypes = {
+export const x3dTypes = {
   X3D: 0,
   UNIT: 1,
   META: 2,
@@ -43,14 +43,14 @@ const x3dTypes = {
 }
 
 // document level node, basically a group
-const x3dX3D = (element) => {
+export const x3dX3D = (element) => {
   const obj = { definition: x3dTypes.X3D }
 
   obj.objects = []
   return obj
 }
 
-const x3dUnit = (element) => {
+export const x3dUnit = (element) => {
   const obj = { definition: x3dTypes.UNIT, category: '', name: '', conversionFactor: 1.0 }
 
   if (element.category) obj.category = element.category
@@ -60,7 +60,7 @@ const x3dUnit = (element) => {
   return obj
 }
 
-const x3dMeta = (element) => {
+export const x3dMeta = (element) => {
   const obj = { definition: x3dTypes.META, content: '', name: '' }
 
   if (element.content) obj.content = element.content
@@ -70,7 +70,7 @@ const x3dMeta = (element) => {
 }
 
 // scenes contain various other nodes, basically a group
-const x3dScene = (element) => {
+export const x3dScene = (element) => {
   const obj = { definition: x3dTypes.SCENE }
   obj.objects = []
   return obj
@@ -78,7 +78,7 @@ const x3dScene = (element) => {
 
 // transforms contain various other nodes, basically a group
 // horrific order of transforms... see http://edutechwiki.unige.ch/en/X3D_grouping_and_transforms
-const x3dTransform = (element) => {
+export const x3dTransform = (element) => {
   const obj = {
     definition: x3dTypes.TRANSFORM,
     center: [0, 0, 0],
@@ -124,7 +124,7 @@ const x3dTransform = (element) => {
 }
 
 // shapes contain geometry and appearance, in any order
-const x3dShape = (element) => {
+export const x3dShape = (element) => {
   const obj = { definition: x3dTypes.SHAPE }
   obj.objects = []
   return obj
@@ -134,7 +134,7 @@ const x3dShape = (element) => {
 // 3D shapes
 //
 
-const x3dBox = (element) => {
+export const x3dBox = (element) => {
   const obj = { definition: x3dTypes.BOX, size: [2, 2, 2] }
 
   if (element.size) {
@@ -146,7 +146,7 @@ const x3dBox = (element) => {
   return obj
 }
 
-const x3dCone = (element) => {
+export const x3dCone = (element) => {
   const NEAR0 = 0.00001
   const obj = { definition: x3dTypes.CONE, bottomRadius: 1, height: 2, subdivision: 32, topRadius: NEAR0 }
 
@@ -165,7 +165,7 @@ const x3dCone = (element) => {
   return obj
 }
 
-const x3dCylinder = (element) => {
+export const x3dCylinder = (element) => {
   const obj = { definition: x3dTypes.CYLINDER, height: 2, radius: 1, subdivision: 32 }
 
   if (element.height) {
@@ -180,7 +180,7 @@ const x3dCylinder = (element) => {
   return obj
 }
 
-const x3dSphere = (element) => {
+export const x3dSphere = (element) => {
   const obj = { definition: x3dTypes.SPHERE, radius: 1, subdivision: 24 }
 
   if (element.radius) {
@@ -195,7 +195,7 @@ const x3dSphere = (element) => {
   return obj
 }
 
-const x3dExtrusion = (element) => {
+export const x3dExtrusion = (element) => {
   const obj = {
     definition: x3dTypes.EXTRUSION,
     ccw: true,
@@ -224,7 +224,7 @@ const x3dExtrusion = (element) => {
       const vi = i * 2
       points.push([values[vi], values[vi + 1]])
     }
-    obj.ccw = (maths.utils.area(points) < 0) // WHAT!!!! X3D IS SICK!!!
+    obj.ccw = (area(points) < 0) // WHAT!!!! X3D IS SICK!!!
     obj.crossSection = points
   }
   if (element.orientation) {
@@ -267,7 +267,7 @@ const x3dExtrusion = (element) => {
 // 2D shapes
 //
 
-const x3dArc2D = (element) => {
+export const x3dArc2D = (element) => {
   const obj = { definition: x3dTypes.ARC2D, endAngle: Math.PI / 2, radius: 1, startAngle: 0, subdivision: 32 }
 
   if (element.endAngle) {
@@ -285,7 +285,7 @@ const x3dArc2D = (element) => {
   return obj
 }
 
-const x3dArcClose2D = (element) => {
+export const x3dArcClose2D = (element) => {
   const obj = { definition: x3dTypes.ARCCLOSE2D, closureType: 'PIE', endAngle: Math.PI / 2, radius: 1, startAngle: 0, subdivision: 32 }
 
   if (element.closureType) {
@@ -306,7 +306,7 @@ const x3dArcClose2D = (element) => {
   return obj
 }
 
-const x3dCircle2D = (element) => {
+export const x3dCircle2D = (element) => {
   const obj = { definition: x3dTypes.CIRCLE2D, radius: 1, subdivision: 32 }
 
   if (element.radius) {
@@ -318,7 +318,7 @@ const x3dCircle2D = (element) => {
   return obj
 }
 
-const x3dDisk2D = (element) => {
+export const x3dDisk2D = (element) => {
   const obj = { definition: x3dTypes.DISK2D, innerRadius: 0, outerRadius: 1, subdivision: 32 }
 
   if (element.innerRadius) {
@@ -333,7 +333,7 @@ const x3dDisk2D = (element) => {
   return obj
 }
 
-const x3dPolyline2D = (element) => {
+export const x3dPolyline2D = (element) => {
   const obj = { definition: x3dTypes.POLYLINE2D, lineSegments: [] }
 
   if (element.lineSegments) {
@@ -346,7 +346,7 @@ const x3dPolyline2D = (element) => {
   return obj
 }
 
-const x3dRectangle2D = (element) => {
+export const x3dRectangle2D = (element) => {
   const obj = { definition: x3dTypes.RECTANGLE2D, size: [2, 2] }
 
   if (element.size) {
@@ -358,7 +358,7 @@ const x3dRectangle2D = (element) => {
   return obj
 }
 
-const x3dTriangleSet2D = (element) => {
+export const x3dTriangleSet2D = (element) => {
   const obj = { definition: x3dTypes.TRIANGLESET2D, vertices: [] }
 
   if (element.vertices) {
@@ -375,7 +375,7 @@ const x3dTriangleSet2D = (element) => {
 // Lines
 //
 
-const x3dLineSet = (element) => {
+export const x3dLineSet = (element) => {
   const obj = { definition: x3dTypes.LINESET, vertexCount: [], colorPerVertex: true }
 
   if (element.vertexCount) {
@@ -389,7 +389,7 @@ const x3dLineSet = (element) => {
   return obj
 }
 
-const x3dIndexedLineSet = (element) => {
+export const x3dIndexedLineSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDLINESET, indexes: [], colorPerVertex: true }
 
   if (element.coordIndex) {
@@ -408,7 +408,7 @@ const x3dIndexedLineSet = (element) => {
 // Meshs
 //
 
-const x3dColor = (element) => {
+export const x3dColor = (element) => {
   const obj = { definition: x3dTypes.COLOR, colors: [] }
 
   if (element.color) {
@@ -423,7 +423,7 @@ const x3dColor = (element) => {
   return obj
 }
 
-const x3dCoordinate = (element) => {
+export const x3dCoordinate = (element) => {
   const obj = { definition: x3dTypes.COORDINATE, points: [] }
 
   if (element.point) {
@@ -438,7 +438,7 @@ const x3dCoordinate = (element) => {
   return obj
 }
 
-const x3dTriangleSet = (element) => {
+export const x3dTriangleSet = (element) => {
   const obj = { definition: x3dTypes.TRIANGLESET, ccw: true, colorPerVertex: true }
 
   if (element.ccw) {
@@ -448,7 +448,7 @@ const x3dTriangleSet = (element) => {
   return obj
 }
 
-const x3dTriangleFanSet = (element) => {
+export const x3dTriangleFanSet = (element) => {
   const obj = { definition: x3dTypes.TRIANGLEFANSET, ccw: true, fanCount: [], colorPerVertex: true }
 
   if (element.ccw) {
@@ -461,7 +461,7 @@ const x3dTriangleFanSet = (element) => {
   return obj
 }
 
-const x3dTriangleStripSet = (element) => {
+export const x3dTriangleStripSet = (element) => {
   const obj = { definition: x3dTypes.TRIANGLESTRIPSET, ccw: true, stripCount: [], colorPerVertex: true }
 
   if (element.ccw) {
@@ -474,7 +474,7 @@ const x3dTriangleStripSet = (element) => {
   return obj
 }
 
-const x3dQuadSet = (element) => {
+export const x3dQuadSet = (element) => {
   const obj = { definition: x3dTypes.QUADSET, ccw: true, colorPerVertex: true }
 
   if (element.ccw) {
@@ -484,7 +484,7 @@ const x3dQuadSet = (element) => {
   return obj
 }
 
-const x3dIndexedTriangleSet = (element) => {
+export const x3dIndexedTriangleSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDTRIANGLESET, ccw: true, index: [], colorPerVertex: true }
 
   if (element.ccw) {
@@ -497,7 +497,7 @@ const x3dIndexedTriangleSet = (element) => {
   return obj
 }
 
-const x3dIndexedTriangleFanSet = (element) => {
+export const x3dIndexedTriangleFanSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDTRIANGLEFANSET, ccw: true, fans: [], colorPerVertex: true }
 
   if (element.ccw) {
@@ -511,7 +511,7 @@ const x3dIndexedTriangleFanSet = (element) => {
   return obj
 }
 
-const x3dIndexedTriangleStripSet = (element) => {
+export const x3dIndexedTriangleStripSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDTRIANGLESTRIPSET, ccw: true, strips: [], colorPerVertex: true }
 
   obj.objects = []
@@ -525,7 +525,7 @@ const x3dIndexedTriangleStripSet = (element) => {
   return obj
 }
 
-const x3dIndexedQuadSet = (element) => {
+export const x3dIndexedQuadSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDQUADSET, ccw: true, index: [], colorPerVertex: true }
 
   if (element.ccw) {
@@ -538,7 +538,7 @@ const x3dIndexedQuadSet = (element) => {
   return obj
 }
 
-const x3dIndexedFaceSet = (element) => {
+export const x3dIndexedFaceSet = (element) => {
   const obj = { definition: x3dTypes.INDEXEDFACESET, ccw: true, convex: true, faces: [], colorPerVertex: true, colorIndex: null }
 
   if (element.ccw) {
@@ -572,7 +572,7 @@ const x3dIndexedFaceSet = (element) => {
   return obj
 }
 
-const x3dElevationGrid = (element) => {
+export const x3dElevationGrid = (element) => {
   const obj = { definition: x3dTypes.ELEVATIONGRID, xDimension: 2, zDimension: 2, xSpacing: 1.0, zSpacing: 1.0, height: [0, 0, 0, 0], ccw: true, solid: false, colorPerVertex: true }
 
   if (element.xDimension) {
@@ -609,14 +609,14 @@ const x3dElevationGrid = (element) => {
 // Materials
 //
 
-const x3dAppearance = (element) => {
+export const x3dAppearance = (element) => {
   const obj = { definition: x3dTypes.APPEARANCE }
 
   obj.objects = []
   return obj
 }
 
-const x3dMaterial = (element) => {
+export const x3dMaterial = (element) => {
   const obj = { definition: x3dTypes.MATERIAL, color: [0.8, 0.8, 0.8, 1.0] }
 
   // convert material to colors if possible
@@ -649,62 +649,17 @@ const x3dMaterial = (element) => {
 
 // GROUPS
 
-const x3dGroup = (element) => {
+export const x3dGroup = (element) => {
   const obj = { definition: x3dTypes.GROUP }
 
   obj.objects = []
   return obj
 }
 
-const parseNumbers = (attribute) =>
+export const parseNumbers = (attribute) =>
   attribute.trim().replace(/,/g, ' ').split(/ +/).map((v) => parseFloat(v))
 
-const parseIndices = (attribute) => {
+export const parseIndices = (attribute) => {
   const indexes = attribute.replace(/,/g, ' ').trim().split(/ -1/)
   return indexes.map((index) => parseNumbers(index))
 }
-
-module.exports = {
-  x3dTypes,
-
-  x3dX3D,
-  x3dUnit,
-  x3dMeta,
-  x3dScene,
-  x3dTransform,
-  x3dShape,
-  x3dGroup,
-
-  x3dBox,
-  x3dCone,
-  x3dCylinder,
-  x3dSphere,
-  x3dExtrusion,
-
-  x3dArc2D,
-  x3dArcClose2D,
-  x3dCircle2D,
-  x3dDisk2D,
-  x3dPolyline2D,
-  x3dRectangle2D,
-  x3dTriangleSet2D,
-
-  x3dColor,
-  x3dCoordinate,
-  x3dTriangleSet,
-  x3dTriangleFanSet,
-  x3dTriangleStripSet,
-  x3dQuadSet,
-  x3dIndexedTriangleSet,
-  x3dIndexedTriangleFanSet,
-  x3dIndexedTriangleStripSet,
-  x3dIndexedQuadSet,
-  x3dIndexedFaceSet,
-  x3dElevationGrid,
-
-  x3dLineSet,
-  x3dIndexedLineSet,
-
-  x3dAppearance,
-  x3dMaterial
-}

package/src/parse.js

@@ -1,6 +1,6 @@
-const saxes = require('saxes')
+import * as saxes from 'saxes'
 
-const {
+import {
   x3dTypes,
 
   x3dX3D,
@@ -43,7 +43,7 @@ const {
 
   x3dAppearance,
   x3dMaterial
-} = require('./objects')
+} from './objects.js'
 
 const nodeToObjectMap = {
   X3D: x3dX3D,
@@ -92,34 +92,33 @@ const nodeToObjectMap = {
 let objectId = 1
 const getObjectId = () => ('0000' + objectId++).slice(-4)
 
-const createX3DParser = (src, pxPmm) => {
+export const parse = (src) => {
   // create a parser for the XML
   const parser = new saxes.SaxesParser()
-  const x3dDefs = new Map() // list of named objects
-  let x3dLast = null // last object found
-  let x3dDefinition = x3dTypes.X3D // what kind of object beinging created
-  let x3dObj = null // x3d in object form
 
   // high level elements / definitions
+  let x3dLast = null // last object found
+  let x3dDefinition = x3dTypes.X3D // what kind of object being created
+
   const x3dObjects = [] // list of objects
+  const x3dDefs = new Map() // list of named objects
+
   const x3dMaterials = [] // list of materials
   const x3dTextures = [] // list of textures
 
   const x3dLength = { factor: 1.0, name: 'meters' }
   const x3dAngle = { factor: 1.0, name: 'radians' }
 
+  let x3dObj = null // x3d in object form
+
   parser.on('error', (e) => {
-    console.log(
-      `error: line ${e.line}, column ${e.column}, bad character [${e.c}]`
-    )
+    console.log(`error: line ${e.line}, column ${e.column}, bad character [${e.c}]`)
   })
 
   parser.on('opentag', (node) => {
     // convert known XML tags to objects
     const elementname = node.name.toUpperCase()
-    let obj = nodeToObjectMap[elementname]
-      ? nodeToObjectMap[elementname](node.attributes, { x3dObjects })
-      : null
+    let obj = nodeToObjectMap[elementname] ? nodeToObjectMap[elementname](node.attributes, { x3dObjects }) : null
 
     if (obj) {
       obj.id = getObjectId()
@@ -130,23 +129,17 @@ const createX3DParser = (src, pxPmm) => {
         if (x3dDefs.has(objectname)) {
           const def = x3dDefs.get(objectname)
           if (def.definition !== obj.definition) {
-            console.log(
-              `WARNING: using a definition "${objectname}" of a different type; ${obj.definition} vs ${def.definition}`
-            )
+            console.log(`WARNING: using a definition "${objectname}" of a different type; ${obj.definition} vs ${def.definition}`)
           }
           obj = def
         } else {
-          console.log(
-            `WARNING: definition "${objectname}" does not exist, using default for ${obj.definition}`
-          )
+          console.log(`WARNING: definition "${objectname}" does not exist, using default for ${obj.definition}`)
         }
       } else {
         if (node.attributes.DEF) {
           const objectname = node.attributes.DEF
           if (x3dDefs.has(objectname)) {
-            console.log(
-              `WARNING: redefintion of ${objectname} has been ignored`
-            )
+            console.log(`WARNING: redefintion of ${objectname} has been ignored`)
           } else {
             x3dDefs.set(objectname, obj)
           }
@@ -339,11 +332,7 @@ const createX3DParser = (src, pxPmm) => {
   // start the parser
   parser.write(src).close()
 
-  return {
-    x3dObj,
-    x3dMaterials,
-    x3dTextures
-  }
+  // return the results
+  // console.log(JSON.stringify(x3dObj))
+  return { x3dObj, x3dMaterials, x3dTextures }
 }
-
-module.exports = createX3DParser

package/src/translate.js

@@ -1,19 +1,17 @@
-const translateDefinitions = require('./translateDefinitions')
+import { translateDefinitions } from './translateDefinitions.js'
+import { x3dTypes } from './objects.js'
+import { parse } from './parse.js'
 
-const { x3dTypes } = require('./objects')
-const parse = require('./parse')
-
-const translate = (options, src) => {
+export const translate = (options, src) => {
   const defaults = {
-    pxPmm: require('./constants').pxPmm
   }
   options = Object.assign({}, defaults, options)
-  const { version, pxPmm, addMetaData, filename } = options
+  const { version, addMetaData, filename } = options
 
   options && options.statusCallback && options.statusCallback({ progress: 0 })
 
   // parse the X3D source
-  const { x3dObj, x3dMaterials, x3dTextures } = parse(src, pxPmm)
+  const { x3dObj, x3dMaterials, x3dTextures } = parse(src)
 
   // convert the internal objects to JSCAD code
   let code = addMetaData
@@ -58,22 +56,9 @@ const codify = (x3d, data) => {
 // Units : ${length.name} (${length.factor})
 // Angles : ${angle.name} (${angle.factor})
 
-const {booleans, extrusions, geometries, maths, primitives, transforms, utils} = require('@jscad/modeling')
-const { colorize } =  require('@jscad/modeling').colors
-
-const applyTransform = (matrix, ...objects) => {
-  objects = utils.flatten(objects)
-  if (objects.length === 0) return objects
-
-  return objects.map((object) => {
-    const color = object.color
-    object = transforms.transform(matrix, object)
-    if (color) object.color = color
-    return object
-  })
-}
+import * from '@jscad/modeling'
 
-const main = () => {
+export const main = () => {
   let options = {}
   let objects = []
 `
@@ -87,9 +72,5 @@ const main = () => {
 
   code += translateDefinitions({}, objects)
 
-  code += 'module.exports = {main}\n'
-
   return code
 }
-
-module.exports = translate

package/src/translateDefinitions.js

@@ -1,8 +1,8 @@
-const createTransform = require('./createTransform')
+import { createTransform } from './createTransform.js'
 
-const { x3dTypes } = require('./objects')
+import { x3dTypes } from './objects.js'
 
-const translateShape = require('./translateShape')
+import { translateShape } from './translateShape.js'
 
 // horrific order of transforms... see http://edutechwiki.unige.ch/en/X3D_grouping_and_transforms
 const translateTransform = (options, object) => {
@@ -23,7 +23,7 @@ const createObjects${object.id} = (options) => {
   // apply the transforms if any
   code += `
   const matrix = [${matrix}]
-  return applyTransform(matrix, objects)
+  return transform(matrix, objects)
 }
 `
 
@@ -81,6 +81,4 @@ const translateDefinition = (options, object) => {
 }
 
 // convert the given X3D objects into a series of JSCAD function definitions
-const translateDefinitions = (options, objects) => objects.reduce((code, object, index) => code += translateDefinition(options, object), '')
-
-module.exports = translateDefinitions
+export const translateDefinitions = (options, objects) => objects.reduce((code, object, index) => code += translateDefinition(options, object), '')

package/src/translateHelpers.js

@@ -1,8 +1,8 @@
-const { x3dTypes } = require('./objects')
+import { x3dTypes } from './objects.js'
 
-const findNode = (x3dtype, objects) => objects.find((object) => object.definition === x3dtype)
+export const findNode = (x3dtype, objects) => objects.find((object) => object.definition === x3dtype)
 
-const findColor = (objects, options) => {
+export const findColor = (objects, options) => {
   const appearance = findNode(x3dTypes.APPEARANCE, objects)
   let material
   if (appearance) {
@@ -19,9 +19,9 @@ const findColor = (objects, options) => {
   return null
 }
 
-const pointToString = (point) => `[${point}]`
+export const pointToString = (point) => `[${point}]`
 
-const pointsToString = (triangle) => {
+export const pointsToString = (triangle) => {
   const strings = triangle.map((point) => pointToString(point))
   return `[
     ${strings.join(',\n    ')}
@@ -66,7 +66,7 @@ const createColorsFromFaceColors = (colorIndex, faceColors) => {
 }
 
 // create a list of colors from the given shape and color objects
-const createColors = (shape, color) => {
+export const createColors = (shape, color) => {
   if (!color) return null
   if (!Array.isArray(shape.colorIndex)) return null
 
@@ -78,13 +78,3 @@ const createColors = (shape, color) => {
   }
   return colors
 }
-
-module.exports = {
-  findNode,
-  findColor,
-
-  createColors,
-
-  pointToString,
-  pointsToString
-}

package/src/translateLine.js

@@ -1,8 +1,8 @@
-const { pointsToString } = require('./translateHelpers')
+import { pointsToString } from './translateHelpers.js'
 
-const { convertLine } = require('./instantiateLine')
+import { convertLine } from './instantiateLine.js'
 
-const translateLine = (options, objects) => {
+export const translateLine = (options, objects) => {
   const components = convertLine(options, objects)
   if (components) {
     const { pointsSet, colors } = components
@@ -24,5 +24,3 @@ const translateLine = (options, objects) => {
   }
   return null
 }
-
-module.exports = translateLine

package/src/translateMesh.js

@@ -1,10 +1,10 @@
-const { pointsToString } = require('./translateHelpers')
+import { pointsToString } from './translateHelpers.js'
 
-const { convertMesh } = require('./instantiateMesh')
+import { convertMesh } from './instantiateMesh.js'
 
 const translateToPolyhedron = (type, points, faces, colors, orientation) => {
   const colorsCode = Array.isArray(colors) ? pointsToString(colors) : 'null'
-  const primitive = 'primitives.polyhedron({points, faces, colors, orientation})'
+  const primitive = 'polyhedron({points, faces, colors, orientation})'
   const code = `
   // 3D ${type} set: ${points.length} points, ${faces.length} faces
   const points = ${pointsToString(points)}
@@ -19,7 +19,7 @@ const translateToPolyhedron = (type, points, faces, colors, orientation) => {
  * Translate the given objects into mesh (polyhedron).
  * @return { primitive, code }
  */
-const translateMesh = (options, objects) => {
+export const translateMesh = (options, objects) => {
   const components = convertMesh(options, objects)
   if (components) {
     const { type, points, faces, colors, orientation } = components
@@ -27,5 +27,3 @@ const translateMesh = (options, objects) => {
   }
   return null
 }
-
-module.exports = translateMesh