@jscad/x3d-deserializer 2.2.10 → 3.0.1-alpha.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +13 -84
- package/LICENSE +1 -1
- package/README.md +3 -1
- package/dist/jscad-x3d-deserializer.es.js +37 -0
- package/dist/jscad-x3d-deserializer.min.js +37 -0
- package/package.json +22 -10
- package/rollup.config.js +29 -0
- package/src/constants.js +1 -5
- package/src/createTransform.js +11 -13
- package/src/extrudeX3D.js +5 -14
- package/src/index.js +9 -16
- package/src/instantiate.js +6 -10
- package/src/instantiateDefinitions.js +10 -12
- package/src/instantiateLine.js +11 -16
- package/src/instantiateMesh.js +6 -11
- package/src/instantiatePrimitive.js +37 -26
- package/src/objects.js +40 -85
- package/src/parse.js +19 -30
- package/src/translate.js +8 -27
- package/src/translateDefinitions.js +5 -7
- package/src/translateHelpers.js +6 -16
- package/src/translateLine.js +3 -5
- package/src/translateMesh.js +4 -6
- package/src/translateShape.js +23 -27
- package/tests/createTransform.test.js +2 -2
- package/tests/instantiate.test.js +74 -75
- package/tests/translate.test.js +41 -37
package/src/translateShape.js
CHANGED
|
@@ -1,16 +1,14 @@
|
|
|
1
|
-
|
|
1
|
+
import { geom3, poly3 } from '@jscad/modeling'
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
import { extrudeX3D } from './extrudeX3D.js'
|
|
4
4
|
|
|
5
|
-
|
|
5
|
+
import { x3dTypes } from './objects.js'
|
|
6
|
+
import { findNode, findColor, pointsToString } from './translateHelpers.js'
|
|
6
7
|
|
|
7
|
-
|
|
8
|
-
|
|
8
|
+
import { translateLine } from './translateLine.js'
|
|
9
|
+
import { translateMesh } from './translateMesh.js'
|
|
9
10
|
|
|
10
|
-
const
|
|
11
|
-
const translateMesh = require('./translateMesh')
|
|
12
|
-
|
|
13
|
-
const translateShape = (options, object) => {
|
|
11
|
+
export const translateShape = (options, object) => {
|
|
14
12
|
let code = `
|
|
15
13
|
// shape
|
|
16
14
|
const createObjects${object.id} = (options) => {
|
|
@@ -27,23 +25,23 @@ const createObjects${object.id} = (options) => {
|
|
|
27
25
|
// 3D geometries
|
|
28
26
|
let shape = findNode(x3dTypes.BOX, objects)
|
|
29
27
|
if (shape) {
|
|
30
|
-
primitive = `
|
|
28
|
+
primitive = `cuboid({size: [${shape.size}]})`
|
|
31
29
|
} else {
|
|
32
30
|
shape = findNode(x3dTypes.CONE, objects)
|
|
33
31
|
if (shape) {
|
|
34
|
-
code += ` const shape =
|
|
32
|
+
code += ` const shape = rotateX(-Math.PI/2, cylinderElliptic({startRadius: [${shape.bottomRadius},${shape.bottomRadius}], height: ${shape.height}, segments: ${shape.subdivision}, endRadius: [${shape.topRadius}, ${shape.topRadius}]}))
|
|
35
33
|
`
|
|
36
34
|
primitive = 'shape'
|
|
37
35
|
} else {
|
|
38
36
|
shape = findNode(x3dTypes.CYLINDER, objects)
|
|
39
37
|
if (shape) {
|
|
40
|
-
code += ` const shape =
|
|
38
|
+
code += ` const shape = rotateX(-Math.PI/2, cylinder({radius: ${shape.radius}, height: ${shape.height}, segments: ${shape.subdivision}}))
|
|
41
39
|
`
|
|
42
40
|
primitive = 'shape'
|
|
43
41
|
} else {
|
|
44
42
|
shape = findNode(x3dTypes.SPHERE, objects)
|
|
45
43
|
if (shape) {
|
|
46
|
-
primitive = `
|
|
44
|
+
primitive = `sphere({radius: ${shape.radius}, segments: ${shape.subdivision}})`
|
|
47
45
|
} else {
|
|
48
46
|
shape = findNode(x3dTypes.EXTRUSION, objects)
|
|
49
47
|
if (shape) {
|
|
@@ -51,12 +49,12 @@ const createObjects${object.id} = (options) => {
|
|
|
51
49
|
const geometry = extrudeX3D(shape)
|
|
52
50
|
// convert the 3D geometry into a call to polyhedron()
|
|
53
51
|
const polygons = geom3.toPolygons(geometry)
|
|
54
|
-
const polysAsStrings = polygons.map((polygon) => pointsToString(poly3.
|
|
52
|
+
const polysAsStrings = polygons.map((polygon) => pointsToString(poly3.toVertices(polygon)))
|
|
55
53
|
code += ` const polygons = [
|
|
56
54
|
${polysAsStrings.join(',\n ')}
|
|
57
55
|
]
|
|
58
56
|
`
|
|
59
|
-
primitive = '
|
|
57
|
+
primitive = 'geom3.fromPoints(polygons)'
|
|
60
58
|
}
|
|
61
59
|
}
|
|
62
60
|
}
|
|
@@ -67,41 +65,41 @@ const createObjects${object.id} = (options) => {
|
|
|
67
65
|
// 2D geometries
|
|
68
66
|
shape = findNode(x3dTypes.ARC2D, objects)
|
|
69
67
|
if (shape) {
|
|
70
|
-
primitive = `
|
|
68
|
+
primitive = `arc({radius: ${shape.radius}, startAngle: ${shape.startAngle}, endAngle: ${shape.endAngle}, segments: ${shape.subdivision}})`
|
|
71
69
|
} else {
|
|
72
70
|
shape = findNode(x3dTypes.ARCCLOSE2D, objects)
|
|
73
71
|
if (shape) {
|
|
74
72
|
if (shape.closureType === 'PIE') {
|
|
75
|
-
primitive = `
|
|
73
|
+
primitive = `circle({radius: ${shape.radius}, startAngle: ${shape.startAngle}, endAngle: ${shape.endAngle}, segments: ${shape.subdivision}})`
|
|
76
74
|
} else {
|
|
77
|
-
primitive = `
|
|
75
|
+
primitive = `geom2.create([path2.toPoints(path2.close(arc({radius: ${shape.radius}, startAngle: ${shape.startAngle}, endAngle: ${shape.endAngle}, segments: ${shape.subdivision}})))])`
|
|
78
76
|
}
|
|
79
77
|
} else {
|
|
80
78
|
shape = findNode(x3dTypes.CIRCLE2D, objects)
|
|
81
79
|
if (shape) {
|
|
82
80
|
// NOTE: X3D circles are really closed arcs (lines)
|
|
83
|
-
primitive = `
|
|
81
|
+
primitive = `arc({radius: ${shape.radius}, segments: ${shape.subdivision}})`
|
|
84
82
|
} else {
|
|
85
83
|
shape = findNode(x3dTypes.DISK2D, objects)
|
|
86
84
|
if (shape) {
|
|
87
85
|
if (shape.innerRadius === shape.outerRadius) {
|
|
88
|
-
primitive = `
|
|
86
|
+
primitive = `arc({radius: ${shape.outerRadius}, segments: ${shape.subdivision}})`
|
|
89
87
|
} else {
|
|
90
88
|
if (shape.innerRadius === 0) {
|
|
91
|
-
primitive = `
|
|
89
|
+
primitive = `circle({radius: ${shape.outerRadius}, segments: ${shape.subdivision}})`
|
|
92
90
|
} else {
|
|
93
|
-
primitive = `
|
|
91
|
+
primitive = `subtract(circle({radius: ${shape.outerRadius}, segments: ${shape.subdivision}}), primitives.circle({radius: ${shape.innerRadius}, segments: ${shape.subdivision}}))`
|
|
94
92
|
}
|
|
95
93
|
}
|
|
96
94
|
} else {
|
|
97
95
|
shape = findNode(x3dTypes.POLYLINE2D, objects)
|
|
98
96
|
if (shape) {
|
|
99
97
|
const lineSegments = shape.lineSegments.join('], [')
|
|
100
|
-
primitive = `
|
|
98
|
+
primitive = `line([[${lineSegments}]])`
|
|
101
99
|
} else {
|
|
102
100
|
shape = findNode(x3dTypes.RECTANGLE2D, objects)
|
|
103
101
|
if (shape) {
|
|
104
|
-
primitive = `
|
|
102
|
+
primitive = `rectangle({size: [${shape.size}]})`
|
|
105
103
|
} else {
|
|
106
104
|
shape = findNode(x3dTypes.TRIANGLESET2D, objects)
|
|
107
105
|
if (shape) {
|
|
@@ -112,7 +110,7 @@ const createObjects${object.id} = (options) => {
|
|
|
112
110
|
const vertices = ${pointsToString(shape.vertices)}
|
|
113
111
|
const triangles = []
|
|
114
112
|
for (let i = 0; i < ${numfaces}; i = i + 3) {
|
|
115
|
-
triangles.push(
|
|
113
|
+
triangles.push(geom2.create([[vertices[i], vertices[i + 1], vertices[i + 2]]]))
|
|
116
114
|
}
|
|
117
115
|
`
|
|
118
116
|
primitive = 'triangles'
|
|
@@ -151,5 +149,3 @@ const createObjects${object.id} = (options) => {
|
|
|
151
149
|
`
|
|
152
150
|
return code
|
|
153
151
|
}
|
|
154
|
-
|
|
155
|
-
module.exports = translateShape
|
|
@@ -1,167 +1,166 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
1
|
+
import fs from 'fs'
|
|
2
|
+
import path from 'path'
|
|
3
3
|
|
|
4
|
-
|
|
4
|
+
import test from 'ava'
|
|
5
5
|
|
|
6
|
-
|
|
6
|
+
import { geom2, geom3, path2 } from '@jscad/modeling'
|
|
7
7
|
|
|
8
|
-
|
|
8
|
+
import { deserialize } from '../src/index.js'
|
|
9
9
|
|
|
10
|
-
// const samplesPath = path.dirname(require.resolve('@jscad/sample-files/package.json'))
|
|
11
10
|
const samplesPath = path.dirname('tests/')
|
|
12
11
|
|
|
13
12
|
test('deserialize simple X3D to JSCAD geometry', (t) => {
|
|
14
|
-
const observed =
|
|
13
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, example01)
|
|
15
14
|
t.true(Array.isArray(observed))
|
|
16
15
|
t.is(observed.length, 2)
|
|
17
|
-
t.true(
|
|
18
|
-
t.true(
|
|
16
|
+
t.true(geom3.isA(observed[0]))
|
|
17
|
+
t.true(geom3.isA(observed[1]))
|
|
19
18
|
})
|
|
20
19
|
|
|
21
20
|
test('deserialize X3D 2D components to JSCAD geometry', (t) => {
|
|
22
21
|
const inputPath = path.resolve(samplesPath, 'tests/Geometry2dComponents.x3d')
|
|
23
22
|
const inputFile = fs.readFileSync(inputPath)
|
|
24
23
|
|
|
25
|
-
const observed =
|
|
24
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
26
25
|
t.true(Array.isArray(observed))
|
|
27
26
|
t.is(observed.length, 11)
|
|
28
|
-
t.true(
|
|
29
|
-
t.true(
|
|
30
|
-
t.true(
|
|
31
|
-
t.true(
|
|
32
|
-
t.true(
|
|
33
|
-
t.true(
|
|
34
|
-
t.true(
|
|
35
|
-
t.true(
|
|
36
|
-
t.true(
|
|
37
|
-
t.true(
|
|
38
|
-
t.true(
|
|
27
|
+
t.true(geom2.isA(observed[0]))
|
|
28
|
+
t.true(path2.isA(observed[1]))
|
|
29
|
+
t.true(geom2.isA(observed[2]))
|
|
30
|
+
t.true(path2.isA(observed[3]))
|
|
31
|
+
t.true(geom2.isA(observed[4]))
|
|
32
|
+
t.true(geom2.isA(observed[5]))
|
|
33
|
+
t.true(geom2.isA(observed[6]))
|
|
34
|
+
t.true(path2.isA(observed[7]))
|
|
35
|
+
t.true(geom2.isA(observed[8]))
|
|
36
|
+
t.true(geom2.isA(observed[9]))
|
|
37
|
+
t.true(geom2.isA(observed[10]))
|
|
39
38
|
})
|
|
40
39
|
|
|
41
40
|
test('deserialize X3D 3D components to JSCAD geometry', (t) => {
|
|
42
41
|
const inputPath = path.resolve(samplesPath, 'tests/Geometry3dComponents.x3d')
|
|
43
42
|
const inputFile = fs.readFileSync(inputPath)
|
|
44
43
|
|
|
45
|
-
const observed =
|
|
44
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
46
45
|
t.true(Array.isArray(observed))
|
|
47
46
|
t.is(observed.length, 5)
|
|
48
|
-
t.true(
|
|
49
|
-
t.true(
|
|
50
|
-
t.true(
|
|
51
|
-
t.true(
|
|
52
|
-
t.true(
|
|
47
|
+
t.true(geom3.isA(observed[0]))
|
|
48
|
+
t.true(geom3.isA(observed[1]))
|
|
49
|
+
t.true(geom3.isA(observed[2]))
|
|
50
|
+
t.true(geom3.isA(observed[3]))
|
|
51
|
+
t.true(geom3.isA(observed[4]))
|
|
53
52
|
})
|
|
54
53
|
|
|
55
54
|
test('deserialize X3D line sets to JSCAD geometry', (t) => {
|
|
56
55
|
const inputPath = path.resolve(samplesPath, 'tests/LineSets.x3d')
|
|
57
56
|
const inputFile = fs.readFileSync(inputPath)
|
|
58
57
|
|
|
59
|
-
const observed =
|
|
58
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
60
59
|
t.true(Array.isArray(observed))
|
|
61
60
|
t.is(observed.length, 32)
|
|
62
|
-
t.true(
|
|
63
|
-
t.true(
|
|
64
|
-
t.true(
|
|
65
|
-
t.true(
|
|
66
|
-
t.true(
|
|
61
|
+
t.true(path2.isA(observed[0]))
|
|
62
|
+
t.true(path2.isA(observed[8]))
|
|
63
|
+
t.true(path2.isA(observed[16]))
|
|
64
|
+
t.true(path2.isA(observed[24]))
|
|
65
|
+
t.true(path2.isA(observed[31]))
|
|
67
66
|
})
|
|
68
67
|
|
|
69
68
|
test('deserialize X3D elevation grids to JSCAD geometry', (t) => {
|
|
70
69
|
const inputPath = path.resolve(samplesPath, 'tests/ElevationGrids.x3d')
|
|
71
70
|
const inputFile = fs.readFileSync(inputPath)
|
|
72
71
|
|
|
73
|
-
const observed =
|
|
72
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
74
73
|
t.true(Array.isArray(observed))
|
|
75
74
|
t.is(observed.length, 4)
|
|
76
|
-
t.true(
|
|
77
|
-
t.true(
|
|
78
|
-
t.true(
|
|
79
|
-
t.true(
|
|
75
|
+
t.true(geom3.isA(observed[0]))
|
|
76
|
+
t.true(geom3.isA(observed[1]))
|
|
77
|
+
t.true(geom3.isA(observed[2]))
|
|
78
|
+
t.true(geom3.isA(observed[3]))
|
|
80
79
|
})
|
|
81
80
|
|
|
82
81
|
test('deserialize X3D 3D triangle sets to JSCAD geometry', (t) => {
|
|
83
82
|
const inputPath = path.resolve(samplesPath, 'tests/TriangleSets.x3d')
|
|
84
83
|
const inputFile = fs.readFileSync(inputPath)
|
|
85
84
|
|
|
86
|
-
const observed =
|
|
85
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
87
86
|
t.true(Array.isArray(observed))
|
|
88
87
|
t.is(observed.length, 4)
|
|
89
|
-
t.true(
|
|
90
|
-
t.true(
|
|
91
|
-
t.true(
|
|
92
|
-
t.true(
|
|
88
|
+
t.true(geom3.isA(observed[0]))
|
|
89
|
+
t.true(geom3.isA(observed[1]))
|
|
90
|
+
t.true(geom3.isA(observed[2]))
|
|
91
|
+
t.true(geom3.isA(observed[3]))
|
|
93
92
|
})
|
|
94
93
|
|
|
95
94
|
test('deserialize X3D 3D triangle sets with comma delimiters to JSCAD geometry', (t) => {
|
|
96
95
|
const inputPath = path.resolve(samplesPath, 'tests/TriangleSets_CommaMF.x3d')
|
|
97
96
|
const inputFile = fs.readFileSync(inputPath)
|
|
98
97
|
|
|
99
|
-
const observed =
|
|
98
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
100
99
|
t.true(Array.isArray(observed))
|
|
101
100
|
t.is(observed.length, 4)
|
|
102
|
-
t.true(
|
|
103
|
-
t.true(
|
|
104
|
-
t.true(
|
|
105
|
-
t.true(
|
|
101
|
+
t.true(geom3.isA(observed[0]))
|
|
102
|
+
t.true(geom3.isA(observed[1]))
|
|
103
|
+
t.true(geom3.isA(observed[2]))
|
|
104
|
+
t.true(geom3.isA(observed[3]))
|
|
106
105
|
})
|
|
107
106
|
|
|
108
107
|
test('deserialize X3D 3D transforms to JSCAD geometry', (t) => {
|
|
109
108
|
const inputPath = path.resolve(samplesPath, 'tests/Transforms.x3d')
|
|
110
109
|
const inputFile = fs.readFileSync(inputPath)
|
|
111
110
|
|
|
112
|
-
const observed =
|
|
111
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
113
112
|
t.true(Array.isArray(observed))
|
|
114
113
|
t.is(observed.length, 4)
|
|
115
|
-
t.true(
|
|
116
|
-
t.true(
|
|
117
|
-
t.true(
|
|
118
|
-
t.true(
|
|
114
|
+
t.true(geom3.isA(observed[0]))
|
|
115
|
+
t.true(geom3.isA(observed[1]))
|
|
116
|
+
t.true(geom3.isA(observed[2]))
|
|
117
|
+
t.true(geom3.isA(observed[3]))
|
|
119
118
|
})
|
|
120
119
|
|
|
121
120
|
test('deserialize X3D 3D indexed triangle sets to JSCAD geometry', (t) => {
|
|
122
121
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets.x3d')
|
|
123
122
|
const inputFile = fs.readFileSync(inputPath)
|
|
124
123
|
|
|
125
|
-
const observed =
|
|
124
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
126
125
|
t.true(Array.isArray(observed))
|
|
127
126
|
t.is(observed.length, 6)
|
|
128
|
-
t.true(
|
|
129
|
-
t.true(
|
|
130
|
-
t.true(
|
|
131
|
-
t.true(
|
|
132
|
-
t.true(
|
|
133
|
-
t.true(
|
|
127
|
+
t.true(geom3.isA(observed[0]))
|
|
128
|
+
t.true(geom3.isA(observed[1]))
|
|
129
|
+
t.true(geom3.isA(observed[2]))
|
|
130
|
+
t.true(geom3.isA(observed[3]))
|
|
131
|
+
t.true(geom3.isA(observed[4]))
|
|
132
|
+
t.true(geom3.isA(observed[5]))
|
|
134
133
|
})
|
|
135
134
|
|
|
136
135
|
test('deserialize X3D 3D indexed triangle sets with comma delimiters to JSCAD geometry', (t) => {
|
|
137
136
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets_CommaMF.x3d')
|
|
138
137
|
const inputFile = fs.readFileSync(inputPath)
|
|
139
138
|
|
|
140
|
-
const observed =
|
|
139
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
141
140
|
t.true(Array.isArray(observed))
|
|
142
141
|
t.is(observed.length, 6)
|
|
143
|
-
t.true(
|
|
144
|
-
t.true(
|
|
145
|
-
t.true(
|
|
146
|
-
t.true(
|
|
147
|
-
t.true(
|
|
148
|
-
t.true(
|
|
142
|
+
t.true(geom3.isA(observed[0]))
|
|
143
|
+
t.true(geom3.isA(observed[1]))
|
|
144
|
+
t.true(geom3.isA(observed[2]))
|
|
145
|
+
t.true(geom3.isA(observed[3]))
|
|
146
|
+
t.true(geom3.isA(observed[4]))
|
|
147
|
+
t.true(geom3.isA(observed[5]))
|
|
149
148
|
})
|
|
150
149
|
|
|
151
150
|
test('deserialize X3D 3D groups to JSCAD geometry', (t) => {
|
|
152
151
|
const inputPath = path.resolve(samplesPath, 'tests/Groups.x3d')
|
|
153
152
|
const inputFile = fs.readFileSync(inputPath)
|
|
154
153
|
|
|
155
|
-
const observed =
|
|
154
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
156
155
|
t.true(Array.isArray(observed))
|
|
157
156
|
t.is(observed.length, 7)
|
|
158
|
-
t.true(
|
|
159
|
-
t.true(
|
|
160
|
-
t.true(
|
|
161
|
-
t.true(
|
|
162
|
-
t.true(
|
|
163
|
-
t.true(
|
|
164
|
-
t.true(
|
|
157
|
+
t.true(geom3.isA(observed[0]))
|
|
158
|
+
t.true(geom3.isA(observed[1]))
|
|
159
|
+
t.true(geom3.isA(observed[2]))
|
|
160
|
+
t.true(geom3.isA(observed[3]))
|
|
161
|
+
t.true(geom3.isA(observed[4]))
|
|
162
|
+
t.true(geom3.isA(observed[5]))
|
|
163
|
+
t.true(geom3.isA(observed[6]))
|
|
165
164
|
})
|
|
166
165
|
|
|
167
166
|
// EXAMPLES FOR SIMPLE TESTING
|
package/tests/translate.test.js
CHANGED
|
@@ -1,11 +1,10 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
1
|
+
import fs from 'fs'
|
|
2
|
+
import path from 'path'
|
|
3
3
|
|
|
4
|
-
|
|
4
|
+
import test from 'ava'
|
|
5
5
|
|
|
6
|
-
|
|
6
|
+
import { deserialize } from '../src/index.js'
|
|
7
7
|
|
|
8
|
-
// const samplesPath = path.dirname(require.resolve('@jscad/sample-files/package.json'))
|
|
9
8
|
const samplesPath = path.dirname('tests/')
|
|
10
9
|
|
|
11
10
|
const countOf = (search, string) => {
|
|
@@ -19,125 +18,130 @@ const countOf = (search, string) => {
|
|
|
19
18
|
}
|
|
20
19
|
|
|
21
20
|
test('deserialize simple X3D to JSCAD script', (t) => {
|
|
22
|
-
const observed =
|
|
21
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, example01)
|
|
23
22
|
t.is(countOf('createObjects', observed), 10)
|
|
24
|
-
t.is(countOf('
|
|
25
|
-
t.is(countOf('
|
|
23
|
+
t.is(countOf('sphere', observed), 1)
|
|
24
|
+
t.is(countOf('cuboid', observed), 1)
|
|
25
|
+
t.is(countOf('transform', observed), 6)
|
|
26
26
|
})
|
|
27
27
|
|
|
28
28
|
test('deserialize X3D 2D components to JSCAD script', (t) => {
|
|
29
29
|
const inputPath = path.resolve(samplesPath, 'tests/Geometry2dComponents.x3d')
|
|
30
30
|
const inputFile = fs.readFileSync(inputPath)
|
|
31
31
|
|
|
32
|
-
const observed =
|
|
32
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
33
33
|
t.is(countOf('createObjects', observed), 46)
|
|
34
|
-
t.is(countOf('
|
|
35
|
-
t.is(countOf('
|
|
34
|
+
t.is(countOf('arc', observed), 2)
|
|
35
|
+
t.is(countOf('circle', observed), 3)
|
|
36
|
+
t.is(countOf('rectangle', observed), 3)
|
|
37
|
+
t.is(countOf('line', observed), 1)
|
|
38
|
+
t.is(countOf('transform', observed), 22)
|
|
36
39
|
})
|
|
37
40
|
|
|
38
41
|
test('deserialize X3D 3D components to JSCAD script', (t) => {
|
|
39
42
|
const inputPath = path.resolve(samplesPath, 'tests/Geometry3dComponents.x3d')
|
|
40
43
|
const inputFile = fs.readFileSync(inputPath)
|
|
41
44
|
|
|
42
|
-
const observed =
|
|
45
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
43
46
|
t.is(countOf('createObjects', observed), 20)
|
|
44
|
-
t.is(countOf('
|
|
47
|
+
t.is(countOf('cylinder', observed), 2)
|
|
48
|
+
t.is(countOf('sphere', observed), 1)
|
|
45
49
|
t.is(countOf('geom3.fromPoints', observed), 1)
|
|
46
|
-
t.is(countOf('
|
|
50
|
+
t.is(countOf('transform', observed), 10)
|
|
47
51
|
})
|
|
48
52
|
|
|
49
53
|
test('deserialize X3D line sets to JSCAD script', (t) => {
|
|
50
54
|
const inputPath = path.resolve(samplesPath, 'tests/LineSets.x3d')
|
|
51
55
|
const inputFile = fs.readFileSync(inputPath)
|
|
52
56
|
|
|
53
|
-
const observed =
|
|
57
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
54
58
|
t.is(countOf('createObjects', observed), 12)
|
|
55
|
-
t.is(countOf('
|
|
59
|
+
t.is(countOf('line(', observed), 32)
|
|
56
60
|
})
|
|
57
61
|
|
|
58
62
|
test('deserialize X3D elevation grids to JSCAD script', (t) => {
|
|
59
63
|
const inputPath = path.resolve(samplesPath, 'tests/ElevationGrids.x3d')
|
|
60
64
|
const inputFile = fs.readFileSync(inputPath)
|
|
61
65
|
|
|
62
|
-
const observed =
|
|
66
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
63
67
|
t.is(countOf('createObjects', observed), 8)
|
|
64
68
|
t.is(countOf('points', observed), 12)
|
|
65
69
|
t.is(countOf('faces', observed), 12)
|
|
66
70
|
t.is(countOf('orientation', observed), 8)
|
|
67
|
-
t.is(countOf('
|
|
68
|
-
t.is(countOf('
|
|
71
|
+
t.is(countOf('polyhedron', observed), 4)
|
|
72
|
+
t.is(countOf('transform', observed), 0)
|
|
69
73
|
})
|
|
70
74
|
|
|
71
75
|
test('deserialize X3D 3D triangle sets to JSCAD script', (t) => {
|
|
72
76
|
const inputPath = path.resolve(samplesPath, 'tests/TriangleSets.x3d')
|
|
73
77
|
const inputFile = fs.readFileSync(inputPath)
|
|
74
78
|
|
|
75
|
-
const observed =
|
|
79
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
76
80
|
t.is(countOf('createObjects', observed), 18)
|
|
77
81
|
t.is(countOf('points', observed), 12)
|
|
78
82
|
t.is(countOf('faces', observed), 12)
|
|
79
83
|
t.is(countOf('orientation', observed), 8)
|
|
80
|
-
t.is(countOf('
|
|
81
|
-
t.is(countOf('
|
|
84
|
+
t.is(countOf('polyhedron', observed), 4)
|
|
85
|
+
t.is(countOf('transform', observed), 0)
|
|
82
86
|
})
|
|
83
87
|
|
|
84
88
|
test('deserialize X3D 3D triangle sets with comma delimiters to JSCAD script', (t) => {
|
|
85
89
|
const inputPath = path.resolve(samplesPath, 'tests/TriangleSets_CommaMF.x3d')
|
|
86
90
|
const inputFile = fs.readFileSync(inputPath)
|
|
87
91
|
|
|
88
|
-
const observed =
|
|
92
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
89
93
|
t.is(countOf('createObjects', observed), 18)
|
|
90
94
|
t.is(countOf('points', observed), 12)
|
|
91
95
|
t.is(countOf('faces', observed), 12)
|
|
92
96
|
t.is(countOf('orientation', observed), 8)
|
|
93
|
-
t.is(countOf('
|
|
94
|
-
t.is(countOf('applyTransform', observed), 1)
|
|
97
|
+
t.is(countOf('polyhedron', observed), 4)
|
|
95
98
|
})
|
|
96
99
|
|
|
97
100
|
test('deserialize X3D 3D transforms to JSCAD script', (t) => {
|
|
98
101
|
const inputPath = path.resolve(samplesPath, 'tests/Transforms.x3d')
|
|
99
102
|
const inputFile = fs.readFileSync(inputPath)
|
|
100
103
|
|
|
101
|
-
const observed =
|
|
104
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
102
105
|
t.is(countOf('createObjects', observed), 16)
|
|
103
|
-
t.is(countOf('
|
|
104
|
-
t.is(countOf('
|
|
106
|
+
t.is(countOf('cuboid', observed), 1)
|
|
107
|
+
t.is(countOf('cylinder', observed), 2)
|
|
108
|
+
t.is(countOf('transform', observed), 8)
|
|
105
109
|
})
|
|
106
110
|
|
|
107
111
|
test('deserialize X3D 3D indexed triangle sets to JSCAD script', (t) => {
|
|
108
112
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets.x3d')
|
|
109
113
|
const inputFile = fs.readFileSync(inputPath)
|
|
110
114
|
|
|
111
|
-
const observed =
|
|
115
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
112
116
|
t.is(countOf('createObjects', observed), 24)
|
|
113
117
|
t.is(countOf('points', observed), 18)
|
|
114
118
|
t.is(countOf('faces', observed), 20)
|
|
115
119
|
t.is(countOf('orientation', observed), 12)
|
|
116
|
-
t.is(countOf('
|
|
117
|
-
t.is(countOf('
|
|
120
|
+
t.is(countOf('polyhedron', observed), 6)
|
|
121
|
+
t.is(countOf('transform', observed), 0)
|
|
118
122
|
})
|
|
119
123
|
|
|
120
124
|
test('deserialize X3D 3D indexed triangle sets with comma delimiters to JSCAD script', (t) => {
|
|
121
125
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets_CommaMF.x3d')
|
|
122
126
|
const inputFile = fs.readFileSync(inputPath)
|
|
123
127
|
|
|
124
|
-
const observed =
|
|
128
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
125
129
|
t.is(countOf('createObjects', observed), 24)
|
|
126
130
|
t.is(countOf('points', observed), 18)
|
|
127
131
|
t.is(countOf('faces', observed), 20)
|
|
128
132
|
t.is(countOf('orientation', observed), 12)
|
|
129
|
-
t.is(countOf('
|
|
130
|
-
t.is(countOf('applyTransform', observed), 1)
|
|
133
|
+
t.is(countOf('polyhedron', observed), 6)
|
|
131
134
|
})
|
|
132
135
|
|
|
133
136
|
test('deserialize X3D 3D groups to JSCAD script', (t) => {
|
|
134
137
|
const inputPath = path.resolve(samplesPath, 'tests/Groups.x3d')
|
|
135
138
|
const inputFile = fs.readFileSync(inputPath)
|
|
136
139
|
|
|
137
|
-
const observed =
|
|
140
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
138
141
|
t.is(countOf('createObjects', observed), 20)
|
|
139
|
-
t.is(countOf('
|
|
140
|
-
t.is(countOf('
|
|
142
|
+
t.is(countOf('cuboid', observed), 1)
|
|
143
|
+
t.is(countOf('cylinder', observed), 2)
|
|
144
|
+
t.is(countOf('transform', observed), 10)
|
|
141
145
|
})
|
|
142
146
|
|
|
143
147
|
// EXAMPLES FOR SIMPLE TESTING
|