@jscad/x3d-deserializer 2.2.4 → 3.0.0-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 +11 -39
- package/README.md +3 -1
- package/dist/jscad-x3d-deserializer.es.js +37 -0
- package/dist/jscad-x3d-deserializer.min.js +38 -0
- package/package.json +21 -9
- 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 +7 -15
- 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 +38 -83
- package/src/parse.js +7 -9
- 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 +62 -63
- package/tests/translate.test.js +37 -31
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,139 +1,138 @@
|
|
|
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 transforms to JSCAD geometry', (t) => {
|
|
96
95
|
const inputPath = path.resolve(samplesPath, 'tests/Transforms.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 indexed triangle sets to JSCAD geometry', (t) => {
|
|
109
108
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets.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, 6)
|
|
115
|
-
t.true(
|
|
116
|
-
t.true(
|
|
117
|
-
t.true(
|
|
118
|
-
t.true(
|
|
119
|
-
t.true(
|
|
120
|
-
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]))
|
|
118
|
+
t.true(geom3.isA(observed[4]))
|
|
119
|
+
t.true(geom3.isA(observed[5]))
|
|
121
120
|
})
|
|
122
121
|
|
|
123
122
|
test('deserialize X3D 3D groups to JSCAD geometry', (t) => {
|
|
124
123
|
const inputPath = path.resolve(samplesPath, 'tests/Groups.x3d')
|
|
125
124
|
const inputFile = fs.readFileSync(inputPath)
|
|
126
125
|
|
|
127
|
-
const observed =
|
|
126
|
+
const observed = deserialize({ output: 'geometry', addMetaData: false }, inputFile)
|
|
128
127
|
t.true(Array.isArray(observed))
|
|
129
128
|
t.is(observed.length, 7)
|
|
130
|
-
t.true(
|
|
131
|
-
t.true(
|
|
132
|
-
t.true(
|
|
133
|
-
t.true(
|
|
134
|
-
t.true(
|
|
135
|
-
t.true(
|
|
136
|
-
t.true(
|
|
129
|
+
t.true(geom3.isA(observed[0]))
|
|
130
|
+
t.true(geom3.isA(observed[1]))
|
|
131
|
+
t.true(geom3.isA(observed[2]))
|
|
132
|
+
t.true(geom3.isA(observed[3]))
|
|
133
|
+
t.true(geom3.isA(observed[4]))
|
|
134
|
+
t.true(geom3.isA(observed[5]))
|
|
135
|
+
t.true(geom3.isA(observed[6]))
|
|
137
136
|
})
|
|
138
137
|
|
|
139
138
|
// 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,99 +18,106 @@ 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 transforms to JSCAD script', (t) => {
|
|
85
89
|
const inputPath = path.resolve(samplesPath, 'tests/Transforms.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), 16)
|
|
90
|
-
t.is(countOf('
|
|
91
|
-
t.is(countOf('
|
|
94
|
+
t.is(countOf('cuboid', observed), 1)
|
|
95
|
+
t.is(countOf('cylinder', observed), 2)
|
|
96
|
+
t.is(countOf('transform', observed), 8)
|
|
92
97
|
})
|
|
93
98
|
|
|
94
99
|
test('deserialize X3D 3D indexed triangle sets to JSCAD script', (t) => {
|
|
95
100
|
const inputPath = path.resolve(samplesPath, 'tests/IndexedTriangleSets.x3d')
|
|
96
101
|
const inputFile = fs.readFileSync(inputPath)
|
|
97
102
|
|
|
98
|
-
const observed =
|
|
103
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
99
104
|
t.is(countOf('createObjects', observed), 24)
|
|
100
105
|
t.is(countOf('points', observed), 18)
|
|
101
106
|
t.is(countOf('faces', observed), 20)
|
|
102
107
|
t.is(countOf('orientation', observed), 12)
|
|
103
|
-
t.is(countOf('
|
|
104
|
-
t.is(countOf('
|
|
108
|
+
t.is(countOf('polyhedron', observed), 6)
|
|
109
|
+
t.is(countOf('transform', observed), 0)
|
|
105
110
|
})
|
|
106
111
|
|
|
107
112
|
test('deserialize X3D 3D groups to JSCAD script', (t) => {
|
|
108
113
|
const inputPath = path.resolve(samplesPath, 'tests/Groups.x3d')
|
|
109
114
|
const inputFile = fs.readFileSync(inputPath)
|
|
110
115
|
|
|
111
|
-
const observed =
|
|
116
|
+
const observed = deserialize({ output: 'script', addMetaData: false }, inputFile)
|
|
112
117
|
t.is(countOf('createObjects', observed), 20)
|
|
113
|
-
t.is(countOf('
|
|
114
|
-
t.is(countOf('
|
|
118
|
+
t.is(countOf('cuboid', observed), 1)
|
|
119
|
+
t.is(countOf('cylinder', observed), 2)
|
|
120
|
+
t.is(countOf('transform', observed), 10)
|
|
115
121
|
})
|
|
116
122
|
|
|
117
123
|
// EXAMPLES FOR SIMPLE TESTING
|